 "3 KEY WARNINGS, BUT A FANTASTIC BOOK" | 2009-10-09 |
| - Reviewed By ghost1030 |
OK - So all the reviews here point out the book's presentation is stunning and brilliant. But what about the actual content?
If you look at the negative reviews of this book, they are, almost without exception, all from people who prefer to have their computer books boring. Fair enough. Some folks have had their senses of humor surgically removed. Nevertheless, few reviews here actually seem to comment on the content of the book. So here's some feedback on the actual content:
WARNING #1 - THE WEAKNESSES OF EACH PATTERN ARE VERY LIGHTLY DISCUSSED OR NOT MENTIONED AT ALL.
All of these patterns have weaknesses, but there's almost no coverage of the drawbacks. The book never tells you, for example, "the Strategy Pattern comes at the cost of many new classes and can inhibit understandability". The book would have been greatly improved with a small box at the end of each chapter that tells the reader when they might not want to use the pattern. The authors do provide some analysis of a few patterns, but not until the very end of the book in the "Leftover Patterns" appendix. They should have done this for every pattern in the main portion of the book - not just for the small patterns in the Appendix. Understanding the weaknesses is as important as understanding the strengths of any pattern. There's also some discussion of trade offs in the final chapter, but the book does so only at a high philosophical level. It never specifically highlights the weaknesses of the patterns it covered in the first 500 pages.
WARNING #2 - THE BOOK DOES NOT PRIORITIZE THE PATTERNS.
The reader is never told which patterns are very common and which are seldom used. That would be nice to know. The Decorator pattern is not often used, and when it is, the results can almost always be achieved using some other pattern. They should have presented the patterns in the order of their importance.
WARNING #3 - INDUSTRY DOESN'T DO IT THAT WAY.
These patterns have been around for a long time. Collectively, they form much of the basis for all those grand code-reuse promises we received 20 years ago in the C++ era. Those promises were never realized. Yes - theoretically, if you follow the patterns in this book, you really can achieve a lot more code reuse. But in practice, industry just doesn't follow these patterns - or at least, not over time. It's just too tempting to use concrete classes where you should be using abstract classes, for example. It would have been very valuable had the authors offered some observations about how and where these patterns typically degenerate over time. There are techniques to combat such degeneration. And the reader should know what to look out for.
Bottom Line?
The book is absolutely fantastic despite these shortcomings. If I compare the book to some non-existent ridiculously idealized notion of the perfect book, this book comes up short. Of course, that's not really a good way to measure a book. If you compare this book to other similar books that really exist, it's utterly fantastic! They've made learning about as fun as it can be.
The highly creative and entertaining presentation in this book is what makes it so special. You can even see the style in the cover. The rest of the book is just like the cover - goofy images and lots of humor. The book would be half the size if you removed all the fun parts, but few people would read it cover to cover.
A PROGRAMMER WHO IS NOT AWARE OF THESE PATTHERNS IS LIKE AN AUTHOR WHO NOT KNOW GRAMMAR.
Glenn Hostetler
Author, Web Service and SOA Technologies |
| |
| "This book is so cool!" | 2009-09-07 |
| - Reviewed By User: A13LM63WUF77BL |
One word, this book is COOL. Hats off to the authors for coming up with such an amazing work. This is certainly one of the most useful books I have read in a while. This book has made design patterns piece of cake. Design patterns were never so easy to learn before. I must say this book is a perfect start to learn design patterns. It includes all of the prominent patterns from the original GoF book and explain each pattern in great deal. The examples are well-chosen and make the learning process even more easy. Some time it feels repetitive but that is also with purpose. As the book explains in the very beginning, it helps our brain in absorbing the details. For the same reason emphasis has been put more on images than text, to make learning easy. The result is that you can understand a pattern quickly by following the images and don't have to go through lot of text every time.
Some of the patterns have been considered less important and are included in the appendix with two-page discussion per pattern. My only little complain is that it includes Bridge pattern too even though it is considered among the important patterns (discussed 3rd in Design Patterns Explained by Alan Shalloway, James Trott). Likewise, Visitor pattern is also included there (I think it is a fairly good pattern, or may be I think so because I have implemented it once)
Note that although it is a 600+ pages book but since it includes lots of images, exercises etc, it is actually like a 300 page book, it won't take you long to finish it.
In short, a wonderful book in all respects, go get it. |
| |
| "Excellent design patterns reference" | 2009-09-07 |
| - Reviewed By User: A1HTXY7JSM3KZB |
| I have read only the first 2 chapters so far. I love this book. The informal way in which the authors explain to you the concepts is exemplary. I recommend this book. |
| |
 "Ouch!" | 2009-07-14 |
| - Reviewed By User: A3619UWPS6J0HE |
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" | 2009-07-09 |
| - Reviewed By unity_in_diversity |
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" | 2009-06-28 |
| - Reviewed By User: A3RKZP5K40Q3ZJ |
Fast delivery... actually shorter (1 week) then 'standard' delivery time (3-5 weeks)
came in as good as a brand new book ! |
| |
International Available
