on November 10, 2004
At first I didn't understand how they would apply the Head First formula to design patterns. I'd read two head first before this one and I was impressed with those so I took a look and now, not only is it clear how they approached the topic, it's also clear to me that this is the best way to learn design patterns.
The Gang of Four book laid out the basics. Here is the pattern, here are some examples. The head first book goes a lot further. They show you good and bad examples of the pattern. They give solid reasoning behind the pattern. It's great.
There are times when I would look at a piece of code and have the author explain to me that it was based on one of the GoF patterns. I would come away thinking, if that's the pattern, then that pattern sucks. It's clear that patterns can be misapplied. So understanding the the how design patterns are applied, and how they are commonly applied wrongly, or to an extreme, is just as important as understanding the basic mechanics of the pattern itself.
The example code is in Java, but I think this is an ideal book for anyone passionate about patterns.
on December 31, 2006
Head first books tend to polarize readers I feel: you either love the unique methodology of the books or you hate it. They are extremely visual, often hilarious, and require you to do various activities to engage more fully with the content. This is similar to the traditional teaching methdology in mathematics: motivating example -> theory -> example -> your turn. This I find as a teacher, is a strong (pedagogical approach) methodology, particularly if you can make it fun, interesting and engaging. I, like the masses, like Head First Books (I have Servlets & JSP as well as this one. I have also read tracts of Java).
Anyway, that aside, the book provides a solid inroduction to selected design patterns- it doesn't cover all the GoF patterns. It contains (in order)
* Adapter and Facade
* Iterator and Composite
* Compound Patterns
* Living better with Patterns
If you have no experience with patterns, I recommend this as a good Intro to the MasterWork by the GoF-> Design Patterns, Elements of reusuable Oject-oriented software IBSN: 0201633612. From personal experience, I found after reading the Head First pattern, I could pick up the GoF book, look at the same pattern and understand it with virtually no problems.
I have no hesitation recommending this book, if you like the Head First way, championed by Kathy Sierra. If you don't like apparent frivolity (I say apparent because there is an ulterior motive to this frivolity-> engagement. Basically, cognitive psychology says the more deeply you engage, the more you learn, retain and understand), then maybe this isn't for you.
Slight criticism-> you may notice this book uses some 'old' java syntax like using iterators for collections like arrayLists, rather than the new for (object j: collection) and no generics in sight in declaring such arrayLists: they use ArrayList name=new ArrayList(), not ArrayList<type>name=new ArrayList<type>(); But these are 'very' minor criticisms. Likewise, it's usefulness as a comprehensive reference like the GoF book may be questionable. But then, if you approach it as a learning tool and a means to mastery rather than a reference, this shouldn't be an issue (you can always resell it when you're done!).
Anyway, in conclusion, two thumbs up. Read it, do the work, enjoy it and you'll be well on the way to the GoF's MasterWork in design patterns. All the 5 star reviews don't lie! This is a five star book.
As an aside I recommend, in addition to this and GoF, reading Streamlined Object Modeling- patterns, rules and implementation- ISBN: 0130668397 for higher level OO system design (OO system architecture). And just so you don't fell excluded from the vernacular (and didn't know this): GoF=Gang of Four (Gamma, Helm, Johnson, Vlissides)
on April 2, 2006
Unlike a lot of people, I don't care much for this book's 'irreverent' sytle. I think it masks some shortcoming in the examples it uses. But once you get past that, this is still the best introduction to object-oriented programming that I have read.
HFDP is not just about design patterns. It's a great introduction to object-oriented programming. The book does a great job of explaining the benefits of OOP over traditional procedural programming, and it explains OOP very well in terms of the most commonly used design patterns.
Now for the bad news. The examples are rather lightweight. They do a pretty good job of illustrating the concepts presented, but the code is in no way real-world. For example, if you are looking for which pattern to use to organize a UI (the 'Mediator', 'State', and 'Composite' patterns), with sample code, you won't find it here. The patterns are discussed, but they are used to create quacking ducks (really).
While that's by-and-large a shortcoming of the book, the code is so simple that non-Java programmers (like me) should have no problem using the book. The code samples are very basic, and should translate with little difficulty into .NET languages such as C# and VB.
One other item of note--this book contains a pretty good chapter on Model-View-Controller architecture, which seems to bedevil a lot of people. If you can get a handle on MVC, then you can pretty much do OOP.
In short, this is probably the book I would recommend as an intro to OOP. If you are under the age of 30, you will probably like the examples of quacking duck simulators and java-enabled gumball machines. For everybody else--it's worth looking past this book's insufferable cuteness if you are getting started in OOP.
on November 8, 2004
Usually when reading through a book or article on design patterns I'd have to occasionally stick myself in the eye with something just to make sure I was paying attention. Not with this book. Odd as it may sound, this book makes learning about design patterns fun.
The first thing you notice is the pages are not paragraph after paragraph of information. There isn't a single page that doesn't contain a doodle, a sidebar, a picture, or something different. While at times it can be a little distracting, it's in a good way (at least I don't have to poke myself with something sharp anymore).
The chapters cover various design patterns and along the way have exercises such as crossword puzzles or match games to test your understanding. The answers are also included at the end of the chapters - so you don't need to purchase a "Teacher's Edition" on the black market. =)
Other books on design patterns are saying, "Buehler... Buehler... Buehler..." while this book is on the float belting out "Shake it up, baby!"
on May 26, 2006
Soon after the Gang of Four published their book about basics of Design Patterns, I bought the book and read it very carefully. About that time I was busy doing other engineering work so I could not put the patterns in immediate use in some practical project. Maybe that contributed to my troubles understanding it.
While reading the GoF book I found it very complicated to memorize the pattern. After reading so many books on programming, so many technical and other books every year in several decades in the past, I thought I have a very strong and sound learning techniques from books. But GoF book simply was out of my reach from some reason. The problem was this: when reading about a pattern, I could understand every sentence, every paragraph, and most of the time the whole chapter about that particular pattern; but it seemed hard to keep in mind that pattern, and soon afterwards, I could hardly implement the pattern in my programs. It was as if you are keeping the slippery fish in your hands, and just when you think you caught it, it slips from your hands back into the water.
Finally after this book (it is still in reading) I found what I was searching for:
1) the crystal sound explanation of Design Patterns – why you use any of them;
2) what is important and what is not important in pattern. Actually the authors of HeadFirst does not speak much about it explicitly, but when they explain the pattern you do not have to think what I was constantly thinking when reading GoF book: what is the most important part of the pattern and which part of pattern can be changed for specific use. With HeadFirst book you get the right measure of all parts of pattern explanation.
3) I could memorize, reproduce and implement the patterns with ease!
Second, the book is astonishingly new, refreshing and perfect in the presentation sense. It is full of pictures and with hand-written comments. Everybody who was ever involved in the presentation material would tell how hard is to achieve such a great presentation level with so many diverse visual effects and putting them in perfect shape like this book achieves. I think this was the problem for one of the very rare reviewers of this book to give this beautiful book such a bad grade. I think he was wrong to falling under the first-impression opinion and misjudged the book greatly.
The truth is the HeadFirst Design Patterns deserves the highest possible marks – I do not give it only 5 stars, but I give it the Oscar for Design Patterns. And that is final even before I read the last page of it. Authors of this book, if you ever read this comment here is the message for you: my sincere complements for your hard work, you has been terrifically good, and I mean it!
on December 25, 2005
I got involved with design patterns in 1995 with the GoF book. I have learned them and used them on numerous consulting projects, and I feel I understand them pretty well. Recently I was asked to teach a Design Patterns course. The course material was excellent and very comprehensive, but I felt I needed an complementary approach for teaching that was a little lighter than the student manual. I picked up the Head First Design Patterns book, and started reading it on the flight to where I was teaching. The time flew by, and so did the pages. When I got off the plane I had read almost 300 pages. It is a really easy read. I was seriously impressed with the quality of the book's coverage, and its really excellent examples to motivate why and how each pattern can be useful. As an object modeler and architect I see way too many examples of developers using either the wrong pattern, or using a pattern just to say "I used the Strategy pattern!". The GoF book is the "bible" on DPs, but this Head First book is a superb introduction for beginners, and for veterans like me to learn something new. At the end of that DP class, several students shared that they had tried to get through the GoF book but just couldn't stay with it. After I showed them several of the examples in this book, they said they were eager to read the GoF book to get more depth.
on April 24, 2010
Before buying this book, I read "C# 3.0 Design Patterns" (C3DP) as it used my preferred language.That book was not as clear as I needed, so I considered other options.
I purchased Head First Design Patterns based on reviews at this site.
For the most part, I had no problem understanding the Java, and the
implementation of most patterns into C# is straight forward.
The largest deficiency of this book is that, unlike C3DP which gives
equal treatment to each pattern, HFDP gives provides only summary
descriptions of 9 of the 23 patterns (2 pages for each pattern.)
This kind of terseness for so many patterns is not what I was looking for.
One star lost. For most other patterns. the presentation is crystal clear.
There was a problem with the explanation of the difference between Abstract Factory
and Factory Method patterns. An elaborate Pizza-related example was used
in both patterns but then the discussion of the pattern differences completely
ignored the example and used a completely different set of terms that confused
me more that helped.
The other problem is the amount of Java-specific code.
The 70 pages devoted to the Proxy pattern had maybe 2 pages I could use
and 68 that I don't think I could translate into C#.
Also, the compound pattern chapter delved into the MVC pattern in such a way
that it was hard to see the interplay of patterns.
What is especially good for Java programmers was not so good for me and C#.
Another star lost.
Only with reservations Would I recommend this book to other C# programmers.
For maybe 16 of the patterns (excluding the 9 summarized and Proxy),which the author says are the most commonly used,readers will gain a greater understanding compared to that gained from the C3DP book. The crossword puzzles are a nice change of pace for a technical book. Still, I need more. I have not not read the GoF book, but maybe I will now.
on September 3, 2006
So far i bought about 30 computer books from amazon. This is the BEST!!!!!! First book that explains something real good but doesn't assume that you (the reader) actualy understood it so they re-explain it and attack the problem from a deferent point of view. I bought steven mezger's design patterns with c# book and read it cover to cover. It doesn't even come close to this piece of art although this is wrriten for java programers. I read "decorator" pattern in mezger's book more than 5 times and didn't actualy understand it. First time i read it in this book and i feel like a design patterns master! I'm thinking a lot about their teaching style. Its briliant! If you realy want to understand design patterns even if you are a c# or c++ programmer, By this book!
on November 22, 2004
I am quite impressed with this book's explanations of design patterns. The authors start each chapter explaining a problem and then showing how a given implementation or two isn't flexible. Then the text presents a design pattern and shows how to use it and how it solves certain issues. Along the way, the reader is given general design ideas to keep in mind while architecting or refactoring a system.
Because key concepts are repeated throughout the book using different phrasing and examples, I found learning/reviewing each pattern to be straightforward and easy. I haven't used Java since '98, but with C# skills I found the code examples fairly simple to understand.
Also note that this book doesn't explain in detail all the patterns explicated in the Gamma et al. text. Instead, you will learn the Strategy, Observer, Decorator, Factory, Singleton, Command, Adaptor, Facade, Template Method, Iterator, Composite, State, and Proxy patterns will full explanations and code examples. Other patterns (e.g., Bridge, Builder, Chain of Responsibility, etc.) receive only a brief overview in the back of the book. The authors feel that those patterns aren't used as often and consequently necessitate less coverage.
If you're looking for no-nonsense writing that delivers design pattern facts in a most direct manner, then choose the original Gang of Four Design Patterns book instead. But for a much friendlier introduction and explanation of patterns, pick up Head First Design Patterns right away and use Design Patterns by Gamma et al. as a reference. Highly recommended.
on January 25, 2006
I know what you're thinking: "This can't be serious", "What's with the clip art", or maybe "This isn't the GoF book!" but dispite the silly cover, this is one of the best and most informative books on computer programming I have ever read.
If you're looking to refine your development skills but just don't have the patience for a BS in Computer Science, this book is just the thing for you. HFIDP covers the very abstract and difficult to understand concept of Design Patterns in an engaging and fun way. By employing several different styles of teaching and visualization (including challenging questions, real world examples, and humour that isn't overly cheesy) it's nearly impossible not to learn something. There is even a section on how to retain information while reading!
This is a Java oriented book, but I have found it to be very useful for ActionScript 2.0 programming as well.