Design patterns : elements of reusable object-oriented software

Easy to pick up and perfect as a reference guide. Using these patterns in your work will make it easier for yourself and others to get up to speed when you come back to it later

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.

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.

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.

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.

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.

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.

Design patterns is the bible that popularized the design patterns movements. While it triggered a lot of offspring books this one is still the most important one by far. It documents 23 design patterns, most of which are still widely used today. There is only one caveat for beginning programmers. Time and time again they told me "I don't get it"' after reading the book. You probably need to bump your head a few times against the problems that these patterns solve before you actually see why they are so good. Highly recommended.

iyi ürün

It is really the bible in design patterns. If you are considering learning design pattern, I believe you only need this book as the only one book on your way to master it. Though the language used in the book including smalltalk (which is dead now), the examples and explanation are really straightforward. For readers who are not familiar with design patterns at all, I recommend to first start from chapter three, which has a lot of details in each design pattern. Then come back to chapter one and chapter two, which are summary and comparison for each pattern.

Par ses explications lumineuses et concises, illustrées d'exemples très accessibles, cet ouvrage fait ressentir au lecteur l'intuition de chaque design pattern, et presque imperceptiblement, la transforme en évidence. Écrit dans un style très agréable, comme on en rencontre rarement dans les ouvrages techniques, il se lit comme un roman, tout en présentant une structure très ergonomique, qui permet au lecteur de le parcourir dans l'ordre adapté à ses besoins. Ce livre condense tellement d'intelligence du logiciel, et la rend si facilement assimilable, que ça semble miraculeux. La lecture est aisée, et les progrès qui en découlent sont immédiats et significatifs. Le développeur qui a lu ce livre se surprendra à résoudre tout naturellement des problèmes qui lui auraient valu, avant lecture, de longs moments d'errements ou d'hésitation. Un must intemporel pour tout adepte de la programmation orientée objet.

Livro excelente