Design patterns : elements of reusable object-oriented software

If you are total newbie with OOP programming this book isn't for you. If you know and understand and even better use/implement, without problems, OOP concepts like polymorphism, abstraction, encapsulation, inheritance etc, and you want to go a step forward in your programming skills, then this book is for you.Not only for stand-alone desktop programs or mobile applications but for web applications also, you will find Design Patterns useful for your code. You will understand how to solve some basic logic problems with design patterns that will render your code reusable and easy to adapt it to any program you make.

This book is the original and best. Yes, it is pretty dry - but you don't read it like a novel. Simply scan through the various patterns so you know that they exist, then when the need comes up and you think "I'm sure there is a pattern that could be adapted to solve this problem" - you go back and read in depth to refresh your memory.Every team who use object-orientation should have a copy in the office to refer to.If you want a softer read, there is a Head First book on design patterns - but I would still recommend having a copy of this book to refer to when you want to implement and adapt a pattern in real life.

Being the well-known classics of software engineering, this book doesn’t need another review. It is a must to have in a collection of any serious practitioner in this field.

I would recommend this book to everyone who wants to further their knowledge about general OOP design patterns. This book is a well-known classic, not without a reason. I believe other reviewers already described why this is a must-read for any senior OOP developer. However, there is also a few things I didn't like about this book.- Programming languages. I do vast majority of my coding in Java, sometimes I code in another JVM languages. This book provides examples in C++ and/or Smalltalk. Even more, this book was written before Java was a thing! This has to have an impact on how easy to follow are some of the examples. If you write Java 8 code, I bet you know what is the difference between external and internal iterator. At the same time, C++ friends will probably be less obvious to you, and the concept of e.g. enum-based singletons will not be mentioned at all. If only someone could write this book once again, but focus on Java-centric point of view.- GUI-based examples. For nearly all the patterns, there is a GUI-related example. I am deeply alergic to GUI development and would appreciate more examples relating to backend functionalities.- Didn't we evolve since then? Many of these design patterns are explicitly targetting challenges around excessive memory utilisation and other past limitations. We can do better now. Same constraints still exist, but are applicable to a very different extent. I can see people blindly following some of these patterns today in the field, with very little reflection upon the actual problem they are trying to solve. Today good programming is frequently not about making the application consume less memory, but about making it easier to understand and change. The problems we are trying to solve have changed, therefore the solutions we apply need to change as well. Keep it in mind while reading this book - not all of that is of equal value today, as it was when this book was first published. This takes us swiftly to the next point, which is...- The pattern catalogue. While many of these design patterns are still valuable these days, there may be others which are more valuable. Just compare and contrast the builder pattern, as described in this book vs the one described many years later by Joshua Bloch.My recommendation - read this book if you haven't done it already. Learn all the good things, just don't forget the world has moved on since then.

Almost 30 years on, this is still the baseline book for design patterns. The descriptions are comprehensive and the examples help clarify what is intended, albeit using C++ as it was written in the '90s. There should be no problem implementing the ideas in a modern incarnation (indeed the STL encompasses some ideas), or in other OOP languages for that matter.

The Gang of Four is already well-known in Software Industry, with many of the patterns introduced in this book are very popular in real world projects. But that's not the main point of why you need to read this. The way the four authors distilled their experience, explained the abstract knowledge, demonstrated the use cases and categorised the patterns are classic! Reading this book is not only lot of fun, but also really enlighted in terms of deeply understanding why you could do better in the past and how you actually do better in the future. Last but not least, this is far beyond a one-time book, it'll be your patterns dictionary in the future.

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.