What Is Programming? A Short History of Telling Machines What to Do

Ask ten developers what programming is and you will get ten answers: “writing code”, “solving problems”, “telling a computer what to do”. All of them are true, and none of them is quite enough. This article tries to pin the idea down, and then follows it through roughly two centuries of history — because most of what feels arbitrary about programming today makes sense once you know where it came from.

What programming is

At its core, programming is the act of describing a process precisely enough that a machine can carry it out without understanding it.

Each part of that sentence matters:

• A process. A program is not a static fact but a recipe — a sequence of steps that transforms some input into some output. Abelson and Sussman open their classic textbook by describing computational processes as abstract beings that inhabit computers, directed by “a pattern of rules called a program”.¹
• Precisely. Natural language tolerates ambiguity because the listener fills the gaps. A machine fills nothing. Every case — the empty list, the negative number, the file that does not exist — has to be decided in advance.
• Without understanding it. The machine does not know what the program is for. It follows rules mechanically. All the meaning lives with the programmer, which is why programs can be perfectly obeyed and still be wrong.

Algorithms, programs and languages

Three words are often used interchangeably, but they are worth separating:

Donald Knuth’s definition of an algorithm is the standard one: it must be finite (it terminates), definite (each step is precisely specified), have inputs and outputs, and be effective (each step is basic enough to actually be done).² The word itself comes from the name of the 9th-century Persian mathematician Muhammad ibn Musa al-Khwarizmi, whose works on arithmetic carried the Hindu–Arabic numerals into Europe.²

Algorithms are far older than computers. Euclid described his method for the greatest common divisor around 300 BCE, and it still runs unchanged today:

def gcd(a: int, b: int) -> int:
    """Euclid's algorithm: the greatest common divisor of a and b."""
    while b != 0:
        a, b = b, a % b
    return a

print(gcd(1071, 462))  # 21

Programming as abstraction

The other half of the definition is that programming is about managing complexity. A processor only understands very small operations — load a number, add two numbers, jump to another instruction. Everything else is built from layers of abstraction: machine code, then assembly language, then high-level languages, then libraries, frameworks and services. Each layer lets the programmer think in larger ideas while the layer below handles the detail.

Niklaus Wirth summarised the craft in the title of a 1976 book: Algorithms + Data Structures = Programs.³ Choosing how to represent information is as much a part of programming as choosing the steps that work on it.

A history of programming

Before computers: programs for looms and engines

The first machine “programs” were not for calculation at all. In 1804 Joseph Marie Jacquard patented a loom controlled by a chain of punched cards: each card encoded which threads to lift for one row of the pattern. Change the cards and the same loom wove a different fabric — the essential idea of separating the machine from its instructions.⁴

In the 1830s Charles Babbage designed the Analytical Engine, a mechanical, general-purpose computer that would have read its instructions from Jacquard-style cards. It was never completed, but it had the shape of a modern computer: a “store” (memory) and a “mill” (processor).

In 1843 Ada Lovelace translated an article on the engine by Luigi Menabrea and added a set of notes three times its length.⁵ Her Note G contains a step-by-step table for computing Bernoulli numbers on the engine, widely regarded as the first published computer program. More importantly, she saw past arithmetic: she suggested the engine could act on anything whose relations could be expressed symbolically, such as musical notes. That is the leap from calculator to computer.

At the end of the century, Herman Hollerith’s punched-card tabulating machines processed the 1890 US census. His company merged into the Computing-Tabulating-Recording Company in 1911, which was renamed IBM in 1924.⁶ Punched cards would remain the main way of feeding programs into computers until the 1970s.

1936: what can be computed at all?

Before anyone built an electronic computer, mathematicians asked a deeper question: which problems can be solved by a mechanical procedure at all?

In 1936 Alan Turing answered with an imaginary device — now called the Turing machine — that reads and writes symbols on an infinite tape according to a table of rules.⁷ He showed that a single universal machine could simulate any other one if given its rule table as input. That is, in theory, the stored-program computer: the program is just more data.

The same year, Alonzo Church reached equivalent conclusions with the lambda calculus, a system built entirely from function definition and application.⁸ The Church–Turing thesis — that these models capture everything that is “effectively computable” — remains the foundation of computer science. The lambda calculus would later become the direct ancestor of functional programming.

The 1940s: programming by hand

The first electronic computers were programmed physically. Konrad Zuse’s Z3 (1941) read instructions from punched film, and between 1942 and 1945 Zuse designed Plankalkül, arguably the first high-level programming language, though it was not published in full until 1972 and was first implemented only in 1975, by Joachim Hohmann.⁹

ENIAC, completed in 1945 at the University of Pennsylvania, was programmed by setting switches and plugging cables between its units — “programming” a new problem could take days. That work was done by a team of six women: Kathleen McNulty, Jean Jennings, Betty Snyder, Marlyn Wescoff, Frances Bilas and Ruth Lichterman. They worked out how to program the machine largely from its logical diagrams, and for decades their contribution went unrecognised.¹⁰

The fix for rewiring was the stored-program concept: keep the instructions in the same memory as the data. John von Neumann’s First Draft of a Report on the EDVAC (1945) described this design so clearly that it is still called the “von Neumann architecture”.¹¹ On 21 June 1948 the Manchester “Baby” became the first machine to run a program from electronic memory,¹² and Cambridge’s EDSAC followed in 1949. The EDSAC team — Maurice Wilkes, David Wheeler and Stanley Gill — published the first textbook on programming in 1951, introducing ideas such as the subroutine library.¹³

The 1950s: from machine code to languages

Early programs were written in raw numeric machine code, then in assembly language, where mnemonics like ADD stand for instructions. Both tie the program to one machine and force the programmer to manage every detail.

The next step was to let the computer translate a more human notation itself. Grace Hopper’s A-0 system (1952) assembled programs from a library of routines, and she argued forcefully that computers should do this kind of clerical work for programmers.¹⁴ Alick Glennie’s Autocode for the Manchester Mark 1 appeared the same year.¹⁵

The breakthrough came with FORTRAN (“Formula Translation”), developed at IBM by a team led by John Backus and released in 1957.¹⁶ Its compiler produced code nearly as efficient as hand-written assembly, which convinced a sceptical industry that high-level languages were practical. Within a few years three more foundational languages appeared:

• LISP (1958), by John McCarthy, built on the lambda calculus, with programs represented as lists, recursion and automatic memory management.¹⁷
• COBOL (1959–60), designed by the CODASYL committee and heavily influenced by Hopper’s FLOW-MATIC, aimed at business data processing in English-like syntax.
• ALGOL 60, which introduced block structure with lexical scope and was the first language whose syntax was defined in the formal notation now known as Backus–Naur Form.¹⁸ Almost every mainstream language since is, syntactically, a descendant of ALGOL.

The 1960s and 1970s: programming becomes a discipline

As programs grew, they became unreliable, late and expensive. In 1968 a NATO conference in Garmisch, Germany, put a name to the problem — the “software crisis” — and popularised the term software engineering.¹⁹

The same year Edsger Dijkstra published his letter Go To Statement Considered Harmful,²⁰ arguing that unrestricted jumps made programs impossible to reason about. The resulting structured programming movement — sequence, selection and iteration as the only control structures — is now so universal that it is hard to see it as an idea that once had to win an argument.

This period also produced the paradigms we still use:

• Object-oriented programming began with Simula (1962–67) by Ole-Johan Dahl and Kristen Nygaard, which introduced classes and objects for simulation,²¹ and was developed further by Alan Kay’s Smalltalk at Xerox PARC in the 1970s.²²
• Systems programming was transformed by C (1972), developed by Dennis Ritchie at Bell Labs as the implementation language for Unix, whose kernel was rewritten in C in 1973. C gave programmers close control over the machine while remaining portable across hardware.²³
• Pascal (1970), by Niklaus Wirth, was designed to teach structured programming clearly.²⁴
• Logic and functional programming took shape with Prolog (1972) and ML (1973), the latter introducing type inference that many modern languages have since borrowed.

The 1980s and 1990s: personal computers and the internet

Cheap microcomputers put programming in homes and schools, often through BASIC. Object orientation went mainstream with C++ (1985), which Bjarne Stroustrup built by adding Simula-style classes to C.²⁵

The 1990s brought languages shaped by the internet and by programmer productivity rather than raw machine efficiency: Python (first released in 1991 by Guido van Rossum),²⁶ Java (1995), with its promise of “write once, run anywhere” on a virtual machine, and JavaScript (1995), prototyped by Brendan Eich in about ten days to make web pages interactive and now one of the most widely deployed languages in the world.²⁷ Garbage collection, virtual machines and huge standard libraries went from research ideas to everyday expectations.

The 2000s to today

Recent decades have been less about inventing paradigms than combining and refining them. Languages such as C# (announced in 2000), Go (2009), Rust (1.0 in 2015)²⁸ and Swift (2014) mix object-oriented, functional and systems ideas, with a strong focus on safety — particularly memory safety and concurrency.

Meanwhile, the work around code has changed as much as the code itself: version control, open-source collaboration, automated testing, continuous integration and cloud deployment are now part of what “programming” means in practice. Since the early 2020s, assistants built on large language models have begun generating and reviewing code from natural-language descriptions — in a sense, the latest step in the long move toward letting the machine handle more of the translation from intent to instructions.

A timeline at a glance

Why the history matters

Almost every habit of modern programming is the answer to a problem someone hit earlier. We store programs in memory because rewiring ENIAC was unbearable. We use high-level languages because FORTRAN proved compilers could compete with hand-written code. We write loops instead of goto because Dijkstra showed we could not otherwise reason about our programs. We fuss over memory safety because decades of C taught us what its absence costs.

The machines have changed beyond recognition since Lovelace’s notes, but the job has not: understand a process well enough to describe it with complete precision, and organise that description so that people — including your future self — can still understand it.

References