Design Patterns: Elements of Reusable Object - Oriented Software (Old Edition) Paperback – 1 January 2008
More items to explore
Customers who viewed this item also viewed
About the Author
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 mobile phone number.
What other items do customers buy after viewing this item?
Review this product
There was a problem filtering reviews right now. Please try again later.
Must read for a good developer! :)
Top international reviews
- Programming languages. I do vast majority of my coding in Java, sometimes I code in another JVM languages. This book provides examples in C++ and/or Smalltalk. Even more, this book was written before Java was a thing! This has to have an impact on how easy to follow are some of the examples. If you write Java 8 code, I bet you know what is the difference between external and internal iterator. At the same time, C++ friends will probably be less obvious to you, and the concept of e.g. enum-based singletons will not be mentioned at all. If only someone could write this book once again, but focus on Java-centric point of view.
- GUI-based examples. For nearly all the patterns, there is a GUI-related example. I am deeply alergic to GUI development and would appreciate more examples relating to backend functionalities.
- Didn't we evolve since then? Many of these design patterns are explicitly targetting challenges around excessive memory utilisation and other past limitations. We can do better now. Same constraints still exist, but are applicable to a very different extent. I can see people blindly following some of these patterns today in the field, with very little reflection upon the actual problem they are trying to solve. Today good programming is frequently not about making the application consume less memory, but about making it easier to understand and change. The problems we are trying to solve have changed, therefore the solutions we apply need to change as well. Keep it in mind while reading this book - not all of that is of equal value today, as it was when this book was first published. This takes us swiftly to the next point, which is...
- The pattern catalogue. While many of these design patterns are still valuable these days, there may be others which are more valuable. Just compare and contrast the builder pattern, as described in this book vs the one described many years later by Joshua Bloch.
My recommendation - read this book if you haven't done it already. Learn all the good things, just don't forget the world has moved on since then.
I've re-read this book so many times in my career and watched as it's contents went from obscure, to fad and overused reference to where I think it should always have been, an accepted classic containing great wisdom.
Study it, learn from from it, implement things they way it suggests - then learn that it is not dogmatic. Simply use it to help shape your software solutions into recognisable forms that can be maintained and evolved over time.
Every team who use object-orientation should have a copy in the office to refer to.
If you want a softer read, there is a Head First book on design patterns - but I would still recommend having a copy of this book to refer to when you want to implement and adapt a pattern in real life.
You have your structural, creational and behavioural patterns, with great advice for, for example, adapting an interface for a new class with features the old interface wouldn't have allowed; OK to me, it reads a lot like industry recognised hacking-together, but I'm told these are genuine real-World problems that you'll face in your careers and by following these patters will have more maintainable code, as future coders will recognise what your classes are doing. Even if you did have to hack it together.
One thing to note: the examples are in C++, but it translates well to any O-O language and the lessons are still valuable and there to be learned.
That's about all I can say, it's the most useful book I own.
There's still plenty to learn from this tome (the fundamentals haven't changed, after all). Just bare in mind that practicality and readability (particularly in the case of your successors) should trump "correctness" in all but the most niche high performance and academic projects.
The languages used in the examples are easily understood so they can be followed.
Not only for stand-alone desktop programs or mobile applications but for web applications also, you will find Design Patterns useful for your code. You will understand how to solve some basic logic problems with design patterns that will render your code reusable and easy to adapt it to any program you make.