Ada Lovelace created what is widely regarded as the first computer program in 1843, written for Charles Babbage's Analytical Engine. The program computed Bernoulli numbers and existed only on paper, since the machine was never built. Some historians instead credit the first executed high-level language to Konrad Zuse's Plankalkül, designed between 1943 and 1945 but published decades later. The answer depends on whether "first" means first published algorithm or first runnable code.
The mechanism: how Lovelace's program actually worked
Lovelace's 1843 work was a set of notes translating an Italian article on Babbage's Analytical Engine. Note G, the final and longest note, contained a step-by-step algorithm for computing Bernoulli numbers. Babbage had sketched approaches to the problem, but Lovelace's version was the first complete, published sequence of operations designed for a general-purpose computing machine.
The Analytical Engine separated storage from processing. Its "store" held numbers on columns of figure wheels, and its "mill" performed arithmetic. Lovelace's program addressed both: it specified which variables went to which store columns and issued ordered operation cards. The machine was designed to read these cards, execute them, and print results.
The Bernoulli algorithm is not trivial. The numbers are defined recursively, so each term depends on all previous terms. Lovelace's program therefore included nested loops, a working table of intermediate values, and conditional branching logic. That combination is why historians treat it as a program rather than a calculation recipe.
Plainly: she wrote instructions that let a machine solve a problem too tedious to finish by hand, and she did it before any such machine existed.
Quantified context: dates, scale, and the gap to execution
The timeline matters because "first" claims collapse without dates.
| Year | Event | Significance |
|---|---|---|
| 1837 | Babbage describes the Analytical Engine | First design for a general-purpose programmable computer |
| 1842 | Menabrea publishes the Italian article | Basis for Lovelace's translation |
| 1843 | Lovelace publishes Notes, including Note G | First complete published program |
| 1943–1945 | Zuse designs Plankalkül | First high-level language design, unpublished until 1972 |
| 1948 | Manchester Baby runs stored programs | First practical execution of stored-program code |
| 1957 | FORTRAN released | First widely adopted high-level language |
The Analytical Engine had a planned store of 1,000 numbers of 40 decimal digits each, roughly 16.7 kilobytes of equivalent storage by one estimate. That is smaller than a single low-resolution photograph today. Lovelace's program needed only a fraction of it.
The gap between publication and execution is about 100 years. That gap is the central caveat: the program was correct in principle but never ran on the machine it targeted.
Edge cases: why the credit is contested
Three disputes recur, and each hinges on definitions.
First, Babbage himself wrote extensive program sketches. His notes on computing Bernoulli numbers predate Lovelace's publication, and some historians argue his contributions were understated. The counterargument is that sketches are not complete published programs.
Second, Zuse's Plankalkül is sometimes called the first programming language rather than the first program. It included assignment, arrays, and structured data, decades before FORTRAN. But it was not implemented on a working machine in its original form.
Third, early machine code run on the Manchester Baby in 1948 was the first code actually executed on a stored-program computer. That is "first run," not "first written."
First published program: Lovelace, 1843 First program sketches: Babbage, 1830s–1840s First high-level language design: Plankalkül, 1943–1945 First executed stored-program code: Manchester Baby, 1948 First widely used high-level language: FORTRAN, 1957
Red flags when reading claims online: sources that say "the first programmer" without naming the machine, sources that conflate language and program, and sources that date Plankalkül to its 1972 publication instead of its design.
Misconceptions: what the popular story gets wrong
The most common error is presenting Lovelace's program as running code. It never executed. The Analytical Engine was never completed, and the program's correctness is a matter of mathematical analysis, not runtime testing.
A second error is treating the 1843 notes as her sole contribution. Lovelace also described the machine manipulating symbols, not just numbers, and she wrote about its potential for composing music. That conceptual leap is arguably more important than the Bernoulli routine itself.
A third error is assuming "first programming language" and "first program" are interchangeable. A program is a specific set of instructions. A language is a notation for writing many programs. Plankalkül is a language claim; Note G is a program claim.
A counterintuitive detail: FORTRAN is often called the first high-level language, but Plankalkül predates it by roughly a decade. FORTRAN wins on adoption and implementation, not on chronological design.
Practical actions: how to evaluate a "first" claim yourself
When you encounter a new claim about the first program or language, apply these checks.
Name the machine: a program must target specific hardware. If no machine is named, treat the claim as incomplete. Separate design from execution: ask whether the code ever ran. Publication and execution are different milestones. Check the definition: program, language, compiler, and executed code are distinct categories. Verify the date source: original publication date beats later reprint date, especially for Plankalkül. Look for the primary document: Lovelace's 1843 Notes are publicly available and can be read directly.
For research or teaching, cite both the 1843 publication and the 1948 execution as separate firsts. That framing avoids the most common factual error in thin explainers.
Limitations: what the historical record cannot settle
The record is incomplete. Babbage's correspondence and notebooks are extensive but not fully digitized, and some sketches are undated. Zuse's wartime work was partly destroyed, so reconstruction relies on his later writings.
There is also no universal authority on "first programmer." The claim rests on scholarly consensus, not a formal registry. Different historians weight publication, completeness, and influence differently, and reasonable people reach different conclusions.
Finally, the Analytical Engine's design was never validated by construction. We cannot know with certainty whether Lovelace's program would have run without modification on the finished machine. What we can say is that it was mathematically sound and structurally complete.