Advanced CORBA Programming with C++
Addison Wesley, February 1999
Reviewed Apr 2, 1999
This thick (1000+ pages) is probably going to become the number one reference to CORBA. Its authors are long time experts in the CORBA arena and they have been in the OMG since its early inception. The book is divided in six parts. Depending on your level of knowledge in CORBA, you will want to skip the first parts and focus on the last ones.
Part 1 is a fifty-page introduction to CORBA for newcomers. You will find the familiar simple distributed application example and some insight on how things actually work.
Part 2 is a biggy (550 pages) and covers Core CORBA in details : IDL (the language and its mapping to C++), client and server-side C++ mapping. The POA is described in chapter 11 and in 100 pages, the authors give a fairly accurate description of its capabilities and API's.
The last chapter of this part is entirely devoted to life cycle. This is indeed a very tricky part of distributed computing and CORBA is no exception. Developers must be fully aware about how memory ownership is handled throughout the various idioms CORBA uses. This chapter covers Factories in details and also more fine-grained API's like how to use remove() and how to move objects. Although this chapter mostly describes the Life Cycle Service, it also mentions other means to have control over the life cycle of servants, like using the various POA policies (NON_RETAIN) and also includes a description of the Evictor pattern, which manipulates the Active Object Map of the POA and removes idle servants based on an LRU algorithm.
Then the authors examine how the Evictor pattern could be extended to support distributed garbage collection, in order to reclaim the space occupied by servants which were create()d but not destroy()ed. More alternatives are explored : explicit keep-alive (the client has to ping the servant regularly), and more interestingly, reverse keep-alive per object, per-client reverse keep-alive, detection of client disconnection and distributed refcount. All these approaches have drawbacks and the Evictor pattern seems to be the most acceptable compromise until garbage collection is finally added to CORBA (which might take a few years, even though an RFP was submitted to the OMG in August 1998).
This is an extremely interesting chapter even though, as the authors say themselves in its conclusion, it raises more questions than it answers.
Part 3 makes a short (sixty pages) incursion into lower-level details, like the GIOP and Implementation Repositories.
Part 4 is Dynamic CORBA. It details all the mechanisms CORBA offers to manipulate and invoke functions on objects dynamically : the any type, type codes and the (newer) DynAny type.
Part 5 describes three important CORBA services : Naming, Trading and Event. Most of CORBA books have to make a choice at this point : there are a lot of CORBA Services and they are very unevenly specified and implemented throughout the various ORB's. But I have to agree with the choice of these three services : they are probably the most useful and most readily available services to be found as of today.
Finally, part 6 explores advanced functionalities of CORBA : multithreading, performance, scalability and maintainability. The multithreading issues are thoroughly explored, including the POA support, and the examples make use of Doug Schmidt's ACE environment, which offers a very wide range of cross-platform support for multi-thread.
This book is a quite impressive piece of work and is a definite must-buy for any C++ CORBA developer. And will probably remain so for quite some time.
Back to the menu