Holub on Patterns: Learning Design Patterns by Looking at Code

Rating:
Summary: accessible
Review: Holub attacks a pedagogic treatment of patterns that tends to focus on the abstract description. Of course, this abstraction is important, in order to generalise from specific instances. The whole point of patterns, after all. But Holub points out that often these descriptions are a little too abstract. Many of us learn from well chosen examples. So he follows this precept by elaborating on 2 nontrivial case studies. One is John Conway's classic Game of Life. From this you can see various common patterns emerge from the gestalt, like Visitor and Composite.

The other case study is an embedded SQL interpreter. Neither example is complicated. But each consists of several interlocking parts that contributes to an overall complexity that can be challenging if you don't use patterns.

Granted, if by one means or another, you're already familiar with patterns, perhaps from the GoF book, then Holub's text will do little for you. But if you're new to patterns, he can offer an accessible insight.

Rating:
Summary: Alan Holub - Design Patterns - Do I really have to say more?
Review: I could write a long detailed review but <a href="http://slashdot.org/article.pl?sid=04/11/16/1919215">James Gray</a> beat me to it with an excellent Slashdot article.

Summary: this book is required reading for any IT professional.

Rating:
Summary: It's OK, not great.
Review: I looked at one other book before purchasing this one, Refactoring to Patterns, but I picked this one because this one had 5/5 average review. I should have picked the other one, though. :-(

This book starts out great, the first 2 chapters (out of 4) give you quite a few tips and rules of thumb. However, once you get to chapter 3 and 4, the chapters on patterns, the author does a so-so job. Quite frankly, I had hard time reading those chapters. I thought that by looking at code you might learn more about patterns. Not true. Especially, when you have to look at GUI code, as is the case with this book. I did not like that.

Maybe that's only me, but I would recommend the Kirovski's book instead (at least look into it).

Rating:
Summary: Pragmatic patterns, Holub style
Review: In order to read Allen Holub's new book, you'll certainly need some programming skills (Java, OOP and patterns to be more specific). On the back of the book, there's specified 'Intermediate to Advanced'. It certainly depends on what you mean by 'Intermediate'... because the book is not exactly a light read. But then again, we don't expect that from Allen Holub. We want interesting, insightful books from him, and 'Holub on Patterns' falls nicely into that cathegory. However, some 'intermediates' should prepare themselves for a harsh ride.
The volume is structured in 4 chapters. The first one contains some 'preliminaries'. Meaning : short explanations about why OOP is still incorrectly used, design patterns are not fully understood, plus a bonus of controversial statements like 'getters and setters are evil' and 'Swing is an over-engineered piece of junk' [well, maybe not exactly these words]. As a direct consequence of reading this chapter, the 'intermediates' will start banging their heads on the closest wall available : "My code sucks ! I swear I'll never blindly copy/paste again !".
In the second chapter things really start to heat up. Allen explains why 'extends is evil' and interfaces are not evil. In case we needed an example of fragile-base-class problem, here we go with some MFC bashing (usual stuff). The chapter focuses also on some creational patterns such as Factory and (at great lenghts) Singleton. I especially liked the cool explanations of how to shut down a Singleton.
The third chapter discusses an [overly complex, on purpose] implementation of the 'Game of Life'. Between huge chunks of code (a bit much for my taste) scattered throughout the chapter, the author explains all the implementation choices: from Visitor to Flyweight. Some 60% of the GoF patterns are encountered in this chapter's code.
The fourth and last chapter contains 'production code', as the author declares. It's a small in-memory database, with and embedded SQL interpreter and a JDBC driver. Very solid example, but it'll probably scare away a few 'intermediates'.
It all ends with an Appendix containing a great 'Design-Pattern Quick Reference', presenting the most used patterns in a very pragmatic format. Each pattern is explained via a diagram, some Java code snippets, its motivation, pros and cons, and a very original 'Often Confused With' paragraph.
Unlike all the other pattern books you've read before, this is not a reference. It's a real programming book that you'll have to read from cover to cover. You'll also need solid programming skills in order to understand the last two chapters (and especially the last one).
My gripes:
- too much code. Probably more than 1/3 of the pages are just printed code.
- typos. There is a slightly disturbing amount of typos in the book, even in some code snippets [like for instance 'Sting' instead of 'String'].
However, these problems should not scare away any potential readers. Because of its original pragmatic approach, 'Holub on Patterns' is surely in the Top 10 Java books for 2005.

Rating:
Summary: Saint Allen or Programming's Travis Bickle?
Review: It's not surprising the ecumenical reactions here; the statements on the jacket sound like Lutherian proclamations. But one of the great things about Allen's stuff is that the message is in the medium: even if you don't go in for every inch of his list of 'evil' things, watching him take things apart is what is compelling. The statements he makes about how every self-respecting programmer should have the Gang of Four committed to memory and know how they interlock is totally true, and having hired and worked with a lot of programmers in the last few years, it is sad how few of them have a good grip even on a couple of the patterns.

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.

Rating:
Summary: Strong opinions, practical advice
Review: This is a unique book. The idea is that you learn patterns through examples in code, as opposed to the architectural level presented in the Gang of Four book. The patterns are presented in a couple of primary case studies. One is the game of life, whose code alone takes up a significant number of pages without sufficient annotation.

The author has strong opinions about how to do patterns right and this is what I appreciate most about the book. Other standout features include the a very concise condensation of the GoF patterns at the end of the book.

I fault the book for the run-on code fragments, but these do not detract enough to take away from the books unique compelling features. For anyone who is interested in a more pragmatic face to patterns this book is well worth the look.

Rating:
Summary: Holub on Holub
Review: This is a very enjoyable book. Reading it is a little like sitting down with an oldfashioned master craftsman. I mean the kind who shows you, step by step, how he plies his trade, and offers a cantankerous side-commentary of opinion on just about everything while he does it. The commentary on p.283, for example, describes a very questionable programming trick that he pulled, and why, and why this one violation of normal practice is acceptable in this one case. In other words, it's real - a little gritty, not like didactically pure textbook examples. It's what real programmers really do.

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.

//wiredweird

Rating:
Summary: Words of the Modern Software Saint
Review: When things are bad for too long, God sends someone to fix it. I'm not overstating anything here - this is how i feel about most of the Enterprise OO Software Systems built these days and this book. This in spite of all that Microsoft bash (oh well, some people coz of their virtue and better know-how can say things, esp when it is true). I look upon this book as a real treasure with a knowledge that is so hard to find these days.

I see lot of things at work - things that mostly prevent people from doing quality work (call it politics or ignorance or sheer stupidity or manipulations or malice or... anything but good). Then i come home and read this book. It's so pure and such a good feeling. Holub has done a wonderful service for people lost in so many thought-less catalog books and some-what-incomplete articles out there (or) i can say, for the industry itself. Incisive. Wise. Practical. Rare.

Restored my faith in the system and gave me hope i can do my job better. Whatelse (that is better) anyone can give somebody..?.

The book contains practical patterns code examples as they appear in real world and in various java APIs and a very useful summary of GoF patterns in the end, for a quick reference. If you want to write better OO software with patterns, just go get it. No second thoughts.