- Hardcover: 395 pages
- Publisher: Addison-Wesley Professional; 1 edition (November 10, 1994)
- Language: English
- ISBN-10: 0201633612
- ISBN-13: 978-0201633610
- Product Dimensions: 7.5 x 1.1 x 9.4 inches
- Shipping Weight: 1.9 pounds (View shipping rates and policies)
- Average Customer Review: 490 customer reviews
Amazon Best Sellers Rank:
#4,602 in Books (See Top 100 in Books)
- #1 in Books > Computers & Technology > Programming > Software Design, Testing & Engineering > Software Reuse
- #2 in Books > Textbooks > Computer Science > Object-Oriented Software Design
- #2 in Books > Computers & Technology > Programming > Software Design, Testing & Engineering > Object-Oriented Design
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Design Patterns: Elements of Reusable Object-Oriented Software 1st Edition
Use the Amazon App to scan ISBNs and compare prices.
Fulfillment by Amazon (FBA) is a service we offer sellers that lets them store their products in Amazon's fulfillment centers, and we directly pack, ship, and provide customer service for these products. Something we hope you'll especially enjoy: FBA items qualify for FREE Shipping and Amazon Prime.
If you're a seller, Fulfillment by Amazon can help you increase your sales. We invite you to learn more about Fulfillment by Amazon .
"Enlightenment Now: The Case for Reason, Science, Humanism, and Progress"
Is the world really falling apart? Is the ideal of progress obsolete? Cognitive scientist and public intellectual Steven Pinker urges us to step back from the gory headlines and prophecies of doom, and instead, follow the data: In seventy-five jaw-dropping graphs, Pinker shows that life, health, prosperity, safety, peace, knowledge, and happiness are on the rise. Learn more
Frequently bought together
Customers who bought this item also bought
Customers who viewed this item also viewed
* 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.
Top customer reviews
There was a problem filtering reviews right now. Please try again later.
However, we are way, way overdue for a new edition, one written using C++11/14 or modern Java for the examples. The C++98-based examples really date this book - lines and lines of code to illustrate what you'd do with a bit of STL in modern C++. The patterns themselves are still relevant, but I hope no one is taking the code examples too seriously.
I wanted to just put a few thoughts in that I didn't see in the other reviews:
1. I read an article one time where John Vlissides (one of the authors) was saying he spoke somewhere and asked how many people had read the book and almost everyone raised their hands, then he asked, who would like to come up and explain how to implement the Composite pattern and suddenly only a couple hands were raised. Though this book is a fount of great ideas, it really will be most useful to you if you become CONVERSATIONAL with EACH of the patterns. That's the whole idea from Alexander anyway so consider it a mandate from on high.
2. One easy way I've used to explain to people what patterns are about is that mere object oriented training leaves people with an idea of how to model things as objects, but so many times I've done reviews of programmers code and they got that far and then as soon as work needed to be done that required more than one class, one of two things happens: they start passing data all over the place (back to the structured world we go), or they start binding their objects into deadly embraces. This book teaches you how to have some 'tricks' in your bag for modeling just such situations. Now, that said, there is some work you will have to do to map it into the newer programming world we're living in, for instance distributed Java makes some services available (like EJBs/container services/messaging) that changes some of the implementation ideas considerably.
3. If you are using Java, you can start to learn patterns and their application to your chosen platform by looking at a vast wealth of work that's already been done. The JDK uses the Observer pattern for its event model. Some of the more advanced frameworks, like BEA's Theory Center, are loaded w/Design Patterns (Chain of Responsibility and Strategy). And many products (Together/J) use patterns in their APIs (Visitor).
Finally, whenever I'm interviewing programmers now I ask them if they know what patterns are, then if they get past that, if they can give me an example of a recent use of a pattern and how it worked. I had a guy a couple of weeks ago looking for 6 figures who told me he'd heard of the book but hadn't gotten around to opening it. Der, that's like a doctor saying 'I've heard milk might not be good for ulcers, but take it because I haven't had time to review the research yet.'
More writers need to put out CD editions that are this good, dang it!!
"Design Patterns" is easy to read, easy to understand and has great code examples that facilitate understanding. It is my opinion that if you haven't read this book and you develop with OOP, you are probably working harder and not smarter. So do yourself a favor and pick up a copy.
This is an academic treatise (it started out as a Master's thesis) and reads like one. But as you read you'll find yourself identifying with some of the patterns that you've unknowingly used in your own code. And you'll start seeing how you could have used other patterns. And before you know it, your approach to programming has changed and you are able to focus more on the domain-specific issues rather than getting caught up in the need to continuously re-invent the proverbial wheel. And the world looks a little bit brighter.
Any book that does that for you deserves 5 stars regardless of how dry it is.