John Backus

Developer of the Fortran programming language

• Born: December 3, 1924
• Birthplace: Philadelphia, Pennsylvania
• Died: March 17, 2007
• Place of death: Ashland, Oregon

Primary Company/Organization: IBM

Introduction

John Backus's work at IBM revolutionized computer programming. In the 1950s, he assembled and led the team that developed Fortran, the first high-level programming language, one rigorous enough to remain in use today. In the course of doing so, he also introduced the first optimizing compiler, in order to encourage Fortran's adoption. Later in the same decade he introduced the Backus-Naur Form (BNF), a notation technique for context-free grammar, a metalinguistic approach to describing languages. Such notation techniques—of which BNF remains one of the two standards—make it easier to discuss and describe programming languages. Backus used it in developing programming languages in the ALGOL family, but he continued to look for better ways to program. His function-level programming language, FP, never caught on, but his introduction of it did raise interest in functional programming as a general area of research.

Early Life

John Warner Backus was born on December 3, 1924, in Philadelphia, Pennsylvania. A poor student from a wealthy family, he graduated from the Hill School, a boarding school in Pottstown (northwest of Philadelphia), in 1942 but was expelled from the University of Virginia before finishing his freshman year. His expulsion left him vulnerable to the draft, and he entered the U.S. Army, where he served at Fort Stewart, Georgia. His poor academic performance may have been due to apathy or inattention, because his military aptitude tests were strong, and while still in the Army he sampled several academic programs in rapid succession: engineering at the University of Pittsburgh, premedical courses at Haverford, and the Flower and Fifth Avenue Medical School in New York City. He dropped out of medical school for lack of interest but designed his own metal plate to replace a cranial bone tumor in his skull.

In 1946, he was discharged honorably from the Army and remained in New York City, working as a radio technician long enough to develop an interest in mathematics. Finally he found a program he could stick with: mathematics at Columbia University, from which he graduated in 1949. Shortly before his graduation, while touring the Selective Sequence Electronic Calculator (SSEC) at IBM's Computing Center, he mentioned an interest in the SSEC to his tour guide and was soon hired as a programmer.

Life's Work

The SSEC operated from 1948 to 1952 and had been constructed when IBM was dissatisfied with the lack of credit it received for its involvement in the construction of the Harvard Mark I (a computer at Harvard University formally known as the Automatic Sequence Controlled Calculator). The construction in 1946 of the Electronic Numerical Integrator and Computer (ENIAC), a fully electronic computer, further motivated IBM to make its mark. The SSEC was deliberately installed on a ground-floor room with a large display window, formerly occupied by a shoe store, so that pedestrians could get a good look at it. The computer used both electromechanical relays and more than twelve thousand vacuum tubes to perform its operations. Its first application was a program called Ephemeris, which in seven minutes could calculate the position of Earth's moon and the planets. This helped to demonstrate the SSEC's computing power; paying customers such as General Electric and the Atomic Energy Commission followed.

Backus worked on the SSEC for three years, developing techniques that were later adopted for use in the National Aeronautics and Space Administration's Apollo program. However, from the start, Backus's real contribution was his approach to the art of programming itself, not just its end products. Programming at the time was done in assembly language, a low-level programming language with a one-to-one correspondence between each programming statement and a machine instruction. Assembly language is specific to a particular model of computer—though this was not yet a limitation in the 1940s and 1950s. Backus's first innovation was a high-level programming language that acted as a programmer's aid: Speedcoding, which made it easier for programmers to handle floating-point number operations. Given the laborious nature of programming in assembly language, any shortcut saved considerable time and money. Unlike low-level programming languages, high-level languages are more abstract, no longer focused on a one-to-one correlation with machine instructions. By today's standards, Speedcoding—the first high-level programming language for an IBM computer—was not very abstract, and although it made programming easier and reduced errors, its programs ran much more slowly (as much as twenty times more slowly) as those written in assembly language.

Backus's experience with Speedcoding led him to propose the IBM Mathematical Formula Translating System (which became Fortran) in 1954. Backus said that his interest in simplifying the programming experience came from his own laziness and boredom: He did not like the tedious work of assembly language. On some level, regardless of how much it contributed to his motivation, he must have realized the gains that could be realized and the sophisticated programs that could be written if the man-hours required to write a program were substantially reduced. The team assembled to develop Fortran, personally chosen by Backus, was eclectic almost to the point of eccentricity and included a researcher from the Massachusetts Institute of Technology (MIT), a cryptographer, a chess champion, and a young woman who had just graduated from Vassar. Long workdays were interrupted by snowball fights outside the offices.

Fortran was not intended as a programming language with special applications, as such, but because of the nature of the work done by computers when Backus developed it, it is especially suited for scientific and engineering work. It became more popular than Speedcoding had ever been and remains one of the most popular languages in disciplines that depend on number crunching—fields like meteorology, computational sciences, and fluid dynamics. Of course, the Fortran used today has considerably evolved, with the most recent version having been released in 2010. However, there is no doubt that it is the descendant of Backus's initial work.

Although Fortran soon eclipsed Speedcoding in popularity, the Speedcoding experience and its effect on programs' running time made users reluctant to adopt Fortran at first. Fortran was released in 1956—containing more than twenty-five thousand lines of assembly language—but use of Fortran increased the following spring, when the Fortran compiler was released. A compiler is the go-between that translates a programming language into machine instructions; Fortran's was an optimizing compiler, assuring that the program would perform at speeds roughly the same as assembly language. A revised and improved version of the language, Fortran II, followed in 1958, adding user-defined subroutines that made procedural programming possible. By the start of the 1960s, Fortran had become popular enough that it was available for four different models of IBM computers, and other manufacturers were including Fortran compilers in order to remain competitive. Programmers used Fortran on dozens of different models, making it the first programming language to be so widely used. Because the language has remained in use from the early modern computing era until the present day, its evolution and that of its compilers has developed in parallel with the state of computing as a whole. Today, Fortran is the language used for comparing the performance of high-end supercomputers.

By 1958, there were two different proposals for a universal programming language, one of which was supported by Backus and the Association for Computing Machinery (ACM). A joint meeting was held with members of the ACM and the Society of Applied Mathematics and Mechanics in Germany (GAMM) from May 27 to June 2, 1958, in Zurich. At the meeting, Backus and others hammered out the proposal for the International Algebraic Language (IAL), an ambitious programming language. No one liked the IAL acronym, and it was replaced with ALGOL the following year. Although Backus contributed to its conception, the original version of ALGOL, ALGOL 58, was not widely implemented at IBM because of the focus on Fortran. ALGOL 58 nevertheless introduced many important programming language concepts, some of which would later be adopted by versions of Fortran, as well as numerous other languages.

It was his work on the Backus-Naur Form (BNF) that led to Backus's Turing Award (bestowed in 1977). The BNF was formulated as a context-free grammar that could be used to describe ALGOL 58 (and its successor, ALGOL 60), both to make it easier for computer scientists to communicate with one another about programming languages and to make them easier to teach. The BNF name is not Backus's; computer scientist Peter Naur, in writing about ALGOL 60, simplified the character set Backus had used and referred to the style of notation Backus introduced as the Backus Normal Form. Because of Naur's contributions, this soon became the Backus-Naur Form. The BNF has also been of interest to information theorists and linguists, whose interest in programming languages is purely theoretical.

When Backus accepted his Turing Award, he delivered a lecture—as is the custom—choosing the topic “Can Programming Be Liberated from the von Neumann Style?” In the lecture, he described not only a new programming language, FP, but also a new approach to programming languages, a function-level language that lacks the variables of value-level programming languages such as Fortran. While FP did not become as popular as Backus might have hoped, he did catalyze a growth in research into function-level languages. Backus retired from IBM in 1991.

Personal Life

Backus was married twice, his marriage to Marjorie Jamison ending in divorce in 1966. His second wife, Barbara Stannard, died in 2004; they had married in 1968. Backus died in 2007 in Ashland, Oregon, survived by two daughters, Karen and Paula.

Bibliography

Ceruzzi, Paul E. A History of Modern Computing. 2nd ed. Cambridge: MIT, 2012. Print. A narrative history of the computer industry from 1945 to 1995, including the spread of Fortran and the evolution of programming languages.

Ensmenger, Nathan L. The Computer Boys Take Over: Computers, Programmers, and the Politics of Technical Expertise. Cambridge: MIT, 2010. Print. Like the Ceruzzi book, an account of the personalities and development of the computer industry, including Backus and his contemporaries.

Lohr, Steve. Go To: The Story of the Math Majors, Bridge Players, Chess Wizards, Maverick Scientists, and Iconoclasts—The Programmers Who Created the Software Revolution. New York: Basic, 2001. Print. Although there is no book-length biography of Backus, he is featured in the chapter on Fortran.

Mitchell, John C. Concepts in Programming Languages. New York: Cambridge UP, 2002. Print. A conceptual introduction to computer programming languages, including Fortran.

Rajaraman, V., and Priti Shankar. “John Backus—Inventor of Fortran.” Resonance 12.8 (2007): 3–5. Print. A review of Backus's major contributions after his death.