I've done work with all three of the major standards for distributed work - CORBA, COM and EJB. I much prefer EJB. For those of you that don't recognize the acronym, it stands for Enterprise JavaBeans, a specification from Sun Microsystems that describes how to construct server components for a Java-based server.

We can do Java server components for any of these standards (although COM is more trouble than it's worth), and can likewise do Java clients that can speak to servers of this type. The selection of the standard has a great deal to do with the overall environment in the company that's going to build a distributed system. If the company is a Microsoft shop, COM is almost a no-brainer. If there is a mix of computers - UNIX, Windows and Macintosh - COM is probably less of a choice, so it comes down to CORBA or EJB. The EJB specification was released a year ago (March 1998) and the first servers began to appear toward the end of the third quarter, so until recently the only choice was CORBA. And it may still need to be the choice, depending on the environment.

One of the greatest strengths of EJB is that it's an all-Java environment. The strength of that approach lies in the fact that by using a single language and programming paradigm, EJB allows for a much richer approach to data transfer and marshaling. No abstract IDL is required to create components; you simply write them in Java. To pass complex objects from one machine to another, you implement Serializable, which is trivial, since that interface has no methods.

That strength is also the biggest weakness of EJB. One of the biggest strengths of CORBA is the ability to integrate multiple languages. In many large companies Java is only one of several languages that will be used for development. Typically, a company uses C/C++, PowerBuilder, Visual Basic and sometimes COBOL. For companies that need to continue to use these languages, EJB offers only a limited amount of usefulness. If a company can commit itself to moving to Java as its main language, EJB is a good choice, as you can work around the other languages to a certain extent and rewrite as time permits. Otherwise CORBA is your best bet.

Whatever you choose, you're in for some interesting times. I guarantee you that developing distributed systems will make a perfectionist out of you. It has to. In earlier times, errant code could crash only one system at a time. Now, bad code in the middle tier has the capability of affecting thousands of people. It's also much more difficult to debug, as the number of possible problems increases dramatically due to the additional layers of communications and the ambiguities present in some of the specifications. If you want to make it work, you have to tighten up your overall code process. Nothing less than zero defects will work.

I hope you'll find information in this issue to aid you in the pursuit of that goal. Let me know - I have to start planning next year's version of this column.