ALGOL Implementation Research Articles

Lambda-calculus schemata

A lambda-calculus schema is an expression of the lambda calculus augmented by uninterpreted constant and operator symbols. It is an abstraction of programming languages such as LISP which permit functions to be passed to and returned from other functions. When given an interpretation for its constant and operator symbols, certain schemata, calledlambda abstractions, naturally define partial functions over the domain of interpretation. Two implementation strategies are considered: the retention strategy in which all variable bindings are retained until no longer needed (implying the use of some sort of garbage-collected store) and the deletion strategy, modeled after the usual stack implementation of ALGOL 60, in which variable bindings are destroyed when control leaves the procedure (or block) in which they were created. Not all lambda abstractions evaluate correctly under the deletion strategy. Nevertheless, both strategies are equally powerful in the sense that any lambda abstraction can be mechanically translated into another that evaluates correctly under the deletion strategy and defines the same partial function over the domain of interpretation as the original. Proof is by translation into continuation-passing style.

An implementation of Algol 68 for a small computer

AbstractA large subset of the language Algol 68 has been implemented on a small computer—the TESLA 200 with a 64 Kbyte store. In this paper, the general structure of the compiler and organization of the program at run‐time are described. Especially, the original methods and devices are mentioned that cause a considerable enhancement of the speed of compilation and program run. These concern the syntax analysis (consistent notation, error recovery), the organization of the resulting program (procedure organization, algorithms of work with multiple values) and the techniques of code generation.We try to show that Algol 68 is a suitable programming language for small as well as large computers and that it can successfully compete with traditional programming languages.

SATHE: Some aspects of an ALGOL implementation

AbstractThe development of a compiler for a dialect of ALGOL 60 is described. The emphasis is on the strategies used in the detection and smooth recovery from errors in the input text. These strategies are independent of both the language implemented and the implementation language. The user's view is such that he sees an ALGOL machine: the user is addressed in a language he is familiar with, using notions from the programming language and his particular program only.

An Improved Algorithm for Testing the Planarity of a Graph

Hopcroft and Tarjan [2] have recently proposed an algorithm that runs in linear time for testing the planarity of a graph. The technique finds a representation of the graph as a sequence of paths and then iteratively imbeds these paths to find a mesh structure, rearranging the meshes as needed to accommodate each new path. Demoucron et al. [1] have shown that this rearrangement process is unnecessary if the paths are considered in the proper order. The present implementation is found to run in linear time for most ordinary cases, about twice as fast as Tarjan's Algol implementation. A graph of 3000 vertices and 8994 edges required about 18 s.

Efficient Planarity Testing

This paper describes an efficient algorithm to determine whether an arbitrary graph G can be embedded in the plane. The algorithm may be viewed as an iterative version of a method originally proposed by Auslander and Parter and correctly formulated by Goldstein. The algorithm used depth-first search and has O ( V ) time and space bounds, where V is the number of vertices in G . An ALGOL implementation of the algorithm succesfully tested graphs with as many as 900 vertices in less than 12 seconds.

Compact transient-analysis program

An algorithm for the transient analysis of nonlinear networks is described. It uses a nodal-admittance representation and an implicit integration technique. The algorithm allows a compact and fast computer implementation, ideally suited to small-computer environments. An example of results obtained with an ALGOL implementation is given.

The implementation of ALGOL N

Recent expansion of new techniques invented a great number of application areas in which computers are used in the ways which have not been dreamed of a decade ago. Since the usage of computers was controlled by programs stored in computers, the production of programs has been increasing in enormous rate. In order to ease programming efforts, many programming devices have been invented and organized to become an operating system and a programming system. Nowadays the operating system serves as an interface between the hardware and the programming system or a programmer. They are designed as a multipurpose program so as to be able to handle any usage of the computer. The programming system is, on the other hand, the tool for the programmer to make a program. It serves as an interface between a programmer and the operating system or the hardware. Since there are peculiar notions in each application area, different programming languages are invented for each application area so that programs become short and easy to write. The nucleus of the programming system is the language processor, so the programming system is expanding in terms of language processors. It now becomes necessary to find an easy way to create programming systems which can be expanded easily. There are three main approaches to resolving this problem. The first approach is to make a universal language and to write all programs in this language. Only one language processor is necessary for one computer. But this has never been realized. PL/I is supposed to serve as a higher programming language version of a universal language. The second approach is to make one compiler-compiler and to generate all compilers for different programming languages by that compiler-compiler. Strong tools for defining the syntax of the language already exist, but it is still not easy to define semantics. So it is very difficult to generate a good compiler with a good optimization facility. The third approach, now becoming more attractive, is the attempt to make a language extensible. An extensible language is the language which can introduce new syntax, practically in the form of operators, and new data structures. So if a programmer wants special operators and data structures, he can declare them before the program and can program in terms of them. This approach is promising since the programmer can make a program constructively.

LITHP--an ALGOL List Processor

A list processing package was written in collaboration with Mr. P. Hammersley of Northampton College of Advanced Technology for use on the Elliott 503, and the Ferranti Pegasus, though further development was halted on the Pegasus due to lack of store and also on the 503 due to limitations of the Elliott ALGOL. The list processing methods used here depend very heavily on those of Woodward and Jenkins of The Royal Radar Establishment (Woodward and Jenkins, 1961; Jenkins, 1964)—in fact, the processes used in this paper are a slight variation on their exposition of McCarthy's LISP (McCarthy, 1960). The object of this paper is to facilitate the implementation of a list processing procedure on any machine that has an adequate ALGOL compiler, and for descriptive purposes the program is called LITHP. As list processing is essentially recursive, an ALGOL implementation that is not fully recursive itself, such as that of the 503, may impose severe restrictions on the capability of the machine to handle LITHP. However, no such difficulties should occur with machines which have a full ALGOL implementation.

A note on the derivation of maximal compatibility classes

An algorithm for determining the maximal compatibility classes of a compatibility relation is proposed in this paper. The algorithm consists of a simple recursive procedure which operates on the compatibility table. The ALGOL implementation of the procedure is illustrated in an Appendix.

Implementation of ALGOL 60 for the English Electric KDF9

Our decision to implement ALGOL 60 for the KDF9 was taken about 18 months ago. We saw in ALGOL 60 the possibility of its use as an automatic programming language for a wide range of users, particularly those who had become accustomed to working with earlier languages. On the one hand, ALGOL 60 was quite obviously much more powerful than any of the others, and on the other hand we wanted to make a contribution towards the effort to establish a language that could be universally understood and implemented. From the first our ambition was to implement the ALGOL 60 Report (Naur, ed., 1960) as fully as we possibly could. Experience in writing and using an optimizing compiler for DEUCE (Duncan and Hawkins, 1959; Duncan and Huxtable, 1960) led to the desire to combine full ALGOL translation with the generation of efficient (or relatively fast-operating) object programs. We realized, of course, that this would entail considerable original work, and planned to put about five man-years into the project.

An implementation of ALGOL 60 procedures

A method for implementing ALGOL 60 procedures which can handle all the basic features is described. The problems raised by the language: the independence of call and declaration, and the name concept, are first discussed. This is followed by a description of a machine representation and an associated administration.