Design Patterns Explained: A New Perspective on Object Oriented Design, 2nd Edition

As a EE major, I didn't get training in OOP, design patterns, or OOP design methods back in the day. I picked up iOS app development for fun, but still couldn't get my head around the OO part of it, and how to get from idea to code. So I was left with finding someone else's code blocks and editing them, hoping that they didn't break. Many tutorials regarding patterns I saw online showed me a design pattern and some code to go with it. They were easy enough to understand, but not to apply. There was still a gap where I couldn't take my idea into OO code. This book bridged the gap! I'm certainly no expert yet, but the explanation made in this book is very clear and now I know what I need to do to get there.

This book makes design patterns practical. It also presents an insightful perspective on how to design and write good code. Specifically, it helps you to move beyond simple concepts like "is a" and "has a". It shows how using inheritance to handle specification leads to greater complexity and too many classes. It shows you how to abstract out variability. This allows you to avoid the temptation to copy and paste code. Instead you abstract it out and reuse it. This makes your code base smaller more maintainable and it compiles faster. I think this book is a must read for any good developer. Other reviews have complained about the lack for code in this book. If you are looking for a book to show you how to write code that implements a specific pattern in a specific language this book is not for you. This book is a higher level book that focuses on the concepts of good design that are true for all object oriented languages. There are other books that go into the specifics of various languages.

Design Patterns Explained: A New Perspective on Object-Oriented Design is a useful book for the major of Management and Information Systems. Shipping is on time, design is new. Take it if you like.

The universe of programming litereature is littered with poorly written, incomprehensible books. Many worthwhile books are painful to read, hard to understand, and are seriously flawed by their authors inability to connect with the reader. This book is none of these things. It is well organized. It is lucid. It is not bogged down with irrelevant detail. A book written about design patterns should be universal, and this book was for me. The examples were written in either Java or C++, and I do not use either (mostly PHP and Javascript). This did not impair my ability to understand the examples. As it should be-a book that is about making your software more understandable by abstracting should make the abstract concepts understandable.

This book fulfils its subheading pretty well (New Perspective on OO design), and for that it is recommended. But not so much regarding the main heading - Design Patterns Explained. It starts off well, easy to read and logical in its progression. But about a third of the way through that quality degrades in my view. Basically software design patterns are abstractions. And therefore this book is talking about abstractions. However be prepared for the explanations too often to talk in an abstract way about these abstractions - so you're holding abstractions in your mind two levels deep. And occasionally they talk abstractly in an abstract way about these abstractions - so the level of abstraction you're holding in your mind is three levels deep. Thus it doesn't necessarily give you a concrete undertanding of design patterns. Also too many times their explanations are based on hidden assumptions. By this I mean they assume the reader will know an aspect of OO development concerning what they are talking about, and their explanation builds on that assumption. If you don't know what they have assumed you do know then it becomes harder to understand what they are explaining. And why hidden? Because they never ever refer to these assumptions, so you never know they are there... until you figure out that they are. They provide a UML introduction which they say will teach you all the UML you need to understand their diagrams, but then use an element in their UML diagrams that wasn't in their chapter on UML. Apart from that the UML diagrams are generally easy to follow but not always at all. The book is written more as a conversation rather than a structured education text, which doesn't necessarily impart the subject in the clearest way. Also there is some sloppy editing in places e.g. references to diagrams that don't exist. or to the wrong diagram for the text it's meant to be illustrating. Plus some less than clear/logical explanations e.g. referring to the same design element/item by several different labels/nouns without clarifying that that is what they are doing. Plus their code examples are stub like and pretty crappy. All these factors, along with the predominately abstract nature of the book, gives arise to ambiguity in too many places in the last two thirds of the book to make it easy or even productive reading. Too many times when it came to the actual design patterns they work with (they only discuss a large handful of the whole official set) I ended up jumping online and after reading the odd article or other kind of info and got the clarity about the design pattern I needed. Having got that, sometimes I'd reread their explanation, but mostly I just moved on to the next topic in the book. They have a wide margin on each page with a few words summarizing each paragraph, which I never read, and regarded it as complete waste of space. They would have been far better off utilizing this vast white space to be more circumspect and detailed in their explanations of the patterns and code examples, spelling things out more. (Even though its purpose is admittedly somewhat different, a good example of a book doing that is "Refactoring" by Martin Fowler, which is an excellent book.) For all these reasons I'd say overall the material in the book that I benefitted from could have been reduced to a book a third of the size. And for all these reasons I wouldn't recommend this book to beginners, nor to anyone who wants to learn actual design patterns. It would be suitable if you want to expand your view of OO programming away from the traditional inheritance focused approach to an approach with a bit more (high level) depth of understanding regarding OO's extended and nuanced capabilities, especially in regard to creating codebases that are easier to understand, maintain and extend. It also has some good concepts regarding how to approach the beginning of analyzing the problem domain and how to work that through (only at a high level though, but that's still useful).

Whilst the 'GoF Book'(Design Patterns: Elements of Reusable Object-Oriented Software) is the bible of patterns, this is undoubtably the Magna Carta of patterns. It should rather be called 'Design Patterns for mere mortals'. I found this book a true pleasure to read, and recommend it above the original GOF book. It really makes patterns incredibly easy to understand and apply in the right context, instead of just blindly using them because they are the next cool thing in Software Engineering. Whilst the 'GoF book' is still a vital book, it is more of reference than something that should be read cover-to-cover. Buy this book first, and then get the 'GoF Book', once you have read this book.

Unlike most people I never learned BASIC, I never knew how to program a calculator, mostly due to the lack of having one. I started learning to program from C++ For Dummies. Since then I have learned the Qt framework, programmed in PHP, Perl, Bash, and Java. I have found this book to open my eyes to patterns that I was already doing, and showing me ways to rethink problems that I thought were hard before.

Good value!

I would strongly recommend that *every* student or practising software engineer should read this book, even "experts" in object-oriented or pattern-based programming. The authors essentially teach the reader how to design software better. They walk the reader through various approaches to a systems design example throughout the book, finally culminating with the approach of combining software patterns with CVA (Commonality and Variability Analysis). It is just so obvious but no-one ever seemed to think of it before. From reading this book I now have a lot more clarity in thinking through the analysis and design of software and am producing implementations that are far more maintainable. For that I cannot thank the authors enough. In summary : GET THIS BOOK!

L'intento dovrebbe essere quello di presentare i design pattern in modo semplice ed intuitivo a coloro che hanno nessuna o poca esperienza con la materia. A mio parere, invece, questo è un testo più utile come seconda lettura sull'argomento. Gli esempi di codice e i contesti applicativi in cui vengono usati, infatti, sono tutt'altro che banali. Se cercate un testo rivolto al completo neofita andate su Head First Design Patterns che fa sempre esempi molto semplici, eliminando i dettagli e concentrandosi sugli aspetti importanti.

Bought used by Books Unplugged and arrived in great condition. Some signs of use and some text marker was used on some pages. I've read great things about this book and glossed over some sections. Looking foward to read it to have a more in depth understanding of this subject.

This is a wonderful book on Design patterns and I think every serious software designer must have this book. I wish I would have bought this book around the time it came out. After reading other patterns literature and books; I find this book easy to understand. This is not a typical book on design patterns which goes through every design pattern. This book teaches how to use patterns as a pattern sequence in order to solve problems and mechanics about implementations. The section about commonality and variability analysis is a must read for any software developer. Learning and applying Design patterns has made me a better programmer over the years and after reading this book it has made me a better programmer with good habits.

Good book.... Even better than head first design patterns, though I didn't like head first much. I would recommend to start reading about design patterns with this book. It spoke of issues which I faced while reading other dp books like gof's book and cleared my many doubts.