Surviving the economical climate as a consultant

These are hard times, but there are in my opinion some healthy rules one should remember to survive in this difficult economical climate. Those are only nine, not to be blaspheme...

1. Be prepared. It sounds obvious, but you need to know your stuff very well. For example, JEE is not about knowing many different application servers (I don't even understand what it means to "know an application server"), it is about "how to design that process so that I am in control of the distributed transactional context". Something like this. Filling your CV with buzzwords and acronyms can lead you to get interviewed by superficial recruiters, but then you are naked if you don't have concrete skills.
   
2. Be versatile. You have to be mentally prepared on how to deal with unforeseen environments, technologies and unknown situations. Be prepared to work abroad and to get a flight early on Monday mornings. This is quite usual for US consultants, but young consultants and consulting companies in Europe should start thinking at the whole Europe as a huge market. Exit your comfort zone.
   
3. Be consistent. Deliver quality and think on how to solve your customer's business needs, IT issues can't be your only priority. Do not think on how to consume hours and days, instead focus on delivering useful stuff. Be prepared to suggest fixed-price packages: if you really know your stuff you can make good estimations and take the risk, you cannot just move the deadline's responsibility into your customer's shoulders and throw out a timesheet each Friday, it is no more enough.
   
4. Improve your skills. Take time to revitalize some old skills and to learn something new. Buy books and study, but expecially experiment on your own.
   
5. Accept short terms activities. Learn to live in a world where things change daily, if you are flexible you will have more chances. Being squeamish about a five days assignment don't provide you with a good credit nowadays.
   
6. Do not undersell yourself. Flexibility doesn't mean you have to drastically reduce your consulting rates only because a couple of recruiters tell you to do so, it is easier to negotiate discounts before than to increase rates afterwards.
7. Be business-oriented. Knowing your IT stuff is no longer enough, try to understand and study basic economy, marketing and generally speaking how your customers make their money. Your salary or your consulting fees don't come from magic, there should be a sustainable business and usually has nothing to do with the latest Linux distribution or that cool scripting language that you are so eager to learn.
8. Learn foreign languages. I wish I studied another language in addition to English when I was at school. Decent English in IT is of course mandatory, French, German and Spanish can open a wide set of new opportunities. Of course you need to always remember point #1, you need to be technically prepared: a silly thing in seven different languages is still a silly thing.
9. Sell. Work is no more jumping into our head, it is necessary to go out and find it. Garden your network, market your skills and then be ready to sell them more often than usual, as assignments and contracts are getting shorter. Presentation skills, technical writing abilities and speech skills in front of an audience are the main sales tools of a freelance consultant, being the best hacker is no more enough.
   

By the way, I think most of these rules apply to both individuals and organizations. I see many consulting companies reacting to the crisis by just enforcing their usual behaviours and keep on providing exactly the same set of services of their competition. Differentiation is key.

Good luck, we need it anyway.

How to call a remote transactional Weblogic EJB from a Java client

My objective here is to show how to call a remote Weblogic stateless EJB from a Java client, then adding the ability to invoke multiple EJBs in a client-controlled transaction.

The code below is very simple and has been tested with BEA Weblogic Application Server 10.0 and developed with the Netbeans 6.1 IDE. The original requirement was to call Weblogic EJBs from Glassfish, using the Weblogic user transactions from the client code. Let's say there is the need to call several EJBs and to make it in a single unit of work, this is not usually a best practice, as client-controlled transactions are usually slower and lead to bad design. The best would be to expose a transactional service from Weblogic which wraps all the calls in one server-side unit of work, but it is not always feasible if we are not in control of the other side and this is also an example how to call a remote EJB from Java, if one removes the transactional code.

Anyway, let's have a look at our sample JEE 5 service (EJB 3), which is deployed in Weblogic:

package com.mt.ejb;

import javax.ejb.Stateless;

@Stateless(mappedName = "CalculatorBean")
public class CalculatorBean implements CalculatorRemote {

    public int add(int a, int b) {
        return a + b;
    }
}

Above is a trivial "hello world" EJB, implementing a Remote interface. The mappedName = "CalculatorBean" is a mandatory parameter for the @Stateless annotation if one wants the EJB to be remotely callable.

I deployed in Weblogic, Netbeans offers the ability to connect to a Weblogic server, even if the plugin has limited functionalities it gives me what I need and allows me to work from my favourite IDE and deploy from there.


Here comes the client code, which is more interesting:

package com.mt.client;

import com.mt.ejb.CalculatorRemote;
import java.util.Hashtable;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.transaction.UserTransaction;

public class WeblogicTest {

    private final Logger log = Logger.getLogger(WeblogicTest.class.getName());

    public WeblogicTest() {
    }

    public void callRemoteEJB() {
        InitialContext context = null;
        UserTransaction transaction = null;

        Hashtable env = new Hashtable();
        env.put(Context.INITIAL_CONTEXT_FACTORY, "weblogic.jndi.WLInitialContextFactory");
        env.put(Context.PROVIDER_URL, "t3://localhost:7001");
        env.put(Context.SECURITY_PRINCIPAL, "weblogic");
        env.put(Context.SECURITY_CREDENTIALS, "weblogic");

        try {
            context = new InitialContext(env);
            transaction = (UserTransaction) context.lookup("javax.transaction.UserTransaction");
            if (transaction != null) {
                log.info("in transaction context.");
                try {
                    CalculatorRemote calculator = (CalculatorRemote) context.lookup("CalculatorBean#com.mt.ejb.CalculatorRemote");
                    transaction.begin();
                    int result = calculator.add(3, 5);
                    transaction.commit();
                    log.info("add=" + result);
                } catch (Exception ex) {
                    ex.printStackTrace();
                    try {
                        transaction.rollback();
                    } catch (Exception ex1) {
                        log.log(Level.SEVERE, "Can't rollback transaction.", ex1);
                    }
                }
            } else {
                log.info("transaction context is null.");
            }
        } catch (NamingException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        WeblogicTest test = new WeblogicTest();
        test.callRemoteEJB();
    }
}

It is necessary to add the CalculatorBean EJB jar file and the wlclient.jar to build the above client code. The wlclient.jar can be usually found into folder \server\lib of our Weblogic server.


Let's comment the main code sections.

First, I populate the connection properties:

Hashtable env = new Hashtable();
env.put(Context.INITIAL_CONTEXT_FACTORY, "weblogic.jndi.WLInitialContextFactory");
env.put(Context.PROVIDER_URL, "t3://localhost:7001");
env.put(Context.SECURITY_PRINCIPAL, "weblogic");
env.put(Context.SECURITY_CREDENTIALS, "weblogic");

I look-up the initial context and get the UserTransaction from Weblogic's JTS:

context = new InitialContext(env);
transaction = (UserTransaction) context.lookup("javax.transaction.UserTransaction");

I lookup and call the remote EJB by enclosing the method invocation in transaction:

CalculatorRemote calculator = (CalculatorRemote) context.lookup("CalculatorBean#com.mt.ejb.CalculatorRemote");
transaction.begin();
int result = calculator.add(3, 5);
transaction.commit();

The lookup string "CalculatorBean#com.mt.ejb.CalculatorRemote" makes the trick, it is the Weblogic syntax to identify the Bean and its Remote interface.

Of course, in this trivial case there are not any transactions, but I wanted to keep the example very simple. If the EJB was transactional, the call made use of the transactional context, while in this case it is simply ignored.

Farewell SGI

The glorious SGI, after being close to bankruptcy and going for chapter 11, has been bought by Rackable for mere $25 millions plus the assurance to pay its debts. I learned 3D computer graphics and OpenGL programming in the late 90s on SGI's Indigo and Octane workstations, beautiful pieces of hardware and software but already feeling the price pressure coming from much cheaper Windows workstations. It is a piece of the Silicon Valley computing history which was hit by the post New Economy bubble crisis and has never really recovered from that point.
Farewell, SGI.