The Dawn of 'Automatic Programming'
Cast your mind back to the early 1950s. Computers were hulking, room-sized machines, and programming them was a painstaking process of writing in low-level assembly or machine code. It was a job for specialists, closer to engineering than writing. John
Backus, a programmer at IBM, famously found the work tedious and slow. He and his team set out to create a more practical alternative: a high-level language that would let scientists and engineers write mathematical formulas in something resembling English. This project became Fortran, short for "Formula Translation." The goal wasn't to design a beautiful language; the primary obsession was efficiency. Backus knew that unless the code compiled from Fortran ran nearly as fast as hand-written assembly, programmers would never adopt it. This singular focus on performance would lead to some very interesting compromises.
The Case of the Ignored Whitespace
Here is the forgotten decision: early Fortran compilers ignored whitespace. Everywhere. Spaces could be inserted anywhere, or removed entirely (except inside a text string), and it wouldn't change a thing. An identifier like `USER COUNT` was identical to `USERCOUNT`. A statement could be written as `G O T O 1 0` or `GOTO10`. This seems like madness today, a recipe for unreadable chaos. But there was a brilliant, practical reason for it. In the 1950s and 60s, programs weren't typed on screens; they were punched onto 80-column cards, one line of code per card. Keypunch operators, who translated handwritten code onto these cards, frequently made spacing errors. Instead of making the compiler fail on a trivial typo, the designers made a pragmatic choice: just tell the compiler to ignore spaces. It was a decision rooted in accommodating human fallibility and the physical limitations of the era's technology.
A Recipe for Peculiar Bugs
This convenience, however, came at a cost. Ignoring whitespace created a new and bizarre class of programming errors that were incredibly difficult to spot. The classic example, which has become a piece of programmer folklore, involves the `DO` loop. A programmer might write a loop header like `DO 10 I = 1, 10`. A simple typo, replacing the comma with a period, would result in `DO 10 I = 1.10`. To a modern language, this would be a syntax error. But to an old Fortran compiler, it was perfectly valid. The compiler would ignore the spaces and interpret the line as an assignment: `DO10I = 1.10`. It would create a new floating-point variable named `DO10I` and assign it the value 1.1. The loop would never run, and the program would fail in a subtle, mysterious way somewhere down the line. While the most famous story of this bug causing a spacecraft to be lost is an urban legend, the error itself was real and demonstrated the treacherous side of Fortran's syntax.
A Legacy of Precision
The rule of ignoring whitespace did not last. As programming moved from punch cards to interactive terminals and text editors, the original justification vanished. The risk of hard-to-find bugs far outweighed the convenience. Subsequent major languages like ALGOL, C, and their descendants took the opposite approach, making whitespace a significant part of the syntax, used to separate keywords and identifiers. The Fortran standard itself eventually changed, making free-form source code with significant whitespace the modern default, though it kept the old fixed-form rules for backward compatibility. In a way, Fortran's "forgotten" decision marks a pivotal moment in the history of software. It represents a transition from an era where the computer had to be lenient with its human operators to the modern era, where the human is expected to be absolutely precise for the computer. It’s a fossil preserved in the code, a reminder of a time when programming was a physical act, and a single misplaced space was a problem to be worked around, not a fatal error.
