de
Informatica30(2006)33–4433 A Survey of Programming Languages and Platforms for Multi-Agent Systems Rafael H.Bordini
University of Durham,UK
E-mail:R.Bordini@https://www.wendangku.net/doc/f513203732.html,,https://www.wendangku.net/doc/f513203732.html,/r.bordini
Lars Braubach
Universit?t Hamburg,Germany
E-mail:braubach@informatik.uni-hamburg.de,https://www.wendangku.net/doc/f513203732.html,rmatik.uni-hamburg. de
Mehdi Dastani
Utrecht University,The Netherlands
E-mail:mehdi@cs.uu.nl,http://www.cs.uu.nl/~mehdi
Amal El Fallah Seghrouchni
University of Paris6,France
E-mail:Amal.Elfallah@lip6.fr,http://www-poleia.lip6.fr/~elfallah
Jorge J.Gomez-Sanz
Universidad Complutense de Madrid,Spain
E-mail:jjgomez@sip.ucm.es,http://grasia.fdi.ucm.es/jorge
Jo?o Leite
Universidade Nova de Lisboa,Portugal
E-mail:jleite@di.fct.unl.pt,http://centria.di.fct.unl.pt/~jleite
Gregory O’Hare
University College Dublin,Ireland
E-mail:Gregory.OHare@ucd.ie,http://www.cs.ucd.ie/staff/gohare
Alexander Pokahr
Universit?t Hamburg,Germany
E-mail:pokahr@informatik.uni-hamburg.de,https://www.wendangku.net/doc/f513203732.html,rmatik.uni-hamburg.de Alessandro Ricci
Universitàdi Bologna,Italy
E-mail:aricci@deis.unibo.it,http://lia.deis.unibo.it/~ari
Keywords:Multi-Agent Systems,Programming Languages,Platforms
Received:April1,2005
This paper surveys recent research on programming languages and development tools for Multi-Agent
Systems.It starts by addressing programming languages(declarative,imperative,and hybrid),followed
by integrated development environments,and?nally platforms and frameworks.To illustrate each of these
categories,some systems were chosen based on the extent to which European researchers have contributed
to their development.The current state of these systems is described and,in some cases,indications of
future directions of research are given.
Povzetek:Podan je pregled jezikov in orodij za MAS.
1Introduction
Research in Multi-Agent Systems(MAS)has recently led to the development of practical programming languages and tools that are appropriate for the implementation of such systems.Putting together this new programming paradigm is fast becoming one of the most important top-ics of research in multi-agent systems,in particular because this is an essential requirement for an eventual technology transfer.
Surveying the MAS literature will reveal a large number of different proposals for agent-oriented languages,rang-ing from purely declarative,to purely imperative,and var-ious hybrid approaches.Some are designed from scratch,
34Informatica30(2006)33–44Bordini et al.
directly encoding some theory of agency,while others ex-tend existing languages to suit the peculiarities of this new https://www.wendangku.net/doc/f513203732.html,ing these languages,instead of more conven-tional ones,proves useful when the problem is modelled as a multi-agent system,and understood in terms of cognitive and social concepts such as beliefs,goals,plans,roles,and norms.
Most agent programming languages have some under-lying platform which implements its semantics.However, agent frameworks exist that are not tightly coupled with one speci?c programming language.Instead,they are con-cerned with providing general techniques for relevant as-pects such as agent communication and coordination.The most mature languages will be accompanied by some In-tegrated Development Environment(IDE),intended to en-hance the productivity of programmers by automating te-dious coding tasks.Typically these will provide function-alities such as project management,creating and editing source?les,refactoring,build and run process,and testing. Despite the large number of languages,frameworks,de-velopment environments,and platforms recently proposed, implementing MAS is still an often daunting task.To ad-dress the problem of managing the inherent complexity of MAS and helping the structuring of their development,the research community has produced a number of methodolo-gies[4].Nevertheless,even if MAS practitioners follow such methodologies during the design phase,they still?nd great dif?culties in the implementation phase,partly due to the lack of maturity of both methodologies and program-ming tools.Among others,such dif?culties can be traced to the lack of specialised debugging tools;to the lack skills that are necessary in mapping analysis/design concepts to programming languages constructs;to the lack of pro?-ciency in dealing with the speci?c characteristics of differ-ent agent platforms;and also to the lack of understanding of the very foundations as well as practical characteristics of the agent-oriented approach to programming.
Even though most of the languages and tools developed so far have not been tried yet in large-scale,industrial-strength applications,much progress has been achieved in the last few years.This is,therefore,an appropriate time for a reality check and a bird’s eye view of the?eld,help-ing to consolidate existing achievements and guide future developments.To this end,this paper surveys some of the existing approaches situated in the MAS Programming area of research,from programming languages to development infrastructures,chosen in part according to the extent to which European researchers have contributed to their de-velopment.
The?rst part of the paper is devoted to the presenta-tion of agent-oriented programming languages,structured according to the existing paradigm on which they build. In Section2,we present declarative agent-oriented lan-guages,while Section3covers the imperative languages and Section4some hybrid languages.The second part will cover various implementations of software infrastructure for agents.These will be structured according to whether they are development environments for MAS,in Section5, or MAS platforms and frameworks,in Section6.The paper ends with some reference to further readings on this subject in Section7,and some?nal remarks in Section8.
2Declarative Languages
Declarative languages are partially characterised by their strong formal nature,normally grounded on logic.This is the case with most of the declarative languages described here:FLUX,Minerva,Dali,and ResPect.Other declara-tive languages are also grounded on other formalisms,such as CLAIM which?nds parts of its roots in the ambient cal-culus.Declarative languages that allow for easy integration with imperative code will be reviewed in Section4below. CLAIM(C omputational L anguage for A utonomous, I ntelligent and M obile Agents[23])is a high-level declar-ative agent-oriented programming language.It is part of an uni?ed framework called Himalaya[25](H ierarchical I ntelligent M obile A gents for building L arge-scale and A daptive s Y stems based on A mbients).It combines the main advantages of agent-oriented programming lan-guages,for representing cognitive aspects and reasoning, with those of concurrent languages based on process alge-bra,for representing concurrency and agent mobility.
The CLAIM language is inspired by ambient calcu-lus[11]and agents are hierarchically organised,thus supporting the design of Mobile Multi-Agent Systems (MMAS)–a set of connected hierarchies of agents–to be deployed on a network of computers.Every agent(i.e., a node of a hierarchy)contains cognitive elements(e.g., knowledge,goals,capabilities),processes,and sub-agents and is also mobile as it can move within its hierarchy or to a remote one.In addition,an agent can dynamically acquire intelligent and computational components from its sub-agents,which can be seen as some sort of inheritance. The mobility and the inheritance as de?ned in Himalaya framework favour a dynamic adaptability and recon?gura-tion of systems[50]for coping with the increasing com-plexity of distributed and cooperative applications.The main elements of CLAIM agents are cognitive,interaction, mobility,and recon?guration primitives.
The formal semantics of CLAIM is based on Plotkin’s [41]structural operational approach consisting of a transi-tion relation,from an initial state of a program to another state resulting from the execution of an atomic operation. At each step of an agent execution,either a message is dealt with,a running process executed,or a goal processed.For a detailed presentation of the semantics,we refer the reader to[24].
As an MMAS within Himalaya is deployed on a set of connected computers,the language CLAIM is supported by a distributed platform called SyMPA[51],which offers all the necessary mechanisms for management of agents, communication,mobility,security,fault-tolerance,and load balancing[30].SyMPA is implemented in Java and
A SURVEY OF LANGUAGES AND https://www.wendangku.net/doc/f513203732.html,rmatica30(2006)33–4435
compliant with the speci?cations of the MASIF[37]stan-dard from the OMG(Object Management Group).There is a central system providing management functions.An agent system is deployed on each computer connected to the platform.
The Himalaya environment has been used for develop-ing several complex applications that showed the expres-siveness of the language and the robustness and strength of the platform,such as:an application for information search on the Web[22],several electronic commerce ap-plications[23,52],a load balancing and resource sharing application using mobile agents[30],and an application for a network of digital libraries.
FLUX[53]is a high-level programming system for cog-nitive agents,which can be downloaded from http:// https://www.wendangku.net/doc/f513203732.html,.It consists of an implementation of the Fluent Calculus,an action representation formalism that provides a basic solution to the classical frame problem using the concept of state update axioms,while addressing a variety of aspects in reasoning about actions(hence the relevance for agents),such as rami?cations(i.e.,indirect effects of actions),quali?cations(i.e.,unexpected action failure),nondeterministic actions,concurrent actions,con-tinuous change,and noisy sensors and effectors.
An agent program in FLUX is a logic program consisting of three parts:the kernel providing the agent with the cog-nitive ability to reason about its actions and acquired sen-sor data,a background theory providing an internal model of its environment,and a strategy which speci?es the task-oriented behaviour in accordance with which the agent rea-sons,plans,and acts.The full expressive power of logic programming can be used to design strategies while facil-itating formal proofs of the correctness of strategies with respect to a problem-dependent speci?cation.
The use of progression,where a(possibly incomplete) initial world model is updated upon the performance of an action,is one of the main characteristics of FLUX.This al-lows for a computationally ef?cient solution to the frame problem and,consequently,an ef?cient agent implemen-tation based on the Fluent Calculus.Further information regarding FLUX can be obtained in[54].
MINERV A[32,33]is an agent system designed to pro-vide a common agent framework based on the strengths of Logic Programming,to allow for the combination of several existing non-monotonic knowledge representation and reasoning mechanisms.It uses MDLP and KABUL to specify agents and their behaviour.A MINERV A agent consists of several specialised,possibly concurrent,sub-agents performing various tasks,whose behaviour is speci-?ed in KABUL,while reading and manipulating a common knowledge base speci?ed in MDLP.
MDLP(M ulti-Dimensional D ynamic L ogic P rogramming)is the basic knowledge representation mechanism of an agent in MINERV A.MDLP is an extension of Answer Set Programming(ASP)where knowledge is represented by logic programs arranged in an acyclic digraph.In this digraph,vertices are sets of logic programs,and edges represent the relations between program.MDLP enjoys the merits of ASP such as default negation.Default negation allows the de?nition of non-monotonic behaviour thus facilitating the representation of,and reasoning about,incomplete knowledge.MDLP also allows for the simultaneous representation of several aspects such as hierarchies and preferences,as well as the evolution of the represented knowledge.
KABUL(K nowledge A nd B ehavior U pdate L anguage), as its recent evolution EVOLP[1],is a logic-programming style language that allows the speci?cation of updates to a knowledge base and to itself.A program in KABUL is a set of statements,each statement being a type of condition-action rule that can be seen as encoding an agent behaviour. The epistemic effects of actions can be either an update to the knowledge base of the agent,represented by an MDLP program,or a self update to the KABUL program,thus changing the behaviour of the agent over time.Condi-tions range from external observations,epistemic state of the agent,as well as concurrent execution of other actions. This allows for a combination of reactive and proactive be-haviour,in the sense that no external stimuli are needed to trigger the behaviour of the agent,while these can be com-bined with the rational features provided by the underlying MDLP knowledge representation framework and its formal and precise ASP-based semantics.More information re-garding MDLP,KABUL,and MINERV A can be found in [32].
DALI[14]is an Active Logic Programming language designed for executable speci?cation of logical agents.It uses plain Horn Clauses and its semantics is based on Least Herbrand Models.It intends to provide constructs to rep-resent reactivity and proactivity in an agent by means of rules.A DALI agent is a logic program that contains re-active rules,events,and actions aimed at interacting with an external environment.The reactive and proactive be-haviour of a DALI agent is triggered by several kinds of events:external,internal,present,and past events.All the events and actions are time stamped so as to record when they occurred.The new syntactic entities,i.e.,predicates related to events and proactivity,are indicated with special post?xes.When an event occurs in the agent’s“external world”,the agent can perceive it and decide to react.The reaction is de?ned by a reactive rule which has in its head that external event.The internal events de?ne the behaviour of a DALI agent,making it proactive independently of the environment and allowing it to manipulate and revise its knowledge.
ReSpecT[38]is a logic-based language,with a well-de?ned formal semantics,allowing for the de?nition of re-actions,expressed in terms of rules.A rule in ReSpecT consists of a head specifying the communication event that triggers the reaction and a body specifying which actions (tuples from the tuple centre)are atomically executed when the reaction is triggered.When a basic action fails,the re-action atomically fails and all its effects on the tuple cen-tre state are rolled back.The coordinating behaviour of
36Informatica30(2006)33–44Bordini et al.
tuple centres can be changed and adapted at runtime by dynamically changing the reactions de?ned in ReSpecT. Such a feature is typically exploited to deal with dynamism and openness of MAS applications.The tuple centre pro-grammed with these reactions acts as a basic scheduler, encapsulating the policy adopted to coordinate the vari-ous(autonomous)agent tasks.By changing the reactions, the overall coordinating behaviour of the system changes, without the need to change the agent’s behaviour.This lan-guage is used within the TuCSoN framework(discussed below in Section6).
3Imperative Languages
Purely imperative approaches to agent-oriented program-ming are less common,mainly due to the fact that most abstractions related to agent-oriented design are,typically, declarative in nature.There are however many program-mers who still use conventional,i.e.non-agent oriented, imperative languages for developing multi-agent systems; as a result,in practice agent notions are often implemented in an ad-hoc manner.An example of an agent-oriented lan-guage which is still essentially imperative,while incorpo-rating agent-speci?c abstractions,is the language available with the development environment JACK[57,26].
The JACK Agent Language(JAL)has been developed by a company called Agent Oriented Software.JAL is based on ideas of reactive planning systems resulting from the work on the BDI agent architecture and is,in this re-spect,similar to the hybrid languages Jason,3APL,and Jadex(discussed below in Section4).However,instead of providing a logic-based language,JAL is an extension of Java(implementing some features of logic languages such as logical variables).A number of syntactic constructs is added to Java,allowing programmers to create plans and belief bases,all in a graphical manner as JAL has a so-phisticated IDE which provides a tool for such purpose. In JAL,plans can be composed of reasoning methods and grouped into capabilities which,together,compose a spe-ci?c ability an agent is supposed to have,thus supporting a good degree of modularisation.Another structuring mech-anism present in JAL is the ability to use teams of agents,or agent organisations,a notion that is increasingly important both in agent-oriented design[4]and because of recent de-velopments in self-organising systems[47].Although JAL has no formal semantics,as a commercial platform,JACK has extensive documentation and supporting tools.It has been used in a variety of industrial applications as well as for research.For evaluation purposes,a free trial license for JAL can be obtained;more information is available at https://www.wendangku.net/doc/f513203732.html,.
4Hybrid Approaches
Various well-known agent languages combine declarative and imperative features.In this section we describe agent programming languages which are declarative while at the same time providing some speci?c constructs allowing for the use of code implemented in some external imperative language.These constructs serve as a means for the use of legacy code.The languages chosen to illustrate the hybrid approach are:3APL,Jason,IMPACT,Go!,and AF-APL. 3APL(A n A bstract A gent P rogramming L anguage “triple-a-p-l”)is a programming language for implement-ing cognitive agents that have beliefs,goals,and plans as mental attitudes,can generate and revise their plans to achieve their goals,and are able to interact with each other and with the environment they share with other agents.The ?rst version of3APL was designed by Hindriks et al.at Utrecht University[28].Since its initial design,the3APL programming language has been subject to continuous de-velopment[17,16].
One of the main features of3APL consists of program-ming constructs to implement mental attitudes of an agent as well as the deliberation process which manipulates them [15].In particular,3APL allows direct speci?cation of mental attitudes such as beliefs,goals,plans,actions and reasoning rules.Actions form the basic building blocks of plans and can be internal mental actions,external actions, or communication actions.The deliberation-related con-structs allow the implementation of selection and execution of actions and plans through which an agent’s belief base can be updated and through which the shared environment can be modi?ed.It also allows the selection and applica-tion of reasoning rules through which the plan base can be modi?ed.
The3APL programming language is designed so as to respect a number of software engineering and program-ming principles such as separation of concerns,modularity, abstraction,and reusability.It also supports the integra-tion of Prolog(declarative)and Java(imperative)program-ming languages.Interested readers will?nd in the3APL user guide(http://www.cs.uu.nl/3apl)a number of illustrative toy-problem applications such as the“blocks world”,Axelrod’s tournament,an English auction system, and the Contract Net protocol.3APL has also been applied to the implementation of the high-level control of mobile robots.In particular,3APL is being used for controlling the behaviour of SONY AIBO robots and to implement small-device mobile applications.
Jason is an interpreter,implemented by R.Bordini and J.Hübner,for an extended version of AgentSpeak(L),a logic-based agent-oriented programming language intro-duced by A.Rao in[43].The language is in?uenced by the work on the Beliefs-Desires-Intentions(BDI)architec-ture and BDI logics[44].The semantics of the extended language(which we call simply AgentSpeak),given by Bordini and colleagues,was recently revised and appears in[55].The core of the interpreter available with Jason is in fact an implementation of that operational seman-tics.Jason is available Open Source under GNU LGPL at https://www.wendangku.net/doc/f513203732.html,[6].Although the documentation is available at that URL,the best mate-
A SURVEY OF LANGUAGES AND https://www.wendangku.net/doc/f513203732.html,rmatica30(2006)33–4437
rial for an overview of the work on Jason is[7].
Some of the features available in Jason are:(i)speech-act based inter-agent communication(and belief annotation of information sources);(ii)annotations on plan labels, which can be used by elaborate(e.g.,decision-theoretic) selection functions;(iii)fully customisable(in Java)se-lection functions,trust functions,and overall agent archi-tecture(perception,belief-revision,inter-agent communi-cation,and acting);(iv)straightforward extensibility(and use of legacy code)by means of user-de?ned“internal ac-tions”;(v)a clear notion of a multi-agent environment, which is implemented in Java(this can be a simulation of a real environment,e.g.,for testing purposes before the sys-tem is actually deployed).Jason has a simple IDE which is discussed in Section5.
IMPACT is a system developed by Subrahmanian et al.[49],with the main purpose of providing a framework to build agents on top of heterogeneous sources of knowl-edge,i.e.,to transform legacy code into agents that can communicate and act.To“agentise”such legacy code,IM-PACT provides the notion of an agent program written over a language of so-called code-calls.A code-call can be seen as an encapsulation of whatever the legacy code is,repre-sented logically through conditions and queries on the re-sults produced by such code.These are used in clauses, that form agent programs,determining constraints on the actions that are to be taken by agents.Actions in IMPACT use some deontic notions such as agent actions being,at a certain time,“obligatory”,“permitted”,“forbidden”,etc. Such agent programs and their semantics resemble logic programs extended with deontic modalities.The seman-tics is given by the notion of a rational status sets,which are generalisations of the notion of stable models in logic programming.
The IMPACT platform provides a number of fea-tures,including agent deployment over a network,reg-istration of available agent services and yellow-page https://www.wendangku.net/doc/f513203732.html,rmation on the IMPACT platform is available at https://www.wendangku.net/doc/f513203732.html,/projects/ impact/.The framework has been extended to support also temporal or probabilistic reasoning[20].A recent overview of the IMPACT language and platform can be found in[21].
Go![12]is a multi-paradigm agent programming lan-guage,with a declarative subset of function and relation de?nitions,an imperative subset comprising action proce-dure de?nitions,and rich program structuring mechanism. Based on the symbolic programming language April[36], Go!extends it with knowledge representation features of logic programming,yielding a multi-threaded,strongly typed and higher order(in the functional-programming sense)language.
Inherited from April,threads primarily communicate through asynchronous message passing.Threads,execut-ing action rules,react to received messages using pattern matching and pattern-based message reaction rules.A communication daemon enables threads in different Go!processes to communicate transparently over a network. Typically,each agent will comprise several threads,each of which can directly communicate with threads in other agents.Threads within a single Go!process,hence in the same agent,can also communicate by manipulating shared cell or dynamic relation objects.As in Linda tuple stores, these elements are used to coordinate the activities of dif-ferent threads within an agent.Go!is strongly typed,which can often reduce the programmer’s burden,and compile-time type checking improves code safety.New types can be declared and thereby new data constructors can be in-troduced.
The design of Go!took into consideration critical issues such as security,transparency,and integrity,in regards to the adoption of logic programming technology.Features of Prolog that lack a transparent semantics,such as the cut (‘!’)were left out.In Prolog the same clause syntax is used both for de?ning relations,with a declarative seman-tics,and for de?ning procedures which only have an op-erational semantics.In Go!,behaviour is described using action rules that have a specialised syntax.
Agent Factory Agent Programming Language(AF-APL)is the core programming language that resides at the heart of Agent Factory,which will be reviewed in Sec-tion5.AF-APL is originally based on Agent-Oriented Pro-gramming as?rst put forward by Y.Shoham[48],but was revised and extended with BDI concepts,such as beliefs and plans.The syntax and semantics of the AF-APL lan-guage have been derived from a logical model of how an agent commits itself to a course of action.Details of this model can be found in[13,46].Speci?cally,the model de?nes the mental state of an agent to be comprised of two primary mental attitudes:beliefs and commitments. In AF-APL,the belief set is comprised of a set of decla-rations about the current state of the environment.Agents are situated,given that an AF-APL programmer can de-clare explicitly,for each agent,a set of sensors referred to as perceptors and a set of effectors known as actuators. Perceptors are realized as instances of Java classes that de-?ne how to convert raw sensor data into beliefs that may be added to the belief set of the agent.Similarly,an ac-tuator is realized as an instance of a Java class,which has two responsibilities:(1)to de?ne the action identi?er that should be used when referring to the action that is realized by the actuator,and(2)to contain code that implements the action.Collectively,these declarations are termed the em-bodiment con?guration of the agent,and they are speci?ed within the agent program.
5Integrated Development
Environments
Integrated Development Environments(IDEs),focus on the programming language level and intend to enhance the pro-ductivity by automating tedious coding tasks.Looking at current IDEs from the object-oriented domain it can be
38Informatica30(2006)33–44Bordini et al.
seen that such IDEs tend to provide functionalities that can be classi?ed into?ve categories:project management, https://www.wendangku.net/doc/f513203732.html,anising the project structure according to develop-ers’needs;creating and editing source?les,e.g.provid-ing structure views for quick and easy navigation,online error detection,auto-completion,and so on;refactoring to enable fast and reliable code restructuring operations; build and run process allowing the execution of applica-tions from within the IDE;and testing,e.g.supported by unit testing with test cases.
In the agent world,the situation differs from conven-tional programming in that there is no common ground with respect to agent programming languages and agent ar-chitectures.Hence,current agent IDEs exist only for agent languages of speci?c agent frameworks.Additionally,we found that only a small proportion of available agent frame-works offer IDE support at all,considering AgentLink (https://www.wendangku.net/doc/f513203732.html,)as a representative selection of existing agent-related software.From this small number,we selected some representative examples: 3APL IDE,Jason IDE,JDE,CAFnE,Visual Soar,Agent-Builder,AgentFactory,and the Living Systems Developer. The3APL IDE allows developers to load/edit3APL programs that implement individual agents,execute one or more agent programs in either a step-by-step or continu-ous fashion,implement and con?gure the environment that is shared by the agents,monitor the internal state of in-dividual agents through an agent property window,moni-tor the exchange of messages through the sniffer tool,send an external-user message to an individual agent,and read the system messages.The3APL IDE is built on top of the3APL multi-agent platform that consists of a direc-tory facilitator called agent management system,a mes-sage transport system which delivers agent messages,and a plugin interface that allows agents to execute actions in the shared environment.The3APL platform thus allows the implementation and concurrent execution of a set of 3APL agents.The3APL development environment,its user guide,and further documentation can be found at http://www.cs.uu.nl/3apl.
Jason[6]is distributed with an IDE which provides a graphical interface for editing a multi-agent system con?g-uration?le,as well as AgentSpeak code for the individ-ual agents.Through the IDE,it is also possible to run and control the execution mode of a multi-agent system,and to distribute agents over a network in a very simple way. The IDE also provides another tool,called“Mind Inspec-tor”,which allows the user to inspect agents’internal states when the system is running in debugging mode.This is very useful for debugging AgentSpeak MAS,as it allows the programmer to inspect agents’mental attitudes across a distributed system.
The JACK Development Environment(JDE)is a full-featured commercial IDE for the JACK BDI agent plat-form[57]developed by Agent Oriented Software Ltd.It is based on the JACK Agent Language(JAL)which was presented in Section3.JDE allows agent developers to or-ganise their?les into projects offering a semantically or-ganised tree view with respect to the different kinds of con-tained elements.The editing of agent code is supported by a rudimentary integrated editor that,for example,pro-vides syntax highlighting for JAL.More advanced features such as auto-completion and error-detection are not avail-able.However,the IDE provides a graphical plan editor that allows the construction of a plan from visual com-ponents similar to statecharts.Once the code base for a project is complete,it is possible to compile and run an application directly from within the IDE.
The CAFnE(C omponent A gent F ramework for n on-E xperts)tool[29]does not represent an IDE in the clas-sical sense.Its objective is to enable domain experts to modify an existing agent application.CAFnE has been conceived to support the development of BDI agents based on a rather platform-independent BDI component language adapted from SMART[34].The rationale of CAFnE is to hide the agent code layer and provide interactive dia-logues for the development.Transformer modules can then be used to generate platform-dependent code from the in-ternal representation.
Visual Soar is a freely available IDE for the Soar agent architecture[31].It supports basic project management capabilities and mainly facilitates Soar agent program-ming through syntax highlighting and some consistency checking functionalities.Additionally,the IDE provides a connection to a Soar runtime environment allowing Soar agents to be executed from the IDE.
AgentBuilder is an agent platform directly based Agent-Oriented Programming(AOP),as originally de?ned by Shoham[48],developed by Acronymics Inc.It relies on the Reticular Agent Language which is an extension of Shoham’s Agent0.As the used agent language is not in-tended for direct programming,an agent developer has to use the AgentBuilder IDE,which consists of a variety of different tools supporting all aspects of building agent ap-plications.The IDE is conceived to hide agent code as much as possible and offers graphical wizards and tools whenever possible.It provides simple project management functionalities and integrates with a compiler tool.Suc-cessfully built agent applications can directly be executed from the IDE.
The Agent Factory[13]Development Environment of-fers support for basic project management,editing,and assembling the different agent constituents.It contains a cohesive layered framework for the development and de-ployment of agent-oriented applications.At the centre of this framework is the Agent Factory Agent Program-ming Language(AF-APL)described above in Section4. The AF-APL interpreter is embedded within the distributed FIPA-compliant Run-Time Environment(RTE)which can be seen as a collection of agent platforms.Besides the IDE, a tool named VIPER[45]allows the composition of Agent UML Sequence Diagrams that sit at the heart of the Pro-tocol Model.In addition to the tools that have been pro-vided to support the development of AF-APL agents,the
A SURVEY OF LANGUAGES AND https://www.wendangku.net/doc/f513203732.html,rmatica30(2006)33–4439
Agent Factory Development Environment also includes a suite of tools that facilitate the testing and debugging of agent-oriented applications.
The Living Systems Developer is a commercial IDE for the Living Systems Technology Suite developed by Whitestein(https://www.wendangku.net/doc/f513203732.html,).The underlying agent platform supports Java-based agents, rather than supporting a specialised agent language. The IDE is designed as an Eclipse(http://www. https://www.wendangku.net/doc/f513203732.html,)plug-in,hence providing sophisticated editing and refactoring functionalities for Java code.In addition,several agent related aspects such as project man-agement in accordance to the agent features used have been added.To facilitate the development process of agent-based applications,the IDE has been extended to fully sup-port all phases of ADEM,the Agent Development Method-ology also created at Whitestein.
6Agent Platforms and Frameworks Most languages described in this paper have some un-derlying platform which implements the semantics of the agent programming language.However,some imple-mented frameworks exist that are not so strongly tied to a particular programming language.Instead,these frame-works are more concerned with providing support for as-pects such as agent communication and coordination.In this Section we focus on such frameworks,having chosen T uCSoN,JADE,and DESIRE as illustrative examples. TuCSoN(Tu ple C entre S pread o ver the N etwork)is a framework for MAS coordination,based on a model and a related infrastructure providing general-purpose,pro-grammable services for supporting agent communication and coordination[39].The model is based on tuple centres as runtime programmable abstractions whose coordinating behaviour can be dynamically speci?ed with a logic-based language called ReSpecT.Tuple centres are an example of coordination artifacts(see the survey on Environment mod-elling for MAS[56]),i.e,?rst-class entities(tools)popu-lating the agent cooperative working environment,shared and used collectively by the agents to support their coor-dination.Such abstractions are also used in the SODA methodology(see the survey on Agent Oriented Software Engineering[4])as basic building blocks for designing the social level and the environment in a MAS.
The TuCSoN technology is available as an open source project(https://www.wendangku.net/doc/f513203732.html,).It is completely based on Java,and is composed of:a runtime platform to be installed on hosts to turn them into nodes of the infrastructure;a set of libraries(APIs)to enable agents access to the services;and a set of tools mainly to support the runtime inspection and control(monitor-ing,debugging)of tuple-centres’state and coordinating be-haviour.At the heart of the TuCSoN technology is the tuProlog technology,a Prolog engine fully integrated with the Java environment,available also as a standalone library and environment(the tuProlog technology is available at https://www.wendangku.net/doc/f513203732.html,[19]).Be-sides being adopted in research projects(e.g.,for dis-tributed work?ow management,logistics,and e-learning), TuCSoN is currently used as one of the reference platforms for building agent-based systems in academic projects and thesis developed at the Engineering Faculties in Cesena and Bologna.
JADE(J ava A gent DE velopment Framework)[2]is a Java framework for the development of distributed multi-agent applications.It represents an agent middleware pro-viding a set of available and easy-to-use services and sev-eral graphical tools for debugging and testing.One of the main objectives of the platform is to support interoperabil-ity by strictly adhering to the FIPA speci?cations concern-ing the platform architecture as well as the communication infrastructure.Moreover,JADE is very?exible and can be adapted to be used on devices with limited resources such as PDAs and mobile phones.
JADE has been widely used over the last years by many academic and industrial organisations(see[2])ranging from tutorials for teaching support in agent-related Uni-versity courses to Industrial prototyping.As an example, Whitestein has used JADE to construct an agent-based sys-tem for decision-making support in organ transplant centres [10].
The JADE platform is open source software,distributed by TILAB(Telecom Italia LABoratories)under the terms of the LGPL license and can be obtained at http:// https://www.wendangku.net/doc/f513203732.html,.Since May2003,the International JADE Board has been responsible for supervising the man-agement of the project.Currently,the JADE Board consists of?ve members:TILAB,Motorola,Whitestein Technolo-gies AG,Profactor,and France Telecom.
Jadex[42]is a software framework for the creation of goal-oriented agents following the belief-desire-intention (BDI)model.The framework is realized as a rational agent layer that sits on top of a middleware agent infras-tructure such as JADE[2],and supports agent development with well established technologies such as Java and XML. The Jadex reasoning engine addresses traditional limita-tions of BDI systems by introducing new concepts such as explicit goals and goal deliberation mechanisms(see, e.g.,[8]),making results from goal-oriented analysis and design methods(e.g.,KAOS and Tropos)more easily trans-ferable to the implementation phase.
Jadex has been used to build applications in different do-mains such as simulation,scheduling,and mobile comput-ing.For example,Jadex was used to develop a multi-agent application for negotiation of treatment schedules in hospi-tals[40].Jadex has also been successfully used in several software engineering courses at the University of Hamburg. The Jadex system,developed at the Distributed Systems and Information Systems group at the University of Ham-burg,is freely available under the LGPL license and can be downloaded from http://jadex.sourceforge. net.Besides the framework and additional development
40Informatica30(2006)33–44Bordini et al.
tools,the distribution contains an introductory tutorial,a user guide,and several illustrative example applications with source code.
DESIRE(DE sign and S peci?cation of I nteracting RE asoning components)is a compositional development method for multi-agent systems,based on a notion of com-positional architecture,and developed by Treur et al.[9] at the Vrije Universiteit Amsterdam.In this approach, agent design is based on the following main aspects:pro-cess composition,knowledge composition,and relations between knowledge and process composition.In this component-based agent approach,an agent’s complex rea-soning process is built up as an interaction between the components representing the subprocesses of the overall reasoning process[9].The reasoning process is structured according to a number of reasoning components that in-teract with each https://www.wendangku.net/doc/f513203732.html,ponents may or may not be composed of other components,where components that are not further decomposed are called primitive compo-nents.The functioning of the overall agent system is based on the functionality of these primitive components plus the composition relation that coordinates their inter-action.Speci?cation of a composition relation may in-volve,for example,the possibilities of information ex-change among components and the control structure that activates the components.The DESIRE approach has been used for applications such as load balancing of electric-ity distribution and diagnosis systems.Further informa-tion and documentation of the tools supporting the devel-opment and implementation of multi-agent systems based on DESIRE is available at http://www.few.vu.nl/ ~wai/demas/tools2.html.
7Further Reading
This paper should be complemented with related literature. Besides the references spread throughout the text,point-ing to more detailed explanations of the systems described, we recommend the survey on agent programming lan-guages by Mascardi et al.[35],which provides a detailed view of ConGolog,Agent-0,IMPACT,DyLog,Concurrent MetateM,and E hhf.A reference book on programming languages for Multi-Agent Systems has been published re-cently[5].It contains detailed description of a selection of practical programming languages and tools which support MAS programming and implement key MAS concepts in a uni?ed framework.Another extensive overview of agent technology is available in[3],which includes a comprehen-sive collection of papers on technologies,methodologies, and current research trends in the MAS domain.
As we have mentioned before,the criteria in which we based our choice of systems was,in part,the extent to which European researchers have contributed to their de-velopment.Of course there are various other agent lan-guages,platforms,and tools besides those referred here.A good collection of agent-related software can be found in the AgentLink III website(https://www.wendangku.net/doc/f513203732.html,). Overall,the systems described here focus on the im-plementation phase.However,current research trends include the attempt to make implementation easier by bridging the analysis and design phase directly to im-plementation[4].Examples of such research efforts are INGENIAS and its Development Kit[27](http: //https://www.wendangku.net/doc/f513203732.html,),and MaSE and its AgenTool[18](https://www.wendangku.net/doc/f513203732.html,/ projects/agentTool/agentool.htm).
8Final Remarks
Programming Multi-Agent Systems is rapidly turning into a new discipline of its own.Throughout the paper,we have described several examples of languages and systems cur-rently being developed in this area.We now draw some conclusions on the three main topics of this survey,namely languages,IDEs,and platforms.
Languages.Most research in agent-oriented program-ming languages is based on declarative approaches.There are many declarative solutions,most of them logic based. Purely imperative languages are unusual in the Agents lit-erature,as in essence they are inappropriate for expressing the high-level abstractions associated with agent systems design.On the other hand,as we saw above,agent-oriented programming languages tend to allow for easy integration with(legacy)code written in imperative languages.Inter-estingly,the characteristics of the underlying agent archi-tectures determine that it is often more appropriate to use interpreters rather than compilers.
IDEs.The existing IDEs provide basic support for project management,creating/editing?les,and building/running the systems,but fail to support sophisticated features within all these categories.In addition,none of the agent IDEs covers aspects of refactoring and testing of agent applica-tions.One reason for this is that,except for the Living Systems Developer,all IDEs have been developed from scratch and thus do not rely on existing reliable technol-ogy.In general,IDE support for developing agent-based systems is rather weak and the existing agent tools do not offer the same level of usability as state-of-the-art object-oriented IDEs.One of the main reason for this is the cur-rently unavoidable tight coupling of agent IDEs and agent platforms,which results from the lack of agreement on an uni?ed programming language for multi-agent systems. Another trend(observable in some of the IDEs),which is in contrast to object-oriented IDEs,is that they partly try to abstract away from the underlying programming language in favour of using graphical means of programming,such as wizards and statecharts.
Platforms.Closed frameworks such as DESIRE,strongly based on a platform,provide more complete solutions than others such as Jadex or TuCSoN.They usually offer an agent architecture and a system model,very useful for novel developers,together with the communication infras-
A SURVEY OF LANGUAGES AND https://www.wendangku.net/doc/f513203732.html,rmatica30(2006)33–4441
tructure and a range of robust services,such as directory facilitators,agent management services,and monitoring facilities.As a drawback,closed frameworks limit the development.For example,the design approach of the framework may not?t certain domain problems.Perhaps that is the reason why most researchers tend to use more open solutions.Currently,the most popular solution is to use JADE as underlying agent infrastructure combined with some other(higher-level)approach to program the agents’behaviour.When dealing with more general frameworks(rather than tied to a platform),their use(i.e., de?ning the agents that will run within it,together with the required services and resources)should be automated as much as possible,in part to free the developer from low-level details(e.g.location of the con?guration?les, their concrete syntax,etc.).Despite this,few existing frameworks have IDE support.Concerning the paradigm of communication used,there are several on offer,often being an important issue when choosing which framework to adopt.T uCSoN is representative of tuple-centred communication,JADE of message passing,and DESIRE of data?ow among processes.
The various approaches mentioned along this survey in-dicate that there is still much work to be done.Among the major challenges faced by this research community are:
–The conception and development of specialised de-bugging tools,in particular for cognitive agent lan-guages;
–The integration of agent tools into existing IDEs, rather than starting from scratch;
–The separation of MAS frameworks from agent plat-forms,so that each framework can be used for deploy-ing systems on a variety of platforms.
–The dissemination of the MAS programming paradigm,so that programmers have a better un-derstanding of its foundations as well as practical characteristics.
We believe that the recent developments surveyed here show a lively interest in this area of research.Despite the large number of open issues and challenges,we ex-pect that the experience gathered in developing MAS with these tools will take us closer to a more mature program-ming paradigm.Arguably,this is one of the few concrete ways for allowing wider audiences to use in practice,and in a systematic way,the various techniques that the MAS re-search community has developed over the last two decades. Acknowledgements
We gratefully acknowledge the help and support of AgentLink III,in particular its Technical Fora,which not only motivated the authors to work together in producing this joint survey,but also provided the conditions for much of the discussion that we used in this paper and indeed that will guide future work in this area of research.We also acknowledge the valuable comments and suggestions pro-vided by the anonymous referees.
References
[1]J.J.Alferes,A.Brogi,J.A.Leite,and L.M.Pereira.
Evolving logic programs.In S.Flesca,S.Greco, N.Leone,and G.Ianni,editors,Proceedings of the 8th European Conference on Logics in Arti?cial In-telligence(JELIA’02),volume2424of LNAI,pages 50–61.Springer,2002.
[2]F.Bellifemine,F.Bergenti,G.Caire,and A.Poggi.
JADE—a java agent development framework.In Bordini et al.[5],chapter5,pages125–148.
[3]F.Bergenti,M.-P.Gleizes,and F.Zambonelli,editors.
Methodologies and Software Engineering for Agent Systems.Kluwer,2004.
[4]C.Bernon,M.Cossentino,and J.Pavon.An overview
of current trends in european aose research.Journal of Informatica,2005.In this volume.
[5]R.H.Bordini,M.Dastani,J.Dix,and A.El Fal-
lah Seghrouchni,editors.Multi-Agent Programming: Languages,Platforms and Applications.Number15 in Multiagent Systems,Arti?cial Societies,and Sim-ulated Organizations.Springer,2005.
[6]R.H.Bordini,J. F.Hübner,et al.Ja-
son,manual,release0.7edition,Aug.2005.
https://www.wendangku.net/doc/f513203732.html,/.
[7]R.H.Bordini,J.F.Hübner,and R.Vieira.Jason and
the Golden Fleece of agent-oriented programming.In Bordini et al.[5],chapter1,pages3–37.
[8]L.Braubach,A.Pokahr,D.Moldt,and https://www.wendangku.net/doc/f513203732.html,mers-
dorf.Goal representation for BDI agent systems.
In R.Bordini,M.Dastani,J.Dix,and A.El Fal-lah Seghrouchni,editors,Programming Multi-Agent Systems,second Int.Workshop(ProMAS’04),volume 3346of LNAI,pages44–65.Springer Verlag,2005.
[9]F.Brazier,C.Jonker,and J.Treur.Principles of
compositional multi-agent system development.In Proceedings of Conference on Information Technol-ogy and Knowledge Systems,pages347–360.Aus-trian Computer Society,1998.
[10]M.Calisti,P.Funk,S.Biellman,and T.Bugnon.A
multi-agent system for organ transplant management.
In A.Moreno and J.Nealon,editors,Applications of Software Agent Technology in the HealthCare Do-main,pages199–212.Birkh?user Verlag,2004.
42Informatica30(2006)33–44Bordini et al.
[11]L.Cardelli and A.D.Gordon.Mobile ambients.In
M.Nivat,editor,Foundations of Software Science and Computational Structures,volume1378of LNCS, pages140–155.Springer,1998.
[12]K.Clark and F.McCabe.Go!—a multi-
paradigm programming language for implementing multi-threaded agents.Annals of Mathematics and Arti?cial Intelligence,41(2–4):171–206,2004. [13]R.W.Collier.Agent Factory:A Framework for the
Engineering of Agent-Oriented Applications.PhD thesis,University College Dublin,2001.
[14]S.Costantini and A.Tocchio.A logic program-
ming language for multi-agent systems.In S.Flesca, S.Greco,N.Leone,and G.Ianni,editors,Proceed-ings of the8th European Conference on Logics in Arti?cial Intelligence(JELIA’02),volume2424of LNAI,pages1–13.Springer,2002.
[15]M.Dastani,F.de Boer,F.Dignum,and J.-J.Meyer.
Programming agent deliberation:An approach il-lustrated using the3APL language.In Proceed-ings of the Second International Joint Conference on Autonomous Agents and Multiagent Systems(AA-MAS’03),pages97–104.ACM,2003.
[16]M.Dastani,M.B.van Riemsdijk,F.Dignum,and J.-
J.C.Meyer.A programming language for cognitive agents:goal directed3APL.In M.Dastani,J.Dix, and A.El Fallah-Seghrouchni,editors,Programming multiagent systems,?rst international workshop(Pro-MAS’03),volume3067of LNCS,pages111–130, Berlin,2004.Springer Verlag.
[17]M.Dastani,M.B.van Riemsdijk,and J.-J.C.Meyer.
Programming multi-agent systems in3APL.In Bor-dini et al.[5],chapter2,pages39–67.
[18]S.DeLoach.Analysis and design using MaSE and
agenTool.In Proceedings of Midwest Arti?cial In-telligence and Cognitive Science.Miami University Press,2001.
[19]E.Denti,A.Omicini,and A.Ricci.Multi-paradigm
Java-Prolog integration in tu Prolog.Science of Com-puter Programming,2005.In press.
[20]J.Dix,S.Kraus,and V.Subrahmanian.Agents deal-
ing with time and uncertainty.In M.Gini,T.Ishida,
C.Castelfranchi,and W.L.Johnson,editors,Pro-
ceedings of the First International Joint Conference on Autonomous Agents and Multiagent Systems(AA-MAS’02),pages912–919.ACM Press,2002. [21]J.Dix and Y.Zhang.IMPACT:a multi-agent frame-
work with declarative semantics.In Bordini et al.[5], chapter3,pages69–94.[22]A.El Fallah Seghrouchni and A.Suna.An uni?ed
framework for programming autonomous,intelligent and mobile agents.In V.Marik,J.Müller,and M.Pe-choucek,editors,Proceedings of Third International Central and Eastern European Conference on Multi-Agent Systems,volume2691of LNAI,pages353–362.Springer Verlag,2003.
[23]A.El Fallah Seghrouchni and A.Suna.CLAIM:
A computational language for autonomous,intelli-
gent and mobile agents.In M.Dastani,J.Dix,and
A.El Fallah Seghrouchni,editors,Programming Mul-
tiagent Systems,?rst international workshop(Pro-MAS’03),volume3067of LNCS,pages90–110.
Springer Verlag,2004.
[24]A.El Fallah Seghrouchni and A.Suna.Programming
mobile intelligent agents:an operational semantics.In Proceedings of the International Conference on In-telligent Agent Technology,pages65–71.IEEE Com-puter Society,2004.
[25]A.El Fallah Seghrouchni and A.Suna.Hi-
malaya Framework:Hierarchical Intelligent Mobile Agents for building Large-scale and Adaptive sYs-tems based on Ambients.In T.Ishida,L.Gasser, and H.Nakashima,editors,Proceedings of Mas-sive Multi-Agent Systems workshop,number3446in LNAI,pages202–216.Springer Verlag,2005. [26]R.Evertsz,M.Fletcher,R.Jones,J.Jarvis,J.Brusey,
and S.Dance.Implementing industrial multi-agent systems using JACK TM.In Programming multiagent systems,?rst international workshop(ProMAS’03), volume3067of LNAI,pages18–48.Springer Verlag, 2004.
[27]J.Gomez-Sanz and J.Pavon.Agent oriented software
engineering with INGENIAS.In V.Marik,J.Müller, and M.Pechoucek,editors,Proceedings of the Third International Central and Eastern European Confer-ence on Multi-Agent Systems,volume2691of LNCS, pages394–403.Springer Verlag,2003.
[28]K.Hindriks,F.de Boer,W.van der Hoek,and J.-
J.Ch.Meyer.Agent programming in3APL.Int.
J.of Autonomous Agents and Multi-Agent Systems, 2(4):357–401,1999.
[29]G.Jayatilleke,L.Padgham,and https://www.wendangku.net/doc/f513203732.html,-
ponent agent framework for non-experts(CAFnE) toolkit.In R.Unland,M.Klusch,and M.Calisti,ed-itors,Software Agent-Based Applications,Platforms and Development Kits.Birkh?user Publishing Com-pany,2005.
[30]G.Klein,A.Suna,and A.El Fallah Seghrouchni.Re-
source sharing and load balancing based on agent mo-bility.In Proceedings of International Conference on Enterprise Information Systems,pages350–355.
ICEIS Press,2004.
A SURVEY OF LANGUAGES AND https://www.wendangku.net/doc/f513203732.html,rmatica30(2006)33–4443
[31]J.F.Lehman,https://www.wendangku.net/doc/f513203732.html,ird,and P.S.Rosenbloom.A
gentle introduction to Soar,an architecture for human cognition.In S.Sternberg and D.Scarborough,edi-tors,An invitation to Cognitive Science,vol.4.MIT Press,1996.
[32]J.A.Leite.Evolving Knowledge Bases,volume81of
Frontiers in Arti?cial Intelligence and Applications.
IOS Press,2003.
[33]J.A.Leite,J.J.Alferes,and L.M.Pereira.MIN-
ERV A—a dynamic logic programming agent archi-tecture.In J.-J.Meyer and M.Tambe,editors,Intel-ligent Agents VIII—Agent Theories,Architectures, and Languages,volume2333of LNAI,pages141–157.Springer,2002.
[34]M.Luck and M.d’Inverno.Understanding Agent Sys-
tems.Springer Series on Agent Technology.Springer, 2nd edition,2004.
[35]V.Mascardi,M.Martelli,and L.Sterling.Logic-
based speci?cation languages for intelligent software agents.Theory and Practice of Logic Programming, 4(4):429–494,2004.
[36]F.McCabe and K.Clark.April—agent process in-
teraction language.In M.Wooldridge and N.Jen-nings,editors,Intelligent Agents,ECAI-94Workshop on Agent Theories,Architectures,and Languages, volume890of LNAI,pages324–340.Springer,1995.
[37]https://www.wendangku.net/doc/f513203732.html,ojicic,M.Breugst,I.Busse,J.Campbell,
S.Covaci, B.Friedman,K.Kosaka, https://www.wendangku.net/doc/f513203732.html,nge, K.Ono,M.Oshima,C.Tham,S.Virdhagriswaran, and J.White.MASIF,the OMG mobile agent sys-tem interoperability facility.In Proceedings of Mo-bile Agents’98,volume1477of LNAI,pages50–67.
Springer,1998.
[38]A.Omicini and E.Denti.From tuple spaces to
tuple centres.Science of Computer Programming, 41(3):277–294,Nov.2001.
[39]A.Omicini and F.Zambonelli.Coordination for
Internet application development.Int.J.of Au-tonomous Agents and Multi-Agent Systems,2(3):251–269,1999.
[40]T.O.Paulussen,A.Z?ller,A.Heinzl,A.Pokahr,
L.Braubach,and https://www.wendangku.net/doc/f513203732.html,mersdorf.Dynamic patient scheduling in hospitals.In M.Bichler,C.Holtmann, S.Kirn,J.Müller,and C.Weinhardt,editors,Coor-dination and Agent Technology in Value Networks.
GITO,Berlin,2004.
[41]G.Plotkin.A structural approach to operational se-
mantics.Technical Report DAIMI-FN19,Depart-ment of Computer Science,Arhaus University,1981.[42]A.Pokahr,L.Braubach,and https://www.wendangku.net/doc/f513203732.html,mersdorf.Jadex:
A BDI reasoning engine.In Bordini et al.[5],chap-
ter6,pages149–174.
[43]A.S.Rao.AgentSpeak(L):BDI agents speak out in a
logical computable language.In Proceedings of Mod-elling Autonomous Agents in a Multi-Agent World, number1038in LNAI,pages42–55.Springer Verlag, 1996.
[44]A.S.Rao and M.P.Georgeff.BDI agents:From
theory to practice.In Proceedings of International Conference on Multi Agent Systems,pages312–319.
AAAI Press/MIT Press,1995.
[45]C.F.B.Rooney,R.W.Collier,and G.M.P.O’Hare.
VIPER:A visual protocol editor.In R.D.Nicola,
G.Ferrari,and G.Meredith,editors,Proceedings of
the International Conference on Coordination Mod-els and Languages,volume2949of LNCS,pages 279–293.Springer Verlag,2004.
[46]R.Ross,R.Collier,and G.O’Hare.AF-APL:
Bridging principles and practices in agent oriented languages.In R.Bordini,M.Dastani,J.Dix, and A.El Fallah Seghrouchni,editors,Program-ming Multi-Agent Systems,second Int.Workshop (ProMAS’04),volume3346of LNCS,pages66–88.
Springer Verlag,2005.
[47]G.D.M.Serugendo,M.-P.Gleizes,and A.Karageor-
gos.Self-organisation and emergence in mas:An overview.Journal of Informatica,2005.In this vol-ume.
[48]Y.Shoham.Agent-oriented programming.Arti?cial
Intelligence,60(1):51–92,1993.
[49]V.Subrahmanian,P.Bonatti,J.Dix,T.Eiter,S.Kraus,
F.?zcan,and R.Ross.Heterogenous Active Agents.
MIT-Press,2000.
[50]A.Suna and A.El Fallah Seghrouchni.Adaptative
mobile multi-agent systems.In Proceedings of Inter-national Central and Eastern European Conference on Multi-Agent Systems,LNAI,2005.To appear. [51]A.Suna and A.El Fallah Seghrouchni.A mo-
bile agents platform:architecture,mobility and se-curity elements.In R.Bordini,M.Dastani,J.Dix, and A.El Fallah Seghrouchni,editors,Programming Multi-Agent Systems,second Int.Workshop(Pro-MAS’04),volume3346of LNAI,pages126–146, New-York,2005.Springer Verlag.
[52]A.Suna,C.Lemaitre,and A.El Fallah Seghrouchni.
E-commerce using an agent oriented approach.
Revista Iberoamericana de Inteligencia Arti?cal, 9(25):89–98,2005.
44Informatica30(2006)33–44Bordini et al.
[53]M.Thielscher.FLUX:A logic programming method
for reasoning agents.Theory and Practice of Logic
Programming,2005.To appear.
[54]M.Thielscher.Reasoning Robots:The Art and Sci-
ence of Programming Robotic Agents,volume33of
Applied Logic Series.Springer,2005.
[55]R.Vieira,A.Moreira,M.Wooldridge,and R.H.Bor-
dini.On the formal semantics of speech-act based
communication in an agent-oriented programming
language.To appear,2005.
[56]D.Weyns and T.Holvoet.On the role of environ-
ments in multiagent systems.Journal of Informatica,
2005.In this volume.
[57]M.Winikoff.JACK TM intelligent agents:An indus-
trial strength platform.In Bordini et al.[5],chapter7,
pages175–193.