TyCO Gently

TyCO stands for "TYped Concurrent Objects". Not that the language includes any form of primitive objects. Instead, a few basic constructors provide for a form of Object-Based Programming (that is, objects but no inheritance). The language is quite simple. The basic syntax reduces to half-a-dozen constructors. To help in writing common programming patterns, a few derived constructors are available. This report introduces TyCO by example, rather than explaining the language first and giving examples secon

A Stochastic Pi Calculus for Concurrent Objects

International audienceWe present SpiCO, a new modeling and simulation language for system biology, based on the stochastic pi-calculus. SpiCO supports higher level modeling via multi-profile concurrent objects with static inheritance. We present a semantics for SpiCO in terms of continuous time Markov chains, and show how to compile SpiCO back into the biochemical stochastic pi-calculus while preserving semantics

Compiling the π\pi-calculus into a Multithreaded Typed Assembly Language

Current trends in hardware made available multi-core CPU systems to ordinary users, challenging researchers to devise new techniques to bring software into the multi-core world. However, shaping software for multi-cores is more envolving than simply balancing workload among cores. In a near future (in less than a decade) Intel prepares to manufacture and ship 80-core processors; programmers must perform a paradigm shift from sequential to concurrent programming and produce software adapted for multi-core platforms. In the last decade, proposals have been made to compile formal concurrent and functional languages, notably the $\pi$-calculus, typed concurrent objects, and the $\lambda$-calculus, into assembly languages. The last work goes a step further and presents a series of type-preserving compilation steps leading from System F to a typed assembly language. Nevertheless, all theses works are targeted at sequential architectures. This paper proposes a type-preserving translation from the $\pi$-calculus into MIL, a multithreaded typed assembly language for multi-core/multi-processor architectures. We start from a simple asynchronous typed version of the $\pi$-calculus and translate it into MIL code that is then linked to a run-time library (written in MIL) that provides support for implementation of the $\pi$-calculus primitives (e.g., queuing messages and processes). In short, we implement a message-passing paradigm in a shared memory architectur

A Stochastic Pi Calculus for Concurrent Objects

International audienceWe present SpiCO, a new modeling and simulation language for system biology, based on the stochastic pi-calculus. SpiCO supports higher level modeling via multi-profile concurrent objects with static inheritance. We present a semantics for SpiCO in terms of continuous time Markov chains, and show how to compile SpiCO back into the biochemical stochastic pi-calculus while preserving semantics

Foundations of Session Types and Behavioural Contracts

International audienceBehavioural type systems, usually associated to concurrent or distributed computations, encompass concepts such as interfaces, communication protocols, and contracts, in addition to the traditional input/output operations. The behavioural type of a software component specifies its expected patterns of interaction using expressive type languages, so that types can be used to determine automatically whether the component interacts correctly with other components. Two related important notions of behavioural types are those of session types and behavioural contracts. This paper surveys the main accomplishments of the last twenty years within these two approaches

Foundations of session types and behavioural contracts

Behavioural type systems, usually associated to concurrent or distributed computations, encompass concepts such as interfaces, communication protocols, and contracts, in addition to the traditional input/output operations. The behavioural type of a software component specifies its expected patterns of interaction using expressive type languages, so types can be used to determine automatically whether the component interacts correctly with other components. Two related important notions of behavioural types are those of session types and behavioural contracts. This article surveys the main accomplishments of the last 20 years within these two approaches

A Type Checking Algorithm for Concurrent Object Protocols

Concurrent objects can be accessed and possibly modified concurrently by several running processes. It is notoriously difficult to make sure that such objects are consistent with – and are used according to – their intended protocol. In this paper we detail a type checking algorithm for concurrent objects protocols that provides automated support for this verification task. We model concurrent objects in the Objective Join Calculus and specify protocols using terms of a Commutative Kleene Algebra. The presented results are an essential first step towards the application of this static analysis technique to real-world programs