Book Information

Authors: Elisabeth Freeman, Eric Freeman, Bert Bates, Kathy Sierra
Paperback: 676 pages
Publisher: O'Reilly Media, Inc. (October 25, 2004)
Language: English
ISBN: 0596007124
Product Dimensions: 9.3 x 8.0 x 1.4 inches Link

 Book Review

Head first Design Patterns, by Eric Freeman and Elisabeth Freeman takes the same design as that of the other Head first series books. The Head First concepts are designed by Kathy Sierra and Bert Bates, the authors of the Head First Java.


Design Patterns have become the part and parcel of every developer irrespective of the programming language they use. In fact, this subject was included in the curriculum of Computer Science Undergraduate studies. But ask a computer professional to suggest two most boring subjects then the answers you often get are XML and Design Patterns. Even a person suffering with insomnia could probably get sound sleep if he takes up a book on XML and the same holds good with Design Patterns. The book is surprise when it comes to this aspect. The authors have made use of the exciting Head First concepts and treats the subject of design patterns in a different fashion, using illustrative figures and simple techniques to ‘teach’ the concepts to the readers.



The book is rich in content, covers 13 design patterns in detail. It starts with an introductory chapter on Design patterns where the Strategy pattern is explained and there on, the patterns follow the subsequent chapters. The approach taken by the authors to explain the design pattern is straight forward. First they present a situation or a problem which is defined thoroughly and quite a few approaches are presented. Then they explain the pattern which could be used on the problem, in a simple way. Then the pattern is defined with technical terms, the author then shows how to apply the pattern to a problem. Then inner details about the pattern, in what situations it is beneficial, etc. are discussed. Wherever applicable the discussion focuses on Java’s support for design patterns. Then each of the chapter is concluded with end chapter exercises. Throughout the book, the authors present a Student-Master conversation at several places which is quite interesting, the student exactly talks about the queries that reader might probably have when reading the chapter. The master then answers them wisely.

Apart from the 13 design patterns, the book has a chapter on Compound patterns which focuses mainly on the Model-View-Controller architecture. The final chapter is a collection of tips and useful information which helps the reader to apply the design patterns they learnt, practically. The book concludes with an appendix which gives introduction to some of the other design patterns that could not make up into the chapters.


The book in spite of being theoretical is never boring and the authors have managed to make it quite interesting when compared to many other books on the same subject. The layout of the book, narration of the subject, the choice of examples is what makes this book different from any other book on Design Patterns.


At the end of the day, what matters is that if we are able to grasp some concepts from the book and the head first series adds an extra step – “how easy was it to grasp the concepts”, and for sure the book lives up to its expectations. The book is no reference on the subject of design patterns, and even the authors agree on this. But this is definitely a reference to those who are new to design patterns and want to know how to apply those to their daily programming tasks. The book focuses on Java as the language of choice, but developers of other languages can also benefit from this excellent book of Head First Series.

 Table of Contents
  1. Intro
  2. Welcome to Design Patterns: an introduction
  3. Keeping your Objects in the know: the Observer pattern
  4. Decorating Objects: the Decorator patter
  5. Baking with OO goodness: the Factory pattern
  6. One of a Kind Objects: the Singleton Pattern
  7. Encapsulating Invocation: the Command Pattern
  8. Being adaptive: The Adaptive and Façade Pattern
  9. Encapsulating algorithms: the Template Method Pattern
  10. Well-managed Collections: The Iterator and Composite Pattern
  11. The State of Things: the State Pattern
  12. Controlling Object Access: the Proxy Pattern
  13. Patterns of Pattern: Compound patterns
  14. Patterns in the Real World: Better living with Patterns
  15. Appendix: Leftover Patterns
 Overview of Chapters
  1. Welcome to Design Patterns

    Pattern Covered: The Strategy Pattern
    Problem Described: The SimUDuck application
    Others: Some of the OO Basics, OO Principles are talked about.

  2. Keeping your Objects in the know

    Pattern Covered: The Observer Pattern
    Problem Described: The Weather Monitoring application
    Others: Advantages with Loose Coupled design

  3. Decorating Objects

    Pattern Covered: The Decorator Pattern
    Problem Described: The Starbuzz Coffee application
    Others: Open Closed Principle

  4. Baking with OO Goodness

    Pattern Covered: The Factory Pattern
    Problem Described: A Simple Pizza Factory
    Others: Dependency Inversion principle

  5. One of a Kind Objects

    Pattern Covered: The Singleton Pattern
    Problem Described: A Chocolate Factory application
    Others: how to deal with multithreading

  6. Encapsulating Invocation

    Pattern Covered: The Command Pattern
    Problem Described: A Home Automation System

  7. Being Adaptive

    Pattern Covered: The Adapter and Façade Patterns
    Problem Described: A Home Theater System
    Others: The Principle of least knowledge

  8. Encapsulating Algorithms

    Pattern Covered: The Template Method Pattern
    Problem Described: pieces of algorithms are encapsulated
    Others: The Hollywood Principle

  9. Well-Managed Collections

    Pattern Covered: The Iterator and Composite Patterns
    Problem Described: Objectville Diner and Pancake house
    Others: Magic of iterator and composite together..

  10. The State of Things

    Pattern Covered: The State Pattern
    Problem Described: Gumball Machine reworked
    Others: Applying State charts to programming

  11. Controlling object access

    Pattern Covered: The Proxy Pattern
    Problem Described: Remote Gumball Machine
    Others: Virtual Proxies, dynamic proxies

  12. Patterns of Patterns

    Pattern Covered: Compound Patterns
    Problem Described: Duck Reunion
    Others: Using all the patterns together and using an MVC Architecture

  13. Patterns in the Real World

    Pattern Covered: None

    • How to create Patterns
    • Organizing Design Patterns
    • Thinking in Design Patterns
    • Top five ways to share design patterns
    • Other Design Pattern Resources


  14. Appendix: Leftover Patterns

    Pattern Covered:

    • Bridge pattern
    • Builder pattern
    • Chain of Responsibility pattern
    • Flyweight Pattern
    • Interpreter Pattern
    • Mediator Pattern
    • Memento Pattern
    • Prototype pattern
    • Visitor pattern