Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Other Sellers on Amazon
Holub on Patterns: Learning Design Patterns by Looking at Code (Books for Professionals by Professionals) Hardcover – September 30, 2004
See the Best Books of 2017
Looking for something great to read? Browse our editors' picks for the best books of the year in fiction, nonfiction, mysteries, children's books, and much more.
Customers who bought this item also bought
What other items do customers buy after viewing this item?
About the Author
Allen Holub is a design consultant, programmer, educator, and author specializing in object-oriented design, Java, C++, and systems programming. He is a contributing editor for JavaWorld, and a popular columnist appearing in many computer magazines, including Dr. Dobb's Journal and Microsoft Systems Journal.
Top customer reviews
There was a problem filtering reviews right now. Please try again later.
The book is basically a commentary on the Gang of Four. It's certainly not the first, but it has a unique format. He demonstrates all 23 of the GoF patterns by applying them to two modest-sized Java applications. This is great for people who need concrete code to see what the pattern really means. It's even better because it shows multiple patterns overlapping, where one application class has different duties in the different classes. A large part of the book's bulk is code listings for the applications - some classes exceed 1000 lines of source code. I normally consider that to be a waste of paper. This time, however, the code is complex enough that it really does need to be presented right next to the commentary. (The code is also available electronically at holub.com .)
Towards the end of the book, he says "So, that's all of the Gang of Four design patterns, all tangled together in the two programs ... the way the patterns appear in the real world ..." That tang of realism is what gives this book such an unfamiliar format, and gives such contrast to the standard, one-at-a-time reductionist descriptions of each pattern in isolation. I'm not saying this holist approach is better; a beginner will just get lost in the whirl. Holub's holism isn't worse, either, it's a complement to the microscopic, academic presentations seen elsewhere. This book plus the analytic pattern catalogs form a sum much more valuable than the parts.
I recommend this very highly. The successful reader already is already quite familiar with Java and with design patterns. That reader is ready to take the next step, from the theory of patterns into their practical application. Seasoned pros may not get much form this book. An advanced beginner, with a little determination to see it through, will get a lot.
That said, the examples here are mixed. The Game of Life was a curious choice. The SQL interpreter was a good idea. Many people will crack this book and think 'I'm never going to write a little language,' but in fact, interpreter is cropping up all over the place these days (as the metadata portion of the coding corpus continues to grow). I also really like this edition: the diagrams are fantastically concise and well-integrated into the text.
Contrary to some of the other claims here, many have tried to do this from Mark Grand (a good 4 years ago), through the slew of books in the last two years proclaiming catalogs. This one makes those look like tinkertoys.
Finally, another book that came out recently, Refactoring to Patterns takes a great line. Sometimes, Allen's world is a tad too clean for me. Most of the world is filled with dirt. And in fact it is a good thing to learn how to work your way into pattern implementations. Rarely do you start, for instance, with Visitor. Unfortunately, that book is a tad thin. The best work I've ever seen in that direction is the Cook's Tour of JUnit by Kent Beck and Erich Gamma which is a short article about how JUnit evolved (starting w/one or two patterns, growing to something crazy, then actually pruning a few).
Anyway, this is really well done all around.
Summary: this book is required reading for any IT professional.
The scenarios are very informative and show a wealth of experience on the part of the author.
I love the concept of this book and have learned much from it, but I feel like it could have been condensed with the same effect.
Not going to gain much of that from your typical 1000 page "courseware" sterile volumes in their 6th and 7th editions. Nor from day-2-day coding at typical "just-do-it" race-against-time project.
Most recent customer reviews
This book has a lot of very good material.Read more