The π-calculus offers an attractive basis for concurrent programming. It is small, elegant, and well studied, and supports (via simple encodings) a wide range of high-level constructs including data structures, higher-order functional programming, concurrent control structures, and objects. Moreover, familiar type systems for the -calculus have direct counterparts in the π-calculus, yielding strong, static typing for a high-level language using the π-calculus as its core. This paper describes Pict, a strongly-typed concurrent programming language constructed in terms of an explicitly-typed-calculus core language.

The tcc model is a formalism for reactive concurrent constraint programming. We present a model of temporal concurrent constraint programming which adds to tcc the capability of modeling asynchronous and non-deterministic timed behavior. We call this tcc extension the ntcc calculus. We also give a denotational semantics for the strongest-postcondition of ntcc processes and, based on this semantics, we develop a proof system for linear-temporal properties of these processes. The expressiveness of ntcc is illustrated by modeling cells, timed systems such as RCX controllers, multi-agent systems such as the Predator /Prey game, and musical applications such as generation of rhythms patterns and controlled improvisation. 1

We investigate concurrency as unifying computational paradigm which integrates functional, constraint, and object-oriented programming. We propose the ae-calculus as a uniform foundation of concurrent computation and formally relate it to other models: The ae- calculus with equational constraints provides for logic variables and is bisimilar to the fl-calculus. The ae-calculus without constraints is a proper subset of the -calculus. We prove its Turing completeness by embedding the eager -calculus in continuation passing style. The ae-calculus over an arbitrary constraint system is an extension of the standard cc-model with procedural abstraction.

Gert Smolka Programming Systems Lab DFKI and Universitat des Saarlandes Postfach 15 11 50, D-66041 Saarbrucken, Germany smolka@dfki.de, http://www.ps.uni-sb.de/~smolka/ To appear in Proceedings of the 1998 European Joint Conferences on Theory and Practice of Software (ETAPS), Lisbon, Portugal, LNCS, Springer-Verlag, Berlin, 1998.

The tcc paradigm is a formalism for timed concurrent constraint programming. Several tcc languages di#ering in their way of expressing infinite behavior have been proposed in the literature. In this paper

We investigate functional computation as a special form of concurrent computation.

The foundation of Prolog's success is the high abstraction level of its declarative subset, namely first-order Horn clause logic with SLDNF resolution. What's missing from Prolog is that little attempt is made to give the same foundation to anything outside the declarative subset. We argue that multiparadigmprogramming can remedy this lack. We give a foundation for multiparadigmprogramming and we show how it is realized in the Oz language and system. Oz naturally encompasses multiple styles of programming, including (constraint) logic, functional, and concurrent object-oriented programming, by providing a common underlying foundation for these styles through a simple formal model in the concurrent constraint paradigm. We illustrate the integrative programming model with paradigmatical code examples.

. We present the ae-calculus, a relational calculus parametrized with a logical constraint system. The ae-calculus provides for higherorder relational programming with first-order constraints, and subsumes higher-order functional programming as a special case. It captures important aspects of the concurrent constraint programming language Oz. We prove the uniform confluence of the ae-calculus. Uniform confluence implies that all maximal derivations issuing from a given expression have equal length. But even confluence of a nonfunctional calculus modelling computation with partial information is interesting on its own right. 1 Introduction We present the ae-calculus, a relational calculus parametrized by a logical constraint system. The ae-calculus provides for higher-order relational programming with first-order constraints. The ae-calculus captures interesting aspects of the concurrent constraint programming language Oz [3]. It is a minimalistic subcalculus of the Oz-Calculus [12] wh...

Abstract not found

We implement the classical Damas-Milner type inference algorithm in a calculus with higher-order abstractions and 1st-order constraints. We encode mono(morphic) types as constraints, and poly(morphic) types as abstractions over monotypes. Our calculus ae deep is intended as computation model of a concrete programming language, i.e., to be what the-calculus is for ML, or the fl-calculus [8] for Oz [2]. Unlike usual in programming language research, ae deep allows reduction below abstraction. This allows to simplify our encoding of polytypes before usage. In the envisaged programming language, the type inferencer can be run just as specified. We claim that deep reduction is one of the essential features for such a high-level implementation of type inference or abstract interpretation algorithms [4]. The algorithm can also be viewed as an extension of Wand's [9] towards let-polymorphism. Like Wand's, our algorithm is easily modified to supply other monomorphic type systems with ML style polymorphism.