Rating: 
Summary: A must have classic for reference and browsing
Review: Anybody involved in object oriented programming should own this book and browse once in a while through it. It is the classic in patterns.Too bad that it is no book for reading from cover to cover though.
Rating:
Summary: One of the Best Books I Continue to Use
Review: In this age of techie books with a shelf life of 6 months, this aged book is as relevant today as it was the day it was written. Even though I consider myself a Java programmer (using UML), I still continue to use this book with examples in C++. The patterns in this book have stood the test of time, and are relevant in any object-oriented language.
Rating:
Summary: Classic in object-oriented development.
Review: If you have been in the software development for a while you will find that the patterns described in the book are very familiar. I also found the structure diagram of the patterns very helpful. Anyone serious about software development needs this book on his or her bookshelf. This book isn't an introduction to object-oriented technology or design. This book assumes you are reasonably proficient in at least one object-oriented programming language, and you should have some experience in object-oriented design as well. The book is a classic in object-oriented development, offering timeless and elegant solutions to common problems in software design. It describes patterns for managing object creation, composing objects into larger structures, and coordinating control flow between objects. The book provides numerous examples where using composition rather than inheritance can improve the reusability and flexibility of the code. Highly recommended! ....
Rating:
Summary: Developer? Project Manager, In software? BUY THIS BOOK
Review: Once you've got a few years of experience under your belt you'll find you start having general "favorite" ways of doing things. Meaning laying out you classes in a particular way. You'll find that giving these things a name and looking at others' named "patterns" is a heck of a good way to write software and communicate ideas to others. This book was kind of the first and kind of the best on the subject. So important its often referred to as the "GOF" (gang of four) or "blue and white" book. It uses C++ to illustrate its points but any oop-familiar person should be able to read it just fine. Its well written and avoids much of that high-browed abstract achedmenic language that most design books use. (often at the expense of both clarity and correct use of language). You'd be ill-advised to ignore this book. The ideas within it have prevailed already.
Rating:
Summary: Easy and delightful reading!
Review: I love this book! Very easy to understand and very practical. If you have been in the software development for a while and have practiced/payed attention to the software design, you will find that the patterns described in the book are so familiar - and now they are all nicely written down and thoroughly discussed. Isn't it wonderful! I also found the the structure diagram of the patterns very helpful. Highly recommended!
Rating:
Summary: Best patterns book ever written
Review: This is the bible of design patterns. Everyone that understands a little bit about object oriented design knows this book. It explains what design patterns are, how they are used and have a small catalog of very useful DP. Probably the most useful small list of patterns you will ever see in your life. Anyone serious about software development needs this book in the bookshelf, and, as far as I have seen, all serious developers have it handy. The examples are in C++ and the diagrams in OMT. A more modern approach would use Java and UML, but it absolutely does not depreciate the value of the pearls you will find in its pages.
Rating:
Summary: Not for "Programmers"
Review: This book is for Software Designers or Architects; if you've happy being a code monkey don't bother buying it. Some of the examples were in Smalltalk. I had never /seen/ a line of Smalltalk code before, and did not have difficulties following the Smalltalk examples. I am familiar with C++ though. The book is heavy; I not only read it not only once but twice. It will be hard to appreciate and understand the patterns without using them. Like a decent math book, it cannot instantly plant the knowledge in your head; it takes some practice. If you do not feel you would be (or would have been) capable of teaching yourself calculus, then there's no good reason to believe you will be able to teach yourself design patterns (though there is more material to cover in calculus, it's about the same difficulty and level of abstractness as design patterns). The reason I believe some people have disliked the book is for one of two reasons; they had insufficient knowledge of object oriented languages (Java complainers), or didn't understand that design patterns are extremely abstract concepts. You should know that C++ doesn't have first class functions and that Java only has single inheritance. Fully implementing patterns in Java will be tedious if support is not already built-in (i.e. Java's Listeners are it's implementation of the observer pattern). With C++'s MI and macros you can build some template base classes to implement "pattern plumbing"; like the ATL for COM. I will also concede that the book is not perfect, but it is the best one available on the subject of design patterns. In 7 years no one has done a better job. One complaint I have is that the language is so plain it hurts. I now greatly appreciate the dry wit of Charles Pretzold and the zanity of Andre LaMonthe. P.S. The diagrams are not in UML. Since UML requires a book in it's own right, for simplicity sake they didn't use it. 1999 BS Computer Science & BS Mathematics from Lawrence Technological University, "Theory and Practice" Magmai Kai Holmlor
Rating:
Summary: Wonderfully done
Review: This is by far one of the finest and most useful books in my library. It is a rare occasion that I find a book which not only shows you how it should be done, but also recognizes some of the pitfalls that are possible even with very solid designs. A fantastic reference and tool. I highly recommend.
Rating:
Summary: One of the best books I own
Review: If you consider designing applications you oughta get that book. I have been working with Pascal, C++ and lately with Java. And I had never read that sort of books before. What a shame! I did miss out on some very worthy information. The way the book is constructed is quite clever. The authors first start by some basics and then explain a few patterns via a small word editing tool (Lexi). As they go along, they explain why to use such and such pattern and also how. Then, they list a whole lot of really cool patterns. The way they wrote that part is also very good because not only they describe each pattern in a concise way, they also say why to use it, how, and what are the pros and cons. As I was reading it, I actually realized that the team that developped the "Java Developement Kit" relied heavily on that information. I also dicovered that I had been using some of these patterns myself without even knowing it. For once I finally read a software book without hundreds of pages of code. No filler in this one, guarantied. And plus, it's not even expensive!
Rating: 
Summary: A great book to be nibbled at
Review: The first time I picked up this book, I found it dry, and tough to read. I bravely worked my way through almost two hundred pages because I thought these were things I should know, but had to put it away because I was falling asleep. I realized when I put the book down, that I had remembered only maybe half a dozen things, and those only in an abstract sense. There were a couple things wrong about my approach. First, although I fancied I was a reasonably seasoned programmer, I was not a seasoned OO programmer even in my own imagination. Second, I read and read and read without coding, or even looking at any code. This is really much more useful as reference work than a textbook. Don't expect to pick it up, and learn good OOD without writing a lot of code along the way. Do go back to this book repeatedly as you are developing as an OO programmer. First, it gives you a vocabulary for common patterns as you encounter them, which helps you not only communicate with team members (by virtue of being canon, the book's vocabulary is widely understood), but also think about the problems yourself. Second, it gives some very good advice on the use of these patterns and their use together, which means that as well as being canon, it's <gasp> darn useful. I won't say that it's a must for every shelf... if you're not working in an OO language, even if the concepts are nice, many will not have reasonable, automatic translations into your language. However, if you are an OO programmer, you'd be missing out if you didn't have the ability to flip this book open at odd intervals when considering your design.
| 
