The Chief Architect's View
In my column entitled "The Chief Architect's View," published in IONA's IONAsphere, I describe IONA's technical goals regarding our end-to-end business and technical integration products and approaches. 

• In the November 2001 issue I discuss the issue of dynamic discovery in relation to Web Services. Unfortunately, many Web Services proponents exaggerate about what dynamic discovery can do, and their claims are wildly misleading. Only knowing a web service's WSDL interface does not give you enough information to be able to properly interact with it dynamically, simply because WSDL cannot convey semantics. As I explain, though, dynamic discovery does have a place in Web Services, but only if it's accompanied by a shared ontology between sender and receiver. Shared ontologies can provide for clear and unambiguous application choreography, such as what B2B standards such as RosettaNet can supply.

• In the October 2001 issue I describe the cluster support built into iPortal Application Server 3.0. These features allow your web-facing integration solutions to avoid single points of failure, ensuring application uptime and availability. The iPortal Application Server provides fully-branded J2EE support with best-of-breed quality of service and implementation at a fraction of the cost of ownership of competitive solutions.

• In the September 2001 issue I describe some of the new features of Orbix 2000 2.0, focusing on the built-in fault tolerance, failover, and load balancing features. These kinds of features make Orbix 2000 the world's best ORB for enterprise-scale CORBA applications.

• In the June 2001 issue I continue my discussion of Web Services by focusing on application-level protocols and choreographies, and why they're important for establishing the proper levels of abstraction in your systems.

• In the May 2001 issue I discuss Web Services -- what they are, why they're good, why they're currently not so good, and the hype surrounding them.

• In the April 2001 issue I describe the basis of IONA's technical approach to middleware and why our approach is superior to that of our competition, and I provide an outline of what I intend to cover in future articles.

Advanced CORBA Programming with C++

Michi Henning's and my CORBA book, Advanced CORBA Programming with C++, is published by Addison Wesley Longman. Click on the book title link for more details, including the table of contents, the preface, a downloadable sample chapter, and the errata list. 

See the reviews at Slashdot for other reader's opinions of the book. 

Here are a few on-line book shops that stock the book and ship internationally: 

Amazon, Barnes and Noble, Borders, Fatbrain, Quantum. 

In the UK, Amazon UK stock the book.

In Germany, Amazon Germany stock the book.

The third printing of Advanced CORBA Programming with C++ came out in the autumn of 1999. For that printing, Michi and I replaced Chapter 17 (about DynAny) with a completely rewritten version.

The reason for the updated chapter is that after the book went to print (which was before publication of CORBA 2.3), the DynAny interfaces were substantially changed by the OMG Core RTF. The reason was that there were many niggling problems with the original DynAny interface, which, unfortunately, could not be resolved without breaking the DynAny interfaces. 

So, as a result, we have a better DynAny interface in CORBA 2.3 but, unfortunately, an out-of-date chapter in the first and second printings. 

As a consolation for those people who bought the first or second printing, we've made the replacement Chapter 17 available for download (PDF). 

You can find the update at Addison Wesley. 

OMG-Related Articles
In the October 1998 issue of Communications of the ACM I published an article entitled New Features for CORBA 3.0 (PDF or Postscript) that gives an overview of some of the new features that will be in CORBA 3.0. (Note: No, CORBA 3.0 is not yet available. It probably won't be published until 2001.) 

For a general overview of CORBA and the Object Management Architecture (OMA), please see my CORBA overview (Postscript or PDF) that was published in the February 1997 issue of IEEE Communications. (An older, similar article appeared in C++ Report in July 1993, but CORBA has of course changed a lot since then.) 

Michi Henning wrote an excellent article entitled Binding, Migration, and Scalability in CORBA for the October 1998 issue of Communications of the ACM. It explains how binding and implementation repositories work in CORBA, and discusses how the design of implementation repositories determines factors such as scalability, performance, and granularity of object migration. The article also explores some issues relating to garbage collection of CORBA objects.

Object Interconnections Columns
Together with Dr. Douglas C. Schmidt of UC Irvine, I write about distributed object computing in our Object Interconnections column in the C/C++ Users Journal.

Our old C++ Report columns are also listed below. (The later columns build on the earlier ones, so you might find them easier to understand if you read them in the reverse of the order shown.) 

• An Overview of the OMG CORBA Messaging Quality of Service (QoS) Framework, C++ Report, SIGS, Vol. 12, No 3, March, 2000. This column outlines the QoS policies defined in the OMG CORBA Messaging specification. These QoS policies provide a new degree of flexibility and control to CORBA application developers. We focus our discussion on several policies, client timeouts and reliable one-ways, that we've found useful when developing real-world CORBA applications. (Postscript or PDF) 
• Collocation Optimizations for CORBA, C++ Report, SIGS, Vol. 11, No. 9, October, 1999. This columns examines various techniques for collocating clients and objects in CORBA. Collocation is a technique for transparently optimizing communication overhead when clients and servants are configured into the same address space. In such cases, CORBA ORBs can transparently employ collocation optimizations to ensure there's no unnecessary overhead of (de)marshaling data or transmitting requests/replies through a "loopback" communication device. (Postscript or PDF) 
• Time-Independent Invocation and Interoperable Routing, C++ Report, SIGS, Vol. 11, No 5, May, 1999. This column focuses on a new feature defined in the CORBA Messaging Specification called time-independent invocation (TII), which adds store-and-forward features to CORBA. In this column, we illustrate how TII essentially extends CORBA asynchronous method invocations (AMI)s with persistent ReplyHandler, Pollers, and Requests. (Postscript or PDF) 
• Programming Asynchronous Method Invocations with CORBA Messaging, C++ Report, SIGS, Vol. 11, No 2, February 1999. This column focuses on asynchronous method invocation (AMI), which is a core part of the new CORBA Messaging specification. A key feature of the CORBA AMI is that it effectively allows deferred synchronous calls using the static invocation interface (SII), thereby alleviating much of the tedium associated with using the DII. This column illustrates how to use the callback and polling AMI models with C++. (Postscript or PDF) 
• An Introduction to CORBA Messaging, SIGS C++ Report, Vol. 10, No. 10, November/December 1998. In this column we begin our coverage of asynchronous messaging and the new CORBA Messaging specification. This specification introduces a number of long-awaited features into CORBA, including asynchronous method invocation (AMI), time-independent invocation (TII), and general Quality of Service (QoS) policies. These new features greatly enhance the standard set of request/response communication models that CORBA provides. (Postscript or PDF) 
• C++ Servant Managers for the Portable Object Adapter, SIGS C++ Report, Vol. 10, No. 7, September, 1998. This column describes servant managers and default servants. Servant managers can dynamically load servants for target objects on demand, and they can help with servant clean-up. Default servants allow multiple CORBA objects to be incarnated by a single servant, thus avoiding the resource usage associated with a servant-per-object design. (Postscript or PDF) 
• C++ Servant Classes for the POA, SIGS C++ Report, Vol. 10, No 6, June, 1998. This column explains how the new POA specification separates the client-side stub hierarchy from the server-side skeleton hierarchy in order to facilitate collocation and ensure source-level portability. (Postscript or PDF) 
• Using the Portable Object Adapter for Transient and Persistent CORBA Objects, SIGS C++ Report, Vol. 10, No 4, April, 1998. This column explains how the new Portable Object Adapter (POA) can be used to support transient and persistent CORBA objects, and shows examples of each in C++. (Postscript or PDF) 
• Object Adapters: Concepts and Terminology, SIGS C++ Report, Vol. 9, No. 11. November/December 1997. This column explains what Object Adapters are and describe their roles within a CORBA-based system. In addition, it details the new Portable Object Adapter (POA) specification that was recently adopted by the OMG. (Postscript or PDF) 
• Overcoming Drawbacks With the OMG Events Service, SIGS C++ Report, Vol. 9, No 6. June, 1997. This column describes techniques for overcoming drawbacks with the OMG Events Service. These techniques range from changing the COS Events Service specification, to changing implementations of the COS Events Service specification, as well as changing applications that use a COS Events Service implementation. (Postscript or PDF) 
• The OMG Events Service, SIGS C++ Report, Vol. 9, No. 2, February 1997. This column outlines the roles of the key components in the OMG Events Service, examines the IDL interfaces of the Events Service components in detail, shows how to use it to build a flexible version of the distributed stock quoter system, and evaluates the strengths and weaknesses of the OMG Events Service model and its specification. (Postscript or PDF) 
• Distributed Callbacks and Decoupled Communication in CORBA, SIGS C++ Report, Vol. 8, No. 10, October 1996. This column examines the use of distributed callbacks in CORBA and illustrates why they are useful for decoupling relationships between consumers and suppliers in object-oriented communication applications. (Postscript or PDF) 
• Comparing Alternative Programming Techniques for Multi-threaded Servers -- the Thread-per-Session Concurrency Model, SIGS C++ Report, Vol 8. No 6. June 1996. This column examines and evaluates three techniques for developing multi-threaded servers using the ``thread-per-session'' concurrency model. These techniques include using the socket network programming interface, using C++ wrappers for sockets, and using multi-threaded Orbix. (Postscript or PDF) 
• Comparing Alternative Programming Techniques for Multi-threaded Servers -- the Thread-Pool Concurrency Model, SIGS C++ Report, Vol 8. No 4. April 1996. This column examines and evaluates three techniques for developing multi-threaded servers using the "thread-pool" concurrency model. These techniques include using the socket network programming interface, using C++ wrappers for sockets, and using multi-threaded Orbix. (Postscript or PDF) 
• Comparing Alternative Programming Techniques for Multi-threaded Servers, SIGS C++ Report, Vol 8. No 2. February 1996. This column examines and evaluates four techniques for developing multi-threaded servers. These techniques include using the socket network programming interface, using C++ wrappers for sockets, and using two multi-threaded versions of CORBA (Orbix and HP ORB Plus). (Postscript or PDF) 
• Comparing Alternative Server Distributed Programming Techniques, SIGS C++ Report, Vol 7. No 8. October 1995. This column examines and evaluates three techniques for developing the server-side a distributed application. These techniques include using the socket network programming interface, using C++ wrappers for sockets, to using CORBA. (Postscript or PDF) 
• Comparing Alternative Client Distributed Programming Techniques, SIGS C++ Report, Vol. 7. No. 4, May 1995. This column examines an evaluates three different programming techniques for developing the client-side of a distributed application. These techniques include using the socket network programming interface, using C++ wrappers for sockets, to using a distributed object computing solution based on CORBA. (Postscript or PDF) 
• Modeling Distributed Object Applications, SIGS C++ Report, Vol 7. No. 2, February 1995. This column describes the key features of DOC frameworks (such as CORBA, Network OLE, and OODCE) and explains how these frameworks address distributed application requirements (such as reliability, heterogeneity, location independence, security, and performance). (Postscript or PDF) 
• Introduction to Distributed Object Computing, SIGS C++ Report, Vol. 7, No. 1, January 1995. This column presents an introduction to distributed object computing (DOC) and briefly describes how DOC frameworks differ from conventional network programming interfaces (such as sockets or TLI) and procedural-oriented distributed computing toolkits (such as DCE and Sun RPC). (Postscript or PDF)