Revised report on the algorithmic language scheme

Authors:
H. Abelson;R. K. Dybvig;C. T. Haynes;G. J. Rozas;N. I. Adams, IV;D. P. Friedman;E. Kohlbecker;G. L. Steele, Jr.;D. H. Bartley;R. Halstead;D. Oxley;G. J. Sussman;G. Brooks;C. Hanson;K. M. Pitman;M. Wand;William Clinger;Jonathan Rees
Affiliations:
-;-;-;-;-;-;-;-;-;-;-;-;-;-;-;-;-;-
Venue:
ACM SIGPLAN Lisp Pointers
Year:
1991

Citing 66
Cited 81

ORBIT: an optimizing compiler for scheme

SIGPLAN '86 Proceedings of the 1986 SIGPLAN symposium on Compiler construction
Revised report on the algorithmic language scheme

ACM SIGPLAN Notices
Obtaining coroutines with continuations

Computer Languages
A closer look at export and import statements

Computer Languages
A scheme for a higher-level semantic algebra

Algebraic methods in semantics
A reduction semantics for imperative higher-order languages

Volume II: Parallel Languages on PARLE: Parallel Architectures and Languages Europe
Structure and interpretation of computer programs

Structure and interpretation of computer programs
Using closures for code generation

Computer Languages
Embedding continuations in procedural objects

ACM Transactions on Programming Languages and Systems (TOPLAS)
Common LISP: the language

Common LISP: the language
Abstracting timed preemption with engines

Computer Languages
A syntactic theory of sequential control

Theoretical Computer Science
The little LISPer

The little LISPer
The SCHEME programming language

The SCHEME programming language
Reflections on Landin's J-operator: a partly historical note

Computer Languages
A calculus for assignments in higher-order languages

POPL '87 Proceedings of the 14th ACM SIGACT-SIGPLAN symposium on Principles of programming languages
LISP: a language for stratified design

BYTE
Semantics of Scheme

BYTE
Control flow analysis in scheme

PLDI '88 Proceedings of the ACM SIGPLAN 1988 conference on Programming Language design and Implementation
Abstract continuations: a mathematical semantics for handling full jumps

LFP '88 Proceedings of the 1988 ACM conference on LISP and functional programming
Syntactic closures

LFP '88 Proceedings of the 1988 ACM conference on LISP and functional programming
A variable-arity procedural interface

LFP '88 Proceedings of the 1988 ACM conference on LISP and functional programming
Implementation strategies for continuations

LFP '88 Proceedings of the 1988 ACM conference on LISP and functional programming
Object-oriented programming in scheme

LFP '88 Proceedings of the 1988 ACM conference on LISP and functional programming
Engines from continuations

Computer Languages
The runtime environment for Scheme, a Scheme implementation on the 88000

ASPLOS III Proceedings of the third international conference on Architectural support for programming languages and operating systems
Scheme and the art of programming

Scheme and the art of programming
Control delimiters and their hierarchies

Lisp and Symbolic Computation
Towards a facility for lexically scoped, dynamic mutual recursion in Scheme

Computer Languages
A module system for scheme

LFP '90 Proceedings of the 1990 ACM conference on LISP and functional programming
A parallel virtual machine for efficient scheme compilation

LFP '90 Proceedings of the 1990 ACM conference on LISP and functional programming
Representing control in the presence of first-class continuations

PLDI '90 Proceedings of the ACM SIGPLAN 1990 conference on Programming language design and implementation
How to read floating point numbers accurately

PLDI '90 Proceedings of the ACM SIGPLAN 1990 conference on Programming language design and implementation
How to print floating-point numbers accurately

PLDI '90 Proceedings of the ACM SIGPLAN 1990 conference on Programming language design and implementation
Continuations and concurrency

PPOPP '90 Proceedings of the second ACM SIGPLAN symposium on Principles & practice of parallel programming
Macros that work

POPL '91 Proceedings of the 18th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Programming in MacScheme

Programming in MacScheme
Constraining control

POPL '85 Proceedings of the 12th ACM SIGACT-SIGPLAN symposium on Principles of programming languages
The implementation of PC Scheme

LFP '86 Proceedings of the 1986 ACM conference on LISP and functional programming
Hygienic macro expansion

LFP '86 Proceedings of the 1986 ACM conference on LISP and functional programming
The mystery of the tower revealed: a non-reflective description of the reflective tower

LFP '86 Proceedings of the 1986 ACM conference on LISP and functional programming
Continuation-Based Program Transformation Strategies

Journal of the ACM (JACM)
Design of a LISP-based microprocessor

Communications of the ACM
Correspondence between ALGOL 60 and Church's Lambda-notation: part I

Communications of the ACM
Revised report on the algorithm language ALGOL 60

Communications of the ACM
Finding the source of type errors

POPL '86 Proceedings of the 13th ACM SIGACT-SIGPLAN symposium on Principles of programming languages
IEEE Std 1178-1990, IEEE Standard for the Scheme Programming Language

IEEE Std 1178-1990, IEEE Standard for the Scheme Programming Language
Denotational Semantics: The Scott-Strachey Approach to Programming Language Theory

Denotational Semantics: The Scott-Strachey Approach to Programming Language Theory
Logic Continuations

Proceedings of the Third International Conference on Logic Programming
Engines build process abstractions

LFP '84 Proceedings of the 1984 ACM Symposium on LISP and functional programming
Reification: Reflection without metaphysics

LFP '84 Proceedings of the 1984 ACM Symposium on LISP and functional programming
The scheme 311 compiler an exercise in denotational semantics

LFP '84 Proceedings of the 1984 ACM Symposium on LISP and functional programming
An overview of COMMON LISP

LFP '82 Proceedings of the 1982 ACM symposium on LISP and functional programming
T: a dialect of Lisp or LAMBDA: The ultimate software tool

LFP '82 Proceedings of the 1982 ACM symposium on LISP and functional programming
Functional geometry

LFP '82 Proceedings of the 1982 ACM symposium on LISP and functional programming
Continuation-based multiprocessing

LFP '80 Proceedings of the 1980 ACM conference on LISP and functional programming
A semantic comparison of LISP and SCHEME

LFP '80 Proceedings of the 1980 ACM conference on LISP and functional programming
An efficient environment allocation scheme in an interpreter for a lexically-scoped LISP

LFP '80 Proceedings of the 1980 ACM conference on LISP and functional programming
The dream of a lifetime: A lazy variable extent mechanism

LFP '80 Proceedings of the 1980 ACM conference on LISP and functional programming
Special forms in Lisp

LFP '80 Proceedings of the 1980 ACM conference on LISP and functional programming
Principal values and branch cuts in complex APL

APL '81 Proceedings of the international conference on APL
Definitional interpreters for higher-order programming languages

ACM '72 Proceedings of the ACM annual conference - Volume 2
Macaroni is better than spaghetti

Proceedings of the 1977 symposium on Artificial intelligence and programming languages
Debunking the “expensive procedure call” myth or, procedure call implementations considered harmful or, LAMBDA: The Ultimate GOTO

ACM '77 Proceedings of the 1977 annual conference
Rabbit: A Compiler for Scheme

Rabbit: A Compiler for Scheme
Orbit: an optimizing compiler for scheme

Orbit: an optimizing compiler for scheme

Back to direct style II: first-class continuations

LFP '92 Proceedings of the 1992 ACM conference on LISP and functional programming
A definition of an ISWIM-like language via scheme

ACM SIGPLAN Notices
Towards efficient partial evaluation

PEPM '93 Proceedings of the 1993 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation
Polyvariant binding-time analysis for applicative languages

PEPM '93 Proceedings of the 1993 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation
A tour of Schism: a partial evaluation system for higher-order applicative languages

PEPM '93 Proceedings of the 1993 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation
Procs and locks: a portable multiprocessing platform for standard ML of New Jersey

PPOPP '93 Proceedings of the fourth ACM SIGPLAN symposium on Principles and practice of parallel programming
An efficient implementation of multiple return values in Scheme

LFP '94 Proceedings of the 1994 ACM conference on LISP and functional programming
Lambda, the ultimate label or a simple optimizing compiler for Scheme

LFP '94 Proceedings of the 1994 ACM conference on LISP and functional programming
Separating stages in the continuation-passing style transformation

POPL '93 Proceedings of the 20th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Quasi-static scoping: sharing variable bindings across multiple lexical scopes

POPL '93 Proceedings of the 20th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Tutorial notes on partial evaluation

POPL '93 Proceedings of the 20th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
APROL: a hybrid language

APL '93 Proceedings of the international conference on APL
PSD—a portable scheme debugger

ACM SIGPLAN Lisp Pointers
The scheme of things: implementing lexically scoped macros

ACM SIGPLAN Lisp Pointers
Metalevel building blocks for modular systems

ACM Transactions on Programming Languages and Systems (TOPLAS)
Representing monads

POPL '94 Proceedings of the 21st ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A library of high level control operators

ACM SIGPLAN Lisp Pointers
Continuation-based partial evaluation

LFP '94 Proceedings of the 1994 ACM conference on LISP and functional programming
Type reconstruction for variable-arity procedures

LFP '94 Proceedings of the 1994 ACM conference on LISP and functional programming
Analyzing stores and references in a parallel symbolic language

LFP '94 Proceedings of the 1994 ACM conference on LISP and functional programming
Fixpoint computation for polyvariant static analyses of higher-order applicative programs

ACM Transactions on Programming Languages and Systems (TOPLAS)
Isolating side effects in sequential languages

POPL '95 Proceedings of the 22nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A unified treatment of flow analysis in higher-order languages

POPL '95 Proceedings of the 22nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Adding generic functions to Scheme

ACM SIGPLAN Notices
A correspondence between continuation passing style and static single assignment form

IR '95 Papers from the 1995 ACM SIGPLAN workshop on Intermediate representations
Register allocation using lazy saves, eager restores, and greedy shuffling

PLDI '95 Proceedings of the ACM SIGPLAN 1995 conference on Programming language design and implementation
Higher-order distributed objects

ACM Transactions on Programming Languages and Systems (TOPLAS)
Catching bugs in the web of program invariants

PLDI '96 Proceedings of the ACM SIGPLAN 1996 conference on Programming language design and implementation
Representing control in the presence of one-shot continuations

PLDI '96 Proceedings of the ACM SIGPLAN 1996 conference on Programming language design and implementation
Flow-directed inlining

PLDI '96 Proceedings of the ACM SIGPLAN 1996 conference on Programming language design and implementation
The semantics of Scheme with future

Proceedings of the first ACM SIGPLAN international conference on Functional programming
First-class synchronization barriers

Proceedings of the first ACM SIGPLAN international conference on Functional programming
Sharing code through first-class environments

Proceedings of the first ACM SIGPLAN international conference on Functional programming
Compiling functional languages with flow analysis

ACM Computing Surveys (CSUR)
Eta-expansion does The Trick

ACM Transactions on Programming Languages and Systems (TOPLAS)
A practical and flexible flow analysis for higher-order languages

POPL '96 Proceedings of the 23rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Type-directed partial evaluation

POPL '96 Proceedings of the 23rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A practical soft type system for scheme

ACM Transactions on Programming Languages and Systems (TOPLAS)
Two for the price of one: composing partial evaluation and compilation

Proceedings of the ACM SIGPLAN 1997 conference on Programming language design and implementation
Automatic management of operating-system resources

ICFP '97 Proceedings of the second ACM SIGPLAN international conference on Functional programming
Partial evaluation of call-by-value &lgr;-calculus with side-effects

PEPM '97 Proceedings of the 1997 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation
Partial Evaluation of the Euclidian Algorithm

Lisp and Symbolic Computation
Ephemerons: a new finalization mechanism

Proceedings of the 12th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Distributed partial evaluation

PASCO '97 Proceedings of the second international symposium on Parallel symbolic computation
Polymorphic splitting: an effective polyvariant flow analysis

ACM Transactions on Programming Languages and Systems (TOPLAS)
A distributed garbage collector with diffusion tree reorganisation and mobile objects

ICFP '98 Proceedings of the third ACM SIGPLAN international conference on Functional programming
Encoding types in ML-like languages

ICFP '98 Proceedings of the third ACM SIGPLAN international conference on Functional programming
Visualizing Evaluation in Scheme

Lisp and Symbolic Computation
Dependency analysis for Standard ML

ACM Transactions on Programming Languages and Systems (TOPLAS)
A Control-Flow Analysis for a Calculus of Concurrent Objects

IEEE Transactions on Software Engineering
Point of view: Lisp as an alternative to Java

intelligence
A Polymorphic Environment Calculus and its Type-Inference Algorithm

Higher-Order and Symbolic Computation
Semantics of combinations in scheme

ACM SIGPLAN Lisp Pointers
Advanced control flows for flexible graphical user interfaces: or, growing GUIs on trees or, bookmarking GUIs

Proceedings of the 24th International Conference on Software Engineering
Message-Based Evaluation in Scheme for High-Level Robot Control

Journal of Intelligent and Robotic Systems
Revised Report on the Algorithmic Language Scheme

Higher-Order and Symbolic Computation
An Introduction to Landin‘s “A Generalization of Jumps and Labels”

Higher-Order and Symbolic Computation
Scoping Constructs for Software Generators

GCSE '99 Proceedings of the First International Symposium on Generative and Component-Based Software Engineering
Automatically Restructuring Programs for the Web

Proceedings of the 16th IEEE international conference on Automated software engineering
Layered, Server-Based Support for Object-Oriented Application Development

IWOOOS '95 Proceedings of the 4th International Workshop on Object-Orientation in Operating Systems
An adequate and efficient left-associated binary numeral system in the λ-calculus

Journal of Functional Programming
DrScheme: a programming environment for Scheme

Journal of Functional Programming
de Bruijn notation as a nested datatype

Journal of Functional Programming
Scheme-based web programming as a basis for a CS0 curriculum

Proceedings of the 35th SIGCSE technical symposium on Computer science education
Logic programming in the context of multiparadigm programming: the Oz experience

Theory and Practice of Logic Programming
How to print floating-point numbers accurately

ACM SIGPLAN Notices - Best of PLDI 1979-1999
The structure and interpretation of the computer science curriculum

Journal of Functional Programming
Computer literacy via Scheme and web programming

Journal of Functional Programming
From functional to object-oriented programming: a smooth transition for beginners

Proceedings of the 2005 workshop on Functional and declarative programming in education
Computability classes for enforcement mechanisms

ACM Transactions on Programming Languages and Systems (TOPLAS)
A new architecture for the implementation of scripting languages

VHLLS'94 Proceedings of the USENIX 1994 Very High Level Languages Symposium Proceedings on USENIX 1994 Very High Level Languages Symposium Proceedings
Design and semantics of quantum: a language to control resource consumption in distributed computing

DSL'97 Proceedings of the Conference on Domain-Specific Languages on Conference on Domain-Specific Languages (DSL), 1997
DiSTiL: a transformation library for data structures

DSL'97 Proceedings of the Conference on Domain-Specific Languages on Conference on Domain-Specific Languages (DSL), 1997
Programming language support for digitized images or, the monsters in the closet

DSL'97 Proceedings of the Conference on Domain-Specific Languages on Conference on Domain-Specific Languages (DSL), 1997
Objective-Tcl: an object-oriented Tcl environment

TCLTK '98 Proceedings of the 3rd Annual USENIX Workshop on Tcl/Tk - Volume 3
OMeta: an object-oriented language for pattern matching

Proceedings of the 2007 symposium on Dynamic languages
Hygienic macros through explicit renaming

ACM SIGPLAN Lisp Pointers
Scheme@33

Celebrating the 50th Anniversary of Lisp
Revised6 report on the algorithmic language scheme

Journal of Functional Programming
Towards compatible and interderivable semantic specifications for the scheme programming language, part I: denotational semantics, natural semantics, and abstract machines

Semantics and algebraic specification
An implementation of a hygienic syntactic macro system for JavaScript: a preliminary report

Workshop on Self-Sustaining Systems

Quantified Score

Hi-index	0.00

Visualization

Abstract

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.