Results 1  10
of
68
Pict: A programming language based on the picalculus
 PROOF, LANGUAGE AND INTERACTION: ESSAYS IN HONOUR OF ROBIN MILNER
, 1997
"... 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 highlevel constructs including data structures, higherorder functional programming, concurrent control structures, and objects. Moreover ..."
Abstract

Cited by 254 (8 self)
 Add to MetaCart
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 highlevel constructs including data structures, higherorder 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 highlevel language using the πcalculus as its core. This paper describes Pict, a stronglytyped concurrent programming language constructed in terms of an explicitlytypedcalculus core language.
An Interactionbased Language and its Typing System
 In PARLE’94, volume 817 of LNCS
, 1994
"... 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 noti ..."
Abstract

Cited by 109 (17 self)
 Add to MetaCart
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 highlevel abstraction of interactionbased 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 welltyped in the typing system, it never causes runtime 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...
A Uniform Type Structure for Secure Information Flow
, 2002
"... The \picalculus is a formalism of computing in which we can compositionally represent dynamics of major programming constructs by decomposing them into a single communication primitive, the name passing. This work reports our experience in using a linear/affine typed \picalculus for the analysis a ..."
Abstract

Cited by 76 (11 self)
 Add to MetaCart
The \picalculus is a formalism of computing in which we can compositionally represent dynamics of major programming constructs by decomposing them into a single communication primitive, the name passing. This work reports our experience in using a linear/affine typed \picalculus for the analysis and development of type systems of programming languages, focussing on secure information flow analysis. After presenting a basic typed calculus for secrecy, we demonstrate its usage by a sound embedding of the dependency core calculus (DCC) and by the development of a novel type discipline for imperative programs which extends both a secure multithreaded imperative language by Smith and Volpano and (a callbyvalue version of) DCC. In each case, the embedding gives a simple proof of noninterference.
Graph Types For Monadic Mobile Processes
 University of Edinburgh
, 1996
"... . While types for name passing calculi have been studied extensively in the context of sorting of polyadic ßcalculus [5, 34, 9, 28, 32, 19, 33, 10, 17], the same type abstraction is not possible in the monadic setting, which was left as an open issue by Milner [21]. We solve this problem with an ex ..."
Abstract

Cited by 60 (7 self)
 Add to MetaCart
. While types for name passing calculi have been studied extensively in the context of sorting of polyadic ßcalculus [5, 34, 9, 28, 32, 19, 33, 10, 17], the same type abstraction is not possible in the monadic setting, which was left as an open issue by Milner [21]. We solve this problem with an extension of sorting which captures dynamic aspects of process behaviour in a simple way. Equationally this results in the full abstraction of the standard encoding of polyadic ßcalculus into the monadic one: the sorted polyadic ßterms are equated by a basic behavioural equality in the polyadic calculus if and only if their encodings are equated in a basic behavioural equality in the typed monadic calculus. This is the first result of this kind we know of in the context of the encoding of polyadic name passing, which is a typical example of translation of highlevel communication structures into ß calculus. The construction is general enough to be extendable to encodings of calculi with mo...
The Name Discipline of Uniform Receptiveness
 Theoretical Computer Science
, 1997
"... In a process calculus, we say that a name x is uniformly receptive for a process P if: (1) at any time P is ready to accept an input at x, at least as long as there are processes that could send messages at x; (2) the input offer at x is functional, that is, all messages received by P at x are appli ..."
Abstract

Cited by 58 (4 self)
 Add to MetaCart
In a process calculus, we say that a name x is uniformly receptive for a process P if: (1) at any time P is ready to accept an input at x, at least as long as there are processes that could send messages at x; (2) the input offer at x is functional, that is, all messages received by P at x are applied to the same continuation. In the calculus this discipline is employed, for instance, when modeling functions, objects, higherorder communications, remoteprocedure calls. We formulate the discipline of uniform receptiveness by means of a type system, and then we study its impact on behavioural equivalences and process reasoning. We develop some theory and proof techniques for uniform receptiveness, and illustrate their usefulness on some nontrivial examples.
Session Types for ObjectOriented Languages
 In Proceedings of ECOOP’06, LNCS
, 2006
"... Abstract. A session takes place between two parties; after establishing a connection, each party interleaves local computations with communications (sending or receiving) with the other. Session types characterise such sessions in terms of the types of values communicated and the shape of protocols, ..."
Abstract

Cited by 53 (23 self)
 Add to MetaCart
Abstract. A session takes place between two parties; after establishing a connection, each party interleaves local computations with communications (sending or receiving) with the other. Session types characterise such sessions in terms of the types of values communicated and the shape of protocols, and have been developed for the πcalculus, CORBA interfaces, and functional languages. We study the incorporation of session types into objectoriented languages through MOOSE, a multithreaded language with session types, thread spawning, iterative and higherorder sessions. Our design aims to consistently integrate the objectoriented programming style and sessions, and to be able to treat various case studies from the literature. We describe the design of MOOSE, its syntax, operational semantics and type system, and develop a type inference system. After proving subject reduction, we establish the progress property: once a communication has been established, welltyped programs will never starve at communication points. 1
Secure Information Flow as Typed Process Behaviour
, 2000
"... We propose a new type discipline for the calculus in which secure information ow is guaranteed by static type checking. Secrecy levels are assigned to channels and are controlled by subtyping. A behavioural notion of types capturing causality of actions plays an essential role for ensuring safe ..."
Abstract

Cited by 52 (0 self)
 Add to MetaCart
We propose a new type discipline for the calculus in which secure information ow is guaranteed by static type checking. Secrecy levels are assigned to channels and are controlled by subtyping. A behavioural notion of types capturing causality of actions plays an essential role for ensuring safe information ow in diverse interactive behaviours, making the calculus powerful enough to embed known calculi for typebased security. The paper introduces the core part of the calculus, presents its basic syntactic properties, and illustrates its use as a tool for programming language analysis by a sound embedding of a secure multithreaded imperative calculus of Volpano and Smith. The embedding leads to a practically meaningful extension of their original type discipline.
A Typing System for a Calculus of Objects
 In 1st International Symposium on Object Technologies for Advanced Software, LNCS
, 1993
"... The present paper introduces an implicitly typed object calculus intended to capture intrinsic aspects of concurrent objects communicating via asynchronous message passing, together with a typing system assigning typings to terms in the calculus. Types meant to describe the kind of messages an objec ..."
Abstract

Cited by 49 (25 self)
 Add to MetaCart
The present paper introduces an implicitly typed object calculus intended to capture intrinsic aspects of concurrent objects communicating via asynchronous message passing, together with a typing system assigning typings to terms in the calculus. Types meant to describe the kind of messages an object may receive are assigned to the free names in a program, resulting in a scenario where a program is assigned multiple nametype pairs, constituting a typing for the process. Programs that comply to the typing discipline are shown not to suffer from runtime errors. Furthermore the calculus possesses a notion of principal typings, from which all typings that make a program welltyped can be extracted. We present an efficient algorithm to extract the principal typing of a process. 1 Introduction Most of the attempts to introduce some type discipline into objectoriented languages start from lambdacalculus, by extending this with some kind of records. There are several limitations to this ap...
A theory of contracts for web services
 In POPL ’08, 35th ACM Symposium on Principles of Programming Languages
, 2008
"... Contracts are behavioral descriptions of Web services. We devise a theory of contracts that formalizes the compatibility of a client to a service, and the safe replacement of a service with another service. The use of contracts statically ensures the successful completion of every possible interacti ..."
Abstract

Cited by 46 (4 self)
 Add to MetaCart
Contracts are behavioral descriptions of Web services. We devise a theory of contracts that formalizes the compatibility of a client to a service, and the safe replacement of a service with another service. The use of contracts statically ensures the successful completion of every possible interaction between compatible clients and services. The technical device that underlies the theory is the filter, which is an explicit coercion preventing some possible behaviors of services and, in doing so, make services compatible with different usage scenarios. We show that filters can be seen as proofs of a sound and complete subcontracting deduction system which simultaneously refines and extends Hennessy’s classical axiomatization of the must testing preorder. The relation is decidable and the decision algorithm is obtained via a cutelimination process that proves the coherence of subcontracting as a logical system. Despite the richness of the technical development, the resulting approach is based on simple ideas and basic intuitions. Remarkably, its application is mostly independent of the language used to program the services or the clients. We outline the practical aspects of our theory by studying two different concrete syntaxes for contracts and applying each of them to Web services languages. We also explore implementation issues of filters and discuss the perspectives of future research