Head First Design Patterns: A Brain-Friendly Guide

A wonderful book to introduce and explain some of the key design patterns. The Java examples are well explained and clear. It's not an exhaustive definition, nor does it claim to be. It is, however, a very approachable guide. I reopen it to review the examples almost weekly. Well done Head First!

Unfortunately, I had the same experience before with the Orally series books. The example code is hard to understand. Let me explain way. The first lesson on patterns is about a way to avoid duplication of code and hiding the code implementation to other objects that do not need to know about that implementation. So, they write a set of objects to "explain" how to do it. So, they write interfaces, concrete classes, and abstract class to show the behavior, which it was complicated enough itself. But wait... they add several different behaviors and classes for different types of ducks, on the very the first example! It was hard to decipher the code and it wasn’t until I build my own set of simplified objects for just 1 behavior that I began to understand! And, all this pictures and drawings, kind to confuses me a little too, not entertain me at all, like they say it was the purpose. So, if you get the book, the clue is: SIMPLIFY the code and you’ll be fine.

This book was recommended to me at a Design Patterns training, along with the Gang of Four design patterns book. This book had clearer examples, was easier to read and more information contained within it than the Gang of Four book.

Awesome book, great job.

The Kindle edition for this book is incompatible with a regular Kindle. You can read it on iPad, but it's just page images so it's really hard to read. the store refunded my money with a push of a button, so no problem there. Also, the book is excellent. I have already read the paper based version of this. If you want to learn GOF patterns, I highly recommend this book.

Plenty of people have commented about the teaching style, and I do not have much to add in that regard. I bought this book as an adjunct to the GoF book, and it serves nicely for me. To put this in context, my favorite chapter in GoF is the second chapter, where they provide the design for an hypothetical editor. Learning and remembering is easier for me when it is tied to something concrete. Like many others, I could do with about 1/2 as much material, but it is easy enough to start skimming when they repeat themselves.

Where I feel this book seriously goes astray is in the problems they choose to use. For reasons I don't understand, they choose to illustrate several design patterns for a problem domain they should not be applied to.

For example, they illustrate the decorator pattern by designing a solution for calculating the prices for a coffee shop. They start out well, showing a naive explosion of classes (HouseBlendWithWhipAndSoy, DecafWithSteamedMilk, and so on), which is clearly a bad approach. Yet, they still implement a number of classes - 4 different classes for each beverage type, and then a decorator for every additive you might want (mocha, soy, milk, whip, etc). This is clearly silly; can you imagine telling a company that every time they want to add a new drink or drink additive you have to modify code?

In the very next chapter we are introduced to the Factory pattern. Before long we are once again writing specialized classes to deal with composition: You have the Pizza class, then the ClamPizza class, a CheezePizza class, a VeggiePizza, and so on. You deal with that with composition (covered in the very first chapter!), not types. What is particularly distressing about this example is that they rightly showed what a maintenance nightmare it would be to have to write a NYStyleCheesePizza, ChicagoStyleCheezePizza, and so on. Again, imagine telling a restaurant owner that every time he wants to introduce a new pizza on the menu that you need to write code and deliver a new application to him. Madness.

I anticipate a retort that these are toy problems meant to illustrate the idea. But we use decorator patterns all of the time in the real world, on real problems. Why not use one of those problems in the book? Again, I recall chapter 2 of GoF; their example problem (a text editor) is very real world, very understandable, and yet is no more complicated than the toy problems in this book. This form of OO, where inheritance and types are used as the main tool in the toolbox is what we see out of junior programmers every day, and it just makes for unmaintainable code.

I do like the exposition style, but loathe (some of) the examples. I guess that averages out to 3 stars? I dunno. I would not hand this book to a junior programmer for fear of them being led astray. I would hand it to an intermediate programmer whose skills I know with strong caveats about the quality of the examples.

class VeggiePizza. Really!

I have been looking for a Design Patterns book for awhile, and have read a few sample chapters from a few books out there, including the GOF's, and Design patterns in C#. Honestly, although GOF book is the bible of Design Patterns, it was hard to understand... When I grabbed the Head First Design Patterns book - the first thought that came to my mind was - this cant be serious... and surprisingly, the authors knew the readers would get that feeling at first, as explained in the introduction section. I read a sample chapter, and finally it was making sense to me. The language is common conversational style, and with lots of diagrams and most importantly I like the way it gradually introduces you to the problem and how a specific design pattern can be used to solve it...

This stuff is simply brilliant! Unbelievable how they made learning the Observer Pattern seem like even a chimp can learn it. I just love how they start with a bare bones example and then build it up bit by bit. This comic strip stuff is an absolutely fun and effectively a potent learning tool! Fantastic attention to details!

Much better to read than a dry MSDN-like approach to the topic. Yes, it definitely gets silly at times, but the points are made and the progress is fairly quick-moving. I'd definitely recommend this book.

I came across this book by way of several recommendations from colleagues, and they were right. While it's not an exhaustive or formal examination of all design patterns, it does a great job teaching you about the design patterns that you are most likely to encounter on a day-to-day basis. The style of the book is relaxed and conversational, which helped me retain what I was reading easily.

If you are looking for a solid introduction to design patterns, start with this book.

The method used by the authors is very useful. Now I have in my brain (as they told at the begining) what the patters are and why we should use them.

My only complain is that is excessively java oriented. Some interesting examples (MVC and some other) are very difficult to follow due to the platform commintment.

Anyway the concept is still there and there are many sources to fix this concept with an example exercise.

Very good for current software developers and goes well alongside design patterns 2nd edition. It is good to read cover to cover once since each pattern builds on the previous but you can read specific chapters as well.

This book make learning design patterns easy and fun. The book reads well, meaning that it was not a chore to pick up the book and read on to the next chapter. This book made me a fan of the 'Head First' collection.

As with most Head First books, this book is geared towards self-study. If you want to teach yourself about design patterns for practical use writing object oriented code, this book is a fantastic place to start (probably the best place, for most). I will mention that the middle chapters can start to feel like a slog. I finished the book over a number of months, with breaks in between. The content is great all the way through -- I just needed to process some patterns in smaller batches, I guess.

I really liked the first chapter in the book - some advice on how to learn and retain the material. Every book should have this - author's suggestions on how to retain the material the author/s spew. The book is very very good in helping to retain the patterns in your head. But to achieve this i think some of the illustrations used are contrived. Perhaps the examples could've been more drawn from some real world applications ? Very good book nevertheless.

A really good introduction to design patters. Each chapter is really wordy though, I would have liked to have a quick reference section where each design pattern was summarised for quick reference later. After reading this book you will start seeing patterns everywhere in your code!

Great book, clear instructions. Interesting to read with good examples. Authors made a great effort to explain Design templates in a very good way.
Also, Book came 2 weeks earlier than expected.
My recomendation.

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.

Really interesting and easy to understand book. But do not buy it for kindle or any other e-readers. Layout of the text is really crazy and most of the code inserted as images which are extremly tiny.

I recommend all Head First books to my students - this book is just as awesome as all the Head First books out there - the humor is great - the code is excellent - you create a whole project as you go along in the chapters - and you learn more than you would in a conventional textbook - guaranteed!

I recommend all Head First books to my students - this book is just as awesome as all the Head First books out there - the humor is great - the code is excellent - you create a whole project as you go along in the chapters - and you learn more than you would in a conventional textbook - guaranteed!

Highly approachable and absorbable. I'm a professional developer of several years, but I don't have a hard and fast computer science background, and I'm always looking for ways to supplement that and add some of the more classic elements to my knowledge base. I've been through CLRS, the Wayne/Sedgewick Red Book, Clean Code, etc., and while I got an awful lot from those books, I almost wish I had started here. Still finding much benefit in it, but this is both a great wealth of knowledge and super easy to get into by comparison to some of the others I mentioned, which can be lead-dense at times. Good SOLID principles taught here. Fun examples that keep you engaged without being flippantly silly. Very well laid out visually and contextually.

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've studied design patterns for years. I wish this book was available back when i started studying them. It's very well written, verging on entertaining. The end result is a clear understanding of what each design pattern is and how it can be used. Well done!

I purchased this book after reading some chapters of the Head First: Object Oriented Analysis and Design book. I've always wanted to learn more about patterns. I have one of the definitive books on patterns but it is had to grasp. Although that books provides examples of the patterns with certain problems/solutions, it does a poor job of diagramming the thought process. Head First does a great job of adding to the knowledge foundation to start thinking about why a pattern is necessary, and why it works. I've already used two of the patterns as I was learning them.

The downside to this book is that it does not have as much coverage in the patterns. Other books are needed to supplement it. However, the knowledge retained is invaluable.

The examples in the book are very well chosen. This gave me real insight in the impact of using design patterns in applications. Every pattern is tested again 9 Object Oriented principle. Above all I read it like a novel.

I highly recommend this book. Suitable for beginners in programming. It teaches you how to programme PROPERLY, I am very surprised as to why is this topic only taught on the 3rd year of my studies! If you are a Malaysian, don't go UCTI ! Very awful university. save your money. Buy this book!