Agent-oriented programming

Last updated

Agent-oriented programming (AOP) is a programming paradigm where the construction of the software is centered on the concept of software agents. In contrast to object-oriented programming which has objects (providing methods with variable parameters) at its core, AOP has externally specified agents (with interfaces and messaging capabilities) at its core. They can be thought of as abstractions of objects. Exchanged messages are interpreted by receiving "agents", in a way specific to its class of agents.

Contents

History

Historically, the concept of agent-oriented programming and the idea of centering software around the concept of an Agent was introduced by Yoav Shoham within his artificial intelligence studies in 1990. [1] [2] His agents are specific to his own paradigm as they have only one method, with one parameter. To quote Yoav Shoham from his paper in 1990 for a basic difference between AOP and OOP:

... agent-oriented programming (AOP), which can be viewed as a specialization of object-oriented programming.

OOPAOP
Basic unitobjectagent
Parameters defining state of basic unitunconstrainedbeliefs, commitments, capabilities, choices, ...
Process of computation message passing and response methodsmessage passing and response methods
Types of messageunconstrainedinform, request, offer, promise, decline, ...
Constraints on methodsnonehonesty, consistency, ...

Frameworks

There are multiple AOP 'frameworks', also called agent platforms, that implement Shoham's programming paradigm. The following examples illustrate how a basic agent is programmed as a hello-world program.

JADE

For the Java-platform one of the frameworks is JADE. [3] Here is a very basic example [4] of an agent that runs code.

packagehelloworld;importjade.core.Agent;publicclassHelloextendsAgent{protectedvoidsetup(){System.out.println("Hello World. ");System.out.println("My name is "+getLocalName());}publicHello(){System.out.println("Constructor called");}}

At the core of JADE's AOP model is that its API supports the standard FIPA Agent Communication Language

Agent Speak (Jason)

AgentSpeak is an agent-oriented programming language based on logic programming and the belief–desire–intention (BDI) architecture.

For a literal translation of agent-oriented concepts into a scheme unobfuscated as is JADE, behind Java and Object Orientedness, Agent Speak [5] (Jason) provides a "natural" language for agents.

started.  +started <- .print("Hello World. ").

GOAL

GOAL is an agent programming language for programming cognitive agents. GOAL agents derive their choice of action from their beliefs and goals. The language provides the basic building blocks to design and implement cognitive agents by programming constructs that allow and facilitate the manipulation of an agent's beliefs and goals and to structure its decision-making. The language provides an intuitive programming framework based on common sense or practical reasoning.

SARL Language

SARL [6] provides the fundamental abstractions for coding multiagent systems. [7] It uses a script-like syntax (inspired by Scala and Ruby).

packagehelloworldimportio.sarl.core.InitializeagentHelloWorldAgent{onInitialize{println("Hello World.")}}

PADE (Python Agent DEvelopment framework)

PADE [8] is a python package to develop intelligent agents in python language. This framework complies to FIPA and ACL standards.

classAgenteHelloWorld(Agent):def__init__(self,aid):super(AgenteHelloWorld,self).__init__(aid=aid)display_message(self.aid.localname,'Hello World!')

Middleware

One way to implement modular or extensible AOP support is to define standard AOP APIs to middleware functions that are themselves implemented as software agents. For example, a directory service can be implemented as a FIPA directory facilitator or DF software agent; life-cycle management to start, stop, suspend and resume agents can be implemented as a FIPA Agent Management Service or AMS agent. [9] A benefit of the AOP approach is that it supports more dynamic roles between different users and providers of applications, services and networks. For example, traditionally, networks and services were usually managed by the network and service provider on behalf of the customer and offered as a single virtual network service but customers themselves are becoming more empowered to integrate and manage their own services. This can be achieved via AOP and APIs to middleware agents that can flexibly and dynamically manage communication. [10]

See also

Related Research Articles

A "Hello, World!" program is generally a simple computer program which outputs to the screen a message similar to "Hello, World!" while ignoring any user input. A small piece of code in most general-purpose programming languages, this program is used to illustrate a language's basic syntax. A "Hello, World!" program is often the first written by a student of a new programming language, but such a program can also be used as a sanity check to ensure that the computer software intended to compile or run source code is correctly installed, and that its operator understands how to use it.

<span class="mw-page-title-main">OSGi</span> Open standards organisation

OSGi is an open specification and open source project under the Eclipse Foundation.

<span class="mw-page-title-main">Windows API</span> Microsofts core set of application programming interfaces on Windows

The Windows API, informally WinAPI, is the foundational application programming interface (API) that allows a computer program to access the features of the Microsoft Windows operating system in which the program is running.

Message-oriented middleware (MOM) is software or hardware infrastructure supporting sending and receiving messages between distributed systems. MOM allows application modules to be distributed over heterogeneous platforms and reduces the complexity of developing applications that span multiple operating systems and network protocols. The middleware creates a distributed communications layer that insulates the application developer from the details of the various operating systems and network interfaces. APIs that extend across diverse platforms and networks are typically provided by MOM.

<span class="mw-page-title-main">Multi-agent system</span> Built of multiple interacting agents

A multi-agent system is a computerized system composed of multiple interacting intelligent agents. Multi-agent systems can solve problems that are difficult or impossible for an individual agent or a monolithic system to solve. Intelligence may include methodic, functional, procedural approaches, algorithmic search or reinforcement learning.

The Web Server Gateway Interface is a simple calling convention for web servers to forward requests to web applications or frameworks written in the Python programming language. The current version of WSGI, version 1.0.1, is specified in Python Enhancement Proposal (PEP) 3333.

In software engineering, a plain old Java object (POJO) is an ordinary Java object, not bound by any special restriction. The term was coined by Martin Fowler, Rebecca Parsons and Josh MacKenzie in September 2000:

"We wondered why people were so against using regular objects in their systems and concluded that it was because simple objects lacked a fancy name. So we gave them one, and it's caught on very nicely."

CherryPy is an object-oriented web application framework using the Python programming language. It is designed for rapid development of web applications by wrapping the HTTP protocol but stays at a low level and does not offer much more than what is defined in RFC 7231.

Caché ObjectScript is a part of the Caché database system sold by InterSystems. The language is a functional superset of the ANSI-standard MUMPS programming language. Since Caché is at its core a MUMPS implementation, it can run ANSI MUMPS routines with no change. To appeal as a commercial product, Caché implements support for object-oriented programming, a macro preprocessing language, embedded SQL for ANSI-standard SQL access to M's built-in database, procedure and control blocks using C-like brace syntax, procedure-scoped variables, and relaxed whitespace syntax limitations.

Agent Communication Language (ACL), proposed by the Foundation for Intelligent Physical Agents (FIPA), is a proposed standard language for agent communications. Knowledge Query and Manipulation Language (KQML) is another proposed standard.

<span class="mw-page-title-main">JADE (programming language)</span> Software development and deployment platform

JADE is a proprietary object-oriented software development and deployment platform product from the New Zealand-based Jade Software Corporation, first released in 1996. It consists of the JADE programming language, Integrated development environment and debugger, integrated application server and object database management system.

The following outline is provided as an overview of and topical guide to computer programming:

Java Agent Development Framework, or JADE, is a software framework for the development of software agents, implemented in Java. JADE system supports coordination between several agents FIPA and provides a standard implementation of the communication language FIPA-ACL, which facilitates the communication between agents and allows the services detection of the system. JADE was originally developed by Telecom Italia and is distributed as free software.

The Simple API for Grid Applications (SAGA) is a family of related standards specified by the Open Grid Forum to define an application programming interface (API) for common distributed computing functionality.

JACK Intelligent Agents is a framework in Java for multi-agent system development. JACK Intelligent Agents was built by Agent Oriented Software Pty. Ltd. (AOS) and is a third generation agent platform building on the experiences of the Procedural Reasoning System (PRS) and Distributed Multi-Agent Reasoning System (dMARS). JACK is one of the few multi-agent systems that uses the BDI software model and provides its own Java-based plan language and graphical planning tools.

In the field of software development, an interceptor pattern is a software design pattern that is used when software systems or frameworks want to offer a way to change, or augment, their usual processing cycle. For example, a (simplified) typical processing sequence for a web-server is to receive a URI from the browser, map it to a file on disk, open the file and send its contents to the browser. Any of these steps could be replaced or changed, e.g. by replacing the way URIs are mapped to filenames, or by inserting a new step which processes the files contents.

Middleware is a type of computer software program that provides services to software applications beyond those available from the operating system. It can be described as "software glue".

<span class="mw-page-title-main">Rodos (operating system)</span> Real-time operating system

Rodos is a real-time operating system for embedded systems and was designed for application domains demanding high dependability.

The SARL programming language is a modular agent-oriented programming language. It aims at providing the fundamental abstractions for dealing with concurrency, distribution, interaction, decentralization, reactivity, autonomy and dynamic reconfiguration.

References

  1. ↑ Shoham, Y. (1990). Agent-Oriented Programming (Technical Report STAN-CS-90-1335). Stanford University: Computer Science Department.
  2. ↑ Shoham, Y. (1993). "Agent-Oriented Programming". Artificial Intelligence. 60 (1): 51–92. CiteSeerX   10.1.1.123.5119 . doi:10.1016/0004-3702(93)90034-9.
  3. ↑ Bellifeminee, Fabio; Agostino Poggi; Giovanni Rimassa (2001). JADE: a FIPA2000 compliant agent development environment. Proceedings of the fifth international conference on Autonomous agents. pp. 216–217. doi:10.1145/375735.376120.
  4. ↑ "Rootdev". rootdev.nl. Archived from the original on 2 July 2011. Retrieved 18 September 2022.
  5. ↑ Anand S. Rao, 1996. AgentSpeak(L): BDI Agents Speak Out in a Logical Computable Language. Proceedings of Seventh European Workshop on Modelling Autonomous Agents in a Multi-Agent World (MAAMAW-96).
  6. ↑ Rodriguez, Sebastian; Gaud, Nicolas; Galland, Stéphane (2014). "SARL: A General-Purpose Agent-Oriented Programming Language". 2014 IEEE/WIC/ACM International Joint Conferences on Web Intelligence (WI) and Intelligent Agent Technologies (IAT). pp. 103–110. doi:10.1109/wi-iat.2014.156. ISBN   978-1-4799-4143-8. S2CID   15508257.
  7. ↑ SARL website
  8. ↑ "Python Agent DEvelopment framework — Pade 1.0 documentation".
  9. ↑ Poslad, S (2007). "Specifying Protocols for Multi-agent System Interaction". ACM Transactions on Autonomous and Adaptive Systems. 2 (4): 15–es. doi:10.1145/1293731.1293735. S2CID   9477595.
  10. ↑ Poslad, S.; Pitt, J.; Mamdani, A.; Hadingham, R.; Buckle, P. (1999). Hayzelden, A.; Bigham, J. (eds.). Agent-oriented middleware for integrating customer network services. In: Software Agents for Future Communication Systems. pp. 221–242. doi:10.1007/978-3-642-58418-3_9.
This page is based on this Wikipedia article
Text is available under the CC BY-SA 4.0 license; additional terms may apply.
Images, videos and audio are available under their respective licenses.