Design Patterns Explained: A New Perspective on Object-Oriented Design (Software Patterns)

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.

A superb book. The explanations were clear and every time I thought of a question the author immediately answered it which just shows how much thought went in to the book. As someone who, stupidly, never really looked at patterns before I have to say this book was perfect. If you take the time with some of the chapters, particularly the one about the Bridge pattern, then you can come up with the actual pattern before the author gives it. You can do this because the authors give you the information and context you need to work out what the solution will be. The only slightly annoying point about the book is that the self satisfaction of the authors sometimes gets in the way of more important matters, however that doesn't spoil a good book. I would recommend that anyone who enjoys this book goes on to look at the books written by Craig Larman, Robert C. Martin and Joshua Kerievsky. They all cover object oriented design and patterns in more detail.

It's easy to read but tedious if software design is not new to you. The book reads like the author chatting to an inexperienced developer and trying to instil his own personal experience. Personally I don't want to read about someone else's career. I want to be able to put names to patterns that I have frequently had to derive myself so that I can demonstrate at job interviews that I know about patterns. A pattern is a solution that comes up enough times that it might as well have a name. By their very nature patterns are obvious solutions if you understand the fundamental principles of software engineering and think about the problem for long enough. The problem almost always defines the solution. Unfortunately this book tries to describe a new perspective on Object Oriented design that frankly just isn't actually new. As with any technology, how it is actually used in practise evolves over time and changes from how it was first envisaged. Whilst reading this book a colloquial expression often came to mind that Dr Watson could have said to Sherlock Holmes if he had just stated the blindingly obvious. This is most definitely not a reference book. You have to wade through bumpf about design and the personal experiences of the authors to find the sections describing specific patterns. Concise is not a word that I would use to describe this book. It's useful to know the names of patterns because it aids communication with other engineers, but if you want to find out what someone else is referring to then it will be faster to use wikipedia. The only thing that I really learnt from this book was about the pitfall of implementing double checked locking in Java. Unfortunately Wikipedia gave a much more useful explanation.

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.

I'm really grateful to the authors for what they taught me in this incredible book. It completely changed my mind as a developer. Thank you Alan Shalloway and James Trott. I read it cover to cover. It came in perfect condition. I highly recommend this book!!!

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.