Constraint Logic Programming (CLP) is a merger of two declarative paradigms: constraint solving and logic programming. Although a relatively new field, CLP has progressed in several quite different directions. In particular, the early fundamental concepts have been adapted to better serve in different areas of applications. In this survey of CLP, a primary goal is to give a systematic description of the major trends in terms of common fundamental concepts. The three main parts cover the theory, implementation issues, and programming for applications.

We extend the π-calculus with polyadic synchronisation, a generalisation of the communication mechanism which allows channel names to be composite. We show that this operator embeds nicely in the theory of π-calculus, we suggest that it permits divergence-free encodings of distributed calculi, and we show that a limited form of polyadic synchronisation can be encoded weakly in π-calculus. After showing that matching cannot be derived in π-calculus, we compare the expressivity of polyadic synchronisation, mixed choice and matching. In particular we show that the degree of synchronisation of a language increases its expressive power by means of a separation result in the style of Palamidessi's result for mixed choice.

We prove that both the synchronous data flow language Lustre restricted to finite value types and the synchronous state oriented language Argos are embedded in the synchronous paradigm Timed Concurrent Constraint (tcc). In fact, for each of the two languages we provide a tcc language encoding it compositionally w.r.to the structure of programs. Moreover, we prove that the "strong abortion" mechanism of the synchronous imperative language Esterel can be encoded in tcc. 1

Abstract not found

The concept of embedding has recently been introduced as a formal tool to study the relative expreive power of (concurrent) programming languages. We use the notion of "modular embedding" to compare various dialects of CSP and ACSP (Asynchronous CSP), which differ on the kind of communication primitives allowed in the guards: all, only input, or none. Concerning the synchronous paradigm, we show that CSP is strictly more powerful than CSPx (the version of CSP with no output guards), and that CSPx is strictly more powerful than CSP (the version of CSP with no communication primitives in the guards). The first separation result does not hold in the asynchronous variants of these languages: since asynchronous output guards cannot be influenced by the environment (they can always proceed), it is ir- relevant to have or not to have them in the language. Therefore, ACSP and ACSPx are equivalent. Still, they are strictly more expressive than ACSP. Finally, we come to compare the synchronous and asynchronous paradigms. The asynchronous communication can be modeled synchronously by means of "buffer" processes. On the other hand, synchronous communication (when not fully used to control nondeterminism) can be modeled asynchronously by means of acknowledgement messages. As a consequence, CSPz, ACSP, and ACSPx are equivalent. An interesting corollary of these results is that ACSP is strictly less powerful than CSP.

Abstract. In this paper, we study eight asynchronous communication primitives, arising from the combination of three features: arity (monadic vs polyadic data), communication medium (message passing vs shared dataspaces) and patternmatching. Each primitive has been already used in at least one language appeared in literature; however, to uniformly reason on such primitives, we plugged them in a common framework inspired by the asynchronous ¢-calculus. By means of possibility/impossibility of ‘reasonable ’ encodings, we compare every pair of primitives to obtain a hierarchy of languages based on their relative expressive power. 1

The endeavor to extend logic programming to a language suitable for concurrent systems has stimulated in the last decade an intensive research, resulting in a large variety of proposals. A common feature of the various approaches is the attempt to define mechanisms for concurrency within the logical paradigm, the driving ideal being the balance between expressiveness and declarative reading. In this survey we present the motivations, the principal lines along which the field has developed, the various paradigms which have been proposed, and the main approaches to the semantic foundations. 1 Introduction Among the various reasons which have contributed to the popularity of logic programming, one is the opinion that it is an inherently parallel language, therefore suitable for parallel and distributed architectures. The pure language can already be regarded as a model for parallel computation: in the so-called process interpretation (van Emden and de Lucena 1982; Shapiro 1983), the goal...

. Although very simple and elegant, Linda-style coordination models lack the notion of time, and are therefore not able to precisely model real-life coordination applications, featuring time-outs and soft real-time constraints. This paper aims at introducing time in these models. To that end, we consider two notions of time, relative time and absolute time, and, for each notion, two types of features. On the one hand, with respect to relative time, we describe two extensions: (i) a delay mechanism to postpone the execution of communication primitives, and (ii) explicit deadlines on the validity of tuples and on the duration of suspension of communication operations. On the other hand, for absolute time, we introduce: (iii) a wait primitive capable of waiting till an absolute point of time, and (iv) time intervals, both on tuples in the data store and on communication operations. The resulting four coordination models are analyzed and compared both from the semantics viewp...

A number of different coordination models for specifying inter-process communication and synchronisation rely on a notion of shared dataspace. Many of these models are extensions of the Linda coordination model, which includes operations for adding, deleting and testing the presence/absence of data in a shared dataspace. We compare the expressive power of three classes of coordination models based on shared dataspaces. The first class relies on Linda's communication primitives, while a second class relies on the more general notion of multi-set rewriting (e.g., like Bauhaus Linda or Gamma). Finally, we consider a third class of models featuring communication transactions that consist of sequences of Linda-like operations to be executed atomically (e.g., like in Shared Prolog or PoliS).

A number of dierent coordination models for specifying inter-process communication and synchronisation rely on a notion of shared dataspace. Many of these models are extensions of the Linda coordination model, which includes operations for adding, deleting and testing the presence/absence of data in a shared dataspace. We compare the expressive power of three classes of coordination models based on shared dataspaces. The rst class relies on Linda's communication primitives, while a second class relies on the more general notion of multi-set rewriting (e.g., like Bauhaus Linda or Gamma). Finally, we consider a third class of models featuring communication transactions that consist of sequences of Linda-like operations to be executed atomically (e.g., like in Shared Prolog or PoliS). 1 Introduction 1.1 Motivations As motivated by the constant expansion of computer networks and illustrated by the development of distributed applications, the design of modern software systems centers o...