The power of patterns in the design of object-oriented software is widely acknowledged in the software development community. This page demonstrates the power of the patterns approach in developing Complex Systems software. The aim is to provoke appreciation of the power of using patterns in a software design setting, with application to other Complex Systems modeling tasks (e.g., algorithm choice, population paradigm, etc.) being readily apparent.

Problem: To understand the behaviour of Boolean network models generated randomly, by design, and from an abstract genome model.

Proposed Solution: Use a collection of appropriate Complex Systems visualization patterns to understand the structure, dynamics and state space of the networks. Ideally, each visualization will reflect the current state of the model, and allow changes to the model's state through its unique view of the system. Network Diagram, Activation Diagram, and Hypercube Diagram are Complex Systems visualization patterns that offer views into the structure, dynamics and state space of the model respectively.

Designing the Solution

A commonly-known software engineering solution for this scenario is the Model-View-Controller (MVC) set of classes. The Model is the main object, the View presents the relevant Model information to the user, and the Controller facilitates user input. The MVC design can be defined in terms of more general software design patterns. Section 1.2 of [1] (page 4) offers the Observer, Composite, and Strategy design patterns as ways of implementing the relationships in MVC.

To implement our proposed solution, we chose the Strategy and Observer patterns.

The Strategy Pattern
For details of the Strategy pattern, see [1] page 315.

The Strategy pattern encapsulates related algorithms, allowing them to be interchangeable without altering the surrounding code, and allowing future algorithms to be easily incorporated. Tailoring the Strategy pattern to fit our scenario, the design of the model-generating algorithms are as follows:

The Observer Pattern
For details of the Observer pattern, see [1] page 293./p>

The Observer pattern defines relationships between objects so that consistency is maintained between them. The primary objects in this pattern are the subject and the observer, where a subject can have any number of observers. Observers are notified whenever the subject's state changes, and subsequently update themselves by querying the subject's state. This fits nicely with our proposed solution, where we want a number of visualizations to be synchronized with a single network model, and may wish to include new visualizations in the future without changing existing code.

Tailoring the Observer pattern to fit our scenario, the design of Model and Visualizations is as follows:

Tying it all together

For our final design, an interface will initially presented that allows the user to choose a Strategy to generate a BooleanModel. Once the model is created, a ModelUI is created, and attached to the Model. The ModelUI allows the visualizations NetworkObserver, ActivationObserver, and Hypercube Observer to be attached to its model. Each of these Observers allows user input to request the model to change the state of a particular network node at a particular time, which causes all Observers to be notified of the change.

Solution Implementation

The solution is written in C#, and requires .NET 1.1 and DirectX 9.0c (with the October 2005 managed extensions). If you have these prerequisites, you just need the smaller installer (222KB). Otherwise, you will need to download the larger installer (34.0MB), which includes the dependencies.

The prototype is still in development (i.e., not all exception handling is implemented, etc.), so email for the latest version of the source code or to ask questions / offer suggestions.







References

[1] Gamma, E., Helm, R., Johnson, R., and Vlissides, J. (1995). Design Patterns: Elements of Reusable Object-Oriented Software. Addison Wesley.