ISBN-10:
0201633612
ISBN-13:
9780201633610
Pub. Date:
11/14/1994
Publisher:
Addison-Wesley
Design Patterns: Elements of Reusable Object-Oriented Software / Edition 1

Design Patterns: Elements of Reusable Object-Oriented Software / Edition 1

Current price is , Original price is $59.99. You

Temporarily Out of Stock Online

Please check back later for updated availability.

Product Details

ISBN-13: 9780201633610
Publisher: Addison-Wesley
Publication date: 11/14/1994
Series: Addison-Wesley Professional Computing Series
Edition description: New Edition
Pages: 416
Sales rank: 126,639
Product dimensions: 7.70(w) x 9.55(h) x 1.10(d)

About the Author

Dr. Erich Gamma is technical director at the Software Technology Center of Object Technology International in Zurich, Switzerland. Dr. Richard Helm is a member of the Object Technology Practice Group in the IBM Consulting Group in Sydney, Australia. Dr. Ralph Johnson is a faculty member at the University of Illinois at Urbana-Champaign's Computer Science Department.

John Vlissides is a member of the research staff at the IBM T. J. Watson Research Center in Hawthorne, New York. He has practiced object-oriented technology for more than a decade as a designer, implementer, researcher, lecturer, and consultant. In addition to co-authoring Design Patterns: Elements of Reusable Object-Oriented Software, he is co-editor of the book Pattern Languages of Program Design 2 (both from Addison-Wesley). He and the other co-authors of Design Patterns are recipients of the 1998 Dr. Dobb's Journal Excellence in Programming Award.



0201633612AB09122003

Read an Excerpt

This book isn't an introduction to object-oriented technology or design. Many books already do a good job of that. This book assumes you are reasonably proficient in at least one object-oriented programming language, and you should have some experience in object-oriented design as well. You definitely shouldn't have to rush to the nearest dictionary the moment we mention "types" and"polymorphism," or "interface" as opposed to "implementation" inheritance.

On the other hand, this isn't an advanced technical treatise either. It's a book of design patterns that describes simple and elegant solutions to specific problems in object-oriented software design. Design patterns capture solutions that have developed and evolved over time. Hence they aren't the designs people They reflect untold redesign and recoding as developers have struggled for greater reuse and flexibility in their software.Design patterns capture these solutions in a succinct and easily applied form.

The design patterns require neither unusual language features nor amazing programming tricks with which to astound your friends and managers. All can be implemented in standard object-oriented languages, though they might take a little more work than ad hoc solutions. But the extra effort invariably pays dividends in increased flexibility and reusability.

Once you understand the design patterns and have had an "Aha!" (and not just a "Huh?") experience with them, you won't ever think about object-oriented design in the same way. You'll have insights that can make your own designs more flexible, modular, reusable, and understandable - which is why you're interested in object-oriented technology in the first place, right?

A word of warning and encouragement: Don't worry if you don't understand this book completely on the first reading. We didn't understand it all on the first writing! Remember that this isn't a book to read once and put on a shelf. We hope you'll find yourself referring to it again and again for design insights and for inspiration.

This book has had a long gestation. It has seen four countries, three of its authors' marriages, and the birth of two (unrelated) offspring.Many people have had a part in its development. Special thanks are due Bruce Andersen, Kent Beck, and Andre Weinand for their inspiration and advice. We also thank those who reviewed drafts of the manuscript: Roger Bielefeld, Grady Booch, Tom Cargill, Marshall Cline, Ralph Hyre, Brian Kernighan, Thomas Laliberty, Mark Lorenz, Arthur Riel, Doug Schmidt, Clovis Tondo, Steve Vinoski, and Rebecca Wirfs-Brock. We are also grateful to the team at Addison-Wesley for their help and patience: Kate Habib, Tiffany Moore, Lisa Raffaele, Pradeepa Siva, and John Wait. Special thanks to Carl Kessler, Danny Sabbah, and Mark Wegman at IBM Research for their unflagging support of this work.

Last but certainly not least, we thank everyone on the Internet and points beyond who commented on versions of the patterns, offered encouraging words, and told us that what we were doing was worthwhile. These people include but are not limited to Ran Alexander, Jon Avotins, Steve Berczuk, Julian Berdych, Matthias Bohlen, John Brant, Allan Clarke, Paul Chisholm, Jens Coldewey, Dave Collins, Jim Coplien, Don Dwiggins, Gabriele Elia, Doug Felt, Brian Foote, Denis Fortin, Ward Harold, Hermann Hueni, Nayeem Islam, Bikramjit Kalra, Paul Keefer, Thomas Kofler, Doug Lea, Dan LaLiberte, James Long, Ann Louise Luu, Pundi Madhavan, Brian Marick, Robert Martin, Dave McComb, Carl McConnell, Christine Mingins, Hanspeter Mossenbock, Eric Newton, Marianne Ozcan, Roxsan Payette, Larry Podmolik, George Radin, Sita Ramakrishnan, Russ Ramirez, Dirk Riehle, Bryan Rosenburg, Aamod Sane, Duri Schmidt, Robert Seidl, Xin Shu, and Bill Walker.

We don't consider this collection of design patterns complete and static; it's more a recording of our current thoughts on design. We welcome comments on it, whether criticisms of our examples, references and known uses we've missed, or design patterns we should have included. You can write us care of Addison-Wesley, or send electronic mail to design-patterns@cs.uiuc.edu. You can also obtain softcopy for the code in the Sample Code sections by sending the message "send design pattern source" to design-patterns-source@cs.uiuc.edu.

Mountain View, California - E.G.
Montreal, Quebec - R.H.
Urbana, Illinois - R.J.
Hawthorne, New York - J.V.

August 1994

Table of Contents



Preface.


Foreword.


Guide to Readers.


1. Introduction.

What Is a Design Pattern?

Design Patterns in Smalltalk MVC.

Describing Design Patterns.

The Catalog of Design Patterns.

Organizing the Catalog.

How Design Patterns Solve Design Problems.

How to Select a Design Pattern.

How to Use a Design Pattern.



2. A Case Study: Designing a Document Editor.

Design Problems.

Document Structure.

Formatting.

Embellishing the User Interface.

Supporting Multiple Look-and-Feel Standards.

Supporting Multiple Window Systems.

User Operations.

Spelling Checking and Hyphenation.

Summary.



Design Pattern Catalog.


3. Creational Patterns.

Abstract Factory.

Builder.

Factory Method.

Prototype.

Singleton.

Discussion of Creational Patterns.



4. Structural Pattern.

Adapter.

Bridge.

Composite.

Decorator.

Facade.

Flyweight.

Proxy.

Discussion of Structural Patterns.



5. Behavioral Patterns.

Chain of Responsibility.

Command.

Interpreter.

Iterator.

Mediator.

Memento.

Observer.

State.

Strategy.

Template Method.

Visitor.

Discussion of Behavioral Patterns.



6. Conclusion.

What to Expect from Design Patterns.

A Brief History.

The Pattern Community.

An Invitation.

A Parting Thought.



Appendix A: Glossary.


Appendix B: Guide to Notation.

Class Diagram.

Object Diagram.

Interaction Diagram.



Appendix C: Foundation Classes.

List.

Iterator.

ListIterator.

Point.

Rect.



Bibliography.


Index.

Preface

This book isn't an introduction to object-oriented technology or design. Many books already do a good job of that. This book assumes you are reasonably proficient in at least one object-oriented programming language, and you should have some experience in object-oriented design as well. You definitely shouldn't have to rush to the nearest dictionary the moment we mention "types" and"polymorphism," or "interface" as opposed to "implementation" inheritance.

On the other hand, this isn't an advanced technical treatise either. It's a book of design patterns that describes simple and elegant solutions to specific problems in object-oriented software design. Design patterns capture solutions that have developed and evolved over time. Hence they aren't the designs people They reflect untold redesign and recoding as developers have struggled for greater reuse and flexibility in their software.Design patterns capture these solutions in a succinct and easily applied form.

The design patterns require neither unusual language features nor amazing programming tricks with which to astound your friends and managers. All can be implemented in standard object-oriented languages, though they might take a little more work than ad hoc solutions. But the extra effort invariably pays dividends in increased flexibility and reusability.

Once you understand the design patterns and have had an "Aha!" (and not just a "Huh?") experience with them, you won't ever think about object-oriented design in the same way. You'll have insights that can make your own designs more flexible, modular, reusable, and understandable - which is why you're interested in object-oriented technology in the first place, right?

A word of warning and encouragement: Don't worry if you don't understand this book completely on the first reading. We didn't understand it all on the first writing! Remember that this isn't a book to read once and put on a shelf. We hope you'll find yourself referring to it again and again for design insights and for inspiration.

This book has had a long gestation. It has seen four countries, three of its authors' marriages, and the birth of two (unrelated) offspring.Many people have had a part in its development. Special thanks are due Bruce Andersen, Kent Beck, and Andre Weinand for their inspiration and advice. We also thank those who reviewed drafts of the manuscript: Roger Bielefeld, Grady Booch, Tom Cargill, Marshall Cline, Ralph Hyre, Brian Kernighan, Thomas Laliberty, Mark Lorenz, Arthur Riel, Doug Schmidt, Clovis Tondo, Steve Vinoski, and Rebecca Wirfs-Brock. We are also grateful to the team at Addison-Wesley for their help and patience: Kate Habib, Tiffany Moore, Lisa Raffaele, Pradeepa Siva, and John Wait. Special thanks to Carl Kessler, Danny Sabbah, and Mark Wegman at IBM Research for their unflagging support of this work.

Last but certainly not least, we thank everyone on the Internet and points beyond who commented on versions of the patterns, offered encouraging words, and told us that what we were doing was worthwhile. These people include but are not limited to Ran Alexander, Jon Avotins, Steve Berczuk, Julian Berdych, Matthias Bohlen, John Brant, Allan Clarke, Paul Chisholm, Jens Coldewey, Dave Collins, Jim Coplien, Don Dwiggins, Gabriele Elia, Doug Felt, Brian Foote, Denis Fortin, Ward Harold, Hermann Hueni, Nayeem Islam, Bikramjit Kalra, Paul Keefer, Thomas Kofler, Doug Lea, Dan LaLiberte, James Long, Ann Louise Luu, Pundi Madhavan, Brian Marick, Robert Martin, Dave McComb, Carl McConnell, Christine Mingins, Hanspeter Mossenbock, Eric Newton, Marianne Ozcan, Roxsan Payette, Larry Podmolik, George Radin, Sita Ramakrishnan, Russ Ramirez, Dirk Riehle, Bryan Rosenburg, Aamod Sane, Duri Schmidt, Robert Seidl, Xin Shu, and Bill Walker.

We don't consider this collection of design patterns complete and static; it's more a recording of our current thoughts on design. We welcome comments on it, whether criticisms of our examples, references and known uses we've missed, or design patterns we should have included. You can write us care of Addison-Wesley, or send electronic mail to design-patterns@cs.uiuc.edu. You can also obtain softcopy for the code in the Sample Code sections by sending the message "send design pattern source" to design-patterns-source@cs.uiuc.edu.

Mountain View, California - E.G.
Montreal, Quebec - R.H.
Urbana, Illinois - R.J.
Hawthorne, New York - J.V.

August 1994


0201633612P04062001

Customer Reviews

Most Helpful Customer Reviews

See All Customer Reviews

Design Patterns: Elements of Reusable Object-Oriented Software 4 out of 5 based on 0 ratings. 17 reviews.
Guest More than 1 year ago
In a nutshell, if you've never had a design patterns book before, this is a great start. It is admitadly an introduction to the topic. I desire more knowledge of real-time design patterns which this book does not specify, but this book gives one the firm grounding required to move onto other, more complex topics such as real-time design patterns.
Guest More than 1 year ago
This is the sort of book that you browse, put on a shelf and forget about for half a year. Then you come on a really tough problem, pull it down and save yourself many, many hours of trial and error.
ztutz on LibraryThing 10 months ago
Category theory lite for computer programmers.This book seemed profound when it came out, but has not panned out as a religion. As an isolated analysis technique, it is a great thing; trying to take it further is questionable.
benfulton on LibraryThing 10 months ago
This book was really a game-changer. The art of creating a computer program had not been analyzed much at all up until that point - plenty of algorithms had been created by computer scientists, and systems designers had some ideas about API's, but there wasn't a whole lot of direction for people who wanted to engineer applications to do things that user wanted them to do. Some of the patterns in the book are in common use today; others have been relegated to the dustbin; but the larger point is that after this book came out, people started using a whole new language to describe the work they were doing. Today we have UI patterns, management patterns, data access patterns, antipatterns, patterns, patterns, patterns everywhere, and this was the book that really caused the concept to take off.Is it worth reading today? That's a little tougher. There's no question to my mind that every developer should be familiar with the patterns in this book, but a more modern book on the same topic would probably display source code in a language that more people would more commonly be using. Still, there's no question that if you want to go back to the basics, you go back to Gamma.
twistedmind on LibraryThing 10 months ago
The classic book on design patterns in object oriented software design. There are newer books on the subject, but most are based on the original.
aethercowboy on LibraryThing 10 months ago
If there were required reading mandated for any degree involving computer software development, this would be it.Gamma, et al (AKA The Gang of Four) have given us a comprehensive guide to various software patterns, and it's the least we could do to follow them.It discourages me to see and hear about professional industries making lousy software that can't communicate with other tools, even those made by the same vendor. It bothers me when there are tools out there that make use of a network connection, but apparently don't play nicely with people using other operating systems or even other interfaces. Why can't I play Scrabble on my iPhone with someone using Facebook's Scrabble app? Why can't I play a co-op game of LittleBigPlanet on my PSP with another user playing on a PS3?Well, the short answer is that you should be able to do these things, using interfacing, one of the fundamental patterns in this book. Just as the user (usually) doesn't care what's going on behind the curtain with their software applications, as long as they get the right feedback when the click the right buttons, the client-side application shouldn't care about what's going on in the server-side, as long as it gets the right feedback from the server when it sends it the right data. When you hear things like this for the first time, it's kind of eye-opening, but at the same time, when you think about it for a minute, it really makes sense. It's like when you're playing a puzzler game, and you need a hint about how to solve a puzzle; once you see the solution, you smack your head. "That's makes so much sense!" you say, "Why didn't I think of that." Well, consider this book the solution guide to software design.No, it's not a recipe book (like the O'Reilly Cookbook series), but it does provide examples of the patterns you should be using, and unless you describe your coding style as "anarchist," it should really help you.If you're a software engineer and get your hands dirty by mucking with software, and you haven't yet read this book, then take off those coding gloves and give yourself about a week to absorb the amazing knowledge this book presents. If you want to go into software engineering, ensure that you have a firm grasp of a particular programming language, and then read this book, preferably before you start interviewing for a job. Then, in your interview, when asked a technical question, you can start off your answer by saying, "Well, The Gang of Four said in their book on design patterns..." And then, you're working in some software engineering field (results may vary).If you're truly devoted to making yourself a better software engineer, though, you simply must read this book.
celephicus on LibraryThing 10 months ago
When I first started C++ I was rapt with this book. It actually gave me an idea what to use all the C++ syntax for. Now 10 years later I think that the book is mainly a crutch for retentive designers who want to make sure that they can hide or expose parts of their system design. Sure the concepts are valuable, but the summary on the endpapers almost suffices to describe the pattern in question. Since I do not program in a statically typed language like C++ or Java anymore, the implentations are painful to read. Most of the patterns, apart from Interpreter which should not be a pattern anyway, are only a few lines in more dynamic languages (like Python).And I use the State pattern everyday, but I code it in C and it is less horrible than the bloated C++ behemoth with it's abstract interfaces and concrete subclasses like the seven heads of something from the book of Revelation. OO is a natural solution for many problems, like web or GUI frameworks. It is not so good for many others.So nice try, and full marks for naming these things, but I think that the Patterns movement is obsessing over the wrong things. I have given this book one star, I see one other person has also done so. At least I don't form a procession of one.
billmcn on LibraryThing More than 1 year ago
Perhaps more referenced than read...that's certainly the case for me. I've never tried to implement one of these things, but every once and a while I skim the patterns and it's useful to have the ideas filed away.
Pattern-chaser on LibraryThing More than 1 year ago
The software-patterns bible. If you know what patterns are, you should already have read it.
tongqg on LibraryThing More than 1 year ago
The famous book to have a deep explaination to design patterns
Tom_Petersen More than 1 year ago
This is one of the standard works of Object Oriented design and analysis. Gamma, et. al, is the base upon which many other works depend. I bought it because I needed my own reference copy. The NookBook may be portable, but I work where Nooks are not necessarily allowed. So, I have my copy of this work with book mark tabs and scribbled notes to fill the void. Recommended for any serious OO analyst, designer, programmer.
Anonymous More than 1 year ago
Anonymous More than 1 year ago
Anonymous More than 1 year ago
Anonymous More than 1 year ago
Anonymous More than 1 year ago
The recipient of the gift seemed very pleased.
Anonymous More than 1 year ago
Any chance this will be available on Nook in the near future???