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.

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.

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.

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.

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

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.

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