Debunking the “expensive procedure call” myth or, procedure call implementations considered harmful or, LAMBDA: The Ultimate GOTO

@inproceedings{Steele1977DebunkingT,
  title={Debunking the “expensive procedure call” myth or, procedure call implementations considered harmful or, LAMBDA: The Ultimate GOTO},
  author={Guy L. Steele},
  booktitle={ACM '77},
  year={1977}
}
  • G. Steele
  • Published in ACM '77 1977
  • Computer Science
Folklore states that GOTO statements are “cheap”, while procedure calls are “expensive”. This myth is largely a result of poorly designed language implementations. The historical growth of this myth is considered. Both theoretical ideas and an existing implementation are discussed which debunk this myth. It is shown that the unrestricted use of procedure calls permits great stylistic freedom. In particular, any flowchart can be written as a “structured” program without introducing extra… 
A Tail-Recursive Semantics for Stack Inspections
TLDR
An abstract machine for a language with security stack inspection whose space consumption function is equivalent to that of the canonical tail call optimizing abstract machine is exhibited and suggests that tail-calls are as easy to implement in a security setting as they are in a conventional one.
Efficient stack allocation for tail-recursive languages
  • C. Hanson
  • Computer Science
    LISP and Functional Programming
  • 1990
The Scheme dialect of Lisp [9] is properly tail-recuraiwit relies entirely on procedure calls to express iteration. In Scheme, a tail-recursive procedure call (that is, a call in which the calling
A tail-recursive machine with stack inspection
TLDR
An abstract machine for a language with security stack inspection whose space consumption function is equivalent to that of the canonical tail call optimizing abstract machine is exhibited and suggests that tail calls are as easy to implement in a security setting as they are in a conventional one.
Lambda, the ultimate label or a simple optimizing compiler for Scheme
TLDR
Lambda lifting makes optimizing compilers for higher-order languages practical by eliminating all non-local variables except for those that would have to be allocated in the heap anyway.
Optimization of Argument Evaluation Order
Lifetime Analysis for Procedure Parameters
TLDR
This paper presents a method for systematic lifetime analysis based on a context-free grammar which describes the calling structure of the program and shows that objects of recursive procedures can also be allocated globally, if certain conditions on their lifetime are met.
Technical correspondence
TLDR
If Rubin had concentrated on analyzing the problem rather than the code of the GOTOless version, he would have found a much simpler and far more general solution and maintenance programmers have a right to expect the loop to iterate the specified number of times.
Listlessness is better than laziness: Lazy evaluation and garbage collection at compile-time
One reason for interest in functional programming is that it is well-suited for program development by transformation: begin by writing a clear (but inefficient) program, and transform this to an
Compiling Higher-Order Languages into Fully Tail-Recursive Portable C
TLDR
The details of the compilation technique for a non-statically typed language (Scheme) are described and it is shown that the performance diiculty arises largely from the cost of C function calls.
An efficient environment allocation scheme in an interpreter for a lexically-scoped LISP
TLDR
This approach saves dramatically on garbage collections, at the price of increasing function application time a bit, but is worth doing if free storage is not abundant, or if it is important to avoid garbage collections.
...
...

References

SHOWING 1-10 OF 48 REFERENCES
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 function of FUNCTION in LISP or why the FUNARG problem should be called the environment problem
TLDR
A problem common to many powerful programming languages arises when one has to determine what values to assign to free variables in functions and the argument is tried to couch the argument in ALGOL-like terms as much as possible.
Fast arithmetic in MacLISP
Abstract : MacLISP provides a compiler which produces numerical code competitive in speed with some FORTRAN implementations and yet compatible with the rest of the MacLISP system. All numerical
A system which automatically improves programs
TLDR
Methods of mechanically converting programs that are easy to understand into more efficient ones, converting recursion equations using high level operations into lower level flowchart programs are given.
BLISS: a language for systems programming
A language, BLISS, is described. This language is designed so as to be especially suitable for use in writing production software systems for a specific machine (the PDP-10): compilers, operating
The Design of an Optimizing Compiler
TLDR
The design and implementation of a highly optimizing compiler for the BLISS language is described and a notational scheme is described in terms of which an overview of the compiler is presented.
A model and stack implementation of multiple environments
TLDR
This paper presents an implementation technique using a single stack to hold procedure activation storage which allows retention of that storage for durations not necessarily tied to control flow, and applications to multitasking, coroutines, backtracking, label-valued variables, and functional arguments are discussed.
LAMBDA: The Ultimate Declarative
TLDR
A new view of LAMBDA as a {\it renaming} operator is presented and contrasted with the usual functional view taken by LISP, which leads to several new insights into the nature of the LISp evaluation mechanism and the symmetry between form and function, evaluation and application, and control and environment.
Recursive functions of symbolic expressions and their computation by machine, Part I
A programming system called LISP (for LISt Processor) has been developed for the IBM 704 computer by the Artificial Intelligence group at M.I.T. The system was designed to facilitate experiments with
Peephole optimization
Redundant instructions may be discarded during the final stage of compilation by using a simple optimizing technique called peephole optimization. The method is described and examples are given.
...
...