IBM Develops the FORTRAN Computer Language

Date April, 1957

IBM programmer John Backus led the design and development of FORTRAN, the first high-level computer programming language, thereby enabling technicians who did not understand the inner workings of computers to create programs that would run on them.

Locale New York, New York

Key Figures

• John Backus (1924-2007), American software engineer and manager at IBM
• John William Mauchly (1907-1980), American physicist, engineer, and computer scientist
• Peter Naur (b. 1928), Danish astronomer and computer scientist
• Herman Heine Goldstine (1913-2004), American mathematician and computer scientist
• John von Neumann (1903-1957), Hungarian-born American mathematician and physicist
• Maurice Vincent Wilkes (b. 1913), English computer scientist

Summary of Event

FORTRAN (FORmula TRANslating system)—the first widely accepted, high-level computer language—was delivered by John Backus and colleagues at IBM in April, 1957. It was designed to support programming in a mathematical language natural to scientists and engineers and has achieved unsurpassed success in scientific computation.

Computer languages are means of specifying what instructions a computer should execute and in what order. They can be divided into categories of progressively higher degrees of abstraction. At the lowest level is binary or machine code: Binary digits (or another base, such as octal or hexadecimal) specify in complete detail every instruction that the machine will execute. This was the only “language” available in the early days of the first computers, such as the ENIAC, and required manually setting switches and plugboard connections. All higher levels of language are implemented by having a program process instructions written in the higher language into binary (also called object code).

Assembly language replaces numbers with names: Instead of having to write numeric instructions, say “14” for “clear accumulator register and add,” one can write the mnemonic instruction “CLA”; likewise, instead of writing numeric addresses, one can assign an arbitrary name to a memory location. The first rudimentary assembler was developed in the late 1940’s by Maurice Vincent Wilkes’s team for the EDSAC computer at the University of Cambridge. High-level languages, or simply programming languages, are largely or entirely independent of the underlying machine structure. The assembler instruction “CLA” is therefore excluded, since it refers to a specific register, the accumulator. Rather than naming registers, a high-level language will exclusively use programmer-specified variable names to hold and process data. FORTRAN was the first language of this type to win widespread acceptance.

The emergence of machine-independent programming languages was a gradual process, spanning the initial decade of electronic computation. One of the earliest developments was the invention of flowcharts (“flow diagrams”) by Herman Heine Goldstine and John von Neumann in 1947. Flowcharting became the most influential software methodology during the first twenty years of computing.

Short Code was the first language to be implemented that contained some high-level features, such as the ability to use mathematical equations. The idea came from John W. Mauchly, and it was implemented on the BINAC in 1949 with an interpreter; later, it was carried over to the UNIVAC 1. Interpreters do not translate a source statement into a series of binary machine instructions; instead, they directly execute (interpret) the source statement. Thus, every time the interpreter reencounters a statement, it must be interpreted again. Compilers, on the other hand, convert the entire program into object code before it is executed. Although interpreters have some advantages, a major disadvantage is that an interpreted program normally will run more slowly than the same program compiled.

Much early effort went into building up libraries of subroutines for handling commonly encountered problems, especially scientific calculations requiring floating-point arithmetic and array indexing. A number of interpretive languages arose to support these features. Among the most influential was Speedcoding, defined in 1953 by John Backus for the IBM 701. As long as floating-point and indexing operations had to be performed in software, however, scientific computation would remain relatively slow. Therefore, Backus lobbied successfully for a direct hardware implementation of these operations on IBM’s new scientific computer, the 704. Backus then started the Programming Research Group at IBM in order to develop a translator (compiler) to allow programs to be written in a more mathematical language, rather than a machine-oriented language. In November, 1954, they defined an initial version of FORTRAN.

To perform the mathematical calculation of doubling a number and multiplying by a further number requires, in machine or assembler language, the following steps: loading two registers, shifting one, multiplying them, checking for overflow, and finally storing the result back in memory. The obscurity and awkwardness of this process guaranteed that it would not generally be used by nonprofessional programmers. In FORTRAN, on the other hand, the same operation is expressed simply by A = (2 ; B) ; C. In general, FORTRAN supported constructs with which scientists were already acquainted, such as functions and multidimensional arrays. It also provided control mechanisms for iteration (repeated calculations in the DO loop), conditional branching (IF and GOTO), and sophisticated input-output (FORMAT). In defining a powerful notation accessible to scientists and engineers, FORTRAN opened up programming to a much wider community.

Backus’s success in getting the IBM 704’s hardware to support scientific computation directly, however, posed a major challenge: Since such computation would then be much faster, the object code produced by FORTRAN could ill afford to be slow—it would not be able to hide its inefficiencies behind the normal inefficiencies of scientific computation, since those were gone. The lower-level interpreters and compilers preceding FORTRAN produced programs that were usually five to ten times slower than their hand-coded counterparts; therefore, efficiency became the primary design objective for Backus. The highly publicized claims for FORTRAN met with widespread skepticism among programmers. In Backus’s terms, in those days programmers formed a “priesthood” used to coding around the highly obscure oddities of early hardware and to fitting code into incredibly small memories. Efficient programming was thought of as a “black art” that could hardly be automated.

Much of the team’s efforts, therefore, went into discovering ways to produce the most efficient object code, and, in fact, the degree of efficiency achieved with FORTRAN was not equaled again until the optimizing compilers of the late 1960’s. The FORTRAN compiler used an algorithm for assigning data to the IBM 704 registers that was nearly optimal, actually simulating the operation of the potential object code. It also performed a variety of global optimizations—for example, moving calculations outside repeated loops, when possible.

The compiler’s efficiency, combined with the language’s clarity and ease of use, guaranteed its success. By 1959, many 704 installations programmed exclusively in FORTRAN. By 1963, virtually every computer manufacturer either had delivered or promised a version of FORTRAN; by 1964, there were forty-three different FORTRAN compilers. Most of these compilers differed slightly from one another in how they implemented the language, but they all supported the same basic set of instructions. They also supported the major piece missing from FORTRAN I, but supplied one year later (1958) in FORTRAN II, which was the SUBROUTINE—a piece of code that could be compiled once and shared by different programs thereafter.

Incompatibilities among manufacturers were minimized by the popularity of IBM’s version of FORTRAN; everyone wanted to be able to support IBM programs on their own equipment (“porting” the program to the new equipment). Nevertheless, there was sufficient interest in obtaining a standard for FORTRAN that the American National Standards Institute adopted a formal standard for it in 1966. A revised standard was adopted in 1978, yielding FORTRAN 77.

Significance

In demonstrating the feasibility of efficient high-level languages, FORTRAN inaugurated a period of great proliferation of programming languages, including ALGOL, LISP, COBOL, BASIC, PL/I, PASCAL, and the other “third-generation” languages. Most of these languages attempted to provide similar or better high-level programming constructs but oriented toward a different, nonscientific programming environment. COBOL, for example, is a business-oriented language.

Backus, meanwhile, sat on the international committee that designed ALGOL-58. There, he invented a specification language in order to provide a precise definition of the syntax of ALGOL. Peter Naur enhanced the language for ALGOL-60, and it is now known as Backus-Naur Form (BNF) and is widely employed in defining language and data communications standards.

FORTRAN, while remaining the dominant language for scientific programming, has not found general acceptance outside that domain. Despite some new programming constructs introduced with FORTRAN 77, it still lacks sophisticated string manipulation, list handling, and other facilities. An IBM project established in 1963 to extend FORTRAN found the task too unwieldy and instead ended up producing an entirely different language, PL/I (delivered in 1966). In the beginning, Backus and colleagues actually believed their revolutionary language would virtually eliminate the burdens of coding and debugging. Far from that, it launched software as a field of study and as an industry.

Beyond stimulating the introduction of new languages, FORTRAN encouraged the development, for example, of operating systems. Assembler systems had already grown into simple operating systems, called monitors. Another early, and very primitive, operating system was the FORTRAN Monitor System for the IBM 709 (a followup to the 704), which was introduced in the late 1950’s. This monitor system handled many of the operational tasks on the computer for the FORTRAN programmer, such as supporting the compilation, loading, and execution of FORTRAN programs as a single procedure, as well as aiding in their debugging. Operating systems since then have been greatly extended to support, for example, simultaneously active programs (multiprogramming) and the networking together of multiple computers.

A further important development in programming languages was the introduction of functional languages, with APL, LISP, and Backus’s Formal Functional Programming (FFP). In the now traditional languages such as FORTRAN—which Backus calls “Von Neumann languages”—the flow of control is explicitly specified, for example, via the DO loops of FORTRAN. In functional programming, control is specified implicitly in the patterns of nested function calls. Functional programming is a further step in abstraction from specific machine architectures and, in particular, away from reliance on Von Neumann architecture. Backus has been an especially vocal proponent of the functional approach: “We have come to regard the DO, FOR, WHILE statements and the like as powerful tools, whereas they are in fact weak palliatives that are necessary to make the Von Neumann style of programming viable at all.” Whatever the limitations and future of Backus’s constructs, their implementation in FORTRAN was clearly a vital step in the continuing evolution of computer software.

Bibliography

Calingaert, Peter. Assemblers, Compilers, and Program Translation. Potomac, Md.: Computer Science Press, 1979. A readable, standard computer science text covering assemblers, macros, loaders, and compiler theory and techniques.

Chandra, Suresh. Computer Applications in Physics with FORTRAN, BASIC and C. 2d ed. Oxford, England: Alpha Science International, 2006. Compares FORTRAN to two other computer programming languages, thereby demonstrating its particular strengths and weaknesses in regard to physics applications. Index.

Meissner, Loren P., and Elliot I. Organick. FORTRAN 77: Featuring Structured Programming. 3d ed. Reading, Mass.: Addison-Wesley, 1980. A standard textbook on FORTRAN, introducing basic programming concepts. Includes exercises and examples.

Metropolis, N., J. Howlett, and Gian-Carlo Rota, eds. A History of Computing in the Twentieth Century. New York: Academic Press, 1980. A collection of papers originally presented at a conference on computing history at the Los Alamos Scientific Laboratory in 1976. The authors, from both sides of the Atlantic, include many of the principals involved in the early development of computers and computer software. Of special interest is Donald Knuth and Luis Trabb Pardo’s eighty-page “The Early Development of Programming Languages.”

Rosen, Saul, ed. Programming Systems and Languages. New York: McGraw-Hill, 1967. An anthology of papers records early efforts to develop and understand programming languages such as FORTRAN, ALGOL, COBOL, LISP, PL/I (known then as NPL). Introduced by a historical survey by Rosen.

Sammet, Jean E. Programming Languages: History and Fundamentals. Englewood Cliffs, N.J.: Prentice-Hall, 1969. A massive description of 120 computer languages and their histories. Introduces the basic concepts of computer languages and their compilers.

Wexelblat, Richard L., ed. History of Programming Languages. New York: Academic Press, 1981. An excellent collection of papers and transcripts of discussion from the ACM History of Programming Languages conference in 1978. Sessions on the histories of thirteen major languages, including FORTRAN, ALGOL, LISP, COBOL, BASIC, and PL/I. Includes John Backus’s paper “The History of FORTRAN I, II, and III.”

Wilkes, Maurice V., David J. Wheeler, and Stanley Gill. The Preparation of Programs for an Electronic Digital Computer. Reading, Mass.: Addison-Wesley, 1951. The first general text on programming methods, written by the EDSAC design team. Describes the rudimentary assembler for the EDSAC and the use of subroutine libraries, with examples. Of historical interest only.