This page describes the Adaptive Web framework (AWF) test system and the agent programming framework (Smiley) that supports its operation. 
Example test system statements are included.  To begin a test a test statement is loaded into Smiley while Smiley executes on the Perl interpreter. 
Part of Smiley's Perl code focused on setting up the infrastructure is included bellow. 
The setup includes:

• Loading the 'Meta file' specification,
  
• Initializing the Slipnet, and Workspaces and loading them
  
• So that the Coderack can be called. 

The Coderack, which is the focus of a separate page of the Perl frame then schedules and runs the codelets that are invoked by the test statement structures. 

This page introduces the many ways a complex modeling and coordination activity can be implemented using agent-based programming (see presentation). 

It describes how salient schematic alternative strings can be used to model a situation and make a decision under evolved control. 

It also introduces bottom up model codelets and complex techniques that are covered more fully on other pages. 

Constraints on the modeling process including requirements for timeliness, parallelism, synchronization and emergence of new models are discussed. 

Once a schematic sequence is selected by a group codelet or any additional type of modeling codelet the codelet will initiate an iterative cycle of detect, signal, match, deploy.  This allows the actions of a schematically selected sequence of model codelets to aggregate into a focused agent. 

A series of example signals sent by complex modeling codelets along with their associated operons and subgroup schematic sequences are included.  The signals are sent by the:

• merge streams spdca builder - The initiator of merge streams's pdca cycle (see schematic pdca).
  
• merge streams dcycip builder - The initiator of the planning phase of the merge streams's pdca cycle. 
  
• merge streams cassert builder - The initiator of the mergestreams's case resolved assert true conditional cascade.  It is a structurally enhanced codelet which activates at the end of the 'do' phase and signals the nucleus. 
  
• merge streams indsloc builder - The start locator codelet finds the application schemata's start operon
  
• merge streams shsloc builder - A start locator codelet that finds an alternative start operon in the application schematic operon
  
• merge streams rchpair builder - A receptor that detects and relays an application signal
  
• pdca ecycdop builder - A cyclin simulation codelet which signals entry to the 'do' phase of the pdca. 
  
• pdca acycchp builder - A cyclin simulation codelet which signals entry to the 'check' phase of the pdca. 
  
• pdca bcycacp builder - A cyclin simulation codelet which signals entry to the 'act' phase of the pdca. 
  

And the Slipnet configuration which activates the schematic subgroup sequence <mergestreams> <for> <case> <resolved> <assert> <true> is included. 

This page looks at how Smiley processes the statement, such as a test request, to ensure that each part of the statement is composed of groups. 
Smiley does this through the operation of a part codelet which indirectly sponsors the modeling of the parts of the statement. 
The modeling itself is performed by model codelets. 
The part codelet synchronizes with the completion of the modeling. 
The part evaluator's signal along with the associated operons and subgroup schematic sequences are included. 
The group models' Slipnet associations are included. 
The codelets and supporting functions are included. 

This page looks at how Smiley processes the statement, such as a test request, to ensure that each part of the statement is valid. 
Smiley does this through the operation of a part codelet which indirectly sponsors the modeling of the parts of the statement. 
The modeling itself is performed by model codelets. 
The part codelet synchronizes with the completion of the modeling. 
The part evaluator's signal along with the associated operons and subgroup schematic sequences are included. 
The group models' Slipnet associations are included. 
The codelets and supporting functions are included. 

This page looks at how Smiley processes the statement, such as a test request, to ensure that each part of the statement is constrained. 
Smiley does this through the operation of a part codelet which indirectly sponsors the modeling of the parts of the statement. 
The modeling itself is performed by model codelets. 
The part codelet synchronizes with the completion of the modeling. 
The part evaluator's signal along with the associated operons and subgroup schematic sequences are included. 
The group models' Slipnet associations are included. 
The codelets and supporting functions are included. 

This page looks at how Smiley processes the statement, such as a test request, to ensure that each part of the statement is integral. 
Smiley does this through the operation of a part codelet which initiates a program to assess the integrity of the parts. 
The modeling itself is performed by model codelets. 
The group models' Slipnet associations are included. 
The codelets and supporting functions are included. 

This page looks at how Smiley processes the statement, such as a test request, to ensure that the statement contains all required parts. 
Smiley does this through the operation of a statement codelet which indirectly sponsors the modeling of the whole statement. 
The modeling itself is performed by model codelets.  The group models' Slipnet associations are included.  The codelets and supporting functions are included. 

This page looks at Smiley's statement codelet. 
What the codelet's goals are. 
The three aspects of its operations are described. 
The indirect nature of its support for the applications programs and Shewhart cycles are illustrated. 
It describes how the application codelets are inhibited from action until the Statement codelet concludes the application's assertion or implementation statement is viable.  An application assertion statement is described and the schematic string included. 
The statement codelet Perl and its support infrastructure are included. 

This page describes the need for stated assumptions to support the setup and development of a Smiley agent-based application. 
As an example it discusses the use of assumptions about connecting external files to the agents. 
The Smiley codelets which process files and integrate them with the application agents using assumptions are introduced. 
The Slipnet associations relating the Workspace schematic strings to group completion scheduled codelets are included. 
The codelets and supporting functions are included. 

This page discusses how Smiley can support the start of the development phase of an agent-based application. 
Startup is an artificial operation not found in living systems.  But Smiley must do it and so we discuss an example of starting the development phase. 
With the Smiley infrastructure and the application integrated the application's development phase is reviewed.
The association of structural Workspaces for state representation is discussed. 
The aggregation of schematic associations of codelets defines a development agent.  At the application level it processes the application's schematic strings. 
The schematic nature of the data processed by the test application suggests the use of an indirect integration framework.  This supports the binding of codelets to the schematic data and detecting and responding to the control operons. 
An application polymerase complex emerges. 
The codelets and supporting functions are included. 

This page describes the specialized codelets that provide life-cycle and checkpoint capabilities for Smiley applications. 
The codelets implement a Shewhart cycle. 
The structural schematic nature of the cycle is described. 
Transcription factor codelets operate the phase change controls. 
How inhibitory agents are integrated into the cycle is described. 
An application agent with management and operational roles emerges. 
The codelets and supporting functions are included. 

This page describes a schematic system about abstracted 'animal' and 'plant' cells competing in a small world. 
The schematic cell was designed to focus in on the nature of mutation and the adjacent possible. 
THE IMPLEMENTATION IS INCOMPLETE AND ONGOING. 
The codelets and infrastructure are included. 

This page describes a schematic system about abstracted neurons operating in a circuit. 
The neuronal system was designed to focus in on the cellular nature of a schematically defined neuron. 
The goals include:

• Development of a system of cells, their differentiation and deployment into a neuron network. 
  
• Abstract receptor operation must support interactions of a network of neurons and attached cells. 

THE IMPLEMENTATION IS INCOMPLETE AND ONGOING. 
The codelets and infrastructure are included. 

This page discusses a complex adaptive system (CAS) implementation of a genetic algorithm (GA), Melanie Mitchell's robot-janitor built as a set of Copycat codelets integrated using agent-based programming.  The improvement in the operation of the robots over succeeding generations of applying the GA is graphed. 

The CAS that generated, and operated the robot is reviewed, including the implementation details and codelet operational program flow, and the challenges and limitations of this implementation. 

The schematic strings which make up the robot's genotype, as well as the signals which are sent to the nucleus of the robot's agents so that the agents can deploy the appropriate response strings (which activate codelets) are listed.  The Slipnet configuration required by the system to associate the schematic strings with programmatic forces (codelets) is also listed.  The codelets and supporting perl are also listed. 

In the conclusion the limitations of the robot-janitor abstraction in studying emergence and creative evolution are discussed and alternative experimental frameworks are proposed.  One such, the schematic cell is the subject of a separate page in this web frame. 

This page discusses how a Smiley based application the event processor test program's operational phase is structured. 
The goals of the event processor test application are described. 
The implementation strategy is outlined. 
Synchronization of Smiley setup completion and operation phase initiation is discussed. 
The association of structural Workspaces for state representation is discussed. 
An application specific codelet merge streams assert responds to the nature of the assertion.  It does not have an emergent structure.  Instead it reflects software engineering practice.  It includes:

• Merge stream case specific
  
• Modeling with sub-programs
  
• Resolving of case
  
• Non case assertion
  

The operation is setup, inhibited, initiated, and managed by iterative phase check-pointing provided by Smiley codelets. 
Schematic synchronization of parallel codelet cascades is performed structurally. 
The assert merge operon cascade is included. 
The Slipnet concept network for merge streams is included. 
The codelets and supporting functions are included. 

This page describes the inhibitor framework provided by the adaptive web framework's (AWF) Smiley agent programming infrastructure. 
Two mechanisms are provided:

1. Uncompetitive inhibition of group completion. 
   
2. Uncompetitive inhibition of transcription factors.  

In both cases the inhibitors provide a restriction process. 
The Slipnet inhibitor descriptions are included. 
The codelets and supporting infrastructure are included. 

This page discusses how the adaptive web framework (AWF) Smiley supports agent-based application's leverage of infrastucture amplification. 
A number of Smiley's amplification strategies are reviewed:

• Locality
  
• Enzyme like catalysis
  
• Efficient routing through the Slipnet 
• Independence and equivalence of transactional codelets 
• Structurally enhanced state based amplification
  

The architecture of Smiley's grab amplification is discussed.  This includes:

• Sub program grab amplification
• Deployment infrastructure cooperation in grab amplification
• Generalizing the grab architecture 

The mechanisms Smiley uses to limit the impact of amplification, such as crowding out and processor starvation, on other codelets operations are discussed. 
The codelets and infrastructure are included. 

This page describes the 'merge streams' application's codelet implementation of a 'case' architecture based on the adaptive web framework's (AWF) Smiley histone infrastructure. 
The application scenario for processing case statements is described. 
It involves a schematic binder complex for resolving the case statements. 
A case tagged application schemata. 
The Smiley infrastructure that supports the case architecture is reviewed. 
The Workspace schematic strings that implement the operon supporting histone like case control are included. 
The Slipnet concept network for the 'merge streams' application's histone like case control is included. 
The codelets and supporting functions are included. 

This page describes the adaptive web framework (AWF) Smiley agent progamming infrastructure's codelet based Copycat grouping operation. 
The requirements needed for a group to complete are described. 
The association of group completion with a Slipnet defined operon is described.  Either actions or signals result from the association. 
How a generated signal is transported to the nucleus of the cell and matched with an operon is described. 
A match with an operon can result in deployment of a schematic string to the original Workspace.  But eventually the deployed string will be destroyed. 
Smiley infrastructure amplification of the group completion operation is introduced.  This includes facilities to inhibit crowding out of offspring. 
A test file awfart04 is included. 
The group codelet and supporting functions are included. 

This page describes the Smiley infrastructure and codelets that instantiate the epiphenomena defined in the Meta file and Slipnet. 
Infrastructure sensors are introduced. 
The role of phenomena in shaping the environment is discussed. 
The focusing of forces by phenomena in Smiley is discussed. 
The Meta file association of case keywords with phenomena is included. 
The codelets and supporting functions are included. 

This page describes the Copycat Slipnet. 
The goal of the Slipnet is reviewed. 
Smiley's specialized use of the Slipnet is introduced. 
The initial Slipnet network used by the 'Merge Streams' and 'Virtual Robot' agent-based applications is setup in initchemistry and is included. 
The Slipnet infrastructure and initialization functions are included. 

This page describes the Copycat Workspace. 
The specialized use of the Workspace by the adaptive web framework's (AWF) Smiley is discussed. 
How text and XML are imported into the Smiley Workspace is described. 
Telomeric aging of schematic structures is introduced. 
The internal data structure used to represent the state of each workspace object is included. 
The Workspace infrastructure functions are included. 

This page describes the Copycat Coderack. 
The details of the codelet architecture are described. 
The specialized use of the Coderack by the adaptive web framework's (AWF) Smiley is discussed. 
The codelet scheduling mechanism is discussed. 
A variety of Smiley extensions to the Coderack are reviewed. 
The Coderack infrastructure functions are included. 

This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.

This page discusses how Smiley provides deployment guarantees to its agent-based applications. 
Smiley's transaction services are reviewed. 
The complex interactions of codelets participating in a deployment cascade are discussed including: 

• The implementation of schematic switches. 
• The cooperative use of goal suppression.  
• Evaluator codelets promotion of other siblings. 
  

Challenges of initiation of a cascade are discussed. 
Tools to associate transaction protection to an operon deployed codelet are described. 
Special support for sub-program codelets is described.  Completion of transactional sub-programs presents special challenges.  Priority and synchronization support includes:

• Delaying the operaton of the cascade sponsor. 
  
• Delaying the notgcompleting cascade participant. 
  
• Waiting for completion of parallel operations with the wait and relay service.  

The need to sustain resource pools is reviewed. 
The use of signals to coordinate siblings is described. 
The structural binding operon for the wait and relay service is included. 
The codelets and supporting functions are included.

This page describes the Smiley infrastructure that supports the associative binding of schematic strings to codelets defined in the Meta file and Slipnet. 
The infrastructure supporting the associations is introduced. 
The role of Jeff Hawkins neocortical attributes is discussed. 
Relevant Slipnet configurations are included. 
The codelets and supporting functions are included. 

This page describes the Smiley data structures.   
Key structures are described each of which is based on a list structure represented with an array and add and free subroutines.