Results 1  10
of
68
Perspectives on Program Analysis
, 1996
"... eing analysed. On the negative side, the semantic correctness of the analysis is seldom established and therefore there is often no formal justification for the program transformations for which the information is used. The semantics based approach [1; 5] is often based on domain theory in the form ..."
Abstract

Cited by 685 (35 self)
 Add to MetaCart
(Show Context)
eing analysed. On the negative side, the semantic correctness of the analysis is seldom established and therefore there is often no formal justification for the program transformations for which the information is used. The semantics based approach [1; 5] is often based on domain theory in the form of abstract domains modelling sets of values, projections, or partial equivalence relations. The approach tends to focus more directly on discovering the extensional properties of interest: for constant propagation it might operate on sets of values with constancy corresponding to singletons, and for neededness analysis it might perform a strictness analysis and use the strictness information for neededness (or make use of the "absence" notion from projection analysis and attempt to discover the di#erence). On the positive side, this usually gives rise to provably correct analyses, although there are sometimes complications (due to deciding what information to stick onto the
Language primitives and type discipline for structured communicationbased programming
 In ESOP’98, volume 1381 of LNCS
, 1998
"... Session primitives and types provide a flexible programming style for structured interaction, and are used to statically check the safe and consistent composition of protocols in communicationcentric distributed software. Unfortunately authors working on session types have recently realised that so ..."
Abstract

Cited by 309 (64 self)
 Add to MetaCart
Session primitives and types provide a flexible programming style for structured interaction, and are used to statically check the safe and consistent composition of protocols in communicationcentric distributed software. Unfortunately authors working on session types have recently realised that some of the previously published systems fail to satisfy the basic theorems of Subject Reduction and Type Safety. This report discusses the issues involved in higherorder session communication, presents a formulation of the recursive types as well as proofs of the Subject Reduction and Type Safety Theorems of the original session typing system by HondaVasconcelosKubo in ESOP’98. It also proposes a variant which allows a more liberal higherorder session communication, based on an idea of Gay and Hole.
Modern Concurrency Abstractions for C#
 ACM TRANS. PROGRAM. LANG. SYST
, 2002
"... Polyphonic C# is an extension of the C# language with new asynchronous concurrency constructs, based on the join calculus. We describe the design and implementation of the language and give examples of its use in addressing a range of concurrent programming problems. ..."
Abstract

Cited by 154 (2 self)
 Add to MetaCart
(Show Context)
Polyphonic C# is an extension of the C# language with new asynchronous concurrency constructs, based on the join calculus. We describe the design and implementation of the language and give examples of its use in addressing a range of concurrent programming problems.
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 152 (22 self)
 Add to MetaCart
(Show Context)
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...
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 109 (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).
A Generic Type System for the PiCalculus
 Theoretical Computer Science
, 2003
"... We propose a general, powerful framework of type systems for the #calculus, and show that we can obtain as its instances a variety of type systems guaranteeing nontrivial properties like deadlockfreedom and racefreedom. A key idea is to express types and type environments as abstract processe ..."
Abstract

Cited by 107 (9 self)
 Add to MetaCart
(Show Context)
We propose a general, powerful framework of type systems for the #calculus, and show that we can obtain as its instances a variety of type systems guaranteeing nontrivial properties like deadlockfreedom and racefreedom. A key idea is to express types and type environments as abstract processes: We can check various properties of a process by checking the corresponding properties of its type environment. The framework clarifies the essence of recent complex type systems, and it also enables sharing of a large amount of work such as a proof of type preservation, making it easy to develop new type systems.
From Region Inference to von Neumann Machines via Region Representation Inference
 IN TWENTYTHIRD ACM SYMPOSIUM ON PRINCIPLES OF PROGRAMMING LANGUAGES
, 1996
"... Region Inference is a technique for implementing programming languages that are based on typed callbyvalue lambda calculus, such as Standard ML. The mathematical runtime model of region inference uses a stack of regions, each of which can contain an unbounded number of values. This paper is concer ..."
Abstract

Cited by 100 (8 self)
 Add to MetaCart
Region Inference is a technique for implementing programming languages that are based on typed callbyvalue lambda calculus, such as Standard ML. The mathematical runtime model of region inference uses a stack of regions, each of which can contain an unbounded number of values. This paper is concerned with mapping the mathematical model onto real machines. This is done by composing region inference with Region Representation Inference, which gradually refines region information till it is directly implementable on conventional von Neumann machines. The performance of a new regionbased ML compiler is compared to the performance of Standard ML of New Jersey, a stateoftheart ML compiler.
A Region Inference Algorithm
 ACM TRANSACTIONS ON PROGRAMMING LANGUAGES AND SYSTEMS
, 1998
"... This article presents an algorithm which implements the specification. We prove that the algorithm is sound with respect to the region inference rules and that it always terminates even though the region inference rules permit polymorphic recursion in regions. The algorithm is the result of several ..."
Abstract

Cited by 88 (4 self)
 Add to MetaCart
This article presents an algorithm which implements the specification. We prove that the algorithm is sound with respect to the region inference rules and that it always terminates even though the region inference rules permit polymorphic recursion in regions. The algorithm is the result of several years of experiments with region inference algorithms in the ML Kit, a compiler from Standard ML to assembly language. We report on practical experience with the algorithm and give hints on how to implement it.