I really can't think of anything good to say about this book. It is, hands-down, the most disappointing technical book I have ever bought (and I buy an obscene amount of them).
To be fair, I don't think it purports to be a reference. But I'm not sure what it *is* good for. I've picked it up a number of times since I bought it, but so far, I have always simply put it back on the shelf in exasperation. It's vaguely reminiscent of some kind of 3rd grade workbook you might have used. I don't necessarily hold that against its producers, but if you haven't actually seen the content, be advised.
I don't know how typical it is of the series, but I don't see me buying another Head First book unless I have the chance to examine it beforehand (which, I suppose, I should have done prior to buying this one).
Formalizes and Deepens Knowledge of Patterns
I've been writing object-oriented programs for the last 20 years, and have used many of the patterns listed in this book during that interval. Some of these were picked up through exposure to frameworks that employed them, some from books, and some just re-invented because they made sense for my particular application.
This book collects all of these patterns in one place, including some that I haven't used, and then explores and explains them from a variety of perspectives.
The book is a collaboration between technical experts and experts in learning theory. The result is that motivation for learning the material is thoroughly integrated into the formal content. Rather than just describing the "what" of a pattern, the book starts by dialoguing with the reader about the "why," so that by the time it gets into the "how" in more depth the reader is interested enough to explore all of the nuances of the various approaches to applying the technique. It attempts to anticipate objections the reader might raise regarding the importance of a given pattern, while at the same time throwing light upon the pattern by showing how it addresses real needs.
The presentation and examples are superior to most other books that I've read. There's a fair amount of repetition, but from different perspectives, so that at least one of the facets presented should resonate with the needs and experiences of the reader. In its presentation of the decorator pattern, for instance, the first example was a concocted coffee cost computation program that left me feeling that a critical aspect of that pattern, the building of more specialized functionality by wrapping more basic and fungible functionality, had not been adequately explored. But they followed up immediately with a real-world example from the java.io package that not only explored that aspect of Decorator, but also referenced code that I had already personally encountered and understood.
Another praiseworthy aspect of this book is the way in which it integrates general design principles like programming to an interface (rather than to an implementation) with more specific patterns like the Strategy pattern. This gives the reader a lower level base to fall back upon if a specific pattern cannot be found, or if an existing pattern needs to be specialized for a particular purpose.
This book arrived while I was designing a new application, and upon scanning through the various patterns for additional places within my application where patterns could be applied, I found a couple right away.
All in all, this book represents a raising of the bar for content, presentation and pedagogy in a technical manual.
Extremely efficient
Fast delivery... actually shorter (1 week) then 'standard' delivery time (3-5 weeks)
came in as good as a brand new book !
Excellent book
This book is an excellent way to learn your skills of design patterns. The book was refreshing to read with a lot of real world examples to help the reader better understand the points being made. I would highly recommend this book.
The More Efficient Way to learn Design Pattern
I was looking for a book on the subject to enhance my knowledge about sofware design and engineering (myself has postgrad in software engineering and 10+ yrs of professional software development) and had to decide whether buy this book or the other. I decided to pick this one instead due to my very positive experience with the other "Head First" book (HF Java). Yes, indeed, my decision was perfect as after I read a few pages of the book, it really excite me to read even more and finish it.
Don't just listen to my comments. There are comments from many experts included in the first few pages of the book, even from some of the "Gang of Four" (the original other Design Patterns authors)!
I have been and always a person who like to describe things in pictures and favor books with a lot of diagrams and graphics (it has 1000 words, right?). If you're already an expert in the area or rather like a dry-and-dull-full-of-text book, this book is not for you though.
If you have mastered what described in this book and "Code Complete" by Steve Mcconnell, I can guarantee you will become a better software developer (these two books are now my top favorite book).
