Skip to content
Software Atlas

How software got here · 1945–2025

The Story of Software

60 milestones, from the first stored-program computers to AI agents. What each one solved, why it still matters, and where to learn it, with sources.

Start in 1945
’40’50’60’70’80’90’00’10’20

1940s· Stored programs

Chapter 11940s

Stored programs · 2 milestones

The idea of keeping a program in memory is written down, and a machine runs one.

  1. Foundation for
    Computers & OS

    The stored-program design is written down

    Black-and-white photo of a long room lined with ENIAC's cabinets and patch cables; a man and a woman stand among the panels, setting it up.
    ENIAC, Eckert and Mauchly's earlier machine, being programmed by Glen Beck and Betty Snyder, late 1940sPhoto: U.S. Army (source file on Wikimedia Commons, opens in a new tab), Public domain

    John von Neumann's “First Draft of a Report on the EDVAC” described a computer that keeps its program in the same memory as its data. Until then, changing what a machine computed could mean rewiring it; a stored-program machine just loads different instructions. J. Presper Eckert and John Mauchly, the engineers behind ENIAC (an earlier electronic computer), weren't named in the draft but shared in the ideas, and historians now credit them too.

    Still matters
    Almost every computer since, including your laptop and phone, follows this design, often still called the “von Neumann architecture”.
    Learn it
    Numbers in Computers · Bits, binary and hex in five minutesCPU Caches · L1, L2, L3 and the 64-byte cache line
    Led to
    Manchester Baby1948Hopper's A-01952Time-sharing (CTSS)1961
    Sources
    Computer History Museum: First Draft of a Report on the EDVAC (opens in a new tab)Smithsonian Libraries: First Draft of a Report on the EDVAC (1945) (opens in a new tab)
  2. Foundation for
    Computers & OSTry it below

    The Manchester “Baby” runs a stored program

    A row of tall open metal racks full of valves and wiring against a red wall, with a small round screen in the middle rack.
    Replica of the Manchester Baby at the Science and Industry Museum, ManchesterPhoto: Logg Tandy (source file on Wikimedia Commons, opens in a new tab), CC BY 4.0

    At the University of Manchester, Frederic Williams, Tom Kilburn and Geoff Tootill's Small-Scale Experimental Machine ran a program held in its own electronic memory: 32 numbers (“words”) of 32 bits each, stored as dots on a TV-like cathode-ray tube. Kilburn's first program, 17 instructions long, searched for the largest number smaller than a given number that divides it exactly (its highest proper factor) and ran for about 52 minutes.

    Try it · flip the switches (each is worth double the one to its right)

    00101010 = 32 + 8 + 2 = 42

    Still matters
    It proved the stored-program idea works in practice. Every program you run is still a list of instructions and data written as 1s and 0s in memory.
    Learn it
    Numbers in Computers · Bits, binary and hex in five minutesNumbers in Computers · Fixed-width integers and negative numbers
    Built on
    EDVAC report1945
    Sources
    University of Manchester: How a 70-year-old ‘Baby’ changed the face of modern computing (opens in a new tab)Computer Conservation Society: the Manchester SSEM (opens in a new tab)

Next1950s The first languages

Chapter 21950s

The first languages · 6 milestones

Compilers and the first languages let people write formulas instead of machine code, and AI gets its name.

  1. Foundation for
    AI

    Turing asks: can machines think?

    In “Computing Machinery and Intelligence”, published in the journal Mind, Alan Turing replaced the vague question “can machines think?” with a test he called the imitation game: can a machine hold a typed conversation well enough that a judge can't reliably tell it from a person?

    Still matters
    The question is back in daily life: chat assistants built on large language models talk fluently, and the hard part is now judging whether what they say is true, which is what LLM evaluation is about.
    Learn it
    How LLMs WorkEvaluating LLM Apps
    Led to
    Dartmouth workshop1956
    Source
    Turing, “Computing Machinery and Intelligence”, Mind 59 (1950) (opens in a new tab)
  2. Foundation for
    Languages

    Grace Hopper's A-0: programs that write programs

    A wide grey operator's console covered in rows of switches and lights, with a typewriter-style keyboard in front.
    A UNIVAC I console (1951), the machine A-0 was written for, at the Computer History MuseumPhoto: The wub (source file on Wikimedia Commons, opens in a new tab), CC BY-SA 4.0

    Grace Hopper's A-0 system for the UNIVAC I let programmers call ready-made routines by a short code instead of writing every machine instruction by hand; the computer assembled the full program. It is often called an early compiler; historians note it worked more like today's linker, which joins ready-made pieces of code into one program. Her later FLOW-MATIC (around 1957) used English words such as ADD and COMPARE and fed into COBOL.

    Still matters
    The idea that a program can translate your code into machine code is behind every compiler and build tool you use.
    Learn it
    Build Tools & Bundlers · Transpiling TypeScript and JSX
    Built on
    EDVAC report1945
    Led to
    FORTRAN1957COBOL1959
    Sources
    Computer History Museum: Higher-level languages (opens in a new tab)Yale News: Grace Murray Hopper (1906–1992), a legacy of innovation and service (opens in a new tab)
  3. Foundation for
    AI

    “Artificial intelligence” gets its name

    A metal maze with low walls on top of an open wooden cabinet full of relays and wiring; a small toy mouse sits inside the maze. It is in a museum display case.
    Theseus, the maze-solving mouse Claude Shannon (one of the four proposers) built with Betty Shannon in 1950, at the MIT MuseumPhoto: Nickknack00 (source file on Wikimedia Commons, opens in a new tab), CC BY 4.0

    John McCarthy, Marvin Minsky, Nathaniel Rochester and Claude Shannon proposed a summer research project at Dartmouth College, coining the term “artificial intelligence” in their August 1955 proposal. The workshop ran in the summer of 1956 and turned AI into a research field of its own.

    Still matters
    It set the goal the field has chased for 70 years. Today's LLMs come from one of its branches: machines that learn from data.
    Learn it
    How LLMs Work
    Built on
    Turing's paper1950
    Led to
    LISP1958Backpropagation1986
    Sources
    McCarthy et al., A Proposal for the Dartmouth Summer Research Project on AI (31 Aug 1955), Stanford copy (opens in a new tab)AI Magazine reprint of the 1955 proposal (opens in a new tab)
  4. Foundation for
    Languages

    FORTRAN: formulas instead of machine code

    Black-and-white photo: a woman seated in front of an IBM 704's console feeds punched cards into a reader while a man inspects the wiring of an open cabinet behind her.
    An IBM 704 used for aeronautical research at NACA's Langley laboratory, 1957Photo: NASA (source file on Wikimedia Commons, opens in a new tab), Public domain

    IBM delivered the first FORTRAN compiler for its 704 computer, built by John Backus's team. Scientists could write a formula like Y = A*X + B and the compiler produced machine code nearly as fast as hand-written code, which convinced skeptics that high-level languages were practical.

    Still matters
    It showed a compiler could produce code nearly as good as hand-written machine code; today's optimizing compilers usually match or beat what most people would write by hand. FORTRAN (now Fortran) still runs weather and physics simulations.
    Learn it
    Numbers in Computers · Floating point: scientific notation in binary
    Built on
    Hopper's A-01952
    Led to
    LISP1958
    Sources
    IBM History: Fortran (opens in a new tab)Backus, “The History of FORTRAN I, II, and III” (1978) (opens in a new tab)
  5. Foundation for
    Languages

    LISP, and memory that cleans up after itself

    Close-up of an older man with white hair, a white beard and heavy black glasses, talking outdoors.
    John McCarthy in 2006Photo: null0 (source file on Wikimedia Commons, opens in a new tab), CC BY-SA 2.0

    John McCarthy began LISP at MIT in 1958 for AI research and described it in a 1960 paper. Programs and data are both written as lists, and the language introduced automatic garbage collection: when free memory runs out, find everything still in use and reclaim the rest, so programmers no longer free memory by hand.

    Still matters
    Garbage collection came from LISP, and so did the read-eval-print loop (the interactive prompt you get when you type node or python). JavaScript, Go, Java and Python all collect garbage for you, and all let you pass functions around as values, an idea LISP made practical.
    Learn it
    Garbage Collection · Mark & sweepGarbage Collection · Garbage = unreachable
    Built on
    FORTRAN1957Dartmouth workshop1956
    Led to
    Java1995MapReduce2004
    Sources
    McCarthy, “History of Lisp” (opens in a new tab)McCarthy, “Recursive Functions of Symbolic Expressions and Their Computation by Machine” (CACM, 1960) (opens in a new tab)
  6. Foundation for
    Languages

    COBOL: one business language for many machines

    Official portrait of an elderly woman in a US Navy commodore's uniform and cap, arms folded, beside an American flag.
    Grace Hopper, whose FLOW-MATIC fed into COBOL, as a US Navy commodore in 1984Photo: James S. Davis (source file on Wikimedia Commons, opens in a new tab), Public domain

    A meeting at the Pentagon in May 1959 started a committee (CODASYL) to design a common business language that would run on computers from different makers. Drawing on Hopper's FLOW-MATIC and IBM's COMTRAN, its specification was published as COBOL 60, with English-like statements such as ADD PRICE TO TOTAL.

    Still matters
    It made code portable between vendors' machines, and huge amounts of COBOL still process bank and government records, using exact decimal arithmetic for money (unlike JavaScript numbers, where 0.1 + 0.2 isn't exactly 0.3).
    Learn it
    Numbers in Computers · Money is never a float
    Built on
    Hopper's A-01952
    Source
    Sammet, “The Early History of COBOL” (HOPL, 1978) (opens in a new tab)

Next1960s Sharing machines, linking them

Chapter 31960s

Sharing machines, linking them · 7 milestones

Computers learn to share: many users on one machine, and the first network messages.

  1. Foundation for
    Computers & OS

    Time-sharing: one computer, many users at once

    A grey IBM operator's console with rows of small round lights and a line of grey and white switches along the front.
    An IBM 7094 console, a machine from about 1962. CTSS debuted on an IBM 709 and later ran on 7090s and 7094sPhoto: ArnoldReinhold (source file on Wikimedia Commons, opens in a new tab), CC BY 4.0

    Fernando Corbató's team at MIT first demonstrated the Compatible Time-Sharing System, one of the first time-sharing systems. Instead of handing in a job and waiting hours for the printout, several people typing at terminals (a keyboard plus a printer or screen) shared one computer, which switched between their programs so quickly that each seemed to have it alone.

    Still matters
    Your operating system does exactly this with your apps: its scheduler gives each process tiny slices of the CPU, many times a second.
    Learn it
    Threads vs Processes · The OS scheduler: who gets a coreThreads vs Processes · Context switches: what a swap really costs
    Built on
    EDVAC report1945
    Led to
    Engelbart's demo1968Unix1969
    Sources
    Saltzer, “Fernando J. Corbató 1926–2019” (MIT) (opens in a new tab)Van Vleck, “The IBM 7094 and CTSS” (opens in a new tab)
  2. Foundation for
    Computers & OS

    ASCII: one code for text

    Close-up of a cream-coloured Teletype terminal: a sheet of paper curls out of it, printed in capital letters with rows of characters.
    A Teletype Model 33, a terminal that used ASCII (at a computer festival in Berlin, 2014)Photo: Kai Wegner (source file on Wikimedia Commons, opens in a new tab), CC BY 2.0

    The American Standards Association published ASCII (X3.4-1963), a 7-bit code with room for 128 characters (numbers 0 to 127), giving letters, digits and symbols agreed numbers so machines from different makers could exchange text. Each character fits in 7 bits and is usually stored in one 8-bit byte. Lowercase letters were added in a 1967 revision.

    Still matters
    UTF-8, the encoding of nearly every web page, keeps ASCII's first 128 codes unchanged, which is why plain English text is the same bytes in both.
    Learn it
    Text & Encodings · Bytes are just numbers: ASCIIText & Encodings · UTF-8: from code point to bytes
    Source
    NIST: Code for Information Interchange (ASCII) (opens in a new tab)
  3. Foundation for
    Web & networkingTry it below

    Packet switching: chop messages into pieces

    link downAB123message cut into packetsput back in order
    Diagram: a message cut into numbered packets that take different routes, even around a broken link, and are put back in order at the other end

    Paul Baran at RAND described a network that splits messages into small blocks, each finding its own way through many routes, so the network survives when links fail. Donald Davies at Britain's National Physical Laboratory reached the same idea independently in 1965 and named the pieces packets.

    Try it · send a message
    Split into packets#1HEL#2LO #3WOR#4LD!
    Arrive (any order)nothing yet
    Put back in order…

    Each packet carries a number, so the receiver can rebuild the message even when packets take different routes.

    Still matters
    The internet still works this way: every web page, video and API call travels as packets that may take different paths and get reassembled at the other end.
    Learn it
    TCP/IP & the OSI Model · Encapsulation: envelopes inside envelopesTCP/IP & the OSI Model · Routing: one hop at a time
    Led to
    ARPANET1969Ethernet1973TCP/IP1974
    Sources
    RAND: Paul Baran and the Origins of the Internet (opens in a new tab)Internet Society: A Brief History of the Internet (opens in a new tab)
  4. Foundation for
    Tools & practices

    “Software engineering” becomes a discipline

    A NATO conference in Garmisch, Germany, popularised the term “software engineering” on purpose: projects were running late, over budget and full of bugs (the “software crisis”), and the organisers argued that building software needed the discipline of other engineering fields.

    Still matters
    Testing, code review, design documents and estimates are all answers to the problems listed at that conference, and teams still wrestle with them.
    Learn it
    Why & What to TestClean / Hexagonal Architecture
    Led to
    Agile2001
    Source
    Randell: NATO Software Engineering Conferences (report and history) (opens in a new tab)
  5. Foundation for
    Computers & OS

    The demo: mouse, windows, links and video calls

    A small wooden box with one red button on top and a braided cable ending in a metal connector.
    Replica of Engelbart's prototype mouse (about 1964) at the Computer History MuseumPhoto: The wub (source file on Wikimedia Commons, opens in a new tab), CC BY-SA 4.0

    In San Francisco, Douglas Engelbart and his SRI team showed their NLS system live for 90 minutes: the public debut of their mouse, plus hypertext links, windows, shared editing and a video link to colleagues about 30 miles away.

    Still matters
    The way you use a computer, pointing, clicking links, editing a shared document on a call, was shown here decades before it was common.
    Learn it
    DOM Events · Events, listeners and their options
    Built on
    Time-sharing (CTSS)1961
    Led to
    The Web1989
    Sources
    Doug Engelbart Institute: The Demo (opens in a new tab)SRI: The computer mouse and interactive computing (opens in a new tab)
  6. Foundation for
    Computers & OSTry it below

    Unix: small tools that work together

    A row of blue metal cabinets with an open front, a round oscilloscope-style screen and tape drives, with cardboard boxes and papers on the desk in front.
    A DEC PDP-7, the model Unix was first written on: a modified one under restoration in Oslo, 2004Photo: Matias Fjeld (Matiashf) (source file on Wikimedia Commons, opens in a new tab), CC BY-SA 3.0

    Ken Thompson and Dennis Ritchie began writing Unix at Bell Labs in the summer of 1969, on a spare PDP-7 minicomputer (smaller and cheaper than the room-sized machines of the day). Two of its ideas spread far: devices such as disks and terminals are read and written like ordinary files, and small programs each do one job. Pipes, added in 1972–73 at Doug McIlroy's urging, connect them: one program's output becomes the next one's input.

    Try it · run a pipeline
    1. ls7 lines
    2. grep gomain.go · parse.go · server.go
    $ ls | grep go
main.go
parse.go
server.go

    Seven files in a folder. ls lists them · grep go keeps lines containing “go” (-v: the other lines) · wc -l counts lines · sort -r sorts in reverse. Each program does one job and passes its output to the next.

    Still matters
    Linux, macOS, Android and iOS all descend from Unix or copy its design, and the shell commands and pipes you type today work the way they did in the 1970s.
    Learn it
    The Command Line · Pipes and small toolsFile Descriptors & Sockets · stdin, stdout, stderr and the shellSystem Calls
    Built on
    Time-sharing (CTSS)1961
    Led to
    C1972GNU1983Linux1991Go2009
    Sources
    Ritchie, “The Evolution of the Unix Time-sharing System” (opens in a new tab)McIlroy, “A Research UNIX Reader” (on pipes) (opens in a new tab)
  7. Foundation for
    Web & networking

    ARPANET sends its first message

    A network diagram titled “ARPANET logical map, March 1977”: dozens of sites such as UCLA, SRI, MIT and Harvard, joined by lines, each listing its computers.
    ARPANET logical map, March 1977: the network about seven and a half years after the first messageMap: ARPANET (via the Computer History Museum) (source file on Wikimedia Commons, opens in a new tab), Public domain

    Student programmer Charley Kline in Leonard Kleinrock's lab at UCLA tried to log in to a computer at SRI, in northern California, over the new ARPANET. The system crashed after two letters, so the first message was “LO”; the full login worked about an hour later.

    Still matters
    ARPANET was the packet-switched network the internet grew from. Its habits, such as open specifications published for anyone to read (the RFCs, which still define internet standards), still shape it.
    Learn it
    TCP/IP & the OSI Model · Four layers that run, seven that we name
    Built on
    Packet switching1964
    Led to
    TCP/IP1974Lamport clocks1978
    Sources
    Kleinrock (UCLA): The Day the Infant Internet Uttered its First Words (opens in a new tab)SRI: ARPANET (opens in a new tab)

Next1970s Unix and the Internet

Chapter 41970s

Unix and the Internet · 8 milestones

Data moves into tables, Unix is rewritten in C, and separate networks join into one.

  1. Foundation for
    Databases

    B-trees: finding one row among millions, fast

    find 503060102025405055708090one node = one disk page · 2 reads find 50
    Diagram: a small B-tree. Each node is one disk page holding sorted keys, so finding 50 takes one read per level

    Rudolf Bayer and Edward McCreight, at Boeing's research labs, described the B-tree (published in a journal in 1972): a sorted tree whose nodes are wide enough to fill a whole page of the disk (the fixed-size block it reads in one go), so finding any value among millions takes only a few disk reads. It also stays balanced as you insert and delete: no branch grows much deeper than the others.

    Still matters
    Nearly every database index you create, in PostgreSQL, MySQL or SQLite, is a B-tree (or a close variant), and many file systems use them too.
    Learn it
    Indexes & B-Trees · Inside a B-treeTrees & Tries · Why balance matters
    Sources
    Bayer & McCreight, “Organization and Maintenance of Large Ordered Indices”, Acta Informatica (1972) (opens in a new tab)Rudolf Bayer, memoir (TU München) (opens in a new tab)
  2. Foundation for
    Databases

    Codd's relational model: data as tables

    employeesnamedeptAdaSalesLinResearchSamSalesKitSupportask for rows by value: dept = 'Sales'
    Diagram: data as a table. You ask for rows by their values, not by following pointers, and the database works out how to find them

    Edgar F. Codd at IBM published “A Relational Model of Data for Large Shared Data Banks”. Instead of programs following pointers from record to record in a fixed storage layout, data lives in tables, and you ask for rows by their values; the database decides how to find them, so the storage can change without breaking programs.

    Still matters
    PostgreSQL, MySQL, SQLite and every other relational database are built on this paper, and most apps you use store their data in one.
    Learn it
    SQL vs NoSQL · Tables, keys and joinsSQL vs NoSQL · Normalization: every fact in one place
    Led to
    SQL1974
    Source
    Codd, “A Relational Model of Data for Large Shared Data Banks”, CACM 13(6), 1970 (opens in a new tab)
  3. Foundation for
    Languages

    C: a language close to the machine

    A tall dark cabinet with a red front panel of switches and small lights labelled pdp11/40, in a museum.
    A DEC PDP-11/40 at the Technisches Museum Wien. C, and the C rewrite of Unix, were developed on PDP-11 computersPhoto: Jeff Keyzer (source file on Wikimedia Commons, opens in a new tab), CC BY-SA 2.0

    Dennis Ritchie developed C at Bell Labs, growing it out of Ken Thompson's B; 1972 was its key year. In 1973 they rewrote the Unix kernel in C. Because C wasn't tied to one processor's instruction set, Unix could later be moved to other kinds of computers: the first such ports, to Interdata minicomputers, came in 1977.

    Still matters
    Linux, the runtimes of Python and Node.js, and most databases are written in C or its descendant C++, and Go, Java and JavaScript borrowed its curly-brace syntax.
    Learn it
    Stack vs Heap · The call stack: a pile of framesSystem Calls · One syscall, step by step
    Built on
    Unix1969
    Led to
    GNU1983Python1991Linux1991Java1995Go2009Rust2015
    Sources
    Ritchie, “The Development of the C Language” (HOPL-II, 1993) (opens in a new tab)Ritchie & Thompson, “The UNIX Time-Sharing System” (CACM, 1974) (opens in a new tab)
  4. Foundation for
    Web & networking

    Ethernet: computers share one cable

    A cream-coloured computer with a tall portrait-shaped screen, a keyboard and a small three-button mouse, in front of a wall printed with program code.
    A Xerox Alto computer. Ethernet was built at Xerox PARC to link computers like this onePhoto: Maksym Kozlenko (source file on Wikimedia Commons, opens in a new tab), CC BY-SA 4.0

    At Xerox PARC, Bob Metcalfe wrote the memo proposing Ethernet, which he then built with David Boggs: a way for many computers in a building to share one cable. Each listens before sending, and backs off and retries if two collide. The experimental version ran at 2.94 megabits per second.

    Still matters
    Ethernet (now hundreds of thousands of times faster in data centres) and its wireless cousin Wi-Fi carry the first stretch of most connections from homes, offices and data centres.
    Learn it
    TCP/IP & the OSI Model · Down to the wire: MAC, ARP and MTU
    Built on
    Packet switching1964
    Sources
    Computer History Museum: Ethernet@50 (opens in a new tab)Metcalfe & Boggs, “Ethernet: Distributed Packet Switching for Local Computer Networks” (CACM, 1976) (opens in a new tab)
  5. Foundation for
    DatabasesTry it below

    SEQUEL, later SQL: asking the database in words

    Donald Chamberlin and Raymond Boyce at IBM described SEQUEL, a language for querying Codd's tables with English-like keywords, designed at IBM's San Jose lab and later built into its System R research database. Renamed SQL, it lets you say what you want and leaves the database to work out how to get it.

    Try it · ask the table a question
    SELECT name FROM people
WHERE city = 'New York';
    name
    Grace
    Ken

    A five-row people table (Ada, Linus, Grace, Ken, Margaret). You say what you want; the database works out how to get it. Written in today's SQL.

    Still matters
    SQL is still the everyday language of data, half a century on: in PostgreSQL, MySQL, SQLite, data warehouses and analytics tools.
    Learn it
    SQL vs NoSQL · Tables, keys and joinsIndexes & B-Trees · Reading EXPLAINInjection Attacks · SQL injection, one quote at a time
    Built on
    Relational model1970
    Led to
    Transactions1981
    Sources
    Chamberlin & Boyce, “SEQUEL: A Structured English Query Language” (ACM SIGFIDET workshop, 1974) (opens in a new tab)CACM: 50 Years of Queries (opens in a new tab)
  6. Foundation for
    Web & networking

    TCP: a protocol for a network of networks

    An older man with a white beard, in a grey suit and red tie, seated and looking towards the camera at a meeting.
    Vint Cerf, who wrote the paper with Bob Kahn, in Vilnius in 2010Photo: Veni Markovski (source file on Wikimedia Commons, opens in a new tab), CC BY 3.0

    Vint Cerf and Bob Kahn published “A Protocol for Packet Network Intercommunication”, a set of rules (a protocol) for connecting separate networks into one. The computers at each end, not the network, put packets back in order and resend lost ones. It was later split into TCP and IP (the part that addresses and routes each packet), and on 1 January 1983 the ARPANET switched over to them.

    Still matters
    Every web request, email and video call rides on TCP/IP or its younger relatives; it is the reason any device can reach any other.
    Learn it
    TCP/IP & the OSI ModelTCP vs UDP · Opening a connection: the three-way handshake
    Built on
    ARPANET1969Packet switching1964
    Led to
    DNS1983The Web1989TLS1999
    Sources
    Cerf & Kahn, “A Protocol for Packet Network Intercommunication”, IEEE Trans. Communications 22(5), May 1974 (opens in a new tab)RFC 801: NCP/TCP Transition Plan (1981) (opens in a new tab)
  7. Foundation for
    Web & networking

    Public-key cryptography: secrets without meeting first

    AliceBobpublic keyx9#Qf@…private key1 Bob shares his public key openly2 Alice locks her message with it3 only Bob's private key unlocks it
    Diagram: the public-key idea. Anyone may use Bob's public key to lock a message for him; only his private key unlocks it

    Whitfield Diffie and Martin Hellman's paper “New Directions in Cryptography” showed how two strangers can agree on a secret key over a channel everyone can read. It started public-key cryptography: each person has a public key that anyone may use to lock messages for them or to check their signatures, and a private key they keep to unlock those messages and to sign. In 1977 Rivest, Shamir and Adleman at MIT followed with RSA, which can also make digital signatures. (British intelligence had found similar ideas in secret earlier.)

    Still matters
    Every HTTPS connection starts with public-key cryptography, and signatures built on it protect the software updates you install.
    Learn it
    Hashing & Encryption · Key pairs: signatures and key agreementTLS & HTTPS · Agreeing on a secret in public
    Led to
    TLS1999
    Sources
    Diffie & Hellman, “New Directions in Cryptography” (IEEE Trans. Inf. Theory, 1976) (opens in a new tab)Rivest, Shamir & Adleman, “A Method for Obtaining Digital Signatures and Public-Key Cryptosystems” (opens in a new tab)
  8. Foundation for
    Distributed & cloud

    Lamport: ordering events without a shared clock

    P1P2P3t=1t=3122314on receive: max(own, message) + 1
    Diagram: logical clocks. Each process counts its events, every message carries the sender's count, and a receiver jumps past it

    Leslie Lamport's paper “Time, Clocks, and the Ordering of Events in a Distributed System” showed that machines on a network can't trust their clocks to agree. He defined “happened before” plus simple counters (logical clocks) to put events in order anyway, and sketched how to keep copies of the same data on several machines in step: run the same commands in the same order.

    Still matters
    Databases that keep copies on several machines, and algorithms like Raft (later on this page) that make those machines agree, start from this paper's way of thinking.
    Learn it
    Time, Clocks & Ordering · Order without clocks: happened-beforeTime, Clocks & Ordering · Lamport clocks
    Built on
    ARPANET1969
    Led to
    CAP2000Dynamo2007Raft2014
    Source
    Microsoft Research: Time, Clocks, and the Ordering of Events (with Lamport's notes) (opens in a new tab)

Next1980s The personal computer

Chapter 51980s

The personal computer · 6 milestones

Computers reach every desk, the network gets names instead of numbers, and the Web is proposed.

  1. Foundation for
    Computers & OS

    The IBM PC puts a computer on every desk

    A beige IBM Personal Computer: a system unit with two floppy drives, a monitor on top and a keyboard on a coiled cable.
    An IBM Personal Computer at the Musée Bolo, EPFL, LausannePhoto: Rama & Musée Bolo (source file on Wikimedia Commons, opens in a new tab), CC BY-SA 2.0 FR

    IBM announced its Personal Computer (model 5150) with an Intel 8088 processor, from $1,565 for a basic model; most buyers added floppy drives and Microsoft's PC DOS. It was built from off-the-shelf parts with published specifications, so other companies could make compatible machines, and “PC compatibles” became a huge market.

    Still matters
    The PC's open, compatible design is why one operating system can run on machines from many makers, and the processor family it used (x86: the 8088 was a cheaper variant of Intel's 8086) still powers most laptops and servers.
    Sources
    IBM History: The IBM PC (opens in a new tab)Computer History Museum: IBM introduces the Personal Computer (12 Aug) (opens in a new tab)
  2. Foundation for
    Databases

    Transactions: all or nothing

    BEGINA: 500 → 400B: 200 → 300COMMITcommitsboth changes keptcrash before COMMITneither: A 500, B 200all or nothing, and kept once confirmed
    Diagram: a transfer as one transaction: both changes happen, or after a crash neither does

    Jim Gray's paper “The Transaction Concept: Virtues and Limitations” set out how a group of changes, like moving money between two accounts, should either all happen or not happen at all, and survive a crash once confirmed. In 1983 Theo Härder and Andreas Reuter added isolation (transactions running at the same time don't see each other's half-finished work) and named the set ACID.

    Still matters
    Every BEGIN … COMMIT you write relies on these guarantees, and knowing where they stop is how you avoid lost updates and double charges.
    Learn it
    Transactions & Isolation · ACID, one letter at a timeTransactions & Isolation · Isolation levels: the standard vs reality
    Built on
    SQL1974
    Sources
    Gray, “The Transaction Concept: Virtues and Limitations” (VLDB, 1981) (opens in a new tab)Härder & Reuter, “Principles of Transaction-Oriented Database Recovery” (1983) (opens in a new tab)
  3. Foundation for
    Tools & practices

    GNU: a free Unix-like system

    A man with long grey hair and a full beard, in a red shirt with a green conference lanyard, speaking.
    Richard Stallman at LibrePlanet in 2019Photo: Ruben Rodriguez (source file on Wikimedia Commons, opens in a new tab), CC BY 4.0

    Richard Stallman announced the GNU project to write a complete Unix-compatible system that he would give away free, for anyone to use and share. Work began in January 1984, and its GNU General Public License (1989) required that anyone who shares a changed version shares it under the same free terms.

    Still matters
    Linux systems still ship GNU's tools and compilers, and the GPL started the licensing debates behind the open source software you depend on.
    Learn it
    The Command Line · How the shell finds and runs a command
    Built on
    Unix1969C1972
    Led to
    Linux1991Open source1998
    Sources
    GNU: Initial announcement (27 Sep 1983) (opens in a new tab)GNU General Public License, version 1 (1989) (opens in a new tab)
  4. Foundation for
    Web & networking

    DNS: names instead of numbers

    www.example.edu?you192.0.2.7resolver1 roottry the .edu servers2 .edutry example.edu3 example.eduwww = 192.0.2.7
    Diagram: looking up a name today: a resolver walks the tree from a root server to the .edu servers to the server for example.edu

    Paul Mockapetris published RFC 882 and RFC 883 (RFCs are the internet's numbered public specifications), describing the Domain Name System. Before it, every computer on the network kept a copy of one central list of names and addresses; DNS split the job into a tree of servers, each responsible for its own part of the names (for example, everything ending in .edu).

    Still matters
    Every time you type a web address, DNS turns the name into an address first, and when it breaks, much of the internet seems to break with it.
    Learn it
    DNS · What happens when you type example.comDNS · Record types: what DNS can store
    Built on
    TCP/IP1974
    Led to
    The Web1989
    Sources
    RFC 882: Domain Names: Concepts and Facilities (opens in a new tab)RFC 883: Domain Names: Implementation and Specification (opens in a new tab)
  5. Foundation for
    AI

    Backpropagation: how neural networks learn

    A grey-haired man in a dark suit and patterned tie, with a small headset microphone, speaking on a stage in front of a dark screen.
    Geoffrey Hinton, a co-author of the paper, at the 2024 Nobel Lectures in StockholmPhoto: Jay Dixit (source file on Wikimedia Commons, opens in a new tab), CC BY-SA 4.0

    David Rumelhart, Geoffrey Hinton and Ronald Williams showed in the journal Nature how neural networks with extra layers between input and output can learn: measure how wrong the output was, then send that error backwards through the layers, nudging every weight (the numbers the network learns) a little. Others had described the maths earlier; this paper made it widely used.

    Still matters
    Almost every modern neural network, including the LLMs behind chat assistants, is still trained by backpropagation, just on far more data and hardware.
    Learn it
    How LLMs Work · Training vs. inference
    Built on
    Dartmouth workshop1956
    Led to
    AlexNet2012Transformer2017
    Source
    Rumelhart, Hinton & Williams, “Learning representations by back-propagating errors”, Nature 323 (1986) (opens in a new tab)
  6. Foundation for
    Web & networkingTry it below

    The World Wide Web is proposed

    A black NeXT cube and monitor in a display case; a partly torn handwritten label on the cube reads “This machine is a server … DO NOT POWER IT DOWN!!”
    The NeXT computer Tim Berners-Lee used as the first web server, on display at CERN in 2005Photo: Coolcaesar at the English-language Wikipedia (source file on Wikimedia Commons, opens in a new tab), CC BY-SA 3.0

    At CERN, Tim Berners-Lee wrote “Information Management: A Proposal” for linked documents across the internet. By the end of 1990 he had the first web server and browser running; in August 1991 he announced the project publicly, and in April 1993 CERN put the software in the public domain. Three ideas made it: URLs, HTTP and HTML.

    Try it · request a page
    Browser sends ↗
    GET /hello.html
    Server answers ↙
    <title>Hello</title>
<h1>Hello, Web</h1>
<p>My first page.</p>

    One line in, the page out, then the server closes the connection. No status code, no headers: it could only send HTML. (A made-up example page.)

    Still matters
    Every website still uses those three ideas, and most APIs use the first two. The free, open release is a big part of why the Web, not a company's network, won.
    Learn it
    HTTP/1.1 → 2 → 3 · What an HTTP message looks likeHow Browsers Render · From bytes to the DOM (and why scripts block it)DNS
    Built on
    TCP/IP1974DNS1983Engelbart's demo1968
    Led to
    JavaScript1995PageRank1998REST2000iPhone2007
    Sources
    Berners-Lee, “Information Management: A Proposal” (W3C copy) (opens in a new tab)CERN timeline: World's first browser/editor, website and server go live (1990) (opens in a new tab)CERN timeline: CERN puts the World Wide Web in the public domain (1993) (opens in a new tab)

Next1990s The Web goes public

Chapter 61990s

The Web goes public · 7 milestones

New languages and free software spread, and the Web gains code in the page, search ranking and encryption.

  1. Foundation for
    Languages

    Python 0.9.0 is posted

    A grey-haired man with glasses and a short white beard, in a checked shirt over a blue T-shirt, with a conference badge on a lanyard.
    Guido van Rossum at PyCon US in 2024Photo: Kushal Das (source file on Wikimedia Commons, opens in a new tab), CC BY-SA 4.0

    Guido van Rossum, who started Python at CWI in Amsterdam in December 1989, posted version 0.9.0 to the alt.sources newsgroup (an early internet discussion board). It aimed to be easy to read, with indentation instead of braces and modules for everyday tasks.

    Still matters
    Python became a main language of data science, scripting and machine learning; most AI research code is written in it.
    Built on
    C1972
    Sources
    CPython Misc/HISTORY: “Release 0.9.0 (February 1991)” (opens in a new tab)Guido van Rossum, “A Brief Timeline of Python” (opens in a new tab)
  2. Foundation for
    Computers & OS

    Linux: “just a hobby”

    A smiling man in glasses and a black T-shirt sits on a white sofa on a stage, wearing a headset microphone.
    Linus Torvalds speaking at LinuxCon Europe in Düsseldorf, 2014Photo: Krd (source file on Wikimedia Commons, opens in a new tab), CC BY-SA 4.0

    Linus Torvalds, a student in Helsinki, posted that he was writing a free operating system kernel, “just a hobby, won't be big and professional like gnu”. Version 0.01 followed in September 1991, and in 1992 he moved it to the GPL, so people everywhere could improve it and share their changes.

    Still matters
    Linux runs most of the world's servers, every Android phone and most cloud machines; containers are built from Linux kernel features.
    Learn it
    System CallsFile Descriptors & SocketsContainers · A container is just a process
    Built on
    Unix1969GNU1983C1972
    Led to
    Open source1998GFS2003Git2005Docker2013
    Sources
    Torvalds' 1991 comp.os.minix post (30th-anniversary repost, lore.kernel.org) (opens in a new tab)Linux 0.12 release notes (GPL change) (opens in a new tab)
  3. Foundation for
    Languages

    Java: compile once, run on any machine

    Hello.javajavacHello.classbytecodeJVMWindowsJVMMacJVMSolaris
    Diagram: Java source is compiled once to bytecode, and the same .class file runs on a JVM on any kind of computer

    Sun Microsystems announced Java at SunWorld in San Francisco. Java code compiles to bytecode for a virtual machine (the JVM) instead of for one kind of processor, so the same program runs on any computer with a JVM, and memory is managed by a garbage collector.

    Still matters
    Java still runs a large share of company back ends, Android apps are written in Java or its JVM cousin Kotlin, and “compile to bytecode, run on a managed runtime” remains a common design.
    Learn it
    Garbage Collection · Most objects die young: generational GCStack vs Heap · The heap: a warehouse with a manager
    Built on
    C1972LISP1958
    Led to
    JavaScript1995
    Sources
    Sun press release, “Sun Brings True Interactivity to the World Wide Web” (23 May 1995) (opens in a new tab)Computer History Museum: This day in history, May 23 (opens in a new tab)
  4. Foundation for
    Languages

    JavaScript: code inside the web page

    ada@example.comCheckLooks like an emailonclick="check()"runs inside the pageservernot asked
    Diagram: a script in the page reacts to a click and changes the page itself, without sending a request to the server

    Brendan Eich wrote the first version at Netscape in about ten days in May 1995; Netscape and Sun announced it as JavaScript in December. It let pages react to clicks and typing without asking the server, and it was standardised as ECMAScript in June 1997.

    Still matters
    It is the language every browser runs natively, and with Node.js it runs on servers too; its event loop is why web code is written with callbacks, promises and async/await.
    Learn it
    The Event LoopAsync / AwaitDOM Events
    Built on
    The Web1989Java1995
    Led to
    Node.js2009React2013
    Sources
    Wirfs-Brock & Eich, “JavaScript: The First 20 Years” (HOPL, 2020) (opens in a new tab)Netscape & Sun press release (4 Dec 1995) (opens in a new tab)
  5. Foundation for
    Tools & practices

    “Open source” gets its name

    Weeks after Netscape said it would release its browser's source code, a group in California chose the term “open source” (suggested by Christine Peterson) to describe shared software in business-friendly terms. Eric Raymond and Bruce Perens founded the Open Source Initiative later that month.

    Still matters
    Most of the software in this timeline from here on is open source, and almost every app you build depends on hundreds of open-source packages.
    Built on
    GNU1983Linux1991
    Led to
    Agentic AI Foundation2025
    Source
    Open Source Initiative: History of the OSI (opens in a new tab)
  6. Foundation for
    Web & networking

    PageRank: ranking the Web by its links

    ABCDEbigger = higher rankeach link passes on part of its page’s rank
    Diagram: PageRank. A page ranks higher when many pages, or highly ranked ones, link to it (sizes illustrative)

    Sergey Brin and Larry Page's paper “The Anatomy of a Large-Scale Hypertextual Web Search Engine” described Google's prototype: rank a page higher when many important pages link to it, treating the whole Web as one huge graph of pages and links. They incorporated Google that September.

    Still matters
    Thinking of data as a graph of links is behind search, recommendations and social feeds, and the Google systems that followed (GFS, MapReduce and Bigtable, all later on this page) set the pattern for big-data computing.
    Learn it
    Graphs · Nodes, edges and the words around themGraphs · Storing a graph in memory
    Built on
    The Web1989
    Sources
    Brin & Page, “The Anatomy of a Large-Scale Hypertextual Web Search Engine” (WWW7, 1998) (opens in a new tab)Google: Our story (opens in a new tab)
  7. Foundation for
    Web & networking

    TLS 1.0: encryption for the web, standardised

    The internet's standards body, the IETF, published TLS 1.0 as RFC 2246, based on Netscape's earlier SSL 3.0. TLS wraps a connection so nobody in between can read or change it, and a certificate proves you're talking to the real site. TLS 1.3 (RFC 8446, 2018) made the opening handshake faster and dropped weak options.

    Still matters
    The padlock in your browser is TLS, and today most web traffic is encrypted with it.
    Learn it
    TLS & HTTPS · The handshake, step by stepTLS & HTTPS · Certificates and the chain of trust
    Built on
    Public-key crypto1976TCP/IP1974
    Sources
    RFC 2246: The TLS Protocol Version 1.0 (opens in a new tab)RFC 8446: The Transport Layer Security (TLS) Protocol Version 1.3 (opens in a new tab)

Next2000s Search, scale and the cloud

Chapter 72000s

Search, scale and the cloud · 12 milestones

Work spreads across many cheap machines, data centres become rentable, and the web moves into your pocket.

  1. Foundation for
    Web & networking

    REST: the Web's architecture, explained

    clientserverGET /orders/42200 OK · Cache-Control: max-age=60PUT /orders/42200 OKDELETE /orders/42204 No Content
    Diagram: one resource, /orders/42, named by a URL and used through the same few HTTP operations; the GET response says it may be cached

    In his PhD dissertation at UC Irvine, Roy Fielding, a co-author of the HTTP specification, described REST: the style behind the Web's success, with resources named by URLs, the same small set of operations for every resource (in HTTP: GET, PUT, POST, DELETE) and responses that can be cached.

    Still matters
    Most web APIs you call or build are “REST-ish” JSON over HTTP, designed with the ideas in that dissertation.
    Learn it
    API Design · Resources: naming the things in your APIHTTP/1.1 → 2 → 3 · Caching, conditional requests and safe retries
    Built on
    The Web1989
    Led to
    AWS S3 & EC22006
    Source
    Fielding, “Architectural Styles and the Design of Network-based Software Architectures” (2000) (opens in a new tab)
  2. Foundation for
    Distributed & cloud

    CAP: you can't have everything when the network splits

    ConsistentAvailablePartition-tolerantCPAPCACP stays consistent, may refuse requestsAP always answers, data may be staleCA not an option once the network splits
    Diagram: the CAP triangle. When the network between copies splits, a system has to choose between consistency (CP) and availability (AP)

    In a keynote at the PODC conference, Eric Brewer argued that when data is copied across machines and the network between them breaks, the system can't both give every reader the latest data (consistent) and answer every request (available): it has to choose. Seth Gilbert and Nancy Lynch proved a formal version in 2002, now called the CAP theorem.

    Still matters
    It's the vocabulary for every “what happens when a data centre is cut off?” discussion, and it explains why some databases refuse writes while others accept and reconcile later.
    Learn it
    CAP & PACELC · CAP, stated properlyCAP & PACELC · PACELC: the trade-off you pay every day
    Built on
    Lamport clocks1978
    Led to
    Dynamo2007
    Sources
    Brewer, “Towards Robust Distributed Systems” (PODC keynote slides, 2000) (opens in a new tab)Gilbert & Lynch, “Brewer's Conjecture and the Feasibility of Consistent, Available, Partition-Tolerant Web Services” (2002) (opens in a new tab)
  3. Foundation for
    Tools & practices

    The Agile Manifesto

    Seventeen software practitioners met at Snowbird, Utah, and wrote the Manifesto for Agile Software Development. It values individuals and interactions, working software, customer collaboration and responding to change over processes and tools, comprehensive documentation, contract negotiation and following a plan, while saying the second list still has value.

    Still matters
    Sprints, stand-ups, continuous integration (merging and testing everyone's code at least daily) and test-driven development (writing the test first), practices from Scrum and XP that the manifesto brought together, are now everyday team habits.
    Learn it
    Why & What to Test · TDD, honestlyCI/CD Pipelines
    Built on
    NATO conference1968
    Source
    Agile Manifesto: History (opens in a new tab)
  4. Foundation for
    Distributed & cloud

    The Google File System: expect machines to fail

    Close-up of stacked shelves of bare circuit boards and hard drives wired together with green and white cables.
    Google's “corkboard” production server, about 1999, at the Computer History MuseumPhoto: Marcin Wichary (source file on Wikimedia Commons, opens in a new tab), CC BY 2.0

    Sanjay Ghemawat, Howard Gobioff and Shun-Tak Leung described how Google stored huge files across more than a thousand cheap Linux machines (commodity hardware). Files are split into large chunks, each copied to three machines by default, so when a disk or machine dies, which happens every day at that scale, nothing is lost.

    Still matters
    “Assume parts fail, keep copies, recover automatically” is how cloud storage, Hadoop's HDFS (an open-source system modelled on GFS) and today's distributed systems are designed.
    Learn it
    Replication · Leader and followersDesign File Sync · Chunking: fixed-size vs content-defined
    Built on
    Linux1991
    Led to
    MapReduce2004Bigtable2006
    Sources
    Google Research: The Google File System (SOSP 2003) (opens in a new tab)ACM Digital Library: The Google File System (opens in a new tab)
  5. Foundation for
    Distributed & cloud

    MapReduce: big data on many machines

    inputmapshufflereducea b ab ca 1 · b 1 · a 1b 1 · c 1a: 1 1b: 1 1c: 1a 2b 2c 1
    Diagram: counting words with MapReduce. Map turns each piece of input into (word, 1) pairs, the shuffle groups them by word, reduce adds them up

    Jeffrey Dean and Sanjay Ghemawat showed how programmers could process terabytes by writing just two functions, map and reduce, like JavaScript's array.map() and .reduce() (the paper credits Lisp). The system splits the work across thousands of machines and reruns pieces when a machine fails.

    Still matters
    Open-source big-data tools copied the idea (Hadoop) and generalised it (Spark), and the pattern of splitting work, running it in parallel and combining the results is everywhere, down to “fan-out/fan-in” inside a single program (one task splits into many, and their results are joined back).
    Learn it
    Channels & select · Fan-out, fan-in and worker pools
    Built on
    GFS2003LISP1958
    Sources
    USENIX OSDI '04: MapReduce: Simplified Data Processing on Large Clusters (opens in a new tab)Google Research: MapReduce (opens in a new tab)
  6. Foundation for
    Tools & practicesTry it below

    Git: version control for the Linux kernel

    a1f39c2e4b7de81amainfeatureHEADarrows point to the parent
    Diagram: a small Git history. Each commit is named by a hash of its content (shortened here); branches are just names pointing at commits

    When the Linux kernel lost free use of BitKeeper, the version control tool its developers used to track changes, Linus Torvalds wrote his own: the first commit of Git is dated 7 April 2005. Every copy holds the whole history, each snapshot is named by a hash of its content, and branches are just names pointing at commits, so branching and merging are cheap.

    Try it · grow a branch
    $ git switch -c feature   ← next
    main

    Each dot is a commit (a snapshot); the ring is where you are (HEAD, on main). A branch is just a name pointing at a commit, which is why Git makes branching cheap. (File edits and git add are left out; main is the name most projects give the first branch.)

    Still matters
    Git is the version-control system behind GitHub and GitLab, and pull requests, code review and CI are built around it.
    Learn it
    Git, From the Inside · Commits are snapshots: blobs, trees and commitsGit, From the Inside · Branches and HEAD are just pointers
    Built on
    Linux1991
    Sources
    git/git: the first commit, “Initial revision of ‘git’” (7 Apr 2005) (opens in a new tab)Pro Git: A Short History of Git (opens in a new tab)
  7. Foundation for
    Distributed & cloud

    Amazon S3 and EC2: renting the data centre

    Rows of tall black server racks, each filled with stacked servers showing small blue and green lights.
    Server racks in a data centre: Wikimedia's servers in 2012Photo: Victor Grigas (source file on Wikimedia Commons, opens in a new tab), CC BY-SA 3.0

    Amazon Web Services launched S3, storage you use over the internet: upload a file, fetch it back by name, and pay per gigabyte (15 cents a month at launch) instead of buying disks. In August a limited beta of EC2 followed, letting developers rent virtual servers in minutes instead of buying hardware.

    Still matters
    This is “the cloud”: most startups never buy a server, and object storage like S3 holds a large part of the world's files, backups and website assets.
    Learn it
    Cloud Basics · IaaS, PaaS, SaaS and serverlessCloud Basics · The core managed services
    Built on
    REST2000
    Sources
    AWS News Blog: Amazon S3 (14 Mar 2006) (opens in a new tab)AWS News Blog: Amazon EC2 beta (Aug 2006) (opens in a new tab)
  8. Foundation for
    Databases

    Bigtable: a table spread across thousands of servers

    writememtablein memoryflush when fullSSTableBSSTableBSSTableBon disk: sorted, never editedB Bloom filter: “not here” or “maybe”
    Diagram: how Bigtable stores writes: first in a memtable, then flushed as sorted SSTables that are never edited; each SSTable can have a Bloom filter

    Google's Bigtable paper described a storage system for petabytes of structured data on thousands of machines. New writes are first collected in memory (a memtable), then saved in batches as sorted files that are never edited afterwards (SSTables). To avoid opening files that can't hold a key, it can keep a tiny “definitely not here / maybe” check per file (a Bloom filter).

    Still matters
    That write path is the LSM-tree design inside Cassandra, HBase, RocksDB and many other databases you'll meet.
    Learn it
    LSM Trees vs B-Trees · The write path: log, memtable, flushLSM Trees vs B-Trees · Bloom filters: skipping files for freeSQL vs NoSQL · Wide-column and graph
    Built on
    GFS2003
    Sources
    USENIX OSDI '06: Bigtable: A Distributed Storage System for Structured Data (opens in a new tab)Chang et al., Bigtable paper (PDF) (opens in a new tab)
  9. Foundation for
    Computers & OS

    The iPhone: the web in your pocket

    An iPhone standing inside a glass display case, with visitors holding up their own phones reflected in the glass.
    The iPhone under glass at its first public showing, Macworld, San Francisco, January 2007Photo: ArnoldReinhold (source file on Wikimedia Commons, opens in a new tab), CC BY-SA 4.0

    Apple announced the iPhone, a phone with a multi-touch screen and a full web browser; it went on sale in the US that June. In July 2008 the App Store opened with more than 500 apps, so outside developers could offer software straight to people's phones, through Apple's store and review.

    Still matters
    Phones became the main computer for most people, which is why sites are designed for small screens first and why app and web performance on slow networks matters.
    Learn it
    CSS Layout · Responsive basicsWeb Performance · Core Web Vitals: LCP, INP and CLS
    Built on
    The Web1989
    Sources
    Apple Newsroom: Apple Reinvents the Phone with iPhone (9 Jan 2007) (opens in a new tab)Apple Newsroom: iPhone 3G on Sale Tomorrow (10 Jul 2008) (opens in a new tab)
  10. Foundation for
    Databases

    Dynamo: always say yes to the shopping cart

    ABCDEFkeyhash(key) → a pointon the ring; copies onthe next 3 serversclockwise
    Diagram: consistent hashing. Servers and keys share one ring; a key is stored on the next few servers clockwise (three here)

    Amazon's Dynamo paper described the key–value store behind services like its shopping cart, built to keep accepting writes even when machines or networks fail. It spreads keys over servers with consistent hashing and keeps several copies of each. The copies may disagree for a while; vector clocks help sort out conflicting versions later.

    Still matters
    Cassandra, Riak and Voldemort borrowed its ideas (Amazon's DynamoDB kept the name but uses a different design), and “available now, consistent eventually” is a choice you make whenever you design for failure.
    Learn it
    Replication · Leaderless: quorums (Dynamo style)Partitioning & Sharding · Three ways to split: range, hash, directoryTime, Clocks & Ordering · Vector clocks
    Built on
    Lamport clocks1978CAP2000
    Source
    Werner Vogels: Amazon's Dynamo (paper, SOSP 2007) (opens in a new tab)
  11. Foundation for
    Languages

    Node.js: JavaScript on the server

    A young man with dark curly hair, glasses and a beard, in a grey T-shirt, speaking at a lectern.
    Ryan Dahl speaking at YUIConf in Sunnyvale, California, in 2010Photo: David Calhoun (source file on Wikimedia Commons, opens in a new tab), CC BY 2.0

    Ryan Dahl tagged the first release of Node.js, which runs JavaScript outside the browser on Google's V8 engine. Instead of one thread per connection, it uses an event loop: its main thread never sits waiting for the network or disk, so one process can juggle thousands of connections.

    Still matters
    Node.js runs many web servers and most front-end build tools, including Vite, which builds this site.
    Learn it
    The Event Loop · Node.js: the libuv phasesThe Event Loop · Node's hidden threads: the libuv thread poolAsync / Await
    Built on
    JavaScript1995
    Sources
    nodejs/node: v0.0.1 release tag (27 May 2009) (opens in a new tab)Node.js: About (opens in a new tab)
  12. Foundation for
    Languages

    Go: a simple language for big servers

    goroutinech <- resultchchannelmainv := <-chgo worker(ch) // start a goroutine
    Diagram: a goroutine started with go sends its result over a channel, and main receives it

    Google released Go as an open-source project, designed by Robert Griesemer, Rob Pike and Ken Thompson for large server software: fast builds, a small language, and goroutines and channels built in for concurrency. Go 1 followed in March 2012, with a promise that code written for it keeps compiling with every later Go 1.x release.

    Still matters
    Docker, Kubernetes and much of today's cloud tooling are written in Go, and it is one of the two languages this site's code samples use.
    Learn it
    Goroutines & the Go SchedulerChannels & selectGo Idioms as Patterns
    Built on
    C1972Unix1969
    Sources
    Go FAQ: history of the project (opens in a new tab)The Go Blog: Go version 1 is released (28 Mar 2012) (opens in a new tab)

Next2010s Containers and deep learning

Chapter 82010s

Containers and deep learning · 7 milestones

Apps ship in containers across whole clusters, deep learning wins on GPUs, and the Transformer arrives.

  1. Foundation for
    AI

    AlexNet: deep learning on GPUs wins

    A long black graphics card with a blower fan at one end and GeForce GTX 580 printed on its cover, lying on a wooden surface.
    A GeForce GTX 580 graphics card (2010), the model of gaming GPU AlexNet was trained on (it used two)Photo: TheStriker (source file on Wikimedia Commons, opens in a new tab), CC BY-SA 4.0

    Alex Krizhevsky, Ilya Sutskever and Geoffrey Hinton trained a neural network with many layers (deep learning) on two gaming GPUs to recognise objects in photos. A version of it won the 2012 ImageNet challenge (a yearly contest to label photos in 1,000 categories): the right answer was missing from its five best guesses for 15.3% of test photos, against 26.2% for the next entry. Much of the field switched to deep learning.

    Still matters
    Training big neural networks on GPUs is exactly how today's LLMs are built, at vastly larger scale, which is why GPUs became the most sought-after chips in computing.
    Learn it
    How LLMs Work · Training vs. inference
    Built on
    Backpropagation1986
    Led to
    Transformer2017
    Source
    Krizhevsky, Sutskever & Hinton, “ImageNet Classification with Deep Convolutional Neural Networks” (NIPS 2012) (opens in a new tab)
  2. Foundation for
    Distributed & cloud

    Docker: ship the app with everything it needs

    Solomon Hykes gave the first public demo of Docker at PyCon in March 2013, and it was released as open source days later. It packs an app and everything it needs into an image that runs the same on a laptop and a server, isolated from other programs by Linux kernel features into a container.

    Still matters
    “Works on my machine” stopped being an excuse: containers are how most server software is built, tested and deployed today.
    Learn it
    Containers · Your first DockerfileContainers · Images and layersContainers · A container is just a process
    Built on
    Linux1991
    Led to
    Kubernetes2014
    Sources
    Docker blog: Docker Nine Years Young (first demo at PyCon, 15 Mar 2013) (opens in a new tab)moby/moby changelog: 0.1.0 (23 Mar 2013) to 1.0.0 (opens in a new tab)
  3. Foundation for
    Web & networking

    React: describe the UI, let the library update the page

    previous rendernew renderAppHeaderCount 2AppHeaderCount 3comparepage: 2 → 3only the change is applied
    Diagram: React renders the UI again for new data, compares it with the last render and changes only what differs on the page

    Facebook released React as open source. Instead of changing the page step by step, you write components that describe what the UI should look like for the current data; when the data changes, React renders again, compares with the last result and applies only the differences to the page.

    Still matters
    Components and “UI as a function of state” became the standard way to build front ends, in React and in the frameworks that followed it.
    Learn it
    How React Works · Reconciliation: comparing two treesHow React Works · Render, then commit
    Built on
    JavaScript1995
    Sources
    facebook/react: “Initial public release” commit (29 May 2013) (opens in a new tab)React blog: Why did we build React? (June 2013) (opens in a new tab)
  4. Foundation for
    Distributed & cloud

    Kubernetes: run containers across a whole cluster

    you declare: replicas: 3node 1node 2node 3appappfailsappappreplacementit keeps reality matching what you declared
    Diagram: you declare how many copies should run; when a machine fails, Kubernetes starts a replacement elsewhere

    Google announced Kubernetes, an open-source system that runs containers across a cluster of machines: you declare what should run and how many copies, and it keeps reality matching, restarting and moving containers when machines fail. It drew on Google's internal Borg system; version 1.0 shipped in July 2015, alongside the new Cloud Native Computing Foundation.

    Still matters
    It became the common way to run services in the cloud, and its idea of “declare the goal, and a background loop keeps fixing the difference” spread to many other tools.
    Learn it
    Kubernetes · Pods: the smallest thing Kubernetes runsKubernetes · Deployments and ReplicaSets
    Built on
    Docker2013
    Sources
    Kubernetes blog: 10 Years of Kubernetes (opens in a new tab)Kubernetes blog: Borg, the predecessor to Kubernetes (opens in a new tab)
  5. Foundation for
    Distributed & cloud

    Raft: consensus you can understand

    leaderterm 31x=11y=23x=5follower1x=11y=23x=5follower1x=11y=2copiesits logentry 3 is on 2 of 3 servers: a majority, so committed
    Diagram: a Raft leader copies its log of commands (each tagged with its term) to the followers; an entry stored on a majority is committed

    Diego Ongaro and John Ousterhout's Raft, a consensus algorithm designed above all to be understandable, was published at USENIX ATC (a draft had circulated since 2013). The servers elect a leader, which copies an ordered list of commands (a log) to the others; as long as a majority is up, they all agree on the same history. The paper won a Best Paper award.

    Still matters
    etcd (the store behind Kubernetes), Consul and many databases use Raft to keep their copies in agreement.
    Learn it
    Consensus & Raft · Raft, live: the whole protocol in one simulatorConsensus & Raft · Elections up close
    Built on
    Lamport clocks1978
    Sources
    USENIX ATC '14: In Search of an Understandable Consensus Algorithm (opens in a new tab)The Raft Consensus Algorithm (raft.github.io) (opens in a new tab)
  6. Foundation for
    Languages

    Rust 1.0: memory safety without a garbage collector

    Rust 1.0 was released. Its compiler checks who owns each piece of memory and who may borrow it, so safe Rust code can't use freed memory or have data races, yet needs no garbage collector, so programs can run about as fast as C.

    Still matters
    Using freed memory and similar mistakes are a classic source of security holes in C and C++ programs; safe Rust rules them out when the code compiles, which is why it is often chosen for new systems code.
    Learn it
    Stack vs Heap · The heap: a warehouse with a managerRaces & Deadlocks · Data races vs race conditionsGarbage Collection
    Built on
    C1972
    Source
    Rust blog: Announcing Rust 1.0 (15 May 2015) (opens in a new tab)
  7. Foundation for
    AI

    The Transformer: attention is all you need

    looks at →thecatsatdownthecatsatdownbrighter = more attentioneach row adds up to 1 (illustrative weights)
    Diagram: attention. Each word gives every word in the sentence a weight and looks at them all at once (weights made up for illustration)

    Eight researchers, most of them at Google, published “Attention Is All You Need”, describing the Transformer for translating text. Instead of reading one word at a time, it uses attention to let each word look directly at the other words, which made it faster to train on GPUs and better at translation.

    Still matters
    It's the T in GPT: nearly every large language model since is a Transformer.
    Learn it
    How LLMs Work · Attention: which earlier tokens matterEmbeddings · Vectors: lists of numbers you can draw as arrows
    Built on
    AlexNet2012Backpropagation1986
    Led to
    RAG2020GPT-32020
    Source
    Vaswani et al., “Attention Is All You Need” (arXiv, June 2017) (opens in a new tab)

Next2020s The AI era

Chapter 92020s

The AI era · 5 milestones

Language models learn to look things up, chat with anyone, and plug into the tools where work happens.

  1. Foundation for
    AI

    Retrieval-augmented generation: look it up, then answer

    questionsearchvector indexWikipedia passagesrelevant passageslanguage modelanswer
    Diagram: retrieval-augmented generation: search first, then the model answers from the passages it found

    Patrick Lewis and colleagues at Facebook AI Research, UCL and NYU combined a language model with a search step. Retrieval-augmented generation first finds relevant passages (from Wikipedia, in the paper) using a vector index, a search index that finds text with similar meaning, then writes the answer from them, so the model can use facts it never memorised.

    Still matters
    Chatbots that answer from your company's documents are built this way, with embeddings and a vector database doing the search.
    Learn it
    Retrieval-Augmented Generation · The pipeline, end to endEmbeddingsVector Databases
    Built on
    Transformer2017
    Source
    Lewis et al., “Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks” (arXiv, May 2020) (opens in a new tab)
  2. Foundation for
    AITry it below

    GPT-3: a model that learns from examples in the prompt

    OpenAI's paper “Language Models are Few-Shot Learners” described GPT-3, a Transformer with 175 billion parameters (the numbers it learns, also called weights), trained to predict the next token of text. Shown just a few examples in the prompt, it could do tasks it was never specifically trained for.

    Toy · you play the model: pick the next token

    Software

    Made-up numbers, not a real model. A real model scores every token in a vocabulary of tens or hundreds of thousands at each step, then picks one (often the most likely, sometimes a less likely one, which is what “temperature” controls).

    Still matters
    Writing a prompt with instructions and examples (few-shot prompting) instead of training a model is how most AI features are built today.
    Learn it
    How LLMs Work · Predicting the next token: scores to probabilitiesPrompting · Few-shot examples, and what the model copies
    Built on
    Transformer2017
    Led to
    ChatGPT2022
    Source
    Brown et al., “Language Models are Few-Shot Learners” (arXiv, May 2020) (opens in a new tab)
  3. Foundation for
    AI

    ChatGPT: anyone can talk to an LLM

    OpenAI released ChatGPT as a free “research preview”: a GPT model tuned with human feedback to follow instructions in a conversation. It made a large language model something anyone could try directly, in a chat window, and it spread fast.

    Still matters
    It started the wave of AI assistants and AI features in everyday software, and made prompting, evaluation and AI safety part of a developer's job.
    Learn it
    How LLMs WorkPrompting · What a request actually containsLLMs in Production
    Built on
    GPT-32020
    Led to
    MCP2024
    Source
    OpenAI: Introducing ChatGPT (30 Nov 2022) (opens in a new tab)
  4. Foundation for
    AI

    MCP: one standard plug for AI tools

    AI app (host)MCP clientMCP serverfilesMCP clientMCP serverissue trackerMCP clientMCP serverdatabase
    Diagram: an AI app runs one MCP client per server; each tool or data source is exposed once, as an MCP server

    Anthropic introduced the Model Context Protocol as an open standard for connecting AI assistants to the tools and data where work happens. Instead of a custom integration for every pair of app and assistant, a tool exposes one MCP server that any assistant supporting MCP can use.

    Still matters
    AI agents act through tools; MCP is a common way to give them those tools, which makes tool calls and their permissions a key part of AI engineering.
    Learn it
    Agents & Tool Calling · MCP: one standard plug for toolsAgents & Tool Calling · Tool calling: the model asks, your code actsAI Security · A policy gate for tool calls
    Built on
    ChatGPT2022
    Led to
    Agentic AI Foundation2025
    Source
    Anthropic: Introducing the Model Context Protocol (25 Nov 2024) (opens in a new tab)
  5. Foundation for
    AI

    AI agents get a neutral home for their standards

    Anthropic donated MCP to the new Agentic AI Foundation, set up under the Linux Foundation and co-founded by Anthropic, Block and OpenAI. Anthropic counted more than 10,000 active public MCP servers by then. Like Kubernetes before it, the protocol moved to a neutral foundation so no single company controls it.

    Still matters
    Agents that use tools are becoming ordinary software, and shared, openly governed standards are how earlier waves, from TCP/IP to the Web to containers, became something everyone could build on.
    Learn it
    Agents & Tool CallingAI Security · The threat model: what an AI feature reads and what it can do
    Built on
    MCP2024Open source1998
    Sources
    Anthropic: Donating the Model Context Protocol and establishing the Agentic AI Foundation (opens in a new tab)Linux Foundation: formation of the Agentic AI Foundation (opens in a new tab)

NextYou are here

You are here

Every tool you use today stands on the ones above: your editor's Git, your cloud's containers, your AI assistant's Transformer. The story isn't finished, and the best way to join it is to understand the foundations.

Pick a learning roadmap →Browse all topics

How this timeline was checked

Every milestone links the source its date and claims come from, usually the original paper, standard or announcement, or an official project history or museum page. Dates are only as precise as those sources: a month or day appears only when they agree. Where the record is disputed, the card says so or uses the safer wording, such as “paper published” instead of “invented”.

Choosing 60 milestones means leaving out many people and projects that mattered. Think of this as one path through the history, picked for the ideas the Software Atlas deep-dives teach.

Photo credits

The photos come from Wikimedia Commons under free licences. Each was resized and re-encoded for the web, and some were cropped at the edges. Portraits are often from years after the milestone; the caption gives the year. The diagrams are original drawings made for this page.

Last checked: November 2026.