Rating: 
Summary: Read it¿ Please!
Review: I was still a fledgling developer at the time I attempted to first read this book. My initial impression was that it was outdated and dry. But as the months and projects went by, I began to understand the importance of patterns in general and this remarkable text in particular. Indeed, without much experience in the field, one might find this book too theoretical, or even irrelevant to practical work. But one day, you'll find yourself faced with a particularly nasty problem, and all of the sudden a pattern will flash in your mind, and click! The connection is made, and the problem is solved. It was very gratifying for me to experience this feeling over and over again; as I'm sure it would be for any junior developer just getting his feet wet.Two words of advice come to mind, though: First, please keep in mind that the patterns herein are not the only ones out there; there are many others documented in various other books and articles. Second, be very careful of the Singleton pattern; it is the most overused and abused of the patterns, simply because it is easy to implement. And note that the text says nothing about the destruction of a Singleton, so watch out. It is my opinion that this book should become mandatory reading for all software developers of all levels, and the patterns within it should be as common a construct as an "if" statement or a "for" loop. Please, do yourself and your profession a favor and read this book.
Rating:
Summary: Getting a little long in the tooth now.
Review: I read this book and then realized I have been using "patterns" for years, I just did not know that they had names. That said, this book is a difficult read for anyone that is not an expert level software designer. It borders on being TOO much theory and academia to be under stood. Every intermidiate to junior level programmer/developer I have introduced this book to gave it back to me and said they did not understand a thing in the book. After an explaination on how to read it and some concrete examples they said it made a "little" more sense after 3 or 4 more reads. Not for the faint at heart, but everyone considers it to be the "bible"
Rating:
Summary: One of the best books of any type I've read
Review: I read it sitting under a palm tree on the beach over last summer. All I can say is that it takes a REALLY good book to make me not even notice the girls in the bikini's. I'm only a junior programmer but I can honestly say that reading this book was one of the most wonderful experiences of my life.I think all junior programmers should read it as soon as they can get their heads around the ideas in it. Designing good software is really hard and the earlier you think about design the better. It gives you a wonderful perspective where you are headed while you are learning. Big thanks to Eric Gamma, Richard Helm, Ralph Johnson and John Vlissides for writing one of the best books of any kind I have ever read.
Rating: 
Summary: Useful, but not all that useful.
Review: I've been a C++ programmer for quite a while. Every three years or so, it seems there's some revolutionary text or other that promises huge leaps forward in the art of software design. This book, extreme programming, various modelling languages and techniques, 4GLs, etc etc. I can remember people arguing that everything C++ would be different once it got a standardized string class. The patterns in this book lie largely within my experience, and none would not be obvious without careful analysis of software requirements. Really, what's new about an Iterator pattern, or an Interpreter, State, Builder, Adapter, or Proxy? In my experience, this is like people raving on about the benefits of hash tables or doubly-linked lists. If you want a mind-opening experience, do something interesting (and hard at first) like writing LISP code to interpret an arbitrary expression using only compiled functions. No, your negative college experiences do not apply. In conclusion, if you're new to programming, this book does contain useful wisdom that comes from experience, and this is largely hard to come by. As another bit of wisdom: avoid trying to simultaneously apply as many patterns as possible. If you're an experienced programmer, though, you probably already know and can explain everything in this text.
Rating:
Summary: Composition + Delegation = Flexibility
Review: This is an excellent book which teaches more than a few gems of software development and design. Developing to interfaces to be independent of implementation, favouring composition over inheritance, and the art of delegation are but a few. The design patterns themselves are awesome and they take a while to sink in. I would be surprised if you could read through the book once from cover-to-cover and understand when and where each design pattern could be used. The authors give some good examples, but you really need to USE the design patterns to fully appreciate them. But, bear with it, this is a book worth studying! Study each design pattern, apply them, be enlightened. One thing that struck me is that many of the patterns are similar and overlapping. They are not as distinct as one might originally think. In fact, it has become clear that the majority of patterns consist of composition and delegation, DELEGATION being the key concept. Understand and learn the art of delegation and you will become a better designer of design patterns. Understand the art of design patterns and you will become a better designer of software. A truly excellent book that facilitates knowledge transfer of software design best practices. The beauty of this book is that it has probably contributed more to the adoption and spread of the software design pattern paradigm than the actual design patterns themselves. Bravo! We are all better off for it.
Rating:
Summary: A classic
Review: This is a classic book. There are alot of copies of this book. If you are a advanced developer, read this book first and then get a newer version for your prefered progrmming language.
Rating:
Summary: What a great book!
Review: If I choose the best computer science reference I have read,
I don't hesitate to pick up this book.
This book is great: nice introduction about OO, good format.. Just buy it, and read, read, read. I alway read this book before starting design new software. thanks a lot, GOF.
Rating: 
Summary: the reference on the topic
Review: This book is a catalog of 23 more or less useful object oriented design patterns in more or less wide spread use. Don't get me wrong, I do like the book's intention of introducing a common vocabulary of solutions to particular engineering problems and it is certainly valuable having these solutions collected and organized in one place. However, I think it is unnecessarily dry and hard to read. The source code examples on the other hand are written in easily understandable C++ with brief mentions of existing implementations or implementation possibilities in different languages. I would have wished for more and more elaborate examples though. The authors often mention the possibility for mixing several patterns to archive their combined strengths, but seldom give code examples demonstrating this - thus leaving the harder problems to the reader. I would have liked less emphasis on the sometimes obscure and outdated 'known uses' section for each pattern - which cites where the pattern has successfully been applied - in exchange for more actual code examples. Sometimes the 'known uses' section reads like an excuse for including that particular pattern, which should be unnecessary, the use should be self evident or the pattern omitted. That said, I still haven't found a use for some of the more esoteric patterns in my everyday designs and application of C++. The book is still a valuable reference, since many patterns (factory, singleton, observer, command) really are in widespread use and you don't want to miss out on their usefulness and seem ignorant in discussions about them ;)
Rating:
Summary: This book changed how I program
Review: I used to think that OOP was all about building elaborate class hierarchies. Reading this book I realize I was wrong. Large hierarchies lead to inflexible design. Flexibility is achieved by having objects from different classes collaborate. This book describes 21 different patterns for such collaborations. Each pattern is presented in a way that makes it easy to understand and easy to incorporate into your own designs.
I strongly recommend this book to any intermediate OOP programmer.
Rating:
Summary: Centers on Smalltalk and C flavors.
Review: If that's your thing, this is your book. If you're looking for Java design pattern implementations (as I was), there are better choices out there.
| 
