Introduction Features Audience Organisation Tracks Differences Background Information

Organization

The book is divided into four parts. Each part presents the issues involved in object-oriented programming from a different perspective, which may be characterized respectively as software engineering and design, languages and system development, abstract data types and polymorphism, and applications and frameworks.

Part I: Designing Object-Oriented Systems

1. Introduction:

This chapter gives an introduction to the area of object-oriented software development. It gives a global view on the object-oriented life cycle and discusses object orientation as a paradigm of programming. It discusses a number of trends and technologies that have come into the focus of public attention and indicates their relevance to `object-orientation'.

2. Idioms and patterns*:

This chapter introduces idioms and design patterns as means to capture recurrent structures and solutions in object-oriented programming. It distinguishes between idioms as solutions tied to a particular language and patterns which are the product of rational design. This chapter contains numerous examples, in Java.

3. Software engineering perspectives:

This chapter discusses the process of software development and the various modeling perspectives involved in analysis and design. It explains the issues involved in arriving at a proper object model and introduces the notion of contract as an instrument to capture the relationships between object classes. In addition, it proposes a method for validation and testing based on contracts.

4. Application development*:

In this chapter we develop a complete application and discuss the issues involved in its design and realization. It presents guidelines for (individual) class design, and gives an example of how to derive an implementation from a formal specification.

Part II: Object-Oriented Languages and Systems

5. Object-oriented languages:

This chapter provides a comparison between object-oriented languages, including Smalltalk, Eiffel, C++ and Java. It further discusses a number of alternative languages, included Self and Javascript, each with their own object model, and treats issues such as dynamic inheritance by delegation. synchronous active objects, and meta-level architectures for class-based languages.

6. Component technology*:

This chapter discusses the relation between component technology and distributed object technology, and will give a brief overview of the solutions that are available on the market, including Microsoft COM/ActiveX, JavaBeans, Java RMI and CORBA. It also presents a simple workgroup application and an example of integrating CORBA with an existing software library.

7. Software architecture*:

In this chapter we explore how software architecture affects design and implementation. It treats design patterns for distributed object systems, and looks at the technical issues involved in developing multi-lingual systems. As an example we show how to employ the native interface to embed an existing framework in Java.

Part III: Foundations of Object-Oriented Modeling

8. Abstract data types:

This chapter considers the notion of abstract data types from the perspective of types as constraints. It presents an algebraic approach in which objects may be characterized as algebras. Further, it explains the difference between the classical approach of realizing abstract data types in procedural languages and the realization of abstract data types in object-oriented languages. The implications of a more pragmatic conception of types is also discussed.

9. Polymorphism:

This chapter discusses inheritance from a declarative perspective, and gives a precise characterization of the subtype relation. It further discusses the various flavors of polymorphism and presents a type theoretical treatment of genericity and overloading. Also, type calculi that capture data hiding and self-reference are given. These insights are related to the realization of polymorphism in Eiffel, C++ and Java.

10. Behavioral refinement:

This chapter extends the notion of types as constraints to include behavioral properties. It presents an assertion logic for the verification of programs and discusses the operational model underlying the verification of object behavior based on traces. It further gives precise guidelines to determine whether classes that are syntactical subtypes satisfy the behavioral refinement relation. Finally, an overview is given of formal approaches to characterize the behavior of collections of objects.

Part IV: Object-Oriented Application Frameworks

11. Business process redesign*:

In this chapter we look at the opportunities IT offers in (re)designing business processes. In particular, we look at (object-oriented) simulation as a means to capture the logistical aspects involved in business process modeling, and in addition we look at how simulation models can be made available as to allow decision making, by deploying visualisation and dissemination over the Web.

12. Web applications*:

In this chapter we look at how object technology may be applied to the Web. We will look both at client-side extensions and server-side solutions. In particular, we look at systems that employ CORBA in addition to other Web technologies. We also briefly look at another new trend in computing, intelligent, mobile agents, and we argue that agents are a direct derivation from object technology.

Appendices

The appendices contain brief tutorials on Smalltalk, Eiffel, C++, Java and the distributed logic programming language DLP. They also contain an overview of UML, an overview of CORBA IDL, a tutorial on programming CORBA applications with Orbacus, and suggestions for small and medium-term projects.