The Chief Architect's
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
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
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:
and Noble, Borders,
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
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
similar article appeared in C++ Report in July 1993, but CORBA has
of course changed a lot since then.)
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
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.
CORBA, Part 2: Applications and Priorities, C/C++ Users Journal, January
2002. The Real-time CORBA Specification enhances regular CORBA by adding
capabilities that control process, communication, and memory resources.
These capabilities enable standard COTS middleware to improve the
determinism of DRE applications by bounding their priority inversions and
managing their system resources more predictably end-to-end. This column
shows how to program the Real-time CORBA features that provide portable
priority mapping and end-to-end priority preservation.
CORBA, Part 1: Motivation and Overview, C/C++ users Journal, December
2001. In this column, we explore distributed real-time and embedded
(DRE) systems by digging into the Real-time CORBA Specification. This spec
provides interfaces and policies that allow applications to control and
configure processor resources (via thread pools, priority mechanisms,
intra-process mutexes, and global scheduling), communication resources
(via protocol properties and explicit bindings), and memory resources
(via buffering requests and bounding the sizes of thread pools). This column
provides an overview of these interfaces and policies.
XML, Part 3: SOAP and Web Services, C/C++ Users Journal, September
2001. In this column, we extensively explore SOAP and Web Services. Both
SOAP and Web Services are currently garnering a lot of industry attention,
with some comparing CORBA and SOAP, or CORBA and Web Services, as if they
were competitors. In disagreeing with this viewpoint, we first compare SOAP
and IIOP and then argue that Web Services and CORBA are not rivals, but
instead are complementary. We see Web Services serving as business process
integration technology capable of combining existing middleware technologies
such as CORBA, J2EE, .NET, and EAI into Internet-accessible service-oriented
CORBA and XML, Part 2: XML as CORBA Data, C/C++ Users
Journal, July 2001. The hype surrounding XML often conceals its real
utility, which ultimately boils down to providing for the structured -- yet
flexible -- description and definition of data. XML's capabilities therefore
mesh well with those of CORBA, which primarily focuses on system
functionality rather than system data. In this column, we continue our
exploration of the relationship between CORBA and XML. Since our previous
column advocated the passing of XML-defined data between client and server,
we first discuss various alternatives for doing this using an example bug
tracking system. We conclude the column with a brief discussion of SOAP and
Web Services and how they relate to CORBA.
and XML, Part 1: Versioning, C/C++ Users Journal, May, 2001. In this
column we explore the hype surrounding XML and how it might be used in a
practical manner in a CORBA-based application. We specifically explore the
issue of versioning support in CORBA systems - or the lack thereof - and
take a look at how XML might be used to alleviate some of the problems.
C++ in the OMG C++ Mapping, C/C++ Users Journal, April, 2001.
In this column we complete our exploration of hypothetical OMG C++ mappings
using Standard C++ by focusing on the server side. This column illustrates
some of the complexity of mapping the language-neutral OMG IDL to C++ in a
way allowing for flexible servant implementations. We also take a brief look
at the mapping for pseudo-objects in a Standard C++ world. As usual, there
are few absolutely right or wrong answers, but many choices with varying
C++ and the OMG C++ Mapping, C/C++ Users Journal, January, 2001.
The OMG mapping from CORBA IDL to C++ was standardized in 1994. As we
explain, there are some good reasons to leave that mapping alone, even
though the C++ language changed significantly between 1994 and 1998, when
it finally became an international standard. But that doesn't keep us from
having a little fun. In this column, we explore our own alternative "what
if" mappings, based on newer features of C++.
of the OMG C++ Mapping, C/C++ Users Journal, November, 2000. This
column goes back in time to when the OMG C++ mapping was defined and
describes some of the non-technical issues that made it the way it is.
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.)
home page also has tons of other useful information about distributed
object computing, design
patterns, and other goodies. The Cetus
Links on CORBA contains lots of links to CORBA information.
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)
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
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)
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
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
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
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
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
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
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
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
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