JavaLog: a framework-based integration of Java and Prolog for agent-oriented programming

Abstract

Intelligent agent development has imposed new challenges on the necessary language support. Object-oriented languages have been proposed as an appropriate tool, although logic-oriented languages are more adequate for managing mental attitudes. Multi-paradigm languages supporting encapsulation of actions, hiding of private knowledge and flexible manipulation of knowledge are, certainly, a good alternative for programming agents. However, a unique language to support flexible and efficient development of multi-agent systems confronts with the tradeoffs imposed by expressive power, efficiency and support technology. An alternative to conciliate these tradeoffs is not to think about a single language but an incrementally compatible family of agent-oriented multi-paradigm languages. In this work we present an approach based on object-oriented framework technology for integrating object and logic paradigms in such a way that new language features can be incrementally added to the core language. This core language is based on logic modules integrated as object abstractions in the object paradigm. JavaLog is a materialization of this framework integrating Java and Prolog. This core was extended to provide multi-threading support, mobility and temporal-logic operators to Prolog. MoviLog, the mobile part of the family provides a novel mobility mechanism, reactive mobility by failure, which enables virtual Prolog databases distributed across Web sites.

Introduction

Intelligent agent programming requires particular capabilities of a programming language. This fact relies on both experiences gained developing applications with standard languages and from the many proposed agent-oriented languages [1].

Many applications have been developed using object-oriented languages and characteristics of these languages such as encapsulation and inheritance are considered important benefits for agent development [2], [3]. On the other side, several proposals for agent languages such as Metatem [4] or Gaea [5], among others, are supported on logic bases. A logic-oriented programming approach is a straightforward consequence of the requirement of managing mental attitudes, since they are generally based on special logics defined for that purpose [6]. For this reason, logic languages such as Prolog may be considered an obvious way for representing and inferring relationships among mental attitudes such as intentions, goals and beliefs. However, they present several limitations for the definition of action capabilities that object-oriented languages naturally support. Usually, logic-based agent languages are enhanced with non-declarative features inherent to other type of languages, such as objects, threads, etc. Thus, in order to have a language that makes it easier the development of different kind of agents, this language should provide, at least, support to smoothly manage mental attitudes, actions, and private information in an integrated way.

Certainly, multi-paradigm languages [7], [8], [9], [10], [11] integrating logic and object-oriented paradigms represent a convenient choice for the definition of agent programming languages. However, the existing proposals of multi-paradigm languages, particularly the ones proposed in the 1980s and their evolutions, present limitations to satisfy the multiple requirements of modern multi-agent systems. In addition, flexibility to cope with specific language capabilities required by the many potential application areas is an essential factor. Also, as efficiency is involved, the use of a language providing a set features not necessary for the domain can be negative, in terms of memory usage or speed, despite the expressive power of the language. Therefore, the main challenge behind the design of an effective language for agent programming relies on how to maintain the right balance among expressive power, support technologies and functionality. We believe that object-oriented framework technology [12], [13] is the current most viable answer.

Under these considerations we have designed JavaLog, a language that integrates Java and Prolog, enabling to exploit the advantages of both programming paradigms in an extensible way. JavaLog is based on a Java framework that can be extended to incrementally add new functionalities to the core language, giving a family of languages. The core language is based on logic modules that encapsulate clauses for the manipulation of mental attitudes. These modules are used through variables or directly in Java methods, defining precise bridges between the two paradigms. Features such as temporal Prolog extensions, concurrency or strong mobility, optional for some agent systems, are provided as incremental extensions of the framework. Concurrency is supported by Java threads; logic threads are also supported. Strong mobility is incorporated supporting logic modules that can be transparently executed using clauses at different sites.

In the remainder of the article, we will first describe our approach based on logic modules for agent programming, then, in Section 3 we summarize relevant characteristics of the JavaLog language. The JavaLog framework is briefly described in Section 4. Then, Section 5 describes an extension of the JavaLog framework to support concurrency. Mobility extensions and a novel form of mobility are presented in Section 6. In Section 7 we describe a number of applications of the framework. Section 8 discusses the most relevant related work. Finally, in Section 9 we conclude with a summary and directions for future work.