ISBN: 0596007124
List Price: $44.95
Amazon Price: $28.75
Usually ships in 24 hours
Buy this book
from amazon.com
or from
amazon.co.uk
|
Avg Cusomer Rating: 4
Reviews:
Summary: Clear, despite the superficial looks
At first glance, the book looks weird, with child-like drawings, quasi hand-written explanations and 'bad' jokes. But all of these are actually very helpful in communicating intent. For example in larger code listings, you can safely ignore most of the code and just pay attention to the 'manual' notes which show very clearly what is happening and why. They're much easier to pick up than embedded comments in the code would be. Interviews with patterns, which also appear regularly, emphasize the finer points and subtle differences between different patterns.
The book claims Java knowledge to be a requirement. I found this is mostly not the case. There are some Java-dependent implementations here and there (the implementation of the Proxy pattern comes to mind as something that is too Java-centric to be useful in other languages, though the purpose and principles of the pattern are still clear). Most of the code is very readable if you just know how to interpret curly-brace syntax and are familiar with basic object terminology.
Downsides are:
- relative lack of 'real' examples of where a given pattern could be used. If you have any experience programming, you'll probably recognize as you read about some patterns that you've already used them (or something similar to them), or at least identify places where you wished you had done so. But it wouldn't hurt to have some more realistic examples than the duck simulator.
- I found the exercises to be mostly too simple to bother with.
- The leftover patterns get a treatment which I think is too short to be useful. I'd have preferred having 4 pages per leftover pattern, or two pages but more tightly packed than they are now.
Summary: It explains why Design Patterns are good coding practices
Most computer books generally skip or just brush by explanations of why a certain set of coding practices are important. Better than any book I've seen in computing, this book tackles a complex topic and drives home the importance of why a given pattern is important. Rather than "do this because we know it's good for you", this book drags the reader through an information maze, constantly nuding the reader's involvement with a series of zany and not-so-zany exercises. The humor is both campy (with the Andy Hardy era photos) and hip. However, it's not superflous or off point. Everything in this book has been woven together into a fine collection of explanations, exercises and examples, the likes of which I've never seen.
The care given to how everything ties together is remarkable, and while some may snort that the book is too cartoony, I found it to be otherwise. (It's like saying that the New Yorker is too cartoony.)
Most important is that this book worked for me. I didn't breeze by it on a single read, but rather I went over it again and again, finding new nugets with each read. Granted, I often didn't do all of the little exercises, and I'm poorer for it. Also, I sometimes skipped the DP Guru exchanges with "grasshopper" (if you've never seen re-runs of Kung-Fu with David Caradine, you may miss the reference), but I still was able to create design patterns -- and in ActionScript 2.0; not Java, the language for which the book was written.
So if you want to lean Design Patterns and learn how and when to use them, this book is solid gold.
Summary: Read this book first before the GOF book.
I mean, I agree that this book wouldn't exist if not for the GOF book, but seriously, I think these people have done such a better job of actually teaching and presenting the patterns to everyone that I think everyone should first read this book before they read the GOF book. Now, it's a different question whether you can stand the dull style of the GOF book after having read this awesome and fun to read book.
Summary:
|
,
amazon.co.uk
,
google.com
