Maurice Wilkes, David Wheeler, and the Birth of Reusable Subroutine Libraries
The EDSAC team made reusable subroutines a practical programming method, combining a paper-tape library, loading conventions and David Wheeler's closed-subroutine technique.
EDSAC was built as a computing service, so programming productivity mattered immediately
Maurice Wilkes’s EDSAC at Cambridge ran its first programs in May 1949. The Computer History Museum emphasizes that Wilkes did more than build a stored-program machine: he established a library of short programs, or subroutines, stored on punched paper tape for recurring calculations.[1]
The decision reflected EDSAC’s institutional purpose. The machine was meant to serve university researchers from many disciplines. If every user had to recreate input routines, arithmetic functions and output formatting from scratch, the computer would spend much of its life supporting repeated programming labor rather than new scientific work.
Reusable code began as physical library material
The word “library” was literal as well as conceptual. Tested routines could be stored on separate paper-tape strips, catalogued and incorporated into new programs when needed.
The Initial Orders turned program loading into software infrastructure
EDSAC’s startup routines, known as the Initial Orders, read symbolic information from paper tape and assembled it into machine words. This made the loader itself an early piece of system software rather than a passive input mechanism.
Cambridge’s later history of EDSAC describes how Wilkes and colleagues used this infrastructure to support relocatable subroutines and a load-module approach, allowing a programmer to combine reusable components instead of coding every operation sequentially.[2]
Relocation and linking were already programming-system problems
A reusable routine cannot simply be copied anywhere if its internal references assume one fixed address. Early library systems therefore had to solve versions of relocation, calling convention and return-control problems that later linkers and loaders would formalize.
David Wheeler made the closed subroutine practical
David Wheeler joined the EDSAC effort as a research student and became one of its most important early programmers. Cambridge commemorates him specifically for pioneering subroutines and credits him with the invention of the closed subroutine.[3]
The technique popularly known as the “Wheeler jump” provided a practical way to enter a shared routine and return to the calling program. Instead of duplicating a routine’s instructions at every use, a program could transfer control to one stored copy and then resume after the call.
A calling convention makes control flow reusable
The profound idea was not merely jumping to another address. The program needed a convention for remembering where it came from and arranging data so one routine could safely serve many different callers.
The library became a social system among EDSAC users
Cambridge reminiscences show that subroutines were written, tested and contributed by members of the user community. Former researcher D. H. Shinn remembered Wheeler spending substantial time in 1950 writing and testing routines for others, while Leonard Dresel recalled contributing a published routine to the library.[4]
This is an early example of software reuse becoming shared infrastructure. The value of a library grows when users trust common components enough to stop rewriting them and when those components are documented well enough to survive beyond their original authors.
Reusability depends on confidence as much as syntax
A routine saves time only if programmers believe it is correct, documented and compatible with their own programs. Testing, naming and conventions were therefore essential parts of the library model.
The 1951 programming book made the method transferable beyond Cambridge
Wilkes, Wheeler and Stanley Gill’s The Preparation of Programs for an Electronic Digital Computer became one of the foundational texts of programming practice. Cambridge’s historical account highlights it as one of the first programming books and notes its treatment of relocatable subroutines.[2]
The book transformed local EDSAC experience into a teachable method. Other groups could study program preparation, checking, library organization and reusable routines without having worked inside the Cambridge laboratory.
Subroutine libraries changed what a program could be made of
Before reusable routines, a program tended to look like a unique instruction sequence written for one job. A library introduced a compositional model: a new program could be assembled partly from existing trusted pieces and partly from problem-specific code.
That shift is a conceptual ancestor of standard libraries, packages and APIs. The later mechanisms are vastly more sophisticated, but the economic logic is the same—capture a solved programming problem once and let many future programs reuse the solution. It also changed ownership of knowledge: a numerical method could be embodied in a routine and inherited by users who never met its author.
System software began to outlive individual applications
The Cambridge Computer Laboratory’s Relics Project preserves EDSAC documents, order codes and accounts of the Initial Orders, showing how central this shared software layer became to the machine’s use.[5]
Applications came and went, but the routines that loaded, assembled, called and supported programs formed a durable environment. The need for standard tape formats, symbolic conventions and relocation rules also shows that reuse requires infrastructure around the code, not merely the code itself.
Why Wilkes and Wheeler belong in the origins of programming
The mathematical idea of a subroutine predates EDSAC, and other early groups also explored reusable code. The Cambridge achievement was to make reuse operational in a working stored-program computing service: library tapes, loading conventions, relocatable routines, calling techniques, documentation and a user community reinforced one another.
Wilkes supplied the service environment and library vision; Wheeler’s closed-subroutine work solved a key control-flow problem; Gill helped codify the method in the 1951 text.[1][3] Together they helped change programming from writing one monolithic instruction sequence into building programs from reusable components.
The paper-tape library also forced practical conventions on the community. A reusable routine needed a known calling method, assumptions about data placement, documentation and a way to be loaded without destroying the caller’s program. Those requirements turned a clever subroutine into a shareable software component and foreshadowed the metadata and interface contracts that later library and package systems would formalize.
Works Cited
- 01Computer History Museum — 1949: EDSAC and Wilkes's Subroutine Library computerhistory.org
- 02Whipple Museum, University of Cambridge — EDSAC and Computing in Cambridge whipplemuseum.cam.ac.uk
- 03
- 04
- 05
CodeHistory is a living archive. Citations document the evidence used for this edition; later evidence may refine the account.
Submit a research lead