 |
Design Patterns: Elements of Reusable Object-Oriented Software by Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides
Book Summary InformationAuthor: Erich Gamma, John Vlissides, Ralph Johnson, Richard Helm Edition: Hardcover Audio: English (Unknown); English (Original Language); English (Published) Published: 1994-11-10 ISBN: 0201633612 Number of pages: 416 Publisher: Addison-Wesley Professional Accessories:
Book Reviews of Design Patterns: Elements of Reusable Object-Oriented SoftwareBook Review: Making Order out of Best Practice Summary: 5 Stars
This is one of the small selection of books that belongs within arm's reach of any OO developer's desk. Example code is written in C++, but the patterns are applicable to any fully-featured object-oriented language, which includes C++, Java, Smalltalk and C#, just to name a few salient examples. It catalogues the 23 now-classic solutions to object-oriented software design problems whose utility and generality have proven them worthy of a pattern name.
What may be less widely appreciated in the software world is that this book has influenced a more general trend towards pattern languages. This may illustrate better than anything else a central truth about the book - that it catalogues and describes existing best practice. If you have done OO design work for any length of time, you will probably have come up with a few of the patterns spontaneously, as they represent the solutions to problems that tend to arise routinely during the designer's work. This is not to say that you don't need the book - quite the opposite. Firstly, there are 23 of these patterns, and it is a designer of rare talent who has spontaneously come up with all 23. Secondly, this is rather a finished documentation of rather finished solutions, and its version of any given solution will help you avoid many pitfalls. Thirdly, we all need reference material from time to time, and this is a central foundational reference work of object-oriented design.
The examples are catalogued in a consistent and clear fashion beginning with "Intent" - why you would need it - and "Also Known As", since these patterns had already acquired names in the wild and this book seeks to organise them into a common language rather than to generate new material. "Motivation" describes the purpose of the solution in more detail, sometimes with a concrete example documented in UML and sometimes with diagrammatic portrayals of GUI goals and the like. Next comes "Applicability", which defines in bullet-point list form the circumstances in which you might want to use the pattern. "Structure" is documented in UML, now the industry standard diagramming language for object-oriented structure. "Participants" describes the object types, or classes, which go to make up the pattern. "Collaborations" describes in text form how the various participants work together and for what guarantees they rely on one another. "Consequences" describes the advantages and penalties for the design of using the pattern in question - yes, there are usually some penalties! Implementation is usually the most substantial sub-section and includes an example implementation programmed in C++ and detailed discussion of the concrete design decisions. "Known Uses" documents some examples of the use of the pattern that have been captured in the wild, while "Related Patterns" closes each section by documenting other patterns which are either interchangeable or interoperable with the pattern.
The patterns themselves are grouped into Creational, Structural and Behavioural categories. Usefully, the inside covers are printed with an index of the patterns in the three groups described above, and at the back a Relationship Diagram showing the links between the different patterns and examples of the graphical notation indicating how Class Diagrams, Object Diagrams and Interaction Diagrams are laid out. All three of these can be studied in more depth in a UML primer such as UML Distilled: A Brief Guide to the Standard Object Modelling Language (3rd Edition).
All-in-all, the book is a masterpiece of clarity in software literature and a true classic, if a little dry. Most of us use a few of the patterns routinely, even unthinkingly, a few occasionally, and a bunch of them not at all. I encountered the Visitor pattern while working for an Investment Banking team and found I hardly knew it, while I used the Decorator Pattern almost to excess in my own HeadCase application. Other books actually warn against "Singeltonitis", so overused has the pattern become. This volume is agnostic, merely documenting how to do it and what the pros and cons are. It is also a standard work, so an OO designer can be expected to be familiar with at least some of it at interview. It would seem unwise to do without a copy ready to hand.
Correction: As a commentator has pointed out, technically the diagrams are in OMT, having been published prior to the standardisation of UML. (Which is still growing to this day.) As OMT is succeeded and subsumed by UML, strictly the diagrams are both OMT and UML, but the academic detail deserves to stand corrected, even if it would be of little interest to any serious professional using the book for practical reference. At any rate, all the diagram types used can be found in any standard work on UML.
Summary of Design Patterns: Elements of Reusable Object-Oriented Software* Capturing a wealth of experience about the design of object-oriented software, four top-notch designers present a catalog of simple and succinct solutions to commonly occurring design problems. Previously undocumented, these 23 patterns allow designers to create more flexible, elegant, and ultimately reusable designs without having to rediscover the design solutions themselves. * The authors begin by describing what patterns are and how they can help you design object-oriented software. They then go on to systematically name, explain, evaluate, and catalog recurring designs in object-oriented systems. With Design Patterns as your guide, you will learn how these important patterns fit into the software development process, and how you can leverage them to solve your own design problems most efficiently. Design Patterns is a modern classic in the literature of object-oriented development, offering timeless and elegant solutions to common problems in software design. It describes patterns for managing object creation, composing objects into larger structures, and coordinating control flow between objects. The book provides numerous examples where using composition rather than inheritance can improve the reusability and flexibility of code. Note, though, that it's not a tutorial but a catalog that you can use to find an object-oriented design pattern that's appropriate for the needs of your particular application--a selection for virtuoso programmers who appreciate (or require) consistent, well-engineered object-oriented designs.
|
 |
CMMIŽ: Guidelines for Process Integration and Product Improvement (2nd Edition)by Mary Beth Chrissis, Mike Konrad, Sandra Shrum Addison-Wesley Professional; Published: 2006-11-23; Hardcover; BookBest price: $8.57Price in other shops: $69.99
An Assessment of Space Shuttle Flight Software Development Processesby Committee for Review of Oversight Mechanisms for Space Shuttle Flight Software Processes, Aeronautics and Space Engineering Board, National Research Council National Academies Press; Published: 1993-01-01; Paperback; BookBest price: $35.00
Automating Software DesignThe MIT Press; Published: 1991-12-26; Paperback; BookPrice in other shops: $35.00
Pattern-Oriented Analysis and Design: Composing Patterns to Design Software Systemsby Sherif M. Yacoub, Hany H. Ammar, Sherif Yacoub, Hany Ammar Addison-Wesley Professional; Published: 2003-08-15; Hardcover; BookBest price: $64.90
Delphi Component Designby Danny Thorpe Addison-Wesley (C); Published: 1996-12; Paperback; BookPrice in other shops: $36.95
Compiler Design (International Computer Science Series)by Renhard Wilhelm, Dieter Maurer Longman Group United Kingdom; Published: 1995-03-01; Hardcover; BookBest price: $131.28
Mastering the Requirements Processby Suzanne Robertson, James Robertson Addison-Wesley Professional; Published: 1999-08-12; Hardcover; BookBest price: $9.18Price in other shops: $52.99
Software Design and Data Structures in Turbo PASCALby Elliot B. Koffman, Bruce B. Maxim Addison Wesley Publishing Company; Published: 2000-06; Paperback; BookBest price: $161.42
An Introduction to Algorithm Design and Structured Programmingby Thomas A. Reed Prentice Hall; Published: 1988-10; Hardcover; BookBest price: $23.16Price in other shops: $38.60
The Design Development and Evaluation of Instructional Softwareby Michael J. Hannafin, Kyle L. Peck Mac; Published: 1988; Paperback; BookBest price: $22.62Price in other shops: $100.40
|
UML Distilled: A Brief Guide to the Standard Object Modeling Language (3rd Edition)by Martin Fowler Addison-Wesley Professional; Published: 2003-09-25; Paperback; BookBest price: $25.00Price in other shops: $49.99
Patterns of Enterprise Application Architectureby Martin Fowler Addison-Wesley Professional; Published: 2002-11-15; Hardcover; BookBest price: $41.50Price in other shops: $69.99
Effective C++: 55 Specific Ways to Improve Your Programs and Designs (3rd Edition)by Scott Meyers Addison-Wesley Professional; Published: 2005-05-22; Paperback; BookBest price: $28.00Price in other shops: $49.99
The Mythical Man-Month: Essays on Software Engineering, Anniversary Edition (2nd Edition)by Frederick P. Brooks Addison-Wesley Professional; Published: 1995-08-12; Paperback; BookBest price: $22.00Price in other shops: $39.99
Effective Java (2nd Edition)by Joshua Bloch Addison-Wesley; Published: 2008-05-28; Paperback; BookBest price: $29.95Price in other shops: $54.99
Refactoring: Improving the Design of Existing Codeby Martin Fowler, Kent Beck, John Brant, William Opdyke, Don Roberts Addison-Wesley Professional; Published: 1999-07-08; Hardcover; BookBest price: $25.00Price in other shops: $64.99
Clean Code: A Handbook of Agile Software Craftsmanshipby Robert C. Martin Prentice Hall; Published: 2008-08-11; Paperback; BookBest price: $33.13Price in other shops: $49.99
The Pragmatic Programmer: From Journeyman to Masterby Andrew Hunt, David Thomas Addison-Wesley Professional; Published: 1999-10-30; Paperback; BookBest price: $35.25Price in other shops: $49.99
Code Complete: A Practical Handbook of Software Constructionby Steve McConnell Microsoft; Microsoft Press; Published: 2004-07-07; Paperback; BookBest price: $24.99Price in other shops: $49.99
Head First Design Patternsby Elisabeth Freeman, Eric Freeman, Bert Bates, Kathy Sierra, Elisabeth Robson O'Reilly Media; Published: 2004-11-01; Paperback; BookBest price: $25.00Price in other shops: $49.99
|