Design Patterns: Elements of Reusable Object-Oriented Software

From all other people's reviews, you have already known this is the classic text on the subject of design patterns. This is indisputable so I don't need to waste time trying to prove it again. However, I would like to say something to those readers who are totally new to design patterns and C++/Smalltalk -- please do not be intimidated by the seemingly terse, dry and difficult style of this book. Since I myself am new to the world of design patterns, I would like to share with you my own experience and hope you can make a better decision when you pick your design patterns book."Design Patterns" is the classic text; its style is academic-oriented, rigorous, and terse. Unlike most popular computer books, you will find reading this book takes a lot of thinking, for each paragraph or even each sentence. Most examples used in this book are adapted from real world systems popular many years ago, so you will likely find you're not familiar with them at all. Moreover, some examples are related to GUI programming, so if you're mainly programming for backend, you will probably feel it's tough to understand some of the examples. Most code example in the book is written in C++ (some in Smalltalk.) If you're a Java programmer and have limited knowledge in C++, it might take you some time to guess what certain C++ syntax means.These all seem to be negative comment, but my conclusion is to the contrary -- this is the BEST book in the area, and you should read it despite of all the issues I mentioned above. I started my design pattern learning by using a couple of other books, such as "Java Design Patterns: A Tutorial", "Design Patterns Explained: A New Perspective on Object-Oriented Design", and "Applied Java Patterns". I chose these books mainly because they seem to be much easier to understand than "Design Patterns". However, after spending time in these alternative books, I found none of them offers the accuracy and depth as "Design Patterns". Often, after I read a chapter of the "easy" book, I feel I am still kind of lost. I seem to have understood the pattern I just learned, but then I feel it's not quite so. I guess I only learned the pattern in a superficial way, with little depth, and without being part of "big picture." Later, I turned to the classic, "Design Patterns". I forced myself to sit down and try to understand the authors' terse and rigorous writing and their unfamiliar examples. Gradually I found I was getting used to the style and the examples, and I actually started to learn much more from this book than from others. After reading half-way through the book, I felt the rigorous style is actually a big plus for this book, because I can get more accurate and in-depth information.Therefore, I strongly suggest that you buy and read this book, even if you feel it's difficult to read. Your effort will pay off eventually. Use other books as reference only.

This is absolutely one of the best books on OO design. I am a System Archtect and I can't image how my design (and Java) would look like without applying the concepts and patterns described in this book. This book, IMHO, plays a much more important role and should enjoy a much higher reputation than the UML series written by the 3 Amigos. This book is definitely not for those who still do not understand the virtue of the concepts presented in the book. This book is not for programmer level either(although they can still greatly benefit from the book to enter the next level). The examples in the book are in C++ but the patterns it describes is language independent. Those who really know Java(not just reading sth like Teach Yourself Java in XX days,weekends,in a nutshells, etc) should tell immediately that lots of patterns are already applied in Java, especially in J2EE. Knowing the patterns in the books not only make your design step up to the next level, but now also a MUST if you want to pass the perfessional certificate exam like SCEA. I have to say no one can claim they know OO design without knowing the concepts and patterns described in this book.This is one of those few books in computer world that will receive more and more recognization as time gose by. In three years no one will even mention 90% of those books currently getting five stars, but this one, I have to say, will be in top in foreseeable future and much longer.I totally agree that this book is a little bit hard to read. Please think it this way, anything you can learn in 10 minutes is useless and of little market value because anybody can do the same. Those who grasp the essence missed by the majority are distinguished and of high value....

I've been a software developer in C++ for some time. I would have to agree with the reviews that mention that most C++ textbooks rarely show the full scope and power of what this language is capable of, until you look at modern OO languages like Java and how they have been put to use. After all, those are language textbooks, not OO design/philosophy books.This book, on the other hand, made clear the "why" behind many software library architectures I've used, from the basic Java classes and AWT to things done in MFC, COM and the Stingray MFC extension libraries. Not only did it give an explanation, but it explicitly set out the "how-tos" on using these patterns yourself (complete with diagrams illustrating the structures and interactions), and more importantly when and when not to use particular patterns.For me at least, the most difficult part of designing an application is not coming up with good algorithms or efficient routines, but is constructing a sensible, easy-to-maintain architecture that will hand the demands placed on it...without writing excessively convoluted code. This seems more all the more difficult the larger the application gets. The patterns in this book clarified many things which I wish I had known earlier. A few patterns that I had "discovered" through much trial-and-error and observation were set out, often in a much cleaner form than I had come up with myself. Several of the patterns in the book were immediately applicable to a project I was working on, helping to speed through what likely would have been another messy and slow design phase. I would recommend ths book for any OO designer. At the very least, it will enable you to understand why various libraries were implemented in certain ways. At best, it will provide a useful toolkit of proven solutions enabling one to get the most out of an OO language such as C++ or Java, a toolkit that can be drawn on to solve your own architectural issues without reinventing the wheel.The only warning I would give about this book is to reiterate the warning in the preface's very first paragraph: "This book assumes you are reasonably proficient in at least one object-oriented programming language, and you should have some experience in object-oriented design as well. You definitely shouldn't have to rush to the nearest dictionary the moment we mention 'types' and 'polymorphism', or 'interface' as opposed to 'implementation' inheritance."

Obviously, this book is *the* most recognized reference work on software-related Design Patterns, and as such cannot be ignored. If you want to know about patterns, here is where to start.The main asset of this book is in its trustworthiness and credibility - not such an easy thing to come by in computer books these days. I went through many if not most of the C++ examples in detail, and did not find a case where it didn't hold up, at least to the extent where it clarified what the point of the pattern was. The UML diagrams are also extremely helpful. Be forewarned, however; this is not light reading. The examples are based on heavy-duty design tasks your average programmer doesn't face, like language-parsing, toolkit creation, compiler writing, and the like. It makes one wonder how applicable many of the patterns are to less complex programming tasks. Also, most of the examples are in C++, so you really have to understand the syntax of C++ before you can get much value out of this book. Another drawback is that many of the examples are abridged, so at times you have to kind of extrapolate on what some of the code *would* look like in order to understand the examples. The chapter on Interpreter in particular was a tough nut to crack due to this. I actually would have liked to have seen *more* explanatory text associated with the code itself. For all that, many of the patterns are pretty staightforward. The trick is to nail down that you "get it" for each pattern. One technique I found enormously helpful in accomplishing this was to write a summary of the pattern after reading a chapter - right in the book, so it can referenced later (there's often an entire blank page opposite the beginning of each chapter you can use for this). You may find yourself delving back into the chapter to confirm your understanding. Overall, a challenging but ultimately rewarding read for anyone who wants to understand what design patterns are all about.

This book really changed my way of thinking about object-oriented design. The idea is that when designing a new class hierarchy, though implementation details may differ, you often find yourself using the same kinds of solutions over and over again. Rather than approaching each design task out of context as an individual, isolated problem, the strategy is to study the task and identify the underlying design pattern most likely to be applicable, and follow the class structure outlined by that pattern. It's a "cookbook" school of design that works amazingly well.There are other advantages to this book. It isolates 23 of the most common patterns and presents them in detail. You wouldn't think that 23 patterns would be enough, but once you become adept at recognizing patterns, you'll find that a large fraction of the patterns you use in practice are among these 23. For each pattern, the book carefully presents the intent of the pattern, a motivating example, consequences of using that pattern, implementation considerations and pitfalls, sample code (C++ or Smalltalk), known uses of that pattern in real-world applications, and a list of related patterns.Upon first reading, you will start to recognize these patterns in the frameworks you see. Upon second reading, you'll begin to see how these patterns can help you in your own designs, and may also start to see new patterns not listed in the book. Once you become familiar with the pattern concept, you will be able to originate your own patterns, which will serve you well in the future. One of the most valuable contributions of this book is that it is designed not merely to help you identify patterns, but to give you a sense of which patterns are appropriate in which contexts.I think this book is particularly valuable to many C++ and Java programmers, because of the dynamic and flexible design philosophy it follows. (Its two fundamental principles of reusable OO design are: "Program to an interface, not an implementation" and "Favor object composition over class inheritance".) I've found that many C++ books unfortunately tend to emphasize a rather static and inflexible design philosophy. Many C++ programmers do not realize how the language and the books they've studied from have been limiting their thinking until they have been exposed to ideas from other lanugages. The authors of this book have obviously been influenced by other languages as well, especially Smalltalk, and have brought many of its best lessons to C++ design. Most Java books seem to take after the C++ books, even though Java is a more dynamic language. This book may help Java programmers take full advantage of the extra power offered by their language, if they look deeply enough into some of the lesser-known features its runtime system affords.Last, but not least, this book is valuable because it names the patterns it uses, and so gives programmers a common vocabulary to describe design concepts, rather than particular implementations.