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

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

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

Message-oriented middleware (MOM) is software or hardware infrastructure supporting sending and receiving messages between distributed systems. Message-oriented middleware is in contrast to streaming-oriented middleware where data is communicated as a sequence of bytes with no explicit message boundaries. Note that steaming protocols are almost always built above protocols using discrete messages such as frames Ethernet), datagrams UDP, packets IP, cells ATM, et al.

<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.

A tuple space is an implementation of the associative memory paradigm for parallel/distributed computing. It provides a repository of tuples that can be accessed concurrently. As an illustrative example, consider that there are a group of processors that produce pieces of data and a group of processors that use the data. Producers post their data as tuples in the space, and the consumers then retrieve data from the space that match a certain pattern. This is also known as the blackboard metaphor. Tuple space may be thought as a form of distributed shared memory.

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.

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.

An application programming interface (API) is a connection between computers or between computer programs. It is a type of software interface, offering a service to other pieces of software. A document or standard that describes how to build such a connection or interface is called an API specification. A computer system that meets this standard is said to implement or expose an API. The term API may refer either to the specification or to the implementation.

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 (2024). 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.