Jean-Pierre Briot

Concurrency and distribution in object-oriented programming

This paper aims at discussing and classifying the various ways in which the object paradigm is used in concurrent and distributed contexts. We distinguish among the library approach, the integrative approach, and the reflective approach. The library approach applies object-oriented concepts, as they are, to structure concurrent and distributed systems through class libraries. The integrative approach consists of merging concepts such as object and activity, message passing, and transaction, etc. The reflective approach integrates class libraries intimately within an object-based programming language. We discuss and illustrate each of these and point out their complementary levels and goals.

From active objects to autonomous agents

The authors describe how they extended a framework of active objects, named Actalk, into a generic multiagent platform, named DIMA. They discuss how they implemented this extension and report on one DIMA application that simulates economic models.

Adaptive replication of large-scale multi-agent systems: towards a fault-tolerant multi-agent platform

In order to construct and deploy large-scale multi-agent systems, we must address one of the fundamental issues of distributed systems, the possibility of partial failures. This means that fault-tolerance is an inevitable issue for large-scale multi-agent systems. In this paper, we discuss the issues and propose an approach for fault-tolerance of multi-agent systems. The starting idea is the application of replication strategies to agents, the most critical agents being replicated to prevent failures. As criticality of agents may evolve during the course of computation and problem solving, and as resources are bounded, we need to dynamically and automatically adapt the number of replicas of agents, in order to maximize their reliability and availability. We will describe our approach and related mechanisms for evaluating the criticality of a given agent (based on application-level semantic information, e.g. interdependences, and also system-level statistical information, e.g., communication load) and for deciding what strategy to apply (e.g., active replication, passive) how to parameterize it (e.g., number of replicas). We also will report on experiments conducted with our prototype architecture (named DimaX).

Programming with explicit metaclasses in Smalltalk-80

This paper discusses the introduction of explicit metaclasses a la ObjVlisp into the Smalltalk-80 language. The rigidity of Smalltalk metaclass architecture motivated this work. We decided to implement the ObjVlisp model into the standard Smalltalk-80 system. The resulting combination defines the Classtalk platform. This platform provides a full-size environment to experiment with class-oriented programming by combining implicit metaclasses a la Smalltalk and explicit metaclasses a la ObjVlisp. Obviously, these experiments are not limited to the Smalltalk world and will be useful to understand and practice the metaclass concept advocated by modern object-oriented languages such as ObjVlisp and CLOS.

Dynamic and adaptive replication for large-scale reliable multi-agent systems

In order to make large-scale multi-agent systems reliable, we propose an adaptive application of replication strategies. Critical agents are replicated to avoid failures. As criticality of agents may evolve during the course of computation and problem solving, we need to dynamically and automatically adapt the number of replicas of agents, in order to maximize their reliability and availability based on available resources. We are studying an approach and mechanisms for evaluating the criticality of a given agent (based on application-level semantic information, e.g. messages intention, and also system-level statistical information, e.g., communication load) and for deciding what strategy to apply (e.g., active or passive replication) and how to parameterize it (e.g., number of replicas).

An application of multi-agent coordination techniques in air traffic management

Air traffic management (ATM) involves collaborative work from several actors: traffic flow managers, air traffic controllers (controllers) and pilots. The ever-increasing demand for commercial air travel poses great challenges to todays airspace-centered ATM system in which each controller only undertakes the responsibility to control the aircraft flying through her/his own airspace (sector). Any aircraft bunching occurring in a sector has the potential to cause the risk of instant traffic overload in another sector. It is therefore essential to further decentralize the system by redistributing the responsibility as well as workload. This paper presents our research to support this redistribution by setting up a methodological framework using multi-agent coordination techniques. A recently identified problem, i.e. real-time traffic synchronization, is chosen as the first application.

Towards reliable multi-agent systems: An adaptive replication mechanism

Distributed cooperative applications are now increasingly being designed as a set of autonomous entities, named agents, which interact and coordinate (thus named a multi-agent system). Such applications are often very dynamic: new agents can join or leave, they can change roles, strategies, etc. This high dynamicity creates new challenges to the traditional approaches of fault-tolerance. In this paper, we will focus on crash failures, with usual preventive approaches by replication. But, as criticality of agents may evolve during the course of computation and problem solving, static design is not appropriate. Thus we need to dynamically and automatically identify the most critical agents and to adapt their replication strategies (e.g., active or passive, number of replicas), in order to maximize their reliability and their availability. In this paper, we describe a prototype architecture, supporting adaptive replication. We also discuss and compare various control strategies for replication, one using agent roles, and another using inter-agent dependences as types of information to infer and estimate criticality of agents. Experiments and measurements are also reported.

Plan-based replication for fault-tolerant multi-agent systems

The growing importance of multi-agent applications and the need for a higher quality of service in these systems justify the increasing interest in fault-tolerant multi-agent systems. In this article, we propose an original method for providing dependability in multi-agent systems through replication. Our method is different from other works because our research focuses on building an automatic, adaptive and predictive replication policy where critical agents are replicated to avoid failures. This policy is determined by taking into account the criticality of the plans of the agents, which contain the collective and individual behaviors of the agents in the application. The set of replication strategies applied at a given moment to an agent is then fine-tuned gradually by the replication system so as to reflect the dynamicity of the multi-agent system

A fault-tolerant multi-agent framework

To make large-scale multi-agent systems reliable, we propose an adaptive application of replication strategies. Critical agents are replicated to avoid failures. As criticality of agents may evolve during the course of computation and problem solving, we need to dynamically and automatically adapt the number of replicas of agents, in order to maximize their reliability and availability based on available resources. We are studying an approach and mechanisms for evaluating the criticality of a given agent and for deciding what strategy to apply (e.g., active replication, passive) and how to parameterize it (e.g., number of replicas).

A modeling framework for generic agent interaction protocols

Agent-UML (AUML) extended UML in order to facilitate the modeling process for agent based systems. It offers several graphical notations, including protocol diagrams which represent agent interaction protocols. In this paper, we describe an AUML-based framework to specify generic protocols. We call generic protocols, agent interaction protocols where only a general behavior of the interacting entities can be described. From AUML protocol diagrams, we identified five fundamental concepts on top of which we defined formal specifications of generic protocols. Through our specifications, we addressed a lack in generic protocol representation by emphasizing the description of actions performed in the course of interactions based on such protocols. The framework we developed is formal, expressive and of practical use. It helps decouple interaction concerns from the rest of an agents architecture. As an application, we used this framework to publish the specifications of generic protocols for agent interactions in several multi-agent system applications we developed. Additionally, the framework helped us address two issues faced in the design of agent interactions based on generic protocols, protocol configuration and their dynamic selection.