Despite the effort of many researchers in the area of multi-agent systems (MAS) for designing and programming agents, a few years ago the research community began to take into account that common features among different MAS exists. Based on these common features, several tools have tackled the problem of agent development on specific application domains or specific types of agents. As a consequence, their scope is restricted to a subset of the huge application domain of MAS. In this paper we propose a generic infrastructure for programming agents whose name is Brainstorm J. The infrastructure has been implemented as an object oriented framework. As a consequence, our approach supports a broader scope of MAS applications than previous efforts, being flexible and reusable.
JAFIMA (Java Framework for Intelligent and Mobile Agents) @cite_12 takes a different approach from the other tools: it is primarily targeted at expert developers who want to develop agents from scratch based on the abstract classes provided, so the programming effort is greater than in the other tools. The weakest point of JAFIMA is its rule-based mechanism for defining agents' behavior. This mechanism does not support complex behaviors such as on-line planning or learning. Moreover, the abstractions for representing mental states lack flexibility and services for manipulating symbolic data.
@cite_12
2061692729 2118300983 2107370049 1544271477
Almost all agent development to date has been “homegrown” [4] and done from scratch, independently, byeach development team. This has led to the followingproblems:• Lack of an agreed definition: Agents built bydifferent teams have different capabilities.• Duplication of effort: There has been little reuse ofagent architectures, designs, or components.• Inability to satisfy industrial strengthrequirements: Agents must integrate with existingsoftware and computer infrastructure. They must alsoaddress security and scaling concerns.Agents are complex and ambitious software systems thatwill be entrusted with critical applications. As such,agent based systems must be engineered with validsoftware engineering principles and not constructed in anad hoc fashion.Agent systems must have a strong foundation based onmasterful software patterns. Software patterns arose outof Alexander’s [2] work in architecture and urbanplanning. Many urban plans and architectures aregrandiose and ill-fated. Overly ambitious agent basedsystems built in an ad hoc fashion risk the same fate.They may never be built, or, due to their fragile nature,they may be built and either never used or used once andthen abandoned. A software pattern is a recurringproblem and solution; it may address conceptual,architectural or design problems.A pattern is described in a set format to ease itsdissemination. The format states the problem addressedby the pattern and the forces acting on it. There is also acontext that must be present for the pattern to be valid, astatement of the solution, and any known uses. Thefollowing sections summarize some key patterns of agentbased systems; for brevity, many of the patterns arepresented in an abbreviated “patlet” form. When kn ownuses are not listed for an individual pattern, it means thatthe pattern has arisen from the JAFIMA activity. Thepatterns presented in this paper represent progress towarda pattern language or living methodology for intelligentand mobile agents. We describe JastAdd, a Java-based system for compiler construction. JastAdd is centered around an object-oriented representation of the abstract syntax tree where reference variables can be used to link together different parts of the tree. JastAdd supports the combination of declarative techniques (using Reference Attributed Grammars) and imperative techniques (using ordinary Java code) in implementing the compiler. The behavior can be modularized into different aspects, e.g. name analysis, type checking, code generation, etc., that are woven together into classes using aspect-oriented programming techniques, providing a safer and more powerful alternative to the Visitor pattern. The JastAdd system is independent of the underlying parsing technology and supports any noncircular dependencies between computations, thereby allowing general multi-pass compilation. The attribute evaluator (optimal recursive evaluation) is implemented very conveniently using Java classes, interfaces, and virtual methods. Java 2 has a security architecture that protects systems from unauthorized access by mobile or statically configured code. The problem is in manually determining the set of security access rights required to execute a library or application. The commonly used strategy is to execute the code, note authorization failures, allocate additional access rights, and test again. This process iterates until the code successfully runs for the test cases in hand. Test cases usually do not cover all paths through the code, so failures can occur in deployed systems. Conversely, a broad set of access rights is allocated to the code to prevent authorization failures from occurring. However, this often leads to a violation of the "Principle of Least Privilege"This paper presents a technique for computing the access rights requirements by using a context sensitive, flow sensitive, interprocedural data flow analysis. By using this analysis, we compute at each program point the set of access rights required by the code. We model features such as multi-threading, implicitly defined security policies, the semantics of the Permission.implies method and generation of a security policy description. We implemented the algorithms and present the results of our analysis on a set of programs. While the analysis techniques described in this paper are in the context of Java code, the basic techniques are applicable to access rights analysis issues in non-Java-based systems. The ability to effectively debug agent-oriented applications is vital if agent technologies are to become adopted as a viable alternative for complex systems development. Recent advances in the area have focussed on the provision of support for debugging agent interaction where tools have been provided that allow developers to analyse and debug the messages that are passed between agents. One potential approach for constructing agent-oriented applications is through the use of agent programming languages. Such languages employ mental notions such as beliefs, goals, commitments, and intentions to facilitate the construction of agent programs that specify the high-level behaviour of the agent. This paper describes how debugging has been supported for one such language, namely the Agent Factory Agent Programming Language (AFAPL).