On Software Patterns — Gang of Four
Software Patterns are general, reusable solutions to a commonly occurring problem within a given context in software design. Software patterns speed up the development process by providing tested development paradigms, they are also sometimes referred to as best practices. Over a decade ago four authors Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides wrote “Design Patterns: Elements of Reusalve Object-Oriented Software”. This book would go on to become infamous for being the first to describe many common software patterns that are still used today. The authors (Gamma, Helm, Johnson, and Vlissides) would go on to be remembered as “The Gang of Four”, immortalizing them in the space of software developers around the world.
The Gang of Four described three different types of design patterns including Creational Design Patterns, Structural Design Patterns, and Behavior Design Patterns.
Creational Design Patterns — describe patterns that create objects/artifacts. They include,
- Abstract Factory, allows for the creation of objects w/o specifying their concrete type
- Builder, used to create complex objects
- Factory Method, creates objects w/o specifying the exact class to create
- Prototype, creates a new object from an existing object.
- Singleton, ensures only one instance of an object is created.
Structural Design Patterns — ease the design by identifying a simple way to realize relationships among entities. They include,
- Adapter, allows for two incompatible classes to work together by wrapping an interface around one of the existing classes.
- Bridge, decouples an abstraction so two classes can vary independently.
- Composite, takes a group of objects into a single object
- Decorator, allows for an object's behavior to be extended dynamically at run time.
- Facade, provides a simple interface to a more complex underlying object
- Flyweight, reduces the cost of complex object models
- Proxy, provides a placeholder interface to an underlying object to control access, reduce cost, or reduce complexity
Behavior Design Patterns — concerned with algorithms and the assignment of responsibilities between objects. They include,
- Chain of Responsibility, delegates commands to a chain of processing objects.
- Command, creates objects which encapsulate actions and parameters.
- Interpreter, implements a specialized language.
- Iterator, accesses the elements of an object sequentially without exposing its underlying representation.
- Mediator, allows loose coupling between classes by being the only class that has detailed knowledge of their methods.
- Memento, provides the ability to restore an object to its previous state.
- Observer, is a publish/subscribe pattern which allows a number of observer objects to see an event.
- State, allows an object to alter its behavior when its internal state changes.
- Strategy, allows one of a family of algorithms to be selected on-the-fly at run-time.
- Template Method, defines the skeleton of an algorithm as an abstract class, allowing its subclasses to provide concrete behavior.
- Visitor, Separates an algorithm from an object structure by moving the hierarchy of methods into one object.
