Who is the father of the computer?
Who is the father of the computer? Babbage, Turing, Zuse, Eckert and Mauchly, von Neumann: each held one piece of the answer, and only one name became famous.

Mục lục
A draft with only one author’s name
In 1945, on a train to Los Alamos, New Mexico, the mathematician John von Neumann sat writing by hand. He was not writing about the atomic bomb. He was writing about a computer that did not exist yet, called EDVAC, and how it should be organized inside. The pages of notes were sent to Philadelphia[1].
There, Herman Goldstine, the security officer of the ENIAC computer project, had them typed and duplicated. The typescript is dated June 30, 1945. It runs 101 pages, it is incomplete, and it carries a single author’s name: von Neumann. Copies spread everywhere. The scientist Maurice Wilkes said it was one reason he traveled to the United States for a 1946 course[1].
His colleagues at the Moore School, where ENIAC was built, were not named on the cover. Von Neumann’s name became attached to the way of organizing a computer that almost every phone, laptop and server uses today. So who is really the father of the computer?
The short answer: there is no single father. “Computer” is four different things, thought up, proven, built and organized by different people over more than a century. This article follows five names. Charles Babbage imagined the machine. Alan Turing proved what such a machine can do. Konrad Zuse built the first working programmable machine. John Mauchly and J. Presper Eckert built the first electronic general-purpose machine. Von Neumann wrote down how to keep the program in memory.
At the end there is a table showing in which sense each person is a “father”, and a section where you can run a toy computer with just 16 memory cells yourself.
What is a computer? A pho shop and four questions
Picture a pho shop (pho is a Vietnamese noodle soup). To get a bowl you need three things: ingredients, a recipe, and a cook who follows the recipe. A computer has three matching parts. Data is the ingredients. A program is the recipe. A processor is the cook, reading the recipe line by line and doing each step exactly. Memory is where both are kept.
The question “who invented the computer” is really four smaller questions:
- Who imagined a machine that could follow any recipe, not just one dish?
- Who proved what such a machine can and cannot do?
- Who built a machine that actually ran?
- Who thought of keeping the recipe together with the ingredients, so the machine can fetch it and cook by itself?
Each person in this article answers one or two of these. The pho shop comparison breaks down in one place: a real cook does not rewrite the recipe while cooking, but a computer can. That difference is the fourth question, and the reason the 1945 report matters.
Babbage: the machine that never ran
In 1837, Charles Babbage described the Analytical Engine. He had started thinking about it around 1833, when he realized he could generalize his earlier machine, the Difference Engine, which only computed tables of numbers[3]. A machine that only computes tables is like a pot that can cook one dish. The Analytical Engine aimed to be the whole kitchen.

The design had almost all the parts that computers still have today[3]:
- Store: memory, planned to hold 1,000 numbers of 40 decimal digits each, about 16.6 kilobytes. Think of a pantry with 1,000 shelves.
- Mill: the arithmetic unit, able to do the four basic operations, comparisons, and optionally square roots. This is where the cook stands.
- Punched cards: instructions were fed in on cards, an idea borrowed from the Jacquard loom, where holes in a card decide which threads are lifted. Like an order slip with holes: wherever there is a hole, the cook makes that dish.
- Conditional branching and loops: the machine could say “if the result looks like this, jump over there,” and repeat a stretch of instructions many times.
- Output: a printer, a curve plotter, and a bell.
The machine was never finished. According to the sources, the reasons include conflicts between Babbage and his chief engineer, and a lack of funding[3]. His son, Henry Prevost Babbage, built part of the mill and the printing apparatus, working on and off from 1880 to 1910. In 1910 that part computed a list of multiples of pi, but with errors. It had no store and could not be programmed[3]. So Babbage’s design never actually ran.
The rest of the story comes from someone else. In 1842, Luigi Federico Menabrea published a French description of the machine, based on Babbage’s lectures in Turin in 1840. In 1843, Ada Lovelace translated that paper into English and added notes longer than the original. Among them was a method for computing Bernoulli numbers that many people call the first complete computer program[3]. That is how people commonly describe it; the machine to run it did not exist at the time.
So what did Babbage contribute? Three things. He separated memory from the calculating unit. He separated the program from the machine, so the program lived on cards. And he gave the machine branching and loops, so one machine could do many jobs. He is the “father” in the sense of the idea of a general-purpose machine, not in the sense of a machine that ran.
Turing: what is computation, really?
Nearly a century later, the question changed. Instead of asking how to build a machine, people asked: are there problems that no machine can solve? The question has a name, the Entscheidungsproblem, or “decision problem.” Simply put, it asks whether every yes-or-no question in mathematics can be handed to a method of calculation to answer[7].

Alan Turing submitted his paper answering this question on November 12, 1936, and it was published in 1937 in the Proceedings of the London Mathematical Society[6][7]. To say what “computation” means, he described a very simple imaginary machine. It has an endless tape divided into squares, a read-write head that looks at exactly one square at a time, and a finite table of instructions that says what to do in each situation[7]. Imagine an endless roll of receipt paper. A cashier may look at only one line, follow a sheet of rules next to them, mark one symbol, then move to the next line. Any calculation that can be done by following mechanical steps can be written as a sheet of rules like that.
He drew two results from it.
First, a universal machine. If the beginning of the tape holds a description of some machine M, then the universal machine U will compute exactly the sequence that M computes[7]. So a single machine with a fixed table of instructions can imitate any other machine, as long as you give it a description of that machine. Your phone is an example: the same hardware with thousands of apps installed, each app being “the description of a different machine.”
Second, there are decision problems that no algorithm can solve in every case[7]. Turing was not the first to prove this. According to the overview article, his was the second proof, after Alonzo Church’s theorem[7]. But his description with a machine is easier to picture, and it became the standard way to think about computation.
One point needs to be clear: the 1936 paper built no machine. It was a proof. Turing’s work on real machines came later. On October 1, 1945, he started the ACE project at the National Physical Laboratory in Britain. At the end of 1945 he completed a proposal titled Proposed electronic calculator. The Wikipedia article on ACE calls it “the first reasonably complete design of a stored-program computer.” According to the same article, ACE had subroutine calls, which the EDVAC design did not. The scaled-down Pilot ACE ran its first program on May 10, 1950[8].
Beyond all this, Turing is also known for the Turing test and for his wartime codebreaking, told in Turing and Enigma. For the question of this article, he is the “father” in the sense of the theoretical foundation of computation: saying what a computer can do, and what it can never do.
Zuse: the relay machine in Berlin
While Turing wrote proofs, an engineer in Berlin was building real machines. Konrad Zuse designed the Z1 in 1935 and 1936 and built it from 1936 to 1938. The Z1 was entirely mechanical and worked only briefly. The Z2, completed in 1940, used relays[5]. A relay is an electromechanical switch, like a light switch in your house, but flipped on and off by an electric current.

The Z3, completed in 1941, was presented on May 12, 1941 to scientists at the German Aeronautical Research Institute (DVL)[5]. Its technical details:
- Memory of 64 words, each 22 bits long.
- Arithmetic with binary floating-point numbers, a way of writing numbers like scientific notation, such as , but in base 2.
- The program was read from a perforated celluloid film. Starting values were entered by keyboard, and results appeared on a row of lamps.
- The number of relays is about 2,000 in the technical description and 2,600 in the lead of the same Wikipedia article, so I only write “roughly 2,000 to 2,600.” They worked at a speed of 5 to 10 times per second[5].
Five to ten beats per second is very slow next to the billions of beats per second of a processor today. But it worked, following a program, with binary numbers. That is why many sources call the Z3 the first working programmable computer.
The limits need to be stated too. The Z3 had no conditional branch instruction[5]. In the late 1990s, Raúl Rojas showed that in principle the Z3 could still compute anything a universal machine can. But that method requires the machine to compute all possible outcomes in advance and then discard those it does not need[5]. So “the Z3 is a universal machine” is true in theory and very slow in practice.
Zuse had a collaborator, Helmut Schreyer, who in 1938 demonstrated a vacuum-tube circuit for logic operations. The idea of an electronic machine was then considered infeasible. Later, according to the Wikipedia article, wartime authorities refused money to replace the relays with electronic switches, calling the project “not war-important.” The original Z3 was destroyed on December 21, 1943 in an Allied air raid on Berlin. In 1961, Zuse’s company built a working replica, now on display at the Deutsches Museum in Munich[5].
Zuse is the “father” in the sense of the first working programmable machine, and that machine was electromechanical, not electronic.
Eckert and Mauchly: ENIAC and the plugboard
On the other side of the Atlantic, John Mauchly (Ursinus College) and J. Presper Eckert (University of Pennsylvania) designed ENIAC[2]. The construction contract was signed on June 5, 1943. Assembly began in June 1944 and finished in May 1945. The first practical use was on December 10, 1945. On the evening of February 14, 1946, the machine was announced to the public[2].

ENIAC in numbers:
- About 18,000 vacuum tubes by the end of its operation in 1955.
- More than 30 short tons (about 27 tonnes).
- About 5,000 additions or subtractions per second, roughly a thousand times faster than electromechanical machines. Multiplication ran at about 357 per second and division at about 35 per second[2].
Vacuum tubes have no moving parts, so ENIAC did not have to wait for relays to open and close like the Z3. According to the Wikipedia article, ENIAC was the first machine with all three properties: electronic, programmable and general-purpose. Other machines had some of them, but none had all three[2].
But ENIAC had a weakness that everyone who worked with it knew: changing the program was a lot of work. Programs were set with plugboards and three portable function tables, each with 1,200 ten-position switches. Turning a problem into a wiring plan often took weeks. Setting the switches and plugging in the cables took several more days before the machine could run[2]. Imagine a pho shop that wants to change its menu and has to rewire the whole kitchen: nobody cooks, and people spend a week rearranging the cables.
The people who did that wiring were six women: Betty Holberton, Kay McNulty, Marlyn Wescoff, Ruth Lichterman, Betty Jean Jennings and Fran Bilas[2]. They were ENIAC’s six programmers. Their job was to turn a problem into a wiring diagram.
Eckert and Mauchly were later drawn into a legal dispute. On October 19, 1973, a U.S. court voided the ENIAC patent (No. 3,120,606). The ruling held that the inventors had derived the subject matter from the work of John Atanasoff, and recognized Atanasoff as the inventor of the first electronic digital computer[2]. So the title “first” always comes with a question for ENIAC: first by which criterion.
The two of them are the “fathers” in the sense of the first electronic general-purpose machine.
Von Neumann: a report and one name
ENIAC’s problem leads to the fourth question: if the program and the data are both just numbers, why not keep them together in memory?

Think of the pho shop’s stock book. In ENIAC, the recipe lived in one place (the wiring) and the ingredients in another (the number memory). To change the recipe you had to rewire. In the new organization, the recipe is written straight into the stock book, right next to the ingredient counts. The cook takes the book, reads the recipe, then takes the same book to record the quantities. To change the dish, you only rewrite a few lines in the book. This is called a stored program.
That is the central idea of the 101-page report of 1945. Von Neumann wrote it by hand on the train to Los Alamos, and Goldstine had it typed and duplicated[1]. The report’s official title is First Draft of a Report on the EDVAC.
The question of whose name goes on it lives here. The Wikipedia article says that von Neumann and Goldstine did not list the other designers as authors, so the credit went to one person. According to the same article, the name “von Neumann architecture” is controversial because he did not name John Mauchly and J. Presper Eckert, who designed EDVAC alongside him. Some members of the team argued that the stored-program idea came from earlier meetings at the Moore School, and that the report mostly translated those ideas into formal logic[1]. The sources do not agree on how to divide the credit among individuals.
There was a clearer legal consequence. A court later concluded that distributing the report was a public disclosure, made more than a year before the EDVAC patent application was filed. For that reason the EDVAC patent could not be enforced[1]. The way of organizing a computer therefore does not sit behind a valid EDVAC patent.
The idea first ran for real in Manchester. On June 21, 1948, Frederic Williams, Tom Kilburn and Geoff Tootill ran the first program on the Manchester Baby, also called the Small-Scale Experimental Machine[4]. Its memory had only 32 words of 32 bits each, 1,024 bits in all, stored on a Williams tube. The first program found the largest proper divisor of . The answer was 131,072. The program had 17 instructions and ran for about 52 minutes, through about 3.5 million operations[4]. The Baby was built mainly to test the Williams tube as a form of random-access memory, but it also showed that the stored-program design works. The source calls it the first electronic stored-program computer[4].
Von Neumann is the “father” in the sense of the organization of the modern computer, but he was not the only one to think of it, and he was not the one who ran it first.
So who is the father of the computer?
The table below gathers the five names, and each answers a different question.
| If “computer” means… | Person usually named | Milestone |
|---|---|---|
| The idea of a general-purpose, programmable machine | Babbage (and Lovelace for the program) | design, 1837 |
| The theoretical foundation of computation | Turing | paper, 1936–1937 |
| The first working programmable machine | Zuse (Z3) | 1941 |
| The first electronic general-purpose machine | Eckert and Mauchly (ENIAC) | 1945–1946 |
| Organizing the program to be stored in memory | von Neumann, with colleagues at the Moore School | report, 1945 |
| The first stored-program machine to actually run | Williams, Kilburn and Tootill (Manchester Baby) | 1948 |
Looking at this table, “who is the father” is like asking “who is the father of a bowl of pho.” The person who thought up the broth, the person who built the shop, the person who wrote the recipe into the book, and the person who cooked the first bowl sold to a customer can be four different people. Each has a fair claim to the title in their own sense.
One point helps answer more briefly: if you ask about the modern computer, the stored-program machine like the phone in your hand, then the broadest answer is a group. The 1945 report carries von Neumann’s name. Eckert and Mauchly are two designers of EDVAC whom the report does not name. Turing’s ACE proposal appeared at the end of 1945. And the first machine to run at Manchester belongs to Williams, Kilburn and Tootill.
Where does the stored-program idea live today?
Every time you install or update an app, you are doing exactly what the 1945 report made possible: writing new numbers into memory, which the machine then treats as a program. Nobody rewires anything. The phone changes behavior only because the data in memory changed.
That is how we got the operating system, a program that runs other programs, and the compiler, a program that turns human-readable code into numbers a machine can run. To memory, both are just data.
The same idea has a downside. Because the program and the data sit in the same memory, a piece of data placed in the wrong spot on purpose can be mistaken for an instruction by the machine. A family of security flaws, such as “buffer overflows,” exploits exactly this. Another limit is speed: the processor and memory are connected by a shared path, so a processor, however fast, has to wait for data. You can read more about how CPUs and GPUs deal with this, and how an SSD differs from a hard drive in storing and fetching data.
Four common misunderstandings about the “father of the computer”
Was ENIAC the first computer? It depends on the definition. The Z3 ran earlier, but it was electromechanical. ENIAC was the first machine with all three properties, electronic, programmable and general-purpose, but it did not yet store its program in memory, and the 1973 court named Atanasoff for the title of first electronic digital computer[2]. The honest answer is to say which criterion “first” refers to.
Did Turing invent the electronic computer? No. The 1936 paper was a proof and built no machine. His contribution is the theoretical foundation, plus the ACE design of 1945. The Pilot ACE ran in 1950, two years after the Manchester Baby[4][8].
Did Babbage build a computer? No. The Analytical Engine was never completed. The part of the mill that his son built in 1910 had no store and could not be programmed[3].
Did von Neumann come up with it alone? The sources suggest not. Some members of the Moore School team argued the idea predated him, and that the report mostly expressed it in formal logic[1].
Run a stored-program machine yourself
The Python script below builds a toy machine with 16 memory cells, each holding an integer. Instructions are numbers too: the opcode times 100 plus the address, so 112 means “LOAD cell 12.” The machine has only six instructions. The program adds 10 + 9 + 8 + … + 1. It is stored in cells 0 to 7, and the data in cells 12 to 14, in other words in the same row of memory. After it runs, the script writes a different number into cell 1, turning the ADD instruction into SUB, then runs again so you can see the result change. This is a small test of what took ENIAC days to do. It draws Figure 6. There is no randomness, so no seed is needed. You need matplotlib.
import matplotlib.pyplot as pltfrom matplotlib.patches import Rectangle
plt.rcParams.update({"figure.facecolor": "#16181c", "axes.facecolor": "#16181c", "text.color": "#d4d7dc", "axes.edgecolor": "#2a2e35", "axes.labelcolor": "#a4a9b2", "xtick.color": "#878d97", "ytick.color": "#878d97", "font.size": 12})
# Toy machine: 16 memory cells, each holding an integer. An instruction is also a number: opcode * 100 + address.OPCODE_NAMES = {0: "HALT", 1: "LOAD", 2: "ADD", 3: "SUB", 4: "STORE", 5: "JNZ"}
def run_machine(memory): """Run until HALT. Return the final memory, the number of steps, and the total after each loop.""" mem, acc, pc, steps, totals = list(memory), 0, 0, 0, [] while True: op, addr = divmod(mem[pc], 100) # split the number into (opcode, address) pc, steps = pc + 1, steps + 1 if op == 0: return mem, steps, totals elif op == 1: acc = mem[addr] elif op == 2: acc += mem[addr] elif op == 3: acc -= mem[addr] elif op == 4: mem[addr] = acc if addr == 12: totals.append(acc) elif op == 5 and acc != 0: pc = addr
# A program that adds 10 + 9 + ... + 1. Cells 0-7 are instructions, cells 12-14 are data: one shared row of memory.PROGRAM = [112, 213, 412, 113, 314, 413, 500, 0, # 0 LOAD 12, 1 ADD 13, 2 STORE 12, 3 LOAD 13, ... 0, 0, 0, 0, 0, 10, 1, 0] # cell 12: total, cell 13: counter, cell 14: the number 1
mem1, steps1, totals1 = run_machine(PROGRAM)print("original program: total =", mem1[12], "after", steps1, "steps")
# Changing the program = writing one number into cell 1: ADD 13 (213) becomes SUB 13 (313).patched = list(PROGRAM)patched[1] = 313mem2, steps2, totals2 = run_machine(patched)print("after writing 313 into cell 1: total =", mem2[12], "after", steps2, "steps")print("total after each loop, original:", totals1)print("total after each loop, modified:", totals2)
# Drawfig = plt.figure(figsize=(14, 8.4))o = fig.add_gridspec(2, 1, height_ratios=[1.15, 1], hspace=0.42)
def draw_memory(ax, mem, y, label): ax.text(-0.2, y + 0.5, label, ha="right", va="center", color="#a4a9b2") for i, v in enumerate(mem): is_instruction, is_data = i < 8, 12 <= i <= 14 edge = "#e8b05a" if is_instruction else "#8fa9c9" if is_data else "#2a2e35" fill = "#3a3220" if is_instruction else "#1f2c3a" if is_data else "#16181c" ax.add_patch(Rectangle((i, y), 0.94, 1.0, fc=fill, ec=edge, lw=1.4)) ax.text(i + 0.47, y + 0.64, str(v), ha="center", va="center", fontsize=12, color="#d4d7dc") if is_instruction: name = OPCODE_NAMES[v // 100] ax.text(i + 0.47, y + 0.2, name if v == 0 else f"{name} {v % 100}", ha="center", va="center", fontsize=7.5, color="#e8b05a")
ax = fig.add_subplot(o[0])draw_memory(ax, PROGRAM, 1.3, "before running")draw_memory(ax, mem1, 0, "after running")for i in range(16): ax.text(i + 0.47, 2.35, str(i), ha="center", color="#878d97", fontsize=10)ax.text(-0.2, 2.35, "address", ha="right", color="#878d97", fontsize=10)ax.text(3.95, 2.75, "cells 0-7: instructions (gold)", ha="center", color="#e8b05a")ax.text(13.5, 2.75, "cells 12-14: data (blue)", ha="center", color="#8fa9c9")ax.set_xlim(-2.6, 16.2)ax.set_ylim(-0.2, 3.1)ax.axis("off")ax.set_title("Instructions and data share one row of memory cells, and both are just numbers", color="#d4d7dc", fontsize=13)
ax = fig.add_subplot(o[1])loops = list(range(1, len(totals1) + 1))ax.plot(loops, totals1, color="#e8b05a", lw=2.4, marker="o", label="original program (cell 1 = 213, ADD)")ax.plot(loops, totals2, color="#8fa9c9", lw=2.4, marker="o", label="after writing 313 into cell 1 (SUB)")ax.axhline(0, color="#2a2e35", lw=1)ax.set_xlabel("loop iteration")ax.set_ylabel("value in cell 12")ax.set_xticks(loops)ax.legend(frameon=False, loc="center right")ax.set_title("Same machine: change one number in memory and you change the whole program", color="#d4d7dc", fontsize=13)for a_ in fig.axes[1:]: for sp in ("top", "right"): a_.spines[sp].set_visible(False)fig.savefig("may-tinh-luu-chuong-trinh-en.png", dpi=150, bbox_inches="tight")Output:
original program: total = 55 after 71 stepsafter writing 313 into cell 1: total = -55 after 71 stepstotal after each loop, original: [10, 19, 27, 34, 40, 45, 49, 52, 54, 55]total after each loop, modified: [-10, -19, -27, -34, -40, -45, -49, -52, -54, -55]
The first line of the output shows the program adds correctly: 10 + 9 + … + 1 = 55, after 71 machine steps. The second line is the main point. Writing one number into cell 1 makes the program do something else at once: the total becomes −55 without touching any hardware. With ENIAC before 1948, the same change meant rewiring cables and resetting switches. This is a toy machine I wrote to illustrate the idea, not a simulation of any historical machine. You can change the PROGRAM list to try other programs, for example by changing the 10 in cell 13 to 100 and checking whether the total is 5,050.
Back to the report
Von Neumann’s report wrote down a way of building machines that ENIAC did not yet have. One detail of the story remains untold. In March 1948, ENIAC itself was fitted with a converter, and in April 1948 it was demonstrated running as a stored-program machine. Its speed dropped by a factor of six, but the time to change programs went from several days to a few hours[2].
The machine that once had to be rewired for every problem ended up running by the idea of a manuscript written by hand on a train to Los Alamos. The idea carries one person’s name, but it came from many desks. And the question “who is the father of the computer” may be best answered with a list, each line saying exactly what that person did.
Free geometry illustrations for students and teachers: EyeViz.
Tài liệu tham khảo
- [1]First Draft of a Report on the EDVAC. Wikipedia.
- [2]ENIAC. Wikipedia.
- [3]Analytical Engine. Wikipedia.
- [4]Manchester Baby. Wikipedia.
- [5]Z3 (computer). Wikipedia.
- [6]A. M. Turing. On Computable Numbers, with an Application to the Entscheidungsproblem. Proceedings of the London Mathematical Society, series 2, 42, 230–265, 1937.
- [7]On Computable Numbers, with an Application to the Entscheidungsproblem (overview article; submitted November 12, 1936). Wikipedia.
- [8]Automatic Computing Engine. Wikipedia.


