Welcome to Scribd, the world's digital library. Read, publish, and share books and documents. See more ➡
Standard view
Full view
of .
Add note
Save to My Library
Sync to mobile
Look up keyword
Like this
0 of .
Results for:
No results containing your search query
P. 1
A survey of Agent-Oriented Software Engineering

A survey of Agent-Oriented Software Engineering



|Views: 10,878|Likes:
Published by isaac2008
Agent-Oriented Software Engineering is the one of
the most recent contributions to the field of Software
Engineering. It has several benefits compared to
existing development approaches, in particular the
ability to let agents represent high-level abstractions
of active entities in a software system. This paper
gives an overview of recent research and industrial
applications of both general high-level methodologies
and on more specific design methodologies for
industry-strength software engineering.
Agent-Oriented Software Engineering is the one of
the most recent contributions to the field of Software
Engineering. It has several benefits compared to
existing development approaches, in particular the
ability to let agents represent high-level abstractions
of active entities in a software system. This paper
gives an overview of recent research and industrial
applications of both general high-level methodologies
and on more specific design methodologies for
industry-strength software engineering.

More info:

Published by: isaac2008 on Apr 26, 2008
Copyright:Attribution Non-commercial


Read on Scribd mobile: iPhone, iPad and Android.
download as PDF, TXT or read online from Scribd
See More
See less





A survey of Agent-Oriented Software Engineering
Amund Tveit
Norwegian University of Science and TechnologyMay 8, 2001
Agent-Oriented Software Engineering is the one of the most recent contributions to the field of SoftwareEngineering. It has several benefits compared toexisting development approaches, in particular theability to let agents represent high-level abstractionsof active entities in a software system. This papergives an overview of recent research and industrialapplications of both general high-level methodolo-gies and on more specific design methodologies forindustry-strength software engineering.
Intelligent Agents, Software Engi-neering, UML, Design Patterns and Components
1 Introduction
 Agent-Oriented Software Engineering
is beingdescribed as a new paradigm [22] for the researchfield of 
Software Engineering
. But in order tobecome a new paradigm for the software industry,robust and easy-to-use methodologies and toolshave to be developed.But first, let us explain what an agent is. An agent,also called a software agent or an intelligent agent,is a piece of autonomous software, the words intel-ligent and agent describe some of its characteristicfeatures. Intelligent is used because the software canhave certain types of behavior (
“Intelligent behavior istheselectionofactionsbasedonknowledge
), andthe term
tells something about the purpose of the software. An agent is
“one who is authorized toact for or in the place of another”
(Merriam Web-ster’s Dictionary).
Examples of software agents
1. The animated paperclip agent in Microsoft Of-fice2. Computer viruses (destructive agents)
3. Artificial players or actors in computer gamesand simulations (e.g. Quake)4. Tradingandnegotiationagents(e.g. theauctionagent at EBay)5. Web spiders (collecting data to build indexesto used by a search engine, i.e. Google)A common classification scheme of agents isthe weak and strong notion of agency [32]. In the
weak notion of agency
, agents have their own will(
), they are able to interact with eachother (
social ability
), they respond to stimulus(
), and they take initiative (
).In the
strong notion of agency
the weak notions of agency are preserved, in addition agents can movearound (
), they are truthful (
), theydo what they’re told to do (
), and theywill perform in an optimal manner to achieve goals(
).Due to the fact that existing agents have more incommon with software than with intelligence, theywill be referred to as software agents or agents inthis context.
1.1 Terminology
Being a relatively new research field, agent-basedsoftware engineering currently has a set of closelyrelated terms used in research papers, I will thus tryto clarify and explain the terms and their relationsbelow.
 Agent-Oriented Programming
(AOP)[29,30] is seen as an improvement and extension of Object-Oriented Programming (OOP). Since the word“Programmingis attached, it means that bothconcepts are close to the programming language andimplementation level. The term “Agent-OrientedProgramming” was introduced by Shoham in 1993[28].First NTNU CSGSC, May 2001 www.csgsc.org
 Agent-Oriented Development 
(AOD) [8] is anextension of Object-Oriented Development (OOD).The word “Development” is sometimes interpretedas “Programming”, on the other hand it is frequentlyinterpreted to include the full development processthat covers the requirement specification and design,in addition to the programming itself.
Software Engineering with Agents
Agent- Based Software Engineering
Multi-agent Systems Engineering
(MaSE) [3,31] and
 Agent-Oriented Software Engineering
(AOSE)[22,20,35,15] are semantically equivalent terms, but
refers to a particular methodology and
seems to be the most widely used term. Thedifference between AOSE and AOD, is that AOSEalso covers issues such as re-use and maintenanceof the agent-system in addition to the developmentof the system itself. However, to be on the safe side,one should omit the use of the term AOD since itcan easily be misinterpreted as pointed out earlier(due to the different interpretations).The term
Agent-Based Computing
[16] can be ap-plied to describe all issues related to agent-orientedsoftware engineering, but it also covers issues re-garding
agents compute.
1.2 Scope and limitations
In this paper we will present a topical overview of recent advances of methodologies for developmentof agent-based systems. The focus is both ongeneral high-level methodologies and on morespecific design methodologies related to softwareengineering. This means that specialized agentmethodologies, e.g. to improve coordination, coop-eration, communication and artificial intelligencein agents and agent systems, are outside the scopeof this paper. Suggested readings that give goodoverviews of other aspects of the agent researchfield are presented in the work by Jennings et al.[11] and by Nwana et al. [27]. This paper is organized as follows: section 2describes aspect of Agent-Oriented Software Engi-neering, section 3 gives a description of high-levelmethodologies, section 4 describes design meth-ods inspired by well-known software engineeringmethods and standards (e.g. UML, componentsand design patterns), section 5 describes problems,methodologies and tools for agents in industrial con-text.
2 Agent-Oriented Software En-gineering
The main purposes of Agent-Oriented Software En-gineering are to create methodologies and tools thatenables inexpensive development and maintenanceof agent-based software. In addition, the softwareshould be flexible, easy-to-use, scalable [5] and of high quality. In other words quite similar to the re-search issues of other branches of software engineer-ing, e.g. object-oriented software engineering.
How are agents distinguished from objects?
Agent-oriented programming (AOP) can be seenas an extension of object-oriented programming(OOP), OOP on the other hand can be seen asa successor of structured programming [29,30]. In OOP the main entity is the object. An objectis a logical combination of data structures andtheir corresponding methods (functions). Objectsare successfully being used as abstractions for
entities (e.g. a house) in the real-world,and agents are regarded as a possible successorof objects since they can improve the abstractionsof 
entities. Agents are similar to objects,but they also support structures for representingmental components, i.e. beliefs and commitments.In addition, agents support high-level interaction(using agent-communication languages) betweenagents based on the “speech act” theory as opposedto ad-hoc messages frequently used between objects[22], examples of such languages are FIPA ACLand KQML [21].Another important difference between AOP andOOP is that objects are controlled from the outside(whitebox control), as opposed to agents that haveautonomous behavior which can’t be directly con-trollable from the outside (blackbox control). Inother words, agents have the right to say “no” [9]
Can agents solve all software problems?
Since this is a new and rapidly growing filed, there isa danger that researchers become
overly optimistic
regarding the abilities of agent-oriented softwareengineering.Wooldridge and Jennings [7,33] discuss the po- tential pitfalls of agent-oriented software engineer-ing. They have classified pitfalls in five groups: po-litical, conceptual, analysis and design, agent-level,and society-level pitfalls.
Political pitfalls
can occurif the concept of agents is oversold or sought appliedas a
universal solution.
Conceptual pitfalls
mayFirst NTNU CSGSC, May 2001 www.csgsc.org
occur if the developer forgets that agents are soft-ware, in fact multithreaded software.
Analysis and design pitfalls
may occur if the developer ignoresrelated technology, e.g. other software engineeringmethodologies.
Agent-level pitfalls
may occur if thedeveloper tries to use too much or too little artifi-cial intelligence in the agent-system. And finally,
society-level pitfalls
can occur if the developer seesagents everywhere or applies too few agents in theagent-system
The problem with hype
Being aware of the failing promises of the closelyrelated field of Artificial Intelligence in the 1980s,Jennings, a prominent researcher of the agent field,points out that the failure of keeping promises andbecoming an offer of media hype and then “slaugh-ter”, could perfectly well happen to the field of agentresearch [16].
3 High-level Methodologies
This section describes methodologies that provide atop-down and iterative approach towards modelingand developing agent-based systems.
3.1 The Gaia Methodology
Wooldridge, Jennings and Kinny [10,8] present the Gaia methodology for agent-oriented analysisand design. Gaia is a general methodology thatsupports both the micro-level (agent structure) andmacro-level (agent society and organization struc-ture) of agent development, it is however no “silverbullet” approach since it requires that inter-agentrelationships (organization) and agent abilities arestatic at run-time. The motivation behind Gaia isthat existing methodologies fail to represent theautonomous and problem-solving nature of agents;they also fail to model agents’ ways of performinginteractions and creating organizations. UsingGaia, software designers can systematically developan implementation-ready design based on systemrequirements.The first step in the Gaia
process is tofind the
in the system, and the second is tomodel
between the roles found. Rolesconsist of four attributes: responsibilites, permis-sions, activities and protocols.
are of two types:
liveness properties
- the role has to addsomething good to the system, and
safety properties
- prevent and disallow that something bad happensto the system.
represents what the roleis allowed to do, in particular, which informationit is allowed to access.
are tasks that arole performs without interacting with other roles.
are the specific patterns of interaction,e.g. a seller role can support different auctionprotocols, e.g. “English auction”. Gaia has formaloperators and templates for representing roles andtheir belonging attributes, it also has schemas thatcan be used for the representation of interactions.In the Gaia
process, the first step is to maproles into
agent types
, and then to create the rightnumber of 
agent instances
of each type. The secondstep is to determine the
services model
neededto fulfill a role in one or several agents, and thefinal step to is create the
acquaintance model
forthe representation of communication between theagents.Due to the mentioned restrictions of Gaia, it isof less value in the open and unpredictable domainof Internet applications, on the other hand it hasbeen proven as a good approach for developingclosed domain agent-systems. As a result of thedomain restrictions of the Gaia method, Zambonelli,Jennings et al. [35] proposes some extensions andimprovements of it with the purpose of supportingdevelopment of Internet applications.Other sources for the discussion of micro andmacro aspects of agent modeling include work byChaib-draa [2]
3.2 The Multiagent Systems Engineer-ing Methodology
Wood and DeLoach [3,31] suggest the Multiagent Systems Engineering Methodology (MaSE). MaSEis similar to Gaia with respect to generality and theapplication domain supported, but in addition MaSEgoes further regarding support for automatic codecreation through the MaSE tool. The motivationbehind MaSE is the current lack of proven method-ology and industrial-strength toolkits for creatingagent-based systems. The goal of MaSE is to leadthe designer from the initial system specification tothe implemented agent system. Domain restrictionsof MaSE is similar to those of Gaia’s, but in additionit requires that agent-interactions are one-to-one andnot multicast.The MaSE methodology are divided into sevensections (phases) in a logical pipeline.
, the first phase, transforms the initial sys-tem specification into a structured hierarchy of sys-tem goals. This is done by first identifying goalsbased on the initial system specification’s require-ments, and then ordering the goals according to im-First NTNU CSGSC, May 2001 www.csgsc.org

Activity (17)

You've already reviewed this. Edit your review.
1 hundred reads
1 thousand reads
Saleha Masood liked this
Fabi Ralison liked this
Sagrika Chanday liked this
Kalyan Vaka liked this
Amit Kapoor liked this
doctorjeep liked this
Kong Nattapon liked this
prisuk liked this

You're Reading a Free Preview

/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->