Results 1  10
of
25
A Variable Typed Logic of Effects
 Information and Computation
, 1993
"... In this paper we introduce a variable typed logic of effects inspired by the variable type systems of Feferman for purely functional languages. VTLoE (Variable Typed Logic of Effects) is introduced in two stages. The first stage is the firstorder theory of individuals built on assertions of equalit ..."
Abstract

Cited by 48 (12 self)
 Add to MetaCart
In this paper we introduce a variable typed logic of effects inspired by the variable type systems of Feferman for purely functional languages. VTLoE (Variable Typed Logic of Effects) is introduced in two stages. The first stage is the firstorder theory of individuals built on assertions of equality (operational equivalence `a la Plotkin), and contextual assertions. The second stage extends the logic to include classes and class membership. The logic we present provides an expressive language for defining and studying properties of programs including program equivalences, in a uniform framework. The logic combines the features and benefits of equational calculi as well as program and specification logics. In addition to the usual firstorder formula constructions, we add contextual assertions. Contextual assertions generalize Hoare's triples in that they can be nested, used as assumptions, and their free variables may be quantified. They are similar in spirit to program modalities in ...
VLISP: A verified implementation of Scheme
 Lisp and Symbolic Computation
, 1995
"... VLISP has produced a rigorously verified compiler from Scheme to byte codes, and a verified interpreter for the resulting byte codes. The official denotational semantics for Scheme provides the main criterion of correctness. The WandClinger technique was used to prove correctness of the main compil ..."
Abstract

Cited by 45 (3 self)
 Add to MetaCart
VLISP has produced a rigorously verified compiler from Scheme to byte codes, and a verified interpreter for the resulting byte codes. The official denotational semantics for Scheme provides the main criterion of correctness. The WandClinger technique was used to prove correctness of the main compiler step. Then a state machine operational semantics is proved to be faithful to the denotational semantics. The remainder of the implementation is verified by a succession of state machine refinement proofs. These include proofs that garbage collection is a sound implementation strategy,
Semantics of Local Variables
, 1992
"... This expository article discusses recent progress on the problem of giving sufficiently abstract semantics to localvariable declarations in Algollike languages, especially work using categorical methods. ..."
Abstract

Cited by 35 (4 self)
 Add to MetaCart
This expository article discusses recent progress on the problem of giving sufficiently abstract semantics to localvariable declarations in Algollike languages, especially work using categorical methods.
References, Local Variables and Operational Reasoning
 In Seventh Annual Symposium on Logic in Computer Science
, 1992
"... this paper we regard the following as synonyms: references, program variables, pointers, locations, and unary cells) to a programming language complicates life. Adding them to the simply typed lambda calculus causes the failure of most of the nice mathematical properties and some of the more basic r ..."
Abstract

Cited by 30 (4 self)
 Add to MetaCart
this paper we regard the following as synonyms: references, program variables, pointers, locations, and unary cells) to a programming language complicates life. Adding them to the simply typed lambda calculus causes the failure of most of the nice mathematical properties and some of the more basic rules (such as j). For example strong normalization fails since it is possible, for each provably nonempty function type, to construct a Y combinator for that type. References also interact unpleasantly with polymorphism [34, 35]. They are also troublesome from a denotational point of view as illustrated by the lack of fully abstract models. For example, in [22] Meyer and Sieber give a series of examples of programs that are operationally equivalent (according to the intended semantics of blockstructured Algollike programs) but which are not given equivalent denotations in traditional denotational semantics. They propose various modifications to the denotational semantics which solve some of these discrepancies, but not all. In [27, 26] a denotational semantics that overcomes some of these problems is presented. However variations on the seventh example remain problematic. Since numerous proof systems for Algol are sound for the denotational models in question, [8, 7, 32, 28, 16, 27, 26], these equivalences, if expressible, must be independent of these systems. The problem which motivated Meyer and Sieber's paper, [22], was to provide mathematical justification for the informal but convincing proofs of the operational equivalence of their examples. In this paper we approach the same problem, but from an operational rather than denotational perspective. This paper accomplishes two goals. Firstly, we present the firstorder part of a new logic for reasoning about programs....
A Model for Syntactic Control of Interference
 MATHEMATICAL STRUCTURES IN COMPUTER SCIENCE
, 1993
"... Two imperative programming language phrases interfere when one writes to a storage variable that the other reads from or writes to. Reynolds has described an elegant linguistic approach to controlling interference in which a refinement of typed calculus is used to limit sharing of storage variables; ..."
Abstract

Cited by 19 (4 self)
 Add to MetaCart
Two imperative programming language phrases interfere when one writes to a storage variable that the other reads from or writes to. Reynolds has described an elegant linguistic approach to controlling interference in which a refinement of typed calculus is used to limit sharing of storage variables; in particular, different identifiers are required never to interfere. This paper examines semantic foundations of the approach. We describe a category that has (an abstraction of) interference information built into all objects and maps. This information is used to define a “tensor” product whose components are required never to interfere. Environments are defined using the tensor, and procedure types are obtained via a suitable adjunction. The category is a model of intuitionistic linear logic. Reynolds’ concept of passive type – i.e. types for phrases that don’t write to any storage variables – is shown to be closely related, in this model, to Girard’s “of course” modality.
NREVERSAL of Fortune  The Thermodynamics of Garbage Collection
 In ACM Sigplan Notices
, 1977
"... The need to reverse a computation arises in many contextsdebugging, editor undoing, optimistic concurrency undoing, speculative computation undoing, trace scheduling, exception handling undoing, database recovery, optimistic discrete event simulations, subjunctive computing, etc. The need to anal ..."
Abstract

Cited by 14 (0 self)
 Add to MetaCart
The need to reverse a computation arises in many contextsdebugging, editor undoing, optimistic concurrency undoing, speculative computation undoing, trace scheduling, exception handling undoing, database recovery, optimistic discrete event simulations, subjunctive computing, etc. The need to analyze a reversed computation arises in the context of static analysisliveness analysis, strictness analysis, type inference, etc. Traditional means for restoring a computation to a previous state involve checkpoints; checkpoints require time to copy, as well as space to store, the copied material. Traditional reverse abstract interpretation produces relatively poor information due to its inability to guess the previous values of assignedto variables. We propose an abstract computer model and a programming languageYLispwhose primitive operations are injective and hence reversible, thus allowing arbitrary undoing without the overheads of checkpointing. Such a computer can be built from reversible conservative logic circuits, with the serendipitous advantage of dissipating far less heat than traditional Boolean AND/OR/NOT circuits. Unlike functional languages, which have one &quot;state &quot; for all times, YLisp has at all times one &quot;state&quot;, with unique predecessor and successor states. Compiling into a reversible pseudocode can have benefits even when targeting a traditional computer. Certain optimizations, e.g., updateinplace, and compiletime garbage collection may be more easily performed, because the
Abstract Models of Storage
, 2000
"... This note is a historical survey of Christopher Strachey's influence on the development of semantic models of assignment and storage management in procedural languages. ..."
Abstract

Cited by 8 (0 self)
 Add to MetaCart
This note is a historical survey of Christopher Strachey's influence on the development of semantic models of assignment and storage management in procedural languages.
A Theory of Classes for a Functional Language with Effects
 In Proceedings of CSL92, volume 702 of Lecture Notes in Computer Science
, 1993
"... this paper we introduce a variable typed logic of effects (i.e. a logic of effects where classes can be defined and quantified over) inspired by the variable type systems of Feferman [3, 4] for purely functional languages. A similar extension incorporating nonlocal control operations was introduced ..."
Abstract

Cited by 7 (6 self)
 Add to MetaCart
this paper we introduce a variable typed logic of effects (i.e. a logic of effects where classes can be defined and quantified over) inspired by the variable type systems of Feferman [3, 4] for purely functional languages. A similar extension incorporating nonlocal control operations was introduced in [27]. The logic we present provides an expressive language for defining specifications and constraints and for studying properties and program equivalences, in a uniform framework. Thus it has an advantage over a plethora of systems in the literature that aim to capture solitary aspects of computation. The theory also allows for the construction of inductively defined sets and derivation of the corresponding induction principles. Classes can be used to express, inter alia, the nonexpansiveness of terms [29]. Other effects can also be represented within the system. These include read/write effects and various forms of interference [24]. The first order fragment is described in [16] where it is used to resolve the denotationally problematic examples of [17]. In our language atoms, references and lambda abstractions are all first class values and as such are storable. This has several consequences. Firstly, mutation and variable binding are separate and so we avoid the problems that typically arise (e.g. in Hoare's and dynamic logic) from the conflation of program variables and logical variables. Secondly, the equality and sharing of references (aliasing) is easily expressed and reasoned about. Thirdly, the combination of mutable references and lambda abstractions allows us to study object based programming within our framework. Our atomic formulas express the (operational or observational) equivalence of programs `a la Plotkin [23]. Neither Hoare's logic nor Dynamic logi...
Computing with Capsules
, 2011
"... Capsules provide a clean algebraic representation of the state of a computation in higherorder functional and imperative languages. They play the same role as closures or heap or stackallocated environments but are much simpler. A capsule is essentially a finite coalgebraic representation of a reg ..."
Abstract

Cited by 4 (2 self)
 Add to MetaCart
Capsules provide a clean algebraic representation of the state of a computation in higherorder functional and imperative languages. They play the same role as closures or heap or stackallocated environments but are much simpler. A capsule is essentially a finite coalgebraic representation of a regular closed λcoterm. One can give an operational semantics based on capsules for a higherorder programming language with functional and imperative features, including mutable bindings. Lexical scoping is captured purely algebraically without stacks, heaps, or closures. All operations of interest are typable with simple types, yet the language is Turing complete. Recursive functions are represented directly as capsules without the need for unnatural and untypable fixpoint combinators. 1