Computer program

Software was born on paper, not in electronics. In 1843 Ada Lovelace published Note G, her long appendix to Luigi Menabrea's paper on Babbage's `analytical-engine`, and included a tabular method for calculating Bernoulli numbers. Charles Babbage had drafted earlier routines for his machine, so Lovelace's claim is best understood as the first published computer program rather than the first time anyone imagined machine instructions. What mattered was not who wrote the very first sequence, but that the sequence became a reusable public object: a procedure that could be separated from the machine and studied in its own right.

That separation only became thinkable after two older lines met. One was the `difference-engine`, which taught Babbage that a long calculation could be decomposed into small repeatable operations. The other was the `jacquard-loom`, whose punched cards showed that a machine could follow an external instruction stream instead of being fixed forever by its internal shape. `path-dependence` is plain here. Table making, textile control, and mechanical arithmetic were already mature enough that Lovelace and Babbage could treat calculation as choreography rather than inspiration.

Note G also created powerful `founder-effects`. Lovelace's table did not simply list answers; it organized operations, intermediate values, repetitions, and dependencies in an ordered sequence. That is the deep body plan of software. Later programmers changed the medium from cards and paper to mercury delay lines, magnetic cores, silicon memory, and cloud servers, but they kept the same grammar: break a task into steps, store state, repeat where possible, branch when needed, and let the machine execute the plan faster and more faithfully than a human clerk could.

Britain supplied the first habitat, which is why `niche-construction` belongs in the story. The same society that wanted accurate navigational tables, actuarial calculations, and astronomical data also had precision workshops, mathematical publishing circles, and living examples of programmable control in weaving. Lovelace's program emerged in `united-kingdom` because Babbage's machine project had already built a local ecology around programmable calculation. Yet the ecology was still incomplete. No full Analytical Engine was finished, so the program existed first as a conceptual species waiting for a workable machine host.

Once electronic memory and switching arrived, the same species reappeared through `convergent-evolution`. In Germany during the 1940s, Konrad Zuse treated procedures as formal symbolic objects in his Plankalkul work. In Manchester on June 21, 1948, the Baby executed a stored routine and proved that a program could live inside memory rather than on a stack of cards or a wiring diagram. Those teams were not copying Lovelace line by line. They were arriving at the same adjacent possible from a new material base: if a general machine exists, it needs detachable instructions.

That shift enabled the `stored-program-computer`, the architecture that turned software from notation into an editable machine resident. Once programs and data occupied the same memory, code could be loaded, tested, altered, copied, and replaced without rebuilding hardware. A second cascade followed with the `operating-system`. If one program could direct a machine, another could schedule jobs, manage files, allocate memory, and supervise many other programs. Software stopped being a single recipe and became a layered ecology of interacting routines.

Commercial scale came much later, and it came through firms that understood software as a product rather than a side effect of hardware. `ibm` helped industrialize programming when the FORTRAN project began in 1954 and shipped commercially in 1957, showing that a program could be maintained, ported, and sold across many installations instead of rewritten machine by machine. `microsoft` pushed the same abstraction into the mass market in 1975 with Altair BASIC, then with operating systems and application software whose value lived in code more than in the box that ran it. By then the computer program had crossed a threshold: it was no longer merely a way to instruct a machine, but an asset with its own economics, update cycles, and competitive moats.

That later software world kept radiating outward. Techniques such as `backpropagation` depend on the program's ability to record long chains of operations and then walk back through them to assign error. Networked services, packaged applications, and AI systems all inherit the same nineteenth-century wager that a machine's behavior can be written down, revised, and rerun. Seen from the adjacent possible, the computer program was the moment procedure became portable. Hardware still mattered, but after 1843 the intelligence of a machine no longer had to be welded into its frame. It could be written, copied, debugged, and evolved.