Diff — History of Programming

{{infobox

| title = History of programming

| image = eniac-operators.jpg

| caption = Two of the ENIAC six at the machine's panels, 1946 — US Army photo

| span = 1801 – present

| first_program = Lovelace's [[Bernoulli numbers]] method, 1843

| first_stored_program = [[Manchester Baby]], 21 June 1948

| first_commercial_computer = [[EDSAC]] lineage → Ferranti Mark 1, 1951

| first_compiler = Grace Hopper's A-0, 1952

| oldest_living_language = [[FORTRAN]], 1957

| eras = Cards → machine code → compilers → structure → ubiquity

}}

**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. Every idea on this page is a link; follow them and the story unfolds.

## Before the machine

[[File:jacquard-loom.jpg|right|300px|A [[Jacquard Loom|Jacquard loom]] — the cards chained above the head carried the program]]

### [[Jacquard Loom|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 card|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. Lyon weavers rioted against it; the machine won anyway, and within a decade eleven thousand looms were running card decks across France.

[[File:charles-babbage.jpg|left|220px|[[Charles Babbage]] in 1860 — he drew the computer before anyone could build one]]

### [[Charles Babbage|Babbage]] and [[Ada Lovelace|Lovelace]] (1830s–1843)

**[[Charles Babbage]]** designed the Difference Engine and then the **[[Analytical Engine]]**, a general-purpose mechanical computer with an arithmetic unit ("the mill"), memory ("the store"), and control flow driven by punched cards — the same cards Jacquard used. It was never finished; machining tolerances and funding ran out, and the design waited a century for the century that could build it.

[[File:ada-lovelace.jpg|right|240px|[[Ada Lovelace]] in the famous 1836 portrait — the first programmer of a machine that didn't exist]]

**[[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. A hundred years before the stored program ran, she had already written the reason to want one.

### Punch cards go practical (1890)

[[File:hollerith-tabulator.jpg|left|280px|Hollerith's tabulator — the [[Punched card|card]] that counted a nation]]

**[[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 card Jacquard invented to weave cloth ended up counting people, paying wages, and feeding the first electronic computers. The 80-column card became so standard that FORTRAN's fixed-column syntax, terminal widths, and print layouts still carry its proportions.

## The theory arrives before the hardware

[[File:alan-turing.jpg|left|220px|[[Alan Turing]] at sixteen — he defined computation before computers existed]]

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, with structured data, loops, and conditionals, decades ahead of its time and never implemented in his lifetime.

## [[The first programmers]]

[[File:eniac.jpg|right|340px|ENIAC at the Moore School, 1946 — programming it meant rewiring it]]

**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]]** — see [[The first programmers]] — were the first modern programmers, inventing subroutines and debugging as they went, largely uncredited for decades.

[[File:john-von-neumann.gif|left|220px|[[John von Neumann]] — the [[EDVAC report]] made the stored program a design]]

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.

## Software becomes an industry

The 1950s turned laboratories into vendors. **UNIVAC I** (1951) — built by Mauchly and Eckert after they left Penn, with [[Betty Jennings]] and [[Betty Snyder]] on its programming team — was the first commercial American computer, famous overnight when it predicted the Eisenhower landslide on live television in 1952. IBM's 701 followed, then the 704 that FORTRAN was built for. Computers stopped being one-off experiments and became products — and products needed programs people could actually write.

That need created the job title: "coder" split from "operator," and then from "programmer" entirely. Assemblers turned numeric opcodes into mnemonic text; flowcharts became documentation; the first programming *libraries* — Wilkes's EDSAC tape cabinet — meant software could finally be shared rather than re-derived.

## The age of languages

[[File:grace-hopper.jpg|right|240px|Grace Hopper at a UNIVAC console — she built the first compiler]]

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. Hopper's famous rule dates from this fight: *it is easier to ask forgiveness than permission*.

### 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.

### 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 — and it is [[AdaLogic BASIC]]'s direct ancestor in spirit.

- **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. A C64 out of the box was a language environment, a graphics tablet, and a synthesizer in one — and magazines printed full programs to type in by hand, making code a mass medium.

Meanwhile **Ada** (1980) was commissioned by the US Department of Defense for safety-critical systems — named for [[Ada Lovelace]] — **C++** (Bjarne Stroustrup, mid-80s) grew objects onto C, and **Turbo Pascal** (1983) made a fast compiler cheap enough for anyone — the first IDE most people ever saw.

### 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 language family tree

| Year | Language | Designer | Descends from |

| --- | --- | --- | --- |

| 1957 | [[FORTRAN]] | John Backus | — the first |

| 1958 | [[LISP]] | John McCarthy | lambda calculus |

| 1960 | [[ALGOL]] | Committee | — invented structure |

| 1964 | BASIC | Kemeny & Kurtz | FORTRAN simplified |

| 1970 | Pascal | Wirth | ALGOL |

| 1972 | C | Ritchie | ALGOL → BCPL → B |

| 1980 | Ada | DoD / Ichbiah | Pascal / ALGOL |

| 1991 | Python | van Rossum | ABC / C |

| 1995 | JavaScript | Eich | C syntax, Scheme ideas |

| 2015 | Rust (stable) | Graydon Hoare | C++ / ML |

| 2017+ | [[AdaLogic BASIC]] | Rocky L. Oliver | Ada + BASIC |

## 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.

## See also

- [[The first programmers]]

- [[FORTRAN]] · [[LISP]] · [[ALGOL]] — the three founding languages

- [[AdaLogic BASIC]]

- [[Punched card]]

- [[Main Page]]

[[Category:History]]

[[Category:Programming]]