We present a model of distributed computation which is based on a fragment of the pi-calculus relying on asynchronous communication. We enrich the model with the following features: the explicit distribution of processes to locations, the failure of locations and their detection, and the mobility of processes. Our contributions are two folds. At the specification level, we give a synthetic and flexible formalization of the features mentioned above. At the verification level, we provide original methods to reason about the bisimilarity of processes in the presence of failures.

We study two encodings of the asynchronous #-calculus with input-guarded choice into its choice-free fragment. One encoding is divergence-free, but refines the atomic commitment of choice into gradual commitment. The other preserves atomicity, but introduces divergence. The divergent encoding is fully abstract with respect to weak bisimulation, but the more natural divergence-free encoding is not. Instead, we show that it is fully abstract with respect to coupled simulation, a slightly coarser---but still coinductively defined---equivalence that does not enforce bisimilarity of internal branching decisions. The correctness proofs for the two choice encodings introduce a novel proof technique exploiting the properties of explicit decodings from translations to source terms.

We obtain a new formalism for concurrent object-oriented languages by extending Abadi and Cardelli's imperative object calculus with operators for concurrency from the-calculus and with operators for synchronisation based on mutexes. Our syntax of terms is extremely expressive; in a precise sense it unifies notions of expression, process, store, thread, and configuration. We present a chemical-style reduction semantics, and prove it equivalent to a structural operational semantics. We identify a deterministic fragment that is closed under reduction and show that it includes the imperative object calculus. A collection of type systems for object-oriented constructs is at the heart of Abadi and Cardelli's work. We recast one of Abadi and Cardelli's first-order type systems with object types and subtyping in the setting of our calculus and prove subject reduction. Since our syntax of terms includes both stores and running expressions, we avoid the need to separate store typing from typing of expressions. We translate asynchronous communication channels and the choice-free asynchronous-calculus into our calculus to illustrate its expressiveness; the types of read-only and write-only channels are supertypes of read-write channels.

We introduce a calculus which is a direct extension of both the and the π calculi. We give a simple type system for it, that encompasses both Curry's type inference for the -calculus, and Milner's sorting for the π-calculus as particular cases of typing. We observe that the various continuation passing style transformations for -terms, written in our calculus, actually correspond to encodings already given by Milner and others for evaluation strategies of -terms into the π-calculus. Furthermore, the associated sortings correspond to well-known double negation translations on types. Finally we provide an adequate cps transform from our calculus to the π-calculus. This shows that the latter may be regarded as an "assembly language", while our calculus seems to provide a better programming notation for higher-order concurrency.

We present a simple extension of the ß-calculus with located actions and channels and with location names as first-class data, which models the notion of locality and failure present in the higher-order, distributed programming language Facile. The interaction between localities and failures distinguishes our approach from previous ones where the notion of locality is considered in isolation. We argue that the combination of these two features leads, at least from the distributed programming viewpoint, to a more natural semantics. We then discuss the translation of this calculus into a standard simply-sorted ß-calculus and show its adequacy with respect to a barbed bisimulation based semantics. In the translation each location is represented by a special process which interacts, by means of a simple protocol, with any process of the original program that wants to access resources depending on that location. We also employ our translation in the verification of a very simple fault-toler...

. Mobile agents, i.e. pieces of programs that can be sent around networks of computers, are starting to appear on the Internet. Such programs may be seen as an enrichment of traditional distributed computing. Since mobile agents may carry communication links with them as they move across the network, they create very dynamic interconnection structures that can be extremely complex to analyse. In this paper we analyse a fragment of a system based on the mobile agent principle written in the Facile programming language. We propose a Structural Operational Semantics (SOS) for Facile, giving a proved transition system that records encodings of the derivation trees of transitions in their labels. This information allows us to easily recover non-interleaving semantics for Facile by looking only at the labels of transitions. We use the new Facile semantics to debug an agent based system. This example is a scaled down version of a system demonstrated at the European IT Conference Exhibition in...

Mobile agents, i.e. pieces of programs that can be sent around networks of computers, are starting to appear on the Internet. Such programs may be seen as an enrichment of traditional distributed computing. Since mobile agents may carry communication links with them as they move across the network, they create very dynamic interconnection structures that can be extremely complex to analyse. In this paper we study an example of a system based on the mobile agent principle written in the Facile programming language. We propose a Structural Operational Semantics (SOS) for Facile, giving a proved transition system that records encodings of the derivation trees of transitions in their labels. This information allows us to easily recover noninterleaving semantics for Facile by looking only at the labels of transitions. We use the new Facile semantics to debug an agent based system. This example is a scaled down version of a system demonstrated at the European IT Conference Exhibition in Brus...

. Mobile agents, i.e. pieces of programs that can be sent around networks of computers, are starting to appear on the Internet. Such programs may be seen as an enrichment of traditional distributed computing. Since mobile agents may carry communication links with them as they move across the network, they create very dynamic interconnection structures that can be extremely complex to analyse. In this paper we apply a non-interleaving semantics to analyse a system based on the mobile agent principle written in the Facile programming language. This example is a scaled down version of a system demonstrated at the European IT Conference Exhibition in Brussels, 1995. This paper further develops a non-interleaving semantics for Facile, first presented in [4]. We develop a Structural Operational Semantics (SOS) for Facile, giving a proved transition system that records encodings of the derivation trees of transitions in their labels. This information allows us to easily recover non-interleavi...

Abstract not found

. We explore the (dynamic) semantics of a simply typed - calculus enriched with parallel composition, dynamic channel generation, and input-output communication primitives. The calculus, called the k - calculus, can be regarded as the kernel of concurrent-functional languages such as LCS, CML and Facile, and it can be taken as a basis for the definition of abstract machines, the transformation of programs, and the development of modal specification languages. The main technical contribution of this paper is the proof of adequacy of a compact translation of the k -calculus into the ß-calculus. 1 Introduction Programming languages that combine functional and concurrent programming, such as LCS [4], CML [11] and Facile [5, 14], are starting to emerge and get applied -- some, like Facile, in industrial settings. These languages are conceived for programming of reactive systems and distributed systems. A main motivation for using such languages is that they offer integration of differe...