From the CD-ROM "Concepts and strategies"

Biological system design

by Peter Small

Modular route to complexity

The ideas for creating stigmergic systems for the Web originated during the writing of the two books Lingo Sorcery and Magical A-Life Avatars (written for multimedia designers who wanted to learn how to use lists and objects).

The central theme of these books was to show how object oriented programming techniques can be used to develop products that went beyond a developer's imagination. This apparent paradox is resolved by using an evolutionary design strategy; creating modules (objects) and adding them - one at a time - to a growing interactive system. Such a strategy allows a design to emerge gradually out of a growing structure.

It was found that designing systems in this way, resulted in productions that went not only beyond the designer's imagination, but also beyond the designer's ability to comprehend the growing complexity that begins to emerge.

It soon became clear that we were dealing with something far more exciting than mere computer programming; we were entering the esoteric world of chaos and complexity theory. This is the domain of biological systems, which, over millions of years of evolution, have learned to harness complexity to produce highly sophisticated systems of self-organization.

Amazingly, this did not lead to the design of large, complicated programs. In fact, it was quite the reverse. By copying biological systems we discovered ingenious mechanisms that could be emulated using elegantly simple programs. Rather than having to specifically design order and organization, systems could be designed to order and organize themselves.


The design of these self-organizing systems is based upon creating objects that have memories and can perform functions. These objects are then arranged to interact with each other.

This involves a way of thinking that is totally different from the way people usually think about computer programs (i.e., algorithms and database type structures with the accent on order and control)...

... it is about thinking like molecular biologists, when they think about the structure and functions of cells and living organisms.

Understanding objects

The key to getting into a biological way of thinking is to have a visual concept of what is meant by an object.

It can be defined as an entity that:

has a memory,

can perform functions

can receive and send messages and information.

Figure 1 illustrates the essential elements of an object's structure. Such entities can be created quite easily with most computer programming languages.


Figure 1 - Basic structure of an object

Objects are created by an object building program

Objects are not created in isolation. They are only useful if there are several objects, which can interact with each other to produce the complexity necessary for the system to exhibit characteristics of self-organization and control.

A computer programmer doesn't build these objects. Instead, the programmer designs a program to build the objects. The objects created by this program will be given different memories and different functions according to information fed into the object creator program.

Figure 2 illustrates the basic arrangement.


Figure 2 - Object oriented system design is about creating programs that build objects. Not about creating the objects themselves

Objects interact with each other

An object building program is designed to produce sets of objects that have the ability to communicate with each other - i.e., to call on each other's functions and read from each other's memories.

This results in a system of objects that collectively will be able to perform the functions of all and benefit from the combined information contained in all of their memories.

Although each individual object is basically a simple structure, the combined effect produces an entity with a complexity that is far higher than the sum of the parts.


Figure 3 - Although each object is a relatively simple structure, when they act collectively, they can appear to be a single object capable of complex activity and behavior

Emergent complexity from simple objects

It may seem weird, that a program designed to create only simple objects can produce a system that exhibits complex patterns of behavior that are not explicitly designed into it.

Yet, it is a fact - in situations where objects are able to communicate and combine functions and memories - self generated behaviors and organization can emerge spontaneously. These phenomena are known as the 'emergent properties' of the system.

In this way, a programs designed to produce only simple objects can effectively become a program that produces objects of considerable complexity. This is illustrated in figure 4.


Figure 4 - A program designed to create simple objects is effectively a program that is creating complex objects

Complex objects can also communicate

Different groups of interacting objects can be created; each of which can act as a separate complex object.

If these groups are then allowed to interact with each other, an even more complex system will be created: as a system of interacting complex objects


Figure 5 - Even more complexity can emerge, if a system of interacting complex objects is created

Organic system created out of simple objects

These diagrams show how a program designed to produce only basic objects, (which each have structures to contain a memory and a few simple functions) can effectively manifest a system of great emergent complexity.

In this way, a relatively simple program can build a highly complex organic structure.

More importantly, the program would be capable of continuously reproducing these complex organic structures. In other words, capable of creating an ongoing series of generations: emulating the reproduction


Figure 6 - A program capable of building complex objects can emulate biological systems by repeatedly creating new generations

Creating a new generation

Being able to create different versions of a system at different times gives rise to the possibility of creating a series of systems, each of which is reflecting the information available at the time it is created. In biological terms, this would be like creating a series of new generations.

By giving the object building program a memory of the most recent system it has created, it is possible to pass information from one generation to another. This is achieved by designing the program that builds each new generation as a complex system itself (made up of many different code modules that act together to build the new generation system).

In this way, a series of new systems can be continuously created which evolve and adapt to a changing external environment (see figure 7).

This is the essence of a stigmergic system.


Figure 7 - New generations of a complex system can be built by combining the information passed from previous generations with current updating information

Humans are a product of complex objects

The most well known example of a system of interacting complex objects is a human person.

This starts out, after conception, as no more than a long string of DNA. This contains objects in the form of genes. These gene objects interact by passing messages to each other in the form of protein molecules.

This interaction between the gene objects causes new objects, in the form of cells, to be created. Each cell has an individual memory and a unique set of functions it can perform, even though all cells are made from the same string of DNA.

The cells, acting as complex objects, interact and combine with each other to produce even more complex objects in the form of organs. These organs combine and react with each other to produce what we observe as a human person (see figure 8).

The important point to grasp here is how much complexity can emerge from such little initial programming. The string of DNA (the biological program) is only 3 billion bits long: that's about 750 megabytes, which is only slightly more than the capacity of a CD-ROM.

In fact, the genes (the basic objects that represent the programming) account for only a small fraction of the DNA (the rest is mostly accumulated "junk"). This means that the complexity incorporated into the human form, including the functioning of the brain and central nervous system, has emerged from no more than about 30 megabytes of code.

It is this ability of self-organizing complexity to emerge out a relatively small amout of basic programming that lies at the heart of stigmergic systems.


Figure 8 - Humans are the most well known and best studied examples of self constructing systems of complex objects

Structure of a stigmergic system

Stigmergic systems function in a very similar way to organic systems (such as the previous example of a human person).

The initial programming is relatively small and uncomplicated. Small modules of code interact and combine to create objects that represent people and questions. The people objects have a memory that contains a particular person's answers to a questionnaire. The question objects have memories that contain all the answers that have been given to the particular question it represents.

These objects organize into groupings according to the specialty interests of the people filling in the questionnaires. These groupings each become a new type of complex object called a 'subject area'.

The subject area objects interact to create a new complex object, which provides a hierarchical navigation structure, linking the subject areas. This increasingly complex system is shown in figure 10.

The point to note here is that the organization of the objects (the questionnaire and question objects), as viewed by the user , is not specifically programmed in. The organization emerges as a result of the interactions of the simple objects created in the master program.

This means that as new or changed questionnaire and question objects are added or removed from the system, it is not necessary to reprogram the system to make the changes. The system can simply rebuild itself to incorporate the changes in a new configuration.

In other words, the system can constantly build new generation of itself, to adjust for any changes being made.


Figure 9 - A stigmergic system is a self constructing system of complex objects, which completes the construction by building a Web site

The functioning system

The functioning system is shown in figure 10. The main input is in the form of new of modified questionnaires. These the system turns into objects that are put into appropriate subject areas where they interact with the question objects to tell these objects what answers have been given to particular questions.

The system continually rebuilds itself to include any changes or new additions.

Simple rules are incorporated in the system to allow it to call for human help where needed. This might be where the system needs human intelligence to decide upon opening up a subject area.

As the system completely rebuilds from the questionnaires at every new generation, feed back from users can be used to censure questionnaires before they become included in subsequent generations. This makes it very easy to remove rogue questionnaires or update for error or accuracy, without having to resort to changing any part of the system itself.

The only part of the system that has to changed with reprogramming is the master program. This is broken up into small, independent objects (code modules) that can be worked on independently. This allows the system to be incrementally changed in response to user feedback and to include improvements or new features.


Figure 10 - The master program is continually regenerating the system and the Web site: completely rebuilding the whole structure from scratch to include any new information and modifications