The fundamental difference between
DCE and CORBA is that DCE was designed to support procedural
programming, while CORBA was designed to support object-oriented programming. Object-oriented
programming environments are usually characterized by their support for:
- Encapsulation of data and the functions that manipulate
the data into objects. This enforces data hiding,
since the only way to access an object’s data is through the operations in the object’s public
interface.
- Abstraction of common features shared by objects into classes.
A class definition describes the data
associated with each instance of the class, defines the set of operations that can be invoked on an
instance of the class, and prescribes the functions that are executed in response to requests for those
operations. Inheritance of interfaces and implementations. This is the mechanism that supports the
specialization or refinement of classes into subclasses. It is also one example of reuse in object-oriented
programming.
- Polymorphism, which is the ability for a request for a
specific operation to be handled differently
depending on the type of object on which it is invoked. For example, subclasses of a common superclass
may override functions defined by the superclass to differentiate how instances of the subclasses and
the superclass behave.
In addition to these common characteristics,
object-oriented programming environments usually support a
style of programming in which:
- Not only new objects, but new classes may be created at
runtime.
- Late binding of operation invocations to function calls
allow programs to be written without regard for
the types of objects they will manipulate.
- Object references are passed among objects freely, which
can lead to dynamic patterns of request
invocations among objects of arbitrary types (by virtue of late binding).
- Once defined, objects and classes may be reused or refined
in subsequent applications, extending the
usefulness of object implementations across multiple applications.
CORBA supports all of the common
characteristics and programming styles described above, with the
possible exception of creating new classes at runtime. We believe the creation of new classes at runtime
may be enabled by recently adopted CORBA 2.0 specifications. In particular, we refer to additional Interface
Repository operations for adding information to a repository at runtime and a Dynamic Skeleton Interface,
which supports the implementation of servers capable of handling requests for objects whose types are
unknown at compile time.
Distributed procedural programming
environments such as DCE support a different set of capabilities than
those described above. The basic approach to distributing a procedural program is to:
1.Partition the program’s
data and the functions that manipulate the data into servers;
2.Distribute those servers across
multiple hosts; and
3.Change function calls to RPCs,
as appropriate.
This style of programming does
encapsulate data and functions in servers, because the only way to access
the data is through the server’s RPC interface. It does not protect any of the data within a server
from
access by any of the functions in the server, however. Nor does it support abstraction, inheritance,
polymorphism, or the dynamic style of programming described above.
DCE does have additional capabilities
that begin to overlap with traditional capabilities of object-oriented
systems:
- A DCE client can determine at runtime the specific servers
to which it will bind and make RPCs (although
the interfaces supported by those servers must be fixed at compile time).
- A DCE server may generate what are called object UUIDs
(universal unique identifiers) to denote
different resources managed by the server. A client that does an RPC to the server can use an object
UUID to identify a specific resource. For example, a print server might generate object UUIDs for the
different printers it controls, and a client submitting a print request would specify the desired printer.
- A DCE server may also generate what are called object type
UUIDs, associate each object UUID with an
object type UUID, and register a separate set of RPC handlers for each object type UUID. When a client
does an RPC to the server and specifies an object UUID, the specific function that is invoked in the
server depends on the object type with which the object UUID is associated. For example, our print
server might associate one object type UUID with RPC handlers that support line printers and another
object type UUID with a corresponding set of RPC handlers that support PostScript printers.
- One can argue that these features support some of the characteristics
of object-oriented systems
described above. The object type UUID does indeed support some form of abstraction and
polymorphism. The important distinction to be made here is that procedural programming is not object-
oriented programming, although it can be used to implement an object-oriented programming
environment, just as C is often used to implement C++ (that is to say, C++ is often pre-processed into
C
before compilation).
- The analogy between C and C++ is a good one. Many CORBA-conformant
ORB vendors (DEC, HP, and
IBM, for example) are implementing ORBs on top of DCE. The desirability of the object-oriented
approach even within the DCE community is evidenced by several efforts to provide C++ interfaces to
DCE [Dilley, Leddy, Mock, Viveney].
The OODCE RFC [Dilley] relates
DCE and CORBA as follows:
- ā€˛...our work focuses on integrating C++ within the existing
DCE system infrastructure, simplifying the
use of the DCE object model.
- ā€˛OMG CORBA will address creating distributed object systems
in C++; some implementations will run
on top of DCE. CORBA IDL provides for interface inheritance, which DCE IDL is lacking, and provides
a
more C++-like syntax for interface specification. The CORBA runtime environment provides a richer set
of object invocation and passing than the DCE environment.
- ā€˛We suggest that our work may assist in the migration from
DCE to CORBA by providing an
intermediate C++- based distributed object system until CORBA implementations are widely available.“
1.Introduction
