CORBA

We've been developing code on Windows and Unix for quite some time, but most of the distributed component work we've been involved in has been done using COM.

That's changing now as a clients have more requirements for Unix based component solutions.

We're currently evaluating CORBA ORBs and learning how the CORBA way of doing things differs from the COM way.

These articles detail our findings.

Articles:

Reference Counting - The first difference that we came across was the way that CORBA servers deal with object lifetime issues. Adding reference counting to CORBA objects isn't as easy as it first seems

More Reference Counting - Although we managed to develop a working solution in the first reference counting article the results were ugly and fragile. In this article we attempt to clean things up a little and, in doing so, get intimate with the Portable Object Adapter and its Servant Managers.

Reference Counting Issues - At the end of the second article we have developed a self contained reference counting implementation that appears to work. Unfortunately, it's still far from reliable as CORBA doesn't provide the level of support for reference counting that's built into COM. In this article we discuss the problem and the various CORBA methods for controlling server object lifetime.

Enumeration - CORBA provides sequences as a way of returning collections of items from an method call. The problem with just using unbounded sequences is that the client has no control over how many items it receives as a result of the call. COM gets around this problem using the IEnum style interfaces that allow a client to control how it accesses the items in a collection.

Iteration - A CORBA style method of enumeration can be seen in the iteration interfaces on the CORBA Naming Service. Given the code we've already written for the enumeration interface we can easily implement an iteration interface as well as (or, more likely, instead of).

The Evictor Pattern - Since CORBA doesn't really support reliable reference counting implementations we'll compare one of the recommended methods of servant life-time management with our reference counted iteration interface.

Keep Alive - One way of making a reference counted implementation more robust is to run the keep-alive protocol yourself. We demonstrate this option here.