Information Technology Reference
In-Depth Information
language to their environment, whilst in Jason, the students were required to develop
an Environment class that played a similar role. While such diversity reflects differing
approaches to building multi-agent systems, it also acts as a barrier to entry for the
wider software engineering community as it makes direct comparison and evaluation of
AOP languages more difficult. As an aside, informal feedback from the students indi-
cated no clear consensus as to which language was preferred, as some students preferred
AFAPL2 whilst others preferred Jason.
With these criticisms in mind, recent work on the Agent Factory framework [4] has
focused on supporting heterogeneous logic-based agent architectures with the goal of
providing a common toolset that can be adapted to different agent models, ranging from
custom Java agents, through to reactive agent architectures and finally to high-level
agent programming languages. Whilst primarily these components have been designed
to support languages based on first-order logic. Non logic based languages can also be
developed using the framework, as long as the language is compatible with the FIPA
based Agent Factory Runtime Environment.
Specifically we have redeveloped the AFAPL2 logic framework in order to make it
modular and extensible, this was required as it was previously limited to only first or-
der structures. Additionally we have decoupled language syntax and underlying logic
structure to allow the component be used in different languages easily. A new planing
mechanism has been developed based on the intention stack concept within AgentS-
peak(L). Furthermore we have reimagined the environment interface to allow aggrega-
tion of relates sensors and actions in the form of modules.
Agent Factory is by no means the only framework or platform that supports heteroge-
neous multi-agent architectures. Platforms such as JADE [1] provide essential runtime
infrastructure such as agent discovery, inter-agent communication, and fault tolerance;
through Java APIs, these services are made available to both native Java agents and
high-level AOP language interpreters. Though such platforms often provide low-level
development tools for deployment and debugging, they typically offer no direct support
for high-level AOP languages.
Language-independent frameworks for high-level AOP languages have been the sub-
ject of relatively little research. Dennis et al developed an extensible model checker for
Beliefs-Desires-Intentions (BDI) agent programs, by distilling the common features of
several AOP languages to create an intermediate language called Agent Infrastructure
Layer (AIL) [7], and an AIL verifier called Agent Java PathFinder [6]. In this approach,
the developer of a new AOP language
X
can obtain a model-checking tool for
X
by
simply implementing an
X
-to-AIL compiler; AIL makes no assumptions regarding the
source language's interpreter cycle, and has clear semantics, making this task relatively
easy. We regard this work as complimentary to our own. Rather than modelling the
commonalities of existing languages, Agent Factory aims to provide greater flexibility,
in the form of tool and platform components that can be reused to quickly implement
and explore novel agent programming language features.
Section 2 presents the various sub-frameworks that make up the CLF. Following
this, section 3 describes the process of creating a language using the CLF, and section 4
describes the evaluation of the framework. Finally, section 5 presents some concluding
remarks.
