Programming Books C Java PHP Python Learn more Browse Programming Books
Design Patterns and over one million other books are available for Amazon Kindle. Learn more
  • List Price: $59.99
  • Save: $39.67 (66%)
Rented from RentU
To Rent, select Shipping State from options above
Due Date: Aug 16, 2014
FREE return shipping at the end of the semester. Access codes and supplements are not guaranteed with rentals.
FREE Shipping on orders over $35.
Used: Good | Details
Sold by apex_media
Condition: Used: Good
Comment: Ships direct from Amazon! Qualifies for Prime Shipping and FREE standard shipping for orders over $25. Overnight and 2 day shipping available!
Add to Cart
Qty:1
  • List Price: $59.99
  • Save: $21.29 (35%)
In Stock.
Ships from and sold by Amazon.com.
Gift-wrap available.
Add to Cart
Want it Monday, April 21? Order within and choose Two-Day Shipping at checkout. Details
Trade in your item
Get a $17.03
Gift Card.
Have one to sell?
Flip to back Flip to front
Listen Playing... Paused   You're listening to a sample of the Audible audio edition.
Learn more
See all 2 images

Design Patterns: Elements of Reusable Object-Oriented Software Hardcover

ISBN-13: 078-5342633610 ISBN-10: 0201633612 Edition: 1st

See all 15 formats and editions Hide other formats and editions
Amazon Price New from Used from Collectible from
Kindle
"Please retry"
Hardcover
"Please retry"
$38.70
$31.85 $20.00
Paperback
"Please retry"
$31.58 $31.95

Free%20Two-Day%20Shipping%20for%20College%20Students%20with%20Amazon%20Student



Frequently Bought Together

Design Patterns: Elements of Reusable Object-Oriented Software + Refactoring: Improving the Design of Existing Code + Clean Code: A Handbook of Agile Software Craftsmanship
Price for all three: $114.49

Buy the selected items together

NO_CONTENT_IN_FEATURE

Shop the New Digital Design Bookstore
Check out the Digital Design Bookstore, a new hub for photographers, art directors, illustrators, web developers, and other creative individuals to find highly rated and highly relevant career resources. Shop books on web development and graphic design, or check out blog posts by authors and thought-leaders in the design industry. Shop now

Product Details

  • Hardcover: 416 pages
  • Publisher: Addison-Wesley Professional; 1 edition (November 10, 1994)
  • Language: English
  • ISBN-10: 0201633612
  • ISBN-13: 978-0201633610
  • Product Dimensions: 9.3 x 7.6 x 1 inches
  • Shipping Weight: 2 pounds (View shipping rates and policies)
  • Average Customer Review: 4.5 out of 5 stars  See all reviews (350 customer reviews)
  • Amazon Best Sellers Rank: #3,620 in Books (See Top 100 in Books)

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

More About the Authors

Discover books, learn about writers, read author blogs, and more.

Customer Reviews

I would recommend this book to any software developer, architect, or designer.
Brett Lomas
Unlike most popular computer books, you will find reading this book takes a lot of thinking, for each paragraph or even each sentence.
Jase
This book outlines each pattern in great detail, giving its definition, use, and examples of each.
Roberto Vila

Most Helpful Customer Reviews

384 of 403 people found the following review helpful By A Customer on March 6, 1997
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.
Read more ›
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
230 of 241 people found the following review helpful By Russell Belfer on May 15, 2000
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.
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
319 of 345 people found the following review helpful By Dave O'Hearn on January 19, 2005
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.
Read more ›
10 Comments Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again

Product Images from Customers

Most Recent Customer Reviews

Search
ARRAY(0xa296d0c0)

What Other Items Do Customers Buy After Viewing This Item?