A Coordianted Atomic Action (CA Action) is a unified scheme for coordinating complex concurrent activities and supporting error recovery between multiple interacting objects in distributed object-oriented systems. They constitute a very interesting concept for the structured developement of fault-tolerant distributed applications. To formalize the design of CA actions, this paper introduces a new language called COALA (COordinateed Atomic actions LAnguage). COALA provides both a concrete syntax to write CA actions and a semantics which formally explains the concept. The semantics is given in the formal object-oriented specification language CO-OPN/2. COALA can thus benefit form the formal techniques developed around CO-OPN/2 and use them for the validation and the test of applications written with COALA CA actions.
The messenger paradigm is one of the earliest models which propose the exchange of code to implement computer communication. Code becomes mobile and mobile code is now considered a promising alternative for the implementation of distributed applications. One application of mobile code is in the implementation of software agents which themselves are used to implement complex distributed applications. However, efficient execution environments for mobile code are needed before mobile code can be considered a true technology for distributed applications. Our messenger project has focused at identifying and providing, both at the operating system level and at the language level, the necessary mechanisms for the efficient support of distributed applications built with messengers. Since the project has reached a global consistent point, this paper, that can be considered as a position paper, provides an overview of the theoretical and practical aspects of the whole project. The main result of our work is the definition and implementation of an environment for the execution of messengers and the corresponding language for expressing the messenger behavior, called respectively the M0 platform and the M0 language. In both the language and the environment, minimality and efficiency have been the leitmotiv.
Most distributed systems are built on top of a message exchange infrastructure. Processes coordinate their execution by exchanging messages which are interpreted according to a pre-established set of protocols. We present in this paper a novel way of communicating which does not require the preconfiguration of protocol entities. The host initiating the communication has the ability to instruct the other host “how” the data exchange has to take place. We call this “communication by messengers”. The host that initiates the data exchange sends to the recipient a program called “messenger” which contains all or parts of the protocol logic. After it has been received by the recipient, the messenger is executed and can, if necessary, deliver its payload. Communication by messengers will change the way distributed systems are built. This paper discusses the impact of the messenger paradigm in various fields such as communication protocols, distributed operating systems and intelligent agents.
Electronic documents may obviously no more be considered as a simple representation of their paper counterpart. They become dynamic components whose content may be modified accordingly to users interaction but also in reaction to modifications in the user's environment (such as an update operation in a database). They not only include data but also behavior (Scripts, Applets, etc.) that may aim at different purposes (provide appropriate rendering method, supply interaction mechanism to the users, etc.). They also include the hypertext dimension and play an important role in the management of information as well as associated knowledge. The extensive use of such hyperdocuments through the Internet, to disseminate and interact with pieces of information, is currently gaining in importance. Designing information systems that rely on this emerging paradigm clearly requires new methods to produce, share and access distributed information. The paper focus on the reusability of information in distributed environments. It aims at presenting our document based approach to both model active document fragments and specify appropriate methods to build customized virtual documents on the basis of so-called fragments.
This paper presents first a formal development methodology that enables the validation of formal specifications as well as program codes wrt client's requirements. The methodology is based on the two languages framework: it advocates the joint use of a model-oriented specification and a logical language. Second, the paper describes development guidelines for system design within the proposed methodology. Guidelines, specific to each kind of system, can be defined. They enable the specifier to add progressively the complexity into the system design. Two development processes are proposed: the first one leads to a traditional client/server design; the second one enables to integrate fault-tolerance in the design. Both development processes have been applied on an example and produced a Java program.
The problem addressed in this paper is the following: how to use high-level Petri nets for the reverse engineering of implemented distributed applications. The paper presents a reverse engineering methodology applied on a real (simple) Java applet based client/server application. First, starting from the Java program, several abstraction steps are described using the CO-OPN/2 formal specification language. Then, the paper presents brand new research that studies property preservations during the refinement process
The Java object oriented programming language has been the subject of an important involvement from programmers and the industry. Especially for applications related to the Web. The problem of such a rapid penetration of Java programs into commercial products is that software engineers do not have any methodology and have to develop complex parallel applications. We present a formal development methodology based on the stepwise refinement of CO-OPN/2 formal specifications, using a real Web parallel application. Starting from a centralized view, we present the following refinement steps: data distribution, behavior distribution, communication layer, and Java program. During the whole refinement process, we study the evolution and the verification of one specific property.
This paper proposes the notion of Specification-Carrying Code as an interaction mechanism for self-assembly of au- tonomous decentralised software components. Each au- tonomoussoftware entity incorporates more informationthan its operational behaviour, and publishes more data than its signature. The idea is to provide separately, for each en- tity, a functional part implementing its behaviour - the tra- ditional program code; and an abstract description of the entity's functional behaviour and necessary parameters - a semantic behavioural description under the form of a for- mal specification. Interactions are exclusively based on the specifications and occur among entities with correspond- ing specifications. In the case of autonomic computing sys- tems, in addition to functional aspects, the specification may carry a semantic description of non-functional information related to self-management. This paper presents the prin- ciples of the Specification-Carrying Code paradigm, the as- sociated Service-Oriented Architecture, and it explains how self-managed systems can benefit from this paradigm.
Decentralised systems made of autonomous devices and software are gaining more and more interest. These autonomous el ements usually do not know each other in advance and act without any central control. They thus form a society of devices and software, and as such need: basic interaction mechanisms for understanding each other and a social infrastructure supporting interactions taking place in an uncertain environment. In an effort to go beyond pre-established communication schema and to cope with uncertainty, this paper proposes an interaction mechanism based exclusively: on semantic information expressed using specifications, and on a social infrastructure relying on trust and reputation.
The design and implementation of distributed, self-organising and self-adaptive systems are challenging. This article details our experience gained during the development of self-organising assembly systems, which provide solutions for user-friendly agile manufacturing systems. More specifically, we describe how both a development method for self-organising systems, called MetaSelf, and the above particular application were progressively shaped, each influencing the other.
