Agent Programming Language Research Articles

Going beyond BDI for agent-based simulation

ABSTRACTResearch in multi-agent systems has resulted in agent programming languages and logics that are used as a foundation for engineering multi-agent systems. Research includes reusable agent programming platforms for engineering agent systems with environments, agent behaviour, communication protocols and social behaviour, and work on verification. Agent-based simulation is an approach for simulation that also uses the notion of agents. Although agent programming languages and logics are much less used in agent-based simulation, there are successful examples with agents designed according to the BDI paradigm, and work that combines agent-based simulation platforms with agent programming platforms. This paper analyses and evaluates benefits of using agent programming languages and logics for agent-based simulation. In particular, the paper considers the use of agent programming languages and logics in a case study of simulating emergency care units.

Model transformations from the SARL agent-oriented programming language to an object-oriented programming language

SARL is a general-purpose agent-oriented programming language. This language aims at providing the fundamental abstractions for dealing with concurrency, distribution, interaction, decentralisation...

Model transformations from the SARL agent-oriented programming language to an object-oriented programming language

SARL is a general-purpose agent-oriented programming language. This language aims at providing the fundamental abstractions for dealing with concurrency, distribution, interaction, decentralisation...

AGENT ORIENTED PROGRAMMING LANGUAGES: A REVIEW

Agent oriented Programming Languages are a set of instructions used to design an Agent Oriented Systems. In Agent Oriented systems, objects known as agents is an interface to accomplish particular objectives. Agents are referred as an encapsulated systems in computer which have an autonomous actions to accomplish the design goals. Agents can be self-sufficient elements, choosing their subsequent stage without the involvement of a user. The agents are particular in the capturing of structure in the natural way and the behavior of a complex system. Now a days Agents based systems are an interesting research area in computer science fields. The undertaken study aims to present the Concept, features and model of Agent Oriented Programing Languages but the main focuses of this study is on review of different programming languages used to design Agent Oriented Systems. This study will be helpful for the scholars, researchers and academicians.

Programming Agent Deliberation Using Procedural Reflection

A key advantage of BDI-based approaches to agent programming, is that agents can deliberate about which course of action to adopt to achieve a goal or respond to an event. However, while state-of-the-art BDI-based agent programming languages allow the programmer to specify the context(s) in which a particular plan is applicable, they are typically limited to a single, hard-coded, deliberation strategy for all task environments. In this paper, we present an alternative approach, in which an agent’s deliberation strategy forms part of the agent program. We show how both conventional agent programs and the agent’s deliberation strategy can be encoded in the agent programming language meta-APL. Key steps in the deliberation cycle of meta-APL are reflected in the state of the agent and can be queried and updated by meta-APL rules, allowing application-specific BDI deliberation strategies to be programmed in a straightforward way. To illustrate the flexibility of meta-APL, we show how three typical BDI deliberation strategies can be programmed using meta-APL rules. We then show how meta-APL can used to program a simple adaptive deliberation strategy that avoids interference between intentions.

Protocol and role: abstraction mechanisms in agent oriented programming languages

The language mechanisms protocol and role are used in order to organise the interaction structures between agents in multi-agent systems. Agents are internally organised by means of roles, roles are related as protocols, and agents send messages to each other through their related roles. The comprehensive and complex interaction structures between agents are conceptualised by protocol and role, and these abstraction mechanisms are used in the description of interaction structures. The description of the interaction structures between agents becomes understandable and the development process of multi-agent systems becomes efficient and flexible. The language mechanisms are illustrated by means of a supporting application framework.

Protocol and role: abstraction mechanisms in agent oriented programming languages

The language mechanisms protocol and role are used in order to organise the interaction structures between agents in multi-agent systems. Agents are internally organised by means of roles, roles are related as protocols, and agents send messages to each other through their related roles. The comprehensive and complex interaction structures between agents are conceptualised by protocol and role, and these abstraction mechanisms are used in the description of interaction structures. The description of the interaction structures between agents becomes understandable and the development process of multi-agent systems becomes efficient and flexible. The language mechanisms are illustrated by means of a supporting application framework.

An agent programming manifesto

There has been considerable progress in both the theory and practice of agent programming since Georgeff & Rao’s seminal work on the Belief-Desire-Intention paradigm. However, despite increasing interest in the development of autonomous systems, applications of agent programming are confined to a small number of niche areas, and adoption of agent programming languages in mainstream software development remains limited. This state of affairs is widely acknowledged within the community, and a number of reasons and remedies have been proposed. In this paper, I present an analysis of why agent programming has failed to make an impact that is rooted in the class of programming problems agent programming sets out to solve, namely the realisation of flexible intelligent behaviour in dynamic and unpredictable environments. Based on this analysis, I outline some suggestions for the future direction of agent programming, and some principles that I believe any successful future direction must follow.

An agent programming manifesto

There has been considerable progress in both the theory and practice of agent programming since Georgeff and Rao's seminal work on the belief-desire-intention paradigm. However, despite increasing interest in the development of autonomous systems, applications of agent programming are confined to a small number of niche areas and adoption of agent programming languages in mainstream software development remains limited. This state of affairs is widely acknowledged within the community and a number of reasons and remedies have been proposed. In this paper, I present an analysis of why agent programming has failed to make an impact that is rooted in the class of programming problems agent programming sets out to solve, namely the realisation of flexible intelligent behaviour in dynamic and unpredictable environments. Based on this analysis, I outline some suggestions for the future direction of agent programming and some principles that I believe any successful future direction must follow.

Automating failure detection in cognitive agent programs

Debugging is notoriously difficult and time consuming but also essential for ensuring the reliability and quality of a software system. In order to reduce debugging effort and enable automated failure detection, we propose an automated testing framework for detecting failures in cognitive agent programs. Our approach is based on the assumption that modules within such programs are a natural unit for testing. We identify a minimal set of temporal operators that enable the specification of test conditions and show that the test language is sufficiently expressive for detecting all failure types of existing failure taxonomy. We also introduce an approach for specifying test templates that supports a programmer in writing tests. Furthermore, empirical analysis of agent programs allows us to evaluate whether our approach using test templates adequately detects failures, and to determine the effort that is required to do so in both single and multi-agent systems. We also discuss a concrete implementation of the proposed framework for the GOAL agent programming language that has been developed for the Eclipse IDE. With the use of this framework, evaluations have been performed based on test files and according questionnaires that were handed in by 94 novice programmers.

Multi-agent programming contest 2016

We present the 11th edition of the multi-agent programming contest, an annual, community-serving competition that attracts groups from all over the world. Our contest enables head-to-head comparison of multi-agent systems and supports educational efforts in their design and implementation. The long-term aim is to evaluate the specific features of agent programming languages and to compare them to more traditional languages.

Automating failure detection in cognitive agent programs

Debugging is notoriously difficult and time consuming but also essential for ensuring the reliability and quality of a software system. In order to reduce debugging effort and enable automated failure detection, we propose an automated testing framework for detecting failures in cognitive agent programs. Our approach is based on the assumption that modules within such programs are a natural unit for testing. We identify a minimal set of temporal operators that enable the specification of test conditions and show that the test language is sufficiently expressive for detecting all failure types of existing failure taxonomy. We also introduce an approach for specifying test templates that supports a programmer in writing tests. Furthermore, empirical analysis of agent programs allows us to evaluate whether our approach using test templates adequately detects failures, and to determine the effort that is required to do so in both single and multi-agent systems. We also discuss a concrete implementation of the proposed framework for the GOAL agent programming language that has been developed for the Eclipse IDE. With the use of this framework, evaluations have been performed based on test files and according questionnaires that were handed in by 94 novice programmers.

Variations on Agent-Oriented Programming

Occurrence of the agent paradigm and its further applications have stimulated the emergence of new concepts and methodologies in computer science. Today terms like multi-agent system, agent-oriented methodology, and agent-oriented programming (AOP) are widely used. The aim of this paper is to clarify the validity of usage of the terms AOP and AOP language. This is disclosed in two phases of an analysis process. Determining to which concepts, terms like agent, programming, object-oriented analysis and design, object-oriented programming, and agent-oriented analysis and design correspond is accomplished in the first phase. Analysis of several known agent system engineering methodologies in terms of key concepts used, final resulting artifacts, and their relationship with known programming paradigms and modern tools for agent system development is performed in the second phase. The research shows that in most cases in the final phase of agent system design and in the coding stage, the main artifact is an object, defined according to the rules of the object-oriented paradigm. Hence, we say that the computing society still does not have AOP owing to the lack of an AOP language. Thus, the term AOP is very often incorrectly assigned to agent system development frameworks that in most cases, transform agents into objects. DOI: 10.15181/csat.v5i1.1361

Population Growth versus Job Generation: Addressing Economic Disparity in the Philippines

Economic disparity, inequality, and poverty have been central when examining the challenges of employment generation, better quality of employment, and decent way of life. This study explores the possible dynamics from an economic perspective resulting from the job-seeking behaviour of the graduates and job generation. Changes in the characteristics of the work location areas shows a variation in the number of areas each job seeker looks at when choosing a place that optimizes the jobseeker’s utility and the options of employment created in the country. The research paper utilized the NetLogo, a multi- agent programming language and modeling environment for simulating complex natural and social phenomena. Specifically, the Economic Disparity NetLogo Model simulates the Philippine context using the socio-economic status of the agents to determine how their preferences for choosing a location to live impacts on employment conditions. In the study, the work location area is affected by variations in the two factors, Factor A being the number of location each job seeker looks at when choosing a place that optimizes the jobseeker’s utility, and Factor B being the number of places of employment created in the country. Four scenarios are simulated by the model when the two factors are set at low or high levels to determine the time for a job location to become saturated. The variation of the factors created four scenarios. Scenarios B and D with large job seeker population and more places of employment created took 28 years to reach job saturation point. Scenarios A and C with a small jobseeker population and few places of employment created took 11 years. In all scenarios, the saturation point reached 14 ticks.

Run-time environment for the SARL agent-programming language: the example of the Janus platform

SARL is a general-purpose agent-oriented programming language. This language aims at providing the fundamental abstractions for dealing with concurrency, distribution, interaction, decentralization, reactivity, autonomy and dynamic reconfiguration that are usually considered as essential for implementing agent-based applications. Every programming language specifies an execution model. For SARL, this run-time model is supported by a SARL run-time environment. The goals of this paper are to highlight the key principles for creating a SARL run-time environment, and its concrete implementation into the Janus agent platform.

A Rational Agent Controlling an Autonomous Vehicle: Implementation and Formal Verification

The development and deployment of Autonomous Vehicles (AVs) on our roads is not only realistic in the near future but can also bring significant benefits. In particular, it can potentially solve several problems relating to vehicles and traffic, for instance: (i) possible reduction of traffic congestion, with the consequence of improved fuel economy and reduced driver inactivity; (ii) possible reduction in the number of accidents, assuming that an AV can minimise the human errors that often cause traffic accidents; and (iii) increased ease of parking, especially when one considers the potential for shared AVs. In order to deploy an AV there are significant steps that must be completed in terms of hardware and software. As expected, software components play a key role in the complex AV system and so, at least for safety, we should assess the correctness of these components. In this paper, we are concerned with the high-level software component(s) responsible for the decisions in an AV. We intend to model an AV capable of navigation; obstacle avoidance; obstacle selection (when a crash is unavoidable) and vehicle recovery, etc, using a rational agent. To achieve this, we have established the following stages. First, the agent plans and actions have been implemented within the Gwendolen agent programming language. Second, we have built a simulated automotive environment in the Java language. Third, we have formally specified some of the required agent properties through LTL formulae, which are then formally verified with the AJPF verification tool. Finally, within the MCAPL framework (which comprises all the tools used in previous stages) we have obtained formal verification of our AV agent in terms of its specific behaviours. For example, the agent plans responsible for selecting an obstacle with low potential damage, instead of a higher damage obstacle (when possible) can be formally verified within MCAPL. We must emphasise that the major goal (of our present approach) lies in the formal verification of agent plans, rather than evaluating real-world applications. For this reason we utilised a simple matrix representation concerning the environment used by our agent.

Agent-oriented model-driven development for JADE with the JADEL programming language

This paper describes, from motivations and main objectives to actual implementation, a novel agent-oriented programming language called JADEL. JADEL is designed to support the effective implementation of JADE agents and multi-agent systems in the scope of real-world model-driven development because it concretely helps developers by natively supporting agent-oriented abstractions, and because it is based on mature industrial-strength technologies. The four core abstractions that JADEL supports, namely agents, behaviours, communication ontologies, and interaction protocols, are presented by gradually introducing the specific syntaxes that the language provides for them. In the last part of the paper, a complete example of a simple JADEL multi-agent system is presented and discussed. Such an example is a well-known example from the official distribution of JADE and many programmers learned the basics of JADE from it. The choice of this example allows comparing JADEL source code with reference Java source code using JADE, and it clearly emphasizes the practical advantages of agent-oriented programming.Section 1 introduces and motivates the presented work. Section 2 surveys major AOP languages and, even if it cannot be considered exhaustive, it highlights the specific features of selected languages that have been relevant for the design of JADEL. Section 3 provides an overview of the features of JADE that are supported by JADEL. Section 4 presents the language in details by discussing main supported abstractions, and by specifying its formal syntax. Section 5 presents the most interesting parts of a complete example of the use of JADEL to develop a simple multi-agent system. Finally, Section 6 concludes the paper with a discussion of the current state of the presented work, and a preliminary assessment of the proposed language.

Abstraction in Situation Calculus Action Theories

We develop a general framework for agent abstraction based on the situation calculus and the ConGolog agent programming language. We assume that we have a high-level specification and a low-level specification of the agent, both represented as basic action theories. A refinement mapping specifies how each high-level action is implemented by a low-level ConGolog program and how each high-level fluent can be translated into a low-level formula. We define a notion of sound abstraction between such action theories in terms of the existence of a suitable bisimulation between their respective models. Sound abstractions have many useful properties that ensure that we can reason about the agent's actions (e.g., executability, projection, and planning) at the abstract level, and refine and concretely execute them at the low level. We also characterize the notion of complete abstraction where all actions (including exogenous ones) that the high level thinks can happen can in fact occur at the low level.

First Comparison of SARL to Other Agent-Programming Languages and Frameworks

Abstract: This paper proposes a first comparison of different agent-oriented programming languages, including the SARL agent-programming language. The study of those tools is based upon various criteria that are defining the essential aspects of multi-agent systems. For the sake of clarity, the comparative study is presented in a tabular form, including the languages and all the criteria. For each criterion, a definition is made to understand its meaning. At the end of the article, all the languages will be described in order to define their advantages and disadvantages.

Aspect Oriented Programming Perspective in Software Agents and Simulation

Agent-driven Simulation Framework-AdSiF provides a declarative scripting agent programming language. Stateoriented programming paradigm combined with multi-programming paradigms is at the background of script, which allows programming by extended state charts. Aspect-oriented programming paradigm draws a solution background related with scattered codes, scattered requirements and tangled requirements. While object-oriented programming paradigm gives a vertical software design, aspect orientation enhances this vertically deep design by horizontal association. Aspect-oriented programming paradigm, which is one of the components of AdSiF’s state oriented programming paradigm, provides a solution by a loosely-coupled script description to the problems mentioned. For this purpose, states and behaviours, which satisfy scattered requirements, are distributed to behaviour’s and behaviour lists, respectively and behaviour phase transitions based on behaviours and active states are allowed. In addition to all, Furthermore, in simulation and agent programming world, the solution provides a solution by shifting modelling aspects conditionally in run time for conceptually different modelling requirements and also tangled requirements. The solution carries aspect oriented programming from design time to execution time and provides a dynamically manageable, flexible, loosely coupled and high coherent design.