The examples in this book are written in Java, and although I am a C# developer, I thought the book was excellent! It is fun, interesting, and packs a lot of information and creativity into every page.

I was able to easily translate the examples into C# in all but the "Proxy pattern" and "MVC" chapters. For these, the code examples use components that are strictly found in Java (however, for the Proxy patterns you could attempt to following along using some form of web service). On these chapters I was still able to learn at a high level where these design patterns are meant to be used, so I wasn't frustrated while reading. That said, I would easily recommend this book to a C# developer. (If you visit the Head First website there is a link to download all the examples - except MVC - in C#)

This was my first Head First book, but it won't be my last. I have never read a tech book that was able to teach its allotted concepts in such an interesting way. I look forward to reading more from this series.

This is an excellent book for learning design patterns. A word of warning; this is not a reference book! It is well written and easy to understand with uncomplicated examples. The innovative learning techniques are a defiant plus and are very helpful in retaining the material.

I have been doing c# programming for about 3 years now. Mostly I did web apps and some utilities, but did do a few larger applications. For that entire time, I could never get my head wrapped around interfaces. I knew how to create them, but not really why, so I just never used them. By the end of the first chapter in Design Patterns, it all finally `CLICKED`. On thinking back on some of the projects I did, if I had this book to begin with, the projects would have gone smoother, especially when requirements changed.

The way O'Reilly's does the Head First series is absolutely amazing. I already have the OO Analysis & Design book that is next on my list. After that, I think I will give the javascript book a shot, as that is something that always seemed to cause me grief, but if that book is anything like the Design Patterns, I don't see not being able to fully grasp it.

This is awesome! All developers MUST have this book. You can apply to not only Java but other programming language, Ruby, PHP, C# etc. But you have to have basic knowledge of Java to read this book though. Anyway, you should get it one now.

Very good book with a very good concept. It takes your hand and follow you in understanding some important programming patterns which will make your life easier.

This was my first book from Head First, and i love it! The book uses an easy approach (besides the schema in each chapter) to make you understand the different patterns. I think the book is good for junior and mid senior people.

This book is like eating icecream. You expend Zero effort in learning valuable information about design patterns for oo development.

First, a little background: I have been programming since 1998 and my primary programming language is C#. My main area of development is ASP.NET websites.

For years I have been trying to get my head around software design patterns, but I kept running into road blocks. I tried learning about them from a combination of websites and books, but none of them seemed to communicate the practical reasons for learning design patterns. I decided to give up on learning them.

Several years went by and the gnawing question about the usefulness of software design patterns resurfaced in my head. I came across Head First Design Patterns, saw the great reviews and decided to take a chance. I am sure glad I did.

Not only is this easily the best design patterns book I have read, this may be one of the best books, teaching a complicated technology topic, I have ever read. This book was created with me in mind. The book is educational, entertaining, and does a good job of showing the practical side of the topic. The examples are all in Java, but I was able to easily translate them into C#.

If you want to learn object oriented design patterns, buy this book. I will definitely be checking out other Head First titles.

This is a book that I recommend to all of the software developers I work with, it is so much more than the gang of 4, it is actually readable. The unique format used to address the topics helps with retention and understandability. The only complaint that I would have about the book, and the reason I gave it 4 stars, is that the examples used are impractical and sometimes silly. The authors also could have alluded more to the usages of algorithms and efficiency of code.

Head First did a fantastic job on replacing the GoF classic...
Nicely written, good examples, ...
Original comparison between the patterns.
Must have!

This book is very exciting and cleverly designed. It teaches with great examples and emphesize every detail with humorous content which helps you to memorize. I really believe in this way of learning methodology instead of heavy books which I have covered most of the serious patterns in one week on my vacation. Now I'm back home and I'll code some examples about all of them.

At first glance this book resembles a comic book, and this may persuade you to put away the book. I recommend that you go through the first chapter and make your decision.

In reality as SW Engineers while designing a system we consider a set of requirements required to meet current deadline. We also attempt to think through several permutations and combinations of these requirements that may be required in future. Often, we fall short in conceiving all that is need to meet future requirements.

This book walks through such scenarios and at times points out how to design software while mitigating such changes to minimal in future releases.

At times some examples present a simplistic approach. Also I would have liked to see some performance analysis while comparing one approach with other.

[Reviewed by XPSD member Ryan Shiffer]

My previous experience in studying design patterns has been met with failure. I have tried getting through the Gang of Four book on design patterns, but reading it for me was about the same as reading the dictionary. Reading this book made the experience of learning design patterns an enjoyable experience instead of a literary root canal. Head First Design Patterns takes the most useful (and understandable) design patterns and makes them accessible to the everyday programmer.

Each chapter tackles one or sometime two related design patterns and creates a rich example to explain it with. Some examples are a little contrived, but they do the job to explain the patterns with real code. Along with this are lots of discussions and other interesting exercises to hold your attention. These help to further explain the pattern, some of the pattern's pitfalls, and where and when it is appropriate to use the pattern.

Along with introducing design pattern, this book reinforces object-oriented design principles and best practices. This proved to be a useful addition to the design patterns and helps root them in the larger picture of object-oriented design. I found myself immediately applying these principles and design patterns in my coding and reviewing older code where I "thought" I was using design patterns correctly.

If you couldn't get your head around the original patterns book before, then this book will change that notion very quickly. It delivers on it's promise and you remember what you read - now that's a bonus in the very fast paced world of software engineering. Highly recomended if you seriously care about your software design.

I'm relatively new to Design Patters. Prior to reading this book I had read several other material on the web trying to get my head around design patterns and although that material was helpful, it didn't fully clarify to me the intent and usages of these patterns. However, when I read a sample chapter of this book online (on the Decorator Pattern), I instantly took a liking to it. The book has a very good way of explaining everything step by step and in a way that will make the topic more interesting to grasp.
I highly recommend this book to anyone who is new to the subject and wants to learn Design Patterns. This book (as even the authors mention) is not meant to be a reference book for professionals who already know about patterns. I think it's more suited to people who want to learn them from the ground up. I would give it 10 stars if I could.

This is an excellent introductory book on patterns. They start out with the assumption that the reader does not really know what design patterns are or what they are good for. Developers who have been around awhile know about patterns, but overall I think their assumption is not a bad one: I think many of us have some ideas about patterns, and think we know some patterns, but don't really understand them. The book shines in its presentation of the patterns, even the ones we already "know," as extrapolations of basic OO design principles. The authors deserve very high marks for that.

They also have a lot of quirky, fun stuff in the book. It is, as another reviewer mentioned, almost insufferably cute. It's for the geek like me who wants to pretend we're not geeks, wink wink. Actually, I don't have any trouble with the humor, especially because sometimes it serves the valuable didactic purpose of helping one remember the points.

The negative points I have about the book are not primarily that the examples are simple; my main gripe is that the examples sometimes made things more confusing than they were before. For example, they spend an excellent first chapter discussing basic OO principles like "Favor Composition over Inheritance" and show how the Strategy pattern embodies them, and show a truly awful design in chapter 2 for Starbuzz Coffee (haha!) neglecting those principles, with a resulting explosion of classes. Very well.

But then, in chapter 4, they demonstrate the Factory pattern by eschewing composition in favor of inheritance, and creating an explosion of classes with all the varieties of pizza styles. Huh? Why are we suddenly dropping the principles that we've spent so much time on? Why not use composition with dependency injection as done in the "SimplePizzaFactory" example? Why not have a Pizza class that favors composition over inheritance? Now, there may in fact be good reasons, but they never discuss them. We're left wondering what's going on.

One more example: in discussing the Decorator pattern, they give what seems to me to be one of the worst uses of that pattern imaginable. "Condiments" are not "Beverages", and having a Beverage that chains to other Beverages seems very non-intuitive. Not at all a good example of "IS-A" relationships. Again, it's an illustration of the pattern, but a very jarring one that breaks reading continuity.

So, buy the book, read the book, "get" the patterns; but when you think some of the examples don't make sense, you're not alone.

This is a great book, very explicit, great examples, clear language and I couldn't stop reading. Very good.

I love this book. It is my first Head First book and I intend to buy more. It is really a fun way to learn. Though the book deals with some advanced topics, the way the material is presented makes it easier to get into your brain.

My suggestion is to pick up one of these books in a book store, skim through it to get the idea of where they're coming from, then buy the book from Amazon. (It's cheaper.)

They use a lot of graphic characters, conversations amongst characters, crossword puzzles, etc. It's not just a text book but a way to learn new technical material. They take a potentially dry subject and make it tasty and exciting.

I hope to see more Head First books in the future.

Finally, a book that explains the basic design patterns, in Java, in a way that makes sense.

The promise they make on the preface of the book is true. The knowledge really sticks to your brain, part due to the examples and part due to the language the authors use along the text. Just one thing to record, the authors were too humble declaring it can't be considered a reference guide, yes it is, although fun, the book is an excelent reference guide.

The "Head First" book series is the best product that O'Reilly makes and Head First Design Patterns is a perfect example of the quality and innovation inherent in this great series.

If you only need to learn the main design patterns or if you want to find out what the deal is with this whole 'design pattern' thing then this book is the easiest way to get started. For those who need to know all 23 design patterns then you might be stuck with the famous "Gang of Four" book which is not as easy or entertaining as this book but good none the less.

I buy quite a bit of stuff from Amazon. Don't we all. But all this while, I had never wrote a review. Just never felt compelled to do so until getting this book.

Just awesome!

I'm a hobbyist programmer and never learned about design patterns in school. Understanding they're importance I tried learning. I really did. But everything I read from articles to glances at different books just left me more clueless.

Except for a very small minority, this book will blow your mind (in a good way). I now understand why there are patterns, what the most popular ones are, and how to apply them.

Just get it.

It's really wonderfull. Not only funny to read, the most important thing: you learn a lot with it.
If you know very much about patterns and object oriented design you may find it useless... but even then you'll admit it's a great book for beginners and for people (not only beginners) who's been working with Java (or other OOLanguage) but haven't learnt subtle details. It makes you realize how many things can be always done better. It takes enough time to explain everything well. And finally, it doesn't only teach patterns but a bit of OODesign in general.

This book is great. Granted, it is a little bit...cheesy, but it is a great way to learn design patterns in a fun and easy to understand way. The code is great, and the object lesson are very effective. Coupled with the price, this is a great book for teaching yourself all the way to a college text book replacement. (My Software Engineering class in college used it!)

This book is fun. More importantly, it really does "load the patterns [...] straight into your brain" with some concerted effort on the reader's part. Once it all clicks (assuming you aren't a design pattern guru already), OOP is taken to the next level! You just need to conceptually map ducks, turkeys, pizzas, and waitresses to your particular situation. Your APIs and apps will rock! (I suspect some people won't like this learning style but at least give it a chance.)

I've read 25% of the book and I'm very pleased with it.

I like its informal style, although you might find they sometimes abuse of their jokes and funny pictures. In my opinion, the authors manage to get you reading more and more (and what's most important: learning).

Behind its appearance of a funny book there's a serious work. The authors help you learn the most important patterns and how they follow the OO programming principles (this is important, that's why those patterns are good).

I highly recommend this book if you are new to patterns but, if you are more or less familiarized with them you probably should go for the classic Design Patterns: Elements of Reusable Object-Oriented Software (Addison-Wesley Professional Computing Series).

I don't writes reviews, but this book was too good that I get forced from inside to write good about it. This book has every thing that you want to learn about design patterns.
This book is good for all level starting from Beginner to Advanced. And it has a different way of teaching that wills directly starting to make sense. Examples are based on real life problems, so it's definitely great book ever written on design patterns.
Two Thumbs up!!!

First off, this book is not for all programmers.
If you think the Gang of Four (GoF) books were great: stay way.
If you think the Gof book are not readable: get this book.

It was written by unconventional writers who are actually trying to TEACH the subject, rather than just tell you about it. That is different from almost all other tech books I see these days.

If you are new to design patterns, but know your object oriented design, this book could be for you. But please, go check out the book at a bookstore first.

This is great book very easy to understand, besides, it's only suitable for starters because it just have a small collection of the most common patterns.
Once you had read it, you'll have to research other sources of information, for deep knowledge and for more patterns.

I am very happy with this purchase. Delivery was prompt, condition of the book ... excellent!

I've been a software developer for a few years and I got this book on recommendation from a friend. I expected this book to be too basic or dumb things down too much but I found it to be very informative and easy to follow. I'd definitely recommend this book to anyone at any skill level interested in improving their skills as a programmer. It makes concepts very easy to understand and leaves you feeling like you've learned an incredible amount from it.

I bought this book because I got into the wave of designing software using UML designing tools.
As a beginner I found it useful but now looking back this won't save you from countless hours of breaking your head how to joggle with the design to fit in the requirements. And the childish design it actually helps. The books looks fluffy and this lets you see the skeleton of ideas from behind.
When talking about requirements I speak about memory footprint, speed of execution, flexibility, extensibility and so on.
I think this book will help you understand why the solution that you found by yourself actually work and improve the ones that you already have.
If you think that you'll become a good designer reading this, you are in for a big surprise.
As with most of things good guidance and a lot of work helps materialize a good theory.
Take the book and make a few designs. In the first designs don't think about any requirements just design to become able to spot the most obvious design mistakes.
Than go back and impose harder design requirements like how you can tweak it to become faster or consume less memory while still analyzing the design from the book perspective. After a few designs you'll definitely become a better designer.
Another book that helped me was Effective C++: 55 Specific Ways to Improve Your Programs and Designs (3rd Edition) (Addison-Wesley Professional Computing Series). This one is very practical and will help you understand that design patterns are dust in the eyes some times when memory and speed requirements are very tight.
This is my advice from my own experience. If it helps than I guess it is a good advice.

As many of the reviews point out, this is not a technical book. But this is not a book for dummies, either.

The first few pages state explicitly the purpose of the book: it's aimed at using all centers of one's brain with the purpose of drilling patterns into the long term memory, and to be able to connect patterns to real life problems. Thus, all the pictures, text, and repetition. It's not a dumbed down teaching style nor even a comprehensive course on patterns; the deeper purpose of the book is to get the reader to the "a-ha!" moment where s/he can start finding patterns useful to real-life problems.

This book was of great help to me. As someone who had very little good OO experience, I had no problem understanding patterns on Wikipedia, but I sure did have a problem "connecting" them to the real world. The book has enabled me to overcome the barrier, appreciate good design, and realize just how important patterns are.

Year back when i looked at Head First Java Servlet series, i was amazed at how clear and simple the concepts were laid out, yea it was good for a starter i thought and did glance it here and there and was pleased.

However There are somethings in Head First Series ( especially with regards to Design Patterns ) that will never click :

1.) Information presentation style is for Kids whereas subject is NOT! ( definitely not, its for people who do some serious stuff everyday and need some recurring problems solutions which can be 'applied' ! )

2.) Examples are absolutely rubbish, For example, in abstract factory i'd rather see a data access object pattern example than say a Pizza ville =(

its a matter of personal taste, for me a subject such as this needs more of a serious introduction than all in "fun" one.

Do yourselves a favor, pick up the old Gang of Four book, its still the best out there. ( and if you need some more specifics to language related problems, buy Core j2ee patterns ).

Regards
Vyas, Anirudh

It is really a good reference to learn design patterns. Its examples and the way to teach a subject is very impressive. Also pictures and comics make the book very funny and reminds you the things that you want to learn.
Head first readers have already known those things from the other books of them.
If you "start" to learn design patterns this book is very effective for you with all JAVA code examples and class diagrams.

This is by far the most stupid book ever written on the subject of design patterns. If you enjoyed this book, or if you found its style to be useful in learning, then you have no right working in the software development field. This book is written by dummies for dummies. Period!

Sure, you may learn a few things about design patterns, but you did it using child like learning methods. That should raise some red flags about your ability to understand complex technical subjects like a grown adult. If you cannot learn from real sources, then please, please, please, stay away from any sort of programming career.

This is one of the best, if not the best, technical book I've ever read. The method of teaching is wonderful and it actually was fun to read. After finishing this book, I re-read the Gang Of Four book and it make much more sense. The only negative is that there isn't a "Head First" book for everything that I want to learn!!! ;-)

At first I was digging this book, towards the middle I ripped it up into shreads (just like the OOA/D book by head first) and threw it away. As a matter of fact, it's sitting in my trash can as I'm writing this. If you're looking for a book explaining design patterns, like many of the cartoons within it, this book's a joke. They could have reduced this book to a fifth of it's size. Instead, you get a load of childish and repetitive fluff. You'll feel like you're getting introduced to design patterns by the dumb jocks who used to beat you up in high school. For goodness sake, we're software engineers not cheerleaders. People, get a real book.

I've got a number of years of software development under my belt. Like most of my colleagues I use design patterns on a daily basis, yet sometimes struggle to identify them by names defined in GOF book, which I've read years ago.
I decided to refresh my memory by reading another book on patterns.
While GOF book covers more patterns, it's not as nearly as much fun to read as Head First Design Patterns. Head First book is simply brilliant! It took me through my early days experience of creating stupid solutions and refactoring them into something nice and elegant. I wish I had this book back then :)
The book is structured very well, with hands-on examples understandable by anybody who can read code.
Bottom line:
- I definitely recommend this book to any junior developer who wants to get familiar with Design Patterns
- Experienced developers will skip quite a few pages (like I did), yet it's still a good read. Most of the time you'll be thinking "a-ha, so this stuff I did yesterday is called Facade!". Knowing the names of patterns saves time in communicating ideas with colleagues. So go and get this book, it's worth it.

First I was a bit skeptical. But this book turned out to be a pleasure to read.

The authors miss the point on pg 139 in their description of Dependency Inversion. They say, "It suggests that our high level components should not depend on our low level components; rather they should both depend on abstractions". The real point of the pattern, if you read Robert Martin original description of the pattern, Agile Principles, Patterns, and Practices in C# (Robert C. Martin Series), is that neither should depend on the other. No concrete dependency and no abstract dependency; independent. The description these authors offer does not describe dependency inversion; it instead displays the weakness of dependency on abstractions Mr Martin wrote about in his original description of the pattern. The only dependency should be the object(s) or data passed between them but the authors fail to make this point. Mr Martin's book is brilliant.

Easy to read and follow.

All the examples are in Java and I'm not a Java programmer, but I can understand the examples.

This books is not a pattern catalog. Only the fundamental patterns are presented.

An excellent place to start learning about design patterns.

I just felt the strong urge to write a review. I usually don't write reviews. My opinion about this book is either you will love it a lot or hate it to the core. I hated it. Their writing style is not conventional. So please go to a book store and read a few pages and see if you like this style of writing. Even though when I first read, I thought I liked it, I realized I don't like this style of writing for a technical book

I think the book is great for learning what it was written to teach. I found it easy to read and stay in its pages for a longer period of time. If you've read computer related books you know what I'm talking about. I would definitely recommend this book if you ware getting into design patterns and want to get a rock solid foundation. One consideration though, you really need to know something about Java or C#. If you are completely unfamiliar with OOP languages altogether, you might want to tackle that subject before this one.

I flipped through this book to get a feel for how it will differ from other design patterns works. I immediately realized that the authors are taking a very accessible approach to teaching readers about patterns.

On an individual basis, the text is very accessible. It is written in an easy-to-read style. Instead of avoiding technical jargon, the text improves understanding and retention by coupling technical terms with humorous anecdotes and quips. This approach gives the feeling that design patterns are within reach (and they are) of even readers new to the concepts. It also serves as a built-in mnemonic tool.

The structure of pattern delivery seems to be intentional as well. In the rare case where a pattern is referenced without yet being described, it is almost always in the context of how the current pattern will prove useful in other scenarios. As such, the reader never feels lost. In fact, quite the opposite affect occurs. Readers should feel like they are following a logical approach to learning patterns.

Although it may seem, from the above comments, that the book is elementary, I assure you that even seasoned developers will find the book useful. Even if you know the material extremely well, you may find that the authors' descriptions are useful when teaching junior developers on your teams.

The book layout, like the rest of the book, is broad-reaching. Obviously, it is an instructional work. More than that, however, the book is also a teaching tool. It can easily be adapted by educators and trainers for classroom-style and one-on-one teaching. The book also serves as a workbook. There are exercises and notes pages throughout each chapter. Finally, the book serves me as a reference work as well. If I remember the gist of a pattern but not the specifics, it is easy to find examples and canonical references.

I absolutely love this style. I highly recommend this book for anyone wanting to learn patterns, refresh their existing patterns knowledge, or just take in a proverbial "breath of fresh air" to the stiff writing style of other books covering complex topics. I also feel that any of the "Head First" books are worth consideration. They provide accessible formats that promote learning.

I have to close this review by concurring with the authors in their note to the "Gang of Four". Seriously, when are we going to see another book? :)

If you are working, if you don't have too much time to invert in learning, or if you feel that leraning something new is very difficult for you, then this book may help you. When i started reading it, the book traped me, and all that stuff (that the book does) to keep your atention focused works.

The book says on the first pages that there will be repeated things, with the purpose of helping you to GET the concepts, and not forGET them later. Besides that trick, there are other aids and ideas to achieve that (text written very near -or inside- images, exercises and more).

This is the first ever technical book I could not stop reading as much as I can...

If you want a book to learn design patterns without falling asleep while doing it, this is the book. It allows you to learn design patterns and then go to other more "textbook" resources for a deeper understanding.

Some buyers might be turned off to the book because all the code snippets are in Java. I am not a big Java user, more C++, but I found the code snippets in the book easy enough to follow.

Excellent book if you want to learn design patterns. These guys do a great job at making learning fun. The way things are explained, it is easy to grasp , you wont get bored. Must buy.

This is quite a long book (638 pages) considering that it only covers about 13 design patterns in detail. The original Design Patterns by the 'gang of four' covered about 23 patterns. However the Head First book has some advantages. 1st: It's not nearly as abstract and computer science orientated as the 'gang of 4' book. 2nd: It's written to take account of the fact that these design patterns are not common sense - they are not intuitive. So the authors use quite a lot of diagrams, various cute 'Head First' learning strategies, reinforced examples and practical exercises. 3rd: The Head First books also explains some of the principles of OOD (and they do this as they explain why the patterns are that way) which is something I didn't find in the other C# 'Design Patterns' book I got which covered all the origninal 'gang of 4' patterns [the other book is 'Design Patterns', publ. 2007, ISBN: 1598220314 by C. Lasater]. So the Head First book is recommended. The Head First examples are in java but java is very close to C# and someone has converted all the code to C# anyway which you can get by following the link at the book code download page http://www.wickedlysmart.com/HeadFirst/HeadFirstDesignPatterns/HeadFirstPatternsIndex.html. A note on this Head First C# code. It's written for dot net 1.1 and assumes you will use NUnit to run it. NUnit is a free download but although I could install NUnit 2.41 and convert the C# code to dot net 2.0 I couldn't figure out how to get it to work with NUnit. This is probably because I've not used NUnit previously!. I'm having to convert each pattern to to a console application and write a main() to test it. That is only a small amount of work.