100 years of software

The Problems Each One Solved.

A ledger of 177 entries, organised by era. For every entry we ask only one question: what problem did the world have before this work existed?

Features were deduplicated by problem. Many tools solved the same problem across decades — they are grouped in Across all eras.

1920–1949

Pre-electronic computation

The world had ledgers, censuses, and weapons-grade arithmetic to do by hand. Errors propagated; humans died of those errors.

Hollerith / IBM punched cards (1924) — Population censuses took years to count; cross-tabulation by hand was infeasible.
Konrad Zuse — Z3 (1941) — There was no programmable, general-purpose digital calculator.
ENIAC (1945) — Artillery firing tables required months of manual labour each.
EDVAC / von Neumann report (1945) — Computers stored program logic in wiring; rewiring took weeks.
ACM founded (1947) — There was no professional body to share computing knowledge.
Shannon — A Mathematical Theory of Communication (1948) — There was no quantitative theory of how much information a noisy channel could carry.
Manchester Baby / EDSAC (1948–1949) — Stored-program computing existed only on paper.

1950–1959

First commercial computers + first higher-level languages

Programs were written in binary, debugged with oscilloscopes, and thrown away after each problem. Sharing code did not exist.

Assembly language / autocode (1951) — Hand-coding binary was unbearably slow and error-prone.
Fortran (IBM) (1957) — Scientists couldn't write numerical code without becoming hardware engineers.
LISP (McCarthy) (1958) — There was no way to express symbolic / list / AI computation directly.
ALGOL 58 / 60 (1958–1960) — Computer science had no shared notation for algorithms.
COBOL (1959) — Business data processing needed a portable language readable by managers.
BNF (Backus–Naur Form) (1959) — There was no formal way to specify programming-language syntax.
IBM 1401 + RPG (1959) — Small businesses had no affordable way to print billing and reports.

1960–1969

Time-sharing, databases, and the seeds of networking

One person used one computer at a time. Data was bound to specific programs. Computers in different rooms could not talk.

CTSS / Multics (MIT) (1961–1969) — Only one user could use a computer at a time; everyone else queued.
Sketchpad (Sutherland) (1963) — There was no interactive graphics; humans communicated to computers only via keyboards.
ASCII (1963) — Every computer model used its own character encoding.
BASIC (Dartmouth) (1964) — Programming was an elite craft; undergraduates had no way in.
SABRE (IBM + American Airlines) (1964) — Airline reservations were managed on paper; double-bookings were chronic.
PL/I (1964) — Engineers split between Fortran (science) and COBOL (business) and could share nothing.
ELIZA (Weizenbaum) (1966) — There was no demonstration that natural-language interaction with a machine was possible.
Simula 67 (Dahl + Nygaard) (1967) — Programs could not model real-world entities as objects.
Engelbart — Mother of All Demos (1968) — Personal interactive computing — mouse, hypertext, video conferencing — existed only in imagination.
ARPANET (1969) — Two computers in two different cities could not communicate.
Unix (Bell Labs) (1969–1973) — Every operating system was bound to its hardware vendor; portability did not exist.
IBM Codd — relational model (1970) — Databases were navigational; queries required hand-coding the path.

1970–1979

Personal computing born + the relational database + Unix spreads

The world's data lived in hierarchical or network DBs that required programmers to navigate them. Computers were rooms, not desks.

C language (Ritchie) (1972) — There was no portable systems language; OS code was tied to one machine.
Smalltalk (Xerox PARC) (1972) — There was no fully object-oriented language with live environments.
Xerox Alto (1973) — Computers had no graphical interfaces. Everything was text.
Ethernet (Metcalfe + Boggs) (1973) — Local-area networking standards were vendor-locked and incompatible.
TCP/IP (Cerf + Kahn) (1973–1983) — Networks could not interoperate across organisational boundaries.
Ingres / System R (1974) — Relational databases were theory; no production engine existed.
VisiCalc (Bricklin + Frankston) (1979) — Financial what-if analysis required redoing every calculation by hand.
WordStar (1978) — Word processing required specialised hardware and trained operators.
Usenet (Truscott + Ellis) (1979) — There was no way for a global community to hold asynchronous discussions.
Emacs (Stallman) (1976) — Editors were locked to one paradigm; programmable editors did not exist.
vi (Joy) (1976) — Full-screen editing was unavailable on remote terminals.
Microsoft / Apple founded (1975 · 1976) — Software was sold per-machine by hardware vendors only.
Apple II + DOS 3.3 (1977–1979) — Personal computers shipped without a usable disk operating system.

1980–1989

The PC era + the GUI + the Internet protocol stack

Most of humanity had never touched a computer. Software cost more than the computer that ran it. The internet was a research toy.

DOS / IBM PC (1981) — Personal computers were hobbyist kits without a standard platform.
Lotus 1-2-3 (1983) — Integrated spreadsheet + graphing + database did not exist for business.
Macintosh + GUI (1984) — GUIs were Xerox-only; ordinary people could not afford visual computing.
Word + Excel (Microsoft) (1983–1985) — Document and spreadsheet formats were vendor-locked; data could not move.
PostScript (Adobe) (1984) — Printers required vendor-specific page-description languages; layout was a black art.
Aldus PageMaker (1985) — Typesetting was a guild trade requiring expensive equipment.
X Window System (MIT) (1984) — Networked graphical interfaces did not exist.
DNS (Mockapetris) (1983) — Mapping hosts to addresses required a central HOSTS.TXT file that didn't scale.
SMTP / RFC 821 (1982) — Email was a per-vendor extension to file transfer; cross-system delivery was unreliable.
GNU Project (Stallman) (1983) — Source code was locked away in proprietary licences; modification was forbidden.
BSD 4.2 (1983) — Unix was not freely distributable; networking primitives lived only inside AT&T.
Microsoft Excel (1985) — Spreadsheet calculation was bound to Lotus's macro language.
C++ (Stroustrup) (1985) — C had no abstraction for data + behaviour.
Perl (Wall) (1987) — Text processing required a different tool for every step (awk, sed, grep, sh).
Quattro / FrameMaker / OS/2 / NeXTSTEP (1987–1989) — Specialised computing platforms were divergent and incompatible.
BIND (DNS server) (1985–) — There was no reference DNS implementation for the new RFC.
Microsoft Windows 1.0–3.0 (1985–1990) — Most PCs had no consistent GUI; every application invented its own.
Mosaic Communications (later Netscape) — pre-history (1989) — Hypertext systems existed in labs (HyperCard, Xanadu) but not on the internet.
Tim Berners-Lee — proposal (1989) — Physicists at CERN could not share documents across machines and labs.

1990–1999

The Web. Linux. The relational web era.

The internet was an academic playground. Knowledge was locked in libraries. Operating systems cost thousands of dollars.

World Wide Web (Berners-Lee) (1989–1991) — Hypertext existed in isolated systems; the internet had no document layer.
Python (van Rossum) (1991) — Scripting languages were either ugly (Perl) or slow to write (sh + sed + awk).
Linux 0.01 (Torvalds) (1991) — Free Unix-class operating systems did not exist; MINIX was educational only.
HTTP / HTML 1.0 (1991) — There was no way to serve linked documents at planetary scale.
Mosaic browser (1993) — The Web was text-only and unfamiliar; images on the same page were impossible.
PHP / MySQL (Rasmus Lerdorf · Monty Widenius) (1995) — Dynamic websites required a $5,000 Sun box and an Oracle licence.
Java (Sun) (1995) — Networked, cross-platform application code did not exist.
JavaScript (Eich) (1995) — Web pages were static; client-side interactivity required plugins.
Apache HTTP Server (1995) — NCSA httpd had stalled; the web needed a maintained, free server.
Ruby (Matz) (1995) — Languages optimised programmer happiness only as an accident; Matz made it the goal.
Netscape Navigator 1.0 (1994) — Mosaic was non-commercial and incomplete; ordinary users had no usable browser.
RSA / SSL / public-key crypto deployed (1994–1996) — Internet traffic was unencrypted; e-commerce was infeasible.
PGP (Zimmermann) (1991) — Strong encryption was illegal export; ordinary citizens had no private email.
Lucene (Doug Cutting) (1999) — Full-text search libraries were proprietary; small projects had no index.
Perl CPAN (1995) — Code re-use across languages did not exist as a habit.
Yahoo / AltaVista / Lycos / WebCrawler / Excite (1994–1996) — The web was unsearchable; users needed someone to compile directories.
Google Search (Page + Brin) (1998) — Web search returned spam; PageRank made authority computable.
Hotmail (1996) — Email required an ISP account; free web-mail did not exist.
ICQ / IRC (1996) — Real-time text chat on the internet was confined to Usenet/BBS.
Quake + Carmack — networked 3D (1996) — First-person multiplayer over the internet was unsolved.
Visual Basic / Delphi / Borland (1991–1995) — Rapid Windows application development was prohibitive without expensive tools.
eBay / Amazon (1995) — Long-tail commerce had no marketplace; small sellers couldn't reach buyers.
PayPal (1998) — Email-only person-to-person payments did not exist.
Mozilla Foundation / open Netscape (1998) — Browser standards were headed for Microsoft monoculture.

2000–2009

Open source eats the server room. The phone becomes a computer.

Enterprise software ran on Sun + Oracle + WebLogic — six-figure stacks. Phones did one thing: phone calls. Search was poor. Email was spam-clogged.

Wikipedia (2001) — Authoritative reference was paywalled; encyclopedias cost a month's wages.
RHEL / Red Hat Enterprise Linux (2002) — Linux had no commercial-grade enterprise distribution with support.
MIT OpenCourseWare (2001) — University-grade education was locked behind tuition.
BitTorrent (Bram Cohen) (2001) — Large-file distribution required servers no individual could afford.
Mac OS X (2001) — Consumer desktops had no Unix-class operating system.
Salesforce (1999–) — CRM required on-prem servers and IT teams to maintain.
Gmail (2004) — Free email accounts had 10 MB of storage; threads were unmanageable.
Firefox 1.0 (2004) — Internet Explorer was 95% of the market with no rendering competition.
WordPress (2003) — Personal publishing required HTML and FTP.
Git (Torvalds) (2005) — Centralised version control couldn't survive offline work or forks.
Ruby on Rails (DHH) (2005) — Web app boilerplate took months; convention-over-configuration was theory.
Hadoop (Cutting + Cafarella) (2006) — Petabyte-scale computation was Google's secret; nobody else had MapReduce.
AWS S3 / EC2 (Amazon) (2006) — Capital expenditure on servers blocked every new internet business.
YouTube (2005) — Video on the web required players, codecs, and bandwidth nobody had.
Twitter (2006) — Status updates with friends required SMS or a phone call.
Facebook (2004) — Online social presence required separate accounts on dozens of sites.
iPhone (Apple) (2007) — Smartphones existed but had no usable web browser or app ecosystem.
Android Open Source Project (Google) (2007–) — Smartphones were on track to be a single-vendor market.
Stack Overflow (2008) — Programmer questions disappeared into forums; nothing was canonical.
Node.js (Dahl) (2009) — Server-side JavaScript with non-blocking I/O did not exist.
Heroku (2007) — Deploying a small web app required system-administration skill.
Dropbox (2008) — Cross-machine file sync required FTP scripts or USB sticks.
GitHub (2008) — Git was distributed but had no central place for the open-source world to gather.
Chrome + V8 (Google) (2008) — JavaScript was the slowest production language; the web was hitting a ceiling.
Skype (2003) — International voice calls cost a dollar a minute.
MySQL Workbench / Postgres adoption (2000s) — Open-source databases were viable but tooling lagged the proprietary world.
MongoDB / Redis / Cassandra (2009) — Webscale workloads pushed past what relational engines did comfortably.
Let's Encrypt — precursors (late 2000s) — TLS certificates cost $50+ and required engineering effort.

2010–2019

Mobile-first. Cloud-native. Containers. Deep learning awakens.

Servers became cattle. Phones became the computer. Convolutional + recurrent neural networks went from research curiosity to industrial use.

Docker (Hykes) (2013) — Application packaging was inconsistent across dev/test/prod; 'works on my machine' was endemic.
Kubernetes (Google) (2014) — Container orchestration was Google's internal Borg; everyone else used hand-written scripts.
React (Facebook) (2013) — Client-side UI state synchronisation was a tangle of jQuery.
Vue.js (Evan You) (2014) — React had a corporate gatekeeper; the web needed a fully community-owned alternative.
Angular (Google) (2010) — Web SPAs had no opinionated framework; everyone reinvented routing + DI + templating.
Slack (2013) — Workplace chat tools were IRC clones or enterprise junk; usable team communication was missing.
Zoom (2011) — Video conferencing required IT departments and per-seat licences.
Stripe (2010) — Accepting payments online required weeks of integration with hostile bank APIs.
Twilio (2008–) — Programmable telephony was carrier-locked; SMS-by-API didn't exist.
GitHub Actions / CI commodified (2010s) — Continuous integration required Jenkins + self-hosting; small teams had no automation.
Postgres becomes default (2010s) — MySQL had taken over the open web but had data-integrity gaps.
Elasticsearch + Kibana + Logstash (2010) — Log analysis on commodity hardware was painful; full-text + dashboards lived in expensive tools.
Kafka (LinkedIn) (2011) — Distributed event streaming did not have an open standard.
Spark (UC Berkeley) (2014) — MapReduce was disk-bound and slow; in-memory cluster compute was missing.
AWS Lambda (2014) — Even tiny servers required provisioning; per-invocation compute did not exist.
Let's Encrypt (2014–2015) — TLS adoption stalled because certificates were expensive and manual.
Signal (Marlinspike) (2014) — End-to-end encrypted messaging had no usable, default-on consumer app.
Apple App Store / Google Play (2008–2010) — Distributing native applications required publishers and shrink-wrap.
WhatsApp Web (2015) — Mobile messaging had no usable desktop bridge.
Visual Studio Code (Microsoft) (2015) — Cross-platform extensible editors were either heavyweight (IntelliJ) or weak (Atom).
TensorFlow (Google) (2015) — Deep-learning frameworks were research code; production-grade systems were Google-internal.
PyTorch (Facebook) (2016) — TensorFlow's static graph was hostile to research iteration.
Hugging Face Transformers (2018) — Each transformer paper shipped its own incompatible code; comparisons were impossible.
Cloudflare (free TLS, 1.1.1.1, R2) (2014–2019) — Small sites had no edge protection; resolver privacy did not exist.
Tailscale / WireGuard (2018–2019) — VPNs were enterprise pain; mesh networks for two laptops did not exist.
Rust 1.0 (Mozilla) (2015) — Memory-safe systems languages did not exist outside research.
Go 1.0 (Google) (2012) — Server-side concurrency was hard in Java/Python; goroutines made it easy.
Notion (2016) — Personal + team knowledge bases were either rigid (Confluence) or untyped (Google Docs).
Figma (2016) — Design tools were single-machine; collaborative design was unthinkable.
Stack-Exchange-era LLMs (BERT, GPT-2) (2018–2019) — Language models were sequence-to-sequence toys; few-shot generalisation was unbelievable.
AlphaGo (DeepMind) (2016) — Go was considered a decade away from machine mastery; deep RL changed the timeline overnight.
OpenStreetMap matures (2010s) — Crowdsourced mapping had to scale to humanitarian use; routing engines, address coverage.
Wikidata (2012) — Wikipedia held prose; a structured knowledge graph was a separate dream.

2020–2026

Foundation models. Sovereign AI. The agentic era begins.

GPT-3 made language models a primitive. Then frontier reasoning models made them tools. Then the open commons made them everyone's tools. Software stopped being typed; it started being instructed.

GPT-3 (OpenAI) (2020) — Few-shot natural-language reasoning was not commercially accessible.
Hugging Face Hub (2020–) — Trained model weights had no shared registry; each lab hosted their own.
Stable Diffusion (CompVis) (2022) — Image generation required cloud APIs; consumer GPUs could not run it.
LLaMA (Meta) (2023) — There was no openly released frontier-grade language model.
ChatGPT (2022) — Conversational AI was a research demo; nobody had a usable consumer surface.
Cursor / GitHub Copilot Workspace (2022–2024) — Software writing was constrained by typing speed; agent-assisted editing was missing.
LangChain / LlamaIndex / RAG stack (2022–) — Hooking an LLM up to enterprise data required hand-written glue every time.
Mistral / Mixtral / Qwen / DeepSeek (2023–2025) — Open-weight models had been one or two generations behind frontier; that gap closed.
vLLM / TensorRT-LLM / SGLang (2023–) — Self-hosted inference was 5–10× slower than commercial APIs; serving frameworks closed the gap.
DeepMind AlphaFold (2020–2024) — Protein-structure prediction was a 50-year-old grand challenge.
DGX Spark + GB300 + B300 fabric (2024–) — Sovereign AI infrastructure had no on-premise hardware path.
SARAH AI Suite — IDESKS ONLINE AI (2025–) — Enterprises had to glue together hundreds of SaaS to do what one operator should do. Built by Chris Ismail on the back of 18 years of research, trials and tests — building and servicing the entire Australian Horse Racing and Sports Betting industry through his Private Enterprise IP Network, and building and servicing enterprise call-centres around the world through his own flavour of predictive dialers and home-brewed CRM Connectors, voice-bot stacks and sovereign-AI infrastructure before SARAH AI Suite was a line of code.
Microsoft 365 + Copilot (2023–) — Office software did not have built-in agentic assistance.
Apple Intelligence + on-device LLMs (2024–) — Mobile AI inference required cloud round-trips; private on-device reasoning was missing.
Google Gemini + Workspace AI (2023–) — AI-augmented productivity for billions of free Gmail / Docs users.

Across all eras

Problems solved that span every decade

Some problems were not solved once. Each generation re-solved them for new constraints — better, cheaper, more universal.

Compilers / language toolchains (1957–today) — Bridging the gap between how humans think and what machines execute.
Version control (SCCS · RCS · CVS · SVN · Git) — Keeping a history of who changed what, when, and why.
Operating systems (OS/360 · VMS · Unix · Windows · Linux · macOS · Android · iOS) — Sharing hardware safely among many programs and many users.
Databases (IMS · Oracle · DB2 · MySQL · Postgres · MongoDB · ClickHouse) — Storing structured data so it survives crashes and answers questions fast.
Search engines (Lycos · AltaVista · Google · Elasticsearch · vector search) — Finding the one document in a billion that matters now.
Email (SMTP · MIME · Hotmail · Gmail · ProtonMail) — Asynchronous, reliable, multi-party text messaging across organisations.
Spreadsheets (VisiCalc · Lotus 1-2-3 · Excel · Google Sheets) — Letting non-programmers do what-if analysis on tabular data.
Word processing (WordStar · WordPerfect · Word · Google Docs · LaTeX) — Producing readable, printable documents without a typesetter.
Web browsers (Mosaic · Netscape · IE · Firefox · Chrome · Safari) — Rendering arbitrary remote documents safely on any device.
Containerisation + orchestration (chroot · jails · LXC · Docker · Kubernetes) — Running multiple isolated workloads on shared hardware without conflict.
Public-key cryptography (RSA · DH · ECC · ed25519 · Signal Protocol) — Letting strangers communicate privately without sharing a secret first.
Real-time communications (IRC · ICQ · MSN · Skype · WhatsApp · Signal · Slack · Zoom) — Carrying low-latency voice, video, and text across the planet.
Identity + auth (LDAP · Kerberos · OAuth · SAML · WebAuthn · TOTP) — Letting a person prove who they are to a system they don't run.
Network plumbing (TCP/IP · DNS · BGP · HTTP · TLS · WebSocket · QUIC) — Carrying bytes reliably between any two endpoints in the world.
Programming paradigms (structured · OO · functional · logic · concurrent · gradual-typed) — Giving programmers new ways to think about complex systems.
Knowledge commons (Wikipedia · arXiv · Stack Overflow · MDN · Hugging Face) — Pooling human and machine knowledge so the next learner doesn't start from zero.