Design Patterns: Elements of Reusable Object-Oriented Software

Twenty Two years since the book's publication it remains incredibly relevant. In the beginning I was surprised the discussion in 1994 was this high level. The preface and introduction are awesome. For example, there was one discussion about dynamically typed languages versus statically typed lanugages... I was not even aware this was being discussed in 1994. In certain situations you see how this book changed the way the field of computer science developed. Before the writing of the book the authors originally called the Singleton pattern the Solitaire pattern. They changed it last minute (explained in the Conclusion) from Solitaire to Singleton, and that is a major part of why everybody calls it Singleton today. Some people may have an issue with the age of book. When you read the introduction, they mention that C++ and Smalltalk are cutting edge programming languages. I know C++ pretty well, but I have never used Smalltalk. What I learned from the book was how Smalltalk was fundamental to creating the MVC (Model-View-Controller) framework. In a lot of places the authors point out situations where C++ programmers would implement a pattern one way, and Smalltalk programmers might use the pattern another way. The book's examples are mostly about text writing programs, windowing, and drawing. These examples fit well for the patterns. You can also see how the current state of programming was much different. Text editors were creating huge innovations back then. This book requires sophistication as a programmer. It will be a challenging book for pretty much anyone to understand completely. You need to have familiarity with the word choice as well. The authors assume you are well versed in their language. The glossary was pretty good in this book, I would recommend taking a look before you start. The progression of the book is excellent. There is a lengthy introduction before getting to the patterns. This helps put the entire book in context and prepares you for the challenge to come. Each pattern is unique in subtle ways that the authors explain masterfully. One hundred years from now this book will still work. The patterns are fundamental to software design itself. I wish most authors were this bold.

Buying this book was a very smart decision. I needed a little of background in object-oriented programming to get the most out of it. The most interesting part is not the catalog, but the principles and the way it explains the object oriented way of thinking. After three decades its content is still relevant. Thank you to the GoF for this seminal work.

This book characterizes the kind of thinking that moves you from the low-level 'small' view of a software developer to the high level long-term view of a software architect. While entry-level and junior developers may spent hours arguing fruitlessly over whether OOP is dead or alive, or whether functional programming is better or worse, most senior engineers and software architects are able to use many different paradigms. They understand that these patterns are deeper than the paradigm they are implemented in. They understand that the concepts and ideas underlying these design patterns cannot and will not ever die because they express evergreen solutions to dealing with evolving software systems. Javascript made the prototype pattern its object model. Generators (and coroutines) that make async/await possible are often implemented as combinations of Factories and Iterators. The Observer pattern underlies almost every single reactive UI framework and most micro-service architectures. Decorators have become mainstays in most languages, inversion of control (IoC) is crucial for dependency injection patterns (Angular, etc.), and on and on... In short... these patterns are used absolutely everywhere, yes, even today. Basically, anyone who says these patterns are dead is either profoundly confused or unaware of how prevalent they are underneath everything they do. For those who say you don't need to know the patterns themselves because they are implemented as language features in modern languages... I would say that coders are generally afraid to use what they don't understand. Have you ever seen someone try to do reactive state management well who didn't understand the Observer pattern? It's not pretty. Moreover, there is no language that offers every single one of these patterns as first-class objects, and certainly no language that has them tailor-made for your use case and your business logic. Understanding the problems that these design patterns solve will help you design better software systems no matter what language or framework you use. Understanding how they work is crucial to using them well and not taking the pros and cons of these abstractions for granted. Yes, the examples are in C++ and quite old, and I wish they updated this book to implement these patterns in a newer language like Python, Typescript, Go, Carbon, Kotlin, or C#... but even this slight deficiency doesn't justify taking a star away. Every other part of the book is complete gold. It should be updated, but even this version is well-worth the money.

This is a really good detailed and in-depth look at design patterns geared towards serious software engineers in the field. I have some minor complaints about it, but overall this is a really good book. Each design pattern has sections that go over things like pros and cons, implementation details, and so on. The pros and cons sections alone are worth the cost of this book. The cons specifically of each pattern are absolutely invaluable, they often cover important counterintuitive consequences of using a pattern that would normally only be learned by experience. This book isn't perfect. Specifically, it focuses too heavily on concrete real world examples of each design pattern, to the point that the overall design pattern feels obscured. For example, every chapter starts with a discussion of a specific real world problem where the design pattern would be useful, and only after discussing this at length does it talk about the design pattern more broadly. This feels backwards. We really want to learn about the general pattern first, and see the specific example second. In fact, I'd prefer if the example was contained in a dedicated section separate from everything else. Instead, the entire chapter on each design pattern tends to focus heavily on the specific example. Another example of this is the diagrams. A diagram for the implementation of the example is actually given before a diagram of the design pattern itself in each chapter. Again, this just feels backwards. We should be given the design pattern diagram first, then the example after. Having said that, the examples are excellent highly realistic real world examples, so they're great. It's just that this focus on the example rather than the pattern creates a feeling of not being able to see the forest through the trees. It obscures the more general design pattern, which should actually be the focus. For that reason, I actually think Head First Design Patterns is overall a better book, but I still recommend buying both. In that book, the focus is much more on the design pattern itself in a general way. That book is much more surface level, but it's also a much clearer and more intuitive introduction to each pattern. Honestly, you should buy both. Start with Head First Design Patterns as a surface level introduction to the design patterns, then use this book as a more in-depth look at each pattern. One last minor complaint is the diagrams themselves. The format and symbols used in the diagrams are not intuitive. This is just a problem with the specific visual design language used for the diagrams. It often takes me a couple of minutes minute to figure out "okay these are descendents, and these are member variables, and this contains this other thing, and this calls this." Overall, the style of the diagrams is just not very clear. This contrasts with Head First Design Patterns where the diagrams are intuitive even at a glance. Despite all that, this is a really great book. It's well written, it's in depth, it gives a lot of amazing information. These complaints I listed are minor in the grand scheme of things. This is overall a really genuinely amazing book and I'm glad it exists and that I have a copy. Its discussion of each design pattern is just about some of the best in-depth discussion on software design that I've read. I highly recommend buying this book, even if you already have a book on this subject. This is like the formal in-depth professional look at the subject. Also pick up Head First Design Patterns so you understand the design patterns at a surface level first.

As others have already noted, this is a seminal work on design patterns and is considered by many software professionals as a must read. It is probably a bit too complex for novices to design patterns in which case they are better off using another resource for starters (e.g.: Head First Design Patterns) and then eventually move on to this book. Head First design patterns was obviously easier to read and understand since the examples are more up to date and material is not as thorough as this book. It took me more than a month and half to read this book carefully from cover to cover. Although a lot of the patterns are discussed in depth from a theoretical level including evaluating trade-offs made with specific implementation choices, the examples in SmallTalk are out of date and not that relevant anymore but that's understandable given the publish date of this book (1994). Like some other books (e.g.: Java Concurrency in Practice), multiple readings are necessary to fully digest the material and that needs to be coupled with either independent practice of the specific implementation choices and/or other resources that have more examples of pattern implementations so as to not only reinforce understanding but also lay a solid foundation for Object Oriented Design. Most senior folks working with Object Oriented Systems typically have this book at their desk as a reference. I found one particular pattern, namely Interpreter, pretty difficult to follow. Other than that the rest of the material is readable. Having some familiarity with UML notation will help but the appendix includes explanation of the notation used in the book, so it is not a stopper if you don't have any exposure in that area. Towards the end of each chapter covering a given pattern, the authors include a section on related patterns which can be extremely helpful. This book also organizes different patterns into creational, structural and behavioral categories and also identifies which ones within a given category can supplement each other and which ones compete against each other. This book is not meant to be a comprehensive resource on design patterns and will have to be supplemented by other books. Highly recommended for anyone working with Object Oriented Systems.

Best book for design patterns there is. Wish it had a soft cover, but oh well.

This is a great, essential book for any software developer who really wants to improve their software designs. When I first read it many years it ago it helped me organize some designs I had "discovered" for myself and introduced me to other designs. It explains not just what the patterns are but WHY you would use each one, how they interact, and when to choose a particular pattern. Despite changes in programming style or the "flavor of the month" of programming methodology, the design principles in this book remain valid. Well worth reading.

My dog literally ate my old copy when he was a puppy so I purchased this copy on pure principle. If you work with software then NEED a great design patterns reference. I love this book and I've used it many times over the years. Suffice it to say, if you're a "real" Software Developer/Engineer you should have this book on your shelf. The book is broken down into three (3) categories (Creational, Structural, Behavioral) of patterns. Each category is further broken down into individual design patterns (sub-categories) with simple and explicit explanations on when and why to use the pattern, as well as HOW to implement the design pattern for your software. At the end of each categorical review of applicable design patterns the authors discuss the categorical patterns which is great for making the correlations necessary to conceptualize how and when to use the patterns discussed.

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.

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

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.