FORTRAN

Quick facts

• Name: FORTRAN, from FORmula TRANslation
• Developed by: IBM
• Project leader: John Backus
• First specifications: 1954
• First release: 1957 for the IBM 704
• Main field: scientific and numerical computing
• Principle: compiled high-level programming language

How were computers programmed before FORTRAN?

In the early 1950s, computer programming was still a highly technical activity. Programmers generally worked in machine language or with symbolic languages closely related to assembly language.

To perform a scientific calculation, writing the mathematical formula was not enough. The programmer had to break the calculation down into a sequence of operations corresponding to the instructions understood by the processor. Registers, memory addresses, branches and many other machine-specific details also had to be managed.

This approach could produce highly efficient programs, but development required considerable time. Programs were also strongly tied to the architecture of a particular computer.

As scientific computing expanded, these limitations became increasingly important. Researchers wanted to use computers for ballistics, aeronautics, physics, statistics, weather forecasting and numerical simulation. Programming had to become easier without sacrificing too much performance.

1953–1957: the birth of FORTRAN

In 1953, John Backus was given the resources at IBM to assemble a team and investigate a new approach to programming. The idea was to allow scientists to express calculations using notation closer to mathematics.

On November 10, 1954, the team produced a preliminary report describing the proposed IBM Mathematical FORmula TRANSlating System. The name FORTRAN came directly from this expression.

The project proved far more difficult than simply inventing a more readable syntax. The team also had to build software capable of translating that notation into efficient instructions for a real computer.

After several years of development, the first FORTRAN system became available for the IBM 704 in 1957.

The key idea: let the compiler translate the program

The fundamental change can be illustrated with a simple example. Suppose a scientist wants to calculate:

Y = (A + B)**2

In machine language or assembly language, this calculation has to be broken down into several individual operations: loading values, performing the addition, storing an intermediate result, multiplying it and finally saving the result.

FORTRAN allows the programmer to write an expression much closer to the mathematical formula itself.

The compiler analyses the FORTRAN source code and generates the corresponding machine instructions. The program written by a human and the instructions actually executed by the processor therefore become two different representations of the same algorithm.

This distinction is fundamental. Scientists can concentrate more on the problem they are trying to solve and less on the internal details of the computer.

The real challenge: generating fast machine code

A more convenient programming language initially faced an important objection. Computers were extremely expensive and their resources were limited. Many programmers believed that automatically generated code would inevitably be less efficient than carefully written machine or assembly code.

John Backus’s team therefore had to solve two problems at the same time: translate the program and optimise the resulting machine code.

This became one of the most important achievements of the original FORTRAN project. The compiler did more than mechanically translate statements. It applied optimisation techniques intended to produce efficient programs.

The result helped demonstrate that high-level programming did not necessarily require an unacceptable loss of performance. The reduction in programming effort could be enormous, while the generated programs remained efficient enough for serious scientific work.

The IBM 704: the computer behind the first FORTRAN

The original FORTRAN system was closely associated with the IBM 704, a scientific computer introduced by IBM in the mid-1950s.

The IBM 704 included hardware support for floating-point arithmetic. This was particularly valuable in scientific applications, where calculations frequently involve non-integer values and very different orders of magnitude.

FORTRAN and the IBM 704 therefore complemented each other. The computer provided the numerical processing capability, while the language made that capability easier for scientists and engineers to use.

What did a FORTRAN program look like?

FORTRAN gradually provided the main elements required to create substantial scientific programs: numerical variables, arithmetic expressions, arrays, loops, branches and functions.

A calculation could, for example, be written in a form such as:

      X = A + B
      Y = X * X
      Z = SQRT(Y)

To a modern programmer, these statements may appear ordinary. In the 1950s, however, they represented a major change. The source code increasingly described what should be calculated rather than every individual operation the processor had to perform.

Punched cards shaped the language

Early versions of FORTRAN remained strongly influenced by the hardware of their time. Programs were commonly prepared using punched cards, with each card generally representing one line of source code.

This explains the famous fixed-format layout of early FORTRAN. Particular columns had specific purposes, such as statement labels, continuation indicators and program text.

These restrictions may seem unusual today, but they illustrate an important principle in computing history: programming languages are influenced by the physical systems on which programmers use them.

Was FORTRAN the first programming language?

No. Machine-oriented symbolic languages, assembly languages and several experiments in higher-level programming existed before FORTRAN.

It would therefore be historically inaccurate to describe FORTRAN simply as “the first programming language”.

Its importance lies elsewhere. FORTRAN became one of the first high-level programming languages to achieve major industrial and scientific adoption. More importantly, its compiler demonstrated that a relatively abstract language could be translated into machine code efficient enough for serious scientific computing.

This helped change the way programmers thought about software. A programming language no longer had to mirror the instruction set of the processor directly.

From FORTRAN to a family of languages

FORTRAN did not remain frozen in its 1957 form. The language evolved continuously as computers and programming practices changed.

• 1957: the first FORTRAN system becomes available for the IBM 704.
• 1958: FORTRAN II improves support for subprograms and larger applications.
• 1960s: FORTRAN spreads to many computer families beyond IBM systems.
• 1966: FORTRAN receives its first major American standard, helping improve compatibility between implementations.
• FORTRAN 77: another major stage in the standardisation and evolution of the language.
• Fortran 90: an extensive modernisation introduces free-form source code and many new language features.
• Fortran 2003, 2008, 2018 and 2023: the language continues to evolve through international standards.

The spelling also changes in modern usage. The traditional uppercase FORTRAN is normally used when referring to the early language and its historical versions, while Fortran is the conventional spelling for the modern language.

Standardisation changes the scale of FORTRAN

As FORTRAN became available on computers from different manufacturers, another problem appeared: implementations were not always completely compatible.

Standardisation therefore became increasingly important. In 1966, the language was standardised in the United States as ANSI X3.9-1966.

This was an important step in software history. Programs were gradually becoming less dependent on a single computer model. If compatible compilers were available, the same language could be used across different systems.

Portability was far from perfect, especially because manufacturers often introduced their own extensions. Nevertheless, the principle became increasingly important and would become fundamental to modern software development.

Why FORTRAN became so important in scientific computing

FORTRAN was particularly well suited to numerical computation. It made it easier to work with arrays, repeated arithmetic operations and scientific algorithms.

The language was consequently used in many fields:

• trajectory calculations;
• physics and nuclear research;
• aeronautics and space research;
• weather forecasting and climate modelling;
• computational fluid dynamics;
• matrix calculations;
• numerical simulations;
• scientific modelling and engineering.

Its longevity can also be explained by the enormous amount of scientific software developed and validated over many decades. In numerical computing, replacing a well-tested program is not necessarily desirable simply because a newer programming language exists.

FORTRAN did not disappear

FORTRAN belongs to the history of computing, but modern Fortran remains an active programming language. Its international standard continues to evolve and modern compilers are still maintained.

Fortran remains particularly important in scientific computing and high-performance computing. Software used in meteorology, oceanography, physics, engineering and numerical simulation still relies on Fortran programs and libraries.

It would therefore be misleading to describe Fortran merely as an obsolete language preserved for historical reasons. Modern Fortran is very different from the language used on the IBM 704 in 1957.

Why FORTRAN was a turning point

• Abstraction: programmers could describe calculations without manually specifying every processor instruction.
• Compilation: the compiler automatically translated source code into executable machine instructions.
• Optimisation: the original compiler demonstrated that high-level programs could still achieve strong numerical performance.
• Productivity: scientists and engineers could spend more time on their problems and less time on low-level programming.
• Portability: the spread of compilers and later standardisation made programs progressively less dependent on a single computer architecture.
• Longevity: nearly seven decades after its introduction, Fortran continues to be developed, standardised and used.

FORTRAN timeline

• 1953: John Backus assembles a team at IBM to investigate a mathematical programming system.
• November 10, 1954: the team produces a preliminary report specifying the proposed FORTRAN system.
• 1957: the first FORTRAN system becomes available for the IBM 704.
• 1958: FORTRAN II appears.
• 1966: the first American FORTRAN standard, ANSI X3.9-1966, is published.
• 1977: John Backus receives the ACM A.M. Turing Award for his contributions to programming languages and systems.
• Fortran 90: a major modernisation of the language introduces free-form source code and numerous new features.
• 2023: a new generation of the international Fortran standard is published.

A lasting legacy

FORTRAN’s historical importance does not simply come from its age. It demonstrated that computers could be programmed efficiently using a language designed primarily for humans, while software handled the translation into the instructions required by the machine.

This principle became one of the foundations of modern programming. Programming languages have changed enormously since the 1950s, but the central idea remains familiar: describe a problem at a higher level of abstraction and let software tools translate that description for the computer.

Main sources: IBM — History of Fortran; Computer History Museum — History of FORTRAN and FORTRAN II; ISO/IEC JTC 1/SC 22/WG 5 — Fortran standards and documents.

Cover image showing Fortran 77 source code by Phrontis — own work, CC BY-SA 3.0, Wikimedia Commons.