This book is a classic and doesn't require any further presentations. It is THE Design Patterns bible and every OO programmer should read at least a couple of times.

The samples are in C++ and sometimes Smalltalk but that really doesn't change anything even if you are a Java or C# guy.

If you are looking for a quick way into patterns I'd recommend Head First: Design Patterns as your 1st reading, but buy both and get ready to start reading this one right after.

Overall a good book. In my opinion it is better suited to be a textbook for a software engineering course than a 'self help' kind of book. Can be a bit too theoretical for my taste, but it is an interesting read.

This book doesn't contain any Java hacks or UML 2.0 up to date notations, it contains the core concepts of software design patterns. The 23 GoF Patterns are described by their four inventors. A must have for software engineers.

unlike the last pattern book i reviewed (see my other reviews), this one has an attractive cover. i like blue.

Most of the books I have read about object oriented programming were about some specific language and failed to provide a more general way to think about solving problems without writing a lot of code. This book was a missing link for me and I wish I had read it sooner. The authors provide you with elegant ways to use object oriented language features to simplify your programming solutions.

When the specs on your project change and you have to re-factor your code, you may be able to use a design pattern from this book to simplify your solution and make your design more flexible with regard to the parts of the spec that are changing quickly.

This is a great book on design patterns. Not only does it cover the theory of what each pattern is and it's respective use. It also gives very concrete examples of the proper use of each pattern in C++. I highly reccomend this to any serious programmer.

Contents of Disign Patterns are more and more classical in software engineering. The work is unaguable the basis which lead to a growth of design patterns. This particular issue is a high-quaulity hardcover on heavy paper, and good print. Its an issue for all who like to have a personal library of important book in superior quality. Well useful are the two bookmarks available in the robust binding.

Being a total noob to programming, my friend got me into learning about Objective-C and Cocoa. I have bought many books on the subject and I'd like to say that this book helped me with my understanding of objective-c programming language.

Thanks to the authors

The book is wonderful and samples are very exciting and meaningful.But book is difficult,if you don't have any idea about design patterns,you cannot learn easily from his book.But If you are not new about Design patterns,this book is very useful.

I would recommend this book to any software developer, architect, or designer. Fit for all levels of experience. It is clear why this is so often referenced in other development literature.

I have read this book many times over. I purchased
this book many years ago and I still reference it today. For those
who are interested in OO design this is the best book I have read,
followed by John Lakos "Large Scale C++ Design". This book will
have you thinking about how to design software, and if you are
diligent, eventually you will be designing your own patterns.

This book is a definite must for any language, since it will
change the way you view software.

I found the case study very helpfull. The patterns explained in a very clean way, so I recomand every developer that is interesting in design patterns, refactoring etc to read it.

This fascinating and extraordinarily clear text guides you in such a persuasive way through the world of software design patterns that once you start reading it you won't want to stop until it is over.

I don't have much formal programming training... much of what I've learned has been through self study. As a consequence, many times I'm not sure if I know something or not. Usually, I try to convince myself I know something but a tiny bit of doubt remains in the back of my head. This is the case for me with respect to object oriented programming. I thought I understood what object oriented programming was about, but I would only use it for certain parts of my programs (using perl, where things are not necessarily object oriented). Also, I would have trouble understanding large OO'd software packages. Reading this book really caused things to click in my mind and I realized what exactly object oriented was all about, how to use object orientation, how not to use it, etc.

Some of those who gave this book low ratings might reasons from their situation, but for me this book helped a lot. I'll agree that the concepts are abstract and difficult, but the authors set up different paths thru the book depending on the readers goals. I think a beginning programmer would get blown away by this book, while experts might know it all from good teachers or painful experience. For me however, this book gave me a bunch of "aha!" moments as the authors explain situations that make programming tricky and explain the solutions.

Also, the book is nice and solid w/ two bookmark ribbons (at least for the hardcover version). Very high quality and not so expensive compared to college textbooks.

Excellent explaining about the design patters even for those who are new to it.
The only problem is that the samples are in C++ wich should be expected because the book was printed in 1995.

10 years ago this book revolutionize the way programmers see object oriented programming. At that time, it was essential to read it. In fact, I remember that employers were testing candidate knowledge on design patterns at job interviews. Today, I consider this book as a classic that I would recommand to read for everyone that has just learned object oriented programming but it is less essential than it used to be as design patterns knowledge has spread in the litterature and you could even learn about them just by working on existing code. That being said, this book is still very valuable even for people that already know about patterns. I am on my second reading after many years of using the design patterns and I am picking up new insights that has escaped my attention at the first reading.

clearly defines design patterns, how and when they should be used, and factors to consider when using them. a very useful book for any software development work. the only disadvantage with this book is that its examples of each design pattern are sometimes convoluted and confusing.

Not even having cracked into the actual patterns yet, this book has already helped me in the way I think about object-oriented design.

As I read I keep thinking back to past projects and thinking about the techniques being described and how much they would've helped me at the time.

Buy it now, don't hesitate.

If you are a software developer, buy this book, period. It is expected that any professional developer has read this book front-to-back!

I think every Solution Architect or Software Engineer must have this book. It's the start of all.

This book is overrated, but it does have utility in bringing to your attention design patterns --which should be obvious to any good programmer--such as the Singleton (object only capable of instantiation once).

Why do I say obvious? Because any programmer worth their salt will over time develop their own home-grown library of patterns and exemplars to reuse. This book merely calls attention to this habit.

Also, as other reviewers have pointed out, the text is too generic and abstract, unless you're into that. Donald Knuth anybody?

Plus the book is too expensive--if you must, buy it used like I plan to. That's right, I haven't read it yet. But I know enough just reading these reviews; sometimes you CAN judge a book by the cover. I am over the age of 13, yes.

Of all the programming books that I've ever read, this one has had the most impact on my programming. I require that all programmers who work for me read Design Patterns.

Muy bueno, muy claro y tiene buenos ejemplos que permiten asimilar los conceptos y llevarlos a la práctica

Really makes clarity on OO programming patterns giving a complete overview and nice examples. Uses UML to describe pattern classes, sequence diagrams and collaborations. Maybe sometimes it's not so concrete in examples and keeps itself too generic.

It's a classic and a must have for the OO developer.

Good basic reference book for design patterns. The organization is NOT for reading ease, but for easy reference when you know what you're looking for to be reminded exactly what a particular pattern is all about. One sentence synopsis--Encapsulate what you expect to change.

This book does a great job of explaining patterns and pointing out benefits and drawbacks to each one. As an aspiring OO developer of business applications though, this books does not provide much guidance. The examples are given for real-time applications like user interfaces for a drawing application, etc. Applying these patterns to a distributed application with a database backend that records everything is a tough leap to make. I give it a high rating because it does its job well, however, I wish it would have addressed a broader scope of application types.

Although this book initiated the now-famous design patterns phenemon,I think we have better alternatives these days.The book has sample codes in C++.

I personally liked Head First Design Patterns.

Everyone who wants to write OO code needs to read this book. No, let me re-phrase, *must master* this book.

When you have *mastered* this book, we will award you a blue belt and you can then move on to Martin Fowler's book.

If you don't know which book I mean by "Martin Fowlers" book, you haven't mastered this book. So don't expect the blue belt until you do.

Expect only beatings with the blue belt.

"Design Patterns" (GoF = Gang of Four) is a signicant and, in many ways, a difficult work for the modern reader (me) to digest. The material in this book is highly self-referential: to understand a particular design pattern, it is important to be familiar with many similar, if not all, design patterns.

I would like to offer a suggestion about an approach that worked well for me. As an introduction to the patterns field, I first read "Head First Design Patterns", which offers a highly competent but light-hearted presentation of the same patterns covered by GoF. The Head First book gave me a thorough overview of the patterns landscape, as well as gently drilling me on pattern application. The Head First book goes out of its way to provoke the thinking reader, while being the most entertaining computer science text that I have ever read.

With this introduction, I found "Design Patterns" to be a much more accessible and friendlier work.

Like many of the typical Computer Science classical texts, you've got to read it, if only to say you read it :-)

True, the book is C++ focused (it will be somewhat tough for those who only know Java / C#) and it has quite a level of sophistication (probably aimed at those in a Computer Science degree or master's programs). But, that said, it really started a big part of the revolution in OO - open source gave us reusable code, but design patterns gave us reusable solutions to design problems; and this was the book that really "lit the fire" for patterns.

If you read this then you don't need to read too many more design pattern books as most of them are just regurgitations on the themes outlined here. I've learned so many great solutions from this which I use and re-use in my software development year after year.

I didn't give it 5 stars simply as it's a tough read at times and sometimes you need to re-read a paragraph / section just to make sure you understood what was said.

This is my primary resource for reference purposes. It's my first stop when I need a specific pattern. I recommend the Head First book for learning; this book for the basic patterns; and Martin Fowler's Enterprise Application Architecture book if you are designing business applications. Also, Partha Kuchana's Design Patterns in Java book is great if you are using Java.

It is a good direction for the Software Engineers to learn about patterns and designing the applications.

This is the best design patterns book ever
language is simple.
examples are usefull
this is a must-have book

Design Patterns is an essential book for every software developer or architect. It was ground breaking for it's time, describing reusable design patterns that recur in software development projects.

The presentation used makes reading and understanding the concepts easy, and allows one to learn and apply the patterns a few at a time. It's a great reference book, and the distilling and naming of the patterns really aids communication between developers.