Programming Books C Java PHP Python Learn more Browse Programming Books
Trade in your item
Get a $5.30
Gift Card.
Have one to sell?
Flip to back Flip to front
Listen Playing... Paused   You're listening to a sample of the Audible audio edition.
Learn more

Holub on Patterns: Learning Design Patterns by Looking at Code Hardcover


See all 3 formats and editions Hide other formats and editions
Amazon Price New from Used from Collectible from
Kindle
"Please retry"
Hardcover
"Please retry"
$30.00 $27.72

NO_CONTENT_IN_FEATURE

Shop the new tech.book(store)
New! Introducing the tech.book(store), a hub for Software Developers and Architects, Networking Administrators, TPMs, and other technology professionals to find highly-rated and highly-relevant career resources. Shop books on programming and big data, or read this week's blog posts by authors and thought-leaders in the tech industry. > Shop now

Product Details

  • Hardcover: 432 pages
  • Publisher: Apress (September 28, 2004)
  • Language: English
  • ISBN-10: 0387226052
  • ISBN-13: 978-1590593882
  • ASIN: 159059388X
  • Product Dimensions: 9.7 x 7.3 x 1.1 inches
  • Shipping Weight: 5.5 pounds
  • Average Customer Review: 4.6 out of 5 stars  See all reviews (17 customer reviews)
  • Amazon Best Sellers Rank: #188,413 in Books (See Top 100 in Books)

Editorial Reviews

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.

More About the Author

Discover books, learn about writers, read author blogs, and more.

Customer Reviews

4.6 out of 5 stars
5 star
13
4 star
1
3 star
3
2 star
0
1 star
0
See all 17 customer reviews
I read the GoF book, Design Patterns Explained before reading the 'Holub on Patterns'.
Wow
It all ends with an Appendix containing a great 'Design-Pattern Quick Reference', presenting the most used patterns in a very pragmatic format.
Adrian Spinei
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 see the world

Most Helpful Customer Reviews

42 of 44 people found the following review helpful By wiredweird HALL OF FAMETOP 500 REVIEWER on October 29, 2004
Format: Hardcover Verified Purchase
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.
Read more ›
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
11 of 12 people found the following review helpful By Adrian Spinei on January 3, 2005
Format: Hardcover
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.
Read more ›
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
8 of 9 people found the following review helpful By R. Williams VINE VOICE on December 16, 2004
Format: Hardcover Verified Purchase
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.
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again

Product Images from Customers

Most Recent Customer Reviews

Search
ARRAY(0xa541bd80)