Chapter 1: A Journey Through Time: The Origin of Operating Systems and the Linux Kernel Story

The hum of the IBM 701 mainframe in 1956 filled a windowless room at the General Motors Research Laboratory, where a team of engineers waited three days for their batch of ballistic trajectory calculations to finish. When the printout finally emerged, it carried a single, costly error: a misplaced decimal point in the input deck of punched cards, rendering the entire run useless. That moment of frustration, repeated across universities and corporations in the post-war era, was not just a story of inefficient computing—it was the first crack in the foundation of an industry that would eventually give birth to the Linux kernel. For decades before Linus Torvalds posted his famous 1991 message to the comp.os.minix newsgroup, the story of operating systems was a story of incremental progress, bitter corporate rivalries, and a quiet rebellion against the idea that computing power should be hoarded by a privileged few.

To understand why Linux exists in its current form—and why its three core subsystems of process management, memory management, and file systems are the pillars of modern computing—we have to travel back to that first batch processing system, and trace the messy, human path from room-sized machines to the 30-million-line codebase that powers 90% of the world’s public cloud, 100% of the TOP500 supercomputers, and 3 billion+ mobile devices. This is not just a history of technology; it is a story of tradeoffs, community, and the radical idea that the most critical software in the world could be built, maintained, and owned by everyone.

The Pre-Operating System Era: When Computers Were Human Calculators

Before operating systems, computing was a manual, batch-driven process. The ENIAC, completed in 1945, had no operating system in any modern sense: programmers rewired the machine by hand to run each calculation, a process that could take days for a job that ran for minutes. By the early 1950s, IBM’s 701 introduced the concept of a “loader” program that could read punched cards and execute code automatically, but it still required operators to mount tapes, load card decks, and interpret error messages by hand. The batch processing systems of the 1950s, like the IBM 7090’s IBSYS, were the first ancestors of modern operating systems, but they were designed for throughput, not interaction. A single job could run for hours, and if it failed, the programmer would not know for days.

The pain point of batch processing was not just inefficiency—it was waste. In 1956, the cost of an hour of mainframe time was roughly $300 (equivalent to $3,500 in 2024), and a single deck of 2,000 punched cards cost $25. A single error in input could waste thousands of dollars and days of wait time. It was this frustration that drove the first push for interactive computing, led by researchers at MIT who wanted to use computers for real-time scientific simulation, not just payroll processing and ballistic calculations.

The Birth of Time-Sharing: The Unix Origin Story

In 1961, MIT’s Compatible Time-Sharing System (CTSS) became the first system to allow multiple users to interact with a single computer simultaneously via terminals. For the first time, a researcher could log in, run a program, get results in seconds, and log off, without waiting for a batch job to finish. CTSS was a revelation, but it was limited: it ran on a modified IBM 7094 with only 32KB of memory, and its codebase was tightly coupled to the hardware.

This limitation drove the next big leap: the Multics (Multiplexed Information and Computing Service) project, a collaboration between MIT, Bell Labs, and General Electric in 1964. Multics was designed to be a general-purpose, secure, multi-user time-sharing system that could run on a GE-645 mainframe, with support for dynamic linking, hierarchical file systems, and fine-grained access control. It was, by any measure, decades ahead of its time. But it was also catastrophically overengineered. The team’s ambition to build a system that could do everything led to a codebase that required 1MB of memory to run—a staggering amount in 1964, when most minicomputers had 64KB or less. Bell Labs pulled out of the project in 1969, frustrated by the slow progress and the system’s complexity.

Two Bell Labs researchers, Ken Thompson and Dennis Ritchie, were not ready to give up on the idea of a usable time-sharing system. Thompson had been writing a space travel game for the GE-645, and when the Multics hardware was decommissioned, he needed a new platform to run it. He found a discarded PDP-7 minicomputer in the corner of the Bell Labs office, and in the summer of 1969, he and Ritchie wrote a small operating system for it, in assembly language. They called it Unics (Uniplexed Information and Computing Service), a pun on Multics. It had a hierarchical file system, a simple shell, and a small set of utilities, all in about 10,000 lines of code. By 1973, Ritchie and Thompson had rewritten the entire kernel in C, a language Ritchie had created specifically for this purpose. This was a revolutionary step: for the first time, an operating system could be ported to new hardware by recompiling the code, rather than rewriting it entirely in assembly.

Unix’s early success was driven by Bell Labs’ policy of distributing the source code to universities for a nominal fee. By the late 1970s, Unix was running on everything from mainframes to minicomputers to early workstations, and the University of California, Berkeley had released its own variant, the Berkeley Software Distribution (BSD), which added TCP/IP networking, the vi editor, and the C shell. But Unix’s success was also its undoing. AT&T, which had acquired Bell Labs in 1982, began enforcing stricter licensing terms for Unix, and by the 1980s, the Unix market had fractured into dozens of incompatible variants: Sun’s SunOS, IBM’s AIX, HP’s HP-UX, and Microsoft’s Xenix all competed for market share, each with their own proprietary APIs and hardware lock-in. A Sun workstation cost $10,000 in 1990 (roughly $23,000 in 2024), putting it out of reach for all but the wealthiest universities and corporations.

It was into this gap that Linus Torvalds stepped.

The Hobby That Ate the World: Linus Torvalds and the 1991 Kernel Release

Linus Benedict Torvalds was a 21-year-old computer science student at the University of Helsinki in 1991. He had been using Andrew Tanenbaum’s Minix, a small Unix-like operating system written for teaching purposes, on his home-built 80386 PC. Minix was affordable—it cost $69 for a copy on 3.5-inch floppies—but it was limited: it lacked virtual memory, had a rudimentary network stack, and its licensing terms prohibited commercial use. Torvalds wanted a system that could run on his cheap PC hardware, support POSIX standards, and let him