- Identify and separate the variant and the invariant behaviors.
- Encapsulate the invariant behaviors into a system of classes.
- Add "hooks" to this class to define communication protocols with other classes.
- Encapsulate the variant behaviors into a union of classes that comply with the above protocols.
The result is a flexible system of co-operating objects that is not only reusable and extensible, but also easy to understand and maintain.
Let us illustrate the above process by applying it to the design of the immutable list structure and its algorithms.
- Here, the invariant is the intrinsic and primitive behavior of the list structure, IList, and the variants are the multitude of extrinsic and non-primitive algorithms that
manipulate it, IListAlgo. The recursive list structure is implemented using the composite design pattern and encapsulated with a minimal and complete set of primitive structural
operations: getFirst() and getRest(). The hook method Object execute (IListAlgo ago, Object inp) defines the protocols for operat¬ing on the list structure. The
hook works as if a IList announces to the outside world the following protocol: If you want me to execute your algorithm, encapsulate it into an object of type IListAlgo, hand it to
me together with its inp object as parameters for my execute(). I will send your algorithm object the appropriate message for it to perform its task, and return you the result.
- emptyCase(...) should be the part of the algorithm that deals with the case where I am empty.
- nonEmptyCase(...) should be the part of the algorithm that deals with the case where I am not empty."
- IListAlgo and all of its concrete implementations forms a union of algorithms classes that can be sent to the list structure for execution.
The above design is nothing but a special case of the Visitor Pattern. The interface IList is called the host and its method execute() is called a "hook" to the IListAlgovisitors. Via polymorphism, IList knows exactly what method to call on the specific IListAlgo visitor. This design turns the list structure into a (miniature) framework where control is inverted: one hands an algorithm to the structure to be executed instead of handing a structure to an algorithm to perform a computation. Since an IListAlgo only interacts with the list on which it operates via the list's public interface, the list structure is capable of carrying out any conforming algorithm, past, present, or future. This is how reusability and extensibility is achieved.