Results 1 
7 of
7
Separating concurrent languages with categories of language embeddings
 In Proceedings of the 23 rd Annual ACM Symposium on Theory of Computing
, 1991
"... Concurrent programming enjoys a proliferation of languages but suffers from the lack of a general method of language comparison. In particular, concurrent (as well as sequential) programming languages cannot be usefully distinguished based on complexitytheoretic considerations, since most of them ..."
Abstract

Cited by 12 (1 self)
 Add to MetaCart
Concurrent programming enjoys a proliferation of languages but suffers from the lack of a general method of language comparison. In particular, concurrent (as well as sequential) programming languages cannot be usefully distinguished based on complexitytheoretic considerations, since most of them are Turingcomplete. Nevertheless, differences between programming languages matter, else we would not have invented so many of them. We develop a general method for comparing concurrent programming languages based on their algebraic (structural) complexity, and, using this method, achieve separation results among many wellknown concurrent languages. The method is not restricted to concurrent languages. It can be used to compare the algebraic complexity of abstract machine models, other families of programming languages, logics, and, more generaly, any family of languages with some syntactic operations and a notion of semantic equivalence. The method can also be used to compare the algebraic complexity of families of operations wit hin a language or across languages. We note that using the method we were able to compare languages and computational models that do not have a common semantic basis.
A typed foundation for directional logic programming
 In Proc. Workshop on Extensions to Logic Programming
, 1992
"... Abstract. A long standing problem in logic programming is how to impose directionality on programs in a safe fashion. The benefits of directionality include freedom from explicit sequential control, the ability to reason about algorithmic properties of programs (such as termination, complexity and d ..."
Abstract

Cited by 12 (1 self)
 Add to MetaCart
(Show Context)
Abstract. A long standing problem in logic programming is how to impose directionality on programs in a safe fashion. The benefits of directionality include freedom from explicit sequential control, the ability to reason about algorithmic properties of programs (such as termination, complexity and deadlockfreedom) and controlling concurrency. By using Girard’s linear logic, we are able to devise a type system that combines types and modes into a unified framework, and enables one to express directionality declaratively. The rich power of the type system allows outputs to be embedded in inputs and vice versa. Type checking guarantees that values have unique producers, but multiple consumers are still possible. From a theoretical point of view, this work provides a “logic programming interpretation ” of (the proofs of) linear logic, adding to the concurrency and functional programming interpretations that are already known. It also brings logic programming into the broader world of typed languages and typesaspropositions paradigm, enriching it with static scoping and higherorder features.
Generalizing Abadi & Lamport's Method to Solve a Problem Posed by A. Pnueli
, 1993
"... . By adding a new technique and a simple proof strategy to Abadi & Lamport's 1988 method [1] for proving refinement between specifications of distributed programs correct, the inherent limitation of their method, occurring when the abstract level of specification features socalled infinite ..."
Abstract

Cited by 5 (1 self)
 Add to MetaCart
. By adding a new technique and a simple proof strategy to Abadi & Lamport's 1988 method [1] for proving refinement between specifications of distributed programs correct, the inherent limitation of their method, occurring when the abstract level of specification features socalled infinite invisible nondeterminism or internal discontinuity, can be sometimes overcome. This technique is applied to the cruel last step of a three step correctness proof for an algorithm for communication between migrating processes within a finite network due to Kleinman, Moscowitz, Pnueli & Shapiro [5]. 1 Introduction In this paper we suggest a generalization of the method developed by Abadi & Lamport in [1] and utilize it to prove a refinement step in the derivation of a protocol that provides a mechanism analogous to message passing between possibly migrating processes in a fixed finite network of nodes. This protocol is described in [5], and concerns a three step refinement of a specification...
Typed Concurrent Programming with Logic Variables
, 1997
"... We present a concurrent higherorder programming language called Plain and a concomitant static type system. Plain is based on logic variables and computes with possibly partial data structures. The data structures of Plain are procedures, cells, and records. Plain's type system features record ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
(Show Context)
We present a concurrent higherorder programming language called Plain and a concomitant static type system. Plain is based on logic variables and computes with possibly partial data structures. The data structures of Plain are procedures, cells, and records. Plain's type system features recordbased subtyping, bounded existential polymorphism, and access modalities distinguishing between reading and writing.
Towards a Practitioners' Approach to Abadi and Lamport's Method
, 1997
"... Our own basic intuitions are presented when introducing the method developed by Abadi and Lamport in [AL88a] for proving refinement between specifications of nondeterministic programs correct to people unacquainted with it. The example we use to illustrate this method is a nontrivial communication p ..."
Abstract
 Add to MetaCart
Our own basic intuitions are presented when introducing the method developed by Abadi and Lamport in [AL88a] for proving refinement between specifications of nondeterministic programs correct to people unacquainted with it. The example we use to illustrate this method is a nontrivial communication protocol that provides a mechanism analogous to message passing between migrating processes within a fixed finite network of nodes due to Kleinman, Moscowitz, Pnueli, and Shapiro [KMPS91]. Especially the cruel last step of a three step refinement proof of that protocol gives rise to a deeper understanding of, and some small enhancements to, Abadi and Lamport's 1988 method.