From Turing to LLMs and Beyond Β· Issue 2 of 10
Issue 2 Β· 1940s–1950s

Building the First Brains

← Previous Issue: The Idea That Started Everything

War Made It Real
Last time, we watched a 23-year-old imagine the simplest possible computing machine. Beautiful. Elegant. Completely imaginary. Nobody had built one. Nobody needed to. And then the world caught fire. Tera

In 1936, Alan Turing's machine existed only on paper β€” a thought experiment to answer a question about the limits of logic. It was not designed to be built. The mathematics worked regardless.

But between 1939 and 1945, the Second World War created problems that no human mind could solve fast enough. Encrypted messages needed cracking β€” not tomorrow, but now. Artillery firing tables required millions of calculations. Theory had a deadline.

Across three countries, engineers and mathematicians raced to build machines that could think faster than people. They used different technologies, different designs, different philosophies. But they all converged on the same basic principle Turing had described: a machine that manipulates symbols according to rules.

1936Turing'sPaper 1941Zuse's Z3 1943Colossus 1945ENIAC 1947Transistor 1958IntegratedCircuit

The first person to build a programmable computer wasn't British or American. He was a German engineer, working alone, in his parents' apartment. And almost nobody noticed.

The Forgotten First
The first working programmable computer? Built by a German civil engineer named Konrad Zuse, in his parents' living room, using scrap metal and old movie film. History hasn't been kind to him. Let's fix that. Tera

Konrad Zuse was born on June 22, 1910, in Berlin. He studied civil engineering, not mathematics. He had no idea Turing's paper existed. He just hated doing calculations by hand.

Starting in 1936 β€” the same year Turing wrote his paper β€” Zuse began building computing machines in his parents' apartment. His first attempt, the Z1, was purely mechanical and jammed constantly. But the concept was sound.

In 1941, Zuse completed the Z3. It was the world's first working, fully automatic, programmable digital computer. It read its programs from punched film β€” strips of discarded 35mm movie stock.

Konrad Zuse (1910–1995)

Background: Civil engineer (not a mathematician or physicist)

Known for: Built the first working programmable computer β€” in his parents' apartment

Fun fact: He used discarded 35mm movie film for punched tape because it was cheap. He also created what may be the first high-level programming language, PlankalkΓΌl, in 1945.

THE Z3 (Berlin, 1941) β”œβ”€β”€ Technology: ~2,600 electromechanical relays β”œβ”€β”€ Speed: Addition in 0.8s, multiplication in ~3s β”œβ”€β”€ Memory: 64 words of 22 bits each β”œβ”€β”€ Input: Punched 35mm film tape β”œβ”€β”€ Weight: ~1,000 kg (about 2,200 lbs) β”œβ”€β”€ Fate: Destroyed by Allied bombing, Dec 1943 └── Turing-complete: Proven retroactively in 1998
Think About It: Zuse, Turing, and others were working on similar problems at the same time, on different continents, without knowing about each other. Why do you think the same kinds of ideas often emerge independently? What does that tell us about the nature of invention?

While Zuse tinkered in Berlin, a very different kind of computing was happening in the English countryside β€” not to solve engineering problems, but to win a war.

Cracking the Uncrackable
Remember Turing from Issue 1? By 1939, he was at Bletchley Park β€” Britain's top-secret code-breaking center. The Germans were using encryption machines, and cracking them by hand was too slow. People were dying while mathematicians did arithmetic. They needed something faster. Tera

By 1943, the Allied code-breakers at Bletchley Park faced an impossible bottleneck. The German military's Lorenz cipher was fiendishly complex. Even after the mathematical method for breaking it was worked out, applying it by hand was agonizingly slow.

Tommy Flowers, a 38-year-old Post Office engineer, proposed a radical solution: build an electronic machine using vacuum tubes β€” glass bulbs that could switch electrical signals thousands of times per second. His bosses were skeptical. Flowers persisted, partly funding the work out of his own pocket.

In December 1943, Colossus Mark 1 became operational. It used approximately 1,500 vacuum tubes and could process 5,000 characters per second β€” reading encrypted messages from a paper tape racing through at 30 miles per hour.

COLOSSUS (Bletchley Park, 1943–1945) β”œβ”€β”€ Designer: Tommy Flowers (Post Office engineer) β”œβ”€β”€ Purpose: Breaking the Lorenz cipher β”œβ”€β”€ Technology: 1,500 vacuum tubes (Mk 1), 2,400 (Mk 2) β”œβ”€β”€ Speed: 5,000 characters/second β”œβ”€β”€ Limitation: Special-purpose β€” Lorenz work only β”œβ”€β”€ Fate: Classified. Dismantled. Secret until 1970s. └── Total built: 10 Colossus machines by end of war
Colossus proved that electronic computation could work at scale. Thousands of vacuum tubes, running together, doing in hours what humans needed weeks to accomplish. The machine was secret. The principle was not: electronics could replace human calculation.

After the war, Colossus was classified. Tommy Flowers was sworn to secrecy and could not claim credit for decades. He received a modest award of Β£1,000 β€” not even enough to cover what he had spent from his own savings.

Colossus was special-purpose β€” it could do one thing. Across the Atlantic, American engineers were building something more ambitious: a machine that could be reprogrammed for any calculation. It would weigh 30 tons.

Seventeen Thousand Tubes
Look at this thing. ENIAC was 80 feet long, 8 feet tall, and weighed 30 tons. 17,468 vacuum tubes. 70,000 resistors. 5 million hand-soldered joints. It consumed 150 kilowatts of power. When they turned it on, legend says the lights in an entire Philadelphia neighborhood dimmed. Tera ENIAC β€” University of Pennsylvania, 1945 person 80 feet long Β· 30 tons Β· 17,468 vacuum tubes

J. Presper Eckert (just 24 when the project began) and John Mauchly (36) built ENIAC at the University of Pennsylvania. Completed in late 1945, it was the first large-scale, general-purpose electronic computer.

ENIAC could perform 5,000 additions per second. A trajectory calculation that took a human 20 hours could be done in 30 seconds.

But there was a catch. To "program" ENIAC, you physically rewired the machine. Programming meant rearranging cables and setting switches β€” a process that could take days or weeks. The computation itself took seconds. Setting it up took forever.

ENIAC (University of Pennsylvania, 1945) β”œβ”€β”€ Designers: J. Presper Eckert & John Mauchly β”œβ”€β”€ Technology: 17,468 vacuum tubes β”œβ”€β”€ Size: 80ft long Γ— 8ft tall Γ— 3ft deep β”œβ”€β”€ Weight: ~30 tons (27,000 kg) β”œβ”€β”€ Power: 150 kilowatts β”œβ”€β”€ Speed: 5,000 additions/second β”œβ”€β”€ Cost: ~$500,000 (~$7M today) β”œβ”€β”€ Programming: Physical rewiring (cables + switches) β”‚ β†’ Changing the program: DAYS β”‚ β†’ Running the program: SECONDS └── Reliability: A tube burned out ~every 2 days

ENIAC was built by Eckert and Mauchly. But who PROGRAMMED it? Not the men. The job of making ENIAC actually work was given to six women β€” and then history forgot their names.

The Women Who Were Computers
Before 'computer' meant a machine, it meant a PERSON. The people who programmed ENIAC β€” who figured out how to make this 30-ton machine actually solve problems β€” were six women mathematicians. They were brilliant. They were essential. And history nearly erased them. Tera

In the 1940s, the word "computer" referred to a person β€” usually a woman β€” who performed mathematical calculations by hand. When ENIAC was built, the engineering leadership considered hardware the "real" work. Programming was seen as clerical. So the job was given to six women:

Jean Jennings Bartik Led the programming team. Later worked on BINAC, UNIVAC. Kay McNulty Born in Ireland. Specialist in trajectory calculations. Betty Holberton Later helped develop COBOL and wrote first sort-merge program. Marlyn Meltzer Computed ballistics trajectories. Ruth Lichterman Trained next generation of programmers on ENIAC. Frances Spence Specialist in ENIAC's master programmer unit.

These six women received no manual β€” because none existed. They studied ENIAC's wiring blueprints, understood its architecture from the ground up, and invented programming techniques as they went.

When ENIAC was publicly demonstrated on February 14, 1946, the women were not introduced. For decades, they were uncredited or identified only as "refrigerator ladies" β€” assumed to be models posing next to the machine. It was not until the 1980s and 1990s that their contributions were recognized.

Programming was invented before it had a name. The ENIAC women didn't just follow instructions β€” they created the discipline of programming from scratch. They broke problems into steps, managed data flow, and debugged a machine with 17,468 vacuum tubes and no error messages. Every programmer today stands on their shoulders.
Think About It: The ENIAC women were left out of history for decades because their work was classified as "clerical" rather than "engineering." Why do you think certain kinds of work get labeled as less important? How does that shape whose stories get told?
The Blueprint Inside the Machine
Remember the Universal Turing Machine from Issue 1? One machine that can be ANY machine β€” because the program is just data on the tape? John von Neumann realized: THAT'S how you should build a real computer. Store the program IN MEMORY, alongside the data. Tera

John von Neumann was possibly the most brilliant mathematician alive by the mid-1940s. Born in Budapest in 1903, he made foundational contributions to quantum mechanics, game theory, and set theory β€” all before age 40.

In 1944, von Neumann visited the ENIAC project. He immediately grasped both its power and its critical limitation: the machine was fast, but changing what it did was agonizingly slow.

Von Neumann had read Turing's 1936 paper. He understood the Universal Turing Machine. The insight was radical in its simplicity: store the program in the same memory as the data.

BEFORE (ENIAC-style) To change the program: REWIRE THE MACHINE Cables Switches Patch Reprogram: DAYS to WEEKS Run program: seconds AFTER (stored-program) To change the program: WRITE NEW NUMBERS INSTRUCTIONS DATA Both live in the SAME memory Reprogram: MINUTES Same hardware. Different software. Forever.
The stored-program concept is the reason you can install new apps on your phone. The hardware doesn't change β€” the instructions in memory do. Von Neumann (building on Turing's insight) turned computers from expensive, single-purpose calculators into general-purpose machines that could do anything, just by loading different software.

A critical note: the ideas were developed collaboratively with Eckert, Mauchly, and others. The stored-program concept is often called the "von Neumann architecture," but it built on work by Turing, Eckert, Mauchly, and others.

The first machine to actually run a stored program was the Manchester Baby (SSEM), built by Frederic Williams and Tom Kilburn, on June 21, 1948. In Cambridge, Maurice Wilkes built EDSAC, which became the first practical stored-program computer designed for regular use in May 1949.

Store the program in memory. Brilliant. But HOW do you organize the machine to make this work? Von Neumann drew a diagram β€” five boxes and some arrows β€” that still describes every computer you have ever used.

Five Boxes That Run the World
This is it. The design that runs the world. Five components. Every computer you've ever touched follows this basic layout. Von Neumann described it in 1945. It is still the blueprint. Tera THE VON NEUMANN ARCHITECTURE (1945 β€” still used today) MEMORY UNIT INSTRUCTIONS DATA data bus CENTRAL PROCESSING UNIT (CPU) CONTROL UNIT Fetches & decodes instructions ALU Does the actual math I/O bus INPUT / OUTPUT INPUT Keyboard, mouse, camera OUTPUT Screen, speakers, printer

The elegance of this design is that it separates what the machine does (defined by the program in memory) from how the machine is built (the hardware). Build the hardware once. Change the software forever.

Step 0 / 3
The von Neumann architecture is the most successful engineering blueprint in history. Every general-purpose computer since 1945 follows this basic design: memory holds both programs and data; the CPU fetches, decodes, and executes instructions; input/output connects the machine to the world. Five boxes. Some arrows. The foundation of the digital age.
Think About It: Your phone follows the von Neumann architecture. Its memory holds both apps (programs) and your photos (data). Its CPU executes instructions billions of times per second. Can you trace the five components in a device you use every day?
Smaller, Faster, Cooler
Vacuum tubes worked. But imagine running your house on candles when someone just invented the light bulb. In 1947, three physicists at Bell Labs invented a replacement. They called it the transistor. Tera VACUUM TUBE (1940s) Size: thumb-sized Power: high (lots of heat) Reliability: burns out in months Speed: fast (for the era) Contains: vacuum, glass, heated filament TRANSISTOR (1947+) (actual size β†’) Β· Size: tiny (eventually microscopic) Power: very low (cool to the touch) Reliability: lasts essentially forever Speed: faster (and keeps getting faster) Contains: semiconductor (silicon)

On December 23, 1947, at Bell Labs in New Jersey, John Bardeen, Walter Brattain, and William Shockley demonstrated the first working transistor. A small electrical signal at one terminal could control a much larger current flowing between the other two. ON/OFF. 1/0. A switch β€” with no vacuum, no filament, no glass bulb, and almost no heat.

They received the Nobel Prize in Physics in 1956. By the late 1950s, transistors had begun replacing vacuum tubes in computers.

The transistor didn't change what computers could compute β€” Turing had already defined that in 1936. It changed what was physically possible to build. Smaller switches meant smaller machines. Less heat meant more switches packed together. The transistor turned computing from a room-sized activity into something that could eventually fit in your pocket.
A Thousand Transistors on a Fingertip
Each transistor was still a separate component, wired together by hand. Engineers called this the 'tyranny of numbers.' Two people, working independently, solved this in the same way. Sound familiar? Tera

In 1958, Jack Kilby at Texas Instruments built the first integrated circuit (IC): all components fabricated from a single piece of semiconductor material. Independently, Robert Noyce at Fairchild Semiconductor had the same idea β€” with a better manufacturing process. Both are credited as co-inventors.

THE SHRINKING COMPUTER YEAR MACHINE TRANSISTORS SIZE 1945 ENIAC 17,468 vacuum tubes Fills a room (30 tons) 1947 First transistor 1 switch Thumbnail 1958 First IC (Kilby) ~1 transistor + components Fingertip 1971 Intel 4004 (1st CPU) 2,300 transistors Fingernail 2020s Modern phone chip ~15 BILLION Postage stamp Moore's Law: transistor count doubles roughly every 2 years. This held for 50+ years.
The integrated circuit solved the tyranny of numbers by putting everything on one chip. The transistor made computers smaller. The IC made them scalable. Together, they set computing on an exponential growth curve that continued for over sixty years.
A Nightmare in Binary
We did it. We went from pure math to room-sized vacuum-tube computers, to transistors, to integrated circuits β€” all in about twenty years. But here's the thing nobody talks about: these machines were almost IMPOSSIBLE to use. Programming meant writing in raw binary. The human problem was just beginning. Tera

By the late 1950s, talking to a computer meant speaking its language β€” binary. Every instruction, every piece of data had to be expressed as patterns of 1s and 0s:

PROGRAMMING IN BINARY (machine code): To add two numbers at addresses 12 and 13, and store the result at address 14: 00010001 00001100 ← Load address 12 00010010 00001101 ← Add address 13 00010011 00001110 ← Store at address 14 One mistyped bit = a broken program. Finding the error? Good luck. ───────────────────────────────────────── THE SAME PROGRAM, in a human-readable language (preview of Issue 3): RESULT = A + B One line. Crystal clear. A "compiler" translates it into binary for you.

The machines were ready. The human interface was not. What computing needed was not faster hardware β€” it needed a way for humans and machines to communicate. A bridge between human thought and machine code.

In twenty years (1936–1958), computing went from theory on paper to millions of components on a chip. The hardware pioneers solved three fundamental problems: they made electronic computation work (vacuum tubes), designed a universal architecture (von Neumann), and made components small and reliable (transistors and ICs). But the hardest problem β€” making computers usable by ordinary humans β€” was still ahead.
Think About It: Every layer of computing technology solved one problem and revealed the next. Vacuum tubes proved electronics could compute but were unreliable. Transistors fixed reliability but created wiring complexity. ICs fixed wiring but computing was still locked in binary. Why do you think progress often works this way β€” solving one problem only to uncover a deeper one?
Next Issue: The quest to make machines understand us. From binary to English, from machine code to programming languages. Issue 3: "Teaching Machines to Understand Us" β†’

References & Further Reading