In the early 1950s, programming a scientific calculation often meant translating every formula into a long sequence of instructions specific to one computer. John Backus wanted to remove that mechanical work. The IBM team he led created FORTRAN, allowing scientists to write recognizable formulas and have them translated automatically.
The challenge was not merely to devise readable notation. Scientists knew how to optimize assembly code and distrusted a program that would write code for them. To win adoption, the FORTRAN compiler had to generate programs almost as fast as those produced by human experts.
Backus later pursued two further questions: how to describe a language’s syntax rigorously, and how to move beyond programming based on repeated changes to memory.
Why scientific programming remained expensive
John Warner Backus was born in Philadelphia in 1924. His education was uneven, and he found his direction only after military service. He first studied medicine, turned to mathematics, and earned a master’s degree from Columbia University in 1950.
That year he visited IBM and encountered the Selective Sequence Electronic Calculator. An improvised conversation led to a job. He soon worked on mathematical programs and Speedcoding, a system that simplified calculations on the IBM 701.
Speedcoding improved productivity but its interpretation slowed execution sharply. When computer time was scarce and costly, programmers still preferred machine code or assembly despite weeks of work and frequent errors. In 1953, Backus proposed a more ambitious system: users would write formulas close to mathematical notation, while a compiler generated efficient code for the forthcoming IBM 704.
FORTRAN was as much a compiler as a language
Backus assembled a team spanning mathematics, programming, and computer architecture. Its members included Harlan Herrick, Irving Ziller, Peter Sheridan, Roy Nutt, Robert Nelson, and Lois Haibt. No individual could alone design the language, optimize the compiler, and test every calculation.
FORTRAN stands for Formula Translation. It expressed arithmetic, loops, and branches without exposing IBM 704 operation codes. A statement described the desired calculation; the compiler selected machine instructions.
Translation still had to preserve performance. The team developed analysis and optimization techniques to organize calculations and register use. Building the compiler took years and produced an exceptionally large program for the period.
When FORTRAN shipped in 1957, its efficiency weakened the main argument for assembly. Scientists could focus on mathematical models rather than processor mechanics. Programs took less time to produce, while the language could gradually be adapted to other machines.
A collective success that changed software economics
Calling Backus FORTRAN’s sole creator would be misleading. He proposed and led the project and contributed to its design, but the language and compiler were collective IBM achievements.
His decisive role was to hold together two difficult goals: moving code closer to mathematics without sacrificing speed. Success proved that high-level languages could serve real computation rather than merely education.
FORTRAN spread through laboratories, industry, and universities. It also introduced a new possibility: scientific code could outlive the computer for which it was written. Later versions improved portability, structure, and domain coverage while preserving a vast heritage of numerical software. The history of FORTRAN follows that evolution; Backus’s biography explains the original effort to make automatic translation credible.
Describing the grammar of a language
After FORTRAN, Backus joined international discussions on ALGOL 58 and ALGOL 60. Designers needed an unambiguous description of which symbol sequences constituted valid programs.
Ordinary prose was insufficient. Backus proposed a formal notation in which syntactic categories were defined by replacement rules. Peter Naur adapted it for the ALGOL 60 report, and it became Backus–Naur form, or BNF.
A rule can state that an expression is a number or two expressions joined by an operator. Recursive application describes infinitely many programs with finitely many productions. BNF separates syntax—the permitted form—from implementation—the method used to analyze and execute it. Its descendants still document languages, data formats, and protocols.
Questioning the model he had helped popularize
FORTRAN greatly improved imperative programming: programs read and modify stored values one instruction at a time. Backus eventually believed this model remained too closely shaped by stored-program computers.
In his 1977 Turing Award lecture, Can Programming Be Liberated from the von Neumann Style?, he criticized the von Neumann bottleneck. Programs continually move values between processor and memory, while reasoning depends on a succession of state changes.
Backus presented FP, a system based on function composition. Rather than specifying every update, a program combined transformations. He hoped this would make computations easier to understand and reason about mathematically. FP did not replace imperative languages, but its intellectual importance is striking: a leader of their first great success also exposed their limits, alongside a functional tradition already visible in John McCarthy’s Lisp.
Composing programs instead of managing every state
Backus was not merely adding functions to an imperative language. FP combined functions through functional forms: composition, pairing, applying an operation to every element, and reducing a sequence to one value.
To compute the sum of squares, an imperative program creates a total, loops through a list, updates the total, and returns it. A compositional description maps squaring over the list and reduces the results with addition. It presents relationships between transformations instead of the detailed order of assignments.
Backus hoped algebraic laws could support reasoning: equivalent compositions could replace one another without tracing every intermediate state. This ambition anticipated modern optimization and parallelization of data pipelines, even though FP itself saw little adoption.
His criticism concerned the intellectual architecture of programs as much as processor-memory traffic. Raising the abstraction level required making transformations and their composition primary.
A legacy beyond FORTRAN
Backus received the Turing Award in 1977 for contributions to high-level languages, compilation, and language specification. He remained an IBM Fellow until retiring in 1991 and died in 2007.
His legacy connects three levels often studied separately. FORTRAN showed that abstraction could still produce efficient code. BNF precisely defined the form of a language. FP asked whether the dominant way of structuring programs was the best one.
Modern compilers extend the first challenge across richer languages. Formal grammars extend the second in parsers and standards. Functional programming extends the third by limiting state changes and composing transformations. Backus did not simply bring code closer to mathematics; he successively questioned how programs are translated, described, and structured.
Timeline
- 1924: John Warner Backus is born in Philadelphia.
- 1950: He earns a mathematics master’s at Columbia and joins IBM.
- Early 1950s: He develops Speedcoding for the IBM 701.
- 1953: He proposes formula translation for the IBM 704.
- 1954: The FORTRAN team is assembled.
- 1957: The first FORTRAN compiler is delivered.
- 1958–1960: He contributes to ALGOL and the notation that becomes BNF.
- 1963: He is named an IBM Fellow.
- 1977: He receives the Turing Award and lectures on the limits of von Neumann style.
- 1978: The lecture and FP system appear in Communications of the ACM.
- 1970s–1980s: He researches FP and functional programming.
- 1991: He retires from IBM.
- 2007: He dies in Ashland, Oregon.
- Today: FORTRAN, formal grammars, and functional composition continue three dimensions of his work.
Frequently asked questions
Did John Backus create FORTRAN alone?
No. He proposed and led the IBM project, but the language and compiler were a team achievement. Their combined expertise produced code efficient enough to persuade users.
Why was the first FORTRAN compiler so important?
A readable language would have failed if its programs were much slower than assembly. Compiler optimization showed that automatic translation could deliver both productivity and performance.
Did Backus invent BNF alone?
He proposed the initial notation for ALGOL; Peter Naur adapted it for the ALGOL 60 report. The name Backus–Naur form recognizes that sequence of contributions.
Is FORTRAN still used?
Yes. Modern versions remain active in scientific computing and software with large, proven numerical libraries. Today’s language differs greatly from its 1957 ancestor.
Why did Backus criticize imperative programming?
He thought programs centered on memory updates were difficult to compose and reason about. FP explored function composition instead of sequences of assignments.
What connects Backus and Grace Hopper?
Both teams sought to move programmers away from machine code in the 1950s. FORTRAN initially addressed scientific calculation; FLOW-MATIC and COBOL focused on business data.
