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.

We present a small language L and its typing system based on the idea of interaction, one of the important notions in parallel and distributed computing. L is based on, apart from such constructs as parallel composition and process creation, three pairs of communication primitives which use the notion of a session, a semantically atomic chain of communication actions which can interleave with other such chains freely, for high-level abstraction of interaction-based computing. Three primitives enable programmers to elegantly describe complex interactions among processes with a rigorous type discipline similar to ML [4]. The language is given formal operational semantics and a type inference system, regarding which we prove that if a program is well-typed in the typing system, it never causes run-time error due to type inconsistent communication patterns, offering a new foundation for type discipline in parallel programming languages. 1 Introduction The idea of interaction, that is, rec...

By adding reflexion to the chemical machine of Berry and Boudol, we obtain a formal model of concurrency that is consistent with mobility and distribution. Our model provides the foundations of a programming language with functional and object-oriented features. It can also be seen as a process calculus, the join-calculus, which we prove equivalent to the pi-calculus of Milner, Parrow and Walker.

Based on a name-passing calculus and on its typing system the paper shows how to build several language constructors towards a strongly-typed objectoriented concurrent programming language. The basic calculus incorporates the notions of asynchronous labelled messages, concurrent objects composed of labelled methods, and a form of abstraction on processes allowing in particular to declare polymorphic classes. We introduce a notion of values as name-expressions, and show how to create subclasses of existing classes. A systematic translation of the derived constructors into the basic calculus provides for semantics and for typing rules for the new constructors. Introduction Concurrent objects constitute a convenient tool to describe concurrent and distributed computations. Types enforce a discipline in the usage of the programming language constructors that not only provides for partial-correctness, but also helps in writing clear programs. Furthermore, a type for a program often gives s...

. We describe a process extension to a lazy functional programming system, intended for applications with graphical user interfaces (GUIs). In the extended language, dynamically-created processes communicate by asynchronous message passing. We illustrate the use of the language, including as an extended example a simple board game in which squares are implemented as concurrent processes. We also describe a window manager, itself implemented in the extended functional language. Keywords: functional language, processes, concurrency, window manager, Gofer. 1 Introduction and Motivation Most of the time, elements of a graphical user interface (GUI) operate independently. For example, a menu doesn't interact with the rest of the program until the user selects an option. The user can highlight options, open up further menus or move the menu around the screen, all without doing anything that should concern any other element of the program. Popular languages such as C do not readily lend the...

We present a compositional encoding of the fl-calculus into the -calculus. The former, used in the Oz semantics, is a recent small language with equational constraints over logical variables; the latter is a basic calculus of interacting processes. We establish a close correspondence between the reductions in the fl-calculus and its encoding, using weak barbed bisimulation congruence. 1 Introduction In this paper we shall relate two different strands in the semantics of programming languages. One is the concurrent constraints paradigm where facts about data values combine to resolve goals; the other is the communicating processes paradigm where parallel agents interact through data transmission. We shall use two small semantic calculi which embody these paradigms in a rigorous and tractable format: the fl-calculus for concurrent constraints and the -calculus for communicating processes. These calculi have been deemed successful as semantic bases for programming languages in thei...

The join-calculus is a model for distributed programming languages with migratory features. It is an asynchronous process calculus based on static scope and an explicit notion of locality and failures. It allows standard polymorphic ML-like typing and thus an integration in a realistic programming language. It has a distributed implementation on top of the Caml language. We review here some of the results recently obtained in the join-calculus.

Both for interleaving and for non-interleaving semantics, several variants of a pi-calculus bisimilarity can be given which differ on the requirements imposed on name instantiations. Examples are the late, early, open and ground variants. The ground variant is the simplest because it places no requirements on name instantiations. With the exception of open bisimilarities, none of the bisimilarity considered in the literature is a congruence relation on the full pi-calculus language. We show that in the case of (certain forms of) causal bisimulation the late, early, open and ground variants coincide and are congruence relations in the sublanguage of the pi-calculus without matching. We also show that to obtain the same results in the case of the interleaving bisimilarity, in addition to forbidding matching it is necessary to constrain the output prefix.

Data Types (ADTs) and objects in ObjectOriented Languages (OOLs) [9]. He argued that although both are based on the idea of data abstraction, they are fundamentally different. In short, an ADT may be understood as a set with operations, whereas objects are sets of operations. In an ADT, abstraction is achieved by hiding the type of the representation. This hiding is often modeled using an existential quantifier. In OOLs, abstraction is achieved by letting the operations themselves represent the data. The interfaces of the operations need not have any direct relation to the underlying representation at all. One of the consequences of the above is that in an ADT, recursion is seldomly needed in the interface (although it may well be used in the representation). In OOLs, recursion is often essential to the interface. Thus, recursion should be central in models of OOLs. Dinesh Katiyar: Interfaces and typed OOP. Katiyar presented a type system featuring bounded existential quantification...

LCS is an experimental high level parallel programming language aimed at exploring design, implementation and use of programming languages based upon process calculi. LCS extends Standard ML with primitives for concurrency and communication based upon a higher order extension of the CCS formalism. The paper discusses language design, illustrates programming disciplines, and investigates abstract machines for sequential and parallel implementations of the language.