A mathematician in wartime
Grace Murray Hopper was born in 1906 and trained as a mathematician, earning a doctorate at Yale in the 1930s and then teaching at Vassar College. During World War II she joined the U.S. Navy Reserve and was assigned to work on the Harvard Mark I, an electromechanical calculator, under Howard Aiken. There she became one of the people who prepared and ran sequences of calculations for the machine.
After the war she moved to the private sector and worked on UNIVAC, one of the early commercial computers, at a company founded by J. Presper Eckert and John Mauchly. She later returned to naval service and eventually retired with the rank of rear admiral. She died in 1992.
The problem she was trying to solve
On early machines, a program was a long list of numbered instructions in the machine’s own terms. Writing it was slow and error-prone, and a program written for one machine usually could not be used on another. Programmers kept libraries of routines they had already written and copied them in by hand, which introduced mistakes.
The idea Hopper’s group explored was to let the computer do some of that clerical work. If routines could be stored with identifiers, then a program could refer to them by name, and a piece of software could assemble the final machine code automatically.
What a compiler is
A compiler is a program that translates instructions written in one form into another, typically from a human-oriented notation into the machine’s own instructions. This differs from simply running each line as it is read, which is the basic split between compilers and interpreters that still shapes how languages are used.
The word was used in a looser sense in the early 1950s than it is today. Hopper and her colleagues used it for programs that compiled, in the sense of collecting, subroutines into a complete program. Over the following years, the term came to mean the more general translation task that it describes now.
A-0 and the early systems
Around 1951 and 1952, Hopper’s team developed a system called A-0 for UNIVAC. It is often described as one of the first compiler-like tools. In practice, it worked by taking a program that called subroutines by number and then linking those routines together into one executable program, so it looks to modern eyes more like a loader or linker than a full translator.
Later systems moved closer to what we would call a compiler. One was FLOW-MATIC, developed in the mid-1950s for business data processing. It let programmers write instructions in English-like statements, so that a manager reading the code might follow the general intent without knowing machine details.
Hopper was not the only person pursuing this direction. Other groups in the same period were developing automatic coding systems, and the team behind FORTRAN at IBM produced a widely influential compiler for scientific work. Credit for early compilers is therefore shared among several teams, and the exact “first” depends on how a compiler is defined.
Skepticism and persuasion
By Hopper’s own later accounts, many colleagues doubted that a computer could be trusted to write its own machine code, or believed that machines were only suited to arithmetic. Part of her contribution was persuasion: she argued repeatedly that programming should be closer to the way people state problems, and that this would widen the group of people who could use computers.
Her accounts of these debates were told many times, often in speeches, and some details have probably been smoothed in retelling. The broad picture, that automatic programming met resistance from people who valued hand-tuned code, is well supported by the history of the period.
Connection to COBOL
In 1959, a committee of representatives from industry, government, and universities began work on a common business-oriented language. The effort led to COBOL language, which was meant to be portable across different manufacturers’ machines and readable to non-specialists.
Hopper’s earlier work on FLOW-MATIC influenced the thinking behind it, and she served as an adviser in the wider effort. She is sometimes called the mother of COBOL, but this overstates matters: the language was designed by a committee, and several people and prior systems contributed. She is better described as an influential advocate for the ideas that COBOL put into practice.
Why readable code mattered
The drive toward readable notation shaped how later programming languages developed. As compilers improved, programmers could think more about the task and less about registers and memory addresses, and programs could move between machines with fewer changes. This is one reason the field gradually shifted from writing machine code to using higher-level notations.
There were trade-offs. Early compiled programs were sometimes slower or larger than hand-written ones, and some programmers resisted for that reason. Over time, better compilers and cheaper hardware reduced the penalty for most purposes.
Legacy
Hopper became widely known later in life, partly through lectures and media appearances, and today several awards, buildings, and a U.S. Navy ship carry her name. Her popular image sometimes makes her seem like a lone pioneer, which does not match the record. She worked within teams, on machines designed by others, and alongside people pursuing the same goals elsewhere.
What she contributed is best understood as a sustained argument, backed by working software, that computers could translate human-friendly instructions. That argument is now so basic to software development that it is easy to overlook how contested it once was. The long run of programming languages that followed, from FORTRAN onward, builds on it. Her story is also a useful window onto early software more broadly, a period when the basic tools of programming were still being invented.