Data As Antigen, or The Simpleton Cascade
KnownSpace uses ideas stolen from existing adaptive systems to build flexible software. Many organic systems like the cell, the nervous system, the immune system, an ant colony, a beehive, a flock of birds, and so on, share many characteristics with constructed systems like an economy, a city, a continential transportation system, the internet, and so forth, and with organic processes like neurogenesis, embryogenesis, evolution, and ecological dynamics.
With all such systems the first rule is: no one is in charge. The second rule is: there is never enough time. The third rule is: no action is completely reliable. These sound like terrible engineering limitations, but they force the systems into configurations that can survive in many regimens. They are what make the systems much more robust and flexible than most of our present-day computational systems.
Here are some common attributes of existing adaptive systems:
There are multiple independent actors.
Actors compete for limited resources.
Actors have finite lifetimes and limited resources (consequently, since the overall problem is complex, no actor is complex enough to solve the whole problem).
Actors can have varying behaviors (either via variable internal structures or variable environments, or both).
Actors may alter their behavior based on the behavior of other actors (so in some sense they can "communicate").
Actors can make mistakes.
No actor controls all other actors.
No actor is indispensible.
Some actors are redundant.
Some actors should generate and test falsifiable hypotheses about their environment.
Actors can maintain a possibly inconsistent and incomplete yet largely common worldview but there is pressure to increase consistency, or bound error, or both.
In the cell, the "actors" are enzymes, on the internet they are internet message processors, in evolution they are genes, in an ant colony they are ants, for neurogenesis they are individual nerve cells, in an economy they are individual economic agents (people, corporations, and governments), and so on.
In KnownSpace, threaded "actors" are simpletons. The data those simpletons work on are entities. The structure of those entities are described by constraints. Entities are kept in pools. The model is of an enzyme (simpleton) roaming through a cell (pool) and trying to bind to whatever random molecules (entities) it bumps into but only binding when the molecule fits its enzymatic binding site (constraint). Once the simpleton binds to an entity, it "tastes" the entity and attaches or detaches various markers (which are themselves entities) to or from the entity in an attempt to decide which other entiies this new molecule is most similar to.
KnownSpace looks at each new, or newly altered, entity as if it were an invading organism. Hundreds of simpletons taste the organism for various properties and attach markers depending on the organism's structure. By attaching markers the system is conceptually moving the invader around inside a space that ultimately leaves the organism in several positions, each of which is the system's best estimate of what other organisms this new, or newly changed, organism is most like.
All earlier invaders have already been formed into fluid self-nonself clusters and it is the job of the intake cascade to place the new invader in as many of those clusters as it seems to be strongly related to. Any invader can appear in multiple such clusters, and the constitution of any cluster can change depending on the new organism's "taste". Clusters also accrete around entities that KnownSpace's user visits often, so the internal database adaptively changes as the user behaves naturally.
KnownSpace does not limit the kinds of simpletons a programmer can introduce, nor does it limit the number or kind of attributes that those simpletons can attach to entities, nor does it limit the computations that can taken place on recognition of some collection of attributes and values. Programmers are free to write arbitrary simpletons that add arbitrary attributes and do arbitrary computations on arbitrary entities whose attributes match arbitrary constraints and whose state changes arbitrarily.
For example, KnownSpace presently does not do detailed analysis of images, video, audio, executables, or anything besides text, but developers are free to add such functionality. To add such functionality, programmers do not need to know where to put it and how it interacts with other attributes. As new functionality proves useful to a wide range of users it can be incorporated as default behaviour in future versions, so the system as a whole can bootstrap up to be arbitrarily complex.