The Rise of High-Level Languages: The First Wave

Zusammenfassung

Between 1954 and 1972, a generation of computer scientists fought — and won — the argument that computers should speak something closer to human language. The first wave of high-level languages was not just a technical achievement; it was a cultural battle against the entrenched belief that computers were mathematical engines that should be addressed in mathematical terms, and that the translation overhead of a compiler would always make high-level code too slow for serious use. FORTRAN, COBOL, ALGOL, LISP, and PL/I proved this wrong and established the conceptual foundations — compilers, type systems, structured control flow, formal syntax definition — on which all subsequent programming language development was built. For the full arc from machine code through modern languages, see The Evolution of Language.

The State of Programming Before 1954

In the late 1940s and early 1950s, programming meant writing machine code: sequences of binary digits that directly commanded the processor. Assembly language — using mnemonic names like ADD, MOV, and JMP instead of binary opcodes — was an improvement, but still required intimate knowledge of each machine’s specific instruction set, register names, and memory architecture. A program written for an IBM 701 was completely useless on a UNIVAC I; a programmer who knew one machine had to start over when their employer bought a different one.

The dominant attitude among hardware engineers — who were the senior figures in the field — was that this was correct and necessary. Computers were expensive instruments of precise calculation, and programming them required the same specialized understanding that programming any laboratory instrument required. The idea that a compiler could automatically translate human-readable descriptions into machine code was viewed with the same skepticism one might direct at a machine that claimed to do mathematics without understanding it.

FORTRAN: The Proof of Concept

John Backus at IBM proposed a project in 1953 to develop a “Formula Translation” system — a compiler that would convert algebraic-style expressions into IBM 704 machine code. His internal IBM proposal faced resistance from engineers who believed that machine-generated code could not match the efficiency of hand-optimized assembly. If FORTRAN-generated code ran slower than hand-coded assembly, scientists would not use it; they would not sacrifice computation time for convenience.

Backus made efficiency the central design constraint. The FORTRAN compiler, released in April 1957 after three years of development by a team of thirteen people, produced code that ran within 20% of hand-optimized assembly on most programs — close enough that scientists would accept the convenience tradeoff. The compiler included sophisticated optimization techniques (loop optimization, register allocation, common subexpression elimination) that were novel as automated processes. Several of these techniques were independent inventions within the project; the compiler team produced papers on compiler optimization that founded the field.

FORTRAN’s acceptance was rapid among scientists and engineers. IBM reported that within six months of release, FORTRAN was being used for more than half the computation time on IBM 704 installations. By 1960, FORTRAN was available on computers from a dozen manufacturers.

Backus-Naur Form: Language for Languages

FORTRAN’s specification described the language in English prose, which created ambiguity when different implementations made different choices. During the development of ALGOL 60, John Backus and Danish computer scientist Peter Naur independently developed a formal notation for describing programming language syntax: Backus-Naur Form (BNF), first used in the ALGOL 60 report (1960).

BNF uses production rules to define the valid sentences of a language: <expression> ::= <term> | <expression> + <term> | <expression> - <term>. A language’s grammar becomes a finite set of such rules, specifying every syntactically valid program. BNF allowed language definitions to be mathematically precise — a compiler implementor could read the BNF grammar and derive exactly what programs were syntactically valid, with no ambiguity.

This connection between formal grammar theory and programming language design — developed simultaneously by Noam Chomsky in linguistics (the Chomsky hierarchy of formal grammars, 1956) and by programming language researchers — established the theoretical foundation of language design. Every programming language specification written since uses a notation derived from BNF.

ALGOL’s Influence Without Commercial Success

ALGOL 60 was technically more sophisticated than FORTRAN: block structure, lexical scoping, recursive procedures, pass-by-name parameter passing, and a clean BNF-defined syntax. It was adopted immediately by European computer scientists and became the standard publication language for algorithms in the Communications of the ACM — algorithms published in ALGOL could be read, understood, and implemented by anyone. IBM declined to support ALGOL for the 704, protecting FORTRAN’s position. ALGOL never achieved commercial success in the United States, but its concepts directly shaped PASCAL, C, Ada, and effectively every imperative language that followed. Dijkstra described ALGOL 60 as “a language so far ahead of its time that it was not only an improvement on its predecessors but also on nearly all its successors.”

COBOL: Business English as Code

Grace Hopper’s FLOW-MATIC demonstrated that English-language commands could drive a computer. The question was whether a standardized business language could unite the incompatible programs written in vendor-specific dialects that were proliferating across government and private sector computing. The push began with Mary Hawes of Burroughs, who in early 1959 called for a common business language; that May the U.S. Department of Defense convened the CODASYL (Conference on Data Systems Languages) committee — its founding meeting chaired by the DoD’s Charles Phillips — to produce one.

The political dimensions of COBOL’s creation were as significant as the technical ones. Computer manufacturers were invested in their proprietary languages. IBM resisted sharing development work that could benefit competitors. The Department of Defense resolved the impasse by threatening to stop purchasing computers whose manufacturers did not support COBOL — a market lever of decisive force. IBM, UNIVAC, and Honeywell aligned.

COBOL’s designers, led by Jean Sammet among others and shaped substantially by Hopper’s earlier work, made deliberate choices that distinguish it from FORTRAN and ALGOL:

Verbosity by design: ADD SALARY TO TOTAL-PAYROLL rather than x := x + y. Business programs should be auditable by managers, not just programmers.
Separate DATA DIVISION: All variables declared with explicit types and formats, separate from procedural code — anticipating the concept of schema separate from logic.
Hardware independence: Explicitly designed to run on IBM, UNIVAC, Burroughs, and any future machine, with a standardization committee to maintain that portability.

COBOL was standardized by ANSI in 1968 — two years after FORTRAN had become the first ANSI-standardized programming language (X3.9-1966). It remained the dominant language for business data processing for three decades and by total lines of code in production is arguably still the most widely deployed language in the world.

LISP: Lists and Lambda

John McCarthy at MIT designed LISP (List Processing, 1958) from a different starting point: not to simplify scientific computation or business data processing, but to implement symbolic manipulation for artificial intelligence research. LISP’s data structure was the linked list; its computation model was the lambda calculus developed by Alonzo Church in the 1930s.

LISP introduced several concepts that would take decades to reach mainstream languages: dynamic typing (variables had no declared type; values did), garbage collection (automatic memory management rather than manual allocation), first-class functions (functions that could be passed as arguments, returned from other functions, and stored in data structures), and code-as-data (programs were represented as lists that the program could itself manipulate — the foundation of macros and metaprogramming).

LISP was used in AI research for forty years. Its commercial success was minimal outside specialized domains (expert systems in the 1980s; Emacs as a programmable text editor). Its conceptual influence is immeasurable: every functional programming language, and the functional features that entered Java, Python, JavaScript, and Rust in the 2000s and 2010s, derive from ideas McCarthy formalized in 1958.

The Compiler Skeptics Were Wrong

By 1965, the argument against high-level languages had been empirically defeated. FORTRAN compilers produced code that ran faster than most hand-coded assembly, because the compiler could perform optimizations (particularly loop transformations) that were tedious for humans but systematic for machines. The distinction between “programmer’s language” and “machine’s language” had been bridged by software, not hardware.

What replaced the first wave of skepticism was a second wave: the argument that programming languages were mature, that FORTRAN and COBOL were sufficient for the tasks at hand, and that designing new languages was academic indulgence. This argument was wrong in a different way. The proliferation of languages that followed — PL/I, Pascal, C, Smalltalk, Ada, ML, Prolog, and hundreds of others — was not indulgence but exploration. The first wave had proved that abstraction was possible. The subsequent waves explored what forms of abstraction were useful, safe, efficient, and appropriate for which tasks. That exploration has not concluded.