Shop now Shop now Shop now  Up to 70% Off Fashion  Shop all Amazon Fashion Cloud Drive Photos Shop now Learn More Shop now Shop now Shop Fire Shop Kindle Shop now Shop now Shop now

Customer Reviews

4.5 out of 5 stars
4.5 out of 5 stars
Format: Hardcover|Change
Price:£27.74+ Free shipping with Amazon Prime
Your rating(Clear)Rate this item

There was a problem filtering reviews right now. Please try again later.

on 5 May 2000
This book is compulsory reading with no real competition.
However it's very badly written. People often mention (without complaining? ) of what a lot of hard work this book is. In fact almost all the patterns are easy to grasp, but rubbish explanations in conjunction with inconsistent use of terminology and weak examples obscures each pattern to the extent that the reader's brain soon falls out of their head.
I can't point to any one example in the book since they are all as bad as each other. But re-reading the visitor pattern finally inspired this diatribe.
I can't understand how these guys have got away with it. It's absurd. There must be an unimaginable number of people who have given up on Design Patterns due to this book, seminal or not. What a shame. The value of patterns is almost incalculable.
If only Odell & Martin or Martin Fowler would condescend to give us something readable!
44 comments| 113 people found this helpful. Was this review helpful to you?YesNoReport abuse
on 9 October 2010
I've worked in the IT industry exclusively since 2006 when I graduated from university. This book was required reading for the Design Patterns module I elected to do. Back to 2010 and I've found myself doing more OO and re-factoring of some complex code bases. I picked up my copy and realised just how out-dated the examples are, especially for developers using Java / C#. The examples might be more relevant to C++ developers but I find the book really heavy going and quite hard to digest.

Design patterns are not difficult and books like Head First Design Patterns are better introductions to Designs Patterns than the GoF book. Unfortunately the Head First series does not cover all the patterns in the GoF and the Head First book is not designed to be a reference book. That said I remember much more of what I read when compared to this text.

Unfortunately there is no alternative that provides essential coverage of some of the most common patterns used day to day.

In short if your new to patterns and have a limited budget go for the Head First Book, while not a reference its a much gentler introduction.
0Comment| 32 people found this helpful. Was this review helpful to you?YesNoReport abuse
on 7 March 1997
This book really changed my way of thinking about object-oriented design. The idea is that when designing a new class hierarchy, though implementation details may differ, you often find yourself using the same kinds of solutions over and over again. Rather than approaching each design task out of context as an individual, isolated problem, the strategy is to study the task and identify the underlying design pattern most likely to be applicable, and follow the class structure outlined by that pattern. It's a "cookbook" school of design that works amazingly well.
There are other advantages to this book. It isolates 23 of the most common patterns and presents them in detail. You wouldn't think that 23 patterns would be enough, but once you become adept at recognizing patterns, you'll find that a large fraction of the patterns you use in practice are among these 23. For each pattern, the book carefully presents the intent of the pattern, a motivating example, consequences of using that pattern, implementation considerations and pitfalls, sample code (C++ or Smalltalk), known uses of that pattern in real-world applications, and a list of related patterns.
Upon first reading, you will start to recognize these patterns in the frameworks you see. Upon second reading, you'll begin to see how these patterns can help you in your own designs, and may also start to see new patterns not listed in the book. Once you become familiar with the pattern concept, you will be able to originate your own patterns, which will serve you well in the future. One of the most valuable contributions of this book is that it is designed not merely to help you identify patterns, but to give you a sense of which patterns are appropriate in which contexts.
I think this book is particularly valuable to many C++ and Java programmers, because of the dynamic and flexible design philosophy it follows. (Its two fundamental principles of reusable OO design are: "Program to an interface, not an implementation" and "Favor object composition over class inheritance".) I've found that many C++ books unfortunately tend to emphasize a rather static and inflexible design philosophy. Many C++ programmers do not realize how the language and the books they've studied from have been limiting their thinking until they have been exposed to ideas from other lanugages. The authors of this book have obviously been influenced by other languages as well, especially Smalltalk, and have brought many of its best lessons to C++ design. Most Java books seem to take after the C++ books, even though Java is a more dynamic language. This book may help Java programmers take full advantage of the extra power offered by their language, if they look deeply enough into some of the lesser-known features its runtime system affords.
Last, but not least, this book is valuable because it names the patterns it uses, and so gives programmers a common vocabulary to describe design concepts, rather than particular implementations. You'll find yourself saying things like, "That would be a good use for a Decorator", or "Should we use a Facade or a Mediator in this case?" I encourage readers of this book to use this vocabulary with other programmers.
In summary, this is one of the few books that I think belongs on every programmer's "must-have" list. Not to overuse a cliche, but like object-oriented design itself, the pattern concept is one of those rare paradigm-shifts in computer programming. It is equally valuable to expert professional and novice student alike. The book has a home page at [...]
11 comment| 23 people found this helpful. Was this review helpful to you?YesNoReport abuse
on 29 December 2004
As you will have guessed from the other reviews this is required reading but if you do find it hardgoing I'd recommend reading "Design Patterns Explained" which is a lighter introduction ("Applying UML and Patterns" by Craig Larman is also useful for this).

Once you get the patterns, and more importantly once you understand why they are good designs, I would recommend looking at "Pattern Hatching", "Agile Software Development (2nd edition)" and "Refactoring to Patterns" which cover the use of patterns.
0Comment| 12 people found this helpful. Was this review helpful to you?YesNoReport abuse
on 15 July 1997
The book commonly referred to as just "Design Patterns" begins with an introduction to Object Oriented Programming and continues with a catalog of design patterns. I wouldn't recommend this book as your first OOP book, but I believe that once you have a basic understanding of OOP, you can try to cope with some of the basic Design Patterns in this book. If you are an advanced OO programmer, it's helpful to just quickly review any pattern you're about to implement and examine possible implementation issues.
0Comment| 15 people found this helpful. Was this review helpful to you?YesNoReport abuse
on 24 May 2001
This book is not an easy read and will only make sense if you know an OO language, understand polymorphism and are prepared to loosen your grip on your hacking axe. If you are hell-bent on smacking your keyboard like a demented monkey then this is not the book for you. The patterns in this book will, however, help you with anything from speeding up build times (try using 'bridge' to insulate commonly used classes) to using polymorphism to implement state behaviour (try 'state'!). Buy the book or a banana - the choice is yours.
0Comment| 32 people found this helpful. Was this review helpful to you?YesNoReport abuse
on 20 July 2004
This book contains really useful information, and really can benefit you and your job, but it is also a tough read, requiring saintly perseverence (see comments on first half!) or deep concentration (see comments on second half!).
The first half of the book is a large example, which reminds me of the mind numbingly boring and irrelevant case studies presented to me at university... in fact, I got bored, and stopped reading it. Maybe there's a twist at the end... I don't know - I got bored.
The second half, on the other hand, contains fantastic descriptions of patterns, object model diagrams, and details on how and when to use them. These sections need your full attention, and you need to know something about OO design already, but if you've got all that it's great.
And if you're suffering from insomnia, you can always start reading the first half of the book...!
0Comment| 13 people found this helpful. Was this review helpful to you?YesNoReport abuse
on 26 May 1999
Starting from what design patterns are, this book then presents how patterns can be used to build a document editor. What follows is a list of great patterns for various purposes. This book is a great tool for anyone who is interested in OO design. You read it, and read it, and read it...and then when you finish you read it again! This book lives on my desk now... I was a bit dissapointed that multi-threaded patterns were not discussed at all in this book, but I'll still give it a 5 because I do think it is excellent.
0Comment| 6 people found this helpful. Was this review helpful to you?YesNoReport abuse
on 10 October 2006
I read a couple of design patterns books before this one and quickly realised that I need to get this book as soon as possible. The others I've read all referenced it and as a design patterns catalog it presents patterns in the purest form. It is extremely easy to read in terms of clarity and layout and certainly in a format that will appeal to programmers. Although most examples are either in C++ or SmallTalk you should have no problem keeping up if you specialise in other languages including scripting languages like PHP5.
11 comment| 9 people found this helpful. Was this review helpful to you?YesNoReport abuse
on 2 July 1998
The authors define design patterns as: descriptions of communicating objects and classes that are customised to solve a general design problem in a particular context. A design pattern names, abstracts, and identifies the key aspects of a common design structure that make it useful for creating a reusable object-oriented design. The design pattern identifies the participating classes and instances, their roles and collaborations, and the distribution of responsibilities. Easy to wrap your mind around, eh? Design Pattern people are in love with the power of abstraction and generality. You might even say they prefer to impress rather than inform. However, somehow you are going to have to learn this stuff, even if only to get into the heads of the guys who designed the AWT. Try starting with the code samples in the Design Patterns book. You have to read this book at least twice before it begins to make any sense. However, if you want to call yourself a programmer you MUST understand this book. I hope somebody writes a version of this book for Java programmers. It is written from the perspective of C++ and Smalltalk. This is a book where the you want the hardcover version. You go back to it again and again.
0Comment| 8 people found this helpful. Was this review helpful to you?YesNoReport abuse

Sponsored Links

  (What is this?)