scholarly journals An Investigation of Abadi and Cardelli's Untyped Calculus of Objects

2008 ◽  
Vol 15 (6) ◽  
Author(s):  
Jacob Johannsen
Keyword(s):  
Program Transformations ◽  
Small Step ◽  
Abstract Machine ◽  
Abstract Machines ◽  
Explicit Substitutions ◽  
The Relationship ◽  
Two Machines

We study the relationship between the natural (big-step) semantics and the reduction (small-step) semantics of Abadi and Cardelli's untyped calculus of objects. By applying Danvy et al.'s functional correspondence to the natural semantics, we derive an abstract machine for this calculus, and by applying Danvy et al.'s syntactic correspondence to the reduction semantics, we also derive an abstract machines for this calculus. These two abstract machines are identical. The fact that the machines are identical, and the fact that they have been derived using meaning-preserving program transformations, entail that the derivation constitutes a proof of equivalence between natural semantics and the reduction semantics. The derivational nature of our proof contrasts with Abadi and Cardelli's soundness proof, which was carried out by pen and paper. We also note that the abstract machine is new.<br /> <br />To move closer to actual language implementations, we reformulate the calculus to use explicit substitutions. The reformulated calculus is new. By applying the functional and syntactic correspondences to natural and reduction semantics of this new calculus, we again obtain two abstract machines. These two machines are also identical, and as such, they establish the equivalence of the natural semantics and the reduction semantics of the new calculus.<br /> <br />Finally, we prove that the two abstract machines are strongly bisimilar. Therefore, the two calculi are computationally equivalent.

scholarly journals Inter-Deriving Semantic Artifacts for Object-Oriented Programming

2008 ◽  
Vol 15 (5) ◽  
Author(s):  
Olivier Danvy ◽  
Jacob Johannsen
Keyword(s):  
Operational Semantics ◽  
Object Oriented ◽  
Object Oriented Programming ◽  
Small Step ◽  
Abstract Machine ◽  
Abstract Machines ◽  
Explicit Substitutions

We present a new abstract machine for Abadi and Cardelli's untyped calculus of objects. What is special about this semantic artifact (i.e., man-made construct) is that is mechanically corresponds to both the reduction semantics (i.e., small-step operational semantics) and the natural semantics (i.e., big-step operational semantics) specified in Abadi and Cardelli's monograph. This abstract machine therefore embodies the soundness of Abadi and Cardelli's reduction semantics and natural semantics relative to each other. <br /> <br />To move closer to actual implementations, which use environments rather than actual substitutions, we then represent object methods as closures and in the same inter-derivational spirit, we present three new semantic artifacts: a reduction semantics for a version of Abadi and Cardelli's untyped calculus of objects with explicit substitutions, an environment-based abstract machine, and a natural semantics (i.e., an interpreter) with environments. These three new semantic artifacts mechanically correspond to each other, and furthermore, they are coherent with the previous ones since as we show, the two abstract machines are bisimilar. Overall, though, the significance of these artifacts lies in them not having been designed from scratch and then proved correct: instead, they were mechanically inter-derived.

scholarly journals A Concrete Framework for Environment Machines

2005 ◽  
Vol 12 (15) ◽  
Author(s):  
Malgorzata Biernacka ◽  
Olivier Danvy
Keyword(s):  
Lambda Calculus ◽  
Intermediate Step ◽  
Common Belief ◽  
Normal Order ◽  
Abstract Machine ◽  
Abstract Machines ◽  
Reduction Strategies ◽  
Explicit Substitutions ◽  
One Step ◽  
The Common

We materialize the common belief that calculi with explicit substitutions provide an intermediate step between an abstract specification of substitution in the lambda-calculus and its concrete implementations. To this end, we go back to Curien's original calculus of closures (an early calculus with explicit substitutions), we extend it minimally so that it can express one-step reduction strategies, and we methodically derive a series of environment machines from the specification of two one-step reduction strategies for the lambda-calculus: normal order and applicative order. The derivation extends Danvy and Nielsen's refocusing-based construction of abstract machines with two new steps: one for coalescing two successive transitions into one, and one for unfolding a closure into a term and an environment in the resulting abstract machine. The resulting environment machines include both the idealized and the original versions of Krivine's machine, Felleisen et al.'s CEK machine, and Leroy's Zinc abstract machine.

scholarly journals A Concrete Framework for Environment Machines

2006 ◽  
Vol 13 (3) ◽  
Author(s):  
Malgorzata Biernacka ◽  
Olivier Danvy
Keyword(s):  
Lambda Calculus ◽  
Intermediate Step ◽  
Abstract Machine ◽  
Abstract Machines ◽  
Reduction Strategies ◽  
Explicit Substitutions ◽  
One Step ◽  
The Common ◽  
Krivine Machine ◽  
Common Understanding

We materialize the common understanding that calculi with explicit substitutions provide an intermediate step between an abstract specification of substitution in the lambda-calculus and its concrete implementations. To this end, we go back to Curien's original calculus of closures (an early calculus with explicit substitutions), we extend it minimally so that it can also express one-step reduction strategies, and we methodically derive a series of environment machines from the specification of two one-step reduction strategies for the lambda-calculus: normal order and applicative order. The derivation extends Danvy and Nielsen's refocusing-based construction of abstract machines with two new steps: one for coalescing two successive transitions into one, and the other for unfolding a closure into a term and an environment in the resulting abstract machine. The resulting environment machines include both the Krivine machine and the original version of Krivine's machine, Felleisen et al.'s CEK machine, and Leroy's Zinc abstract machine.

scholarly journals A Functional Correspondence between Call-by-Need Evaluators and Lazy Abstract Machines

2004 ◽  
Vol 11 (3) ◽  
Author(s):  
Mads Sig Ager ◽  
Olivier Danvy ◽  
Jan Midtgaard
Keyword(s):  
Lambda Calculus ◽  
Program Transformations ◽  
Abstract Machine ◽  
Abstract Machines ◽  
Implementation Techniques ◽  
Closure Conversion ◽  
Implementation Technique

We bridge the gap between compositional evaluators and abstract machines for the lambda-calculus, using closure conversion, transformation into continuation-passing style, and defunctionalization of continuations. This article is a followup of our article at PPDP 2003, where we consider call by name and call by value. Here, however, we consider call by need.<br /> <br />We derive a lazy abstract machine from an ordinary call-by-need evaluator that threads a heap of updatable cells. In this resulting abstract machine, the continuation fragment for updating a heap cell naturally appears as an `update marker', an implementation technique that was invented for the Three Instruction Machine and subsequently used to construct lazy variants of Krivine's abstract machine. Tuning the evaluator leads to other implementation techniques such as unboxed values. The correctness of the resulting abstract machines is a corollary of the correctness of the original evaluators and of the program transformations used in the derivation.

scholarly journals Towards Compatible and Interderivable Semantic Specifications for the Scheme Programming Language, Part I: Denotational Semantics, Natural Semantics, and Abstract Machines

2008 ◽  
Vol 15 (7) ◽  
Author(s):  
Olivier Danvy
Keyword(s):  
Programming Language ◽  
Denotational Semantics ◽  
Transition Function ◽  
Evaluation Function ◽  
Small Step ◽  
Valuation Function ◽  
Abstract Machine ◽  
Abstract Machines

We derive two big-step abstract machines, a natural semantics, and the valuation function of a denotational semantics based on the small-step abstract machine for Core Scheme presented by Clinger at PLDI'98. Starting from a functional implementation of this small-step abstract machine, (1) we fuse its transition function with its driver loop, obtaining the functional implementation of a big-step abstract machine; (2) we adjust this big-step abstract machine so that it is in defunctionalized form, obtaining the functional implementation of a second big-step abstract machine; (3) we refunctionalize this adjusted abstract machine, obtaining the functional implementation of a natural semantics in continuation style; and (4) we closure-unconvert this natural semantics, obtaining a compositional continuation-passing evaluation function which we identify as the functional implementation of a denotational semantics in continuation style. We then compare this valuation function with that of Clinger's original denotational semantics of Scheme.

scholarly journals A Functional Correspondence between Call-by-Need Evaluators and Lazy Abstract Machines

2003 ◽  
Vol 10 (24) ◽  
Author(s):  
Mads Sig Ager ◽  
Olivier Danvy ◽  
Jan Midtgaard
Keyword(s):  
Lambda Calculus ◽  
Program Transformations ◽  
Abstract Machine ◽  
Abstract Machines ◽  
Implementation Techniques ◽  
Closure Conversion ◽  
Implementation Technique

<p>We bridge the gap between compositional evaluators and abstract machines for the lambda-calculus, using closure conversion, transformation into continuation-passing style, and defunctionalization of continuations. This article is a spin-off of our article at PPDP 2003, where we consider call by name and call by value. Here, however, we consider call by need.<br /> <br />We derive a lazy abstract machine from an ordinary call-by-need evaluator that threads a heap of updatable cells. In this resulting abstract machine, the continuation fragment for updating a heap cell naturally appears as an `update marker', an implementation technique that was invented for the Three Instruction Machine and subsequently used to construct lazy variants of Krivine's abstract machine. Tuning the evaluator leads to other implementation techniques such as unboxed values and the push-enter model. The correctness of the resulting abstract machines is a corollary of the correctness of the original evaluators and of the program transformations used in the derivation.</p><br /><br />Superseded by BRICS-RS-04-3.

scholarly journals A Rational Deconstruction of Landin's SECD Machine

2003 ◽  
Vol 10 (33) ◽  
Author(s):  
Olivier Danvy
Keyword(s):  
Programming Languages ◽  
Subsequent Development ◽  
Reconstruction Method ◽  
Evaluation Function ◽  
Program Transformations ◽  
Abstract Machine ◽  
Functional Programming Languages ◽  
Secd Machine ◽  
Abstract Machines ◽  
Environment Control

Landin's SECD machine was the first abstract machine for the lambda-calculus viewed as a programming language. Both theoretically as a model of computation and practically as an idealized implementation, it has set the tone for the subsequent development of abstract machines for functional programming languages. However, and even though variants of the SECD machine have been presented, derived, and invented, the precise rationale for its architecture and modus operandi has remained elusive. In this article, we deconstruct the SECD machine into a lambda-interpreter, i.e., an evaluation function, and we reconstruct lambda-interpreters into a variety of SECD-like machines. The deconstruction and reconstructions are transformational: they are based on equational reasoning and on a combination of simple program transformations--mainly closure conversion, transformation into continuation-passing style, and defunctionalization.<br /> <br />The evaluation function underlying the SECD machine provides a precise rationale for its architecture: it is an environment-based eval-apply evaluator with a callee-save strategy for the environment, a data stack of intermediate results, and a control delimiter. Each of the components of the SECD machine (stack, environment, control, and dump) is therefore rationalized and so are its transitions.<br /> <br />The deconstruction and reconstruction method also applies to other abstract machines and other evaluation functions. It makes it possible to systematically extract the denotational content of an abstract machine in the form of a compositional evaluation function, and the (small-step) operational content of an evaluation function in the form of an abstract machine.

scholarly journals Description and Optimization of Abstract Machines in a Dialect of Prolog

2015 ◽  
Vol 16 (1) ◽  
pp. 1-58 ◽  
Author(s):  
JOSÉ F. MORALES ◽  
MANUEL CARRO ◽  
MANUEL HERMENEGILDO
Keyword(s):  
Virtual Machine ◽  
State Of The Art ◽  
Optimization Techniques ◽  
Program Transformations ◽  
Competitive Performance ◽  
Abstract Machine ◽  
Relative Ease ◽  
Machine Description ◽  
Abstract Machines ◽  
High Level

AbstractIn order to achieve competitive performance, abstract machines for Prolog and related languages end up being large and intricate, and incorporate sophisticated optimizations, both at the design and at the implementation levels. At the same time, efficiency considerations make it necessary to use low-level languages in their implementation. This makes them laborious to code, optimize, and, especially, maintain and extend. Writing the abstract machine (and ancillary code) in a higher-level language can help tame this inherent complexity. We show how the semantics of most basic components of an efficient virtual machine for Prolog can be described using (a variant of) Prolog. These descriptions are then compiled to C and assembled to build a complete bytecode emulator. Thanks to the high-level of the language used and its closeness to Prolog, the abstract machine description can be manipulated using standard Prolog compilation and optimization techniques with relative ease. We also show how, by applying program transformations selectively, we obtain abstract machine implementations whose performance can match and even exceed that of state-of-the-art, highly-tuned, hand-crafted emulators.

Conclusion: Legacies

2018 ◽  
pp. 238-242
Author(s):  
Deirdre Coleman
Keyword(s):  
Sierra Leone ◽  
West Indies ◽  
Mixed Race ◽  
West African ◽  
Small Step ◽  
Commercial Agriculture ◽  
The West ◽  
Forced Labour ◽  
Black Poor ◽  
The Relationship

Smeathman dies in London from a ‘putrid fever’ in July 1786. The Committee for the Black Poor sully his posthumous reputation, possibly because of his support for a mixed-race constitution in Sierra Leone. They fail to see that Smeathman’s scheme for commercial agriculture, powered by the labour of redeemed slaves, presented a small step forward in recasting the relationship between forced labour and empire. Smeathman’s essay on the West African termite has many afterlives, especially in terms of its engravings, but the big book on Africa and the West Indies—his ‘Voyages and Travels’—is never published.

Continuation-based compilation of functional languages for parallel machines

1992 ◽  
Vol 2 (4) ◽  
pp. 393-414
Author(s):  
J.-F. Giorgi ◽  
D. Le Métayer
Keyword(s):  
Parallel Machines ◽  
Parallel Implementation ◽  
Functional Expression ◽  
Functional Languages ◽  
Program Transformations ◽  
Task Management ◽  
Machine Code ◽  
Abstract Machine ◽  
Functional Term

We tackle the problems of correctness and efficiency of paralled implementations of functional languages. We present a compilation technique described in terms of program transformations in the functional framework. The original functional expression is transformed into a functional term, which can be seen as traditional machine code. The main feature of the parallel implementation is the use of continuations. We introduce a parallel abstract machine describing lazy task creation in terms of exportation of continuations. The advantages of the approach are twofold: (1)correetness proofs are made simpler and (2) the implementation is efficient because the use of continuations reduces the task management overhead.

Sign in / Sign up

Export Citation Format

Share Document