ALGOL Compiler Research Articles

Embracing the Algol Effort in Czechoslovakia

In the 1950s, Czechoslovakian computing was more famous for its fault-tolerant computers, SAPO and EPOS, than for developments in automatic programming. However, the Algol effort did not go unnoticed there. It was quite the contrary, even though its appeal to Czechoslovakian computer programmers only became manifest in their work after the publication of the preliminary report on the algorithmic language in 1958. The publication of the full Algol 60 report was well noted and the "Algol craze" spread quickly in Czechoslovakia. This article traces the history of programming methods and techniques in Czechoslovakia until the first Czechoslovakian Algol compiler in the early 1960s.

De AERA. Gedroomde machines en de praktijk van het rekenwerk aan het Mathematisch Centrum te Amsterdam

AERA. Dream machines and computing practices at the Mathematical Center Dream machines may be just as effective as the ones materialised. Their symbolic thrust can be quite powerful. The Amsterdam ‘Mathematisch Centrum’ (Mathematical Center), founded February 11, 1946, created a Computing Department in an effort to realise its goal of serving society. When Aad van Wijngaarden was appointed as head of the Computing Department, however, he claimed space for scientific research and computer construction, next to computing as a service. Still, the computing service following the five stage style of Hartree’s numerical analysis remained a dominant chara c ter istic of the work of the Computing Department. The high level of ambition held by Aad van Wijngaarden lead to ever renewed projections of big automatic computers, symbolised by the never-built AERA. Even a machine that was actually constructed, the ARRA which followed A.D. Booth’s design of the ARC, never made it into real operation. It did serve Van Wijngaarden to bluff his way into the computer age by midsummer 1952. Not until January 1954 did the computing department have a working stored program computer, which for reasons of policy went under the same name: ARRA. After just one other machine, the ARMAC, had been produced, a separate company, Electrologica, was set up for the manufacture of computers, which produced the rather successful X1 computer. The combination of ambition and absence of a working machine lead to a high level of work on programming, way beyond the usual ideas of libraries of subroutines. Edsger W. Dijkstra in particular led the way to an emphasis on the duties of the programmer within the pattern of numerical analysis. Programs generating programs, known elsewhere as autocoding systems , were at the ‘Mathematisch Centrum’ called ‘superprograms’. Practical examples were usually called a ‘complex’, in Dutch, where in English one might say ‘system’. Historically, this is where software begins. Dekker’s matrix complex, Dijk stra’s interrupt system, Dijkstra and Zonneveld’s ALGOL compiler – which for housekeeping contained ‘the complex’ – were actual examples of such super programs. In 1960 this compiler gave the Mathematical Center a leading edge in the early development of software.

The ilem project: Pascal to algol in easy stages. I: Outward bound

AbstractMost academic institutions have Pascal compilers coming out of their ears. Most academic institutions have Algol compilers only on their dinosaur mainframes. The Ilem project consists of designing a sequence of intermediate languages, IL0, IL1, IL2, …, ILN–1, ILN, where IL0 is Pascal and ILN is Algol, and where any two consecutive languages differ so little that a one‐man spare‐time project suffices to convert a compiler for one language into a compiler for the next.

Debugging computer programs. A survey with special emphasis on ALGOL : R. S. Scowen. National Physical Laboratory, Teddington, Middlesex, U.K. NPL-REP-NAC-21. June (1972)

Abstract : This report considers the problems of debugging computer programs and some of the tools which can simplify the task. The main sections describe: (1) ways in which compilers can aid the debugging of programs, (2) ALGOL programs which can be used to determine the kinds of errors detected by an ALGOL compiler, (3) results of running the test programs on sixteen different compilers, (4) results obtained from a survey of the errors made by programmers at NPL.

Optimization of error recovery in syntax-directed Parsing algorithms

The syntactic error recovery of automatically generated recognizers is considered with two related systems for automatically generating syntactic error recovery presented, one for a Floyd production language recognizer, the other for a recursive descent recognizer. The two systems have been implemented for a small language consisting of a subset of ALGOL. When compared with each other and with a commercial ALGOL compiler, the results indicate that automatically generated syntactic error recovery can exceed the performance of reasonable hand-coded error recovery.

Decision tables in Algol 60

This paper defines an extension to Algol 60, which allows the programmer to write decision tables in his Algol program. A pre-processor converts the decision tables to Algol, and its output is used as input to the ordinary Algol compiler. The generated Algol program uses a straight-forward and efficient algorithm for choosing the appropriate decision rule.

CHAMP—character manipulation procedures

A new programming language facility for symbol manipulation is described. String procedures may be declared and called in a standard ALGOL context. ALGOL procedures can in turn be called by string procedures so that numeric and symbolic processes may conveniently be programmed together. Concatenation and a variant of SNOBOL's pattern matching make up a set of primitive commands. These are assembled together into conditional expressions which are to be used to provide alternative computational patterns. Arrays of strings are processed using quantifiers. The class of things which may be assigned to an identifier can be restricted by a procedure expressed in the notation. The language facilities have been implemented in the ALGOL compiler for the Burroughs B5500.

The Atlas ALGOL Preprocessor for Non-Standard Dialects

This paper describes the preprocessor written to replace the original input routine of the Atlas ALGOL compiler. The main purpose of this preprocessor is to allow programs punched in a wide range of conventions and codes to be run, without change, on Atlas.

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.

Generation of machine code in ALGOL compilers

The paper describes the method used in the GIER ALGOL compiler for generating machine code from an error free Reverse Polish representation of the source code. The basic method is a pseudo evaluation of the expressions in the text. This imitates the run time processes but works with descriptions of how and where the operands are stored instead of with their values. The flow of control of the process is governed by the operators via a table which for each operator holds one or more pseudo instructions. These are obeyed interpretatively by the central logic of the process.

The performance of a system for automatic segmentation of programs within an ALGOL compiler (GIER ALGOL)

The performance of a system for automatic segmentation of programs within an ALGOL compiler (GIER ALGOL)

Checking of operand types in algol compilers

The paper describes the method used in the GIER ALGOL compiler for checking the source program for the compatibility of the kinds and types of identifiers and constants as given in declarations with the use of these entities as operands in the statements and expressions of the program. The basic method is a pseudoevaluation of the expressions of the program. This proceeds like a run-time evaluation, but works with descriptions of the types and kinds of the operands instead of with values. Several examples of the use of this method are given. A general way of achieving suppression of redundant error messages while still retaining the power to continue the checking process when an error has been detected is also described. Further, a classification of the operands of ALGOL 60 for use in the process is given. The paper ends with a sample error report produced by the GIER ALGOL compiler, illustrating the power of the method.

Some techniques used in the ALCOR ILLINOIS 7090

An ALGOL compiler has been written by the ALCOR group for the IBM 7090. Some little known but significant techniques in compiler writing, together with organizational details of this compiler, are described. Timing estimates and an indication of compiler requirements are also given.

The structure of yet another ALGOL compiler

A high-speed “top down” method of syntax analysis which completely eliminates “back-up” of the source string has been implemented in a convenient macro-language. A technique of simulation at compile time of the use of a conventional run-time stack enables the generation of code for expressions which minimizes stores, fetches and stack-pointer motion at run time, while properly treating recursion and side effects of procedures. Block structure and recursion are handled without need for interpretive methods at run time. The “context problem” in the transmission to recursive procedures of parameters “called by name” is solved in a manner which permits the handling of the common cases of simple expressions and array identifiers with particular efficiency.

Automatic grading of students' ALGOL programming

The report describes an experiment on automatic grading of student algorithms, using an ALGOL compiler. The experiment is based on an evaluation of the efficiency and logical completeness of the algorithms, not on their formal correctness, which is supposed to be checked in advance by the individual student. The technique used is to embed the student algorithms within a larger grading program structure, which supplies test cases and performs checks and evaluation. The complete text of such a grading program is given. The experience gained through the experiment, and suggestions for further developments, are discussed.

A proposal for input-output conventions in ALGOL 60

The ALGOL 60 language as first defined made no explicit reference to input and output processes. Such processes appeared to be quite dependent on the computer used, and so it was difficult to obtain agreement on those matters. As time has passed, a great many ALGOL compilers have come into use, and each compiler has incorporated some input-output facilities. Experience has shown that such facilities can be introduced in a manner which is compatible and consistent with the ALGOL language, and which (more importantly) is almost completely machine-independent. However, the existing implementations have taken many different approaches to the subject, and this has hampered the interchange of programs between installations. The ACM ALGOL committee has carefully studied the various proposals in an attempt to define a set of conventions for doing input and output which would be suitable for use on most computers. The present report constitutes the recommendations of that committee.

Note on an ALGOL 60 Compiler for Pegasus I

This note gives a brief description of an ALGOL 60 compiler which implements most of ALGOL 60 including recursive facilities. Comparison is made with the Pegasus Autocode, and the effort involved and reasons for writing are given.

Design of a separable transition-diagram compiler

A COBOL compiler design is presented which is compact enough to permit rapid, one-pass compilation of a large subset of COBOL on a moderately large computer. Versions of the same compiler for smaller machines require only two working tapes plus a compiler tape. The methods given are largely applicable to the construction of ALGOL compilers.

The design of the GIER ALGOL compiler Part I

The report gives a full description of the design of an ALGOL 60 system for the GIER, a machine having 1024 words of cores and 12800 words on drum. An introductory section gives the historical perspective of the design and the principal characteristics of the machine. The second section discusses the problems of the running ALGOL program: storage allocation and addressing of variables, program references, procedure calls, and the automatic administration of transfers of program segments from the drum to the core store. The second part of the report will describe the translator, and the performance of the system.