John Backus

John Backus
Institutions	IBM
Fields	Computer science; Programming language theory
Occupation	Computer scientist
Awards	ACM Turing Award (1977)
Known for	FORTRAN; Backus–Naur Form (BNF)
Wikidata	Q92746

John Warner Backus (1924–2007) was a pioneering American computer scientist and mathematician who transformed programming in the mid-20th century. He led the team at IBM that created FORTRAN (Formula Translator), the first widely used high-level programming language, opening the door to modern software development. Backus also developed the Backus–Naur Form (BNF) for formally describing the syntax of programming languages. Over a 41-year IBM career, he introduced innovations like automatic compilers and the concept of functional programming. His work earned him the ACM Turing Award in 1977 and many other honors. Backus’s contributions—from simplifying complex machine instructions to shaping language theory—remain fundamental in computing.

Early life and education

John Backus was born in 1924 in Philadelphia, Pennsylvania, and grew up in an affluent family in Wilmington, Delaware. As a youth he was mischievous and unoriented academically, often finding schoolwork tedious. He attended the Hill School, a private boarding school, but graduated in 1942 with poor grades. He briefly enrolled at the University of Virginia to study chemistry but was expelled for missing classes. Drafted into the U.S. Army during World War II, Backus initially trained in engineering and medicine but discovered a knack for mathematics and electronics.

After the war, Backus turned his focus to higher education in mathematics. He entered Columbia University in New York City, where he earned a bachelor’s degree in mathematics in 1949 and a master’s in 1950. It was at Columbia that he developed his skill in abstract thinking and problem-solving. Upon finishing his master’s degree, Backus took a chance by visiting IBM’s headquarters on Madison Avenue. After impressing IBM staff with his mathematical aptitude, he was hired on the spot in 1950 as a junior programmer, even though he had no formal training in computing. This fortuitous meeting marked the start of his influential career at IBM.

Major works and ideas

At IBM in the 1950s, Backus tackled the difficulties of programming early computers. These machines required painstakingly detailed instructions written in binary (machine code), which was slow and error-prone. To simplify tasks, Backus created Speedcoding in 1952 for the IBM Selective Sequence Electronic Calculator (SSEC). Speedcoding was an early translator program that let users perform arithmetic operations more easily by hand, reducing tedious calculations. It introduced concepts like automatic decimal scaling, making it a precursor to modern programming systems.

Backus is best known for leading the design and development of FORTRAN. In 1953 he proposed creating a translator for IBM’s new 704 scientific computer. He assembled a diverse team of mathematicians and engineers (including the future mathematician Lois Haibt) to design a more natural programming language for scientific computing. FORTRAN (short for Formula Translator) was intended to allow programmers to write arithmetic formulas and loops using familiar algebraic notation rather than coding each machine operation. The team worked out the language’s structure and built a compiler – a program that automatically translates high-level instructions into machine code. In 1954 they published the Preliminary Report of the IBM Mathematical FORmula TRANslating System describing FORTRAN’s design. After two years of development, IBM released the first FORTRAN compiler in 1957.

FORTRAN revolutionized programming for engineers and scientists. Tasks that once required thousands of machine instructions could be expressed in just a few lines of FORTRAN code. For example, a complex trajectory calculation that might have taken a programmer a week to hand-code could now be written and compiled quickly. FORTRAN made computers practical for heavy numerical work (such as physics simulations, missile calculations, and weather forecasting) by raising the programming level. Because it worked well, FORTRAN rapidly became the dominant language for scientific computing. It also set the pattern for subsequent high-level languages (like COBOL and ALGOL) and showed that compilers could translate intuitive code into efficient machine instructions.

In 1959 Backus introduced Backus–Naur Form (BNF), a notation for formally specifying the grammar or syntax of programming languages. In simple terms, BNF uses rules written in a logical, mathematical style to describe how correct programs can be formed. For example, one rule might say that an expression can be a number or an expression plus another expression. By chaining such rules together, BNF precisely defines what counts as a valid statement in a language. BNF became a standard tool in programming language theory: it was used in the official report on the ALGOL 60 language and later in the descriptions of languages like Pascal, C, and Java. The notation’s rigor helped language designers avoid ambiguity and ensured that compilers agreed on language rules. Today, variants of BNF are still used in language manuals and compiler construction, giving Backus’s name lasting recognition.

In the 1970s Backus turned toward functional programming, a different paradigm from the traditional imperative style. The conventional “von Neumann” model of programming (named after the computer architecture at the time) relies on step-by-step instructions and changing the machine’s memory state. Backus argued that this word-at-a-time, sequential style created inefficient and error-prone programs. In his notable 1977 Turing Award lecture “Can Programming Be Liberated from the Von Neumann Style?”, he proposed a more mathematical, expression-based style. In this approach, programs are built by composing functions (like formulas) rather than issuing commands. He developed a language called FP (for Functional Programming) to experiment with these ideas. Although FP itself did not become widely used, the concepts Backus championed—such as using algebraic functions, avoiding unnecessary loops, and treating programs as mathematical objects—have influenced later languages like Haskell, and even features in mainstream languages (for example, functions as first-class values, map/reduce operations, and other high-level constructs in Python, Java, and C++). Backus believed expressing solutions at a high level of abstraction would let compilers automatically generate more efficient code.

Besides these headline projects, Backus contributed to the development of early programming languages and computers. He worked on the specifications for ALGOL, a language from the late 1950s that was highly influential in Europe and eventually worldwide. As part of international committees, Backus helped shape ALGOL 58 and 60, which introduced block structure and formal syntax rules into language design. ALGOL’s influence moves forward--its block structure and language description techniques are seen in almost every later language. Backus also helped refine the design of the IBM 704 hardware itself, ensuring it supported mathematical calculations well (for example, the 704 provided floating-point arithmetic in hardware, which FORTRAN could use). Throughout his career, Backus kept searching for better ways to let programmers express ideas without drowning in machine details.

Method

Backus approached programming as a problem of human communication. He saw early programming tasks as monotonous and error-prone, and he prioritized abstraction and automation to ease the burden on programmers. He famously remarked that much of his motivation came from “being lazy”: he disliked performing tedious low-level coding, so he set out to build tools and systems to do the work instead. This practical attitude led him to develop compilers and notation that handled routine tasks automatically.

He also believed strongly in trial and error as a method of research. In leading the FORTRAN project, Backus built a loosely organized team of talented individuals (from chess champions to cryptographers) and allowed creative freedom. He downplayed strict management processes, once famously ignoring IBM’s rigid annual review system for his team. He encouraged experimentation, accepting that many ideas would fail before finding a good solution. As Backus later said, successful design often means generating many ideas, rejecting the ones that don’t work, and persevering until a good one surfaces.

Backus’s technical method was to break problems into smaller parts and then recombine them. When developing FORTRAN, for example, his team first defined the simplest expressions (like addition, multiplication, and loops) and then figured out how to parse and compile those expressions into machine instructions. Writing the “compiler” (the translating program) was a major part of the work, since no such tool had existed before at that scale. The FORTRAN compiler itself was a marvel: it used techniques like optimization to produce efficient code that in many cases ran nearly as fast as handwritten assembly code.

In devising notation like BNF, Backus applied formal, mathematical thinking. He treated a programming language like a logical system, writing down rules that described valid sentences (programs) in that system. This mix of practical coding and abstract formalism was characteristic. Even in advocating functional programming, his style was theoretical: he liked to express the algebraic properties of programs and how they could compose. Backus’s blend of engineering pragmatism (speed, efficiency, usability) with theoretical clarity (formal definitions, proofs of correctness) made his work both useful and enduring in computer science.

Influence

John Backus’s influence on computing was profound. FORTRAN alone changed how the world used computers: before FORTRAN, only a small class of “computer nannies” who understood machine code could use a computer. After FORTRAN, scientists, engineers, and researchers began programming without needing to memorize hardware details. This shift dramatically accelerated scientific computation. In fact, FORTRAN remains in use today in fields like numerical weather prediction, computational physics, and climate modeling, where decades of legacy code and libraries continue to solve large-scale problems.

Beyond FORTRAN’s immediate success, Backus helped establish the high-level programming language as a central idea in software development. A high-level language uses human-readable notation—such as words, algebraic symbols, or phrases—to describe computations, rather than requiring direct binary or assembly instructions. The success of FORTRAN led directly to the creation of other high-level languages (COBOL, for business; LISP, for AI; ALGOL, for algorithms; and later languages like Pascal, C, and Java). By proving that compilers could efficiently handle high-level syntax, Backus set a standard that no serious programming language development has since moved away from.

His notation for grammars—Backus–Naur Form—became a staple in programming language theory and compiler design. Nearly every modern programming language uses some variant of this idea to define its grammar. For example, when a new language specification is written, its syntax (like statement structure, loops, function calls) is often described in a formal grammar whose style descends from BNF. This ensures that different compiler writers implement languages consistently and that programmers understand the exact rules of a language. In effect, BNF and its descendants gave a precise mathematical foundation to what had previously been informal language descriptions.

Backus’s later work on functional programming also had a lasting influence on language design. The notion that programs could be composed of pure functions without side-effects (changing memory) was not mainstream when he proposed it, but it became central in the rise of purely functional languages (like Haskell and ML) in the 1980s and beyond. Moreover, many mainstream languages now adopt functional features (such as anonymous functions, first-class functions, map-reduce operations, and immutable data types) to allow programmers to write cleaner, more abstract code. Backus introduced the key ideas that laid the groundwork for this trend.

He influenced generations of computer scientists through his writings and lectures. His 1977 Turing Award lecture (published in the Communications of the ACM) is still cited in programming language research. His insistence on formal descriptions helped spawn the field of “formal methods” for software, where rigorous mathematical techniques are used to prove properties of programs. Alan Turing Award-winning colleagues and later language designers often acknowledged Backus’s role in creating the conditions for the software revolution.

Backus also influenced computer science culture. At IBM he mentored younger researchers and championed innovation. His quote about laziness as a motivator and his emphasis on practicality inspired others to seek simpler, more efficient solutions. After retirement he continued to speak at conferences, sharing anecdotes about early computing. Institutions such as the Computer History Museum recognize him as a founding father of software design.

Critiques

While John Backus’s achievements are celebrated, some of his ideas were controversial or met with skepticism. One area of debate was Backus’s strong criticism of conventional programming at the time. In his 1977 lecture, he complained about the “von Neumann style” of programming (the dominant sequential, imperative style) and promoted functional programming instead. Some contemporaries felt that Backus painted with too broad a brush. Many scientists and engineers argued that imperative languages were practical for certain problems and that abandoning them was not realistic. The computer scientist Edsger Dijkstra, for example, agreed that improving programming style was important but did not endorse abandoning the von Neumann model altogether. In hindsight, the field took a middle path: functional programming ideas were incorporated alongside imperative ones, rather than replacing them wholesale. Thus, while Backus’s critique sparked valuable discussion, it was not fully heeded at the time, and some viewed it as overly pessimistic about existing platforms.

Another critique involves FORTRAN itself. Early compilers for FORTRAN were impressive, but the language had limitations. FORTRAN initially lacked some programming constructs (it had few data types and only a numeric focus), and it encouraged using GOTO statements liberally. In later years, many programmers blamed FORTRAN-style languages for programs with tangled jumps and hard-to-manage flow. (The famous 1968 Dijkstra letter “GOTO considered harmful” cited the structured programming revolution that partially stemmed from lessons learned with FORTRAN and its successors.) Backus did not promote unstructured coding, but FORTRAN’s popularity nonetheless led to codebases that were sometimes criticized for being unreadable without discipline. Over time, FORTRAN evolved (later standards added features like IF/THEN/ELSE, recursive functions, and array operations), and much of the criticism faded, but its early reputation was mixed.

Backus–Naur Form has also seen commentary. BNF is extremely powerful for context-free rules, but natural programming languages often have context-sensitive aspects (for example, type rules or declarations that affect parsing). In practice, BNF needed extensions (like context rules or semantic actions) to handle full language definitions. Some critics note that BNF tells you how code is structured, but not how it behaves (its semantics). Nevertheless, this critique is more a limitation of any syntax notation, not a personal failing of Backus — even so, it’s worth noting that BNF had to be supplemented by other specifications.

In the realm of functional programming, Backus’s FP language and concepts were ahead of their time. While his critique of imperative programming was influential, some felt that Backus’s advocacy of pure functional programming underestimated practical needs for efficiency and control. Tests showed that functional-style programs could be elegant but not always the fastest on hardware of the day. For a time, functional ideas were viewed as academically interesting but not ready for mainstream use. Only decades later, as hardware became faster and new compiler techniques emerged, did functional languages begin to thrive in earnest. Backus was sometimes regarded as being “on the wrong track” during that interim period, though his core insights have since been validated as powerful programming techniques.

Despite these debates, no one seriously disputes Backus’s central achievements. Even critics of his views acknowledge that FORTRAN changed computing and that BNF is an indispensable tool. The critiques mostly addressed downstream effects and the evolution of his ideas, not his technical brilliance. In general, Backus’s work catalyzed improvements in how computer science approached language design and software development, even if some adjustments were made along the way.

Legacy

John Backus’s legacy is built into the foundations of modern computing. Above all, he made computers vastly more usable. By raising the programming level from binary instructions to symbolic formulas and by formally defining language grammar, he aligned computer tools with how humans think. In doing so, Backus helped trigger the software revolution: tasks that once required specialized low-level expertise became accessible to scientists, engineers, and later programmers of all backgrounds.

His name lives on in several key ways. Fortran (renamed “FORTRAN” in later years) is one enduring artifact. Although no longer front-page news, Fortran continues to be used in high-performance scientific and engineering applications worldwide. Code written in Fortran runs on supercomputers simulating weather patterns, designing cars, modeling financial markets, and even in some space missions. This longevity – over six decades – is a testament to the solid principles Backus’s team established.

Backus–Naur Form is another lasting contribution. The acronym BNF is ubiquitous in textbooks and technical documents about programming languages. Whenever a new language is standardized or a data format is specified, a derivative of BNF is almost always used to describe its syntax. Thus, Backus’s influence goes on every time a new compiler or interpreter is built: implementers use tools founded on his notation to parse code.

His emphasis on formal methods and theoretical rigor in software inspired generations of computer scientists. Backus helped seed the view that programming could be as much a scientific discipline as engineering – requiring proofs, formal specifications, and correctness arguments. This perspective led to fields like type theory, compiler theory, and even formal verification of programs. Students still learn about context-free grammars, syntax trees, and compiler construction because of ideas Backus introduced.

Backus earned the highest honors in computer science, which underscore how respected he was by his peers. In 1977, he received the ACM A.M. Turing Award (often called the “Nobel Prize of computing”) for “profound, influential, and lasting contributions to the design of practical high-level programming systems” and for formal language specification. In 1975 he was awarded the U.S. National Medal of Science, making him an early medalist in computer science. The Charles Stark Draper Prize (the top engineering prize in the U.S.) came in 1993, honoring the development of high-level programming languages. He was elected to the National Academy of Engineering and the American Philosophical Society. In 1997, the Computer History Museum named him a Fellow. Even an asteroid, “6830 Johnbackus”, was named in his honor in 2007. These recognitions reflect not just achievement in a single project, but a lifetime of impact.

After retirement, Backus remained a revered senior statesman in computer science. Colleagues recall his generous support for younger researchers and his humility (“I didn’t invent mathematics,” he once said, noting he applied math rather than claimed credit for it). His lecture anecdotes and archival interviews were popular for insights into early computing. Academic competitors and collaborators alike show deference when speaking of Backus, often citing his pioneering role.

In technology history, Backus is remembered as one of the first “software heroes.” Museums of computing often feature FORTRAN as a milestone exhibit, and films or articles on computer history invariably mention Backus’s name. Even outside computing, think of how we send papers to journals: we describe algorithms in something like FORTRAN or pseudocode. This traces back to Backus’s philosophy that the focus should be on the idea, not on punching bits.

His vision continues as software grows ever more complex: modern languages and tools still strive to let programmers work at a high level. Ideas of “declarative programming” (describe what rather than how) in databases and configuration languages echo Backus’s functional push. When computer scientists teach language theory, they still invoke Backus–Naur Form. His emphasis on failure and iteration (he said trial and error was key to finding solutions) is now a mantra in tech development (“fail fast, iterate often”).

In short, John Backus laid brick and mortar for the street we now walk on in programming. Without his work, programming might still be a game of painstaking detail. Instead, his liberating approach set in motion the abstraction layers and formal foundations that define modern computing. He is rightly honored as a father of Fortran, a founder of formal language theory, and one of the builders of the software age.

Selected works

Preliminary Report: Specifications for the IBM Mathematical FORmula TRANslating System (FORTRAN) (April 1954). A seminal internal IBM report by Backus and his team, outlining the design of FORTRAN and showing how algebraic formulas would be parsed by the computer.
IBM 704 Programming Manuals (1957–1958). Manuals and documentation for the IBM 704 computer that included the FORTRAN compiler reference and tutorials (written under Backus’s leadership). These first editions helped spread FORTRAN globally.
Report on the Algorithmic Language ALGOL 60 (1960). Backus was a primary contributor to this international committee report, which formally defined the ALGOL 60 language using BNF notation. It served as a model for programming language definitions.
“The Syntax and Semantics of the Proposed International Algol 68 Language” (1964, with P. Naur). A follow-up report that further developed BNF-like descriptions (Backus–Naur Form) for the successor to ALGOL 60.
John Backus, “Can Programming Be Liberated from the Von Neumann Style? A Functional Style and its Algebra of Programs,” Communications of the ACM (Vol.21 No.8, August 1978). The published version of his influential Turing Award lecture, proposing functional programming principles and the FP language.
IBM Systems Journal articles (1977–1979). Backus authored papers outlining the FP language and functional programming algebra, formalizing his ideas for programming theory, such as “Programming in the Function-Level Language FP” (1979).

Timeline

1924 – Born December 3 in Philadelphia, Pennsylvania.
1942–1946 – Attends Hill School; joins U.S. Army during WWII (studies pre-med, then electronics).
1949 – B.S. in Mathematics from Columbia University.
1950 – M.S. in Mathematics from Columbia; joins IBM in New York as a programmer.
1952 – Creates Speedcoding (an early assembly translator) for the IBM SSEC.
1953–1957 – Leads development of FORTRAN; publishes the FORTRAN design report (1954); first FORTRAN compiler released (1957).
1959 – Introduces Backus–Naur Form (a formal grammar notation) to describe language syntax.
1960 – Contributes to ALGOL 60 report (widely using BNF); becomes IBM Fellow (1963).
1975 – Awarded the U.S. National Medal of Science.
1977 – Receives ACM A.M. Turing Award; delivers famous lecture on functional programming.
1991 – Retires from IBM as IBM Fellow.
1993 – Wins Charles Stark Draper Prize from the National Academy of Engineering.
1997 – Named a Computer History Museum Fellow.
2007 – Passes away March 17 in Ashland, Oregon; Asteroid “6830 Johnbackus” named in his honor.