Abstract
Rule markup languages will be the vehicle for using rules on the Web and in other distributed systems. They allow publishing, deploying, executing and communicating rules in a network. They may also play the role of a lingua franca for exchanging rules between different systems and tools. In a narrow sense, a rule markup language is a concrete (XML-based) rule syntax for the Web. In a broader sense, it should have an abstract syntax as a common basis for defining various concrete languages addressing different consumers. The main purposes of a rule markup language are to permit the publication, interchange and reuse of rules. This chapter introduces important requirements and design issues for general Web rule languages to fulfill these tasks. Characteristics of several important general standardization or standards-proposing efforts for (XML-based) rule markup languages including W3C RIF, RuleML, R2ML, SWRL as well as (human-readable) Semantic Web rule languages such as TRIPLE, N3, Jena, and Prova are discussed with respect to these identified issues.
TopIntroduction
Agent-oriented software engineering paradigm is a modern approach for the development of distributed intelligent systems. In this paradigm, software systems (called multi-agent systems) consist of a number of interacting (software) agents, each of which is capable of sensing its environment (including other agents) and deciding to act in order to achieve its design objectives. Examples of such systems are e-commerce applications, auctions, electronic institutions, power management systems or transportation systems.
Multi-agent systems are specified, designed, and implemented in terms of high-level concepts and abstractions such as roles, communication, beliefs, goals, plans, actions, and events. Different development methodologies (Bergenti et al., 2004), specification languages (e.g., BDICTL (Rao et al., 1991, Cohen et al., 1990) and KARO (Meyer et al., 1999), and programming languages (Bordini et al., 2007, Winikoff et al., 2005, Pokahr et al., 2005, Hindriks et al. 1999, Kakas et al. 2004, Giacomo et al. 2000) have been proposed to facilitate the development of agent-based systems.
While most agent-oriented development methodologies specify and design system architectures in terms of agent concepts and abstractions, the proposed agent-oriented programming languages and development tools aim at providing programming constructs to facilitate direct and effective implementation of these concepts and abstractions. Moreover, existing agent-oriented programming languages aim at supporting programming techniques such as modularity, reuse, encapsulation and information hiding. The availability and combination of agent-oriented programming constructs and programming techniques characterize and differentiate these programming languages and determine their usefulness and applicability.
Existing agent-oriented programming languages differ as they provide programming constructs for specific, sometimes overlapping, sets of agent concepts and abstractions. They also differ as they are based on different logics and use different technologies. Some of them are rule-based capturing the interaction of agent concepts by means of specific rules, while others are extension of Java programming language. Some capture specific rationality principles that underlie agent concepts in their semantics, while such principles are assumed to be implemented by agent programmers in other programming languages. Finally, they differ in programming techniques that are introduced to support the implementation of multi-agent systems. See (Bordini et al., 2005) for a comparison between some of these agent programming languages.
In this chapter, a modular rule-based agent-oriented programming language is presented that 1) separates multi-agent from single-agent concerns, 2) provides and integrates programming constructs that are expressive enough to implement a variety of agent concepts and abstractions used in the existing agent-oriented methodologies, 3) provides different types of rules to capture the interaction of agent concepts such as beliefs, goals and plans, 4) introduces a specific notion of modules and provides a set of module related operations that allows an agent programmer to determine how and when modules are used, and 5) realizes an effective integration of declarative and imperative programming styles. It is important to emphasize that multi-agent systems can be implemented in any existing programming language. However, we aim at designing an agent-oriented programming language that provides dedicated and expressive programming constructs and techniques to facilitate practical and effective implementation of agent related concepts and abstractions.
Key Terms in this Chapter
Agent Profile: An agent profile is the representation of an agent. An agent can build and maintain the profile of other agents. In a modular agent programming language, an agent profile may be implemented by means of a module.
Agent Role: An agent role is a specific functionality or task that an agent can realize. In a modular agent programming language, an agent role may be implemented by a specific module.
Modular Agent Programming Language: An agent programming language is modular if it supports the implementation of agents in terms of separate modules each of which implements a separation of concern.
BDI Agents: A BDI agent decides its actions based on its mental state consists of beliefs, goals, events, and plans. In particular, it decides actions that he believes they either contribute to the achievement of its goals or react to its received events and messages.
Agent: An agent is a computational system that is situated in some dynamic environment and can autonomously decide which actions to perform in order to achieve its objectives.
BDI-Based Agent Programming Language: A BDI-based agent programming language is designed to support the implementation of BDI agents. Such a programming language provides constructs to implement an agent’s beliefs, goals, events, plans, and decisions making process.
Agent Deliberation: An agent deliberation is a cyclic process through which the agent continuously senses its environment (processing the received internal and external events), updates its state, reasons about its state to decide which actions to perform, and executes those actions. Such a cyclic process constitutes the interpreter of agent programming languages.