Lone Leth

A Facile Tutorial

The Facile system combines language, compiler and distributed system technology into a programming environment supporting the rapid construction of reliable and sophisticated end-user applications operating in distributed computing environments. In particular, Facile is well suited for construction of systems based on the emerging “mobile agents” principle.

Some facile chemistry

In this paper we use the chemical abstract machine (CHAM) framework [BeB90, BeB92, Bou94] for discussing various semantics for the Facile programming language [GMP89, GMP90, FAR93] and for formalising (parts of) its implementations. We use these formal descriptions to argue (informally) about implementability and cost of implementation in terms of low level machinery needed to implement the given semantics.We take the Facile language as source for discussion, but the results also apply to several other new languages such as CML [Rep91, BMT92] and Poly/ML [Mat91]. Characteristic for all these languages is that they combine ideas from the λ-calculus and process algebra, such as CCS [Mil80, Mil89], to support high level constructs for programming concurrent, parallel and/or distributed systems.The full version of this extended summary can be found in [LeT94].

Some Issues in the Semantics of Facile Distributed Programming

Facile is an experimental programming language intended to support applications that require a combination of distribution and complex computation. The language originates from an integration of the typed call-by-value λ-calculus with a model of concurrency derived from Milners CCS. At a theoretical level, an operational semantics has been developed in terms of labelled transition systems, and a notion of observability of programs has been defined by extending the notion of bisimulation. An experimental implementation currently supports distributed programming over networks of workstations. The implementation, obtained by extending the ML language, supports polymorphic types as well as mobility of functions, processes and communication channels across a distributed computing environment. A number of language constructs have been added or modified to handle certain issues that arise with real distribution. These include the need to control the locality of computation in a physically distributed environment, the potentially expensive implementation of certain operators and the need for a system to tolerate partial failures. In this paper we discuss a possible approach for the operational semantics of these constructs that follows the Facile philosophy and some recent results in concurrency theory.

From a concurrent λ-calculus to the π-calculus

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 λ∥-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 λ∥-calculus into the π-calculus.

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.

FACILE—From Toy to Tool

The FACILE system combines language, compiler, and distributed system technology into a programming environment supporting the rapid construction of reliable and sophisticated end-user applications operating in distributed computing environments. In particular, FACILE is well suited for construction of systems based on the emerging and increasingly popular “mobile agents” principle.

Analysis of Facile Programs: A Case Study

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.

Causality for debugging mobile agents

Abstract. Mobile agents, i.e. pieces of programs that can be sent around networks of computers, appear more and more frequently on the Internet. These programs may be seen as an enrichment of traditional distributed computing, and structuring applications using mobile agents is destined to become the de facto way of constructing distributed systems in the near future. Since mobile agents may carry communication links with them as they move across the network, they create very dynamic interconnectio n 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 enables us to easily recover non-interleaving semantics for Facile by looking only at the labels of transitions. We use the new 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 Brussels, 1995. We also adopt our causal semantics to analyse the specification of a prefetch pipeline processor.

Understanding Mobile Agents via a Non-Interleaving Semantics for Facile

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 Brussels, 1995.