Batch 01: Origins

You don't need a single line of code to start here. This batch takes you on a 5-chapter, 28-episode journey — from ancient civilizations counting grain to the transistors powering every AI model alive today. History, science, and wonder — all in one.

A Journey in Five Acts

Each chapter is a self-contained story. Together they answer the most fundamental question in computing: how did humans teach machines to think?

"We understand something only when we've seen it emerge from nothing. This batch starts at nothing."

The Year-by-Year Timeline

Every major leap in computing — from the abacus to the AI — mapped chronologically. Scroll right to travel through time.

← Scroll to explore 5,000 years →

Why Humans Started Computing

Before code, before computers, before electricity — humans needed to count. Trade, taxes, astronomy, and survival drove the invention of the first calculating tools. This chapter shows where the need came from, and how ancient humans solved it with genius.

Why do we count? Why do we need math at all? This episode traces the fundamental human need behind all of computation — trading grain, dividing land, predicting seasons. Told like a story, not a lecture.

The abacus wasn't just a toy. It was enterprise software for ancient traders. The Inca Quipu stored census data in knots. Tally sticks were financial instruments used by the British Treasury until 1826. We meet the world's first computing devices.

Pulled from a Greek shipwreck in 1901 — a 2,000-year-old bronze device with 37 interlocking gears that predicted solar eclipses, moon phases, and Olympic games schedules. It is the most sophisticated machine made before the Industrial Revolution. Why was this genius forgotten for 1,500 years?

The word "Algorithm" comes directly from "Al-Khwarizmi" — a Persian mathematician who wrote a book on systematic problem-solving in 830 CE. We also meet Al-Jazari, the inventor of programmable machines. The Islamic Golden Age gave us the mathematical foundation for all computing.

Fibonacci's Liber Abaci (1202) introduced the 0–9 numeral system to Europe — the same system your computer uses. John Napier invented logarithms in 1614 to make multiplication as easy as addition. These tools accelerated science by centuries and planted the seeds of computing.

The Mechanical Age — Gears, Punch Cards & Ada Lovelace

The 1600s–1900s saw humans try to build machines that could calculate. Pascal built one at 19 to help his tax-collector father. Babbage dreamed of a steam-powered programmable computer — 100 years before electricity. Ada Lovelace wrote the first program for a machine that was never built.

Blaise Pascal was 18 years old and watching his father do tax calculations by hand every night. So he built a machine. The Pascaline: brass wheels, gears, and the first carry-mechanism — adding numbers automatically. Only 50 were ever made. It was too expensive to run.

In 1801, Jacquard built a loom that wove complex silk patterns automatically — controlled by a series of punch cards with holes that directed needles. Each card was a line of code. Each hole was a binary instruction. Babbage saw it and had an idea that changed the world.

Charles Babbage designed two revolutionary machines in the 1800s: the Difference Engine (a calculating machine) and the Analytical Engine (a general-purpose programmable computer). Both used thousands of brass gears and wheels. Neither was ever completed in his lifetime. But every modern computer is built on his vision — exactly.

Ada Lovelace — daughter of Lord Byron, friend of Charles Babbage — wrote detailed notes for his Analytical Engine in 1843 that included the first ever algorithm intended to be processed by a machine. She also saw something Babbage didn't: that the machine could do more than numbers. It could manipulate symbols. That insight is what makes computers universal.

George Boole was a self-taught mathematician from Lincoln who had no university degree. In 1847, he published "The Mathematical Analysis of Logic" — reducing all logical reasoning to TRUE and FALSE, AND/OR/NOT. At the time, it seemed purely theoretical. 90 years later, Claude Shannon proved it could control electronic circuits. Boolean logic became the DNA of all computing.

The 1880 US Census took 8 years to manually tabulate. With a population growing fast, the 1890 Census was projected to take 13 years — past the next census. Herman Hollerith built a punch-card tabulating machine that processed 65 million records in just 2.5 years. His company later became IBM. Data processing at scale was born.

The Electronic Revolution — Turing, Shannon & ENIAC

The 1930s–1950s compressed more invention into 20 years than the previous 3,000. Alan Turing defined what computation even means. Claude Shannon connected math to electricity. And then the world built actual electronic computers — first to crack codes, then to conquer space. Everything you know today came from these two decades.

Alan Turing — 23 years old, never built anything physical — published a thought experiment in 1936 that defined what computation fundamentally IS. The Turing Machine: an infinite tape, a read/write head, and a rulebook. Any problem solvable by an algorithm can be solved by this machine. This is why computers can run ANY program. We also cover the Halting Problem — a problem no computer can ever solve.

Claude Shannon had two moments of genius that deserve Nobel Prizes. In 1937 (his master's thesis!), he proved Boolean algebra could control electrical relay circuits — making digital electronics possible. In 1948, he published Information Theory — defining what a "bit" is, how information can be measured, compressed, and transmitted. He basically invented the internet before the internet existed.

COLOSSUS (1943) was built in secret at Bletchley Park to crack Nazi Enigma codes — 1,500 vacuum tubes, it reduced code-breaking from weeks to hours. ENIAC (1946) was the first general-purpose computer — 18,000 vacuum tubes, 30 tons, 1,800 sq ft, using as much power as a city block. The women who programmed ENIAC — the "ENIAC Six" — were the first professional programmers in history.

In 1945, John von Neumann wrote a report that defined the blueprint for all modern computers: a CPU, a Memory Unit, an Input Device, and an Output Device — all connected and able to store programs in memory (not just data). The "stored-program" concept is what makes computers programmable. Before this, you changed the program by rewiring the hardware. After this, you write code.

Three scientists at Bell Labs — Shockley, Bardeen, and Brattain — invented the transistor in December 1947. It replaced vacuum tubes (hot, fragile, huge) with solid-state switches (tiny, cool, reliable). One modern AI chip (H100) contains 80 billion transistors. The transistor is the most manufactured artifact in human history — trillions made every year.

A dedicated deep-dive into Shannon's Information Theory — what a bit actually is, what "entropy" means in information, why data can be compressed, how error correction works, and why all of this is fundamental to AI (which learns by measuring information, uncertainty, and surprise).

The CS Era Begins — Languages, Internet & Personal Computers

From 1950 to 1995: the computer went from room-sized to pocket-sized. Programming languages were invented, the internet was born, and Steve Jobs walked into a Xerox lab and saw the future. This chapter covers the most dramatic 45 years in technological history — the era where Computer Science became a real discipline.

1947: transistor invented. 1958: integrated circuit (chip). 1965: Moore's Law. 1971: the first microprocessor (Intel 4004). In 24 years, computers went from filling rooms to fitting on a chip smaller than a fingernail. How? And what does Moore's Law actually mean for AI today?

Before FORTRAN (1957), programming meant flipping physical switches or writing in machine code — pure binary. FORTRAN let scientists write math. COBOL (invented by Grace Hopper) let businesses write in near-English. LISP (invented for AI research) was recursive, symbolic, and still influences modern AI. We trace how programming languages evolved from machine code to Python — and why they had to.

October 29, 1969: the first message ever sent between two computers. "LO" — the system crashed before completing "LOGIN." That message connected UCLA to Stanford — 4 universities on a network called ARPANET. The goal was a nuclear-proof communication system for the US military. What emerged was the internet. We trace how ARPANET → TCP/IP → internet → World Wide Web.

1975: Bill Gates and Paul Allen license BASIC to MITS Altair — the first personal computer. 1977: Apple II goes on sale — the first mass-market personal computer. 1981: IBM PC with MS-DOS. 1984: Apple Macintosh, the first GUI computer. The story of how computing went from government labs to living rooms — and what that meant for software as a business.

The internet existed in 1989. But it had no easy way to navigate. Tim Berners-Lee — a physicist at CERN — invented three things that built the web: HTTP (how browsers request pages), HTML (how pages are structured), and URLs (how everything is addressed). And he gave it away for free. The web turned the internet from a research tool into the medium of human civilization.

Google's PageRank (1998) introduced algorithmic ranking — a machine deciding what's important based on data patterns. The iPhone (2007) put a computer in every pocket and created sensors generating petabytes of data daily. Social media created behavioral data. The internet became a data machine — and all that data was exactly what AI would need to learn from.

How Modern CS Actually Works — From Transistors to AI

The final chapter closes the loop. We go inside a modern computer and connect every historical concept to the physical hardware and software you use today. Binary, logic gates, CPU cycles, memory hierarchy, operating systems — and then the giant leap to AI. By the end, you know how a neural network actually runs on your hardware.

Binary, Decimal, Hexadecimal. How text is encoded as ASCII/UTF-8. How images are pixel grids of RGB numbers. How audio is sampled amplitude values. How video is moving images. Everything digital is numbers. This episode shows you exactly how and why — with visual animations for every concept.

AND, OR, NOT gates → Half Adder → Full Adder → ALU → CPU. This is the full chain from a single logic gate to a working arithmetic unit — fully animated. We build a 1-bit adder and a 4-bit ALU from scratch with logic gate animations. This is where abstract Boolean logic becomes something you can draw on paper.

Why does your computer have RAM AND storage? Why is there L1, L2, L3 cache? Why can't everything just be RAM? This episode visualizes the memory hierarchy pyramid — from registers (fastest, tiniest) to cache to RAM to SSD to HDD — explaining speed, size, cost, and volatility tradeoffs with real latency numbers and animated diagrams.

What does an operating system actually do? Process scheduling, memory management, file systems, device drivers, system calls — explained with animations. Why Linux dominates servers and cloud (and therefore AI). What happens in the 0.3 seconds between pressing the power button and your desktop appearing. The OS is the software that makes all other software possible.

The final episode of Batch 01 — a grand synthesis. We trace the unbroken line from the Antikythera Mechanism to AlexNet to ChatGPT. AlexNet (2012) won ImageNet using GPUs and deep learning — starting the modern AI era. Attention mechanisms (2017) enabled Transformers. The data, compute, and algorithm breakthrough all arrived simultaneously. And now you're here — ready to build with it. Your roadmap for the next 10 batches is laid out.

5,000 Years — The Year Map

Every major milestone covered in Batch 01, organized chronologically with context, people, and why it matters to AI today.

Skills That Stick Forever

This isn't trivia. These are frameworks for thinking about computation that will inform every line of code you write for the rest of your career.

Understand Binary & How Data is Represented

Read binary, convert to hex, understand how text, images, audio, and video are stored as numbers — the foundation of all data engineering and AI inputs.

Explain How a CPU Works — From Gates to Execution

Trace the path from Boolean logic gate → adder → ALU → CPU → machine instruction → program execution. Know what happens when code runs.

Understand Memory Hierarchy & Performance

Know why RAM, cache, and storage are different. Explain why "cache miss" is slow, why GPU VRAM matters for AI, and why memory bandwidth constrains model size.

Trace 5,000 Years of Computing History

Connect every modern concept to its historical origin. Explain why Boolean algebra from 1847 is in ChatGPT. Tell the story of computing with precision and passion.

Understand What AI Is — At the Foundation Level

Know that AI models are math on hardware. Trace how AlexNet → Transformers → LLMs built on top of everything in this batch. No more mysticism about AI.

Talk Like a Computer Scientist

Use terms correctly: algorithm, bit, binary, boolean, transistor, compiler, operating system, TCP/IP, Von Neumann architecture. Understand what engineers mean when they use these words.

What Comes After Batch 01

Batch 01 is the foundation. Everything that follows builds directly on the concepts introduced here. Here's the full journey:

History to CS Fundamentals

Python for AI Engineers

Learn the language of AI from zero

Data Structures & Algorithms

The engine of every program

Mathematics for AI

Linear algebra, calculus, probability

Machine Learning Foundations

Where computing becomes intelligence

Generative AI & LLMs

Build with ChatGPT-class models

5,000 Years of Genius. Free. On YouTube.

The most complete, beautifully animated history of computing ever put on YouTube — from a civilization's first tally stick to the transistors powering the AI models of 2026. Start anywhere. Start now.