Learn more Shop now Learn more Shop now Shop now Shop now Shop now Shop now Shop now Shop now Shop now Shop now Learn More Shop now Learn more Click Here Shop Kindle Learn More Shop now Shop Women's Shop Men's



on 17 April 2017
I've had this book for years, after a more senior dev initially lent me his copy.
I've re-read this book so many times in my career and watched as it's contents went from obscure, to fad and overused reference to where I think it should always have been, an accepted classic containing great wisdom.
Study it, learn from from it, implement things they way it suggests - then learn that it is not dogmatic. Simply use it to help shape your software solutions into recognisable forms that can be maintained and evolved over time.
0Comment| 3 people found this helpful. Was this review helpful to you?YesNoReport abuse
on 7 July 2017
Great patterns for programming but rubbish patterns for knitting.
0Comment| 4 people found this helpful. Was this review helpful to you?YesNoReport abuse
on 19 February 2015
As a piece of classic computer programming writing, this is easily a 5*. It introduces a systematic way of explaining a commonly used idiom and captures this as a pattern. You might not agree with the patterns (I'm looking at you "singleton") but the importance of this book is that this is where the whole pattern movement started.
0Comment|Was this review helpful to you?YesNoReport abuse
on 20 October 2017
No nonsenses.
0Comment|Was this review helpful to you?YesNoReport abuse
on 11 May 2017
Thanks
0Comment|Was this review helpful to you?YesNoReport abuse
on 13 August 2016
Design patterns (the method) are a foundational part of modern CS and software engineering. Design Patterns (the book, aka GOF) is what kicked it all off. But the book is more than 20 years old now, and it shows. Is it still relevant? Is it still worth reading? With that question in mind I picked up the book again for the first time in many many years.

In short, yes it is still worth reading. Definitely so. Designing class structures is a significant part of most major software engineering projects, and doing it well reduces friction throughout the project, now and in future iterations. Whilst modern reactive, functional techniques subsume some of GOF or make knowledge of it unnecessary for the application developer, the API's and libraries these tools are built on almost always use patterns from GOF, as do other tools and libraries. Knowing those patterns makes using the libraries easier.

What's more, the book clearly makes the case and explains the value of concepts common to good software engineering, object oriented and otherwise. Decoupling, encapsulation, clearly defined responsibilities and others are all explained.

Of course, patterns are no panacea. You can make a good argument that design patterns are only necessary because of weaknesses in the languages used, that the need for them disappears in modern languages (and old, good, good-old languages like Common Lisp):

"The shape of a program should reflect only the problem it needs to solve. Any other regularity in the code is a sign, to me at least, that I'm using abstractions that aren't powerful enough-- often that I'm generating by hand the expansions of some macro that I need to write." (Paul Graham)

The Strategy pattern is a clear example of this, wrapping up functions in an object - and only necessary in languages which do not treat functions as first class entities in their own right. And using Singleton is generally accepted as a terrible idea.

(As an aside, Visitor is also sometimes presented as another unnecessary pattern whose motivation disappears if you use a good language - Scala, Groovy and C# come to mind, Wikipedia lists more. I'm less convinced by this claim, multiple dispatch is complex and easy to misunderstand. Explicit use of a visitor takes more typing but may be clearer.)

The book has clearly dated in other ways. The diagrams aren't UML (the book predates it!). The book depends on customs instead of what are now language-level features like interfaces. The heavy use of inheritance and subclassing is antiquated. A (to modern ears) obscure focus on micro-optimisation, warning that some patterns require instantiation of more objects and that this could be a performance concern. There is no consideration of concurrency and dependency injection doesn't get a look in. The absence of testing, although use of the patterns often presciently enables it much more than the "un-patterned" alternatives.

So there you have it: GOF is a hero, complete with tragic flaws. Well worth reading, but read it with the knowledge that a lot has changed in the last 20 years. Modern languages make some patterns redundant. There are other problems that patterns don't address. But for better or worse, I still find myself thinking in patterns most days of the week.
0Comment| One person 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 6 April 2015
It is very important book for software development and object oriented design, but this book is very old. The style of the book is so boring. Currently you can find a lot of books about same design patters written in much better way.
0Comment| One person 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| 16 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| 16 people found this helpful. Was this review helpful to you?YesNoReport abuse

Sponsored Links

  (What is this?)