On April 15, 1957, a team at IBM led by John Backus released Fortran I for the IBM 704 computer. The product of nearly three years of intense development, Fortran (FORmula TRANslation) was the first commercially successful high-level programming language — and it changed software development permanently. Before Fortran, programming meant writing machine code or assembly language: cryptic sequences of numbers and mnemonics that mapped directly to hardware instructions. A simple mathematical formula like X = A + B * C might require a dozen assembly instructions, each one specific to the machine architecture. Fortran allowed scientists and engineers to write programs that looked like the mathematics they already knew, and a compiler translated those programs into efficient machine code automatically. IBM management was skeptical — they doubted a compiler could produce code anywhere near as efficient as hand-written assembly. Backus and his team proved them wrong. The Fortran I compiler generated code that ran within 20% of hand-optimized assembly on most benchmarks, and in some cases it produced faster code than human programmers wrote. This demolished the argument against high-level languages overnight. Within two years of its release, over half of all IBM 704 programs were written in Fortran. Nearly seven decades later, Fortran remains in active use for scientific computing, weather simulation, and computational physics — a testament to the soundness of Backus’s original design decisions.
Early Life and Path to Technology
John Warner Backus was born on December 3, 1924, in Philadelphia, Pennsylvania, to a wealthy family. His father was a chemist who became a senior executive at the Atlas Powder Company. Despite the comfortable upbringing, Backus was a self-described poor student who showed little academic motivation during his youth. He attended the Hill School, an elite prep school in Pottstown, Pennsylvania, and later enrolled at the University of Virginia in 1942 to study chemistry — primarily because his father had studied chemistry there.
Backus’s academic career was interrupted by World War II. He was drafted into the U.S. Army in 1943 and stationed at an antiaircraft installation in Fort Stewart, Georgia. An aptitude test revealed strong mathematical ability, and the Army sent him to the University of Pittsburgh to study engineering as part of a specialized training program. During this time, a medical exam discovered a cranial bone plate issue, and Backus underwent surgery at a hospital in Atlantic City. During his nine-month recovery, he became interested in electronics and began taking radio technician courses.
After the war, Backus enrolled at Columbia University, where he earned a B.S. in mathematics in 1949 and an M.S. in mathematics in 1950. It was at Columbia that he first encountered a computer — the IBM Selective Sequence Electronic Calculator (SSEC) at IBM’s headquarters on Madison Avenue. Backus was fascinated by the machine and, almost on a whim, mentioned his interest to a guide during a tour. IBM happened to be looking for programmers, and Backus was hired in 1950 as a programmer for the SSEC. He had found his calling entirely by accident.
The Breakthrough: Fortran
The Technical Innovation
By 1953, Backus had been at IBM for three years and was growing frustrated with the state of programming. Writing code for the IBM 701 and 704 computers meant working in assembly language, and the process was slow, error-prone, and tedious. He estimated that the cost of programming — not hardware — accounted for as much as 75% of the total cost of operating a computer. In late 1953, he wrote a proposal to his manager, Cuthbert Hurd, arguing that IBM should develop a system to automatically translate mathematical formulas into machine code.
IBM approved the project, and Backus assembled a team that would eventually grow to about ten people, including Sheldon Best, Harlan Herrick, Peter Sheridan, Roy Nutt, Robert Nelson, Irving Ziller, Richard Goldberg, Lois Haibt, and David Sayre. The team began work in early 1954 with a single clear goal: the compiled code had to be nearly as fast as hand-written assembly. Without this, programmers would reject the system — efficiency was everything on machines that cost millions of dollars to operate.
The Fortran I compiler took approximately 18 person-years to develop and contained about 25,000 lines of machine code. The compiler itself was a major achievement in optimization. It implemented loop analysis, register allocation, and code motion — techniques that are still the foundation of modern compiler optimization. The language syntax was designed to be immediately readable to scientists and engineers:
C FORTRAN I EXAMPLE — COMPUTING STANDARD DEVIATION (1957)
C THIS IS HOW SCIENTISTS COULD FINALLY TALK TO COMPUTERS
DIMENSION X(100)
READ 10, N, (X(I), I = 1, N)
10 FORMAT (I3 / (10F8.2))
C
C COMPUTE THE MEAN
SUM = 0.0
DO 20 I = 1, N
SUM = SUM + X(I)
20 CONTINUE
XMEAN = SUM / FLOAT(N)
C
C COMPUTE VARIANCE
SUMSQ = 0.0
DO 30 I = 1, N
SUMSQ = SUMSQ + (X(I) - XMEAN) ** 2
30 CONTINUE
VAR = SUMSQ / FLOAT(N - 1)
STDDEV = SQRT(VAR)
C
WRITE (6, 40) XMEAN, STDDEV
40 FORMAT ('MEAN = ', F10.4, ' STD DEV = ', F10.4)
STOP
ENDSeveral design decisions in Fortran I were groundbreaking. The DO loop introduced structured iteration to programming. The FORMAT statement provided a declarative way to specify input/output layouts. Array declarations with the DIMENSION statement allowed direct mathematical notation for vectors and matrices. The arithmetic IF statement (IF (X) 10, 20, 30) branched to one of three labels depending on whether the expression was negative, zero, or positive — directly mirroring mathematical case analysis.
The compiler’s optimization capabilities were its most important feature. Backus’s team developed algorithms for detecting and optimizing loops, eliminating common subexpressions, and allocating the IBM 704’s three index registers efficiently. The compiler analyzed the entire program’s flow graph — a technique that was itself a new invention. These optimizations meant that Fortran programs ran nearly as fast as hand-coded assembly, removing the primary objection to high-level languages.
Why It Mattered
The impact of Fortran was immediate and dramatic. Before Fortran, writing a program took weeks or months. With Fortran, the same computation could be coded in hours or days. IBM documented that Fortran reduced programming time by a factor of 5 to 10 on typical scientific computations. Within a year of release, most IBM 704 users had switched to Fortran. By 1960, IBM had released Fortran II (with subroutine support) and Fortran III, and competitors like Sperry Rand and Honeywell were developing their own Fortran compilers.
Fortran proved that high-level languages were viable. This was not just a technical achievement — it was a psychological one. Before Fortran, the conventional wisdom among programmers was that no compiler could match hand-tuned assembly. Backus showed that with sufficient engineering effort, a compiler could come close enough to eliminate the need for assembly in most cases. This opened the door for every high-level language that followed: Lisp (1958), COBOL (1959), ALGOL 60, Pascal (1970), C (1972), and eventually JavaScript, Python, and every modern language.
Beyond Fortran: Other Contributions
After the success of Fortran, Backus made contributions that were arguably even more important from a theoretical standpoint. In 1959, he developed the Backus-Naur Form (BNF), a formal notation for describing the syntax of programming languages. BNF was first used to define the syntax of ALGOL 60 and has since become the universal standard for specifying programming language grammars. Every language specification you read today — from TypeScript to Rust to Go — uses BNF or one of its derivatives (EBNF, ABNF) to define its syntax.
<!-- Backus-Naur Form (BNF) example — defining a simple expression grammar -->
<!-- This notation is now used universally in language specifications -->
<expression> ::= <term> | <expression> "+" <term> | <expression> "-" <term>
<term> ::= <factor> | <term> "*" <factor> | <term> "/" <factor>
<factor> ::= <number> | "(" <expression> ")" | <variable>
<number> ::= <digit> | <number> <digit>
<digit> ::= "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"
<variable> ::= <letter> | <variable> <letter> | <variable> <digit>In 1977, Backus delivered his Turing Award lecture, titled “Can Programming Be Liberated from the von Neumann Style?” This lecture was a remarkable self-critique. The man who had created Fortran — the quintessential von Neumann-style language, with its assignment statements, sequential execution, and mutable variables — argued that this entire programming model was fundamentally limited. He proposed functional programming (FP) as an alternative: a style where programs are built by composing functions without mutable state or assignment.
Backus’s FP system was a formal algebra of programs — a mathematical framework for reasoning about program composition and transformation. While FP itself did not gain wide adoption, the ideas Backus articulated in his lecture influenced the development of Haskell, ML, Erlang, and the functional features in languages like JavaScript (map, filter, reduce) and Python (list comprehensions, lambda expressions).
Philosophy and Engineering Approach
Key Principles
Backus was driven by a practical problem-solving instinct rather than abstract theory. His approach to Fortran was characteristically pragmatic: he started from the observation that programming was too expensive and worked backward to a solution. The emphasis on optimization — making compiled code competitive with hand-written assembly — was a strategic decision based on understanding his users. He knew that scientists and engineers would not adopt a high-level language unless it could match the performance they achieved manually.
This pragmatism was balanced by a growing appreciation for mathematical elegance. His career traced an arc from the intensely practical (Fortran) to the deeply theoretical (BNF, functional programming). In his Turing Award lecture, he explicitly criticized the ad hoc nature of conventional programming and called for a more mathematical approach. This evolution — from practitioner to theorist — is unusual in computer science, where most researchers move in the opposite direction.
Backus was also a champion of teamwork in an era that celebrated individual genius. He consistently credited the Fortran team and was known for creating an environment where talented engineers could do their best work. Lois Haibt, one of the few women on the team, later recalled that Backus was entirely unconcerned with credentials or background — he hired people who could solve problems, regardless of their degrees or demographics. The Fortran team included people with backgrounds ranging from mathematics to crystallography.
Throughout his career, Backus maintained that the primary role of a programming language was to help humans think, not to efficiently drive hardware. This belief, radical in the 1950s when hardware was enormously expensive, has become the dominant philosophy of modern software development — developer productivity now matters more than raw machine efficiency in most contexts.
Backus’s influence on IBM’s technical culture was substantial. The Fortran project demonstrated that a small, focused team could produce transformative technology — a model that IBM would replicate with later projects. The success of Fortran also established compiler development as a serious engineering discipline within IBM, leading to decades of compiler research at IBM’s Thomas J. Watson Research Center that produced advances in optimization, static analysis, and parallel compilation. The Fortran team’s original insight — that investing heavily in compiler optimization could make high-level languages practical — drove the entire compiler industry and remains the core business proposition of compiler vendors today.
The Fortran standardization process that followed the original release also set important precedents. Fortran 66 (1966) was one of the first programming languages to be formally standardized by ANSI. The process of creating a formal standard through committee negotiation — balancing backward compatibility with new features — became the model for standardizing C, C++, and later languages. The challenges of this process (competing vendor interests, backward compatibility constraints, committee design compromises) are still visible in modern language standardization efforts.
Legacy and Modern Relevance
Backus died on March 17, 2007, at the age of 82, in Ashland, Oregon. His legacy operates at multiple levels of modern computing. Fortran itself remains in active use — Fortran 2023 is the latest standard, and the language dominates high-performance computing (HPC). Climate models (like the Community Earth System Model), computational fluid dynamics simulations, quantum chemistry programs, and weather forecasting systems are largely written in Fortran. The language’s array operations, which Backus designed for mathematical computation in 1957, still provide performance characteristics that modern languages struggle to match for numerical workloads.
BNF remains the standard notation for defining programming language syntax. Every parser generator, from YACC (1975) to ANTLR (2013), uses BNF or its extensions. When you read a programming language specification, you are reading in a notation that Backus invented in 1959.
The compiler optimization techniques that Backus’s team pioneered — loop analysis, common subexpression elimination, register allocation, flow graph analysis — are the foundation of every modern compiler. GCC, LLVM/Clang, the V8 JavaScript engine, and every other optimizing compiler in existence builds on the techniques the Fortran I team invented. When your web application runs fast in a browser, it is partly because Backus’s team figured out how to optimize compiled code in 1957.
Backus’s Turing Award lecture on functional programming anticipated a movement that continues to grow. The rise of functional features in mainstream languages — arrow functions and promises in JavaScript, streams and lambdas in Java 8, pattern matching in C#, and the growing popularity of purely functional languages like Haskell and Elm — vindicates Backus’s 1977 argument that the von Neumann style has fundamental limitations.
He received the Turing Award in 1977, the National Medal of Science in 1975, the IEEE Computer Pioneer Award in 1980, and the Charles Stark Draper Prize in 1993 (shared with the Fortran team). He was elected to the National Academy of Sciences and the National Academy of Engineering. But his most lasting contribution may be the simplest one: he proved that humans should not have to think like machines. Machines should be taught to understand humans.
Key Facts
- Born: December 3, 1924, Philadelphia, Pennsylvania, USA
- Died: March 17, 2007, Ashland, Oregon, USA
- Known for: Creating Fortran (the first high-level programming language), inventing BNF notation, advocating functional programming
- Key projects: Fortran I (1957), Backus-Naur Form (1959), FP functional programming system (1977)
- Awards: Turing Award (1977), National Medal of Science (1975), Charles Stark Draper Prize (1993), IEEE Computer Pioneer Award (1980)
- Education: B.S. and M.S. in Mathematics from Columbia University (1949, 1950)
Frequently Asked Questions
Who is John Backus?
John Backus (1924–2007) was an American computer scientist who led the team at IBM that created Fortran, the first commercially successful high-level programming language, released in 1957. He also invented Backus-Naur Form (BNF), the standard notation for defining programming language syntax, and delivered an influential Turing Award lecture advocating functional programming as an alternative to the conventional von Neumann programming model.
What did John Backus create?
Backus led the creation of Fortran (1957), which demonstrated that high-level languages could produce code nearly as efficient as hand-written assembly. He invented BNF notation (1959), which became the universal standard for defining programming language grammars. He also developed the FP (Functional Programming) system, a formal mathematical framework for program composition that influenced the development of modern functional programming languages.
Why is John Backus important?
Backus is important because Fortran proved that programmers did not need to write machine code, opening the door for every high-level language that followed — from C to Python to JavaScript. His BNF notation is still used in every programming language specification written today. The compiler optimization techniques his team invented remain the foundation of modern compiler technology. His advocacy of functional programming in 1977 anticipated a major trend in language design that continues to shape how software is written decades later.
