Results 1 
6 of
6
Concurrent Constraint Programming
, 1993
"... This paper presents a new and very rich class of (concurrent) programming languages, based on the notion of comput.ing with parhal information, and the concommitant notions of consistency and entailment. ’ In this framework, computation emerges from the interaction of concurrently executing agent ..."
Abstract

Cited by 442 (15 self)
 Add to MetaCart
This paper presents a new and very rich class of (concurrent) programming languages, based on the notion of comput.ing with parhal information, and the concommitant notions of consistency and entailment. ’ In this framework, computation emerges from the interaction of concurrently executing agents that communicate by placing, checking and instantiating constraints on shared variables. Such a view of computation is interesting in the context of programming languages because of the ability to represent and manipulate partial information about the domain of discourse, in the context of concurrency because of the use of constraints for communication and control, and in the context of AI because of the availability of simple yet powerful mechanisms for controlling inference, and the promise that very rich representational/programming languages, sharing the same set of abstract properties, may be possible. To reflect this view of computation, [Sar89] develops the cc family of languages. We present here one member of the family, CC(.L,+) (pronounced “cc with Ask and Choose”) which provides the basic operations of blocking Ask and atomic Tell and an algebra of behaviors closed under prefixing, indeterministic choice, interleaving, and hiding, and provides a mutual recursion operator. cc(.L,t) is (intentionally!) very similar to Milner’s CCS, but for the radically different underlying concept of communication, which, in fact, pro’ The class is founded on the notion of “constraint logic programming ” [JL87,Mah87], fundamentally generalizes concurrent logic programming, and is the subject of the first author’s dissertation [Sar89], on which this paper is substantially based.
Semantic foundations of concurrent constraint programming
, 1990
"... Concurrent constraint programming [Sar89,SR90] is a simple and powerful model of concurrent computation based on the notions of storeasconstraint and process as information transducer. The storeasvaluation conception of von Neumann computing is replaced by the notion that the store is a constr ..."
Abstract

Cited by 259 (26 self)
 Add to MetaCart
Concurrent constraint programming [Sar89,SR90] is a simple and powerful model of concurrent computation based on the notions of storeasconstraint and process as information transducer. The storeasvaluation conception of von Neumann computing is replaced by the notion that the store is a constraint (a finite representation of a possibly infinite set of valuations) which provides partial information about the possible values that variables can take. Instead of “reading” and “writing ” the values of variables, processes may now ask (check if a constraint is entailed by the store) and tell (augment the store with a new constraint). This is a very general paradigm which subsumes (among others) nondeterminate dataflow and the (concurrent) (constraint) logic programming languages. This paper develops the basic ideas involved in giving a coherent semantic account of these languages. Our first contribution is to give a simple and general formulation of the notion that a constraint system is a system of partial information (a la the information systems of Scott). Parameter passing and hiding is handled by borrowing ideas from the cylindric algebras of Henkin, Monk and Tarski to introduce diagonal elements and “cylindrification ” operations (which mimic the projection of information induced by existential quantifiers). The se;ond contribution is to introduce the notion of determinate concurrent constraint programming languages. The combinators treated are ask, tell, parallel composition, hiding and recursion. We present a simple model for this language based on the specificationoriented methodology of [OH86]. The crucial insight is to focus on observing the resting points of a process—those stores in which the process quiesces without producing more information. It turns out that for the determinate language, the set of resting points of a process completely characterizes its behavior on all inputs, since each process can be identified with a closure operator over the underlying constraint system. Very natural definitions of parallel composition, communication and hiding are given. For example, the parallel composition of two agents can be characterized by just the intersection of the sets of constraints associated with them. We also give a complete axiomatization of equality in this model, present
Compositional Analysis of Modular Logic Programs
 In Proc. Twentieth Annual ACM Symp. on Principles of Programming Languages
, 1993
"... This paper describes a semantic basis for a compositional approach to the analysis of logic programs. A logic program is viewed as consisting of a set of modules, each module defining a subset of the program's predicates. Analyses are constructed by considering abstract interpretations of a compo ..."
Abstract

Cited by 55 (10 self)
 Add to MetaCart
This paper describes a semantic basis for a compositional approach to the analysis of logic programs. A logic program is viewed as consisting of a set of modules, each module defining a subset of the program's predicates. Analyses are constructed by considering abstract interpretations of a compositional semantics. The abstract meaning of a module corresponds to its analysis and composition of abstract meanings corresponds to composition of analyses. Such an approach is essential for large program development so that altering one module does not require reanalysis of the entire program. A compositional analysis for ground dependencies is included to illustrate the approach. To the best of our knowledge this is the first account of a compositional framework for the analysis of (logic) programs. 1 Introduction It is widely acknowledged that as the size of a program increases, it becomes impractical to maintain it as a single monolithic structure. Instead, the program has to be...
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.
Replay, Recovery, Replication, and Snapshots of Nondeterministic Concurrent Programs
 In ACM Symposium on Principles of Distributed Computing
, 1990
"... The problem of replaying computations of nondeterministic concurrent programs arises in contexts such as debugging and recovery. We investigate the problem for an abstract model of concurrency, which generalizes dataflow networks, processors with shared variables, and logic programming models of ..."
Abstract

Cited by 5 (0 self)
 Add to MetaCart
The problem of replaying computations of nondeterministic concurrent programs arises in contexts such as debugging and recovery. We investigate the problem for an abstract model of concurrency, which generalizes dataflow networks, processors with shared variables, and logic programming models of concurrency. We say that nondeterminism is visible if the state is determined, up to some (appropriately defined) notion of equivalence, by the external behavior. We show that if nondeterminism is visible then replay is achievable using a onestep lookahead sequential simulation algorithm. If the program has an additional monotonicity property called stability then recovery is possible without simulating the original computation, by restarting the program from a certain easily constructed state. Also, for stable programs with visible nondeterminism, a process composed of identical parallel processes has the same external behavior as each of its components. Hence high crashfailure res...
Concurrency in the lambdacalculus: Higherorder Concurrent Constraint Programming (Extended Abstract)
, 1991
"... of Preliminary Report) December 4, 1991 Abstract We introduce higherorder versions of the determinate and nondeterminate concurrent constraint (cc) programming languages [Sar89]. Thereby, we propose a simple conceptual and semantic framework for the joint exploration of (concurrent) functional a ..."
Abstract
 Add to MetaCart
of Preliminary Report) December 4, 1991 Abstract We introduce higherorder versions of the determinate and nondeterminate concurrent constraint (cc) programming languages [Sar89]. Thereby, we propose a simple conceptual and semantic framework for the joint exploration of (concurrent) functional and (concurrent) (higherorder) (constraint) logic programming languages. 1 Introduction and overview The concurrent constraint (cc) programming paradigm is based on a set of very simple ideas, arising from concurrent logic programming and constraint logic programming. The basic references are [Sar89, SR90, SRP91, JSS91]; we summarize here briefly. Imperative languages may be thought of as based on the notion of storeasvaluation: a state of the computation is described by a valuation which assigns a unique value to each variable of interest. In constraintbased computation, this notion is replaced by that of storeasconstraintthe store is seen to contain pieces of partial information ...