Shop now Shop now Shop now  Up to 50% Off Fashion  Shop all Amazon Fashion Cloud Drive Photos Shop now Learn More Shop now Shop now Shop Fire Shop Kindle Learn more Shop now Shop now

Customer Reviews

4.6 out of 5 stars111
4.6 out of 5 stars
Format: Paperback|Change
Price:£26.32+ Free shipping with Amazon Prime
Your rating(Clear)Rate this item

There was a problem filtering reviews right now. Please try again later.

on 15 August 2006
This is an excellent book. I have read other books on design patterns including Design Patterns Explained by Shalloway Trott and whilst it was a good book it was rather a dry read.

By contrast the Head First book although looking a bit like a Design Patterns for Dummies type book by the cover does indeed cover the same material but in a way which is definetely easy to read and hopefully better to remember.

Where the book excels is in it's examples which clearly show you where you may wish to apply a paticular pattern which is really the key to the whole field. There may be more exhaustive books on the market but this one explains the key patterns and more importantly the principles behind them well.

I'm a C# programmer and the fact it's a Java book doesn't really make a difference. The code samples are almost exactly the same as they would be in C#. On a few occasions it does make reference to paticular Java classes to show examples of patterns in use (e.g. Iterator) but it's easy enough to relate these to their .NET equivalent and even if you can't it doesn't really matter.

All in all the most enjoyable computer book I have ever read and thoroughly recommended if you want to start learning about Design patterns and their use.
0Comment|47 people found this helpful. Was this review helpful to you?YesNoReport abuse
on 24 November 2010
Having read several books on design patterns before, and ending up no wiser than before, this book was a refreshing change. Even without the wacky style (which I liked a lot), the explanations were clear, and the samples realistic enough to be useful, without being boring.

So my overall opinion of this book is that it's easily the best design patterns book around, and essential reading for anyone who wants to do Grown Up Programming.

Having said that, I have a very serious complaint about this book, which is why I gave it four stars not five.

Design patterns are language agnostic, so you can use them equally well in any true OO language. Given that Java is (probably) the most widely-used OO language around today, it made sense to give the samples in Java. I don't think anyone could complain about that.

However, why oh why did the author have to make it SO Java-oriented? A lot of the book kept referring to the JVM, and using the Java console and so on. This was unnecessary and annoying to us non-Java programmers. The chapter on the Iterator pattern made it even worse by using a Java-specific feature, without any real explanation of how to do it in other languages.

Even this might not have knocked it off the five-star rating, had it not been for the chapter on the Proxy pattern, which was basically useless to non-Java programmers, as instead of showing how to implement it in a neutral way, they used a Java-specific one, which doesn't help the rest of us. Although the description of the pattern was good, it wasn't clear enough how to implement it in other OO languages, and I ended up skimming most of the chapter.

So, the book was brilliant, but if you aren't a Java programmer, be prepared for some disappointing bits. The annoying thing is that it would have been SO easy to have written the book to apply to any OO language, and just add some notes as to how specific languages have extra features that can help.

So well done guys, but how about a revised version of the book that appeals to everyone? Why do you assume that only Java people are interested?
33 comments|9 people found this helpful. Was this review helpful to you?YesNoReport abuse
on 27 February 2006
Ok, if you work in a big consultancy your boss/client may not want to see this on your desk.
If you can read the GOF patterns book, then you dont need it. If like me, you know patterns are good, but you quickly lose the will to live when seeing yet another esoteric UML diagram describing a pattern, then get this book.
One important way that this book differs from others I read, is in the examples. These actually look like something you might write and the final example using many of the major patterns was superb.
Oh, and this book is funny.
0Comment|63 people found this helpful. Was this review helpful to you?YesNoReport abuse
on 23 November 2006
I ordered this book before I read that the examples inside it are written in Java. I do not have any knowledge of Java, the only language I know is PHP.

However this was not a problem as the code in the book is minimal and is very focused on the design pattern being explained at the time. If you have knowledge of object oriented programming then I'm sure this book will be good for you. It is an absolute Gem!
0Comment|6 people found this helpful. Was this review helpful to you?YesNoReport abuse
on 2 August 2006
ESSENTIAL reading if you develop or test OO software. You can read this book cover to cover (not something I'd recommend for the GoF book, unless you are actually a computer). Use this book to learn the concepts quickly, then use the excellent GoF book for reference. If you're already familiar with and have used a lot of OO patterns this book is not for you, however, if you want to learn how to design and write more robust, elegant and maintainable code, read this book now! It will even show you why some areas of the Java API have been built the way they are.

Warning: this book contains some cheesy jokes and slightly wacky examples, but you will not be worried about that when you get to the last page and realise that virtually all of it is stored securely in your mind.
0Comment|24 people found this helpful. Was this review helpful to you?YesNoReport abuse
on 30 August 2012
If you're completely new to the topic then this book may be for you. It's written in simple and clear English, but it stills conveys all the required information regarding quite a large number of patterns. That said, perhaps it's biggest downfall is the way in which things are "dumbed down" for the user...

The relevant knowledge is passed on, but it's passed on via the use of incredibly long and drawn out examples which are supposed to be entertaining - but actually just prove to be irritating. I understand the reasoning behind the examples, and sure - they made reading it more enjoyable (well, for the first 5 minutes) - but they also acted to fill pages with needless dialog!

The book has an underlying storyline which also acts to add bloat, but for some readers this could act as intended; allowing them to 'take more in'.

I think I'm just not suited to the Head First format (that said this isn't the only HF book I have on my shelf) but can see just how this approach could help those that are.

Regardless of this, I still managed to walk away with a firm grasp of various different patterns - more so than I would've if I went straight to the GoF book!

For that reason alone, this book deserves 3/5. Add on another point for the amount of patterns this book covers, as well as the depth it goes into.

This book misses the 5/5 mark simply because it felt bloated with some of the story line and examples.
0Comment|2 people found this helpful. Was this review helpful to you?YesNoReport abuse
on 8 October 2009
If you are already familiar with design patterns, want a reference manual, like your books technical and short, or are completely unfamiliar with java/c/c#, then this is not the book for you, as it's bulky, with long worked examples, and doesn't have class diagrams for some of the patterns, and relies on a v basic knowledge of at least one of these languages in its examples.

That said, if you're a design pattern novice, this is a very accessible and readable book, although a couple of the patterns were just plain confusing (the Factory & Abstract Factory being examples). It uses the latest 'cognitive science' and 'psychological research' to inform the learning style, making it visual, conversational, with lots of questions and challenges for the reader.

It covers the patterns set out in the original Gang of Four book Design patterns : elements of reusable object-oriented software(the grandaddy publication on design patterns, which although was the first, is reputed to be a hard read). It covers 15 patterns in detail, and 9 in brief:

Detail: Abstract Factory, Adapter, Command, Composite, Decorator, Facade, Factory Method, Iterator, Model-View-Controller, Observer, Proxy, Singleton, State, Strategy, Template Method.

Brief: Bridge, Builder, Chain of Responsiblity, Flyweight, Interpreter, Mediator, Memento, Prototype, Visitor.
0Comment|One person found this helpful. Was this review helpful to you?YesNoReport abuse
on 26 February 2005
Before reading this book I was not that passionate about programming. I could knock out some code and get things to work which was fine. After reading this book my thinking has been changed forever...this book presents ways in which you can write slick, elegant code....and get more of a buzz out of your work because you know how to do it better. It's easy to read, entertaining and best of all it sinks in without you straining trying to stay awake.
The different patterns are presented in each chapter. The chapter begins with a problem scenario and then proceeds to follow the thoughts of a developer as to how to implement the solution. A solution using basic programming techniques is used first which would work, and then the design pattern is used to show how the problem could be solved in a way that would make the code easier to maintain and extend. In amongst all of this are puzzles and games that allow knowledge to sink in, and detailed explanations of class diagrams and code.
A day after reading a few chapters of this book I was able to look at code in my workplace, and could immediately see how to improve it.
The designers of the book did all the hard work so that we wouldn't have to. Brilliant.
0Comment|14 people found this helpful. Was this review helpful to you?YesNoReport abuse
on 9 January 2007
This book is BRILLIANT - it makes learning design patterns a joy. Know your OO fundimentals first (Inheritance, Polymorphism, and Interfaces) because you'll find yourself using them in ways that make you smile ... confident that from the investment you have made in this book, you will reap the reward for the rest of your life in programming.

I bought this book because I'm studying for a computing degree and the section on design patterns looked daunting ... this book taught me all I needed to know without my brain falling asleep every couple of pages ... in fact, my brain felt stimulated by this book - if ever you need an example of a book that is a shining example of what educational books should be - this is a star ... and a very bright one at that.

I am an ActionScript 2.0 programmer, and whilst the code examples are in Java, I found rewriting them in AS 2.0 was a great way of consolidating what I had learnt. Mind you, if you don't want to do that, the crossword puzzles at the end of each chapter really help consolidate everything as you progress through the book.

Summary ... if Amazon would let me, I would award this with more stars.
0Comment|7 people found this helpful. Was this review helpful to you?YesNoReport abuse
on 18 October 2005
I have bought many design pattern books and found all of them dull - but not this one! It explains the patterns with excellent examples that makes you REMEMBER and UNDERSTAND them. I wish all computer books were like this!
0Comment|3 people found this helpful. Was this review helpful to you?YesNoReport abuse

Sponsored Links

  (What is this?)