Dartmouth ALGOL 30

Last updated
Dartmouth ALGOL 30
Paradigms Multi-paradigm: procedural, imperative, structured
Family ALGOL
Designed by Stephen J. Garland
Robert F. Hargraves
Anthony W. Knapp
Thomas E. Kurtz
Developer Dartmouth College
First appeared1961;62 years ago (1961)
Implementation language Assembly
Platform LGP-30
OS None
Influenced by
ALGOL 58, ALGOL 60
Influenced
SCALP for the LGP-30
Algol 60 for the Dartmouth Time Sharing System

Dartmouth ALGOL 30 was a 1960s-era implementation, first of the ALGOL 58 programming language and then of ALGOL 60. It is named after the computer on which it ran: a Librascope General Precision (LGP-30) desk-size computer acquired by Dartmouth College in 1959.

Since the limited size of the LGP-30 (4K 31-bit words) precluded a full implementation of ALGOL 60, certain features (arrays called by value, own arrays, strings, variable array bounds, and recursion) were omitted; but the implementation did include parameters called by name, using thunks [1] [2] and integer labels. [3]

ALGOL 30 was implemented by four undergraduate students. Stephen J. Garland wrote the compiler, discovering as a sophomore that compound statements and blocks could be included in the Samelson and Bauer translation algorithm. [4] This simple fact was not published until some years later by David Gries. [5] Robert F. Hargraves, Jorge Llacer, and Anthony W. Knapp developed the run-time system, which included an interpreter for floating-point arithmetic (not supported by the limited instruction set of the LGP-30). [6]

ALGOL 30 was a two-pass system. The first pass loaded the compiler and processed source code typed by the user; it generated intermediate code, similar to relocatable binary, and punched it onto paper tape. The second pass loaded both the run-time system and the intermediate code. Compilations could be "batched," but the delay between entering the source code tape and executing the compiled program were too great to allow widespread student use. [7]

To enable wider use, Garland and Knapp developed a "load-and-go" system known as SCALP, a Self Contained ALgol Processor, for a smaller subset of ALGOL 60 (which did not allow boolean variables or operators, blocks, procedures, own or dynamic arrays, conditional expressions, and step-until for statements). SCALP devoted a third of the LGP's memory to the compiler, a third to the run-time system (which included a floating-point interpreter and numeric functions), and a third for compiled user code. Students prepared source code off-line and punched it on paper tape with a Friden Flexowriter. Compilation occurred almost as quickly as the tape could be read in. This enabled student jobs to be completed in three minutes. Hundreds of students used SCALP before BASIC became available on the Dartmouth Time Sharing System in 1965. [8] [9]

ALGOL 30 was the basis for an implementation in 1965 of ALGOL 60 on the Dartmouth Time Sharing System. Several years later, Sidney Marshall produced an implementation of ALGOL 68. [10]

Related Research Articles

<span class="mw-page-title-main">ALGOL</span> Family of programming languages

ALGOL is a family of imperative computer programming languages originally developed in 1958. ALGOL heavily influenced many other languages and was the standard method for algorithm description used by the Association for Computing Machinery (ACM) in textbooks and academic sources for more than thirty years.

In computing, a compiler is a computer program that translates computer code written in one programming language into another language. The name "compiler" is primarily used for programs that translate source code from a high-level programming language to a low-level programming language to create an executable program.

Dartmouth BASIC is the original version of the BASIC programming language. It was designed by two professors at Dartmouth College, John G. Kemeny and Thomas E. Kurtz. With the underlying Dartmouth Time Sharing System (DTSS), it offered an interactive programming environment to all undergraduates as well as the larger university community.

Thomas Eugene Kurtz is a retired Dartmouth professor of mathematics and computer scientist, who along with his colleague John G. Kemeny set in motion the then revolutionary concept of making computers as freely available to college students as library books were, by implementing the concept of time-sharing at Dartmouth College. In his mission to allow non-expert users to interact with the computer, he co-developed the BASIC programming language and the Dartmouth Time Sharing System during 1963 to 1964.

In computer programming, a thunk is a subroutine used to inject a calculation into another subroutine. Thunks are primarily used to delay a calculation until its result is needed, or to insert operations at the beginning or end of the other subroutine. They have many other applications in compiler code generation and modular programming.

The Dartmouth Time-Sharing System (DTSS) is a discontinued operating system first developed at Dartmouth College between 1963 and 1964. It was the first successful large-scale time-sharing system to be implemented, and was also the system for which the BASIC language was developed. DTSS was developed continually over the next decade, reimplemented on several generations of computers, and finally shut down in 1999.

<span class="mw-page-title-main">Peter Landin</span> British computer scientist (1930–2009)

Peter John Landin was a British computer scientist. He was one of the first to realise that the lambda calculus could be used to model a programming language, an insight that is essential to the development of both functional programming and denotational semantics.

ALGOL 60 is a member of the ALGOL family of computer programming languages. It followed on from ALGOL 58 which had introduced code blocks and the begin and end pairs for delimiting them, representing a key advance in the rise of structured programming. ALGOL 60 was one of the first languages implementing function definitions. ALGOL 60 function definitions could be nested within one another, with lexical scope. It gave rise to many other languages, including CPL, PL/I, Simula, BCPL, B, Pascal, and C. Practically every computer of the era had a systems programming language based on ALGOL 60 concepts.

<span class="mw-page-title-main">ALGOL 68</span> Programming language

ALGOL 68 is an imperative programming language that was conceived as a successor to the ALGOL 60 programming language, designed with the goal of a much wider scope of application and more rigorously defined syntax and semantics.

ALGOL 58, originally named IAL, is one of the family of ALGOL computer programming languages. It was an early compromise design soon superseded by ALGOL 60. According to John Backus

The Zurich ACM-GAMM Conference had two principal motives in proposing the IAL: (a) To provide a means of communicating numerical methods and other procedures between people, and (b) To provide a means of realizing a stated process on a variety of machines...

The Navy Electronics Laboratory International ALGOL Compiler (NELIAC) is a dialect and compiler implementation of the programming language ALGOL 58, developed by the Navy Electronics Laboratory (NEL) in 1958.

<span class="mw-page-title-main">LGP-30</span> Librascope General Purpose computer (1956)

The LGP-30, standing for Librascope General Purpose and then Librascope General Precision, is an early off-the-shelf computer. It was manufactured by the Librascope company of Glendale, California, and sold and serviced by the Royal Precision Electronic Computer Company, a joint venture with the Royal McBee division of the Royal Typewriter Company. The LGP-30 was first manufactured in 1956, at a retail price of $47,000, equivalent to $510,000 in 2022.

Jensen's device is a computer programming technique that exploits call by name. It was devised by Danish computer scientist Jørn Jensen, who worked with Peter Naur at Regnecentralen. They worked on the GIER ALGOL compiler, one of the earliest correct implementations of ALGOL 60. ALGOL 60 used call by name. During his Turing Award speech, Naur mentions his work with Jensen on GIER ALGOL.

Klaus Samelson was a German mathematician, physicist, and computer pioneer in the area of programming language translation and push-pop stack algorithms for sequential formula translation on computers.

<span class="mw-page-title-main">History of compiler construction</span>

In computing, a compiler is a computer program that transforms source code written in a programming language or computer language, into another computer language. The most common reason for transforming source code is to create an executable program.

The history of the programming language Scheme begins with the development of earlier members of the Lisp family of languages during the second half of the twentieth century. During the design and development period of Scheme, language designers Guy L. Steele and Gerald Jay Sussman released an influential series of Massachusetts Institute of Technology (MIT) AI Memos known as the Lambda Papers (1975–1980). This resulted in the growth of popularity in the language and the era of standardization from 1990 onward. Much of the history of Scheme has been documented by the developers themselves.

IFIP Working Group 2.1 on Algorithmic Languages and Calculi is a working group of the International Federation for Information Processing (IFIP).

DOPE, short for Dartmouth Oversimplified Programming Experiment, was a simple programming language designed by John Kemény in 1962 to offer students a transition from flow-charting to programming the LGP-30. Lessons learned from implementing DOPE were subsequently applied to the invention and development of BASIC.

References

  1. ↑ P. Z. Ingerman, "Thunks: a way of compiling procedure statements with some comments on procedure declarations", Communications of the ACM 4:1, January 1961, pages 55–58.
  2. ↑ E. T. Irons and W. Feurzeig, "Comments on the implementation of recursive procedures and blocks in Algol-60", Communications of the ACM 4:11, January 1961, pages 65–69
  3. ↑ Thomas E. Kurtz, "Basic", History of Programming Languages, Association for Computing Machinery, June 1978, page 516.
  4. ↑ K. Samelson and F. L. Bauer, "Sequential formula translation", Communications of the ACM 3:2, February 1960, pages 76–83.
  5. ↑ (David Gries, "The use of transition matrices in compiling", Communications of the ACM 11:1, January 1968, pages 26–34.
  6. ↑ ALGOL for the LGP-30, A Comparison, Computation Center, Dartmouth College February 16, 1962.
  7. ↑ Kurtz, loc. cit.
  8. ↑ Kurtz, op. cit., page 517.
  9. ↑ A Manual for SCALP, being a Self Contained Algol Processor for the General Precision LGP-30, CCM-7A, Computation Center, Dartmouth College, January 1, 1964.
  10. ↑ Sidney Marshall, Preliminary Report on an ALGOL 68 Implementation, Kiewit Computation Center, Dartmouth College, December 1, 1969.
This page is based on this Wikipedia article
Text is available under the CC BY-SA 4.0 license; additional terms may apply.
Images, videos and audio are available under their respective licenses.