Design Patterns and Contracts [Paperback]

Jean-Marc Jezequel (Author), Michel Train (Author), Christine Mingins (Author)

Book Description

Publication Date: October 27, 1999

Design Patterns and Contracts is a thought-provoking guide to building design patterns to solve software engineering problems. Design patterns have gained widespread acceptance today because they capture the best practices of software design. Patterns offer optimized solutions to common design problems, reduce complexity by naming and defining abstractions, and provide a base for building reusable software. With Design Patterns and Contracts, object-oriented software practitioners have a new resource to help them further exploit the power of design patterns. This book introduces the fundamentals of software contracts and illustrates how Design by Contract contributes to the optimal use of design patterns in a quality-oriented software engineering process. The Design by Contract approach to software construction provides a methodological guideline for building systems that are robust, modular, and simple. Readers will find value in the bookis overview of the Object Constraint Language, a precise modeling language that allows Design by Contract to be used with the industry standard Unified Modeling Language (UML). Although written in Eiffel, this book makes an excellent companion for developers who are using languages such as Java and UML. Throughout the book the authors discuss specific implementation issues and provide complete, ready-to-be-compiled examples of the use of each pattern. They introduce design patterns and Design by Contract in the context of software engineering, and show how these tools are used to guide and document system design. 0201309599B04062001

Editorial Reviews

From the Inside Flap

The idea of systematically identifying and documenting design patterns as autonomous entities was born in the late 1980s. It was brought into the mainstream by the Hillside Group, such people as Beck, Ward, Coplien, Booch, Kerth, and Johnson. However, the main event in this emerging field was the 1995 publication of the book Design Patterns: Elements of Reusable Object-Oriented Software (Gamma et al., 1995) by the so-called Gang of Four (GoF): Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides.

Today, design patterns are widely accepted as useful tools for guiding and documenting the design of object-oriented software systems. Design patterns play many roles in the development process. They provide a common vocabulary for design, reduce system complexity by naming and defining abstractions, constitute a base of experience for building reusable software, and act as building blocks from which more complex designs can be built.

Design patterns can be considered reusable microarchitectures that contribute to an overall system architecture. Ideally, they capture the intent behind a design by identifying the component objects, their collaborations, and the distribution of responsibilities. The purpose of this book is to show how this intention can be made explicit, based on the notion of contract. A software contract captures mutual obligations and benefits among stakeholder components--for example, between the client of a service and the suppliers, including subclasses, of that service. Contracts strengthen and deepen interface specifications. Along the lines of abstract data type theory, a common way of specifying software contracts is to use Boolean assertions called pre- and postconditions for each service offered, as well as class invariants for defining general consistency properties. Then the contract reads as follows: The client should ask a supplier for a service only in a state in which the class invariant and the precondition of the service are respected. In return, the supplier promises that the work specified in the postcondition will be done and that the class invariant will still be respected. In this way, rights and obligations of both the client and the supplier are clearly delineated, along with their responsibilities.

This idea, first implemented in the Eiffel language (Meyer, 1992a) under the name Design by Contract, is now available in several other programming languages, such as Java, and even in the Unified Modeling Language (UML) with the Object Constraint Language (OCL) (Warmer and Kleppe, 1999). Like the design pattern idea, the Design by Contract is not tied to any particular language, but we need to choose one for describing concrete examples. We settled on Eiffel because it provides the right paradigms to address the construction of large, high-quality object-oriented software systems and is quite easy to master. This book can thus be used as a GoF's companion for the Eiffel community; however, we believe that this book will also be most useful to people more generally interested in obtaining the greatest benefit from the design patterns ideas in a quality-based software engineering framework. We describe many examples, using the UML notation, and we also explain, in Section C.1, how Design by Contract can be used with Java through the iContract tool (Kramer, 1998).

Part I of this book establishes the framework for using design patterns. Chapter 1 introduces the notion of design patterns and their role in the software life cycle. Chapter 2 outlines the arguments for an optimal use of design patterns in a quality-oriented software engineering process, based on Design by Contract and associated technologies.

The three chapters in Part II explain how the GoF creational, structural, and behavioral patterns can be augmented with contracts. For each of these design patterns, we simply review its name and intent from the GoF book and then discuss specific implementation issues and provide a complete example, ready to be compiled and run, of the use of the pattern in a hypothetical application. Only the most interesting parts of the source code are presented and discussed in this book; the full source code of each example, ready to be compiled and run with a free Eiffel compiler, is available on this book's Web site (see Appendix D for the details).

Part III illustrates how one can build on design patterns to solve interesting software engineering problems. Chapter 6 explains how creational design patterns can be leveraged to simplify software configuration management without impacting on the application's overall performance. Chapter 7 discusses how to combine patterns for building graphical user interfaces.

Finally, the book contains a detailed glossary (Appendix A) of object-oriented design concepts and terminology, pointers to further information on design patterns and Design by Contract (Appendix B) and a discussion of Design by Contract in other languages (Appendix C). Appendix D tells you how to get more information about this book. 0201309599P04062001

From the Back Cover

Design Patterns and Contracts is a thought-provoking guide to building design patterns to solve software engineering problems. Design patterns have gained widespread acceptance today because they capture the best practices of software design. Patterns offer optimized solutions to common design problems, reduce complexity by naming and defining abstractions, and provide a base for building reusable software.

With Design Patterns and Contracts, object-oriented software practitioners have a new resource to help them further exploit the power of design patterns. This book introduces the fundamentals of software contracts and illustrates how Design by Contract contributes to the optimal use of design patterns in a quality-oriented software engineering process. The Design by Contract approach to software construction provides a methodological guideline for building systems that are robust, modular, and simple.

Readers will find value in the bookis overview of the Object Constraint Language, a precise modeling language that allows Design by Contract to be used with the industry standard Unified Modeling Language (UML). Although written in Eiffel, this book makes an excellent companion for developers who are using languages such as Java and UML. Throughout the book the authors discuss specific implementation issues and provide complete, ready-to-be-compiled examples of the use of each pattern. They introduce design patterns and Design by Contract in the context of software engineering, and show how these tools are used to guide and document system design. 0201309599B04062001

See all Editorial Reviews

Product Details

• Paperback: 384 pages
• Publisher: Addison Wesley Longman; 1st edition (October 27, 1999)
• Language: English
• ISBN-10: 0201309599
• ISBN-13: 978-0201309591
• Product Dimensions: 9.1 x 7.3 x 0.7 inches
• Shipping Weight: 1.2 pounds
• Average Customer Review: 3.2 out of 5 stars  See all reviews (5 customer reviews)
• Amazon Best Sellers Rank: #2,836,122 in Books (See Top 100 in Books)

More About the Author

Discover books, learn about writers, read author blogs, and more.

Customer Reviews

Most Helpful Customer Reviews

54 of 58 people found the following review helpful:

5.0 out of 5 stars Design Patterns Brought into Sharp Focus, January 1, 2000

By 

William R. Fowler (Eldorado Springs, CO USA) - See all my reviews
(REAL NAME)   

This review is from: Design Patterns and Contracts (Paperback)

If you have already read the famous 1995 book, Design Patterns, by Gamma, Helm, Johnson, and Vlissides, you will enjoy this excellent sequel tremendously. It brings into sharp focus each of the object-oriented design patterns listed in the 1995 book by giving even more clear and more readable examples. It also adds the vital element of software contract: preconditions which must be met by a client before calling a routine, and postconditions which are guaranteed to be true after a routine completes its work.

If you have not read the 1995 book, don't bother. Buy this one instead. You don't need to have read Design Patterns to get full value out of this newer book.

The book uses the Eiffel programming language for its examples mainly because Eiffel does such a good job supporting contracts. Prospective readers who have closed their minds to anything not centered around Java or C++ will miss a treat if they pass up this book. Eiffel is written using English words. You don't need a language reference manual to read the Eiffel examples. The authors of this book have guided the reader through the Eiffel examples painlessly and do not require any prior contact with the language.

If you do buy a copy of this book, don't miss reading the case study in Chapter 6 on software configuration management. The general concept presented here is extremely valuable to any software developer. The authors kill two birds with one stone: design patterns are illustrated and a very eligant simplification of the software configuration management problem is proposed.

I highly recommend this extremely practical book.

8 of 10 people found the following review helpful:

2.0 out of 5 stars This book is about Eiphel, not Design Patterns., June 2, 2001

By 

Michael (Israel) - See all my reviews

This review is from: Design Patterns and Contracts (Paperback)

If you want to learn about design patterns - don't buy this book! The most of the book is in Eiphel language which is not so easy do understand. To understand the design patterns with the examples of the book is very difficult. I bought this book because of it stars - but it was my big mistake!

3 of 3 people found the following review helpful:

4.0 out of 5 stars A great resource for Design Patterns, August 16, 2001

By 

Brent Fulgham (Ventura, CA United States) - See all my reviews
(REAL NAME)   

This review is from: Design Patterns and Contracts (Paperback)

After reading Jean-Marc Jezequel's excellent first Eiffel book, I was looking for more information on "Design By Contract", and its impacts on real-world projects. Based on the author and subject matter, I immediately ordered "Design Patterns and Contracts."

I was somewhat disappointed with the first section, covering the basics of UML, Design Patterns, and Design by Contract. There are many other references that do a better job of covering these basics. It also had the bland feel of an "Executive Summary" chapter, complete with an overabundance of whitespace, diagrams of questionable value, and concept definitions that would probably have been better off in a glossary.

Things rapidly improve after the first short section. The second part of the book is an excellent resource for the most common design patterns. This section makes a great reference, and I find myself refering to it from time to time for guidance, even when not using Eiffel.

I also greatly enjoyed the third part of this book, which brought the whole discussion into concrete terms by describing several case studies based on the authors' works. This section was very helpful in seeing the design patterns in action.

The one missing piece that would have forced me to give a 5-star rating would have been more discussion of how Design by Contract had a measurable impact on their work. For example, did the use of pre- and post-conditions allow them to find any esoteric bugs that might have gone unnoticed in another implementation language? Did they find that their software was measurably more reliable then systems built using other languages? But these are minor complaints, and can be satisfied through a literature review. This book is an excellent companion volume to your other software design volumes, and is a bargain at its retail price.