Agent-Based Software Engineering
نویسنده
چکیده
It has previously been claimed that agent technologies facilitate software development by virtue of their high-level abstractions for interactions. We address a more specific characterization and utility. We believe that it is important to distinguish agent technologies from other software technologies by virtue of a set of unique software characteristics. This is in contrast to much in the literature that concentrates on high-level characteristics that could be implemented with a variety of software techniques. Agent-based software engineering (ABSE), for at least an important class of agents and applications, can be characterized by both model and inner/outer language components. Our experience in developing applications based on longterm asynchronous exchange of agent messages, similar to typical email usage, leads us to believe these unique characteristics facilitate useful software development practices. The utility derives from a stratification of change among the components, ease of collaborative change and debugging even during runtime due to asynchronous text parsing-based message exchange, and reuse of the outer language as well as generic agents as a programming environment. 1 Agent Development Characteristics Jennings and Wooldridge have described Agent-Oriented Software Engineering (AOSE)[19] [7]. AOSE effectiveness claims are based upon three strategies for addressing complex systems: decomposition, abstraction, and organization and that the “agent-oriented mindset” gives one an advantage in using these strategies. That agents have objectives gives one a clear way to decompose the problem into agents. That agent systems work largely by emergent behavior and handle errors gracefully reduces the need for detailed specifications, since not all interactions need be specified in advance, and allows more abstraction to be used in system building. And finally, agent systems are naturally hierarchical organizations themselves. Indeed, it is important to note that agent identity is a fundamental component of all agent languages and methodologies for interactions. We agree with these points. In particular, the idea of engineering a system so that the correct emergent behavior results is the most critical idea in agent software engineering. We further agree with the notions introduced by Huhns[5] that one aspect of emergent 1 A shorter version of this paper first appeared in Proc. PAAM 2000, Manchester, April, 2000. behavior is having software modules being able to model themselves and other modules, which leads to modules that are able to attempt different methods of accomplishing a task based upon runtime data and these models, which in turn leads to flexibility and robustness without the necessity of the programmer having correctly considering every possibility. The fundamental idea here is that the programmer focuses on the types of interactions possible without specifying all possibilities in advance and one technique for doing this is modeling interaction behaviors. These notions are important and fundamental. This paper is also important because it points out that software engineering seems to have reached a plateau of results and has been stuck there for some time. Thus the agents approach is potentially very important. However, we find the AOSE explanations lacking in the detail that would allow a software engineer to decide easily whether an AOSE approach was even being used or not. We describe Agent-Based Software Engineering (ABSE) here as a refinement of some aspects of AOSE, based upon our practical experience in agent building. We do not, though, attempt to describe how to practice ABSE. Our goal is rather show that ABSE could be distinguished objectively from other software techniques, which has not previously been done. This is a topic that is frequently addressed with respect to languages. In fact, in the abstract of a recent paper on agent languages, M. Wooldridge said his intent was to develop “a semantics where conformance (or otherwise) to the semantics could be determined by the independent observer” [20]. Whether something is an agent or not, and whether a software engineering technology is agent-based or not, should also be verifiable by independent observers. Further, we attempt to persuade the user that ABSE could be useful in practice and why, apart from the general potential of emergent behavior. We emphasize some particular aspects of agent models and languages that distinguish agent system development from other software technologies and make it useful. Our intent is to help bridge the gap between agent technology and software engineering. 1.1 Semantics-based Agenthood Describing agent development requires distinguishing agents from other kinds of software. Unfortunately, definitions of agents most often differentiate the technology from other software technologies by anthromophising agents: ascribing human cognitive traits such as environmental awareness, autonomy, and intelligence. The AOSE view has its foundations in Yoav Shoham’s “Agent-Oriented Programming (AOP)”[14] in which it is advocated that agents be directly programmed in terms of the mentalistic, intentional notions of agent theories. Similarly, Rao and Georgeff developed the “beliefs”, “desires”, and “intensions” (BDI)[13] theory of agenthood and developed both formalisms and programming technologies based on them. We call this a semantic view because it usually requires ascribing some meaning to the operation of each agent. And while this early work was formal with distinct software technologies, it is clear that the difficult objectives of creating a programming environment were not completely reached. The programming languages and compilers generated were not generally useful. It has been critiqued as unhelpful by people attempting to use the technology[10]. But more important, this formal work has very limited scope in agent building, much as formal software methods in general have. Since useful languages and compilers were not forthcoming, proponents of agent technologies spoke more of the general characteristics of agents and how that influenced software practices. These informal descriptions of agents as “autonomous” and “proactive” are useful. Courses on agents, such as “Intelligent Agents” [3], cover much important technical material. For instance, if one intends that agents follow goals without a lot of specific instructions, then one has to turn to the most sophisticated learning, planning, nonmonotonic reasoning, and distributed constraint satisfaction techniques that have been developed by the Artificial Intelligence community. This is in fact the most important aspect of agents per se: that they perform such sophisticated reasoning, especially in collaboration with each other so that the desired behavior is emergent rather than specifically programmed. But the less formal AOSE recent work does not describe mentalistic, intentional notions of agenthood in a way that would permit an objective observer to distinguish agents from other software technologies, at least not without a lot of persuasive discussion in each case. Shoham’s definition of an agent as “an entity whose state is viewed as consisting of mental components such as beliefs, capabilities, choices, and commitments”, and the similar BDI descriptions, are of little help in objectively defining agents apart from their specific formalisms. And it does not help to focus on one narrow theory of agents, such as BDI, as this tends not to generalize to a software engineering practice or methodology. The informal interpretation of mentalistic agent theories is not sufficient to distinguish agent technology from other software technologies, much less provide practical specific techniques for agent building that would constitute software engineering. It is at least arguable that, say, object-oriented programming, could be used to implement non-monotonic reasoning, for instance, as well as any other. More to the point, how would one know if one is using agent technology as a software technique? The distinguishing factor cannot be just that the program can be interpreted as exhibiting a kind of autonomy using various sophisticated algorithms. This view of agents says nothing about programming practice, much less software engineering. However, consider the use of AI techniques in building agents. At one time, “what is AI?” was an oft-asked question. The answer eventually turned out to be that AI was the use of AI techniques. This was a seemingly circular definition but it came to be accepted because they was a definite set of techniques that was developed by researchers and departments explicitly identified as “AI”. The same idea can be used in the case of agents. It may be that emergent behavior system design is in its infancy, but based on experience, we can identify several general but distinguishing characteristics of agent software technology. 1.2 Agent Theory Modeling The BDI theory is portrayed primarily in AOSE as a means of guiding agent software development. But BDI is only one type of agent semantics and to consider only it misses the abstraction of imposing any agent theory during development. This is especially important when one is converting legacy code into an agent capable of working with other agents to carry out a distributed computation. What one does in this case is to interpret the workings of the legacy code as an instance of a BDI theory that is then used as the common model upon which agent interactions are based, and which is thus the basis for the integration of the software components. The Agent-Objection-Relationship model of [17] (similar to other work reported in this volume) is a clear example of an agent model, based more on entity-relationship models than on BDI, used for application-building. In our set of engineering applications, the ProcessLink framework used the Redux theory of design to characterize the acts of the engineering agents[12]. The Redux theory is quite different from the BDI theory and not at all anthromorphic. However, both are used in modeling: translation from legacy code into agent interactions. The case is not that different with agents that are built “from scratch” rather than being legacy code conversions. One has a computation in mind and is then is careful to code it so that it ultimately conforms to the agent theory, whether it be BDI or Redux. Another example is Tate’s O-Plan[16], which is similar to Redux in many respects, which was used in agents with the “Act” formalism[9].
منابع مشابه
Integrating Agent-oriented Enterprise Software Engineering into Software Engineering Curriculum
1 Gilda Pour, Department of Computer Engineering, San Jose State University, San Jose, CA 95192-0180, U.S.A. [email protected] Abstract – Agent-oriented enterprise software engineering (AOESE) has emerged as a promising approach to developing Web-based enterprise software systems. AOESE is based on developing and evolving enterprise software systems from selected pre-engineered and pre-tested soft...
متن کاملA Tutorial on Agent Based Software Engineering
Agent oriented software development is one of the most contributions to the field of software engineering. The method of analysis and design is not so mature as structured analysis and design and object oriented analysis and design. In this case, robust and easyto-use methodologies and tools have to be developed for agent based software engineering. As we know, Analysis is an important phase in...
متن کاملEngineering Agent-Based Social Simulations
This special section on "Engineering Agent-Based Social Simulations" aims to represent the current state of the art in using Software Engineering (SE) methods in ABSS. It includes a mixture of theoretically oriented papers that describe frameworks, notations and methods adapted from SE and practice-oriented papers that demonstrate the application of SE methods in real world ABSS projects.
متن کاملEngineering Agent-Based Social Simulations
This special section on "Engineering Agent-Based Social Simulations" aims to represent the current state of the art in using Software Engineering (SE) methods in ABSS. It includes a mixture of theoretically oriented papers that describe frameworks, notations and methods adapted from SE and practice-oriented papers that demonstrate the application of SE methods in real world ABSS projects.
متن کاملLessons Learned from Software Engineering Multi-Agent Systems
The popularity of agent-based systems has increased rapidly in recent years because agents bring intelligence, reasoning and autonomy to software systems. A number of software engineering frameworks and/or methodologies have been proposed to support multi-agent systems construction. Traditionally, the development of AI systems in general and intelligent agent-based systems in particular had ado...
متن کاملAgents and Software Engineering
Software engineers continually strive to develop tools and techniques to manage the complexity that is inherent in software systems. In this article, we argue that intelligent agents and agent-based systems are just such tools. Following a discussion on the subject of what makes software complex, we introduce intelligent agents as software structures capable of making “rational decisions”. Such...
متن کامل