Location: [CPSC 333] [Listing by Topic] [Listing by Date] [Previous Topic] [Next Topic] Additional Emerging Standards
This material was not covered in lectures in 1997 due to lack of time. It can be considered to be optional (so, it won't be used on assignments and tests in the course this year).
One criticism that's been about object-oriented development is that while it's intended to facilitate software reuse, the reusable components one would need for this haven't been easy to find (if they existed at all), and it hasn't always been clear how to use the components that have been available could be used. The emergence of methods for object-oriented design, as well as toolkits, patterns, and frameworks can be taken as evidence that this problem is being addressed.
Another criticism is that the available components have often been incompatible with one another, and ``platform dependent,'' making it difficult to port a system from one platform to another, if reusable components had been used.
The Standard Template Library is an example of a library of components that is (or will soon be) available on all platforms, because it is (apparently) being adopted as part of the C++ standard. It is well designed, including components with (relatively) simple interfaces that are easily combined, and (therefore) a ``standard'' for libraries for generic components might well emerge from it.
This page mentions two other ``emerging standards'' that might also be taken as evidence that problems involving incompatibility of component libraries, and platform dependence, are being addressed.
Rogers includes chapters of both these (as well as the Standard Template Library):
G. Rogers
Framework-Based Software Development in C++
Prentice Hall, 1997
It's likely that there will soon be quite a few additional references on the Standard Template Library, and CORBA. Indeed, there are several books concerning CORBA (for use with Java, as well as C++) in the bookstore now. It's possible that more material will be available on ODMG soon as well (but I'm unaware of additional references for this at present).
As defined by Rogers,
``CORBA, which stands for Common Object Request Broker Architecture, is an industry-standard model for communication between objects. The model specifies how objects invoke each other's member functions, regardless of their physical proximity to each other. Objects communicating as per this model can be on different machines, as long as there is network connectivity between these machines. Communicating objects need not have the same implementation language, hardware platform, or to be executing under the same operating system.''
The additional software needed to implement this is an ``Object Request Broker:''
``An Object Request Broker (ORB) is a software package that implements the CORBA standard, enabling objects to invoke each others' member functions, regardless of their proximity to each other. A C++ language binding, specified as part of CORBA, must be supported by an ORB. This binding specifies the C++ syntax that can be used by C++ programmers to take advantage of the features provided by an ORB.''
CORBA makes it possible to define generic software services that can be provided via an ORB, and the consortium of companies that has defined this standard (the Object Management Group - ``OMG'') intends to develop specifications of such services as a continuation of their work. As mentioned by Rogers, ``this could ultimately result in the emergence of an industry that provides commodity software components for CORBA.''
Here is another interesting point that Rogers makes.
``All this reserved curiosity about Java and the Web is now bursting into immense anticipation with recent announcements by several ORB vendors that they are providing a Java language binding with their ORBs. This means that a Java object will be able to directly invoke member functions of C++ objects on some other machine. This marriage is, perhaps, the single most significant software innovation of the late 1990's. And it is one that is already blessed by the OMG, which has sent out a Request For Proposals for a standard Java binding.
The fact that CORBA will enable a Java object to become a client of a C++ object is a wonderful thing. It means that C++ frameworks built using the methodology presented in this (Rogers') book can be directly used to build complex Web applications, where Java applets are clients to industrial-strength compute servers.
There is one group of vendors that have great cause for concern: those who sell GUI toolkits. Just as STL has rendered much of the commercially available component libraries obsolete, so too will this marriage. The Java/HTML GUI capabilities just may provide a much needed industry standard GUI interface...''
Rogers presents a set of steps to follow in order to use CORBA and presents an ``Event Notification'' example.
Object-oriented systems frequently interact with a data base package in order to maintain persistent objects, which must be stored on termination of the system and retrieved when the system is resumed. These also facilitate management of data when there is too much of it for all of it to exist in main memory at once.
If a ``relational'' data base package is used, then it is necessary to organize data into a set of data tables, as has been described already in this course, and it is necessary to develop an interface between the object-oriented system and the relational data base, which (among other things) must handle a ``translation'' of data from the representation that the one system supports to the representation that the other system expects.
Object-oriented data bases have the advantage that this kind of translation is generally not required: ``Your C++ class declarations are your schema, so the programming language view of the data is consistent with the database view.''
Unfortunately, object-oriented data base packages have not used consistent interfaces (with one another) in the past, so that using these data bases has caused problems when systems have been ported across platforms. This is not a problem with relational data base packages since the Standard Query Language (SQL) provides this kind of standard. (See Computer Science 471 for a discussion of this standard.)
ODMG-93 is a proposed standard interface for Object-Oriented Languages which is (now) being supported by commercial object-oriented data base systems and (as of 1996) being used by commercial vendors as a selling feature. It's to be hoped that its adoption will address some of the compatibility and portability problems that have been introduced by the use of object-oriented data base packages in the past.
Again, Rogers describes a way to use an ODMG-93-compliant object-oriented data base package with C++, and provides an example (involving ``Security Alarm Reporting'').
Location: [CPSC 333] [Listing by Topic] [Listing by Date] [Previous Topic] [Next Topic] Additional Emerging Standards