The A-0 System — When "Compiler" Meant Something Else

In May 1952, at the ACM national meeting in Pittsburgh, Grace Hopper of Remington Rand read a paper called "The Education of a Computer". The system it describes is A-0, which had been running on a UNIVAC I since that spring.

The work is usually filed under "the first compiler". That is not false, but it is not accurate either, because the word compiler in 1952 did not point at the same object it points at now. Skip that, and what A-0 actually solved disappears from view.

What A-0 did

Hopper's own paper calls the thing a compiling routine of type A and sets out, in nine numbered items, what it performs for each operation the mathematician lists. In summary:

• locate the subroutine indicated by the call-number
• fabricate the instructions that transfer the arguments from working storage into the subroutine, and enter them in the program
• adjust the entrance and normal exit lines to the position the subroutine occupies in the program
• adjust alternate exit lines according to the control information the programmer supplied
• modify all the addresses in the subroutine's instructions and enter those instructions in the program
• maintain a record of the program, including each subroutine's call-number and the position of its entrance line

Allocation of temporary storage and program space, and control of input and output, are carried by the same routine. The paper puts it in one sentence: "Stated bluntly, the compiling routine is the programmer and performs all those services necessary to the production of a finished program."

To see why that list mattered, consider what it replaced. A subroutine library existed already — Howard Aiken had described one in the Mark I manual in 1946, and Hopper's paper credits him for the idea — but using it meant a human looking up where each routine sat, copying it, and then hand-patching every address inside it to match its new position in the program. It was slow, it was arithmetic, and it was exactly the kind of work that produces transcription errors at scale. Hopper's argument was that a machine has no business asking a person to do that. Her paper also promises what the programmer gets back: "the mathematician need only state, 'go to operation k', and the compiling routine does the rest."

Translate that list into today's vocabulary and it reads symbol resolution, relocation, and calling-convention generation. It is not parsing, not semantic analysis, not code generation. The IEEE Milestone plaque unveiled at the University of Pennsylvania's Moore School on 7 May 2024 says the same thing in its citation: A-0 was a series of specifications "that functioned as a linker/loader".

Why "compiler" was nevertheless the right word

In ordinary English of the period, to compile meant to gather material from a library and bind it into one volume. The subroutines lived in a tape library and each carried a call-number. Pulling the needed ones out and binding them into a single program was, in 1952, a perfectly literal use of the verb.

The modern sense — translating source text in a high-level language into machine code — becomes the primary meaning of compiler only after FORTRAN. The popular account misreads a pre-move usage with a post-move dictionary. That is the whole of the discrepancy.

The qualifier that belongs on "first"

Several people were working the same problem from different sides at the same time.

Wikipedia's history of compiler construction holds that the first compiler in the modern sense to be implemented was Glennie's Autocode, and records that Donald Knuth regarded Autocode as the first compiler. Against that, A-0 was implemented, was running, and was running on a commercial machine with paying customers. Which came first depends entirely on how you define "compiler" — and writing "first" without stating the definition is the worst available option.

The argument that actually mattered

A-0's significance is not a priority claim. What Hopper was asserting in 1952 was that producing a program is itself work a machine can be given. That was not obvious at the time; the prevailing view was that a computer was a device for doing arithmetic, not a device for writing programs.

She closes the paper by pushing the schoolroom metaphor of its title to the end: "With some specialized knowledge of more advanced topics, UNIVAC at present has a well grounded mathematical education fully equivalent to that of a college sophomore, and it does not forget and does not make mistakes."

From A-2 to FLOW-MATIC and COBOL

A-0 was revised into A-1 and A-2; the IEEE Computer Society's pioneer record dates A-2 to 1953. A-2's source was distributed to customers, who were invited to send their improvements back — nearly forty years before anyone said "open source". The line continued through ARITH-MATIC and MATH-MATIC to B-0, FLOW-MATIC, in 1957, and FLOW-MATIC became one of the three sources of ideas named by the first COBOL specification.

Every high-level language since has assumed a translation layer between what a human writes and what a machine runs. Whether A-0 was the first implementation of that layer is a matter of definition; that it was one of the first working systems to argue the layer was permissible is not.