Overview

To give an indication of the contents of the book I have included the adapted preface of the 1st edition.

Features of this book

Intended readers

This book may be used as the primary text for a course on OOP or independently as study or reference material. It may be used by the following categories of readers: Naturally, this is not meant to exclude other readers. For instance, researchers may find the book useful for its treatment of foundational issues. Programmers may benefit from the hints and example programs in Java and C++. Another reason for using this book may be its compact representation of already familiar material and the references to other (often research) literature. The book is meant to be self-contained. As prior knowledge, however, a general background in computer science (that is, computer languages and data structures as a minimum) is required.

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 the trends and technologies that have come into the focus of public attention and indicates their relevance to 'object-orientation'. It further presents an overview of the material covered with reference to the literature used and suggestions for further reading.

2. Idioms and Patterns*:

This chapter introduces idioms and design patterns as means to capture recurrent structures and solutions in object-oriented programming. It will distinguish between idioms as solutions tied to a particular language and patterns which are the product of rational design. As an example, a canonical approach to developing concrete data types in C++ is presented.

3. Object-oriented design:

This chapter discusses the process of software development and the various modeling perspectives involved in analysis and design. Included is a brief tutorial on the use of UML. It further 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.

4. Developing an application*:

In this chapter we will develop a complete application and discuss all the issues involved in it's design and realization. Included will be a description of the hush framework that has been used to realize this application.

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 will further discuss a number of alternative languages, included Perl, Self and Javascript, each with their own object model, and will treat issues such as dynamic inheritance by delegation. and meta-level architectures for class-based languages.

6. Distributed Object Technology*:

This chapter gives a detailed introduction to CORBA, including a number of simple examples. It will discuss 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) OpenDoc.

7. Software Architectures*:

In this chapter we will explore how software architecture affects design and implementation. It will treat design patterns for distributed object systems. We will also discuss the requirements for heterogeneous systems and, finally, we will look at the technical issues involved in developing multi-lingual systems. As an example it will be shown 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 will be 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 will look at (object-oriented) simulation as a means to capture the logistical aspects involved in business process modeling, and in addition we will look at how simulation models can be made available as to allow decision making, by deploying visualisation and dissemination over the Web.

12. Web-based applications*:

In this chapter we will 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 will look at systems that employ CORBA in addition to other Web-technologies. We will also briefly look at another new trend in computing, intelligent, mobile agents, and we will argue that agents are a direct derivation from object-technology.

Appendices

The appendix will contain brief tutorials on Smalltalk, Eiffel, C++, Java and the distributed logic programming language DLP. It will also present an overview of UML, a tutorial on programming CORBA applications with Orbix, and sugestions for small and medium term projects.