Java & CORBA

This section brings together Java and CORBA, two of the major object models used in distributed computing. Java provides mobile code that can run within a Web browser on any specific platform, while CORBA introduces an infrastructure which enables an application to invoke transparently operations on objects located anywhere on a network. By combining those two approaches, we will offer to Java applets the possibility to use services provided by object servers written in any language, not only in Java.

CORBA, on the one hand, provides Web developers with several important benefits.

• Rich distributed object infrastructure. Distributed applications requires more functionalities than simple method invocations. Therefore, the OMG has included in the CORBA 2.0 specifications a rich set of distributed object services and facilities, such as the Lifecycle Service, the Event Service, the Naming Service or the Trading Service. In particular, the two last ones offer essential services that everyone, either in possession of a phone set or in charge of distributed objects, inevitably needs: these are respectively the White Pages, provided by the Naming Service, and the Yellow Pages, provided by the Trading Service. Moreover, CORBA provides many other features of great help for the use of robust distributed applications like automatic server activation when the appropriate one is not already running, load balancing to distribute charge across multiple machines, and persistence for both object states and object references.
• Language independence. Since CORBA supports numerous language mappings for OMG's IDL, components of a system or objects of a distributed application can be implemented in various programming languages. According to the situation, this gives the developers the freedom to:
• choose the programming language they favor,
• choose the language that will be the most suitable for developing the specific component,
• reuse already existing objects, if they had previously been written in languages that support IDL mapping rules, for example C++, Ada or SmallTalk.

That last point is generally known as Legacy Integration.

• Location transparency. In contrast with URL-based and socket-based naming mechanism, CORBA provides location transparency: an object reference is independent of both the object physical location and a potentially change of this location. This means that object can be moved without breaking all the applications that use them.

On the other hand, Java offer four new features to CORBA programmers.

• Portability across platforms. Due to wide industry support, Java compilers and run-time systems are available for nearly any hardware platform and operating system. Therefore, applications, and most of all client applications, can be usable on any plaform without any porting effort.
• Code distribution. Since Java code can be deployed and managed centrally from the server, code distribution in large CORBA systems is simplified. Maintenance of large client/server applications doesn't require anymore systematic updates on the client side.
• Internet Programming. Java-enabled Web browsers are becoming the universal graphical user interface. Writing CORBA clients as Java applets enables a world-wide audience to CORBA systems and universal access to their CORBA objects and legacy applications.
• Object-oriented enhancements. Java provides a cleaner approach to object-oriented programming than other traditional languages like C++ or SmallTalk:
• fewer memory management responsibilities,
• no pointers,
• and a less confusing syntax,

but also

• built-in multithreading,
• automatic garbage collection,
• and exception handling.

These features are particularly useful for developing robust distributed Web applications that mix the simplicity of Java applets and the power of various server objects.