Design patterns and their benefits

A design pattern is a description of a common design problem and the essence of a good solution to it, written in a general way so that it can be reused in many different settings. Patterns capture the experience of expert designers. They became widely known through the "Gang of Four" book (Gamma, Helm, Johnson and Vlissides, 1995).

Essential elements of a pattern

1. Name – a meaningful reference, e.g. Observer.
2. Problem description – when the pattern applies and what problem it solves.
3. Solution description – the classes/objects involved, their relationships and responsibilities; a template, not concrete code.
4. Consequences – the results and trade-offs of using the pattern.

Kinds of patterns (GoF)

• Creational – object creation, e.g. Singleton, Factory Method.
• Structural – composing classes and objects, e.g. Adapter, Facade, Composite.
• Behavioural – communication between objects, e.g. Observer, Strategy, Iterator.

Example: Observer pattern

Problem: several displays must show the same data, and all must update automatically when the data changes. Solution: the data object (subject) keeps a list of observers and calls update() on each when its state changes.

+----------------+  notifies  +----------------+
|    Subject     |----------->|   Observer     |
|----------------|  1      *  |----------------|
| attach(o)      |            | update()       |
| detach(o)      |            +----------------+
| notify()       |                ^        ^
+----------------+                |        |
        ^                 +----------+ +----------+
        |                 | Bar      | | Pie      |
+----------------+        | chart    | | chart    |
| SalesData      |        | view     | | view     |
+----------------+        +----------+ +----------+

When SalesData changes, both the bar chart and pie chart views are updated, and new views can be added without changing SalesData.

Benefits of design patterns

1. Reuse of proven design knowledge – solutions already tested in many systems.
2. Common vocabulary – saying "use a Singleton" communicates a whole design quickly.
3. Better quality designs – patterns promote low coupling, high cohesion and flexibility.
4. Faster design – designers do not need to solve known problems again.
5. Easier maintenance and extension – structures like Observer or Strategy let new behaviour be added with little change.
6. Language independence – patterns can be implemented in any object-oriented language.
7. Better documentation – naming the patterns used makes a design easier to understand.