INTRODUCTION
The goal of this introduction is to present an overview of the content of this book. We will also use it as a vehicle for explaining our motivation behind writing the book and the objectives we set out to achieve. We identify the target group we want to reach with this book and then present a chapter-by-chapter breakdown of the topics discussed.
1.1 INFRASTRUCTURES FOR DISTRIBUTED APPLICATIONS
The pervasiveness of networking technology both locally (e.g., local area networks) and globally (e.g., the Internet) enables the proliferation of distributed applications. Since the parts of a distributed application execute in different physical locations, these applications offer a number of advantages: geographical constraints can be matched, applications become fault tolerant through replication, and performance can be improved by parallelizing a task—to name just a few. Taking a closer look at the execution environment reveals its heterogeneity: different hardware platforms, network technologies, operating systems, and programming languages can make the development of distributed applications a big challenge.
What is needed for distributed systems, therefore, is an infrastructure that suitably supports the development and the execution of distributed applications. A middleware platform presents such an infrastructure because it provides a buffer between the applications and the network (see Figure 1.1). The network merely supplies a transport mechanism; access to it depends heavily on technological factors and differs between various physical platforms. Middleware homogenizes access to networks and offers generic services for applications. It also bridges technological domains and encapsulates the differences between different systems.
In this book we describe middleware from two different perspectives: from the view of applications programmers and from the view of systems programmers. Applications programmers regard middleware as a tool that helps them in the development of distributed applications. These programmers are not normally interested in how the middleware is implemented but only in how it is used. Applications programmers see the distribution platform as a black box with a well-defined interface and prescribed functionality.
Systems programmers take a complementary view. They regard the distribution platform as a white box and are interested primarily in its internal processes. The application running on a middleware is of minor importance. The common reference point for both types of programmer is the interface to the middleware that is used by applications programmers and provided by systems programmers.
Our approach is to look at middleware from both points of view and to use this information as the basis for honing the knowledge of systems and applications programmers. Systems programmers are presented with the requirements of the applications side for which solutions have to be produced. Knowledge about the inner workings of distribution platforms helps applications programmers make optimal use of the functions available. The concept of the two viewpoints runs through the book like a thread. Our objective is to provide a comprehensive look at the architecture and the design of middleware.
1.2 THEMATIC ORGANIZATION
Many different middleware technologies are available today, among them CORBA (Common Object Request Broker Architecture) and Web Services. In this book we emphasize the concepts for designing and implementing a middleware platform, and the concrete technology is only of a secondary nature. Although Web Services have gained momentum in recent years, we feel that the CORBA specification is still more mature. But the principles explained in this book are universal and apply to all middleware platforms.
There are many advantages to using COCRBA as an underlying basis. For one thing, it allows us to base our examples and explanations on an established industry standard for which numerous products are available. The freely available CORBA specification can be referred to as secondary literature. Also numerous excellent books have been written on CORBA. Finally, knowledge about the internal processes of CORBA platforms is helpful for developing a general understanding about CORBA, and this comes in handy for anyone working with commercial CORBA products.
All source code in this book as well as Mico itself is completely implemented in C++. An elementary knowledge of the programming language C++ is therefore essential for understanding the examples. Some of the introductory examples are also presented in Java. We regard a programming language merely as an aid in implementing the concepts we introduce. The reader will find it a useful exercise to map the concepts presented in the book to other programming languages. Along with having C++ experience, the reader will find that experience with a development environment under UNIX or Windows is necessary for understanding the programs presented in this book.
1.3 TARGET GROUP
We have aimed this book at students who are at an advanced stage of their studies and at professional developers who want to use middleware for their work. Different interests motivate these two groups. Students can use this book as a textbook to help them to learn how middleware platforms function. This book has been successfully used in a graduate class on distributed systems, in which the students had to write a distributed application based on CORBA using C++ and Java. As part of their project, the students had to use μORB (described in Chapter 4) to get first-hand experience with the inner workings of a middleware platform. The material used for the term project are available online (see Section 1.5).
The relevance of the topics covered in this book to professional programmers is linked to the success of Mico as an Open Source project. Open Source has become respectable in the commercial world, and more and more companies are now making use of the benefits it offers. The availability of source code enables Open Source to be adapted to meet specific needs—something that comparable commercial products cannot offer. This book lays the foundations for an understanding of the internal workings of Mico—a prerequisite for such adaptations.
1.4 CHAPTER OVERVIEWS
This book is logically structured in several parts. The first part, which includes Chapters 2 through 4, covers the basics and presents an overview of middleware in general and CORBA in particular. All the discussions in these chapters are independent of Mico. The second part, which includes Chapters 5 through 9, then goes into detail about Mico’s design and architecture. Chapter 10 gives a broader view on current and future middleware technologies. The final part of this book is composed of the appendices which serve as a brief Mico user manual. The book is structured so that the chapters can be read in sequence. However, the appendices, which explicitly deal with Mico, can be referenced from the index as a direct information source.
A brief overview of the content of each of the chapters follows:
Chapter 2 introduces the basic concepts required for understanding the content of the book. It also presents a simple sample application to help clarify some of the concepts.
Chapter 3 presents a brief introduction to CORBA. The sample application presented in the previous chapter is implemented on a distributed basis through the use of CORBA.
Chapter 4 describes the μORB. The μORB is a mini ORB that is used to present some components of CORBA-based middleware in a compact form.
Chapter 5 is the first of five chapters that deal solely with the internal details of Mico. This chapter presents the microkernel architecture of Mico’s Object Request Broker.
Chapter 6 describes the implementation of CORBA’s interoperability framework. In Mico the implementation of IIOP is based on the microkernel approach presented in the previous chapter.
Chapter 7 describes the binding of object implementations to the Object Request Broker on the server side. The CORBA standard introduces its own component, called an object adapter.
Chapter 8 discusses the interface between caller and Object Request Broker— this time from the client side. The invocation adapters responsible for this task are likewise integrated in the ORB through the microkernel approach.
Chapter 9 introduces the architecture of Mico’s IDL compiler and describes how IDL compilers and interface repositories are closely related.
Chapter 10 concludes this book by giving an overview of emerging technologies in the middleware domain. We also briefly touch on the main differences between CORBA and Web Services.
In addition to the chapters listed, the book includes extensive appendices with further information about Mico:
Appendix A provides some information on the installation process for Mico.
Appendix B provides an implementation overview of Mico. It discusses some Mico-specific details such as Mico’s Interface Repository and Implementation Repository.
Appendix C gives further information on some specific internals of Mico, including how to integrate new transport mechanisms.
Appendix D reproduces the complete source code for the CORBA sample application presented in Chapter 3.
1.5 ANCILLARY MATERIALS
As an Open Source project, Mico boasts its own home page, which you can find at www.mico.org. There you will find the current source code for Mico along with other information about this particular implementation in the form of a user handbook, frequently asked questions (FAQ), and an archive of mailing lists.
Another thing we have done is to set up a special Web page specifically for this book. You can access this Web page at www.mico.org/textbook. In addition to updated references, the Web page includes the complete source code for all sample programs discussed in this book. You will also find a programming project based on μORB and Mico that can be used as a term project for a graduate-level course.