ALGOL 68

ALGOL 68
source
Name	ALGOL 68
Paradigm	Multi-paradigm (procedural, imperative, structured)
Designer	IFIP Working Group 2.1
Latest release version	Revised Report
Latest release date	1973
Typing	Strong, static, manifest
Influenced	C, Ada, Python, Lua, Seed7

ALGOL 68. It is a high-level, algorithmic programming language developed as a sophisticated successor to ALGOL 60. Designed by the international IFIP Working Group 2.1, its ambitious goal was to provide a comprehensive, orthogonal language for systems and application programming. The language's formal definition, published in the 1968 ALGOL 68 Report and later revised, introduced novel concepts that significantly influenced subsequent language design.

History and development

The development of ALGOL 68 was initiated by the IFIP Working Group 2.1, a committee that included prominent computer scientists like Adriaan van Wijngaarden, John Backus, and Tony Hoare. The initial report was presented at the 1968 IFIP Congress in Edinburgh, following years of intense and sometimes contentious debate within the committee. A major revision, known as the "Revised Report," was published in 1973 to clarify the original specification. The language's development was contemporaneous with other significant projects like the Multics operating system and the rise of minicomputers, yet it maintained a distinct, theoretically rigorous path. Key contributors, including Charles H. Lindsey and Steve Bourne, later worked on implementations and elucidations of the complex standard.

Language design and features

ALGOL 68 was designed with a principle of orthogonality, aiming for a small set of independent constructs that could be combined flexibly. It introduced a novel two-level grammar, the van Wijngaarden grammar, for its formal definition. The type system was advanced, featuring structural typing, reference modes, and facilities for declaring new primitive types. It supported concurrency through parallel clauses and incorporated comprehensive facilities for arrays and structures. The language also mandated Transput, a unified model for input and output operations, treating them symmetrically. These features placed it in contrast with more pragmatic contemporaries like FORTRAN and the emerging C.

Examples and syntax

The syntax of ALGOL 68 is notable for its use of boldface or underlined keywords in its official reports, such as **if**, **then**, **fi**, and **proc**. A distinctive feature is the use of closing keywords that mirror the opener, like **if**...**fi** and **do**...**od**. A simple procedure to compute factorial might be declared as `proc factorial = (int n) int: (n = 0 | 1 | n * factorial(n-1));`. The language's **case** construct provided a powerful alternative to the **switch** statement found in C. Its expression-oriented design meant that almost every construct returned a value, influencing later languages like Python. The syntax for operators allowed for their overloading and the creation of new ones, a feature later seen in C++.

Implementations and variants

Due to its complexity, full implementations of ALGOL 68 were challenging. Early notable implementations included the ALGOL 68-R compiler for the ICL 1900 series, developed at the Royal Signals and Radar Establishment in the UK, and the ALGOL 68C compiler from the University of Cambridge. The Odra computers in Poland also featured an implementation. A significant subset, known as ALGOL 68S, was created for educational purposes. Other variants and partial implementations emerged, such as those for Burroughs large systems and the Soviet Union's ES EVM computers. The language's influence is evident in the design of Ada and the ABC language, a direct precursor to Python.

Influence and legacy

Despite limited commercial adoption, ALGOL 68's conceptual influence on programming language theory and design has been profound. Its emphasis on orthogonality and a clean, consistent design philosophy impacted the development of Ada, C (particularly in its type structure and operators), and Modula-2. The language's handling of slices and dynamic arrays prefigured features in modern languages like Python and Lua. Concepts from its formal definition, such as the use of a two-level grammar, contributed to research in compiler theory. The work of its designers, including Tony Hoare and Niklaus Wirth, continued to shape the field, with Wirth later creating Pascal and Modula-2 as reactions to ALGOL 68's complexity.

Category:ALGOL programming language family Category:Procedural programming languages Category:Structured programming languages Category:Programming languages created in 1968