Vai al contenuto principale
Bethemesh
BiografiaStoria dell’informatica

Grace Hopper: from early compilers to COBOL

Discover how Grace Hopper helped transform programming by making computers translate readable instructions into machine operations.

Pubblicato 3 agosto 2026Lettura : 6 minDi Bethemesh Team
Principiante
Historical portrait of Grace Hopper
Mostra indice
  1. Learning to program before the profession existed
  2. What the moth story really tells us
  3. Why A-0 automated part of programming
  4. FLOW-MATIC brought code closer to business work
  5. COBOL was a collective achievement
  6. Why portability requires more than a common language
  7. From language design to standardization
  8. Timeline
  9. Frequently asked questions
  10. Did Grace Hopper invent the first compiler?
  11. Did she create COBOL alone?
  12. Did she invent the word “bug”?
  13. Why is FLOW-MATIC important?
  14. Why is COBOL still present?
  15. What connects Grace Hopper and John Backus?

The first computers did not execute words such as READ, ADD, or PAYROLL. They understood numerical codes tied closely to their hardware. Grace Hopper devoted her career to narrowing the distance between human intent and machine operations.

Her contribution cannot be reduced to one invention or to the solitary creation of COBOL. She programmed one of the first large automatic calculators, led pioneering work on program translation, developed a language for business data with her team, and championed standards. One idea connects it all: programs should express the problem being solved rather than the peculiarities of a particular computer.

Learning to program before the profession existed

Grace Brewster Murray was born in New York in 1906. She studied mathematics and physics at Vassar College and earned a doctorate in mathematics from Yale in 1934. She taught at Vassar until World War II changed her path.

She joined the US Naval Reserve in 1943. The following year she was assigned to Howard Aiken’s team at Harvard, which operated the IBM Automatic Sequence Controlled Calculator, better known as the Harvard Mark I.

The Mark I was an electromechanical machine several meters long. It read instructions from punched tape and automated long calculations. Hopper learned to program it, produced tables for the Navy, and helped write its manual. The work forced the team to formalize a new activity: breaking down problems, arranging instructions, checking results, and reusing sequences. Programming was becoming a profession distinct from building hardware.

What the moth story really tells us

In 1947, the Harvard Mark II team found a moth trapped in a relay. It was taped into the laboratory logbook beside a note about the first actual case of a “bug.”

The anecdote is often distorted into a claim that Hopper invented the term. Engineers had already used bug for technical faults in the nineteenth century, and the logbook does not establish that Hopper removed the moth herself. The joke mainly shows that bug and debugging were already part of computing vocabulary.

That nuance better reflects her importance. Hopper’s place in history rests not on an insect, but on her work to make programming understandable, teachable, and independent of hardware.

Why A-0 automated part of programming

In 1949, Hopper joined the Eckert-Mauchly Computer Corporation, soon absorbed by Remington Rand, to work on UNIVAC I. Businesses wanted to process customer, inventory, and payroll records, but coding every operation in machine language remained slow and costly.

In the early 1950s, Hopper’s team developed A-0. A programmer identified available subroutines; A-0 found their code, loaded it, and organized their use. By modern definitions, it resembles a loader and linker as much as a complete compiler.

Calling it one of the earliest compiling systems is therefore more accurate than declaring it the first compiler without qualification. Its significance does not depend on the label: A-0 demonstrated that one program could automatically prepare another for execution. A-1, A-2, and MATH-MATIC continued this approach and supported Hopper’s then controversial argument that computers could reliably translate human-oriented notation.

FLOW-MATIC brought code closer to business work

Scientific languages primarily represented formulas. Business applications instead described operations such as reading a file, comparing records, calculating a total, or printing a report. Hopper believed their notation should reflect that vocabulary.

Her team developed FLOW-MATIC in the mid-1950s. Its English-like instructions described flows of data. Readability did not remove the need to learn programming, but it brought code closer to procedures understood by analysts and organizations.

FLOW-MATIC also taught a lesson about portability. If an instruction expressed a business operation rather than a hardware detail, a compiler could translate it for different computers. Programs became less dependent on a manufacturer. This approach directly prepared the discussions that produced COBOL.

COBOL was a collective achievement

In 1959, manufacturers, government agencies, and users met through CODASYL, the Committee on Data Systems Languages. They wanted a common language for business applications that could run on machines from different vendors.

Hopper attended the first meeting, and FLOW-MATIC strongly influenced the project. She had long advocated English-like instructions and machine independence. Nevertheless, committees produced the COBOL specification, with a drafting group responsible for its initial text.

Saying Hopper invented COBOL alone erases that cooperation. She was a pioneer, technical influence, and determined advocate, and later helped adoption and standardization, notably through the Navy. COBOL let organizations retain programs as hardware changed. Its longevity reflects decades of business rules whose replacement would be costly and risky.

Why portability requires more than a common language

A specification alone does not make programs portable. Vendors may interpret a rule differently, accept incompatible extensions, or disagree in edge cases. Hopper therefore emphasized compiler validation: test suites checked whether an implementation recognized required constructs and produced expected behavior.

Validation did not prove a compiler free of every defect. It established measurable, comparable conformity. The progression is continuous: A-0 automated subroutine assembly, FLOW-MATIC used business vocabulary, COBOL supplied a shared language, and validation sought to preserve that language’s meaning across machines.

Standardization can look less inventive than syntax design, yet it determines whether an idea becomes durable infrastructure or remains tied to one vendor.

From language design to standardization

Hopper continued at Remington Rand and Sperry Rand, publishing, teaching programmers, and presenting languages as a way to broaden access to computers.

After leaving the Naval Reserve in 1966, she returned to active duty in 1967. The Navy needed COBOL programs to remain compatible and verifiable across systems, and Hopper worked on validation and standardization.

She served until 1986 and retired as a rear admiral. In lectures, she made computing scales tangible, famously using pieces of wire representing the distance light travels in a nanosecond to explain the physical cost of time.

Hopper died in 1992. Her legacy lies in compilers and in a conviction now central to software: languages should bring programs closer to human problems, while standards should keep that progress from being trapped on one machine.

Timeline

  • 1906: Grace Brewster Murray is born in New York.
  • 1928: She graduates from Vassar in mathematics and physics.
  • 1934: She earns a doctorate in mathematics from Yale.
  • 1943: She joins the US Naval Reserve.
  • 1944: She joins the Harvard Mark I team.
  • 1947: The moth is discovered in a Mark II relay.
  • 1949: She joins Eckert-Mauchly to work on UNIVAC.
  • 1952: Work on A-0 is presented.
  • 1955–1959: Her team develops FLOW-MATIC.
  • 1959: She participates in the first CODASYL discussions.
  • 1960: The first COBOL specification is published.
  • 1967: The Navy recalls her to work on COBOL standardization.
  • 1986: She retires as a rear admiral.
  • 1992: She dies in Arlington, Virginia.
  • Today: Compilers, portable languages, and standards continue the work to which she devoted her career.

Frequently asked questions

Did Grace Hopper invent the first compiler?

She led the development of A-0, often described as the first compiler. Its function also resembles what is now called a loader or linker, so “one of the earliest compiling systems” is more precise.

Did she create COBOL alone?

No. CODASYL committees designed COBOL collectively. Hopper’s ideas and FLOW-MATIC directly influenced it, and she later played an important role in adoption, validation, and standardization.

Did she invent the word “bug”?

No. The word already described technical faults. The Mark II moth inspired a memorable joke about an “actual” bug, but did not originate the term.

Why is FLOW-MATIC important?

It showed that a business language could use words close to organizational procedures while remaining translatable by a computer. It directly influenced COBOL.

Why is COBOL still present?

Organizations have accumulated decades of proven business rules in COBOL. Replacing them is expensive and risky, while the original emphasis on portability helped the code survive successive hardware generations.

What connects Grace Hopper and John Backus?

Both sought to move programming away from machine code in the 1950s. Hopper focused on business processing through FLOW-MATIC and COBOL; Backus led FORTRAN for scientific calculation.

Fonti e riferimenti

  1. 1.Naval History and Heritage Command --- Grace Murray Hopper
  2. 2.Smithsonian --- Grace Hopper: The Navy and Computers
  3. 3.Computer History Museum --- Grace Murray Hopper
  4. 4.Computer History Museum --- Oral History of Grace Hopper
  5. 5.Smithsonian --- Log Book With Computer Bug

Raccolta

Linguaggi di programmazione

  1. 01Grace Hopper: from early compilers to COBOL
  2. 02John Backus: FORTRAN, BNF, and the rejection of machine code
  3. 03Dennis Ritchie: the C language at the heart of Unix
  4. 04FORTRAN: proving that a compiler could compete with assembly
  5. 05The C language: making systems portable without hiding the machine
  6. 06Niklaus Wirth: from Pascal to Oberon, designing through simplicity
  7. 07Bjarne Stroustrup: designing C++ without giving up performance
  8. 08Pascal: learning to program by making structure visible
  9. 09C++: from C with Classes to a general-purpose language
  10. 10Object-oriented programming: objects, messages, and reusable abstractions
  11. 11Guido van Rossum: creating Python to make code readable
  12. 12Brendan Eich: JavaScript, from Netscape prototype to Web standard
  13. 13James Gosling: the engineer behind Java
  14. 14Python: readability, batteries included, and a global ecosystem
  15. 15Java: write once, run anywhere
  16. 16JavaScript: the language that made the Web interactive
  17. 17Ken Thompson: from Unix to Go, simplicity as a method
  18. 18John McCarthy: Lisp and the idea of programming with symbols
  19. 19Alan Kay: Smalltalk and the computer as a personal medium
  20. 20Barbara Liskov: the abstraction that made software modular
  21. 21Robin Milner: ML, machine-assisted proof, and languages of interaction
  22. 22Brian Kernighan: AWK, Unix, and the art of explaining code
  23. 23Anders Hejlsberg: from Turbo Pascal to C# and TypeScript
  24. 24Larry Wall: Perl, the language that connected the tools of the Internet
  25. 25Yukihiro Matsumoto: Ruby and programmer happiness
  26. 26Rasmus Lerdorf: PHP and the democratization of the dynamic Web

Questo articolo ti è stato utile?