Results 1  10
of
15
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
HigherOrder, Linear, Concurrent Constraint Programming
, 1992
"... We present a very simple and powerful framework for indeterminate, asynchronous, higherorder computation based on the formulaasagent and proofascomputation interpretation of (higherorder) linear logic [Gir87]. The framework significantly refines and extends the scope of the concurrent constrai ..."
Abstract

Cited by 30 (5 self)
 Add to MetaCart
We present a very simple and powerful framework for indeterminate, asynchronous, higherorder computation based on the formulaasagent and proofascomputation interpretation of (higherorder) linear logic [Gir87]. The framework significantly refines and extends the scope of the concurrent constraint programming paradigm [Sar89] in two fundamental ways: (1) by allowing for the consumption of information by agents it permits a direct modelling of (indeterminate) state change in a logical framework, and (2) by admitting simplytyped terms as dataobjects, it permits the construction, transmission and application of (abstractions of) programs at runtime. Much more dramatically, however, the framework can be seen as presenting higherorder (and if desired, constraintenriched) versions of a variety of other asynchronous concurrent systems, including the asynchronous ("input guarded") fragment of the (firstorder) ßcalculus, Hewitt's actors formalism, (abstract forms of) Gelernter's Lin...
LEDA: A Blending of Imperative and Relational Programming
 IEEE Software
, 1994
"... This paper describes features of a new strongly typed, compiled programming language, called LEDA. LEDA attempts to combine aspects of both imperative (valueoriented) and logical (relationoriented) styles of programming. Logical behavior is introduced by means of a new programming structure, calle ..."
Abstract

Cited by 9 (0 self)
 Add to MetaCart
This paper describes features of a new strongly typed, compiled programming language, called LEDA. LEDA attempts to combine aspects of both imperative (valueoriented) and logical (relationoriented) styles of programming. Logical behavior is introduced by means of a new programming structure, called a relation. Relations have similarities to functions and procedures, but are distinct from both. Several examples are presented illustrating how the combination of features from the two paradigms are mutually beneficial. Finally a short overview of the implementation is given. 1 Introduction The field of programming languages has undergone a transformation in the last several years, from considering programming languages each as representing just a particular syntax and perhaps an emphasis on a particular data structure, to recognizing the existence of diverse philosophies or outlooks in languages. These different approaches are called language paradigms, a term which emphasizes that the ...
A Fully Abstract Semantics for a FirstOrder Functional Language with Logic Variables
 ACM Transactions on Programming Languages and Systems
, 1991
"... There is much interest in combining the functional and logic programming paradigms � in particular, there have been several proposals for adding logic variables to functional languages, since that permits incremental construction of data structures through constraint intersection. While it is straig ..."
Abstract

Cited by 5 (0 self)
 Add to MetaCart
There is much interest in combining the functional and logic programming paradigms � in particular, there have been several proposals for adding logic variables to functional languages, since that permits incremental construction of data structures through constraint intersection. While it is straightforward to give an abstract semantics for functional languages and for logic languages, it has proven surprisingly di cult to give a proper semantic account of functional languages with logic variables. In this paper, we present a rstorder functional language with logic variables and give its meaning using a structural operational semantics. We also give it a denotational semantics, using a novel technique involving closure operators on a Scott domain. Finally, we show that these two semantics correspond in the strongest possible wayweshow that the denotational semantics is fully abstract with respect to the operational semantics. The techniques developed in this paper are quite general, and can be used to give semantics to any constraintbased logic programming languages. Our results can also be interpreted as a generalization of Kahn semantics for data ow networks in which processes not only exchange messages, but have access to a shared global address space in which variables are bound through constraint intersection. Categories and Subject Descriptors: D.1.1 [Programming Techniques]: Functional Programming � D.3.1 [Programming Languages]: Formal De nitions and Theory semantics � D.3.2 [Programming Languages]: Data ow Languages � F.3.2 [Theory of Computation]: Semantics of Programming Languages denotational semantics � F.4.1 [Theory of Computation]: Mathematical Logic logic programming
A Common Intermediate Language and its Use in Partitioning Concurrent Declarative Programs
 New Generation Computing
, 1996
"... The plethora of concurrent declarative language families, each with subtly different semantics, makes the design and implementation of static analyses for these languages a demanding task. However, many of the languages share underlying structure, and if this structure can be exploited, static analy ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
The plethora of concurrent declarative language families, each with subtly different semantics, makes the design and implementation of static analyses for these languages a demanding task. However, many of the languages share underlying structure, and if this structure can be exploited, static analysis techniques can be shared across language families. These techniques can thus provide a common kernel for the implementation of quality compilers for this entire language class. The purpose of this paper is to exploit the similarities of nonstrict functional and concurrent logic languages in the design of a common intermediate language (CIL). The CIL is introduced incrementally, giving at each step the rationale for its extension. As an application, we present, in CIL form, some stateoftheart static partitioning algorithms from the literature. This allows us to "uncover" the relative advantages and disadvantages of the analyses, and determine promising directions for improving static ...
A Logical View of Assignments
, 1991
"... Imperative lambda calculus (ILC) is an abstract formal language obtained by extending the typed lambda calculus with imperative programming features, namely references and assignments. The language shares with typed lambda calculus important properties such as the ChurchRosser property and strong n ..."
Abstract

Cited by 2 (2 self)
 Add to MetaCart
Imperative lambda calculus (ILC) is an abstract formal language obtained by extending the typed lambda calculus with imperative programming features, namely references and assignments. The language shares with typed lambda calculus important properties such as the ChurchRosser property and strong normalization. In this paper, we describe the logical symmetries that underly ILC by exhibiting a constructive logic for which ILC forms the language of constructions. Central to this formulation is the view that references play a role similar to that of variables. References can be used to range over values and instantiated to specific values. Thus, we obtain a new form of universal quantification that uses references instead of variables. The essential term forms of ILC are then obtained as the constructions for the introduction and elimination of this quantifier. While references duplicate the role of variables, they also have important differences. References are semantic values whereas variables are syntactic entities and, secondly, references are reusable. These differences allow references to be used in a more flexible fashion leading to efficiency in constructions and algorithms. 1
Acceptors as values: Functional programming in classical linear logic
, 1991
"... Girard’s linear logic has been previously applied to functional programming for performing statemanipulation and controlling storage reuse. These applications only use intuitionistic linear logic, the subset of linear logic that embeds intuitionistic logic. Full linear logic (called classical linea ..."
Abstract

Cited by 2 (1 self)
 Add to MetaCart
Girard’s linear logic has been previously applied to functional programming for performing statemanipulation and controlling storage reuse. These applications only use intuitionistic linear logic, the subset of linear logic that embeds intuitionistic logic. Full linear logic (called classical linear logic) is much richer than this subset. In this paper, we consider the application of classical linear logic to functional programming. The negative types of linear logic are interpreted as denoting acceptors. An acceptor is an entity which takes an input of some type and returns no output. Acceptors generalize continuations and also single assignment variables, as found in data flow languages and logic programming languages. The parallel disjunction operator allows such acceptors to be used in a nontrivial fashion. Finally, the “why not ” operator of linear logic gives rise to nondeterministic values. We define a typed functional language based on the these ideas and demonstrate its use via examples. The language has a reduction semantics that generalizes typed lambda calculus, and satisfies strong normalization and ChurchRosser properties.
Compilation of Concurrent Declarative Languages
 University of Oregon
, 1995
"... The plethora of concurrent declarative language families, each with subtly different semantics, makes the design and implementation of static analyses for these languages a demanding task. However, many of the languages share underlying structure. If this structure can be exploited, static analysis ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
The plethora of concurrent declarative language families, each with subtly different semantics, makes the design and implementation of static analyses for these languages a demanding task. However, many of the languages share underlying structure. If this structure can be exploited, static analysis techniques can be shared across language families. These techniques can thus provide a common kernel for the implementation of quality compilers for this entire language class. The purpose of this paper is to exploit the similarities of nonstrict functional and concurrent logic languages in the design of a common intermediate language (CIL). The CIL is introduced incrementally, giving at each step the rationale for its extension. As an application, we have analyzed some stateofthe art static partitioning algorithms from the literature in terms of their action upon CIL programs. This allowed us to "uncover" the relative advantages and disadvantages of the analyses, and determine promising ...
Refine "Refine"
"... The quality of the Software Refinery TM KBSE environment derives significantly from the quality of its embedded Refine programming language. While Refine provides strong support for many modern highlevel programming paradigms (functional, logic, objectoriented and metaprogramming), a number of i ..."
Abstract
 Add to MetaCart
The quality of the Software Refinery TM KBSE environment derives significantly from the quality of its embedded Refine programming language. While Refine provides strong support for many modern highlevel programming paradigms (functional, logic, objectoriented and metaprogramming), a number of improvements seem appropriate. These improvements are motivated through analysis of Refine's existing capabilities, embodied in suggested language changes, and validated by implementation feasibility studies. 2 1. INTRODUCTION Other work [1] has concentrated on explaining why a particular software engineering environment  Reasoning Systems' "Software Refinery"  has attained preeminent status as an enabling technology for KnowledgeBased Software Engineering (KBSE), and in particular for what we might term KnowledgeBased Software Reengineering (KBSR). In order to perfect this capability, it is appropriate for us now to concentrate on how a key component of Software Refinery  the Refine...