Instructor's Guide
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.