You’re not alone.

At any given moment, somewhere in the world someone struggles with the same software design problems you have. You know you don’t want to reinvent the wheel (or worse, a flat tire), so you look to Design Patterns--the lessons learned by those who’ve faced the same problems. With Design Patterns, you get to take advantage of the best practices and experience of others, so that you can spend your time on...something else. Something more challenging. Something more complex. Something more fun.

You want to learn about the patterns that matter--why to use them, when to use them, how to use them (and when NOT to use them). But you don’t just want to see how patterns look in a book, you want to know how they look "in the wild". In their native environment. In other words, in real world applications. You also want to learn how patterns are used in the Java API, and how to exploit Java’s built-in pattern support in your own code.

You want to learn the real OO design principles and why everything your boss told you about inheritance might be wrong (and what to do instead). You want to learn how those principles will help the next time you’re up a creek without a design pattern.

Most importantly, you want to learn the "secret language" of Design Patterns so that you can hold your own with your co-worker (and impress cocktail party guests) when he casually mentions his stunningly clever use of Command, Facade, Proxy, and Factory in between sips of a martini. You’ll easily counter with your deep understanding of why Singleton isn’t as simple as it sounds, how the Factory is so often misunderstood, or on the real relationship between Decorator, Facade and Adapter.

With Head First Design Patterns, you’ll avoid the embarrassment of thinking Decorator is something from the "Trading Spaces" show. Best of all, in a way that won’t put you to sleep! We think your time is too important (and too short) to spend it struggling with academic texts.

If you’ve read a Head First book, you know what to expect--a visually rich format designed for the way your brain works. Using the latest research in neurobiology, cognitive science, and learning theory, Head First Design Patterns will load patterns into your brain in a way that sticks. In a way that lets you put them to work immediately. In a way that makes you better at solving software design problems, and better at speaking the language of patterns with others on your team.

You’re not alone.

At any given moment, somewhere in the world someone struggles with the same software design problems you have. You know you don’t want to reinvent the wheel (or worse, a flat tire), so you look to Design Patterns--the lessons learned by those who’ve faced the same problems. With Design Patterns, you get to take advantage of the best practices and experience of others, so that you can spend your time on...something else. Something more challenging. Something more complex. Something more fun.

You want to learn about the patterns that matter--why to use them, when to use them, how to use them (and when NOT to use them). But you don’t just want to see how patterns look in a book, you want to know how they look "in the wild". In their native environment. In other words, in real world applications. You also want to learn how patterns are used in the Java API, and how to exploit Java’s built-in pattern support in your own code.

You want to learn the real OO design principles and why everything your boss told you about inheritance might be wrong (and what to do instead). You want to learn how those principles will help the next time you’re up a creek without a design pattern.

Most importantly, you want to learn the "secret language" of Design Patterns so that you can hold your own with your co-worker (and impress cocktail party guests) when he casually mentions his stunningly clever use of Command, Facade, Proxy, and Factory in between sips of a martini. You’ll easily counter with your deep understanding of why Singleton isn’t as simple as it sounds, how the Factory is so often misunderstood, or on the real relationship between Decorator, Facade and Adapter.

With Head First Design Patterns, you’ll avoid the embarrassment of thinking Decorator is something from the "Trading Spaces" show. Best of all, in a way that won’t put you to sleep! We think your time is too important (and too short) to spend it struggling with academic texts.

If you’ve read a Head First book, you know what to expect--a visually rich format designed for the way your brain works. Using the latest research in neurobiology, cognitive science, and learning theory, Head First Design Patterns will load patterns into your brain in a way that sticks. In a way that lets you put them to work immediately. In a way that makes you better at solving software design problems, and better at speaking the language of patterns with others on your team.

You’re not alone. At any given moment, somewhere in the world someone struggles with the same software design problems you have. You know you don’t want to reinvent the wheel (or worse, a flat tire), so you look to Design Patterns--the lessons learned by those who’ve faced the same problems. With Design Patterns, you get to take advantage of the best practices and experience of others, so that you can spend your time on...something else. Something more challenging. Something more complex. Something more fun. You want to learn about the patterns that matter--why to use them, when to use them, how to use them (and when NOT to use them). But you don’t just want to see how patterns look in a book, you want to know how they look "in the wild". In their native environment. In other words, in real world applications. You also want to learn how patterns are used in the Java API, and how to exploit Java’s built-in pattern support in your own code. You want to learn the real OO design principles and why everything your boss told you about inheritance might be wrong (and what to do instead). You want to learn how those principles will help the next time you’re up a creek without a design paddle pattern. Most importantly, you want to learn the "secret language" of Design Patterns so that you can hold your own with your co-worker (and impress cocktail party guests) when he casually mentions his stunningly clever use of Command, Facade, Proxy, and Factory in between sips of a martini. You’ll easily counter with your deep understanding of why Singleton isn’t as simple as it sounds, how the Factory is so often misunderstood, or on the real relationship between Decorator, Facade and Adapter. With Head First Design Patterns, you’ll avoid the embarrassment of thinking Decorator is something from the "Trading Spaces" show. Best of all, in a way that won’t put you to sleep! We think your time is too important (and too short) to spend it struggling with academic texts. If you’ve read a Head First book, you know what to expect--a visually-rich format designed for the way your brain works. Using the latest research in neurobiology, cognitive science, and learning theory, Head First Design Patterns will load patterns into your brain in a way that sticks. In a way that lets you put them to work immediately. In a way that makes you better at solving software design problems, and better at speaking the language of patterns with others on your team.

You’re not alone.

At any given moment, somewhere in the world someone struggles with the same software design problems you have. You know you don’t want to reinvent the wheel (or worse, a flat tire), so you look to Design Patterns--the lessons learned by those who’ve faced the same problems. With Design Patterns, you get to take advantage of the best practices and experience of others, so that you can spend your time on...something else. Something more challenging. Something more complex. Something more fun.

You want to learn about the patterns that matter--why to use them, when to use them, how to use them (and when NOT to use them). But you don’t just want to see how patterns look in a book, you want to know how they look "in the wild". In their native environment. In other words, in real world applications. You also want to learn how patterns are used in the Java API, and how to exploit Java’s built-in pattern support in your own code.

You want to learn the real OO design principles and why everything your boss told you about inheritance might be wrong (and what to do instead). You want to learn how those principles will help the next time you’re up a creek without a design paddle pattern.

Most importantly, you want to learn the "secret language" of Design Patterns so that you can hold your own with your co-worker (and impress cocktail party guests) when he casually mentions his stunningly clever use of Command, Facade, Proxy, and Factory in between sips of a martini. You’ll easily counter with your deep understanding of why Singleton isn’t as simple as it sounds, how the Factory is so often misunderstood, or on the real relationship between Decorator, Facade and Adapter.

With Head First Design Patterns, you’ll avoid the embarrassment of thinking Decorator is something from the "Trading Spaces" show. Best of all, in a way that won’t put you to sleep! We think your time is too important (and too short) to spend it struggling with academic texts.

If you’ve read a Head First book, you know what to expect--a visually-rich format designed for the way your brain works. Using the latest research in neurobiology, cognitive science, and learning theory, Head First Design Patterns will load patterns into your brain in a way that sticks. In a way that lets you put them to work immediately. In a way that makes you better at solving software design problems, and better at speaking the language of patterns with others on your team.

First glance may resembles a comic book, but ...
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.

Accessible and immediately useful
[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.

Wow, never seen it put this way
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.

Very good book
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.

Very good book on patterns but examples leave questions
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.

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

Head First is good for your brain.
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!
Finally, a book that explains the basic design patterns, in Java, in a way that makes sense.

Amazing and fun book
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 best way to learn the main design patterns
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.

Wonderfull
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.

Writing my first Amazon review in appreciation of this book!
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.

Head First Design Patterns
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!)

Applied design patterns...
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.)

A very good book (if you don’t mind the informal style)
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).

Great Book
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!!!

Excellent book -- very different style
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.

Surely a first step
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.

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

Excellent book for all skill levels
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.

pretty good book
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.

Excellent way to connect patterns to real world problems
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.

This Head First will make your Head ’Spin’ First unfortunately
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

Best way to learn
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.

Stupid book for stupid people.
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.

AWESOME book!
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!!! ;-)

Bad choice for professional developers
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.

Really good hands-on book on design patterns
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.

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

Not All That
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.

Excellent Intro
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.

Love it or Hate it and I hate it
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

Excellent learning style
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.

Theory AND Practicality!
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? :)

A good choice
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).

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

Design patterns
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
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.

Buy it.
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.

Awesome book - The best for understanding design patterns.
This is the best design patterns book i have ever read. With a completely new approach this book makes learning design patterns such an enjoyable reading experience with lot of FUN. Having worked with Object Oriented programming in Java for many years i found myself enjoying the reading with every page and could see many aspects of design practically unfold in multitude of images in my mind as well as in the book. The examples are great, the bullet points are excellent and the pace and tone of the text alongwith the images and drawings are absolutely fantastic. I would recommend this book to anyone who wants to learn and apply patterns in their object oriented programming using Java or C#.

Better book to start with
I tried to read Steven Metsker’s book "Design Patterns in C#" before this one. But it was a difficult read because I was new to the subject. After reading "Head First", I was able to understand why Metsker’s book is a well written and well organized book. If you are a C# programmer and have no experience in design patterns, you need both books.

One of the best
This book is an extremely clear and readable introduction to design patterns. It has serious contents and is not too goofy so that it becomes distracting.

While the sample code is in Java (and will help you gain more appreciation for the language) the concepts will apply to other languages equally well.

Definetly one of the best and most approachable books on this subject. Highly recommended if you want to learn about design patterns.

Outstanding!
I had never read a Head First book but everybody talks about them!
Having read the SCJP book by Katty Sierra and Bert Bates, I decided to try the Design Pattern book (authored by the Freeman couple, with help from Katty & Bert).

My impression... wow!
VERY clearly explained, lot of examples, lot of graphics! After 8 hours of work I find myself arriving at home and just reading chapter or two to relax! What amazes me is that for each chapter they present a requirement and create a first solution that is VERY similar to what we, in our fast spaced, timeline based IT world are used to do: something that will be done quickly and will solve the business needs... for now.
But then they show what can happen when CHANGES are requested to our initial solution (software developers KNOW what we are talking about here!) so that the reader truly apreciates how the initial quick-solution is totally un-scalable and lot of code rewriting must be dedicated over again to implement the changes.
A pattern is then introduced, showing how, by dedicating just a little bit of effort in the early stages of development, can save hours and hours of work in the future.

Phenomenal
If you haven’t read a pattern book before, this is the one to start with. It not only teaches patterns in an approachable manner, it also teaches sound object oriented design. It’s so good I’ve bought one for every person on my team. Each time we hire a new developer we hand them a copy of Head First Design Patterns. Excellent book.

A Must Read
If you plan on ever going into a programming/computer science related field, this book is a must. Great reference book, and easy to understand and retain information. This book will help a programmer transform into a software engineer. I never understood the full power of abstract / interface classes until reading this book (one of my college professors reccommended it for his software engineering 2 class). In my four years of college, the best book I purchased.... by far.

Fun way to learn about design patterns
This is a fun way to learn a serious topic. I can’t personally imagine a more entertaining method to write a book about a "mundane" topic such as design patterns. The book promises that the concepts and topics would ’reside’ in the reader’s brain long after the reader is done reading the book. That I found to be a true statement for myself. I am sure you will find that true too.

Remember that the authors expect you to known the fundamental concepts about OO design (UML) and Java (C# knowledge might be supplementary). But of course, you wouldn’t be reading a book about design patterns without knowing the concepts before hand. Would you?