Antonio Natali

Programmable Coordination Media

The design, development and maintenance of multi-component software systems often suffer from the lack of suitable coordination abstractions. The aim of this paper is to show the benefits of coordination models based on global communication abstractions whose behaviour is not fixed, but is extensible so as to accomplish the intended behaviour of the whole system. Accordingly, we propose the notion of programmable coordination medium as an abstraction provided by the coordination model around which the global behaviour of a coordination architecture can be designed. As an example, we show how a Linda-based approach can be empowered by exploiting the notion of programmable tuple space, as supported by the ACLT coordination model.

Objects as Communicating Prolog Units

The aim of this paper is to present a set of extensions to the Prolog language in order to insert in it concepts typical of parallel, distributed object-oriented systems. A program is a collection of objects (P-Units) that represent chunks of knowledge expressed as separate Prolog programs. P-units interact by asking for the demonstration of goals conceived as requests for operations. P-units can perform operations in parallel. Policies of interaction between objects, the creation of parallel activities, inheritance and delegation mechanisms are not frozen in the basic interpreter, but can be explicitly expressed in particular P-units that act as meta-objects. This approach enhances both the flexibility and reusability of the resulting object-oriented system.

Agent Coordination and Control through Logic Theories

This work describes an agent interaction model (ACLT, Agent Communicating through Logic Theories) rooted in the concept of logic theory. ACLT agents and their behaviour are conceived as inferential as well as procedural activities within a multiple theory space. The communication unit (CU) abstraction is exploited, subsuming traditional communication models (both shared memory and message passing) based on explicit and extensional knowledge, while allowing agents to exploit partial/incomplete knowledge through deduction. Agent synchronization is reconducted to the concept of theory evolution, by allowing agents to wait for theory modification until facts can be deduced from a CU. Agent cooperation/competition is re-interpreted in terms of knowledge generation/consumption. A coherent notion of logic consequence in a time-dependent environment is proposed. As a result, the traditional dichotomy between reactive and symbolic systems is here exploited as a feature rather than a problem, leading to an integration of behavioural and planning-based approaches.

An extended Warren abstract machine for the execution of structured logic programs

Abstract Extending logic programming towards structuring concepts such as modules, blocks, taxonomy of logic theories and viewpoints leads, from the implementation point of view, to the development of more complex, specialized execution models to achieve acceptable efficiency. In this work we address the effective implementation of a general framework, subsuming standard Prolog, where different languages for structuring logic programs can be efficiently supported and integrated and thus become useful constructs to build real applications. The implementation is based on an extension of the abstract machine (WAM) developed by D. H. D. Warren, obtained by adding a new stack, new registers, and some new instructions to the WAM. In the paper we focus on the design of the extended WAM. Moreover, some performance results are discussed.

Programs as Collections of Communicating Prolog Units

At the current state of the art, people are not encouraged to use logic programming languages for bulding large and complex software systems due to the difficulty of expressing concepts such as modularity, information hiding, data and process abstraction etc. In particular, it is impossible to build a system as a collection of different modules, independently designed and coded, with a lifetime extended till execution time.

Object-Oriented Computations in Logic Programming

When interpreted as a model for structuring programs and organizing computations, the object-oriented paradigm can be thought as a set of abstractions independent of the host language. By generalizing the notion of object state configuration with respect to that embedded in languages based on assignment, this paper explores a relational approach to object-oriented programming. An object-oriented model based on the notion of object as structured logic theory, is introduced, allowing instance creation and configuration as well as computations with partially configured objects. The model is founded on an abductive framework rooted in the basic class/instance model of O-OP, which reconciles dynamic object creation with the declarative reading of LP. Meta-level constraints provide the computational support for the abstract model based on abduction. A simple first-order logic language implementing this model is presented, along with some examples of object-oriented logic computations dealing with intra- and inter-object constraints and with partially specified instances.

A multi-agent framework and programming environment for autonomous robotics

This paper discusses a multi-agent framework for the control of robot systems along with an integrated programming environment which takes advantage of it. An agent society is engaged in a competitive or cooperative interaction under a control metalevel while a particular agent represents the real-time robot machine. By virtue of the support of adequate tools, this schema well lends itself both to a general increase of robot programming capability and flexibility and to rapid prototyping of different architectural solutions. The overall programming environment is built upon the integration of a distributed, extended logic programming environment with a real-time RCCL-based robot server. It is also interfaced to a graphical simulator in which a sensory driven task can be given a preliminary validation. An example of application of the environment to a simple test case concludes the paper.<<ETX>>

Techniques for Implementing Contexts in Logic Programming

In this paper we discuss different techniques for implementing an extension of logic programming for knowledge structuring. The extension we consider, in particular, is based on Contextual Logic Programming. Three different implementation approaches are considered first: meta-interpretation, translation into Prolog code and compilation on an extended Warren Abstract Machine. These approaches are compared from the point of view of both methodology and efficiency. In the last part of the paper we consider a more effective implementation, developed on an industrial Prolog enhanced with the module construct.

An Extensible Frame work for the Development of Coordinated Applications

Distributed programming suffers from the lack of abstractions and tools required to handle and analyse the large amount of information characterising distributed systems. On the other hand, the separation of computation and coordination models definitely simplifies the design of a programming environment for distributed applications. Starting from this consideration, the ACLT coordination model extends the basic Linda kernel, by providing support for heterogeneous multiagent systems, as well as for hybrid agent architectures integrating deduction and reaction. The design of the architectural support for the ACLT model led to the definition of a general-purpose scheme which is powerful enough to be used both for the system extension of the basic communication kernel and for building application-defined development tools. Such an approach is based on the idea of reactive communication abstractions, which can be programmed by agents according to a specification language which is rooted in the same model as the coordination language.

Logic Tuple Spaces for the Coordination of Heterogenous Agents

This work presents ACLT, a coordination model aimed to combine and coordinate heterogeneous agents by means of a communication abstraction inspired to the Linda model, but rooted in a logic framework. The twofold interpretation of a logic tuple space both as a message and as a knowledge repository naturally induces a categorization of agents as logic and non-logic. While non-logic agents adopt the basic Linda kernel, logic agents exploit the full power of the ACLT model, which supports deduction and reasoning over the content of the tuple space. By providing a conceptual framework where logic inference and temporal tuple space evolution coexist, ACLT provides a suitable environment to build heterogeneous multi-agent systems, where hybrid agent architectures can be designed, integrating reasoning capabilities together with reactive behaviours.