Composite patterns, such a the Bureaucracy pattern, are patterns built by the composition of other “smaller” patterns. However even usual design patterns can be considered composite patterns made of smaller subpatterns.
The goal is therefore to find out which are the main subpatterns that enable to reconstruct as many design patterns as possible.
From an early analysis I believe that four subpatterns form the foundation of many GoF design patterns:
- Type Hierarchy and its variants (interface, abstract class, non final class…)
- Type Set, a set of types with no particular relationship between them
- Delegation and its variants (one-to-one, one-to-many)
- Allocation (creation of instances) and its variants
To validate this proposal, I have coded a small experiment to generate every combination of two subpatterns out of (1) and (2) plus one relationship between them out of (3) and (4), or every combination of one subpattern out of (1) and (2) plus a relationship of (3) and (4) to either itself, or in the case of (1), between a super type and a subtype or the other way round.
For each generated combination I have automatically generated its corresponding class diagram, and grouped them together into one SVG document, converted into PDF using Inkscape. The resulting picture is available here, and you can see a partial preview below:
The interesting finding is that this simple combinatorial method re-discovers 11 well-known design patterns (in the reading order of the picture):
- Template Method (delegation to self, expecting a subtype to provide the service)
- Composite (Considering a one-to-many delegation) or Decorator / Proxy (one-to-one delegation)
- Prototype (creates instance of this type)
- Bridge (one Abstraction hierarchy delegates to another Implementor hierarchy)
- Abstract Factory (one Factory hierarchy creates instances of another (or several others) Products hierarchy)
- … skip 4 next …
- Strategy or State or Builder (some client delegates to some hierarchy)
Note that there are several cases where we could see the Factory Method, Adapter or Facade patterns. This would lead to some 13 design patterns out of the 23 in the GoF book.
It is obvious anyway that the four subpatterns used here are not enough to rebuild the full set of the 23 design patterns. The Command pattern is unique in its use of a separate invoker, and the Chain of Responsibility is clearly about how handlers self-assign a given task without any centralized management. In these two examples however, the unique characteristics is not in their structure but rather in their dynamics. Sequence diagrams would be much more relevant to convey that kind of information.
The full test runs in one go in a fraction of second. The source code is available here: patternitygraphic_src, the code of the experiment is in CombinationTest.
EDIT: the plain SVG file that was generated is also available here for download: