Design Patterns: Elements of Reusable Object-Oriented Software (Hardcover)

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.

Software patterns are a way of preventing the programmer from reinventing the wheel. Many of the patterns discussed in this book are refinements of procedures that have been tried and tested thousands of times over the years. The idea is that by studying these prototypes, we can save ourselves time by standing on the shoulders of those noble computer scientists who came before us. And it really works too. Reading about these patterns instantly drove into my head all the places in the past where I should have been using an elegant pattern as described here, rather than the ramshackle, jury-rigged solution I created. And I even learned more about the patterns that I was already familiar with. Every Java programmer knows about, say, Iterator, but I found it fascinating to read about how powerful that little routine can be.

The book is divided into three main forms of patterns: creational patterns, structural patterns and behavioral patterns. The patterns discussed span all portions of an object's life (the book is geared towards Object-Oriented Programming). We learn the best way of creating objects, the best way to have them communicate with other objects, and the best way to have them running their own algorithms. It really encourages the writing of clean code. Decoupling objects is the order of the day, and while I already knew vaguely that this was a good idea, this book showed me why exactly this is desirable, and equally importantly, it showed me how best to implement it.

I was introduced to this book by enrolling in an excellent class, which walked us through the various patterns. Given that the book has a tendency towards dryness, I would recommend this learning method to anyone. The examples proposed on these pages are, perhaps, a little esoteric and can at times be obscure. Because the book was written way back in the dark ages of 1994, the sample code is written in C++ and Smalltalk; we can assume that if this same book were written today, Java would reign supreme. An instructor who has used these patterns in real applications should be able to provide the student with a plethora of easy-to-understand scenarios, to really drive home how and where these patterns should be implemented.

Again, don't let the relative age fool you; get this book and take a class that explains it. If you can't find a class that teaches from this, then try to learn on your own. The skills you'll pick up from this will be immensely rewarding. Just be prepared to have the inevitable realization of: "Oh, so that's what I should have been doing all this time! Now where am I going to find the time to go back and fix it?"