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
Sprache
Verlagsort
Verlagsgruppe
Zielgruppe
Für höhere Schule und Studium
Maße
Höhe: 234 mm
Breite: 186 mm
Dicke: 17 mm
Gewicht
ISBN-13
978-0-201-30959-1 (9780201309591)
Copyright in bibliographic data and cover images is held by Nielsen Book Services Limited or by the publishers or by their respective licensors: all rights reserved.
Schweitzer Klassifikation
Jean-Marc Jezequel 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 (www.trusted-components.org).
0201309599AB04062001
Preface.
I. DESIGN PATTERNS IN A SOFTWARE ENGINEERING CONTEXT.
1. A Software Engineering Perspective.
Introduction to Design Patterns.
Key Points.
Understanding the Notion of Design Patterns.
An Example: The Observer Pattern.
Describing Design Patterns.
Notions Related to Patterns.
Design Patterns and Frameworks.
Design Patterns in the Software Life Cycle.
A Software Engineering Process.
Modeling Problems and Solutions with UML.
From Problems to Solutions with Patterns.
Toward Formalizing a Pattern-Based Software Process.
The Common Phases.
Two Levels of Decision.
Synthesis and Transformations.
2. Object-Oriented Design with Contracts.
Supporting Design Patterns with Contracts.
Choice of a Language.
Covariant Typing.
Controlled Multiple Inheritance.
Supporting OO Design.
Encapsulation and Information Hiding.
Modularity and Coupling.
Idioms for Implementing Design Patterns.
Accessing the Original Version of a Redefined Feature.
Implementing Inheritance and Delegation.
Class Variables.
Finalization.
Low Complexity of Routines.
Command-Query Distinction.
Dealing with Optional Behaviors.
Documenting the Use of Design Patterns.
Importance of Documentation.
Modeling Pattern Roles with Inheritance.
Documenting the Use of Patterns with the Indexing Clause.
Conclusion.
II. GoF DESIGN PATTERNS WITH CONTRACTS.
3. Creational Patterns.
The Maze Example.
Creating Objects in Eiffel.
Using Creational Design Patterns.
Abstract Factory (GoF 87).
Builder (GoF 97).
Factory Method (GoF 107).
Prototype (GoF 117).
Singleton (GoF 127).
4. Structural Patterns.
Adapter (GoF 139).
Bridge (GoF 151).
Composite (GoF 163).
Decorator (GoF 175).
Facade (GoF 185).
Flyweight (GoF 195).
Proxy.
5. Behavioral Patterns.
Chain of Responsibility (GoF 223).
Command (GoF 233).
Interpreter (GoF 243).
Iterator (GoF 257).
Mediator (GoF 273).
Memento (GoF 283).
Observer (GoF 293).
State (GoF 305).
Strategy (GoF 315).
Template Method (GoF 325).
Visitor (GoF 331).
III. BUILDING ON DESIGN PATTERNS.
6. Application to Software Configuration Management.
Introduction.
Software Configuration Management.
Variants in Software Systems.
Traditional Solutions.
Using SCM Tools.
Case Study: The Mercure Software System.
Object-Oriented Modeling of Variants.
Applying Creational Design Patterns.
Compilation Technology.
Principle of Type Inference and Code Specialization.
The SmallEiffel Compiler.
Living and Dead Code in SmallEiffel.
Specialized Code Generation in SmallEiffel.
Performance Results.
Experimental Conditions.
Compilation.
Memory Footprint and Runtime Performance.
Discussion.
Bibliographic Notes.
Conclusion.
7. Combining Patterns for Building User Interfaces.
Problems and Strategies.
Building a Model.
The Interface Builder Approach.
Modal or Nonmodal Interaction: Responsibility versus Forbidding.
A Consistent Interface from Uniform Mechanisms.
Models and Designs.
Two Worlds and a Bridge: From Application to Interface.
The Observer: Always the Same; Always Different.
Graphics Creation and Binding.
Keeping Track of Model Path Changes.
Triggering Actions: Passing Information Around.
Combining and Grouping.
Introducing Control: How to Stay Generic.
Generating or Reusing: The Limits of Genericity.
Analysis and Remarks.
Exposing Properties for Further Uses.
Reifying Collaborations.
Designing Components; Using Connection Protocols.
Performance Issues.
Leaving Room for Evolution.
A. Glossary.
B. Design Pattern and Design by Contract Pointers.
Sources of Information.
Frequently Asked Questions (FAQ) (with Answers).
Mailing Lists.
World Wide Web.
USENET.
Software Resources.
SmallEiffel.
Interactive Software Engineering Inc.
Halstenbach ACT GmbH.
Object Tools Inc.
C Design by Contract in Other Languages.
Design by Contract in Java.
The iContract Tool.
A Simple Example.
Design by Contract in UML.
Introduction to the OCL.
A Simple Example.
D. More Information about This Book.
Bibliography.
Index. 0201309599T04062001
