The Off-Key Bard
History

This Day in History — The First FORTRAN Program Successfully Runs

On this day in 1954

On September 20, 1954, the first FORTRAN program ran at IBM — a language John Backus invented because he was, in his own words, too lazy to keep writing programs the hard way.

The Off-Key Bard sits before an early computer and discovers that programming it requires knowing far more about the machine than the problem he actually wants to solve. Memory locations, registers, instructions, and machine-specific details dominate the programmer's attention.

"What if instead of learning to think like the computer, we taught the computer to understand something closer to the way we describe the problem?"

On this day in 1954, the first successful program written in the developing FORTRAN language ran on an IBM 704 at IBM's facilities — a milestone the Cambridge Centre for Computing History dates to September 20. The program was a test, not a production run, and the full FORTRAN compiler wouldn't be delivered to customers until 1957. But the date marks the moment the core concept was proven to work, and in doing so, it helped change programming forever.

The project had started with a letter. In late 1953, mathematician and computer scientist John Backus wrote to his manager at IBM proposing a "better way" to program computers, estimated it would take six months, and asked for a small team. He got the budget and the people. The six months stretched into nearly four years.

In a 1979 interview, Backus was asked where the idea came from. His answer was characteristically direct: "Much of my work has come from being lazy. I didn't like writing programs, and so, when I was working on the IBM 701, writing programs for computing missile trajectories, I started work on a programming system to make it easier to write programs."

What Programming Was Before FORTRAN

In the early 1950s, programming a computer meant working in one of two ways: machine code — the raw binary numbers that the processor actually executed — or assembly language, which used mnemonic abbreviations for machine instructions but still required the programmer to manage memory locations, registers, and the specific architecture of the machine in front of them. Backus later described it as "doing hand-to-hand combat with the machine."

Every IBM 701 or 704 programmer needed to know the machine's internal structure intimately. Writing a scientific calculation — even something as conceptually simple as solving a quadratic equation — required manually constructing a precise sequence of low-level instructions. That work was slow, error-prone, and deeply tied to one specific machine. Programs written for one IBM model couldn't run on a different one without being substantially rewritten.

FORTRAN — FORmula TRANslator — was Backus's attempt to fix this at a fundamental level. The idea was to let scientists and engineers write calculations in algebraic notation that resembled the mathematics they already knew, then have a piece of software — a compiler — translate those statements into the machine code the computer actually executed.

The Team

The team Backus assembled was deliberately diverse. Lois Haibt built the arithmetic expression analyzer and helped write the first FORTRAN manual; she later said no one on the team worried about seeming stupid or being possessive of their code — they were all learning together. Roy Nutt wrote an assembler for the IBM 704 and was responsible for the format command. Irving Ziller designed methods for loops and arrays. Peter Sheridan invented compiler code that would be used for decades afterward. Robert Nelson, a cryptographer, handled sophisticated sections of the compiler.

Together they assembled a system that could parse mathematical expressions into syntax trees, determine the correct order of operations, and generate machine instructions to carry them out — all automatically.

The Skepticism

The September 1954 test was an early validation of the concept, but the project faced a serious credibility problem. Experienced programmers knew that hand-written machine code, carefully optimized by a skilled human, ran as fast as possible. Automatically generated code, the skeptics argued, would inevitably be slower — and on machines that cost hundreds of thousands of dollars per year to operate, slower code was expensive code. If FORTRAN made programming easier but caused computers to run significantly slower, the aerospace companies and research laboratories that IBM needed to win wouldn't use it.

Backus understood this from the beginning. He insisted, over the objections of team members who thought it was too hard, that the compiler had to produce highly optimized machine code. This was one reason the project took nearly four years instead of six months. The techniques for parsing expressions, optimizing loops, and allocating registers efficiently were genuinely difficult to develop, and the team invented most of them from scratch.

When the first production FORTRAN compiler was delivered to Westinghouse-Bettis for nuclear reactor design work in mid-April 1957, it ran. Programs that previously required around a thousand manually written instructions could sometimes be expressed in only dozens of FORTRAN statements. The generated code ran perhaps 20 percent slower than hand-optimized assembly, but development was five times faster. For most scientific applications, the trade-off was obvious.

What It Started

FORTRAN spread rapidly through the scientific computing community. Researchers used it for weather modeling, aerospace calculations, nuclear physics simulations, and computational chemistry — anywhere that large amounts of numerical computation needed to be expressed precisely and run repeatedly.

It also established a conceptual framework that every programming language since has built upon: the idea that a programmer should be able to describe what they want to compute, not how a particular machine should compute it. C, BASIC, Pascal, C++, Java, Python — the lineage runs directly from FORTRAN's central insight.

Fortran — the name is now conventionally lowercase — has been revised repeatedly and remains in active use in supercomputing centers worldwide, particularly for climate modeling and aerospace simulation. Modern Fortran looks almost nothing like the original 1954 language, but it descends directly from the proposition Backus made to his manager in a letter: that there had to be a better way.

"Once every step the coder knew,
Each memory place and instruction too.
Then formulas became commands instead —
And machines learned the language humans read."

History reminds us: the greatest breakthroughs in computing aren't always about making processors faster. Sometimes they are about inventing better abstractions so human minds can focus on the problem rather than the machine. FORTRAN didn't make computers more powerful. It made programmers far more productive — which, in the end, did far more to change the world.

Sources

← Back to the Desk — History