Rating: 
Summary: Must read, but requires some sophistication
Review: As you probably already realize from the large number of reviews, this book is one of the seminal books on patterns in software development. If you are a professional software developer, you must read this. If you are learning to write good software, this is a book that you will need to take on at some point, but I urge some caution.In particular, many of the patterns in this book represent highly distilled wisdom about effective solutions -- distilled so far that, unless you have implemented code that realizes the pattern in question already, you may have trouble absorbing the material. I find that programmers-to-be who dive into this book, often end up talking annoyingly about "applying patterns" without having a real grasp of how these things translate (with some distortion and compromise) into real projects. That being said, an excellent way to bridge the gap is to read this book along with "Pattern Hatching : Design Patterns Applied" by John Vlissides. That book is a chatty companion piece for this one -- I found myself understanding how to incorporate patterns into my day-to-day design work much more after reading both books. See: Pattern Hatching : Design Patterns Applied [also at Amazon.com] Overall, while this book is an extremely important contribution to software developers, it is structured in a way that makes the material difficult to absorb if you aren't approaching it with substantial previous knowledge about developing software. You can start with some of the simpler patterns (Singleton, for example) and work through the harder ones, but only by implementing projects and stumbling upon these yourself will you really feel a flash of recognition as you read them in the book.
Rating:
Summary: Very important topic, mediocre presentation
Review: There is no question that design patterns are an important part of object-oriented development, and this is the definitive work on that topic. As good as it is, it does have its weaknesses, although some of them can be dismissed as points that are mere personal preference. For example, I would have preferred that the code examples be written in Java, but I would not penalise the book because of that. In addition, the style of the writing is very academic, but that is probably due to the authors' background and may even have been done deliberately. However, I did sometimes find the UML diagrams more confusing than helpful, and the code samples were somewhat sparse. The explanations were largely adequate, although I sometimes found myself having to re-read the description of a pattern many times before I felt that I understood it. Even though, I would sometimes wind up being confused about the difference between two patterns or exactly what a pattern represented. Part of this I think has to do with the nature of design patterns -- they are by definition somewhat high-level and abstract. Even so, I could not help but think that they could have been described better, which is why I only give this book four stars.
Rating: 
Summary: Must have book for developers
Review: As stated before this is a catalog of design patterns for Object Oriented design and development. You don't just read this book. You study it. When done you should have an effective vocabulary for design discussions. Write down the names of all the patterns and as much detail as will remind you of why you would use it and when. Keep this memorized and as you work on a new system or piece of a system the patterns will reveal themselves to you saving alot of work. Also you will better understand why some well designed systems were built that way and how some poorly designed systems could be better.
Rating:
Summary: Revolutionary
Review: I have heard numerous accounts from programmers of varying experience levels on how this particular book and set of concepts changed the way they approach object-oriented software. Object-oriented software is about object interaction, implementation is trivial in a system where a reasonable framework is set. Good object-oriented design, it is true, existed before Design Patterns was introduced, but it is the way object-oriented design was given a set of commonly agreed intuitive names of generic object traits that this piece of holy software scripture earned its place in the 5-star-league. By discussing and using agreed concepts, the processes involved with design, implementation and refactoring can be exposed to a much broader audience, because applying these naming conventions in code implies desired functionality. The approachable, yet rigorously thought-out guidelines in this book further makes reviewing code more efficient because comparison against tested design approaches can be utilized, pointing out many common pitfalls. A word of caution. This work is very inspirational, and junior level programmers might, upon leafing through this book, emerge even too enthusiastic on applying generic design on systems where simpler approaches would be more logical.
Rating: 
Summary: Way overrated
Review: This book serve mostly as historical note. In its time pepole use to think that "the answer" is OOP/OOD. If this book prove anything is that OOP/OOD is NOT the answer. For begginer this book is usless since they do not have the knowlage to read it and evaluate it ideas. For experience programmers this book may serve to prove that in some implemention they were using some ideas that other were using. For those with experience that realy find something new here then I think it only time for them to realized that they are very poor designers. You see in C++ you have many tools to use (and OOP is only one). This book seem to be writing by people who start to program in programming laguages that force you to use object - such as smalltalk. C++ is much more then that and now we know (I realy hope that those who are using C++ know) that OOP is just anther thing to use and not the most important one. Anther problem is that it may lead people to use those patterns in much the same way as OOP - seeing pattenrs everywhere (like many programmer who using OOP see object everywhere). Anther problem is that it like those books about "how to succeed in life in 10 steps". Well like there is no magic in being successfull (you can't realy learn how to become one) there is no way in becoming good designer. If you don't know how to design system, no book can save you. Designing good software is like art, if you don't have the gift you cannot do it - and ideas from architecture are the worst to take from. When you designing a system, look in the system that you are building for ideas and not in a book that try to solve problems that are not even there. By the way for Java/C# programmers it maybe more usefull (beacuse those lagauges only support OOP). If you are C++ programmer then learn the laguage realy well (there's much to learn), this is the only thing that will realy help you.
Rating:
Summary: The original and definitive work on OO design patterns
Review: Design Patterns, referred to warmly as the "Gang of Four" book by it's fans, is the book that introduced me to the world of design patterns. After reading this book, you'll immediately see patterns from it everywhere - many classes you use every day will suddenly all fit together in a pattern. Besides being a tool for writing good maintainable code, patterns are a crucial tool for communication among developers. Knowing even a half-dozen of the basic patterns will facilitate communication among team members immensely. For instance, you may be having a whiteboard design session with another developer or two, explaining some particular design you have in your head. Instead of having to detail 3 or 4 or more classes and how they would interact, you could simply say that you are thinking of using the Factory pattern here, and the Decorator pattern over there, and the others will know exactly what you are thinking. The patterns are grouped into three groups: Creational, Structual, and Behavioral patterns. Each pattern is considered in turn, each having sections detailing the intent of the pattern, the motivation for using it, the consequences (both good and bad) of its application, collaboration among the objects involved, and examples. The examples are mostly in C++ with a small dose of Smalltalk, but the patterns are equally applicable to any object-oriented language, Java in particular. Some of the patterns can be implemented even more simply and cleanly in Java, as a result of language features such as dynamic class loading, among others. This book is well-written, and it's a quality book well worth owning. It even has two nice ribbon bookmarks attached to the binding which makes to book even more practical as well as handsome.
Rating:
Summary: Must-read for Object Oriented Programmers
Review: This book is a very interesting discussion of certain Object Oriented structures that continually reappear in solutions to computer science problems. This book outlines each pattern in great detail, giving its definition, use, and examples of each. The detail may be a bit much, causing the book to drag a bit, but it is invaluable later on when using it as a reference. The key benefits of design patterns are that they provide you with a common OO vocabulary for discussing these issues with other developers, and that they allow you to reuse certain core elements of an application, not having to solve a particular problem again and again. The book is an essential read for an intermediate to advanced OO developer. I hesitate to give it 5 stars because I think the book would have benefited from a more concrete sample application that brought in the patterns and showed the ways in which they communicate with each other, with sample code as opposed to diagrams. Even so, this book is great.
Rating:
Summary: Will change the wake you develop software
Review: When I first saw this in the bookstore, I didn't really know what to make of it. Intending only to glance quickly through it, I found myself immersed in the new and exciting world of design patterns. The first 70 pages or so of the book take you through the creation of MS Word type of word processor showing you the patterns used to achieve its design. The rest of the book serves as a reference for the 24 design patterns, and includes small examples, as well consequences of each pattern. If you have not yet studied design patterns, then I suggest you begin with this book. You can not survive in a true development environment without them.
Rating: 
Summary: Don't bother with the cd - get the book
Review: The CD is EXACTLY like the book. Yes, you can browse it with a web browser, but it's really not much different. The thing that really ticks me off is that once you buy it you can't return it because it's a CD. I specifically bought the CD because it mentioned code samples, so I thought, "Oh that means it has a working implementation of the code samples for me to play with." The major problem with this book is that the code samples are really all code snippets. They show you enough code to give you an example, but not enough for you to play with. It's one thing to read a few lines of code, but another to see the code in action in a full, working program. So I thought the CD was different. Nope, it doesn't have a specific section with working code samples... the code samples are the code snippets from the book, you have to cut-and-paste them straight out of the chapter to use them... but you can't because they're not a full working example. Whoopdeedo! The samples are only about 10 lines each, you can easily just type it yourself. Don't bother buying the CD, just get the book. At least with the book you can write on it and underline things.
Rating:
Summary: A classic that applies to virtually any language
Review: I picked up this book at the recommendation of another book (Guru's Guide to Sql Server Stored Procedures) and was surprised at how well what it teaches applies to the languages I use most of the time, VB.NET and Transact-Sql. The other book had a chapter on design patterns in Transact-Sql and showed how some of the ones in this book as well as a few new ones were common in Transact-Sql stored procedures. Thanks to that book and this one, I now look at code differently and know a pattern when I see it. Even for non-OOP languages, this book is a godsend for those who care about design. The book is also extremely well written and as clear as it possibly can be. I read through it the first time over a weekend and came away charged up and ready to pattern the world! I can't apply everything it teaches to my daily work, but enough of it applies that I highly recommend this book regardless of the language your using.
| 
