Time-sharing

A million-dollar computer that serves one person at a time is not a computing model. It is an expensive queue. That was the reality of the late 1950s. Users punched cards, handed them to operators, and waited for the machine to return a result long after the original train of thought had cooled.

In 1959, Christopher Strachey in Britain and John McCarthy in the United States separately described a different arrangement. Instead of dedicating one large machine to one job at a time, let many people share it in tiny slices so quickly that each experiences the illusion of a private computer. The insight was economic before it was philosophical. Mainframes were scarce capital goods. Human attention was not. Burning an hour of a mathematician's time to discover a typo in line three was a bad trade.

The stored-program computer made the idea technically plausible. Once programs and data lived in writable electronic memory, supervisory software could suspend one user, load another, protect address spaces, and resume work fast enough to fake simultaneity. Time-sharing looked social on the surface, but its deep prerequisite was architectural: computing had to become interruptible, relocatable, and governable by software rather than fixed wiring.

The idea only mattered once somebody made it work. At MIT, Fernando Corbato's team built the Compatible Time-Sharing System, first demonstrated in 1961 and matured on IBM 7090 and 7094 hardware. IBM mattered here not as a logo but as an ecological host. CTSS needed memory protection, swapping drums, disk files, and communications controllers sturdy enough to keep many users from trampling one another. By the middle of the decade, CTSS could support roughly 30 simultaneous users at remote terminals. They could edit, compile, run, save files, log back in later, and even send messages that plainly foreshadowed email.

Convergent evolution shaped the field from the start. Strachey's 1959 paper for the UNESCO conference in Paris and McCarthy's near-simultaneous American advocacy were not coincidences. MIT's CTSS and Dartmouth's later system were not coincidences either. The same selection pressure existed on both sides of the Atlantic: too many researchers and students wanted computational access, too few machines existed, and batch delay had become intolerable for debugging, teaching, and exploratory work.

Once several people could inhabit one system, network effects appeared inside computing itself. A shared machine became more valuable when more users joined it, because they wrote utilities, exposed bugs, invented conventions, and generated reasons to stay online. CTSS users were exchanging messages by 1965. Shared directories, command libraries, and account systems turned a computer from a calculator into a social environment.

Dartmouth showed that the model could leave elite research centers. Using General Electric hardware, John Kemeny and Thomas Kurtz launched the Dartmouth Time-Sharing System on May 1, 1964, alongside BASIC. Computing stopped looking like priestly batch processing and started looking like a campus utility. That was niche construction in plain form. Time-sharing created the habitat that beginner programmers needed, and those new programmers then justified more terminals, more software, and more institutional spending.

Path dependence followed quickly. Once users expected conversational access, the industry had to provide logins, permissions, file systems, editors, and remote sessions as ordinary features rather than exotic add-ons. ARPA's networking agenda inherited the same assumption that computation should be reached interactively from somewhere else, which made packet switching feel like a next step rather than a leap. Project MAC's Multics, backed first by General Electric and later by Honeywell, tried to turn time-sharing into a utility-grade public service. Even where Multics proved too heavy, the expectations it normalized survived.

One of those survivors was the portable operating system. Bell Labs stripped down the large-system ambitions of Multics into Unix, but it kept the central social fact that time-sharing had already established: many users, many processes, one machine, and software standing between them. That assumption later scaled down into minicomputers and up into network services.

Time-sharing mattered because it reversed the direction of computing. Before it, humans lined up for machines. After it, machines mediated communities of humans. Modern cloud computing still lives inside that inversion: one pool of computation, many users, slices handed out so fast that exclusivity feels personal.