A graphical environment that implements visual programming techniques based on autonomous agents is presented. The model consists of active entities called agents, and passive entities such as behaviours, trajectories, actions, and conditions. The agents have a rule based behaviour defined as a spatial and temporal evolution. A consistent set of agent structures, actions and rule types is highlighted to support a general oriented visual programming. The model concerns on the notion of trajectory and topological information used in a cooperative evolution to control applications which are based on real time processes synchronization, data flow diagrams, graphical animation, metaphorical user interface, visual programming, multimedia and artificial intelligence techniques.
user interfaces, multiagents, visual programming, direct manipulation, rule based behaviour.
Intelligent agent technology seems to be a good solution for the development of complex distributed systems, visual programming environments, courseware authoring, intelligent graphical user interfaces [3], virtual reality and scientific visualization. Intelligent agents [6] are autonomous mobile entities having associated behaviours, and able to interact with other agents and to react to their environment.
LiveWorld [10] is a graphical environment designed to support a style of programming based on rule-like agents that allow objects to be responsive to their environment. Behavioural rules are concrete and accessible graphic objects. ALIVE (Artificial Life Interactive Video Environment) [7] is a virtual environment which allows wireless full-body interaction between a human participant and a virtual world which is inhabited by animated autonomous agents. One notable project is Julia [8], an autonomous agent that lives in a text based MUSE system (Multi-User Simulation Environment). Julia's behavioural repertoire includes moving around in and mapping of the environment. Julia has moods, feelings and attitudes towards players and a good memory.
Using animation in user interfaces and so called active objects [2, 4] the application program has a user oriented control and is more closed to the natural manner of manipulation on the application entities.
There are also tools for describing systems of cooperating processes. The project MADE (Multimedia Application Development Environment) [1] defines and implements a portable object-oriented development environment for multimedia applications.
The work reported here attempts to estimate the convenience of multi-agent based interactive applications. It proposes a multi-agent based environment which provides for the implementation of the graphical user interfaces. The work is founded upon the AGM (Active Agents Model) presented in [3] (where the model is called the AOM). The AGM model has been developed as an experimental version at the University of Cluj-Napoca (Borland C++ version), and an extended version is being developed at the Rutherford Appleton Laboratory, UK (Visual C++, multi-threads version). The key principles of the AOM model are:
- provision of visual and metaphorical techniques for programming paradigms;
- a flexible model that allows visual programming, and definition of agent behaviours by direct manipulation;
- a consistent set of entities that support active and dynamic evolution;
- intelligent cooperation between agents in order to provide a flexible and adaptive user interface;
- a simple and consistent structure for active objects, variables, behaviours, trajectories, and so on, to support dynamic functionality, unique identification, interactive applications, and concurrent evolution;
- a set of light-weight processes that perform behaviours, delegated actions, animated images and interactions;
- flexible, dynamic and interactive behaviour of active entities in order to provide for both event oriented and action based functionality of the model;
- consistent modelling of notions such as: behaviours, trajectories, trajectory positions, rules, conditions, expressions, actions, operations, action parameters;
- consistent topological and graphical information that provides a direct manipulation paradigm on model entities and abstract notions.
The model is a system using the prototype-based inheritance. Prototype-based object languages [5] are an alternative to the class-based object schemes used in more traditional OOP languages. A prototype-based system has no classes or special class objects. In the active model any entity may serve as a prototype for other entities. One of the most important consequence is a behaviour pattern may be inherited by an instance and executed for a concrete agent.
AGM embodies two types of entities: active and passive [3]. Active entities are agents: active agents and variables. The passive entities are behaviours, processors, trajectories, explicit trajectory positions, rules, expressions, and actions. An AGM model consists of a networking AGM agents.
An active agent has an evolution described by an attached behaviour. The evolution of an agent progresses on a trajectory in some space, performing a defined sequence of rules at designated points on the trajectory. A variable has a different evolution. A variable has an attached expression that supplies its value. The expression is evaluated in a static or dynamic manner. A static variable evaluates its expression only when some agent inquires the variable's value. The dynamic variable evaluates its expression autonomously, at a programmable rate.
Unlike other systems such as Garnet or Peridot [9], and LiveWorld [10] where agent's attributes are slots to functions (e.g. encoded in Lisp), the active model obtains the value of an attribute through the agent's actions. In the active model, an action and an expression is encoded as a direct executable structure.
The agents exchange information using messages. The sent message is a command which encodes an action which the sender agent can not execute it and delegates the receiver agent to perform it.
The multiagent model has revealed the usefulness of topological elements in the description of interactive applications. It provides techniques for a more natural control of the parallel and concurrent processes through direct manipulation. Cooperation among agents is accomplished at different levels of complexity:
- an agent can ask explicitly information from another agent. The second agent replies an answer according with its knowledge.
- an agent can transfer its knowledge and behaviour to another agent (e.g. instantiates its behaviour, trajectory, instances and give them to another agent).
- an agent can use the sub-tasks of another agent to achieve its own goal.
The model is parallel and concurrent:
- each agent has an associated set of processors (i.e. behaviour, play, server, and interactors) which perform its evolution.
- the processors of different agents access concurrently the model's resources.
[1] Arbab, F., Herman, I., Reynolds, G.J.: "An Object Model for Multimedia Programming", Computer Graphics Forum, Vol. 12, No. 3, pp. C-101 - 113, 1993.
[2] Chatty, S.: "Defining the dynamic behavior of animated interfaces", Engineering for Human-Computer Interaction EHCI'92, 1992, IFIP Transactions, pp. 95-109.
[3] Gorgan, D.: "Fuzzy Learning and Behavior in Multi-Agents Based Interactive Systems". LDAIS Workshop at ECAI96 Conference, 12-16 August 1996, Budapest.
[4] Hudson, S.E., Stasko, J.T.: "Animation Support in a User Interface Toolkit: Flexible, Robust and Reusable Abstractions". Proceedings UIST'93, Atlanta GA, November 1993, pp.55-67.
[5] Lieberman, H.: "Using Prototypical Objects to Implement Shared Behavior in Object Oriented Systems". In Proceedings of First ACM Conference on Object Oriented Programming Systems, Languages & Application., 1986.
[6] Maes, P.: "Modeling Adaptive Autonomous Agents", Journal of Artificial Life, Volume 1, Number 1/2, MIT Press, Fall 1993/Winter 1994.
[7] Maes, P.: "Artificial Life meets Entertainment: Lifelike Autonomous Agents". Special Issue on New Horizons of Commercial and Industrial AI, Communications of the ACM, Vol.38(11), November 1995.
[8] Mauldin, M.: "ChatterBots, TinyMuds, and the Turing Test: Entering the Loebner Prize Competition", Proceedings of the AAAI 1994 Conference, MIT Press, pp. 16-21.
[9] Myers, B.A.: "The Garnet Compendium: Collected Papers, 1989-1990", Research Report, Carnegie Mellon University, USA, August 1990.
[10] Michael Travers: "Recursive Interfaces for Reactive Objects". [PostScript] In Proceedings of the Conference on Human Factors in Computing Systems (CHI'94), Boston 1994, pp. 379-385.