This book discusses techniques for designing and implementing
object-oriented software based on contracts. It is intended for
students and software developers who are looking for design and 
coding methodologies that will allow them to develop more reliable 
applications.

According to the preface, the design of software with contracts is
“all about adding assertions to object oriented programs.” The
authors spend the 12 chapters of the book expounding on the art of
writing preconditions, postconditions, and invariants, based on six
guiding principles and some basic guidelines. The reader is
encouraged to interact with the book, by putting into practice the
practical, clear, examples that are included. While the technique of
design by contract is oriented toward the design phase of the software
development process, the last part of book discusses the use of
contracts in use case-based analysis.

Chapters 1, 2, and 3 build the foundation for the ideas proposed in
the book, presenting the six principles for design by contract, and
the ways in which these must be applied. Special attention is given to
the definitions of query and command. The two included (and classic) 
examples, the design of a class to manage generic stacks, and of a 
dictionary class, are both simple and complete enough explain the 
authors’ insights.

The example in chapter 4 develops a class for immutable lists to
support contracts in other classes. Chapter 5 makes use of this class
to design, with contracts, a classical linear structure like queue. It
is really interesting to see these common kinds of problems from this
point of view. After reading chapter 5, readers will understand the
concept of “classes to support contracts in other classes.”

Chapter 6 addresses questions related to inheritance and contracts,
and will be useful for people who are writing classes to be used like
superclasses; they will find details about how to make contracts that
are able to be redefined in future implementations. People who are
writing subclasses, in contrast, will learn how to redefine contracts
from superclasses.

Developers not familiar with contracts could confuse design by
contracts with defensive programming; in chapter 8, a comparison is
made between them, including a demonstration of the benefits of
writing contracts. It might have been better if those benefits were
presented at the beginning of the book, as part of clarifying the
concepts.

People working with object-oriented frameworks must pay attention to
chapter 9; it addresses the creation of observer design patterns by
contracts, and demonstrates that design by contracts is applicable to
collaborating classes schemes. There is also a section in this chapter
that discusses frame rules; this further clarifies material presented
in chapter 7, and also introduces the privacy requirements related to
contracts when inheriting classes. Chapter 10 discusses the
verification of precondition fulfillment, based on an example of a
simple counter.

The examples in the book are presented using Unified Modeling Language
(UML) notation, and are based primarily on the Eiffel language,
because it offers native support for contracts. In chapter 11,
however, some examples are developed with Java, making use of a
preprocessor called iContract. Though examples written with Eiffel
aren’t complicated to understand, C++ developers like me will feel
more comfortable looking at Java examples, considering its similarity
to C++, despite the fact that the authors don’t include specific
information about preprocessors for C++ compilers.

The vast experience of the authors in the field of object-oriented
software is an advantage; this is a book made by developers, for
developers. The book could be really useful for people who want to 
explore the possibility of spending extra time on their development 
projects, in return for better designs, documentation, and reliability.