Revised3 report on the algorithmic language scheme

  title={Revised3 report on the algorithmic language scheme},
  author={Jonathan Rees and William D. Clinger},
  journal={ACM SIGPLAN Notices},
The report gives a defining description of the programming language Scheme. Scheme is a statically scoped and properly tail-recursive dialect of the Lisp programming language invented by Guy Lewis Steele Jr. and Gerald Jay Sussman. It was designed to have an exceptionally clear and simple semantics and few different ways to form expressions. A wide variety of programming paradigms, including imperative, functional, and message passing styles, find convenient expression in Scheme. 
Revised5 Report on the Algorithmic Language Scheme
The report gives a defining description of the programming language Scheme. Scheme is a statically scoped and properly tail-recursive dialect of the Lisp programming language invented by Guy Lewis
Taming the Y operator
The techniques presented are general-purpose analysis and optimization tools, similar to well-known techniques used in theAnalysis and optimization of applicative languages, that combine synergistically to enable LIAR to generate identical machine code for ordinary recursive definitions written using letrec and those written using suitable forms of Y.
Compiling functional languages with flow analysis
This work argues for the use of aggressive interprocedural flow analysis to guide optimizations for higher-order languages such as Scheme and ML and presents a strategy for building high-performance implementations that relaxes these assumptions and provides a framework upon which useful optimizations can be built.
Report on the programming language Haskell: a non-strict, purely functional language version 1.2
"Some half dozen persons have written technically on combinatory logic, and most of these, including ourselves, have published something erroneous"; this is regarded as evidence that the subject is refractory.
Incremental JIT compiler for implicitly parallel functional language
  • Petr Krajča
  • Computer Science
    2013 Federated Conference on Computer Science and Information Systems
  • 2013
A novel method for automatic parallelization of functional programs which combines interpretation and just-in-time compilation is presented which involves a runtime environment which is able to identify portions of code worth running in parallel and be able to spawn new threads of execution.
Object-oriented programming in scheme
A small set of additions to Scheme to support object-oriented programming, including a form of multiple inheritance, are proposed, in keeping with the spirit of the Scheme language and consequently differ from Lisp-based object systems such as Flavors and the Common Lisp Object System.
Laziness by Need
This paper presents a semantics-based refactoring that helps strict programmers manage manual lazy programming, and presents a correctness argument for the underlying transformations and some preliminary experiences with a prototype tool implementation.
Pre-Scheme: A Scheme Dialect for Systems Programming
Pre-Scheme is a statically typed dialect of Scheme that gives the programmer the eeciency and low-level machine access of C while retaining many of the desirable features of Scheme. The Pre-Scheme
A Syntactic Approach to Type Soundness
A new approach to proving type soundness for Hindley/Milner-style polymorphic type systems by an adaptation of subject reduction theorems from combinatory logic to programming languages and the use of rewriting techniques for the specification of the language semantics is presented.
Assignment as the sole means of updating objects
It is possible, by appropriate programming language extensions, to use the assignment statement as the sole means of changing the value of a variable, thereby eliminating the need to modify routine


The Revised Revised Report on Scheme or An Uncommon Lisp
Abstract : Scheme is a statically scoped and properly tail-recursive dialect of the Lisp programming language invented by Guy Lewis Steele Jr and Gerald Jay Sussman. It was designed to have an
Rabbit: A Compiler for Scheme
A compiler for the lexically-scoped dialect of LISP known as SCHEME, which handles only a small basis set which reflects the semantics of lambda-calculus, and serves to produce code as good as that produced by more traditional compilers.
T: a dialect of Lisp or LAMBDA: The ultimate software tool
The T project is an experiment in language design and implementation that tests the thesis developed by Steele and Sussman that Scheme may be used as the basis for a practical programming language of exceptional expressive power and that implementations of Scheme could perform better than other Lisp systems, and competitively with implementations of programming languages.
Lambda: The Ultimate Imperative
We demonstrate how to model the following common programming constructs in terms of an applicative order language similar to LISP: Simple Recursion, Iteration, Compound Statements and Expressions, GO
The Revised Report on SCHEME: A Dialect of LISP.
SCHEME is an expression-oriented, applicative order, interpreter-based language which allows one to manipulate programs as data which differs from most current dialects of LISP in that it closes all lambda-expressions in the environment of their definition or declaration, rather than in the execution environment.
Programming with Continuations
This paper illustrates, with a novel example, the power of first class control objects, called continuations, in object oriented programming.
ORBIT: an optimizing compiler for scheme
Orbit was an optimizing compiler for T, a dialect of Scheme, that directly spawned six PhD theses and one Masters thesis, and influenced many other projects as well, including SML of New Jersey.
The Art of the Interpreter or, The Modularity Complex (Parts Zero, One, and Two)
We examine the effects of various language design decisions on the programming styles available to a user of the language, with particular emphasis on the ability to incrementally construct modular
Denotational Semantics: The Scott-Strachey Approach to Programming Language Theory
Syntactic extensions in the programming language LISP
A new macro declaration tool is designed that addresses each of the five problems from which the traditional tools suffer, and a new macro expansion algorithm is developed that eliminates the capturing problem.