1.3.1 The Design Stack

The Monod computational approach is somewhat more complex than, say, a Turing machine. However, it is fairly easy to describe as the top of a hierarchy of structures. We introduce in the next section this hierarchy. Happily, the implementation of the Monod Cell model has been made to closely mirror this abstract design stack. Hence the uses of the hierarchy are twofold: to reduce the explanatory load on the reader and to provide a good framework for the implementation.

The stack can be seen in the following image, where each layer uses and is more complex than the one below it.

The bottom three layers are useful and fairly generic design patterns. Above them, the Cytoplasm model contains the complete computational model, properly speaking. The Monod Cell adds some practical gewgaws. Finally, the Monod Culture is a framework for applying evolutionary algorithms to Monod Cells. We present a quick overview of the various layers. More details for each layer may be found in dedicated sections in further chapters.

The Hive

The Hive is a design pattern that we use to abstract away the computational difficulty of maintaining a multitude of independent execution threads. A Hive contains residents, which are simply programs wrapped in an object. The Hive can be seen as a fairly simple scheduler for the residents, which can be assimilated to threads. Many considerations have led to the adoption of the Hive design pattern rather than using the underlying threading model of the Operating System (OS). The Hive is described in The Hive Design Pattern.

The Swarm

The Swarm is another design pattern built on top of the Hive and introduces formalized interactions between the residents. Residents of a swarm expose certain projections, and these projections are tagged with markers. Markers have variable affinities for one another, and may trigger bindings between the projections that are propagated to the control flow of resident and may affect its behavior. Bound projections may also be released, and markers altered.

Binding is the most fundamental principle driving Monod. It is introduced very early, and further refined in the higher layers of the design stack.

Details are given in The Swarm Design Pattern.

The Incubator

An Incubator is a Swarm where the residents are of two kinds: ligands and processing units. Ligands are akin to simple passive text strings. Processing units can be arbitrarily complex, but their projections operate in a fashion similar to text strings and regular expressions, binding with each other and with ligands. Furthermore, processing units (procunits, for short) may alter the ligands by changing the string, cutting them up, binding them, etc.

An analogy can be made by imagining a soup of Turing machines, with the machines binding, releasing and reassembling the tapes floating in the soup according to their individual programs and to their binding markers. Another analogy is with biological cells, identifying processing units with proteins and ligands with DNA and/or RNA strings.

The Incubator is described in more details in The Incubator Design Pattern, along with this analogy.

The Cytoplasm

The Cytoplasm model builds on the Incubator design pattern by introducing several concepts inspired by cell microbiology. It is not called a design pattern anymore because of its lack of generality. The most significant difference introduced in the cytoplasm is that processing units — now called proteins — are made out of a finite set of domains, each of which performs a specific action, such as calculating a logical function or altering a ligand based on a logical input. Domains must be assembled, lego-like, to create valid, fully-functional proteins, and different proteins may be creating by different combinations of the same domains.

Other innovations also appear in the Cytoplasm. For instance:

• some protein operations consume energy;
• certain ligand patterns are identified as poisonous and others as nutrients;
• all residents (proteins and ligands) have densities that vary along a geometry of the cell;
• bindings between and across proteins and ligands are subject to a stochastic release mechanism.

The Cytoplasm incorporates all the details of the computational model of Monod. It is described in detail in The Cytoplasm.

The Monod Cell

The Monod Cell complements the Cytoplasm with a nucleus to coordinate protein synthesis and introduce a compilation step from a genetic representation of the proteins to the proteins themselves (akin to the transcription/translation process that takes place in the eukaryotic cell); and a membrane to coordinate ligand transport to and from outside the cell. Many hooks are also added to be able to control and monitor processing within the cell. The Monod Cell is essentially a Cytoplasm equipped with a practical “interface” that can be used by an appropriately design harness to run experiments. It is described in The Monod Cell.

The Monod Culture

The Monod Culture is the culmination of the project. One of the original inspirations for Monod is to provide a convenient breeding ground for programs. A Monod Culture is a glorified harness that employs evolutionary algorithms to alter the genomes of Monod Cells according to various programmable policies and, hopefully, find something, er, better. The Monod Culture framework is described in Monod Cultures.

Much of the interesting work envisioned consists in running experiments with different Monod Cultures. Some of these results are described in Results and Future Projects, and alluded to in Overview of the Results below.