Rating: 
Summary: The best initial and definitive step to design patterns
Review: This is the best book about design patterns that I have read.
Read this before the GangOf4. It`s a must for every system designer.
Rating:
Summary: A great book on OO and Design Patterns
Review: Being new to patterns, I tried to read the Gof4 book first only to become bored, confused, and uninterested after the first few chapters. Then I bought this book. This book clearly explains the power behind patterns and draws on other disciplines to making OOAD a lot easier to get your arms around. Moreover, the book is a fairly quick read!I highly recommend this book to get a conceptual understanding of the use of design patters and as a complement to the Gof4 book. It's light on examples, but look to the Addison Wesley books for Design Patterns in Java, for instance, for more examples of their use.
Rating:
Summary: Read my mind...
Review: I tend not to heap praise on books because of one thing: I think we buy books that we need at the moment, so it seems that they all have "something to offer". That said, I have never read a book like this one that seemed so approachable, and yet very deep at the same time. What I mean by this, is that there are certain gems of wisdom that are very thoroughly explained. This is a book to read twice or more, and keep the red pen handy to write in the margins for epiphany moments. You will have them. The authors are very careful to give credit where it is due, and to explain that they are fellow pilgrims. This is a very PRACTICAL treatment of what can be some way too abstract concepts.
Rating: 
Summary: too verbose and unfocused; not worth the price
Review: I found "Design Patterns Explained" disappointing, and not worth its price, for many reasons. It has, nonetheless, some very good qualities. In the following, I'll write a detailed review starting with the disappointing features and finishing with the good qualities. I apologize if you consider this review too long for this forum. First, "Design Patterns Explained" is very verbose without being particularly clear. The authors spend about 25% of the length of the book (the first 80 pages or so) going on and on about an alleged new perspective on object-oriented software design which is, in the end, not particularly new nor sufficiently concrete to be useful. In addition, I found the discussion of the architectural origins of design patterns to be too general and confusing for the beginner software designer. Second, it constantly refers to the Gang of Four (GoF) book as if the authors of "Design Patterns Explained" needed confirmation of their ideas. Frankly, it tired me to the point of thinking that one might as well just read the GoF book instead. That wouldn't be a bad idea, in fact, since the GoF book is arguably the best book written so far on the subject of design patterns; its second chapter alone is worth more than "Design Patterns Explained" and is the best written, clearest, most concise (yet concrete) introduction to design patterns I have seen to this date. Third, this book's Overview section at the beginning of each chapter is unnecessary, wasteful of paper and ink, repetitive, and downright annoying because it confuses what should be a useful summary with the listing of obvious facts about the chapter in question. For a typical example, consider the overview section of Chapter 16, "The Singleton Pattern and the Double-Checked Locking Pattern:" "In this chapter, * I introduce the Singleton pattern.
* I describe the key features of the Singleton pattern.
* I introduce a variant to the Singleton called the Double-Checked Locking pattern.
* I describe some of my experiences using the Singleton pattern in practice." None of these four bulleted items says anything that the reader would not already infer from the chapter title or expect from a well written book. And speaking of annoying features, the entire text is written in the first person, even though the book has two authors. There's nothing intrinsically wrong about that practice. It is extremely disconcerting, however, to read someone's "experiences using the Singleton pattern in practice" while not being able to determine whose experiences those are. Next, the authors make Java their choice of language for the examples in the main body of each chapter, with C++ code at the end of each chapter. I applaud that choice, but the Java code often cannot be compiled. True, the authors admit right off the start that the code is fragmentary. But, if you're going to write a loop that uses an Enumeration, with the degree of detail that is found on page 270 (Example 17-1 on the implementation of the Observer pattern), then make sure it is complete and correct. The example just mentioned is missing the critical nextElement() call: public void notifyObs() {
for (Enumeration e =
myObs.elements();
e.hasMoreElements() ;) {
((Observer) e).update(this);
}
} This is not an isolated case. In addition, whenever a UML diagram contains code in a comment box, that code is written in C++, not in Java. For a typical example, refer to the bottom of p. 251, Figure 15-7, where we find statements such as component->Operation and Decorator::Operation(). For a book intended for beginners, and of this size (less than 350 pages) and cost [price], the faults I mentioned are just too many and too serious. A seasoned software designer may be able to recover quickly and painlessly from them, but a beginner trying to understand why the code cannot be compiled would surely feel frustrated. Yet, the book is not completely devoid of qualities. Here are several: The authors constantly emphasize the fact that requirements do change, often unexpectedly, and that a good design always anticipates those changes. Likewise, the authors advocate that designers should be proactive in their dealings with clients. I also liked the fact that the authors always present first the obvious, often inflexible, approaches to a problem before presenting the design-pattern solution. Another good point about this book is how the authors offer a cooperative look at the patterns discussed, often explaining how certain patterns can be used together. Their notion of seniormost patterns constraining other patterns is also very useful and one that I had not seen in any other book. Kudos to the authors for presenting that concept. Chapter 9 is a very clear presentation of the Bridge pattern and chapter 12, a detailed walkthrough of a case study, is likely to be very useful to the beginner software designer. Chapter 20, "The Analysis Matrix," is probably the best contribution of this book to the toolbag of software designers, beginner and seasoned alike. The book's website looks quite good. I've explored it briefly and have a sense that the authors tried hard to create a useful site. In conclusion, although this book has several very good qualities, it is too unfocused and verbose, and has several serious defects, to be really useful to a beginner software designer and to justify its price. If you can get your company or someone else to pay for it, it will be a good deal. Otherwise, don't bother getting it. Instead, put the same amount of effort into reading the GoF book and you should come out a good designer.
Rating:
Summary: An ultimate book on Design pattern
Review: Design patterns Explained is an excellent book. It helps you to learn the intricacies of Design pattern concepts in a nice way. The examples used here are more practical and interesting. More over when you will feel most of them you are using unknowingly. Authors have taken the pain of explaining every bit in minute details. Atlast I feel it's irrestive i.e once you have started the book you can't stay without finishing the same.
Rating:
Summary: Excellent Patterns book, especially for Java programmers
Review: These folks lead you gracefully into the very important world of software design patterns. Their book wisely explains & maps OO concepts, UML and patterns. It has a sufficient explanation of OO and UML at the outset in preparation for their brilliant patterns explanations. Their style of explaining patterns via examples and concepts is masterful. Readers with a firm Java background who are looking to understand design patterns should consider this book required reading. My background is 12 years of professional programming, 8 years of PowerBuilder, a few years of serious Java studies and a half-read UML book.
Rating:
Summary: Insightful, Readable
Review: This is the best Design Patterns books I have read. I have GoF book and have used design patterns before. I think this book gives insight succintly and simply no other books have. This book could have expanded to describe more other patterns and may be include a pattern catalog or matrix as an Appendix.
The strength of this book is to use Java( a language with clean syntax) and diverse simple examples to convey points across.
I'm looking forward to their second book..
Rating:
Summary: Buy this book!
Review: I'm a VB programmer, and I've read a couple of books on design patterns, even ones that look at it from a VB perspective. This book beats them all, even though the code snippets are mostly in Java. It starts simple and builds up to a great discussion of all the patterns that's easy to understand.
Better still, it looks at objects in a new way, and gives you plenty of "real world" examples of objects to cement the concepts in your head.
If you know the basics of OO, and want to get into design patterns, this is for you.
Rating:
Summary: Superb Explanation
Review: Purely conceptual, this book does a great job in giving the reader a true grasp of design pattern concepts. My copy is well highlighted, and I refer to it often.
Rating:
Summary: couldn't stop reading
Review: I bought this book to start using design patterns. I didn't really know what I should expect, but what I got
was awesome.
Once started, I couldn't stop reading this book! It's content
is so interesting and is written clearly and exciting.
Shalloway and Trott give a good view of what design patterns are,
what they can be used for, and how to use them! Everybody who wants to get started with design patterns...
buy this book! The Gang of Four book is a great reference,
but this book is an even better introduction.
| 
