History of Programming
Programming — telling a machine what to do — is younger than the car and older than the transistor. Its history runs from punched cards on looms, through paper sketches of machines that were never built, to the global web of languages that software is written in today.
Before the machine
The Jacquard loom (1801–1804)
The first device controlled by a stored pattern of instructions was not a computer at all. Joseph-Marie Jacquard's loom used chains of punched cards to weave complex images into fabric automatically. The idea that holes in a card could encode an operation sequence — and that swapping cards meant swapping the program — is the conceptual seed of all programming.
Babbage and Lovelace (1830s–1843)
Charles Babbage designed the Difference Engine and then the Analytical Engine, a general-purpose mechanical computer with an arithmetic unit, memory, and control flow driven by punched cards — the same cards Jacquard used. It was never finished; machining tolerances and funding ran out.
Ada Lovelace, translating a paper on the engine in 1843, added a series of notes far longer than the paper itself — including a worked method for computing Bernoulli numbers that is often called the first published computer program. She also saw what Babbage largely did not: that such a machine could manipulate symbols, not just numbers — music, text, ideas.
Punch cards go practical (1890)
Herman Hollerith's punched-card tabulator cut the United States census from years to months. His company eventually became IBM, and card-based data processing ran the business world for the next eighty years.
The theory arrives before the hardware
In 1936 Alan Turing described a universal machine — a tape, a head, and a table of rules — that could compute anything computable. Alonzo Church reached the same boundary independently with lambda calculus. Before anyone had built a real computer, mathematicians had already defined what programming was: describing a procedure precisely enough for a machine to follow.
In Germany, Konrad Zuse built the Z3 (1941), the first working programmable computer, and designed Plankalkul (1942–45) — the first high-level programming language ever conceived, decades ahead of its time and never implemented in his lifetime.
The first programmers
ENIAC (1945) calculated artillery tables at electronic speed — but "programming" it meant physically rewiring panels with cables and switches. The people who did that work — Kay McNulty, Betty Jennings, Betty Snyder, Marlyn Wescoff, Fran Bilas, and Ruth Lichterman — were the first modern programmers, inventing subroutines and debugging as they went, largely uncredited for decades.
The stored-program idea — keeping instructions in memory alongside data — was laid out in the 1945 EDVAC report associated with John von Neumann, and first ran on the Manchester Baby (1948) and EDSAC (1949). From then on, a program was data you could write down, save, and share — software was born.
The age of languages
The first programs were raw numbers — machine code. Assembly language gave each instruction a name. Then Grace Hopper's A-0 system (1952) became the first compiler: a program that writes programs. The idea was met with skepticism — machines, people said, should be programmed by hand — and it changed everything anyway.
The 1950s: names that still echo
- FORTRAN (1957, IBM, John Backus) — "FORmula TRANslation," the first practical high-level language. Still running in scientific computing.
- LISP (1958, John McCarthy) — lists, recursion, and the seed of functional programming and symbolic AI.
- ALGOL (1958/60) — introduced block structure, scope, and the notation (BNF) used to describe languages themselves. Nearly every language since is its descendant.
- COBOL (1959, Grace Hopper and the CODASYL committee) — English-flavored business language; enormous COBOL systems still run banks and governments.
The 1960s: programming for everyone
- BASIC (1964, John Kemeny and Thomas Kurtz, Dartmouth) — Beginner's All-purpose Symbolic Instruction Code. The radical idea was not the language but the audience: students, not specialists. Combined with time-sharing, it let a whole campus program at once.
- Simula (1967) — the first language with objects and classes, the concept that would later dominate.
- Logo (1967, Seymour Papert) — a child-friendly language with turtle graphics; programming as a way to think, not just to compute.
The 1970s: the tools that endure
- Pascal (1970, Niklaus Wirth) — clean, strict, built for teaching; for a generation it was "learning to program."
- C (1972, Dennis Ritchie, Bell Labs) — written to build UNIX. Close to the machine, portable everywhere; still the lingua franca of systems code.
- Smalltalk (1972, Xerox PARC) — objects, messages, and a live environment inside the graphical interface ideas that became the modern desktop.
- Prolog (1972) and SQL (1974) — programming by describing what you want, not how to get it.
The 1980s: the home computer wave
The Apple II, Commodore 64, and ZX Spectrum shipped with BASIC in ROM — the machine booted straight into a programming prompt. Millions of people wrote their first line of code on one; a large part of the modern software industry started with 10 PRINT loops on home machines. Meanwhile Ada (1980) was commissioned by the US Department of Defense for safety-critical systems, C++ (Bjarne Stroustrup, mid-80s) grew objects onto C, and Turbo Pascal made a fast compiler cheap enough for anyone.
The 1990s: the internet era
- Python (1991, Guido van Rossum) — readability as a design goal.
- Java (1995) — "write once, run anywhere" on a managed virtual machine.
- JavaScript (1995, Brendan Eich) — designed in days for the browser; now the most-run language ever written.
- Ruby and PHP (1995) — web and scripting staples.
- Visual Basic (1991) — drag-and-drop windows plus BASIC: desktop programming for the rest of us.
The 2000s and beyond: safety, scale, speed
C# (2000) anchored .NET; Go (2009) and Rust (first stable 2015) chased simplicity and memory safety; TypeScript (2012), Kotlin, Swift, Julia, and Zig each claimed a niche. And in the 2020s, AI-assisted tools began writing code alongside people — the newest chapter in a story that started with holes in paper cards.
The shape of the story
| Era | Shift |
|---|---|
| 1800s–1940s | Programs as hardware: cards, cables, rewiring |
| 1950s | Programs as text: assemblers, then compilers |
| 1960s–70s | Structure and reach: blocks, objects, portability |
| 1980s | Programming for everyone: BASIC in every home machine |
| 1990s | Programming connected: the internet and managed runtimes |
| 2000s–now | Safety and scale — and machines that help write themselves |
The constant through every era is the one Kemeny and Kurtz bet on in 1964: programming belongs to everyone, and each generation of tools exists to bring the machine a little closer to the person using it. That is the lineage AdaLogic BASIC continues — a modern BASIC that treats approachability and real power as the same goal.