Design Patterns Explained: A New Perspective on Object-Oriented Design (Software Patterns) Paperback – Illustrated, 12 Oct. 2004

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!

Right from the start this book began to change the way i think about the design of my software. Within weeks it has led me to creating much more powerful designs that I previously was capable of. Explained very well in a form that anyone with programming knowledge can understand.

The target of this book isn't to explain Design Patterns. It tries to teach you about good design by applying well-known principles (strong cohesion, weak coupling, ...) and by explaining several possibilities to order your thoughts.The book is really easy to understand, too easy for me. The author repeats himself very often in the first half. The first third of the book is an slow introduction to what will come (his intentions, absolute basic thinking and definitions, an example which will be used later on and a chapter about design patterns in building).These were the reasons I disliked the book in the beginning, it becomes constantly better after the Facade Pattern. He explains all patterns very well, so I think everybody will understand it. It can get somewhat boring if you know the pattern already or already have a responsibility-like thinking of objects (like I did).Nonetheless I fould at least something interesting in every chapter, most often observations of his own practice were helpful.What I found most interesting was the Bridge Pattern (really good explained) and the Analysis Matrix (a way to develop a good system from scratch, I liked it more than his CVA-approach [Commonality and Variability Analysis], because CVA is just proper OO-thinking).His linkage to XP / agile development is generally just "works with agile development, too". What he refers to is most often the style of thinking.To summarize: Even if I didn't found this book exciting from page to page, I fully agree with his opinion. Nothing in this book is false (I think thats an important thing to say about a technical book).His quotes from other books are really gorgeous, they explain everything in short. His definitions made in the beginning are very good and neat (cohesion, coupling, aggregation, ...) I liked the recommodations in the end, it's always good to have an opinion on some books to know what to read next.Whom I recommend this book:He often refers to the old style of OO-thinking (nouns and verbs) and tell how to improve your OO-thinking to his new style. So I would recommend this book to everyone who already was involved in some projects, but doesn't know Design Patterns at all or is used to the old OO-thinking. I wouldn't recommend this book to beginners, because imho you need some experience to understand why patterns are helpfull or the way of thinking is superior.If you already know some patterns and have a responsibility-like OO-thinking, this book will bore you most of the time. But like said, it's not wrong and there is a nugget around sometimes, e.g. the Analysis Matrix.In the end I found it worth reading.I expected more patterns, thats why I will read the classic Design patterns : elements of reusable object-oriented software next.

What can I say? This book is well presented and written. If you need a start in OO and patterns this is the best place to start.

An excellent book on Design Patterns, very easy to follow, and not as dry a read as most programming books

I bought this book as I had been struggling with the GoF's classic patterns book ("Design patterns : elements of reusable object-oriented software" http://www.amazon.co.uk/gp/product/0201633612). I found that heavy going, and thought this might be a more gentle and easy to understand introduction to design patterns.What I didn't realise is that the bulk of this book, ie the parts that describe the patterns themselves, does nothing more than rehash what the GoF did, but not as well. The depth (or lack of) that this book covers was in the first few pages of the GoF's description of each pattern, and the heavy stuff that the GoF added was missed out from this book altogether. What's worse is that the GoF had far better examples that made the patterns easier to understand. With the descriptions here, you just started to get the idea of what the pattern was about when the chapter ended. You were left with a feeling of being dropped right at the crucial moment.To make matters worse, the "dozens of code examples" promised on the back of the book turned out to be very short and unhelpful. Whilst it's important to concentrate on only those bits of code that are relevant to the issue being discussed, you need enough code to see what's going on. This book has very little. In fairness, the web site has a lot more code to download, but the book should have had more code shown, instead of forcing you to wade through the downloaded files.If you just want to learn the patterns, then you're WAY better off with the GoF book, and just skip anything you find too heavy.This book spends far too much time on irrelevant points (like discussing things he's not going to cover). For example, it spends a whole chapter describing an example situation, making out that it's going to be a major part of the book, but then you find that it is then not used very much in the rest of the book. The bits that re used could have been described in one paragraph. What a waste of time!The one thing that the GoF book doesn't do, that this one attempts to do is explain how to decide which pattern to use. This is a very important issue, as learning the patterns is really only the beginning. You need to know how and when to apply them. This books spends some time describing how to analyse your problem domain, and how to decide which patterns might be appropriate.Unfortunately, this is all done in a fairly vague manner, and so it far less useful than it could have been. Had this part been done well, the book would have been worthwhile, even with my other complaints. However, as this part was fairly unclear, I don't think the book warrants more than three stars. The authors keep dropping hints about their courses, but if this is the way they teach, I can't see the courses being much good. I certainly wouldn't pay money to have them teach me!It could be that repeated reading of the analysis section of the book might eventually help, but I don't have the time or interest to bash through it over and over again in the hope that it make become clearer. I'm sure there are better ways to learn this stuff.A great disappointment.

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 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.

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.

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.

Good read