|By JP Morgenthal
|November 1, 1998 12:00 AM EST
Currently hard at work, the Object Management Group (OMG) is preparing for a preproduction release of the CORBA 3.0 specification before year-end. Such a release will give CORBA ORB vendors an opportunity to implement new CORBA services and identify potential problems before the final release in the first half of 1999.
The preproduction release is essentially a test run of the specification, while the final specification will differ from the "P" release only in the changes necessary to correct problems.
A question arises about whether CORBA can continue to thrive in the face of all the emerging distributed computing technologies, such as Java Remote Method Invocation (RMI) and XML-based programming interfaces. The answer, unequivocally, is Yes. With the changes that will go into CORBA 3.0, not only will CORBA thrive, but it will finally be complete enough to support mainstream adoption and use by multiple levels of developers.
CORBA is primarily used by systems developers in the back office who have extensive knowledge of building distributed object applications. These developers are in high demand and are extremely expensive. But when it comes to integrating legacy COBOL applications with new C++ applications, CORBA rises to the top of the solution heap. That is, as long as a company can obtain and support the resources necessary to deliver that solution.
With 3.0, CORBA will achieve a new level of capabilities that will serve two groups: the hard-core distributed computing programmers and the less technical business programmer/analysts. Note that while CORBA 3.0 doesn't simplify distributed object computing, it does simplify the use of CORBA ORBs for the development of distributed object applications. Those building and deploying distributed applications must still understand the implications of networking, remote exception handling, object life cycles, multithreading and...the list goes on.
CORBA 2.2 and 2.3 Update CORBA IDL to Java language mapping - The OMG formal specification for mapping CORBA types to Java objects.
Before we can thoroughly dig into CORBA 3.0, we first have to look at the work
delivered today by OMG-CORBA 2.2 and 2.3. Some important changes and new features being added to CORBA will impact CORBA users and the capabilities of the future 3.0 release. CORBA 2.2, which is available now, incorporated the following specification into CORBA:
Portable ORB Adapter (POA) - This is an important initiative that will allow all future CORBA source code to be portable across ORB vendors. While CORBA will provide interoperability between ORBs, a server written for one ORB implementation is not necessarily portable to another. The POA provides a framework for managing object creation, policies and persistent identifiers, and a consistent service for objects that span multiple server lifetimes.
COM/CORBA Interworking Part B - This specification identifies the interoperability of Microsoft DCOM and CORBA.
CORBA 2.3 simply amends the work of 2.2 for errors and problems and adds support POA for IDL/Java. POA for IDL/Java states that any CORBA server developed using Java and the POA shall be binary-interoperable. That is, any CORBA/Java application can be loaded into a compliant JVM running any vendor's ORB that supports the POA for IDL/Java.
CORBA 3.0 Features
CORBA 3.0 will bring many new features to CORBA that will facilitate its adoption in the enterprise. As previously noted, CORBA, even at the 2.3 level, is complex to implement. Some have identified Microsoft's COM architecture as simpler in some regards. But besides their both having activate and deactivate binary modules, that statement is like comparing apples to oranges.
The features listed and discussed below will be added to CORBA in 3.0. Where possible (some specifications haven't even received submissions yet), we'll identify the benefits a feature will bring to the enterprise.
CORBA Component Model - Perhaps the most important and significant addition to CORBA, this model will specify a framework for the development of plug-and-play CORBA objects. It will encapsulate the creation, life cycle and events for a single object and allow clients to explore an object's capabilities, methods and events dynamically. The component model will significantly decrease the learning curve for developing and using CORBA servers and clients.
CORBA Scripting Language - Scripting languages are significantly easier to learn than low-level programming languages. They remove complexities such as memory allocation and deallocation, memory pointers, and compilation and linking procedures. The CORBA scripting language will let client developers create and access CORBA servers while focusing on integration for the development of business logic.
Objects-by-Value - CORBA has traditionally passed references to objects around the network, which has simplified development of the ORB environment. References are merely aliases to the real object. Any methods calls made on the reference are deferred to the real object for processing. With the addition of objects-by-value, CORBA will pass the state of an object to another process for manipulation. When passing objects by this method, a proper type of object server must be available to handle the incoming object. However, as long as the object doesn't need to be activated, the object can exist in its "by-value" form, meaning it can be handed to a persistence service or a messaging service for further action.
CORBA Interoperable Naming Service - This service is the facility that allows CORBA clients to look up and obtain a reference to a CORBA server. Since each ORB implements its own naming service, and naming services aren't readily interoperable across ORB implementations, a manual configuration is necessary to tell one naming service how to communicate with another. This specification identifies a way for independently developed CORBA clients to share a single naming context. The current submission has yet to define how bootstrapping - the process of naming services automatically detecting each other's presence - will be accomplished.
Additionally, the specification adds support for URL-style naming conventions, though the current submission doesn't yet identify how this will take place.
Multiple Interfaces - As submissions for this specification haven't been received yet, it's unclear what specifically this service will provide. Its intent, however, is to allow a single object to present multiple views of itself through an interface selection mechanism. If this sounds like Microsoft COM's interface query facility, one of the intended purposes of this specification was to more closely align CORBA with the COM object model.
CORBA Persistent State Service (PSS) - Possibly one of the most controversial specifications for the OMG, this service will replace the CORBA Persistence Service, one of the least implemented services due to its ambiguity and complexity. CORBA PSS will provide a simple extensible interface that will allow CORBA to hide the implementation of storing and retrieving objects from the client and provide a consistent portable interface for CORBA server developers.
These six features embody the CORBA components initiative. Additional features include:
Minimum CORBA - This specification identifies the requirement for obtaining the smallest footprint possible for a CORBA ORB. Specifically, this work will help jump-start the use of CORBA in embedded devices.
Realtime CORBA 1.0 -This feature will extend the CORBA specification for a new type of ORB called the Realtime ORB. It will expose interfaces so that developers will have more direct control over ORB resource allocation.
Asynchronous Messaging - This specification has two components: different levels of quality-of-service agreements, and IDL changes necessary to support asynchronous method invocations. CORBA previously provided only three types of method invocation: synchronous, deferred synchronous and one-way. A one-way method invocation is a primitive form of asynchronous invocation that sends the message with no expectation for return. In the deferred synchronous method, control is returned to the client without a response, but the ORB synchronously invokes the method on the object and sends the response later. Thus the ORB still blocks while making the method call on behalf of the client as an agent.
Asynchronous Method Invocation (AMI) - This defines a way for the client and the ORB to asynchronously invoke a method on an object. Hence the need for quality-of-service policies, which tell the ORB how to handle various delivery scenarios, such as when the object cannot be reached or requires too many jumps to deliver the method call. These quality-of-service agreements are implemented as a set of interfaces that manage policies, not a specific metric that must be met.
Java Language to IDL Mapping - This facility will allow developers to build distributed applications completely in Java and then generate the CORBA IDL from the Java class files. Other binary applications can then access Java applications using RMI over IIOP.
Firewall Support - The firewall specification defines interfaces for implementing IIOP through a firewall. It includes options for allowing the firewall to perform filtering and proxying on either side, which is important for extending the use of CORBA to the Internet and across organizational boundaries.
Simply speaking, the preproduction release of the CORBA 3.0 specification at year-end will provide ORB vendors an opportunity to correct problems that may arise during implementation of the new features and services. For many ORB vendors, some of these features may already be available either in a proprietary manner or one that is close to the released specification (this is often the case when the specification comes primarily from submitting vendors).
For organizations considering CORBA as a tool for integrating legacy and new systems, the new features and services could ease implementation considerably. In addition, companies may find CORBA to be among the most reliable of all interoperability software - an increasingly important issue in the age of distributed computing. However, the most likely to benefit from CORBA 3.0 are those attempting to address application integration across heterogeneous hardware and operating system platforms, where distributed computing resources are in short supply.