On a hot summer day in 1947, a team of engineers at Harvard University was troubleshooting the Mark II computer when they found a moth wedged in a relay, preventing a circuit from closing. They taped the insect into the logbook and wrote: “First actual case of bug being found.” The team leader was Grace Murray Hopper — a Navy lieutenant, mathematician, and the woman who would go on to invent the first compiler, help create COBOL, and fundamentally change the relationship between humans and computers. Before Hopper, programming meant writing raw machine code — sequences of binary numbers unique to each computer. She believed that was absurd. Humans should write in something resembling English, and the machine should do the translating. That conviction drove her entire career and shaped every programming language that followed.
Early Life and Path to Technology
Grace Brewster Murray was born on December 9, 1906, in New York City. Her father, Walter Fletcher Murray, was an insurance company executive. Her mother, Mary Campbell Van Horne, had a deep interest in mathematics — unusual for a woman of her generation. Grace inherited that interest. As a child, she dismantled alarm clocks to understand their mechanisms. When she took apart seven of them before her mother intervened, her allowance was limited to one clock at a time.
She attended Vassar College, graduating in 1928 with a bachelor’s degree in mathematics and physics. She earned a master’s degree from Yale in 1930 and a PhD in mathematics from Yale in 1934 — one of the few women in the United States to hold a doctorate in mathematics at that time. Her doctoral dissertation was on “New Types of Irreducibility Criteria,” a topic in abstract algebra. She joined the Vassar faculty as an associate professor of mathematics and taught there from 1931 to 1943.
When the United States entered World War II, Hopper tried to enlist in the Navy but was initially rejected — at 34, she was considered too old, and at 105 pounds, she was fifteen pounds below the minimum weight requirement. She obtained a waiver and joined the Navy WAVES (Women Accepted for Volunteer Emergency Service) in December 1943. She was commissioned as a lieutenant (junior grade) and assigned to the Bureau of Ships Computation Project at Harvard University, under Commander Howard Aiken.
The Breakthrough: Inventing the Compiler
The Technical Innovation
At Harvard, Hopper programmed the Mark I — an electromechanical computer 51 feet long, 8 feet tall, and weighing five tons. It could perform three additions per second. Programming it meant writing sequences of numerical codes on paper tape: each instruction was a specific number that told the machine to perform a specific operation on data at a specific memory address. There was no programming language. There was no keyboard. There was no screen. You fed in paper tape and read the results off paper.
Hopper hated it. She was a mathematician, not a machine operator. She wanted to express mathematical ideas, not translate them into machine codes by hand. Over the next several years, working on the Mark I, Mark II, and Mark III, she developed a growing conviction that computers should be able to understand something closer to human language.
In 1949, Hopper joined the Eckert-Mauchly Computer Corporation (later acquired by Remington Rand, then Sperry) to work on the UNIVAC I — one of the first commercial computers. There she began building what she called a “compiling routine” — a program that translated a higher-level notation into machine code.
Her first compiler, the A-0 System, was completed in 1952. It was not a compiler in the modern sense — it was closer to a linker or loader, translating mathematical notation into machine code subroutines. But the concept was revolutionary: instead of writing machine instructions directly, you wrote expressions in a more abstract notation, and the computer translated them into the binary codes the hardware understood.
; A-0 System: Hopper's first compiler (1952)
; The programmer wrote mathematical notation:
; ASSIGN result = (x + y) * z
; The A-0 compiler translated this into UNIVAC I machine code:
; Load value of x into accumulator
00 010 000 100 ; LOAD address_x
; Add value of y to accumulator
01 020 000 101 ; ADD address_y
; Store intermediate result
02 030 000 110 ; STORE temp
; Load intermediate result
03 010 000 110 ; LOAD temp
; Multiply by z
04 040 000 102 ; MULT address_z
; Store final result
05 030 000 111 ; STORE result
; Before Hopper: programmers wrote these numeric codes by hand
; After Hopper: programmers wrote mathematical expressions
; The compiler handled the translation automaticallyThe response from the computing community was disbelief. “I had a running compiler,” Hopper later recalled in a 1980 lecture, “and nobody would touch it. They told me computers could only do arithmetic.” The prevailing wisdom was that computers were calculating machines — they manipulated numbers, nothing more. The idea that a computer could process English-like statements was considered nonsensical.
Hopper persisted. By 1955, she and her team had developed the B-0 compiler (also called FLOW-MATIC), which went further than A-0: it accepted programs written in English-like statements. FLOW-MATIC was the first programming language to use English words for its commands.
FLOW-MATIC: The first English-like programming language (1955-1958)
Designed by Grace Hopper's team at Remington Rand
(0) INPUT INVENTORY FILE-A PRICE FILE-B ; OUTPUT OUTPUT-FILE FILE-C ;
(1) COMPARE PRODUCT-NO (A) WITH PRODUCT-NO (B) ;
(2) IF GREATER GO TO OPERATION 10 ;
(3) IF EQUAL GO TO OPERATION 5 ;
(4) OTHERWISE GO TO OPERATION 2 ;
(5) TRANSFER A TO D ;
(6) WRITE-ITEM D ;
(7) JUMP TO OPERATION 8 ;
(8) CLOSE-OUT FILES C ; D ;
(9) STOP . (END)
; For the first time, a non-specialist could read a program
; and understand what it did. This was Hopper's revolution:
; programming should be readable by humans.FLOW-MATIC was designed for business data processing, not scientific computing. Hopper made this choice deliberately. She understood that computers would be adopted by businesses, not just laboratories, and business users were not going to learn machine code. If programming remained the exclusive domain of specialists, computers would remain niche tools. Making programming accessible was not just convenient — it was necessary for the technology to fulfill its potential.
Why It Mattered
Hopper’s compiler concept — the idea that a program can translate human-readable code into machine instructions — is the foundation of all modern programming. Every language you write in today passes through a compiler or interpreter before the hardware executes it. When you write JavaScript in a browser, the V8 engine compiles it to machine code. When you write Python, the interpreter translates it. When you compile a C program, GCC or Clang transforms your source into binary. Every one of these tools is a descendant of the concept Hopper invented in 1952.
The magnitude of this contribution is hard to overstate. Before compilers, every program was written for a specific machine. Code written for the UNIVAC I could not run on an IBM 701. Programmers were not writing in a “language” — they were writing machine-specific instructions. Compilers introduced the abstraction layer that separated programs from hardware. This separation enabled software portability, code reuse, and the entire concept of a “programming language” as we understand it today.
Beyond the Compiler: COBOL and Standardization
FLOW-MATIC directly influenced the creation of COBOL (Common Business-Oriented Language). In 1959, the U.S. Department of Defense convened a committee — the Conference on Data Systems Languages (CODASYL) — to create a standard business programming language. Hopper served as a technical advisor, and FLOW-MATIC was one of three languages the committee used as a basis for COBOL’s design.
COBOL debuted in 1960. Its syntax was deliberately verbose and English-like — a direct reflection of Hopper’s philosophy that code should be readable by non-programmers. Academic computer scientists mocked it. Edsger Dijkstra famously said that the use of COBOL “cripples the mind.” But COBOL worked. It processed business transactions reliably. It ran on different manufacturers’ hardware. And it scaled.
More than six decades later, COBOL still processes an estimated 95% of ATM transactions, 80% of in-person financial transactions, and handles approximately $3 trillion in daily commerce. The IRS runs COBOL. Major banks run COBOL. Insurance companies, government agencies, and healthcare systems run COBOL. The language that academics derided as simplistic turns out to be one of the most durable and economically significant programming languages ever created.
Hopper also championed the idea of programming language standards — the concept that a language should have a specification that multiple manufacturers implement identically. Before standardization, every computer vendor had its own language. Code written for one manufacturer’s machine was useless on another’s. Hopper pushed for COBOL to be standardized so that the same program could run on any compliant computer. This idea — that programming languages should be portable across hardware — is so fundamental today that we take it for granted. In 1960, it was radical. Today, the web frameworks and development tools we use all depend on standardized languages.
Philosophy and Engineering Approach
Key Principles
Hopper articulated her philosophy through memorable statements that reflected decades of fighting institutional resistance to new ideas.
“The most dangerous phrase in the language is: We’ve always done it this way.” Hopper repeated this throughout her career. She encountered resistance at every stage: resistance to compilers, resistance to English-like languages, resistance to standardization. Each time, the objection was some variant of “this is not how it is done.” Hopper’s response was always the same: prove it works, and they will change their minds. She was usually right, though it sometimes took years.
“It is easier to ask forgiveness than it is to get permission.” This was her approach to bureaucratic obstacles in both the Navy and the computing industry. When Hopper wanted to build the A-0 compiler, she did not write a proposal and wait for approval. She built it. When the compiler worked, the arguments against it became irrelevant. This principle — ship first, justify later — predates the Silicon Valley “move fast and break things” ethos by four decades.
Accessibility is not optional. Hopper’s insistence that programming should be accessible to non-specialists was not a soft goal. It was an engineering requirement. She understood that the number of people who could write machine code was a bottleneck on the computer’s usefulness. Remove the bottleneck, and computers become useful to everyone. This thinking directly parallels the modern web accessibility movement — the principle that technology must be usable by all people, not just specialists.
Standards enable innovation. Counterintuitively, Hopper argued that standardization accelerated innovation rather than constraining it. When every vendor had a proprietary language, programmers spent time rewriting code for different machines instead of building new things. When languages were standardized, programmers could focus on solving problems rather than fighting compatibility issues. The same principle applies today: HTML, CSS, and JavaScript standards enable the diverse framework ecosystem that exists because the underlying platform is consistent.
Legacy and Modern Relevance
Hopper served in the Navy for 43 years, retiring at the rank of Rear Admiral in 1986 at the age of 79. At the time, she was the oldest active-duty commissioned officer in the U.S. Navy. After retirement, she worked as a senior consultant at Digital Equipment Corporation until her death on January 1, 1992, at age 85.
Her legacy is embedded in the infrastructure of computing. The compiler she invented in 1952 is the ancestor of GCC, LLVM, V8, the Java Virtual Machine, and every other compiler and interpreter in existence. The English-like programming she championed led directly to COBOL, and the principle of human-readable code influenced every subsequent language — from C to Python to TypeScript.
The connection between Hopper’s work and modern web development is direct. When you write a React component in JSX, a compiler transforms it into JavaScript function calls. When you write Git commands, a program translates your text into operations on a content-addressable data store. When you use a build tool to optimize your web application, compilers minify, tree-shake, and bundle your code. Every layer of the modern development stack contains compilers, and every one of them exists because Hopper proved in 1952 that computers could translate human-readable instructions into machine code.
Tim Berners-Lee created the web. Linus Torvalds built the servers it runs on. Brendan Eich gave it interactivity. Margaret Hamilton pioneered software engineering discipline. But Hopper laid the conceptual foundation that made all of their work possible. Without compilers, there are no programming languages. Without programming languages, there is no web, no Linux, no JavaScript. Hopper did not just build a tool. She established the principle that machines should adapt to humans, not the other way around.
The U.S. Navy named a guided-missile destroyer after her: the USS Hopper (DDG-70), commissioned in 1997. Yale University renamed Calhoun College to Grace Murray Hopper College in 2017. The Grace Hopper Celebration of Women in Computing, held annually since 1994, is the world’s largest gathering of women in technology — drawing over 30,000 attendees. Her legacy extends beyond code into the culture of computing itself.
Key Facts
- Born: December 9, 1906, New York City, New York
- Died: January 1, 1992 (age 85), Arlington, Virginia
- Known for: Inventing the first compiler (1952), co-creating COBOL (1959), popularizing the term “debugging”
- Education: B.A. Mathematics and Physics, Vassar College (1928); M.A. Mathematics, Yale (1930); PhD Mathematics, Yale (1934)
- Military rank: Rear Admiral, United States Navy (retired 1986)
- Key projects: Mark I programming, A-0 compiler, FLOW-MATIC, COBOL
- Awards: Presidential Medal of Freedom (posthumous, 2016), National Medal of Technology (1991), Defense Distinguished Service Medal
- Named after her: USS Hopper (DDG-70), Grace Hopper College at Yale, Grace Hopper Celebration of Women in Computing
Frequently Asked Questions
Who is Grace Hopper?
Grace Murray Hopper (1906-1992) was an American computer scientist, mathematician, and United States Navy Rear Admiral. She invented the first compiler in 1952, helped create the COBOL programming language, and was one of the first people to program the Harvard Mark I computer. She is widely regarded as one of the most influential figures in the history of computing.
What did Grace Hopper create?
Hopper created the first compiler (the A-0 System, 1952) — a program that translates human-readable code into machine code. She also created FLOW-MATIC, the first programming language to use English-like syntax. She was a key technical advisor in the creation of COBOL, which remains one of the most widely used languages in financial transaction processing. She also popularized the concept of machine-independent programming languages.
Why is Grace Hopper important to computer science?
Hopper proved that computers could be programmed in human-readable languages rather than raw machine code. This insight — and the compiler she built to demonstrate it — is the foundation of all modern programming. Every programming language, every compiler, and every interpreter in use today descends from the concept she pioneered. She also championed language standardization, which enabled software portability across different hardware platforms.
Did Grace Hopper really find the first computer bug?
Hopper’s team found a moth trapped in a relay of the Harvard Mark II computer in 1947 and logged it as the “first actual case of bug being found.” However, the term “bug” for technical problems predated this incident — Thomas Edison used it in the 1870s. Hopper is credited with popularizing the terms “bug” and “debugging” in the context of computer programming, not with inventing them.
