The individual chapters in the body of the thesis discuss work that is related to the separate themes of this thesis. Here, we discuss a few systems that are related to more than one theme: that is, some other environments that are designed for novices, strive for a lively feel, and contain programming capabilities that are in some sense agent-like.
KidSim (Cypher and Smith 1995) is a programming environment designed to allow children to create graphic simulations, using a rule-based approach to programming. KidSim has a colorful interface which permits direct manipulation of a variety of objects (i.e. agents, costumes, and rules). In KidSim, an agent is equivalent to what LiveWorld calls actors or creatures (and what KidSim calls a rule, we would call an agent). Each agent has a set of rules and a set of properties (slots) that are accessible through a graphic editor. While you cannot create entirely new kinds of objects as in LiveWorld, agents once created can be used as a basis for creating more agents of the same type. KidSim originally had the ability to support a deep inheritance hierarchy as does LiveWorld, but this feature was eliminated because it was judged to be too confusing.
KidSim avoids text-based programming languages, instead using a form of programming by demonstration to generate graphic rewrite rules, which can then be modified in an editor. The world of KidSim is based on a grid of cells which can be occupied by various graphic objects. The rewrite rules thus operate on patterns of cell occupancy. Each agent has a set of rules which can be arranged in order of priority.
KidSim is based on a simple idea which makes it easy to learn, yet permits creating a wide range of simulations. However, the rewrite rule approach makes some things difficult. For instance, if an object is to both move and deal with obstacles in its path, it must be given separate rule sets for each of the four possible directions of movement. More fundamentally, pure rule-based systems have difficulties dealing with sequential action and control in general. They also do not lend themselves to building powerful abstractions in the way that procedural languages do, and thus are limited in their ability to deal with complexity.
Agentsheets (Repenning 1993) is not an end-user environment itself, but a tool for creating a variety of domain-specific graphical construction systems. Each such system includes a set of parts (agents) which the end-user can arrange on gridded field (the agentsheet). The end-user cannot construct the agents themselves; instead these are desigened and built by a separate class of expert designers. Agents in this system are autonomous objects that contain sensors, effectors, behavior, state, and a graphical depiction. Agents can move from cell to cell, although not all of the visual languages supported by the system make use of this feature. They can also sense and communicate with their neighbors. Their behavior is specified by a Lisp-embedded language called AgenTalk. (In fact there are other ways to program agents, such as specifying graphical rewrite rules as in KidSim, but most of the system's flexibility comes from the AgenTalk level).
This simple scheme supports a wide variety of metaphors. In flow-based languages, agents are static but change their state based on their neighbor, and so can simulate electrical circuits or fluid flow. In anthropomorphic metaphors, the agents represent creatures that move around in the world and interact with one another, and can support behavioral simulations or certain types of videogames. Limited programming can be done at the end-user level with languages that provide agents with control-flow metaphors (one example is a visual language for designing the flow of automatic phone answering services).
Agentsheets has been shown to be a very flexible system, but its full range is only accessible to experts. There is a sharp division between the end user, who can only manipulate a set of pre-constructed objects, and the expert designer who can build new kinds of objects and new languages. This is in contrast to LiveWorld's goal of making as much of the inner workings of the system accessible to the end-user as possible.
ToonTalk is the most unusual of the environments described here, and perhaps the most powerful. Its interface is entirely visual and highly animated, and its underlying computational model is a version of Concurrent Constraint Programming (CCP) (Saraswat 1993), an advanced programming paradigm descended from logic programming. The system provides an elaborate mapping from the constructs of CCP to animated objects. For example, methods are shown as robots; their programs exist in thought bubbles; a communication is a bird flying out of its nest and back; terminating an agent is represented with an exploding bomb. Just as Logo was designed as a child-friendly version of Lisp, ToonTalk is a version of CCP in which mathematical formalisms are replaced by animated characters.
ToonTalk is extremely lively, sometimes to the point of causing confusion. The underlying language is inherently concurrent, and so is the environment. Graphic objects or sprites form the basis of user worlds. Games and simulations on the order of Pong can be readily constructed. The programming style is a form of programming by example. The user performs a sequence of concrete actions using a set of tools, which can be recorded into a robot (method). The user can then make the resulting programs more abstract by explicitly removing constants from them.
Program execution is animated, and since there is no textual code other than the graphic actors, Kahn is justified in claiming that the programs themselves are in the form of animations, not merely illustrated by them. Whether this is really easier to understand than a textual description is debatable, however. While the idiom of animated video characters might be more immediately accessible to a child, it is hard to follow a complex set of moving objects. Static descriptions of programs and their activity (such as storyboards; see section 5.3.5) have the advantage of standing still so you can read them!
Another problem is that some of these metaphors seemed strained--for instance, agents and objects are represented as houses, presumably because they contain an assortment of other objects, while an entire computation system is a city. However, when this metaphor is extended via recursion it leads to expectation violations such as objects that have within them whole cities. In other cases, the metaphor is apt but not extensible: for instance, a scale is used to indicate a comparison between numbers, but this metaphor does not readily extend to other predicates.
CCP comes from an essentially declarative logic programming tradition, which ordinarily would make it an awkward tool for programming dynamic systems. Nevertheless ToonTalk manages to represent action and perception using extensions to the basic model in the form of sensors and "remote control variables" which cause side effects. Because of these, ToonTalk is quite capable of building animate systems such as videogames despite its declarative heritage.