* 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
and over one million other books are available for Amazon Kindle.
Learn more
FREE Two-Day Shipping for students on millions of items. Learn more |
| ||||||||||||||||||||||||||||||
 Sell Back Your Copy for $14.40
Whether you bought it on Amazon or somewhere else, you can sell it back through our Book Trade-In Program at the current price of $14.40.
Used Price$20.33
Trade-in Price$14.40
Price after
Trade-in$5.93 |
Book Description
Special Offers and Product Promotions
- Buy $50 in qualifying physical textbooks, get $2 in Amazon MP3 Credit. Here's how (restrictions apply)
Best Value
Editorial Reviews
Amazon.com Review
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.
Review
This book isn't an introduction to object-oriented technology or design. Many books already do a good job of that...this isn't an advanced treatise either. It's a book of design patterns that describe simple and elegant solutions to specific problems in object-oriented software design....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? -- From the Preface
This is one of the best written and wonderfully insightful books that I have read in a great long while...this book establishes the legitimacy of patterns in the best way: not by argument, but by example. -- C++ Report
This is one of the best written and wonderfully insightful books that I have read in a great long while...this book establishes the legitimacy of patterns in the best way: not by argument, but by example. -- C++ Report
Product Details
Would you like to update product info or give feedback on images?
|
More About the Authors
Discover books, learn about writers, read author blogs, and more.
Customer Reviews
Most Helpful Customer Reviews
351 of 368 people found the following review helpful
Format:Hardcover
This book really changed my way of thinking about object-oriented design. The idea is that when designing a new class hierarchy, though implementation details may differ, you often find yourself using the same kinds of solutions over and over again. Rather than approaching each design task out of context as an individual, isolated problem, the strategy is to study the task and identify the underlying design pattern most likely to be applicable, and follow the class structure outlined by that pattern. It's a "cookbook" school of design that works amazingly well.
There are other advantages to this book. It isolates 23 of the most common patterns and presents them in detail. You wouldn't think that 23 patterns would be enough, but once you become adept at recognizing patterns, you'll find that a large fraction of the patterns you use in practice are among these 23. For each pattern, the book carefully presents the intent of the pattern, a motivating example, consequences of using that pattern, implementation considerations and pitfalls, sample code (C++ or Smalltalk), known uses of that pattern in real-world applications, and a list of related patterns.
Upon first reading, you will start to recognize these patterns in the frameworks you see. Upon second reading, you'll begin to see how these patterns can help you in your own designs, and may also start to see new patterns not listed in the book. Once you become familiar with the pattern concept, you will be able to originate your own patterns, which will serve you well in the future. One of the most valuable contributions of this book is that it is designed not merely to help you identify patterns, but to give you a sense of which patterns are appropriate in which contexts.
I think this book is particularly valuable to many C++ and Java programmers, because of the dynamic and flexible design philosophy it follows. (Its two fundamental principles of reusable OO design are: "Program to an interface, not an implementation" and "Favor object composition over class inheritance".) I've found that many C++ books unfortunately tend to emphasize a rather static and inflexible design philosophy. Many C++ programmers do not realize how the language and the books they've studied from have been limiting their thinking until they have been exposed to ideas from other lanugages. The authors of this book have obviously been influenced by other languages as well, especially Smalltalk, and have brought many of its best lessons to C++ design. Most Java books seem to take after the C++ books, even though Java is a more dynamic language. This book may help Java programmers take full advantage of the extra power offered by their language, if they look deeply enough into some of the lesser-known features its runtime system affords.
Last, but not least, this book is valuable because it names the patterns it uses, and so gives programmers a common vocabulary to describe design concepts, rather than particular implementations. You'll find yourself saying things like, "That would be a good use for a Decorator", or "Should we use a Facade or a Mediator in this case?" I encourage readers of this book to use this vocabulary with other programmers.
In summary, this is one of the few books that I think belongs on every programmer's "must-have" list. Not to overuse a cliche, but like object-oriented design itself, the pattern concept is one of those rare paradigm-shifts in computer programming. It is equally valuable to expert professional and novice student alike. The book has a home page at http://st-www.cs.uiuc.edu/users/patterns/DPBook/DPBook.html
200 of 209 people found the following review helpful
Format:Hardcover
As you probably already realize from the large number of reviews, this book is one of the seminal books on patterns in software development. If you are a professional software developer, you must read this. If you are learning to write good software, this is a book that you will need to take on at some point, but I urge some caution.
In particular, many of the patterns in this book represent highly distilled wisdom about effective solutions -- distilled so far that, unless you have implemented code that realizes the pattern in question already, you may have trouble absorbing the material. I find that programmers-to-be who dive into this book, often end up talking annoyingly about "applying patterns" without having a real grasp of how these things translate (with some distortion and compromise) into real projects.
That being said, an excellent way to bridge the gap is to read this book along with "Pattern Hatching : Design Patterns Applied" by John Vlissides. That book is a chatty companion piece for this one -- I found myself understanding how to incorporate patterns into my day-to-day design work much more after reading both books.
See: Pattern Hatching : Design Patterns Applied [also at Amazon.com]
Overall, while this book is an extremely important contribution to software developers, it is structured in a way that makes the material difficult to absorb if you aren't approaching it with substantial previous knowledge about developing software. You can start with some of the simpler patterns (Singleton, for example) and work through the harder ones, but only by implementing projects and stumbling upon these yourself will you really feel a flash of recognition as you read them in the book.
247 of 266 people found the following review helpful
Format:Hardcover
... well, it's over. "Patterns" have not revolutionized the world. Nor does this book need to be "studied" for deep insights.
What it seems patterns are actually good for is giving common names to popular solutions to problems, to make them easier to call to mind, and easier to discuss with others. Even this much is overrated. Before the advent of patterns, you could have said "callbacks" and people would have understood. Now you say "the Observer pattern".
_Design Patterns_ is none the less valuable, because it is one of those few books that EVERYONE is expected to have read. This is helpful in practice, as you can expect everyone to be familiar with its vocabulary. Few books truly fall into this "required reading" category. The only other that comes to mind is the MIT algorithms text. Many tech pundits claim that every next book is "required reading", and the claim becomes tiring after a while, but this is one of the few that really is.
I would not necessarily purchase it, though. The "pattern" schematic is verbose, and requires pages upon pages to describe something that, once you have seen it in practice once or twice, you will recognize immediately. Omitting the appendixes, the book is barely 350 pages, and presents only 23 patterns. Only a handful of the patterns are truly famous: Singleton, Observer, Template Method ... perhaps a few more. A number of them are poorly presented. Chain of Responsibility, for instance, is just one of many ways to define an event framework and does not belong in a book that doesn't present the alternatives. Mediator is another; there must be dozens of ways to create a Mediator, which most people would call an "event registry" or something else, rather than a Mediator. "Mediator" itself is little more than a name, and won't help you in design.
Some patterns are boring, since modern languages tend to provide them, and we've heard about them many times already: Iterator, Proxy, Memento (serialization). Others, like Command, are geared towards GUIs, and provide little value to other types of applications. Then there are the State and Strategy patterns, which are two sides of the same coin, and needn't be given two different names.
And so on. Definitely do not "study" this book if it seems you "just don't get it". Chances are the book is wrong. It is worth a read through, and a second read through if the terminology doesn't stick the first time, but stop at that. My gut feeling is that this book is most appropriate for someone working on his or her first large project. After that, once the terminology sinks in, the book has little else to offer. And if taken dogmatically, or considered "inspired" or infallible, the book is a hindrance. Finally, overuse of patterns can result in a "kitchen sink" design, instead of a simple one that takes a few patterns, that may or may not be ones from this book, and implements them cleanly. Take the book for what it's worth, but remain skeptical.
What it seems patterns are actually good for is giving common names to popular solutions to problems, to make them easier to call to mind, and easier to discuss with others. Even this much is overrated. Before the advent of patterns, you could have said "callbacks" and people would have understood. Now you say "the Observer pattern".
_Design Patterns_ is none the less valuable, because it is one of those few books that EVERYONE is expected to have read. This is helpful in practice, as you can expect everyone to be familiar with its vocabulary. Few books truly fall into this "required reading" category. The only other that comes to mind is the MIT algorithms text. Many tech pundits claim that every next book is "required reading", and the claim becomes tiring after a while, but this is one of the few that really is.
I would not necessarily purchase it, though. The "pattern" schematic is verbose, and requires pages upon pages to describe something that, once you have seen it in practice once or twice, you will recognize immediately. Omitting the appendixes, the book is barely 350 pages, and presents only 23 patterns. Only a handful of the patterns are truly famous: Singleton, Observer, Template Method ... perhaps a few more. A number of them are poorly presented. Chain of Responsibility, for instance, is just one of many ways to define an event framework and does not belong in a book that doesn't present the alternatives. Mediator is another; there must be dozens of ways to create a Mediator, which most people would call an "event registry" or something else, rather than a Mediator. "Mediator" itself is little more than a name, and won't help you in design.
Some patterns are boring, since modern languages tend to provide them, and we've heard about them many times already: Iterator, Proxy, Memento (serialization). Others, like Command, are geared towards GUIs, and provide little value to other types of applications. Then there are the State and Strategy patterns, which are two sides of the same coin, and needn't be given two different names.
And so on. Definitely do not "study" this book if it seems you "just don't get it". Chances are the book is wrong. It is worth a read through, and a second read through if the terminology doesn't stick the first time, but stop at that. My gut feeling is that this book is most appropriate for someone working on his or her first large project. After that, once the terminology sinks in, the book has little else to offer. And if taken dogmatically, or considered "inspired" or infallible, the book is a hindrance. Finally, overuse of patterns can result in a "kitchen sink" design, instead of a simple one that takes a few patterns, that may or may not be ones from this book, and implements them cleanly. Take the book for what it's worth, but remain skeptical.
Most Recent Customer Reviews
It is OK - CDROM format
While it has the classical content, the CDROM format is very disappointing. It is a great example of a technology applied wrong. Read more
Published 1 month ago by VLAD DIDENKO
Hardcover not acceptable, print more softcovers
I know everyone is going with eBooks these days but I do some plane travel and to have this book in paperback would be wonderful. Read more
Published 2 months ago by A. Seaman
The best computer book on your shelf you will never read
In 1993 this book was groundbreaking. Patterns in C++? Java was just an idea at that point. By now there are many, easier to read and apply, books on Design Patterns. Read more
Published 2 months ago by Roger
Nostalgic, but a good book to browse
This book came out after I had graduated college, and was recommended to me by past professors. That was the level of quality of the book in the late 90's. Read more
Published 2 months ago by David Martin
Must Read
This book is a must read for all software engineers. It defines a vocabulary that you will need to communicate effectively with other engineers in your day to day work. Read more
Published 3 months ago by Eric Hamilton
Design Patterns from the GOF
I purchased this book as a suggestion while taking a UML and Object Orientation design class. It's amazing how well this book has aged. Read more
Published 3 months ago by Autoglitch
The book that started it all
The authors had the great insight to identify patterns in software design, and everything follows from this book. Read more
Published 3 months ago by Hektor Konomi
Must Read
As others have already noted, this is a seminal work on design patterns and is considered by many software professionals as a must read. Read more
Published 4 months ago by Siddhardha
Design Patterns: Elements of Reusable Object-Oriented Software
good shape and right product. It arrived on time. Funny that I haven't used it in class yet, but it should work well.
Published 4 months ago by Devin Crane
Essential
Absolutely essential for any programmer...enough said. You will be asked about the patterns in this book in job interviews and you will use some of these patterns in almost every... Read more
Published 5 months ago by Matt Accola
Inside This Book
(learn more)
Key Phrases - Statistically Improbable Phrases (SIPs):
(learn more)
glyph interface, design patterns solve design problems, glyph classes, polymorphic iterators, compiler subsystem, flyweight objects, glyph structure, following interaction diagram, polymorphic iteration, external iterator, multiple window systems, different window systems, command subclass, public widget, extrinsic state, internal iterator, checking and hyphenation, window abstraction, common parent class, decorator object, formatting algorithm, creational patterns, design patterns help, virtual proxy, hyphenation points Key Phrases - Capitalized Phrases (CAPs): (learn more)
Abstract Factory, Chain of Responsibility, Sample Code, Text Shape, Literal Expression, The Interpreter, The Flyweight, Watt Power, Presentation Manager, Glyph Draw, Mode Composer, Object Behavioral Intent Define, Motivation Consider, Related Patterns, Christopher Alexander, Smalltalk Model, Terminal Expression, Responsibility Operations, The Unidraw, Prototype Manager, Factory Method Browse Sample Pages:
Front Cover | Table of Contents | First Pages | Index | Back Cover | Surprise Me!
glyph interface, design patterns solve design problems, glyph classes, polymorphic iterators, compiler subsystem, flyweight objects, glyph structure, following interaction diagram, polymorphic iteration, external iterator, multiple window systems, different window systems, command subclass, public widget, extrinsic state, internal iterator, checking and hyphenation, window abstraction, common parent class, decorator object, formatting algorithm, creational patterns, design patterns help, virtual proxy, hyphenation points Key Phrases - Capitalized Phrases (CAPs): (learn more)
Abstract Factory, Chain of Responsibility, Sample Code, Text Shape, Literal Expression, The Interpreter, The Flyweight, Watt Power, Presentation Manager, Glyph Draw, Mode Composer, Object Behavioral Intent Define, Motivation Consider, Related Patterns, Christopher Alexander, Smalltalk Model, Terminal Expression, Responsibility Operations, The Unidraw, Prototype Manager, Factory Method Browse Sample Pages:
Front Cover | Table of Contents | First Pages | Index | Back Cover | Surprise Me!
Citations (learn more)
This book cites 16
books:
See all 16 books this book cites
100
books
cite this book:
See all 100 books citing this book
- Design Patterns by Erich Gamma in Front Matter (1), Front Matter (2), and Back Matter
- The Practice of Programming by Brian W. Kernighan in Front Matter
- Object-Oriented System Development by Dennis deChampeaux in Back Matter
- Object-Oriented Software Construction (Book/CD-ROM) (2nd Edition) by Bertrand Meyer in Back Matter
- Computer Programming by Johnson in Back Matter
See all 16 books this book cites
- The Patterns Handbook: Techniques, Strategies, and Applications (SIGS Reference Library) by Linda Rising on 15 pages
- C++ Gems: Programming Pearls from The C++ Report (SIGS Reference Library) by Stanley B. Lippman on 7 pages
- UML 2000 - The Unified Modeling Language. Advancing the Standard: Third International Conference York, UK, October 2-6, 2000 Proceedings (Lecture Notes in Computer Science) by Andy Evans on 5 pages
- Building Application Frameworks: Object-Oriented Foundations of Framework Design by Mohamed E. Fayad on 4 pages
- Java Testing Patterns by Jon Thomas on page 167, page 178, and page 231
See all 100 books citing this book
What Other Items Do Customers Buy After Viewing This Item?
Tags Customers Associate with This Product(What's this?)Click on a tag to find related items, discussions, and people.
|
Customer Discussions
|
This product's forum
Active discussions in related forums
Search Customer Discussions
|
Related forums
|
![[Start the discussion]](http://g-ecx.images-amazon.com/images/G/01/x-locale/communities/discussion_boards/start-new-discussion-sec._V192250339_.gif){kind=small}
Listmania!
|
|
So You'd Like to...
|
|
Look for Similar Items by Category
- Books > Computers & Technology > Computer Science > Software Engineering > Design Tools & Techniques
- Books > Computers & Technology > Programming > Algorithms
- Books > Computers & Technology > Programming > Software Design, Testing & Engineering > Object-Oriented Design
- Books > Computers & Technology > Programming > Software Design, Testing & Engineering > Software Reuse
- Books > Computers & Technology > Software
- Books > Education & Reference > Foreign Language Study & Reference
- Books > New & Used Textbooks > Computer Science > Object-Oriented Software Design
- Books > Science & Math
