Design Patterns and Contracts - Softcover

Jezequel, Jean-Marc; Train, Michel; Mingins, Christine

Softcover

ISBN 10: 0201309599 ISBN 13: 9780201309591

Publisher: Addison Wesley Longman, 1999

Synopsis

Provides a guide to building design patterns to solve software engineering problems. Offers optimized solutions to common design problems, and provides a base for building reusable software. Softcover. DLC: Computer software-Development.

About this title

About the Author

Jean-Marc Jézéquel is a research manager in the Irisa Lab for the Centre National de la Recherche Scientifique. His areas of expertise include software engineering and object-oriented technologies for telecommunications and distributed computers. He is the author of Object-Oriented Software Engineering with Eiffel (Addison-Wesley) and has written numerous articles for various international publications.

Michel Train is part of the software architecture team in Lucent Rennes, where he designs new releases of a switch, based on object-oriented technology, that includes a significant use of patterns. Previously, at Transpac, he worked on network management software, as well as artificial intelligence applied to network management and information retrieval. For France Telecom he worked on user-interface software design, building a tool to produce user-interface code from an applicative model and collaboration patterns.

Christine Mingins is Associate Head of School in the Faculty of Information Technology at Monash University (Australia), where she has led the use of object-oriented methods at undergraduate and postgraduate levels. Her publications span software metrics, reusable components, IT education, analysis and design methods, and management issues. She has been the program chair of TOOLS Pacific, and helped start the Trusted Components Initiative (trusted-components).

0201309599AB04062001

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

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

Excerpt. © Reprinted by permission. All rights reserved.

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.

Edition details

• Publisher: Addison Wesley Longman
• Publication date: 1999
• Language: English
• ISBN 10: 0201309599
• ISBN 13: 9780201309591
• Binding: Paperback
• Edition number: 1
• Number of pages: 368