Results 1  10
of
24
The Polymorphic Picalculus: Theory and Implementation
, 1995
"... We investigate whether the πcalculus is able to serve as a good foundation for the design and implementation of a stronglytyped 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 su ..."
Abstract

Cited by 112 (0 self)
 Add to MetaCart
We investigate whether the πcalculus is able to serve as a good foundation for the design and implementation of a stronglytyped 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 typetheoretic constructions such as recursive types and higherorder polymorphism. Higherorder polymorphism is important, since it gives us the ability to implement abstract datatypes in a typesafe 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 wellknown 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).
Assigning Types to Processes
 In LICS 2000
, 2000
"... this paper we propose a finegrained typing system for a higherorder pcalculus which can be used to control the effect of such migrating code on local environments. Processes may be assigned different types depending on their intended use. This is in contrast to most of the previous work on ty ..."
Abstract

Cited by 43 (5 self)
 Add to MetaCart
(Show Context)
this paper we propose a finegrained typing system for a higherorder pcalculus which can be used to control the effect of such migrating code on local environments. Processes may be assigned different types depending on their intended use. This is in contrast to most of the previous work on typing processes where all processes are typed by a unique constant type, indicating essentially that they are welltyped relative to a particular environment. Our finegrained typing facilitates the management of access rights and provides host protection from potentially malicious behaviour
A capability calculus for concurrency and determinism
 In CONCUR 2006  Concurrency Theory, 17th International Conference, Proceedings
, 2006
"... Abstract. We present a capability calculus for checking partial confluence of channelcommunicating concurrent processes. Our approach automatically detects more programs to be partially confluent than previous approaches and is able to handle a mix of different kinds of communication channels, incl ..."
Abstract

Cited by 23 (3 self)
 Add to MetaCart
(Show Context)
Abstract. We present a capability calculus for checking partial confluence of channelcommunicating concurrent processes. Our approach automatically detects more programs to be partially confluent than previous approaches and is able to handle a mix of different kinds of communication channels, including shared reference cells. 1
Design and Semantics of Quantum: a Language to Control Resource Consumption in Distributed Computing
 In Usenix Conference on DomainSpecific Languages (DSL’97
, 1997
"... This paper describes the semantics of Quantum, a language that was specifically designed to control resource consumption of distributed computations, such as mobile agent style applications. In Quantum, computations can be driven by mastering their resource consumption. Resources can be understood ..."
Abstract

Cited by 18 (6 self)
 Add to MetaCart
(Show Context)
This paper describes the semantics of Quantum, a language that was specifically designed to control resource consumption of distributed computations, such as mobile agent style applications. In Quantum, computations can be driven by mastering their resource consumption. Resources can be understood as processors cycles, geographical expansion, bandwidth or duration of communications, etc. We adopt a generic view by saying that computations need energy to be performed. Quantum relies on three new primitives that deal with energy. The first primitive creates a tank of energy associated with a computation. Asynchronous notifications inform the user of energy exhaustion and computation termination. The other two primitives allow us to implement suspension and resumption of computations by emptying a tank and by supplying more energy to a tank. The semantics takes the form of an abstract machine with explicit parallelism and energyrelated primitives. 1 Introduction Millions of computers ...
Type Reconstruction for Linear PiCalculus with I/O Subtyping
, 2000
"... Powerful concurrency primitives in recent concurrent languages and thread libraries provide great exibility about implementation of highlevel features like concurrent objects. However, they are so lowlevel that they often make it dicult to check global correctness of programs or to perform non ..."
Abstract

Cited by 13 (7 self)
 Add to MetaCart
Powerful concurrency primitives in recent concurrent languages and thread libraries provide great exibility about implementation of highlevel features like concurrent objects. However, they are so lowlevel that they often make it dicult to check global correctness of programs or to perform nontrivial code optimization, such as elimination of redundant communication. In order to overcome those problems, advanced type systems for inputonly /outputonly channels and linear (useonce) channels have been recently studied, but the type reconstruction problem for those type systems remained open, and therefore, their applications to concurrent programming languages have been limited. In this paper, we develop type reconstruction algorithms for variants of Kobayashi, Pierce, and Turner's linear channel type system with Pierce and Sangiorgi's subtyping based on inputonly/outputonly channel types, and prove correctness of the algorithms. To our knowledge, no complete type recons...
An Effective Fixpoint Semantics for Linear Logic Programs
 THEORY AND PRACTICE OF LOGIC PROGRAMMING
, 2002
"... In this paper we investigate the theoretical foundation of a new bottomup semantics for linear logic programs, and more precisely for the fragment of LinLog (Andreoli, 1992) that consists of the language LO (Andreoli & Pareschi, 1991) enriched with the constant 1. We use constraints to symbolic ..."
Abstract

Cited by 13 (3 self)
 Add to MetaCart
(Show Context)
In this paper we investigate the theoretical foundation of a new bottomup semantics for linear logic programs, and more precisely for the fragment of LinLog (Andreoli, 1992) that consists of the language LO (Andreoli & Pareschi, 1991) enriched with the constant 1. We use constraints to symbolically and finitely represent possibly infinite collections of provable goals. We define a fixpoint semantics based on a new operator in the style of TP working over constraints. An application of the fixpoint operator can be computed algorithmically. As sufficient conditions for termination, we show that the fixpoint computation is guaranteed to converge for propositional LO. To our knowledge, this is the first attempt to define an effective fixpoint semantics for linear logic programs. As an application of our framework, we also present a formal investigation of the relations between LO and Disjunctive Logic Programming (Minker et al., 1991). Using an approach based on abstract interpretation, we show that DLP fixpoint semantics can be viewed as an abstraction of our semantics for LO. We prove that the resulting abstraction is correct and complete (Cousot & Cousot, 1977; Giacobazzi & Ranzato, 1997) for an interesting class of LO programs encoding Petri Nets.
Static Analysis of Linear Logic Programming
 NEW GENERATION COMPUTING
, 1997
"... Linear Logic is gaining momentum in computer science because it offers a unified framework and a common vocabulary for studying and analyzing different aspects of programming and computation. We focus here on models where computation is identified with proof search in the sequent system of Linear ..."
Abstract

Cited by 12 (3 self)
 Add to MetaCart
Linear Logic is gaining momentum in computer science because it offers a unified framework and a common vocabulary for studying and analyzing different aspects of programming and computation. We focus here on models where computation is identified with proof search in the sequent system of Linear Logic. A proof normalization procedure, called "focusing", has been proposed to make the problem of proof search tractable. Correspondingly,
Typing Confluence
, 1997
"... We investigate confluence properties for concurrent systems of messagepassing processes, because such properties have proved to be useful for a variety of applications, ranging from reasoning about concurrent objects to mobile and highspeed telecommunication protocols. Roughly, confluence means th ..."
Abstract

Cited by 11 (0 self)
 Add to MetaCart
We investigate confluence properties for concurrent systems of messagepassing processes, because such properties have proved to be useful for a variety of applications, ranging from reasoning about concurrent objects to mobile and highspeed telecommunication protocols. Roughly, confluence means that for every two computations starting from a common system state, it is possible to continue the computations, so to reach a common state again. In order to prove confluence for a given system, we are required to demonstrate that for all states reachable by computation from the starting state, the `flowing together' of possible computations is possible. In this paper, we aim at proving con#uence properties for concurrent systems without having to generate all reachable states. Instead, we use a type system that supports a static analysis of possible sources of nonconfluence. In messagepassing systems, confluence is invalidated whenever two processes compete for communication with another proce...
A Bottomup Semantics for Linear Logic Programs
 In Proceedings of PPDP'00
, 2000
"... The operational semantics of linear logic programming languages is given in terms of goaldriven sequent calculi. The prooftheoretic presentation is the natural counterpart of the topdown semantics of traditional logic programs. In this paper we investigate the theoretical foundation of an alterna ..."
Abstract

Cited by 8 (8 self)
 Add to MetaCart
(Show Context)
The operational semantics of linear logic programming languages is given in terms of goaldriven sequent calculi. The prooftheoretic presentation is the natural counterpart of the topdown semantics of traditional logic programs. In this paper we investigate the theoretical foundation of an alternative operational semantics based on a bottomup evaluation of linear logic programs via a fixpoint operator. The bottomup fixpoint semantics is important in applications like active databases, and, more in general, for program analysis and verification. As a first casestudy, we consider Andreoli and Pareschi's LO [4] enriched with the constant 1. For this language, we give a fixpoint semantics based on an operator defined in the style of TP . We give an algorithm to compute a single application of the fixpoint operator where constraints are used to represent in a finite way possibly infinite sets of provable goals. Furthermore, we show that the fixpoint semantics for propositional LO without the const...