Rating: 
Summary: Towards a better vocabulary...
Review: Most standard data structures and algorithms are known by their name(s) eg. 'heap', 'quick sort'. This book talks about solutions to recurring design problems and gives them standard names such as 'Visitor' and 'Abstract Factory' or at the very least the authors hope that they'll become standard. They call these 'design patterns'.The book's structure is like this: an introduction, followed by a medium-sized example design, followed by a standard-format catalog of 23 'patterns'. The example is well written but I haven't had the need to look at all 23 patterns. They've followed architect Christopher Alexander's lead(The Pattern Language). However, Alexander tends to focus more on the problem. These authors focus more on the solution. Despite this, this book can raise the consciousness level of average design practice and make it less of black magic. However be warned that this has a heavy object oriented bias.
Rating:
Summary: fashion design program
Review: we are in the women ready clothes production line and we are looking for a supplier of women clothes fashion design program, please advice the ability of providing such program
Rating: 
Summary: Not for the faint-hearted, but a must read.
Review: Obviously, this book is *the* most recognized reference work on software-related Design Patterns, and as such cannot be ignored. If you want to know about patterns, here is where to start. The main asset of this book is in its trustworthiness and credibility - not such an easy thing to come by in computer books these days. I went through many if not most of the C++ examples in detail, and did not find a case where it didn't hold up, at least to the extent where it clarified what the point of the pattern was. The UML diagrams are also extremely helpful. Be forewarned, however; this is not light reading. The examples are based on heavy-duty design tasks your average programmer doesn't face, like language-parsing, toolkit creation, compiler writing, and the like. It makes one wonder how applicable many of the patterns are to less complex programming tasks. Also, most of the examples are in C++, so you really have to understand the syntax of C++ before you can get much value out of this book. Another drawback is that many of the examples are abridged, so at times you have to kind of extrapolate on what some of the code *would* look like in order to understand the examples. The chapter on Interpreter in particular was a tough nut to crack due to this. I actually would have liked to have seen *more* explanatory text associated with the code itself. For all that, many of the patterns are pretty staightforward. The trick is to nail down that you "get it" for each pattern. One technique I found enormously helpful in accomplishing this was to write a summary of the pattern after reading a chapter - right in the book, so it can referenced later (there's often an entire blank page opposite the beginning of each chapter you can use for this). You may find yourself delving back into the chapter to confirm your understanding. Overall, a challenging but ultimately rewarding read for anyone who wants to understand what design patterns are all about.
Rating:
Summary: Excellent, but also see...
Review: Anyone seriously interested in the subject matter of this book should also take a look at Pattern Oriented Software Architecture: A System of Patterns by Frank Buschmann et al.
Rating: 
Summary: Excellent concept but rather disappointing mistake density
Review: I rate this book 5 stars for the idea and -2 stars for all the confounding little mistakes. Apologize, I don't have too many details because it was one of the few books I borrowed that I actually returned (and to the original owner). I went through two of the patterns with full concentration, found mistakes in both and found they really did get in the way. Things were named or referenced in ways that just couldn't be right. I wrote to the authors about a few issues (e.g. on pg 275, Widget should reference DialogDirector, not aggregate it) and the response (Johnson, Vlissedes) was very kind and constructive. But I believe there is significant work remaining. You may think I'm being overly picky here (at issue on pg 275 is an itsy bitsy little shape), but try understanding something completely new when there is one mistake in it. You wonder if you're comprehending wrong. I have a hunch that most folks here, pardon my presumption, who are rating high without reservation are really in love with the idea of finding patterns to design (as am I). But I wonder if they've ever really really tried to go through any of the examples at a finer resolution than a bird's eye view. The book does a lot to crystalize the dream of reusable design patterns but not as much as it could to wake us up to realizing it. Still it's on my list of things to buy because it's darn thought-provoking. Maybe that's it's highest purpose: to announce, if only by the title, the shocking idea that there could be patterns to design, that programmers might not always have to reinvent the universe with each project. (The idea that they don't is not new, but the *fact* that they don't is making woefully slow progress.) The big question I still have is did they pick really good patterns and objectify them with compassion and vision? Are these the very paradigms and clumps of computational power that will be in the toolbox of programmers yet unborn? Dunno. I suspect from the tactical gaffs that strategic corrections are in order. Maybe 3 stars isn't harsh enough but it's certainly a pioneering book. I believe one significantly better will come out in the next decade. It would be nice (somehow in my rosy view of the world) if it were by some of the same guys...
Rating:
Summary: Works even better if you have encountered similar problems
Review: This book is an excellent collection of valuable experience and great insights into good software design. However, don't expect to digest everything by reading cover to cover. Try to skim through all patterns, and go into details for patterns dealing with problems you have encountered before. I found that this way I have been able to pick up the patterns quickly and integrate them to my own experience. Re-readings are essential.
Rating:
Summary: This book is a must have
Review: This book cannot be ignored. After recommendations from co-workers, references to this book in some of my other books (Java and ASP), and the glowing reviews at Amazon, I decided I'd better get it. I am not disappointed.
Rating:
Summary: Fantastic Book !
Review: One of the best books I ever read. Required reading for any OO programmer
Rating:
Summary: Required Reading. Absolutely Fantastic!
Review: Design Patterns is required reading for all object-oriented designers, developers, and architects who want to improve and streamline their design skills. This book will open your eyes and teach you how to utilize widely accepted and standardized design patterns to implement efficient solutions for frequently encountered design challenges. You'll immediately recognize multiple instances within your own projects in which design patterns would have improved efficiency and reuse within the architecture. The authors take a very methodical approach to describe every aspect of each design pattern including applicability, structure, collaborations, and consequences to name just a few. The book is extremely well organized making it easy to refer to the catalog for a refresher on various patterns. One of the best OO books I've read.
Rating:
Summary: Two thumbs up
Review: If you were to buy only one book from Amazon.com this year...this would be it. Lots of examples in C++. It sometimes refers to smalltalk which I could care less. You can gain years of programming 'experience' from reading this book.
| 
