University of California, Irvine
The following document is the foreword to the book Fundamentals of
Distributed Object Systems: The CORBA Perspective, by Zahir Tari
and Omran Bukhres, Wiley and Sons, 2001.
Innovations have been occurring at a predictable rate in certain
technology domains for many years. For example, Moore's Law--where
the capacity of general-purpose computer chips have doubled every 18
months--is still going strong after three decades. More recently, the
speed of IP networks has been improving at an even faster rate--known
as Metcalf's Law--where bandwidth increases by a factor of ten every
two years. At this point there is even a ``bandwidth index,'' similar
to indices that track the price/performance of other commodities, such
as petroleum or electricity. The steady advance in these technologies
is remarkable and is due in no small part to decades of synergistic
research, development, and education by academic, industrial, and
government partners around the world.
There are, however, important domains--particularly software-intensive
distributed systems in telecommunications, health care, aerospace, and
online financial services--that are not improving at the same rate as
Moore's Law or Metcalf's Law, due to a variety of inherent and
accidental complexities, such as partial failures, distributed
deadlock, and non-portable programming APIs. Consequently, although
computer and network hardware keeps getting smaller, faster, cheaper,
and better at a predictable pace, complex distributed software systems
seem to get bigger, slower, more expensive, and buggier, and the
innovation cycles are hard to predict.
An appropriate metaphor for the challenges of software-intensive
distributed systems appears in the movie Apollo 13 starring Tom Hanks.
After an explosion in the command module forces the crew into the
lunar module, the carbon dioxide levels grow dangerously high due to a
broken air scrubber. At this crucial moment, a manager at Johnson
space center walks into a room full of engineers and scientists
sitting around a table and dumps out a bag containing common
components--such as a toothpaste, tang, and duct tape--found on the
lunar module. He tells the group they've got eight hours to take
these component and assemble an air scrubber that will fit into the
appropriate opening, and if it is not right the first time, everyone
is going to die!
Increasingly, developers of complex software-intensive distributed
systems--especially large-scale mission-critical ``systems of
systems''--are facing challenges analogous to those of the Apollo 13
engineers and scientists. In particular, time-to-market pressures and
competition for consumers and personnel have created a situation where
distributed systems must be developed using a large number of
commodity-off-the-shelf (COTS) components, which are not developed
in-house and whose quality can thus rarely be controlled directly.
Yet, just like the Apollo 13 engineers and scientists, we must quickly
and robustly master the principles, patterns, and protocols necessary
to thrive in a COTS-centric environment because our livelihoods--and
sometimes even our lives--depend upon our success.
Over the past decade, various techniques and tools have been developed
to alleviate many accidental and inherent complexities associated with
distributed software systems. Some of the most successful of these
techniques and tools center on distributed object computing (DOC)
middleware, which resides between applications and the underlying
operating systems, protocol stacks, and hardware devices to simplify
and coordinate how these components are connected and how they
interoperate. Just as communication protocol stacks can be decomposed
into multiple layers, so to can DOC middleware be decomposed into the
following layers:
- Infrastructure middleware, which encapsulates and
enhances native OS communication and concurrency mechanisms to create
object-oriented (OO) network programming components, such as reactors,
acceptor-connectors, monitor objects, active objects, and component
configurators. These components help eliminate many tedious,
error-prone, and non-portable aspects of developing and maintaining
networked applications via low-level OS programming API, such as
Sockets or POSIX pthreads. Widely-used examples of infrastructure
middleware include Java virtual machines (JVMs) and the ADAPTIVE
Communication Environment (ACE).
- Distribution middleware, which use and extend the
infrastructure middleware to define a higher-level distributed
programming model. This programming model defines reusable APIs and
components that automate common end-system network programming tasks,
such as connection management, (de)marshaling, demultiplexing,
end-point and request demultiplexing, and multi-threading.
Distribution middleware enables distributed applications to be
programmed using techniques familiar to developers of stand-alone
applications, i.e., by having clients invoke operations on
target objects without concern for their location, programming
language, OS platform, communication protocols and interconnects, and
hardware. At the heart of distribution middleware are Object Request
Brokers (ORBs), such as Microsoft's Component Object Model (COM)+,
Sun's Java Remote Method Invocation (RMI), and the OMG's Common Object
Request Broker Architecture (CORBA), which is a key focus of this
book.
- Common middleware services, which augment distribution
middleware by defining higher-level domain-independent services, such
as event notifications, logging, multimedia streaming, persistence,
security, global time, real-time scheduling and end-to-end quality of
service (QoS), fault tolerance, concurrency control, and transactions.
Whereas distribution middleware focuses largely on managing end-system
resources in support of an OO distributed programming model, common
middleware services focus on managing resources throughout a
distributed system. Developers can reuse these services to allocate,
schedule, and coordinate global resources and perform common
distribution tasks that would otherwise be implemented in an ad
hoc manner within each application.
- Domain-specific services, which are tailored to the
requirements of particular domains, such as telecommunications,
e-commerce, health care, process automation, or aerospace. Unlike the
other three OO middleware layers--which provide broadly reusable
``horizontal'' mechanisms and services--domain-specific services are
targeted at vertical markets. Domain-specific services are the least
mature of the middleware layers today, due partly to the historical
lack of distribution middleware and common middleware service
standards, which provide a stable base upon which to create
domain-specific services. Since these services embody knowledge of
application domains, however, they can significantly increase system
quality and decrease the cycle-time and effort required to develop
particular types of distributed applications.
As these DOC middleware layers mature they are becoming COTS products
that are readily available for purchase or open-source acquisition.
COTS DOC middleware has become essential in software development
organizations that face stringent time and resource constraints since
it helps amortize software life-cycle costs by leveraging previous
development expertise and concentrating research efforts that improve
quality and performance. Ultimately, this R&D process will result in
software-intensive distributed systems that get smaller, faster,
cheaper, and better at a predictable pace, just as computer and
network hardware do today.
The following factors have helped improve the quality and performance
of COTS DOC middleware products during the past decade:
- Maturation of DOC middleware standards -- DOC middleware
standards have matured considerably in recent years. For instance,
the OMG has adopted specifications for CORBA that reduce ORB
footprint, improve fault tolerant behavior, reserve real-time
connection and threading resources, and expose various types of QoS
policies to applications.
- Maturation of DOC middleware patterns and frameworks --
A substantial amount of R&D effort has focused on patterns and
frameworks for DOC middleware and applications. As these patterns
mature and become instantiated in COTS framework components, they have
helped improve the efficiency, scalability, predictability, and
flexibility of DOC middleware.
Until recently, however, it has been hard for instructors and students
to learn how to use DOC middleware effectively without dedicating
substantial time and effort. One problem has been that DOC middleware
APIs, capabilities, and best practices have existed largely in the
programming folklore, the heads of expert developers, or scattered
throughout articles in trade magazines and web sites. Another problem
is that existing books on DOC middleware and CORBA are intended as
guides for industry practitioners rather than as textbooks for
students. Thus, many important theoretical and fundamental
distribution issues are not covered in these books.
In a highly competitive information technology economy, educating
students to become effective distributed software developers is
increasingly important. Premium value and competitive advantage is
accruing to individuals, universities, companies, and even countries
that can quickly master the principles, patterns, and protocols
necessary to integrate COTS middleware to create complex DOC
applications that cannot be bought off-the-shelf yet. Success in this
endeavor requires close collaboration between researchers and
practitioners, which is why I'm delighted that Zahir Tari and Omran
Bukhres have written Fundamentals of Distributed Object Systems:
The CORBA Perspective to help educate researcher and developers
of next-generation information technologies.
This book uses CORBA to illustrate the theory and practice of
distribution middleware and many common middleware services, as
follows:
- The coverage of CORBA's distribution middleware is split into two
parts: (1) fundamental aspects of the CORBA reference model,
such as the CORBA interface definition language (IDL), object
references, and standard interoperability protocols and (2)
advanced CORBA features, such as portable object adapters,
client caching, and enhanced communication protocols. This material
provides much more than a rehash of the standard CORBA APIs -- it also
describes the key technical concepts, underlying theoretical
foundations, and common solutions related to challenges encountered
when developing and integrating interoperable software.
- The coverage of common middleware services focus on a wide range
of CORBA's object services, such as the CORBA Naming, Trading, Events,
Transaction, and Query services. For most of these services, this
book describes the corresponding architectures and basic elements. It
also shows how such services can be implemented and presents lessons
that can be learned and generalized when developing domain-specific
services and distributed applications.
By study, mastering, and applying the material in this book you'll be
able to design and implement distributed applications more rapidly and
effectively.
We are fortunate that Zahir and Omran have found time in their busy
professional lives to write an outstanding textbook on DOC middleware
and CORBA. If you want thorough coverage of the DOC middleware
technologies that are shaping next-generation distributed systems read
this book. I've learned much from it and I'm confident that you will
too.
Douglas C. Schmidt
University of California, Irvine
Back to my
editorials home page.
Last modified 11:34:19 CDT 28 September 2006