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
Amazon.com Link

Organization

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.

Difference

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.

Finally

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.

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

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
    Others:
    

    • 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

Reviewer: Krish Bhargav