Jean-Marc Andreoli

Linear objects: logical processes with built-in inheritance

We present a new framework for amalgamating two successful programming paradigms: logic programming and object-oriented programming. From the former, we keep the delarative reading of programs. From the latter, we select two crucial notions: (i) the ability for objects to dynamically change their internal state during the computation; (ii) the structured representation of knowledge, generally obtained via inheritance graphs among classes of objects. We start with the approach, introduced in concurrent logic programming languages, which identifies objects with proof processes and object states with arguments occurring in the goal of a given process. This provides a clean, side-effect free account of the dynamic behavior of objects in terms of the search tree—the only dynamic entity in logic programming languages. We integrate this view of objects with an extension of logic programming, which we call Linear Objects, based on the possibility of having multiple literals in the head of a program clause. This contains within itself the basis for a flexible form of inheritance, and maintains the constructive property of Prolog of returning definite answer substitutions as output of the proof of non-ground goals. The theoretical background for Linear Objects is Linear Logic, a logic recently introduced to provide a theoretical basis for the study of concurrency. We also show that Linear Objects can be considered as constructive restriction of full Classical Logic. We illustrate the expressive power of Linear Objects compared to Prolog by several examples from the object-oriented domain, but we also show that it can be used to provide elegant solutions for problems arising in the standard style of logic programming.

Focussing and proof construction

Abstract This paper proposes a synthetic presentation of the proof construction paradigm, which underlies most of the research and development in the so-called “logic programming” area. Two essential aspects of this paradigm are discussed here: true non-determinism and partial information. A new formulation of Focussing, the basic property used to deal with non-determinism in proof construction, is presented. This formulation is then used to introduce a general constraint-based technique capable of dealing with partial information in proof construction. One of the baselines of the paper is to avoid to rely on syntax to describe the key mechanisms of the paradigm. In fact, the bipolar decomposition of formulas captures their main structure, which can then be directly mapped into a sequent system that uses only atoms. This system thus completely “dissolves” the syntax of the formulas and retains only their behavioural content as far as proof construction is concerned. One step further is taken with the so-called “abstract” proofs, which dissolves in a similar way the specific tree-like syntax of the proofs themselves and retains only what is relevant to proof construction.

XPECT: a framework for electronic commerce

Electronic commerce is emerging as one of the most important applications on the Internet, with the potential to revolutionize the whole structure of retail merchandising and shopping. There is already a need for an information technology infrastructure that goes well beyond the simple capabilities offered by the current development environments for Internet applications. For electronic commerce to really take off, however, it will have to give shoppers options not available through traditional commercial channels. This implies the further need for an infrastructure that can support complex and flexible services to manage customer tailored requests in the context of highly dynamic networks and federations of providers. To achieve this level of support will mean using the functionalities now considered to be whole applications as the elementary building blocks of e-commerce applications. Among these functionalities are: transactional payment; workflow; and multiparty agreement. To address these issues, we developed XPect, a generic framework for electronic commerce. The XPect framework supports the integration of multiple component functionalities. It is implemented in the Coordination Language Facility, an object based distributed application development tool. CLF assumes an object model of autonomous agents that can engage in interactions, more sophisticated than those in the traditional object paradigm. In addition, CLF allows for dynamically adding new services and for coordinating the access to multiple services.

Constraint Agents for the Information Age

We propose constraints as the appropriate computational constructs for the design of agents with the task of selecting, merging and managing electronic information coming from such services as Internet access, digital libraries. E-mail, or on-line information repositories. Specifically, we introduce the framework of Constraint-Based Knowledge Brokers, which are concurrent agents that use so-called signed feature constraints to represent partially specified information and can flexibly cooperate in the management of distributed knowledge. We illustrate our approach by several examples, and we define application scenarios based on related technology such as Telescript and workflow management systems.

The constraint-based knowledge broker model: semantics, implementation and analysis

Abstract Imagine distributed knowledge processing with autonomous activities and decentralized control where the handling of partial knowledge does not result in unclear semantics or failure-prone behavior. In this paper, a modular approach is taken where concurrent agents, called constraint-based knowledge brokers (CBKBs), process and generate new knowledge in the presence of partial information. CBKBs apply constraint solving techniques to the domain of information gathering in distributed environments. Constraints are exploited to allow partial specification of the requested information, and to relate information requests from multiple sources. We present a mathematical model where the semantics of the knowledge system is described using a standard fixed-point procedure. A basic execution model is then provided. This is incrementally refined to tackle problems of inter-argument dependencies (that arise with constraints relating information requests from different sources), of knowledge reuse inside the knowledge generators, and of recursion control. The model refinements are illustrated by a detailed complexity analysis in terms of the number of agents needed and of the number of messages sent, distinguished by requests and answers of the involved broker agents. A detailed example shows a broker-based chart-parser for unification grammars with feature terms implemented using CBKBs. As we shall point out, this apparently abstract example can be easily generalized to full-fledged information gathering.

LO and behold! Concurrent structured processes

We introduce a novel concurrent logic programming language, which we call LO, based on an extension of Horn logic. This language enhances the process view of objects implementable in Horn-based concurrent logic programming languages with powerful capabilities for knowledge structuring, leading to a flexible form of variable-structure inheritance. The main novelty about LO is a new kind of OR-concurrency which is dual to the usual AND-concurrency and provides us with the notion of structured process. Such OR-concurrency can be nicely characterized with a sociological metaphor as modelling the internal distribution of tasks inside a complex organization; this complements the external cooperation among different entities accounted for by AND-concurrency.

Rule-Based Object Coordination

We discuss a framework in which the traditional features of objects (encapsulation, communication, etc.) are enhanced with synchronization and coordination facilities, using the declarative power of rules. We propose two interpretations of rules, one re-active and the other proactive, corresponding to different kinds of interactions between the rules and the objects. Finally, we consider the problem of capturing domain specific knowledge within a general coordination framework, for which constraints offer a promising direction of research.

The coordination language facility: coordination of distributed objects

The development of communication infrastructures and the rapid growth of networking facilities in information technologies increase information mobility and the decentralisation of work processes in industry and services. This evolution leads to increasing demands on the coordination of information systems. However, information technologies available today are capable of supporting only interoperability of information systems from the point of view of communication infrastructures. This makes possible an easy exchange of information but provides no support for coordination. To fill this gap, we propose the Coordination Language Facility (CLF) as a coordination layer on top of distributed systems infrastructures such as CORBA-compliant Object Request Brokers. The CLF provides support for the coordination of heterogeneous, possibly distributed, active objects within larger units implementing (work) processes. On one hand, coordinator objects are declaratively implemented as rules. On the other hand, the objects participating in a coordination (participants) must instantiate a minimal interface which specifies the negotiation dialogue invoked, at run-time, by coordinators. The coordination activity is split between the implementation of the interface on the participants’side and the execution of the rules on the coordinators’ side, thus offering a clear separation of concerns between local and global activities. The interface is specified using the CORBA standard for distributed objects, removing issues of heterogeneity and allowing each component to be implemented in the most appropriate language and environment.

Multiparty negotiation of dynamic distributed object services

Abstract Object-oriented programming (OOP) has proven a very useful paradigm for supporting client-server computing within the context of local-area networks, where stable assumptions can be made about the available resources and services and where interactions between clients and servers are relatively simple. By implementing servers as objects, access to services can be kept separate from implementation, thus making client-server applications both more flexible and easier to maintain. Now that we are moving from single enterprise computing to the inter-organizational information world of the Internet and WWW, object-oriented programming must adapt itself to new client-server requirements. Specifically, there is need of coping with situations where new services can be dynamically added to servers, and where clients may need to coordinate the access to multiple services, rather than to single individual ones. In this paper, we describe the object model of the Coordination Language Facility, a programming framework that extends OOP with constructs that support dynamic services and multi-service coordination. We illustrate the use of these constructs through the application domain of distributed workflow.

True Concurrency Semantics for a Linear Logic Programming Language with Braodcast Communication

We define a true concurrency semantics for LO, a reactive programming language characterized by dynamically reconfigurable agents (processes), with interagent communication implemented as broadcasting and logical operators corresponding to Linear Logic connectives. Our semantic model is given by the well-known Chemical Abstract Machine formalism, where concurrent events happen in the form of chemical-like reactions. Our approach consists of mapping LO computations into CHAM computations and is easily generalizable to CHAM-related models like CHARMs, rewriting logics etc. We propose two mappings from LO to CHAMs, both making use of the “membrane” mechanism of the CHAM, but differing in the choice of active elements: in one case, the messages are passive and the agents are the active entities which perform read and write operations; by contrast, in the second case, the agents are passive with respect to communication and the messages themselves move around the solution to deliver their content to each agent. The results in the paper show the effectiveness of the CHAM and related formalisms as abstract frameworks for modeling the implementation of practical languages on parallel architectures. Furthermore, they provide insight on the two following issues: (i) the amount of synchronization needed to add broadcasting to one-to-one communication primitives; (ii) the problem of parallel searching for Linear Logic proofs.