Saving programming time and machine time
In the 1950s, scientific computing faced difficulties beyond calculation speed. Users had to break mathematical procedures into machine instructions and arrange storage addresses, loops, and input and output. Programming and debugging consumed substantial labour, while expensive computers could not afford markedly inefficient executable programs. Automatic translation that made code easier to write but calculations much slower would struggle to gain users' trust.
John Backus led an International Business Machines team in New York developing FORTRAN for the IBM 704, which supported floating-point arithmetic and index registers. Preliminary specifications in 1954 proposed formula translation; an October 1956 reference manual allowed users to learn in advance. Only delivery of the compiler in 1957 turned the language description into a system that users could repeatedly run on their own machines.
Writing formulas on cards
Users still had to choose an algorithm. To calculate a circle's area, for example, they could write AREA = 3.14159 * R * R, asking the system to evaluate the right-hand expression and store the result at the location corresponding to AREA. The equals sign denoted assignment, not a request to prove an algebraic equality. The compiler generated 704 instructions for fetching, multiplying and storing values; the computer ultimately still executed machine code.
Arrays and DO statements simplified repeated processing of groups of data, while IF statements could select a path according to whether a value was positive, negative or zero. Programmers entered statements in specified columns on punched cards and separately prescribed input and output formats. The formula-like language retained clear restrictions: integers, floating-point numbers and array subscripts could not be mixed arbitrarily, and source programs had to follow card layouts for statements and continuation lines.
References: [2]
Translation also reorganizes computation
The FORTRAN compiler did not replace every word with a fixed instruction. It analysed formulas and control statements, organized array loops, program flow and registers, and finally produced the object program. The 1957 paper used a root-finding formula to show how repeated subexpressions could be calculated once and a square implemented as one multiplication. Such processing meant concise notation need not incur a corresponding amount of repeated computation.
A harder problem was that the 704 had only three index registers, while a program could involve many arrays and loops. The team first used symbolic index locations, then analysed frequently travelled paths and assigned actual registers where they were most useful, reducing loading and saving overhead. Lois Haibt handled flow analysis and Sheldon Best the subsequent index-register processing. Optimization depended on cooperation among several stages rather than one isolated technique.
From laboratory results to users' sites
In February 1957, the team presented its system paper at the Western Joint Computer Conference in Los Angeles. It reported examples generating many machine instructions from a small number of FORTRAN statements, but developers' demonstrations did not guarantee performance for every user's work. Backus later recalled that around the conference they were still borrowing North American Aviation's 704 for overnight debugging. Only in April did they consider the system stable enough for distribution.
Delivery itself was an engineering problem. Copying thousands of binary cards was error-prone, so the team turned to magnetic tape with accompanying editing and loading programs. Users' source-program errors and compiler defects required different treatment, and patches continued after delivery. The 1957 milestone therefore marks distribution of a usable compiling system, not the end of debugging.
Giving the compiler more work
The first FORTRAN chiefly served numerical computation. As programs grew, recompiling everything and interpreting unclear diagnostics became burdens. FORTRAN II, distributed in 1958, added capabilities including separately compiled subroutines, helping users divide work and reuse code. These were later developments, not features of the original 1957 release.
Frances Allen's technical review identified early FORTRAN's organization of flow analysis, loop processing and register allocation as important foundations for later compilers. It demonstrated that high-level expression and efficient execution could be combined through a sophisticated translator. The cost was also clear: optimization took time and might not be worthwhile for short or frequently changed programs. A new software layer carrying substantial engineering judgment stood between user and machine, and the language's spread depended jointly on reliable implementation, manuals and maintenance.