scispace - formally typeset

Book ChapterDOI

Reflecting on Agent Programming with AgentSpeak(L)

26 Oct 2015-pp 351-366

TL;DR: This paper attempts to build a bridge between the concepts underpinning mainstream languages and those underpinning AOP through a conceptual mapping that is subsequently used to drive the design of a new programming language entitled ASTRA, which has been evaluated by a group of experienced software engineers attending an Agent-Oriented Software Engineering Masters course.
Abstract: Agent-Oriented Programming (AOP) researchers have successfully developed a range of agent programming languages that bridge the gap between theory and practice. Unfortunately, despite the in-community success of these languages, they have proven less compelling to the wider software engineering community. One of the main problems facing AOP language developers is the need to bridge the cognitive gap that exists between the concepts underpinning mainstream languages and those underpinning AOP. In this paper, we attempt to build such a bridge through a conceptual mapping that we subsequently use to drive the design of a new programming language entitled ASTRA, which has been evaluated by a group of experienced software engineers attending an Agent-Oriented Software Engineering Masters course.

Content maybe subject to copyright    Report

Provided by the author(s) and University College Dublin Library in accordance with publisher
policies. Please cite the published version when available.
Title Reflecting on Agent Programming with AgentSpeak(L)
Authors(s) Collier, Rem; Russell, Sean E.; Lillis, David
Publication date 2015-10-30
Publication information Chen, Q., Torroni, P., Villata, S., Hsu, J. and Omincini, A. (eds.). PRIMA 2015: Principles
and Practice of Multi-Agent Systems, 18th International Conference, Bertinoro, Italy, 26-30
October 2015, Proceedings
Conference details 18th International Conference, Bertinoro, Italy, 26-30 October 2015
Series Lecture Notes in Computer Science
Publisher Springer
Item record/more information http://hdl.handle.net/10197/8130
Publisher's statement The final publication is available at Springer via
http://dx.doi.org/10.1007/978-3-319-25524-8.
Publisher's version (DOI) 10.1007/978-3-319-25524-8
Downloaded 2022-08-09T18:00:04Z
The UCD community has made this article openly available. Please share how this access
benefits you. Your story matters! (@ucd_oa)
© Some rights reserved. For more information, please see the item record link above.

Reflecting on Agent Programming with
AgentSpeak(L)
Rem W. Collier, Se´an Russell, and David Lillis
School of Computer Science,
University College Dublin, Ireland
{rem.collier,sean.russell,david.lillis}@ucd.ie
Abstract. Agent-Oriented Programming (AOP) researchers have suc-
cessfully developed a range of agent programming languages that bridge
the gap between theory and practice. Unfortunately, despite the in-
community success of these languages, they have proven less compelling
to the wider software engineering community. One of the main problems
facing AOP language developers is the need to bridge the cognitive gap
that exists between the concepts underpinning mainstream languages
and those underpinning AOP. In this paper, we attempt to build such a
bridge through a conceptual mapping that we subsequently use to drive
the design of a new programming language entitled ASTRA, which has
been evaluated by a group of experienced software engineers attending
an Agent-Oriented Software Engineering Masters course.
Keywords: Agent-Oriented Programming, AgentSpeak(L), ASTRA
1 Introduction
The Agent-Oriented Programming (AOP) paradigm is nearly 25 years old. Since
its inception, a number of established AOP languages have emerged, with the
most prominent being: 2/3APL [1, 2], GOAL [3] and Jason [4]. However, while
these languages have received much critical success within the AOP community,
they have been less well received by the wider software engineering community.
A useful barometer for the view of this wider community has been the stu-
dents enrolled on an Agent-Oriented Software Engineering (AOSE) module that
is part of a Masters in Advanced Software Engineering offered at University Col-
lege Dublin since 2005. Students on this course typically have 5 or more years
of industrial software engineering experience and are senior software engineers
in their respective companies. During the course, the students are exposed to
an AgentSpeak(L)-based language, which has been one of AF-AgentSpeak [5],
Jason [4], and our most recent agent-programming language, ASTRA [6].
Each year, the students have been asked to provide informal feedback on the
AOP language(s) used and to comment on whether they would consider using
such a language in a live industry application. The common response has been
“no”, with typical criticisms being the lack of tool support and the perceived
learning curve required to master an AOP language.

2 Collier, Russell and Lillis
The lack of tool support seems strange given the existence of mind inspec-
tors [7], advanced debugging techniques [8, 9], and a range of analytical tools [10,
11]. However, after delving deeper, it became apparent to us that the criticisms
were directed more closely towards the quality of the Integrated Development
Environments (IDEs) provided and their limitations in terms of practical fea-
tures such as code completion, code navigation and formatting support. Over
the years, it has become apparent that developers become uneasy when stripped
of their traditional supports and that this engenders a feeling that the languages
are not production quality.
Conversely, the perceived learning curve is less unexpected. AOP, with its
origins in Distributed Artificial Intelligence, is underpinned by a quite different
set of concepts to mainstream software engineering, where there is a clear evolu-
tion from procedural programming languages to Object-Oriented Programming
(OOP) languages. Individuals attempting to learn about AOP are confronted
with a range of concepts - beliefs, desires and intentions; speech acts; plans -
that bear little relation to mainstream programming concepts. For many, this
can act as a significant barrier to learning how to program in an AOP language.
Perhaps the most common explanation of the relationship between AOP
and OOP is the comparison table presented in [12]. This table presents a very
high-level view of AOP and OOP that treats AOP as a specialisation of OOP.
Unfortunately, it provides little practical detail. For example, how does the state
of an object relate to the state of an agent? is there any correlation between how
behaviours are specified in OOP and how they are specified in agents? when and
how will a behaviour be executed?
Answering these questions requires a more detailed comparison of AOP and
OOP. However, when attempting to create a deeper comparison, it quickly be-
comes evident that it is not possible. The main reason for this is that AOP, unlike
OOP, does not promote or enforce a consistent conceptual model (i.e. a standard
view of state, methods, messages, etc.). Instead, different languages can, and
are, based around quite different approaches. For example, AgentSpeak(L) style
languages are essentially event-driven languages. They define context-sensitive
event handlers that map events to partial plans. Conversely, GOAL is, at its
heart, an action selection language where rules identify the context in which
each action should be executed. The consequence of this diversity is that it is
more appropriate to compare specific styles of AOP language with OOP rather
than trying to over-generalise.
In this paper, we focus on understanding the relationship between AgentS-
peak(L) and OOP with the goal of trying to reduce the perceived cognitive gap.
Our approach is to start by identifying a mapping between AgentSpeak(L) and
OOP concepts in Section 2, which we then reflect on in Section 3. The purpose
of the reflection is to try to understand how to improve the design of AgentS-
peak(L) to better support developers wishing to learn the language. Following
on from this, we introduce a new member of the AgentSpeak(L) family called
ASTRA that has been designed in response to the findings of the previous sec-
tion. Full details of ASTRA are not provided in this paper. Instead, we focus on

Reflecting on Agent Programming with AgentSpeak(L) 3
only the most pertinent features. Finally, in Section 4 we present the relevant
results of a wider survey carried out on the most recent class of the M.Sc. in
Advanced Software Engineering.
2 Relating AgentSpeak(L) to OOP
AgentSpeak(L) can be prosaically described as an event-driven language where
event handlers are fired based on both the triggering event and some context.
Events, which are either external (environment-based) or internal (goal-based),
are generated and added to an event queue. Events are then removed from this
queue and matched to a rule which is then executed. The matching process
checks both that the rule applies to the event and that the rule can be executed
based on a rule context that defines valid program states in which the rule may
be applied.
More commonly, the event handlers are known as plan rules; the program
state is modeled as a set of beliefs, that are realized as atomic predicate logic
formulae; the events are also modeled as atomic predicate formulae (with some
additional modifiers); and the execution of plan rules is achieved through creation
and manipulation of intentions. Finally, external events are generated through
changes to the agent’s state (i.e. the adoption or retraction of a belief), and
internal events are generated through the declaration of goals.
It follows then, that an AgentSpeak(L) agent consists of an event queue, a set
of beliefs (state), a set of plan rules (event handlers), and a set of intentions that
are used to represent the execution of plan rules. Given that AOP is commonly
viewed as a specialization of OOP, and that agents are a special type of object,
the following outlines how AgentSpeak(L) concepts relate to OOP concepts from
the perspective of an OOP developer:
Beliefs are equivalent to fields As indicated above, beliefs form the state of
an agent. In OOP, state is defined in terms of a set of fields that hold values
(or object references). If we consider a field, such as int value; this could
be modeled as a belief value(0). Here, the value 0 is chosen as it is the
default value for integer fields in many OOP languages. To be fully precise,
beliefs and fields are not the same. Whereas fields can be modeled using
beliefs, beliefs actually encompass more than this, including environment
information, global variables, etc.
Plan Rules are equivalent to methods A plan rule associates a plan with
a triggering event and a context. Plans define behaviours and are basically
blocks of procedural code that are executed whenever a matching event is
processed and the rules context is satisfied. In OOP languages, procedural
code is defined within methods and is executed whenever the method signa-
ture is matched to a message that has been received by the object. Accord-
ingly, the AgentSpeak(L) equivalent of a method signature is the triggering
event (specifically the identifier and the number of arguments). The con-
text has no real equivalent in OOP, however, it can be viewed as providing

4 Collier, Russell and Lillis
a form of method overloading based on state (i.e. when there are multiple
rules matching a given event, the context is used to identify which of the
rules should be executed).
Goals are equivalent to method calls Goals generate events. The are then
matched to rules, which are subsequently executed. Method calls generate
messages that are matched to methods that are executed. Typically, goals
are declared from within a plan. The result is that the plan component of
the selected rule is pushed onto the program (intention) stack and executed.
Events are equivalent to messages Within AgentSpeak(L), events play a
similar role to messages in OOP. Events are used to trigger plan rules in
the same way that, for OOP languages, messages are used to invoke meth-
ods. This can be somewhat confusing because “message” is also the term
used for communication between agents, however this is not the focus here.
In OOP, the set of messages that can be handled by an object is known as the
interface of the object. This set of messages corresponds to the signatures
of the methods that are defined in the objects implementing class(es). Given
our view of events being equivalent to OOP messages, then in AgentSpeak(L)
the interface of an agent is the set of events that it can handle.
Intentions are equivalent to threads Intentions represent the plans that the
agent has selected based upon the matching of events to plan rules. The
AgentSpeak(L) interpreter processes the intentions by executing the instruc-
tions contained within the plan. In cases where the instruction is a sub-goal,
this results in an additional plan being added to the intention which must be
executed before the next instruction in the initial plan can be executed. In
most programming languages, this activity is modelled by the program (call)
stack. Intentions are simply the AgentSpeak(L) equivalent of this. Given that
an agent can have multiple concurrent intentions whose execution is inter-
leaved, it is natural to view an intention as being the equivalent of a thread.
The above mappings are intended to relate the concepts of AgentSpeak(L) to
those present in OOP. The objective behind this is to try to reduce the cognitive
gap faced by individuals who know OOP and wish to learn an AOP language.
The benefit of doing this is that someone who is proficient in OOP can use these
mappings as a starting point for their study of the language.
3 Exploring the Implications
The mapping developed in Section 2 is not only potentially useful to developers
aiming to learn AgentSpeak(L), but it is also useful from a language developer’s
perspective as it raises questions about the set of features that may be appropri-
ate for AgentSpeak(L)-style languages. In this section, we explore some of the
consequences of adopting the above mapping.
3.1 Beliefs are like fields
Understanding the role of beliefs in AOP languages can be one of the most
challenging concepts to grasp. Certainly, at a high-level it is clear that beliefs

Citations
More filters

Journal ArticleDOI
TL;DR: A comprehensive view of logic-based technologies for agents and multi-agent systems is provided by making them the subject of a systematic literature review (SLR) and the resulting technologies are discussed and evaluated from two different perspectives.
Abstract: Precisely when the success of artificial intelligence (AI) sub-symbolic techniques makes them be identified with the whole AI by many non-computer-scientists and non-technical media, symbolic approaches are getting more and more attention as those that could make AI amenable to human understanding. Given the recurring cycles in the AI history, we expect that a revamp of technologies often tagged as “classical AI”—in particular, logic-based ones—will take place in the next few years. On the other hand, agents and multi-agent systems (MAS) have been at the core of the design of intelligent systems since their very beginning, and their long-term connection with logic-based technologies, which characterised their early days, might open new ways to engineer explainable intelligent systems. This is why understanding the current status of logic-based technologies for MAS is nowadays of paramount importance. Accordingly, this paper aims at providing a comprehensive view of those technologies by making them the subject of a systematic literature review (SLR). The resulting technologies are discussed and evaluated from two different perspectives: the MAS and the logic-based ones.

26 citations


Journal ArticleDOI
Viviana Mascardi1, Danny Weyns2, Alessandro Ricci3, Clara Benac Earle4  +26 moreInstitutions (18)
TL;DR: This paper reports on the results of the 6th International Workshop on Engineering Multi-Agent Systems (EMAS 2018), where participants discussed the issues above focusing on the state of affairs and the road ahead for researchers and engineers in this area.
Abstract: The continuous integration of software-intensive systems together with the ever-increasing computing power offer a breeding ground for intelligent agents and multi-agent systems (MAS) more than ever before Over the past two decades, a wide variety of languages, models, techniques and methodologies have been proposed to engineer agents and MAS Despite this substantial body of knowledge and expertise, the systematic engineering of large-scale and open MAS still poses many challenges Researchers and engineers still face fundamental questions regarding theories, architectures, languages, processes, and platforms for designing, implementing, running, maintaining, and evolving MAS This paper reports on the results of the 6th International Workshop on Engineering Multi-Agent Systems (EMAS 2018, 14th-15th of July, 2018, Stockholm, Sweden), where participants discussed the issues above focusing on the state of affairs and the road ahead for researchers and engineers in this area

26 citations


Cites methods from "Reflecting on Agent Programming wit..."

  • ...AgentSpeak(ER) has been implemented and experimentally evaluated on top of the ASTRA [13] platform and an implementation in Jason is under way....

    [...]


Journal ArticleDOI
01 Oct 2020
TL;DR: It is argued that the unique strengths of BDI agent languages provide an ideal framework for integrating the wide range of AI capabilities necessary for progress towards the next-generation of intelligent systems.
Abstract: It is claimed that, in the nascent ‘Cognitive Era’, intelligent systems will be trained using machine learning techniques rather than programmed by software developers. A contrary point of view argues that machine learning has limitations, and, taken in isolation, cannot form the basis of autonomous systems capable of intelligent behaviour in complex environments. In this paper, we explore the contributions that agent-oriented programming can make to the development of future intelligent systems. We briefly review the state of the art in agent programming, focussing particularly on BDI-based agent programming languages, and discuss previous work on integrating AI techniques (including machine learning) in agent-oriented programming. We argue that the unique strengths of BDI agent languages provide an ideal framework for integrating the wide range of AI capabilities necessary for progress towards the next-generation of intelligent systems. We identify a range of possible approaches to integrating AI into a BDI agent architecture. Some of these approaches, e.g., ‘AI as a service’, exploit immediate synergies between rapidly maturing AI techniques and agent programming, while others, e.g., ‘AI embedded into agents’ raise more fundamental research questions, and we sketch a programme of research directed towards identifying the most appropriate ways of integrating AI capabilities into agent programs.

12 citations


Cites background or methods from "Reflecting on Agent Programming wit..."

  • ...Although it was an abstract language (initially) lacking an implementation, AgentSpeak(L) was influential in the design of many other languages and platforms, notably Jason [18] and ASTRA [37], as well as further work on abstract BDI programming, in particular CAN [155]....

    [...]

  • ...Another platform based on AgentSpeak is ASTRA 16 [37]....

    [...]


Proceedings ArticleDOI
13 May 2019
TL;DR: A new approach to building MAS known as Multi-Agent MicroServices (MAMS) is introduced, illustrated through a worked example of a Vickrey Auction implemented as a microservice.
Abstract: This paper explores the intersection between microservices and Multi-Agent Systems (MAS), introducing the notion of a new approach to building MAS known as Multi-Agent MicroServices (MAMS). Our approach is illustrated through a worked example of a Vickrey Auction implemented as a microservice.

10 citations


Cites background or methods from "Reflecting on Agent Programming wit..."

  • ...ASTRA was used because it offers a closer integration with Java than many other AOP languages [8] as it exposes object references to the logical layer of the agent....

    [...]

  • ...Figure 2 contains a snippet of ASTRA code that relates to steps B and C above....

    [...]

  • ...Traditionally, ASTRA has been supported through a customEclipse plugin that integrateswith the standard Eclipse build process....

    [...]

  • ...To send messages, we implement a custom ASTRA Message Service....

    [...]

  • ...To remedy this, we have restructured ASTRA into a set of Maven5 artifacts....

    [...]


Journal ArticleDOI
TL;DR: An extension of the agent-oriented domain-specific language ALAS to support Distributed Non-Axiomatic Reasoning is presented, to allow programmers to develop intelligent agents easier by using domain specific constructs.
Abstract: This paper presents an extension of the agent-oriented domain-specific language ALAS to support Distributed Non-Axiomatic Reasoning. ALAS is intended for the development of specific kind of intelligent agents. It is designed to support the Siebog Multi-Agent System (MAS) and implementation of the Siebog intelligent agents. Siebog is a distributed MAS based on the modern web and enterprise standards. Siebog offers support to reasoning based on the Distributed Non-Axiomatic Reasoning System (DNARS). DNARS is a reasoning system based on the Non-Axiomatic Logic (NAL). So far, DNARS-enabled agents could be written only in Java programming language. To solve the problem of interoperability and agent mobility within Siebog platforms, the ALAS language has been developed. The goal of such language is to allow programmers to develop intelligent agents easier by using domain specific constructs. The conversion process of ALAS code to Java code is also described in this paper.

10 citations


Cites methods from "Reflecting on Agent Programming wit..."

  • ...ASTRA constructs are mapped to methods, flow-control components, loops etc. (Collier, Russell, and Lillis 2015a; Collier, Russell, and Lillis 2015b)....

    [...]


References
More filters

Journal ArticleDOI
Yoav Shoham1Institutions (1)
TL;DR: The concept of agent-oriented programming is presented, the concept of mental state and its formal underpinning are discussed, a class of agent interpreters are defined, and a specific interpreter that has been implemented is described.
Abstract: Shoham, Y., Agent-oriented programming, Artificial Intelligence 60 (1993) 51-92. A new computational framework is presented, called agent-oriented programming (AOP), which can be viewed as a specialization of object-oriented programming. The state of an agent consists of components such as beliefs, decisions, capabilities, and obligations; for this reason the state of an agent is called its mental state. The mental state of agents is described formally in an extension of standard epistemic logics: beside temporalizing the knowledge and belief operators, AOP introduces operators for obligation, decision, and capability. Agents are controlled by agent programs, which include primitives for communicating with other agents. In the spirit of speech act theory, each communication primitive is of a certain type: informing, requesting, offering, and so on. This article presents the concept of AOP, discusses the concept of mental state and its formal underpinning, defines a class of agent interpreters, and then describes in detail a specific interpreter that has been implemented.

1,820 citations


Yoav Shoham1Institutions (1)
17 Dec 1992
TL;DR: This paper describes features of the agent oriented programming framework in a little more detail, and summarizes recent results and ongoing AOP-related work.
Abstract: Shoham, Y., Agent-oriented programming, Artificial Intelligence 60 (1993) 51-92. A new computational framework is presented, called agent-oriented programming (AOP), which can be viewed as a specialization of object-oriented programming. The state of an agent consists of components such as beliefs, decisions, capabilities, and obligations; for this reason the state of an agent is called its mental state. The mental state of agents is described formally in an extension of standard epistemic logics: beside temporalizing the knowledge and belief operators, AOP introduces operators for obligation, decision, and capability. Agents are controlled by agent programs, which include primitives for communicating with other agents. In the spirit of speech act theory, each communication primitive is of a certain type: informing, requesting, offering, and so on. This article presents the concept of AOP, discusses the concept of mental state and its formal underpinning, defines a class of agent interpreters, and then describes in detail a specific interpreter that has been implemented.

1,308 citations


"Reflecting on Agent Programming wit..." refers background in this paper

  • ...10 A[j+1] = temp 11 return A 1 !do_sort ([7, 5, 12, 15, 3]);...

    [...]

  • ...Perhaps the most common explanation of the relationship between AOP and OOP is the comparison table presented in [12]....

    [...]


Book
01 Jul 2007
Abstract: Preface. 1 Introduction. 1.1 Autonomous Agents. 1.2 Characteristics of Agents. 1.3 Multi-Agent Systems. 1.4 Hello World! 2 The BDI Agent Model. 2.1 Agent-Oriented Programming. 2.2 Practical Reasoning. 2.3 A Computational Model of BDI Practical Reasoning. 2.4 The Procedural Reasoning System. 2.5 Agent Communication. 3 The Jason Agent Programming Language. 3.1 Beliefs. 3.2 Goals. 3.3 Plans. 3.4 Example: A Complete Agent Program. 3.5 Exercises. 4 Jason Interpreter. 4.1 The Reasoning Cycle. 4.2 Plan Failure. 4.3 Interpreter Configuration and Execution Modes. 4.4 Pre-Defined Plan Annotations. 4.5 Exercises. 5 Environments. 5.1 Support for Defining Simulated Environments. 5.2 Example: Running a System of Multiple Situated Agents. 5.3 Exercises. 6 Communication and Interaction. 6.1 Available Performatives. 6.2 Informal Semantics of Receiving Messages. 6.3 Example: Contract Net Protocol. 6.4 Exercises. 7 User-Defined Components. 7.1 Defining New Internal Actions. 7.2 Customising the Agent Class. 7.3 Customising the Overall Architecture. 7.4 Customising the Belief Base. 7.5 Pre-Processing Directives. 7.6 Exercises. 8 Advanced Goal-Based Programming. 8.1 BDI Programming. 8.2 Declarative (Achievement) Goal Patterns. 8.3 Commitment Strategy Patterns. 8.4 Other Useful Patterns. 8.5 Pre-Processing Directives for Plan Patterns. 9 Case Studies. 9.1 Case Study I: Gold Miners. 9.2 Case Study II: Electronic Bookstore. 10 Formal Semantics. 10.1 Semantic Rules. 10.2 Semantics of Message Exchange in a Multi-Agent System. 10.3 Semantic Rules for Receiving Messages. 10.4 Semantics of the BDI Modalities for AgentSpeak. 11 Conclusions. 11.1 Jason and Agent-Oriented Programming. 11.2 Ongoing Work and Related Research. 11.3 General Advice on Programming Style and Practice. A Reference Guide. A.1 EBNF for the Agent Language. A.2 EBNF for the Multi-Agent Systems Language. A.3 Standard Internal Actions. A.4 Pre-Defined Annotations. A.5 Pre-Processing Directives. A.6 Interpreter Configuration. Bibliography.

1,173 citations


Book
12 Nov 2007
TL;DR: The BDI Agent Model, a Computational Model of BDI Practical Reasoning, and Semantics of the BDI Modalities for AgentSpeak, a Reference Guide to Agent-Oriented Programming, are presented.
Abstract: Preface. 1 Introduction. 1.1 Autonomous Agents. 1.2 Characteristics of Agents. 1.3 Multi-Agent Systems. 1.4 Hello World! 2 The BDI Agent Model. 2.1 Agent-Oriented Programming. 2.2 Practical Reasoning. 2.3 A Computational Model of BDI Practical Reasoning. 2.4 The Procedural Reasoning System. 2.5 Agent Communication. 3 The Jason Agent Programming Language. 3.1 Beliefs. 3.2 Goals. 3.3 Plans. 3.4 Example: A Complete Agent Program. 3.5 Exercises. 4 Jason Interpreter. 4.1 The Reasoning Cycle. 4.2 Plan Failure. 4.3 Interpreter Configuration and Execution Modes. 4.4 Pre-Defined Plan Annotations. 4.5 Exercises. 5 Environments. 5.1 Support for Defining Simulated Environments. 5.2 Example: Running a System of Multiple Situated Agents. 5.3 Exercises. 6 Communication and Interaction. 6.1 Available Performatives. 6.2 Informal Semantics of Receiving Messages. 6.3 Example: Contract Net Protocol. 6.4 Exercises. 7 User-Defined Components. 7.1 Defining New Internal Actions. 7.2 Customising the Agent Class. 7.3 Customising the Overall Architecture. 7.4 Customising the Belief Base. 7.5 Pre-Processing Directives. 7.6 Exercises. 8 Advanced Goal-Based Programming. 8.1 BDI Programming. 8.2 Declarative (Achievement) Goal Patterns. 8.3 Commitment Strategy Patterns. 8.4 Other Useful Patterns. 8.5 Pre-Processing Directives for Plan Patterns. 9 Case Studies. 9.1 Case Study I: Gold Miners. 9.2 Case Study II: Electronic Bookstore. 10 Formal Semantics. 10.1 Semantic Rules. 10.2 Semantics of Message Exchange in a Multi-Agent System. 10.3 Semantic Rules for Receiving Messages. 10.4 Semantics of the BDI Modalities for AgentSpeak. 11 Conclusions. 11.1 Jason and Agent-Oriented Programming. 11.2 Ongoing Work and Related Research. 11.3 General Advice on Programming Style and Practice. A Reference Guide. A.1 EBNF for the Agent Language. A.2 EBNF for the Multi-Agent Systems Language. A.3 Standard Internal Actions. A.4 Pre-Defined Annotations. A.5 Pre-Processing Directives. A.6 Interpreter Configuration. Bibliography.

810 citations


"Reflecting on Agent Programming wit..." refers background in this paper

  • ...During the course, the students are exposed to an AgentSpeak(L)-based language, which has been one of AF-AgentSpeak [5], Jason [4], and our most recent agent-programming language, ASTRA [6]....

    [...]

  • ...ASTRA is based upon Jason, but includes a number of features that are inspired by the mapping presented in this paper....

    [...]

  • ...The usefulness of constructs such as these is emphasised by Jason’s inclusion of some of these procedural-style constructs (e.g. if statements, loops) in its extended version of AgentSpeak(L)....

    [...]

  • ...The first approach is the approach adopted in Jason....

    [...]

  • ...Certainly, Jason includes support for atomic behaviours and has an extended suite of plan operators....

    [...]


Journal ArticleDOI
Mehdi Dastani1Institutions (1)
TL;DR: A BDI-based agent-oriented programming language that facilitates the implementation of multi-agent systems consisting of individual agents that may share and access external environments, called 2APL (A Practical Agent Programming Language).
Abstract: This article presents a BDI-based agent-oriented programming language, called 2APL (A Practical Agent Programming Language). This programming language facilitates the implementation of multi-agent systems consisting of individual agents that may share and access external environments. It realizes an effective integration of declarative and imperative style programming by introducing and integrating declarative beliefs and goals with events and plans. It also provides practical programming constructs to allow the generation, repair, and (different modes of) execution of plans based on beliefs, goals, and events. The formal syntax and semantics of the programming language are given and its relation with existing BDI-based agent-oriented programming languages is discussed.

375 citations


"Reflecting on Agent Programming wit..." refers background in this paper

  • ...Since its inception, a number of established AOP languages have emerged, with the most prominent being: 2/3APL [1, 2], GOAL [3] and Jason [4]....

    [...]


Network Information
Related Papers (5)
Performance
Metrics
No. of citations received by the Paper in previous years
YearCitations
20211
20206
20193
20187
20171
20151