The History of the Operating System

The History of the Operating System

An operating system is the foundational software that manages computer hardware and software resources, acting as an intermediary between physical components and application programs.^[37] Its primary functions include managing central processing unit time, allocating memory space, controlling storage and peripheral devices, and providing a stable abstraction layer for software developers. Without an operating system, every application would need to include its own drivers for every possible hardware configuration, making software development highly inefficient and hardware interoperability nearly impossible.

The history of the operating system represents a continuous progression driven by the shifting economic constraints of computing.^[38] In the early decades of the industry, hardware was astronomically expensive, and operating systems were designed strictly to maximize the utilization of the processor. As hardware became cheaper and ubiquitous, the primary constraints shifted. Operating systems evolved to prioritize programmer productivity, software portability, user experience, and eventually power efficiency and distributed network management.

Today, operating systems range from minimal embedded microkernels managing industrial sensors to massive distributed orchestrators managing global cloud infrastructure. Modern operating systems consist of millions of lines of code and incorporate complex security models, memory virtualization, and hardware abstraction techniques. The development of these systems involves a long sequence of technical compromises, standardizations, and commercial battles that shaped the modern computing environment.

The Pre-Operating System Era and Batch Processing (1940s to 1950s)

The earliest electronic computers, such as the Electronic Numerical Integrator and Computer (ENIAC) developed at the University of Pennsylvania in the 1940s, possessed no operating system ENIAC History^[1]. These machines were programmed manually by plugging cables into patch panels and setting physical switches. When the stored-program architecture emerged with machines like the Electronic Discrete Variable Automatic Computer (EDVAC), programs were loaded into memory via punched cards or paper tape First Draft of a Report on the EDVAC. During this era, a human operator acted as the operating system. The operator would load the compiler tape, load the source code tape, execute the compilation, and then load the resulting object code tape to run the program.

This manual process created a severe economic inefficiency. Early mainframe computers like the IBM 701 cost thousands of dollars per month to rent and operate, not per hour, yet the processor sat completely idle while human operators walked around the room changing tapes. To solve this constraint, programmers at General Motors Research Laboratories and North American Aviation developed GM-NAA I/O in 1956 for the IBM 704 1956 Timeline^[2]. GM-NAA I/O is widely considered the first operating system. It functioned as a resident monitor that automated batch processing. Programmers submitted their jobs on punched cards, which were copied sequentially onto a single magnetic tape. The resident monitor read the tape, executed the first job, recorded the output to another tape, and immediately began the next job without human intervention.

In 1959, the SHARE user group, a collective of IBM mainframe customers, heavily modified GM-NAA I/O to create the SHARE Operating System (SOS) SHARE Operating System^[3]. SOS introduced standard input and output routines, allowing programmers to write software without needing to know the exact physical track and sector layout of the storage devices. This represented the first major collaborative software development effort and established the concept of hardware abstraction, which remains a core function of all modern operating systems.

Multiprogramming, Virtual Memory, and Time-Sharing (1960s)

While batch processing eliminated human delays, it did not solve the input and output bottleneck. Mechanical tape drives and card readers were vastly slower than electronic processors. When a program requested data from a tape, the processor sat idle waiting for the mechanical operation to complete. To address this, computer scientists developed multiprogramming, a technique where multiple programs are loaded into memory simultaneously. When one program pauses to wait for data, the operating system directs the processor to execute instructions from another program.

Multiprogramming required advanced memory management. In 1962, the Atlas computer at the University of Manchester introduced the Atlas Supervisor, which implemented the first virtual memory system Atlas Computer Documents^[4]. The Atlas Supervisor divided memory into fixed-size blocks called pages. It kept the most actively used pages in fast magnetic core memory and swapped inactive pages to slower magnetic drum storage Virtual Memory Computing Surveys^[5]. This paging system gave programmers the illusion of a massive, continuous memory space, abstracting away the physical limitations of the hardware.

Simultaneously, researchers sought to make computers interactive. Batch processing required programmers to wait hours or days for results. In 1961, Fernando Corbató and his team at the Massachusetts Institute of Technology (MIT) demonstrated the Compatible Time-Sharing System (CTSS) CTSS History. CTSS used a hardware timer to interrupt the processor multiple times per second, rapidly switching execution between different user programs CTSS FJCC Paper^[6]. This allowed multiple users sitting at teletype terminals to interact with the mainframe simultaneously, with each user experiencing the illusion of having a dedicated computer.

The commercial climax of this era was the announcement of IBM OS/360 in 1964 IBM System/360 Announcement. IBM intended OS/360 to be a single, unified operating system that would run across the entire System/360 family of computers, replacing dozens of incompatible systems. The project proved vastly more complex than anticipated. The software was delivered late and required far more memory than planned. The project manager, Fred Brooks, later analyzed the failures in his book The Mythical Man-Month, formulating Brooks's Law, which states that adding human resources to a late software project makes it later due to communication overhead The Mythical Man-Month^[7].

In 1965, MIT, Bell Labs, and General Electric began a joint project to build Multics (Multiplexed Information and Computing Service) Multics History^[8]. Multics was highly ambitious, introducing a hierarchical file system, dynamic linking, and a security model based on concentric rings of privilege Multics Security Rings^[9]. However, its complexity led to severe performance issues on the hardware of the time, prompting Bell Labs to withdraw from the project in 1969.

The Unix Philosophy and the Drive for Portability (1970s)

Following the withdrawal from Multics, Bell Labs researchers Ken Thompson and Dennis Ritchie sought to create a simpler, more efficient environment for software development. In 1969, they developed Unics (later renamed Unix) on a discarded Digital Equipment Corporation PDP-7 minicomputer Unix History.^[39] Unix introduced a minimalist design philosophy. Instead of building large, monolithic programs, the Unix philosophy encouraged writing small, single-purpose utilities that could be chained together using a feature called pipes.

The most significant contribution of Unix was its portability. Prior to 1972, operating systems were written in assembly language, meaning they were tightly coupled to the specific instruction set of the processor they ran on. To move an operating system to a new computer architecture required rewriting the entire system from scratch. To solve this, Ritchie created the C programming language C Language History^[10]. Between 1972 and 1973, Thompson and Ritchie rewrote the Unix kernel in C Unix CACM Paper^[11]. This allowed Unix to be ported to entirely different hardware architectures simply by writing a new C compiler for the target machine.

Because AT&T (the parent company of Bell Labs) was bound by a 1956 antitrust consent decree that forbade it from entering the commercial computing business, the company licensed Unix to universities for the cost of the magnetic tape media. This led to widespread academic adoption. At the University of California, Berkeley, students and researchers modified the system to create the Berkeley Software Distribution (BSD) Explaining BSD^[12]. In the late 1970s and early 1980s, BSD developers integrated the Transmission Control Protocol and Internet Protocol (TCP/IP) into the kernel, making BSD the foundational operating system of the early Internet RFC 793^[13].

UNIX System V was released in 1983, before the AT&T breakup was finalized in 1984. This sparked the "Unix Wars," a period of intense commercial fragmentation as vendors like Sun Microsystems, IBM, and Hewlett-Packard developed incompatible Unix derivatives. To prevent total fragmentation, the Institute of Electrical and Electronics Engineers (IEEE) published the POSIX (Portable Operating System Interface) standard in 1988, which defined a common application programming interface for Unix-like systems IEEE POSIX Standard^[14].

Microcomputers and the Standardization of the BIOS (Late 1970s to 1980s)

While Unix dominated minicomputers and mainframes, the invention of the microprocessor (such as the Intel 8080) created a new class of microcomputers Intel 8080 History^[15]. These early personal computers were severely constrained by cost, often featuring only 4 kilobytes to 64 kilobytes of memory. They lacked the hardware necessary for memory protection or multiprogramming, forcing operating system design to regress to single-tasking models.

Gary Kildall developed CP/M (Control Program for Microcomputers) in 1974, but he did not found Digital Research until 1976 CP/M Source Code^[16]. Kildall separated the operating system into two parts: the hardware-independent core and the Basic Input/Output System (BIOS). The BIOS contained the specific drivers for the disk controllers and serial ports. By rewriting only the BIOS, computer manufacturers could run the exact same CP/M software on hundreds of different hardware designs. This standardization created the first broad commercial software market for personal computers.

When IBM decided to build the IBM Personal Computer in 1981, they needed an operating system IBM PC Birth. After negotiations with Digital Research failed, IBM contracted Microsoft. Microsoft purchased an existing CP/M clone called 86-DOS from the company Seattle Computer Products, not from Tim Paterson himself (who was the developer), modified it, and licensed it to IBM as PC DOS. Microsoft retained the right to license the software to other manufacturers as MS-DOS MS-DOS Source Code^[17]. MS-DOS dominated the 16-bit computing era. It was a single-user, command-line system that provided no memory protection. If an application crashed, the entire system halted, reflecting the strict transistor constraints of the Intel 8088 processor.

Graphical User Interfaces and the Desktop Era (1980s to 1990s)

Command-line interfaces required users to memorize complex syntax. The solution emerged from Xerox PARC, which developed the Alto computer in 1973 Xerox Alto Exhibit^[18]. The Alto featured the first graphical user interface (GUI) utilizing windows, icons, menus, and a pointing device (the mouse).

Apple Computer commercialized this concept. Following the commercially unsuccessful Apple Lisa in 1983, Apple released the Macintosh in 1984, running System 1 Macintosh System 1^[19]. The classic Mac OS brought the GUI to the consumer market. It utilized cooperative multitasking, a system where applications had to voluntarily yield the processor to allow other programs to run. If a single application entered an infinite loop, the entire graphical interface would freeze.

Microsoft responded by releasing Windows 1.0 in 1985 Windows 1.0 Press Release. Initially, Windows was not a standalone operating system but a graphical operating environment that ran on top of MS-DOS. Other systems, such as Commodore AmigaOS, introduced preemptive multitasking and advanced multimedia capabilities to the home market in 1985, though they eventually lost market share to the IBM PC compatible standard AmigaOS History^[20].

To address the instability of MS-DOS, Microsoft hired Dave Cutler from Digital Equipment Corporation to build a completely new, 32-bit operating system aimed at enterprise environments. Released in 1993, Windows NT (New Technology) featured a hybrid kernel, preemptive multitasking, and a Hardware Abstraction Layer (HAL) that allowed it to run on multiple processor architectures, including x86, MIPS, and Alpha Windows NT Version History^[21].

For consumers, Microsoft released Windows 95, which merged MS-DOS and the Windows graphical shell into a single product Windows 95 Launch. Windows 95 introduced the Start menu, long filename support, and 32-bit preemptive multitasking, though it retained significant 16-bit legacy code for backward compatibility. Apple, struggling with the aging architecture of the classic Mac OS, acquired NeXT in 1996. This acquisition provided Apple with NeXTSTEP, a Unix-based operating system that served as the technical foundation for Mac OS X NeXTSTEP History^[22].

The Open Source Movement and the Monolithic Kernel (1990s)

During the 1980s, proprietary Unix systems became increasingly expensive and fragmented. In 1983, Richard Stallman launched the GNU Project with the goal of creating a completely free, Unix-compatible operating system The GNU Manifesto^[23]. Stallman drafted the GNU General Public License (GPL), a legal framework that required anyone who modified and distributed the software to release their source code under the same terms. By 1990, the GNU Project had successfully built a C compiler (GCC), a text editor (Emacs), and basic system utilities, but their microkernel project, GNU Hurd, was severely delayed.

In 1991, Linus Torvalds, a university student in Finland, announced a hobbyist operating system kernel on the comp.os.minix newsgroup Torvalds Minix Post^[24]. Torvalds combined his kernel, named Linux, with the GNU utilities to create a fully functional, free operating system Linux Kernel Archives^[25].

The architecture of Linux sparked a highly publicized academic debate in 1992 between Torvalds and Andrew Tanenbaum, the creator of the MINIX operating system Tanenbaum-Torvalds Debate^[26]. Tanenbaum argued that microkernels, which run most operating system services (like file systems and device drivers) in isolated user space, were technically superior and more secure. Torvalds defended the monolithic kernel design of Linux, where all core services run in a single privileged memory space (kernel space). Torvalds argued that monolithic kernels provided vastly superior performance by avoiding the overhead of passing messages between isolated components.

In practice, the performance advantages of the monolithic design won the commercial market. Linux became the dominant operating system for web servers, forming the foundation of the LAMP stack (Linux, Apache, MySQL, PHP/Python/Perl) that powered the expansion of the World Wide Web in the late 1990s and early 2000s LAMP Stack^[27].

Mobile Operating Systems and Extreme Power Constraints (2000s to 2010s)

The transition to mobile computing introduced severe new hardware constraints. Smartphones operated on small batteries, lacked active cooling fans, and relied on intermittent cellular network connections. Symbian was a smartphone operating system that did provide APIs for complex software, not a feature phone operating system Symbian OS^[28].^[40]

In 2007, Apple released iOS (originally named iPhone OS). Rather than building a mobile operating system from scratch, Apple scaled down Mac OS X. iOS utilized the Darwin core and the XNU hybrid kernel, bringing advanced Unix capabilities to a mobile device Darwin Kernel Architecture^[29]. However, the original iPhone possessed only 128 megabytes of physical memory and used flash storage that degraded with frequent write cycles. To protect the flash memory, iOS did not use a swap file for virtual memory. Instead, the operating system aggressively managed memory by terminating background applications and strictly limiting background processing to preserve battery life.

In 2008, Google released Android, an open-source mobile operating system based on a heavily modified Linux kernel Android Open Source Project^[30]. Because Google intended Android to run on a vast array of hardware configurations from different manufacturers, they required a hardware-independent application layer. Android applications were written in Java and executed within a managed virtual machine (initially Dalvik, and later the Android Runtime) Dalvik Runtime. This virtual machine handled memory allocation and garbage collection, isolating application developers from the specific hardware architecture of the phone.

The mobile era fundamentally changed the operating system security model. Desktop operating systems traditionally relied on perimeter defense, assuming that any software executed by the user had full access to the user's files. Mobile operating systems shifted to an application sandboxing model. Applications are distributed through centralized stores and installed in isolated storage containers. The operating system acts as a strict mediator, requiring explicit user permission before an application can access the camera, microphone, or location hardware.

Distributed Systems, Virtualization, and the Cloud (2010s to Present)

As server hardware became exponentially more powerful, running a single operating system on a single physical machine resulted in vastly underutilized processors. To solve this, the industry adopted hardware virtualization. Hypervisors (such as Xen, KVM, and VMware ESXi) act as operating systems for operating systems Xen Project^[31]. A Type 1 hypervisor runs directly on the bare metal hardware and allocates virtualized processor cores, memory, and network interfaces to multiple guest operating systems running simultaneously.

While hypervisors maximize hardware utilization, booting a full guest operating system for every application consumes significant memory and storage. This constraint led to the popularization of OS-level virtualization, commonly known as containers. Containers utilize specific features of the Linux kernel, specifically namespaces (which isolate process visibility) and cgroups (which limit resource usage), to run isolated applications sharing a single underlying kernel Linux cgroups Documentation^[32]. The release of Docker in 2013 standardized the packaging and deployment of these containers Docker Overview^[33].

In the modern cloud computing environment, the data center operates as a single computer. Operating systems now function as individual nodes within a massive distributed system. Orchestration platforms like Kubernetes act as cluster-level operating systems, automatically scheduling containers across thousands of physical machines, managing network routing, and attaching distributed storage volumes Kubernetes Concepts^[34].

The modern state of the operating system is highly stratified and abstracted. At the lowest level, hypervisors and secure microkernels manage hardware execution and cryptographic enclaves, such as ARM TrustZone ARM TrustZone Architecture^[35]. In the middle tier, traditional monolithic and hybrid kernels (Linux, Windows NT, XNU) manage local resources and hardware drivers. At the highest level, distributed orchestrators manage global fleets of servers. For the end user, the local operating system has increasingly receded into the background. On desktop devices, systems like ChromeOS function primarily as secure bootloaders for a web browser, shifting the burden of application execution and data storage entirely to the distributed cloud Chromium OS Architecture^[36]. The operating system has evolved from a manual tool for keeping expensive mainframes busy into an invisible, globally distributed fabric that mediates nearly all modern digital infrastructure.