IONA End to Everywhere
» Support   » Downloads   » Sales   » Search  
Steve Vinoski Homepage

oThe Chief Architect's View

oInformation on our CORBA book Advanced CORBA Programming with C++

oObject Interconnections columns on Distributed Object Computing

oArticles on CORBA and the OMG


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++
Cover of 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.

  • Real-time 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.  

  • Real-time 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.  

  • CORBA and 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 business processes.  

  • 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. 

  • 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.  

  • Using Standard 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 consequences.  

  • Standard 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++.  

  • The History 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.) 

  • 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
     


     
     

Doug's 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.