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
- It provides an introduction to object-oriented programming,
covering design, languages, and foundational issues.
It pays attention to issues such as reuse, component technology,
design patterns and in particular the application of object technology
in Web-applications.
- It contains guidelines for developing object-oriented applications.
Apart from practical examples it provides an overview of
development methods as well as an introduction to UML,
the standard for object-oriented modeling.
In particular design patterns will act as a recurrent
theme, or rather as a perspective from which examples
and solutions will be discussed.
- Distributed object technology will be a major theme.
The book provides an introduction to CORBA that allows the student to
gain hands-on experience with developing CORBA applications.
It also provides a discussion of competing technologies,
and in particular it will elucidate the distinction between
component-technology and distributed objects.
Examples in Java and C++ will be included.
-
Another major theme of the book is to establish precisely
the relation between
the guidelines and prescriptions emerging from
software engineering practice
on the one hand, and
the constraints and insights originating theoretical research.
In the book attention will be paid both to foundational issues
as well as the pragmatical solutions the designers of object-oriented
languages have chosen to realize their ideas.
- Many of the notions introduced and problems discussed are clarified
by short programs, mostly in Java some in C++.
The examples cover GUI development,
business process reengineering, Netscape browser plugins
and Web applications.
No extensive knowledge
of the programming languages used is required since a brief tutorial
on a number of object-oriented programming languages, including C++,
Smalltalk, Eiffel and Java, is given in the appendix.
- The material is organized around slides.
The slides occur in the text in reduced format, but are also available
for use on an overhead projector.
Each slide captures some important notion or concept
which is explained and commented upon in the accompanying text.
An Instructor's Guide is available that provides hints
for presenting the slides
and answers to the questions posed at the end of each chapter.
-
The entire book, including the software from the examples and
the Instructor's Guide is available electronically,
on the accompanying CDROM as well as on the Internet.
The electronic version contains links to other material on
the Internet. The electronic version may be accessed
also in slide mode that allows for
presenting the material in a classroom equipped with
a beamer,
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:
- students -- as a textbook or as supplementary reading
for research or project papers.
- software engineers -- as (another) text on object-oriented programming.
- professional teachers -- as ready-made material for a course
on object-oriented programming.
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.