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 investigate whether the π-calculus is able to serve as a good foundation for the design and implementation of a strongly-typed concurrent programming language. The first half of the dissertation examines whether the π-calculus supports a simple type system which is flexible enough to provide a suitable foundation for the type system of a concurrent programming language. The second half of the dissertation considers how to implement the π-calculus efficiently, starting with an abstract machine for π-calculus and finally presenting a compilation of π-calculus to C. We start the dissertation by presenting a simple, structural type system for π-calculus, and then, after proving the soundness of our type system, show how to infer principal types for π-terms. This simple type system can be extended to include useful type-theoretic constructions such as recursive types and higherorder polymorphism. Higher-order polymorphism is important, since it gives us the ability to implement abstract datatypes in a type-safe manner, thereby providing a greater degree of modularity for π-calculus programs. The functional computational paradigm plays an important part in many programming languages. It is well-known that the π-calculus can encode functional computation. We go further and show that the type structure of λ-terms is preserved by such encodings, in the sense that we can relate the type of a λ-term to the type of its encoding in the π-calculus. This means that a π-calculus programming language can genuinely support typed functional programming as a special case. An efficient implementation of π-calculus is necessary if we wish to consider π-calculus as an operational foundation for concurrent programming. We first give a simple abstract machine for π-calculus and prove it correct. We then show how this abstract machine inspires a simple, but efficient, compilation of π-calculus to C (which now forms the basis of the Pict programming language implementation).

CBS is a simple and natural CCS-like calculus where processes speak one at a time and are heard instantaneously by all others. Speech is autonomous, contention between speakers being resolved nondeterministically, but hearing only happens when someone else speaks. Observationally meaningful laws differ from those of CCS. The change from handshake communication in CCS to broadcast in CBS permits several advances. (1) Priority, which attaches only to autonomous actions, is simply added to CBS in contrast to CCS, where such actions are the result of communication. (2) A CBS simulator runs a process by returning a list of values it broadcasts. This permits a powerful combination, CBS with the host language. It yields several elegant algorithms. Only processes with a unique response to each input are needed in practice, so weak bisimulation is a congruence. (3) CBS subsystems are interfaced by translators; by mapping messages to silence, these can restrict hearing and hide speech. Reversi...

Machine" [BB90], except that there are no "cooling" and "heating" transitions (the process sets of this semantics can be thought of as perpetually "hot" solutions). The concurrent evaluation relation extends "7\Gamma!" to finite sets of terms (i.e., processes) and adds additional rules for process creation, channel creation, and communication. We assume a set of process identifiers, and define the set of processes and process sets as: ß 2 ProcId process IDs p = hß; ei 2 Proc = (ProcId \Theta Exp) processes P 2 Fin(Proc) process sets We often write a process as hß; E[e]i, where the evaluation context serves the role of the program counter, marking the current state of evaluation. Definition4. A process set P is well-formed if for all hß; ei 2 P the following hold: -- FV(e) = ; (e is closed), and -- there is no e 0 6= e, such that hß; e 0 i 2 P. It is occasionally useful to view well-formed process sets as finite maps from ProcId to Exp. If P is a finite set of process state...

Functional programming languages have traditionally lacked complete, flexible, and yet referentially transparent I/O mechanisms. Previous proposals for I/O have used either the notion of lazy streams or continuations to model interaction with the external world. We discuss and generalize these models and introduce a third, which we call the systems model, to perform I/O. The expressiveness of the styles are compared by means of an example. We then give a series of surprisingly simple translations between the three models, demonstrating that they are not as different as their programming styles suggest, and implying that the styles could be mixed within a single program. The need to express non-deterministic behavior in a functional language is well recognized. So is the problem of doing so without destroying referential transparency. We survey past approaches to this problem, and suggest a solution in the context of the I/O models described. The I/O system of the purely func...

. [Pra91, Pra92] develop CBS, a CCS-like calculus [Mil89] where processes communicate by broadcasting values along a single channel. These values are hidden or restricted by translation to noise. This paper types CBS and restricts it to processes with a unique response to each input. Nondeterminism arises only if two processes in parallel both wish to transmit. These restrictions do not reduce the programming power of CBS. But strong and weak bisimulation can now be defined exactly as in CCS, yet capture observationally meaningful relations. Weak bisimulation is a congruence. This paper also shows how to program in CBS in a (lazy) ML framework. A simple CBS simulator is given, and a parallel implementation discussed. The simulator represents data evaluation, recursion and conditionals directly in Lazy ML. It implements an extended CBS with evaluation as well as communication transitions. [Pra91, Pra92] develop a CCS-like [Mil89] calculus of broadcasting systems, CBS. This paper continu...

Computation can be modelled as a sequence of values, each broadcast by one agent and instantaneously audible to all those in parallel with it. Listening agents receive the value; others lose it. Subsystems interface via translators; these can scramble values and thus hide or restrict them. Examples show the calculus describing this model to be a powerful and natural programming tool. Weak bisimulation, a candidate for observational equivalence, is defined on the basis that receiving a value can be matched by losing it.

The -calculus offers an attractive basis for concurrent programming languages. It is small, elegant, and well understood, and it supports, via simple encodings,a wide range of high-level constructs such as structured data, higher-order programming, concurrent control structures, and objects. Moreover, familiar type systems for the -calculus have direct counterparts in the -calculus, yielding strong, static typing for high-level languages defined in this way. 1 Introduction Though it originated some years before computer science itself, the -calculus has come to be regarded as a canonical calculus capturing the notion of sequential computation in an elegant, mathematically tractable presentation. Many of the fundamental issues of sequential programming languages can profitably be studied by considering them in the more abstract setting of the -calculus. Conversely, the -calculus has strongly influenced the design of many programming languages, notably McCarthy's LISP [McC78]. Mil...

. The UniForM Concurrency Toolkit is a comprehensive library of abstract data types for shared memory and message passing communication that extends Concurrent Haskell with a concept of dynamic types, thread identity, thread local state and selective communication as found in CML. Notable features of the toolkit are its support for reentrant monitors, interactors providing iterative choice and the uniform representation of internal channel events as well as external tool events of the environment in the form of first class synchronous event values. 1 Introduction The UniForM Concurrency ToolKit 1 has primarily been designed to support the development of reactive systems using Concurrent Haskell [PJGF96]. The toolkit provides, partially backed up by a class system, a number of archetypical shared memory abstractions such as semaphores, locks and shared variables. The most important contribution, however, is the concept of reentrant monitors, whose main advantage over MVar's is that r...

. We study the longstanding problem of semantics for input /output (I/O) expressed using side-effects. Our vehicle is a small higher-order imperative language, with operations for interactive character I/O and based on ML syntax. Unlike previous theories, we present both operational and denotational semantics for I/O effects. We use a novel labelled transition system that uniformly expresses both applicative and imperative computation. We make a standard definition of bisimilarity and prove it is a congruence using Howe's method. Next, we define a metalogical type theory M in which we may give a denotational semantics to O. M generalises Crole and Pitts' FIX-logic by adding in a parameterised recursive datatype, which is used to model I/O. M comes equipped both with judgements of equality of expressions, and an operational semantics; M itself is given a domain-theoretic semantics in the category CPPO of cppos (bottom-pointed posets with joins of !-chains) and Scott continuous functions...