- Atlas
- Computer Science
- Operating Systems
Operating Systems
An operating system is the software that stands between a computer's hardware and the programs people want to run.
17 frameworks, from 1956 to today · Computer Systems · Computer Science
- Batch processing monitors 1956-1970
- Multiprogramming 1961-1985
- Time-sharing 1961-1990
- Virtual memory 1962-Present
- General-purpose family operating systems 1964-1980
- Hypervisor 1966-Present
- Unix 1969-Present
- Monolithic kernel 1970-Present
- Graphical user interface 1973-Present
- Personal computer operating systems 1974-1995
- Distributed operating system 1980-1995
- Open-source Unix-like systems 1983-Present
- Network-integrated systems 1984-Present
- Microkernel 1985-Present
- Exokernels and library operating systems 1995-Present
- Mobile operating system 2007-Present
- Container-based isolation 2008-Present
Overview
An operating system is the software that stands between a computer's hardware and the programs people want to run1. It hands out the processor, memory, disks, and network to competing programs, keeps them from corrupting one another, and presents the whole machine through a simpler interface than the raw hardware offers1. The history of the field is a long argument about where to put complexity: in the hardware, in a privileged kernel, in libraries, or in the structure of the machine itself. Each era's answer was shaped by what hardware could do and by who was using the machine—a single operator, a roomful of programmers, a company, or a billion people with phones in their pockets.
Batch processing and the first monitors
Early electronic computers of the 1940s and 1950s were operated directly: a programmer wired or loaded a program, ran it, and read results off panels or printers. The machine sat idle whenever a human was setting up the next job. The first operating systems grew out of the effort to keep the expensive machine busy. On the IBM 709 in the late 1950s, the SHARE user group's SOS (Share Operating System) and, more influentially, the FMS (Fortran Monitor System) and later IBSYS introduced a resident program—a monitor—that stayed in memory and loaded and ran jobs one after another from a queue, typically read from magnetic tape. A job was a deck of punched cards plus control cards telling the monitor what to do. The monitor was the first software to treat programs as things to be scheduled rather than things a human babysat.
Batch processing made throughput the goal, but it kept the programmer at arm's length: submit a deck, wait hours or a day for output. The next step was to let several jobs share the machine at once.
Multiprogramming and time-sharing
Multiprogramming means keeping several jobs in memory simultaneously so that when one waits for a slow device—a tape, a disk, a card reader—the processor switches to another23. The idea was pursued in the early 1960s on machines such as the IBM 7090 and the British Atlas, and it became a defining feature of the IBM System/360's OS/360, announced in 1964. Multiprogramming required new machinery: memory protection so one job could not overwrite another, and interrupts so the hardware could signal the kernel when a device finished.
Time-sharing went further: instead of running jobs to completion in turn, give each interactive user a short slice of processor time, fast enough that each feels the machine is theirs4. The intellectual case was made by J. C. R. Licklider in "Man-Computer Symbiosis" (1960), and working systems followed quickly. MIT's Compatible Time-Sharing System (CTSS), demonstrated in 1961 on an IBM 709, let multiple users at terminals run programs concurrently5. Project MAC at MIT, funded from 1963, pushed the idea into Multics, a joint MIT–Bell Labs–General Electric effort to build a time-sharing system with the ambition of a utility: reliable, secure, and able to serve many users. Multics was commercially disappointing but technically fertile, and it set the agenda for the next two decades6.
Virtual memory and protection
Time-sharing exposed a hard problem: programs were growing larger than physical memory, and users had to overlay code by hand. Virtual memory solved it by giving each program an address space larger than the real memory, with the hardware and kernel translating addresses and moving pages between memory and disk on demand7. The Manchester Atlas, operational in 1962, is credited with the first working demand-paged virtual memory, using a scheme designed with Tom Kilburn's group. The idea spread: the GE 645 built for Multics, the IBM System/360 Model 67, and the DEC PDP-10 all implemented paging and segmentation in the late 1960s.
Virtual memory and protection are inseparable. Once each process has its own address space and the hardware can trap unauthorized access, the kernel can isolate users from one another and from itself. This is the foundation on which every later multi-user system rests, and it is why the kernel must run in a privileged mode the user programs cannot enter.
The Unix tradition
In 1969, at Bell Labs, Ken Thompson and Dennis Ritchie began building a small time-sharing system on a spare PDP-7, partly in reaction to the size and complexity of Multics8. The result, Unix, was rewritten in the C language by 1973, which made it portable: the same system could be moved to a new machine by recompiling rather than rewriting8. Unix's design—a small kernel, a hierarchical file system, and a set of small tools connected by pipes—became the model for a whole tradition of systems software. Its influence spread through the 1970s via source licenses to universities, notably the University of California, Berkeley, whose Berkeley Software Distribution (BSD) added virtual memory, networking, and the TCP/IP stack in the late 1970s and early 1980s1910. Unix also carried the monolithic kernel architecture: all core services—scheduling, memory, file systems, device drivers—run together in one privileged address space, which is simple and fast but hard to isolate and extend11.
Personal computers and single-user systems
The microprocessor changed who owned a computer. Early personal machines such as the Altair 8800 (1975) ran with no operating system at all, or with tiny monitors in ROM. CP/M, written by Gary Kildall and sold from 1974, gave 8-bit machines a standard way to manage disks and load programs, and it became the dominant system for business microcomputers12. In 1981 IBM chose a version of CP/M's successor, MS-DOS, for its Personal Computer; Microsoft's system, derived from Tim Paterson's QDOS, became the standard for IBM-compatible machines through the 1980s. These were single-user, single-tasking systems with minimal protection—appropriate for a machine one person used, and a sharp break from the multi-user assumptions of the mainframe world.
The graphical user interface arrived from research labs: Xerox PARC's Alto (1973) and Smalltalk environment pioneered windows, icons, and a mouse; Apple's Lisa (1983) and Macintosh (1984) brought the idea to a mass market; and Microsoft Windows, from 1985, layered a graphical shell over DOS before becoming a full operating system with Windows NT (1993), which brought protected memory and a kernel designed by a team led by Dave Cutler. The Macintosh's own system moved to a Unix-based kernel, Mac OS X, in 200113.
Microkernels and the architecture debate
The monolithic kernel's weakness is that a bug in any driver can crash the whole system. In the 1980s a rival architecture emerged: the microkernel, which keeps only the minimum—address-space management, inter-process communication, scheduling—in the privileged core and runs file systems, drivers, and other services as user-level processes. The idea is associated with Carnegie Mellon's Mach (from 1985) and with Jochen Liedtke's L4, whose 1990s implementations showed that a well-tuned microkernel could be fast. Proponents argued for reliability and flexibility; critics pointed to the cost of message passing between components. The debate shaped later designs: Windows NT and macOS use hybrid kernels that borrow microkernel ideas, and seL4, a formally verified microkernel, demonstrated in the 2000s that the approach could be made both small and provably correct.
Virtualization and hypervisors
In the 1960s, IBM's CP/CMS on the System/360 Model 67 introduced virtual machines: a control program (later called a hypervisor) that ran several operating systems, each believing it owned the hardware. This let one expensive mainframe serve many users with different system images. The idea lay dormant on smaller machines until the 2000s, when VMware (founded 1998) and the open-source Xen (2003) made x86 virtualization practical, and hardware support from Intel and AMD followed. Virtualization became the substrate of cloud computing, letting data centers pack many isolated servers onto one physical machine.
Distributed and network-integrated systems
The 1980s and 1990s explored systems that spanned machines. Distributed operating systems such as Carnegie Mellon's Mach and Amoeba, and later Plan 9 from Bell Labs (developed from the late 1980s), aimed to make a collection of computers look like one, with a single namespace and transparent remote access. The fully transparent ideal proved hard to sustain against network failures and heterogeneity, and the field shifted toward network-integrated systems: ordinary local operating systems plus network file systems (Sun's NFS, 1984) and remote procedure calls, which made distribution explicit rather than hidden. This is the lineage that leads to today's cluster and cloud infrastructure.
Open-source Unix-like systems
In 1983 Richard Stallman launched the GNU Project to build a free Unix-compatible system, and by the early 1990s it had produced compilers, shells, and utilities but lacked a kernel. In 1991 Linus Torvalds released the Linux kernel, which, combined with GNU tools, gave the world a complete open-source Unix-like system1415. Linux spread from hobbyist machines to servers, supercomputers, and—through Android—phones. The BSD descendants (FreeBSD, NetBSD, OpenBSD) followed a parallel open-source path. The open-source model changed how operating systems were built and taught: source code became a shared public artifact, and the Unix tradition's portability and small-tool philosophy reached a far wider audience.
Exokernels and application-level resource management
A radical 1990s critique asked whether the kernel should manage resources at all. The exokernel, proposed by Dawson Engler and Frans Kaashoek at MIT (1995), gives applications direct control of hardware and confines the kernel to protecting resources rather than abstracting them; libraries implement the abstractions each application actually wants. Related work on application-level resource management argued that a general-purpose kernel imposes costs on programs with unusual needs. The idea did not displace mainstream systems, but its emphasis on minimal kernels and library operating systems influenced later designs, including unikernels and the lightweight virtualization used in modern data centers.
Mobile operating systems
The smartphone created a new set of constraints: limited power, touch input, and app stores with strict sandboxing. Early mobile systems included Symbian and Palm OS; Apple's iOS (2007) and Google's Android (2008) came to dominate. Both descend from the Unix tradition—iOS from a Darwin/macOS base, Android from a Linux kernel—but they reorganize the system around managed applications, permissions, and background power management. Mobile systems made the operating system a platform for third-party software distribution, and their sandboxing and energy-management techniques now feed back into desktop and server design.
The present
Today's operating systems are mostly descendants of the Unix and Windows lineages, running on everything from phones to cloud servers. The monolithic kernel remains dominant, with microkernel ideas embedded in hybrid designs; virtualization and containers (lightweight isolation built on kernel features such as Linux namespaces and cgroups) have become the standard way to run software at scale. Open questions persist: how to isolate components without paying the performance cost of message passing, how to manage energy and heterogeneous processors, how to secure kernels against their own drivers, and how far the operating system should recede as applications and hypervisors take over resource management. The argument about where to put complexity is not settled; it has simply moved to new hardware.
References
- Operating system (introduction, Definition and purpose, History), Wikipedia
- Computer multitasking (Multiprogramming), Wikipedia
- Process (computing) (History), Wikipedia
- Time-sharing, Wikipedia
- Compatible Time-Sharing System, Wikipedia
- Multics, Wikipedia
- Virtual memory, Wikipedia
- Unix (introduction, History), Wikipedia
- Berkeley Software Distribution, Wikipedia
- FreeBSD (Background), Wikipedia
- Monolithic kernel, Wikipedia
- CP/M, Wikipedia
- MacOS, Wikipedia
- Linux kernel, Wikipedia
- Linux, Wikipedia
The frameworks of Operating Systems
Each framework is a way of working the field has used: when it held, and the question it answers.
- 1956-1970
Batch processing monitors
How can a computer run jobs without an operator?
- 1961-1985
- 1961-1990
Time-sharing
How can many users share one computer at once?
About Time-sharing
Time-sharing is a framework for organizing a computer system around a single, powerful machine shared by many people at once. Its distinctive idea is that the computer can rapidly switch its attention among multiple users, giving each person the illusion that they have the machine to themselves. Instead of submitting a job and waiting hours for a result, a user sits at a terminal, types a command, and sees a response within seconds. The system achieves this by dividing the processor’s time into small slices and rotating through the waiting users so quickly that no one notices the interruptions. The central problem time-sharing addresses is economic and practical: early computers were enormously expensive, and letting one person use one exclusively was wasteful. Time-sharing made computing affordable and, just as importantly, made it interactive.The framework emerged in the early 1960s and became the dominant model of computing through the 1970s. Before time-sharing, the standard approach was batch processing. In a batch system, a user punched a program onto cards, handed the deck to an operator, and waited—often for hours or days—for the output to be printed. There was no way to interact with the program while it ran. If the program had a bug, the user discovered it only after the run completed, and the whole cycle began again. Time-sharing broke this pattern by connecting many terminals directly to the computer. The machine polled each terminal in turn, or responded to interrupts from them, so that a user’s keystrokes could be processed immediately. The Dartmouth Time-Sharing System (DTSS), which supported over one hundred simultaneous users by 1972, captured the goal in a famous observation: any response time averaging more than ten seconds destroys the illusion of having one’s own computer. That illusion was the whole point.To understand time-sharing, it helps to learn a small set of core concepts in order. First, the terminal: a keyboard-and-screen (or printer) device that lets a user send input to the computer and receive output. Second, the time slice or quantum: the fixed maximum amount of processor time a user’s program gets before the system switches to someone else. Third, the scheduler: the part of the operating system that decides which user’s program runs next, balancing fairness, responsiveness, and efficiency. Fourth, interrupts: hardware signals that allow the computer to stop what it is doing, notice that a terminal has new input, and switch attention accordingly. Fifth, multiprogramming: keeping several programs in memory at once so that when one program waits for input or output, the processor can immediately run another. Finally, virtual memory, which became important in later time-sharing systems: it gives each user’s program the illusion of a large, private memory space, even though physical memory is shared and limited. These concepts work together: the scheduler hands the processor to a user for a slice, an interrupt from a terminal signals new input, and multiprogramming ensures the processor never sits idle while one user thinks.The intellectual history of time-sharing is rooted in the early 1960s at a few key institutions. Project MAC at MIT, funded by DARPA, was a central hub; its work led to CTSS (the Compatible Time-Sharing System), one of the first successful time-sharing systems, demonstrated in 1961. John McCarthy, the artificial intelligence pioneer, was an early advocate of interactive computing and helped push the idea that users should be able to converse with the machine. Fernando Corbató, also at MIT, led the CTSS effort and later the Multics project, which extended time-sharing ideas into a large, secure, and reliable system. At Dartmouth, John Kemeny and Thomas Kurtz developed DTSS and, in 1964, created the BASIC programming language specifically to make time-sharing accessible to non-specialists. At the RAND Corporation, the JOSS system offered a simpler, calculator-like interactive environment. These systems were not just technical experiments; they changed the culture of computing. Users began to think of the terminal as the computer itself, rarely considering the shared machine behind it. The JOSS newsletter even asked users to reduce their storage usage, a reminder that the resource was communal.Time-sharing differs from nearby approaches in a fundamental way. Batch processing treated the computer as a factory that processed jobs in sequence; time-sharing treated it as a utility that served many customers simultaneously. The later monolithic kernel framework, which rose to prominence around 1970, is not a competitor to time-sharing but a different answer to a different question: how to structure the operating system’s internal code. A monolithic kernel puts all operating system services—scheduling, file systems, device drivers—into one large program running in privileged mode. Time-sharing systems like CTSS and Multics were built as monolithic kernels, and the two frameworks coexisted. Real-time operating systems, by contrast, prioritize guaranteed response times for critical tasks, such as controlling machinery, rather than fair sharing among interactive users. Virtualization, which became prominent much later, shares a machine among multiple complete operating systems, whereas time-sharing shares one operating system among many users. The closest modern descendant of time-sharing is the web server: a single expensive machine handling thousands of customers in bursts of activity, exactly the pattern DTSS handled in the 1960s.The continuing significance of time-sharing is visible everywhere, even though the term has faded. The scheduling algorithms, interrupt handling, and multiprogramming techniques developed for time-sharing are the foundation of every modern operating system. When you type in a terminal window, run multiple applications, or use a cloud service, you are relying on the same basic mechanism: a processor rapidly switching among tasks to create the illusion of simultaneity. The personal computer ended the need for time-sharing in the 1980s, because a single user could own the entire machine. But the Internet brought the concept back: a server farm costing millions of dollars can host thousands of customers, all sharing the same resources, with no perceptible delay unless the servers become overloaded. The economic logic that drove time-sharing—expensive hardware should not sit idle—remains the logic of cloud computing today.No specialist knowledge is required to understand time-sharing. A basic familiarity with what a computer program is, and a willingness to think about how a single machine can serve many people at once, is enough. The framework is best appreciated as a historical turning point: it made computing interactive, affordable, and social, and it established the core techniques that every operating system still uses.The 6 concepts its tower teaches
- Time slice
- Scheduler
- Terminal
- Interrupts
- Multiprogramming
- Virtual memory
- 1962-Present
- 1964-1980
General-purpose family operating systems
How can one system serve a whole machine family?
- 1966-Present
- 1969-Present
- 1970-Present
- 1973-Present
- 1974-1995
Personal computer operating systems
What system suits a single person's computer?
- 1980-1995
- 1983-Present
Open-source Unix-like systems
How can software be free to share and change?
- 1984-Present
Network-integrated systems
How can separate machines work together openly?
- 1985-Present
- 1995-Present
Exokernels and library operating systems
How can applications manage their own resources?
- 2007-Present
- 2008-Present
Container-based isolation
How can many programs share one kernel safely?
How the ideas connect
Each arrow runs from an earlier idea to the later one it shaped. The list below says what passed between them.
Multiprogramming grew out of Batch processing monitors
Batch monitors established the resident supervisor that loads and schedules jobs; multiprogramming extended this by keeping several jobs resident and switching on I/O waits, as in OS/360.
Carried by IBSYS; OS/360.
Virtual memory influenced by Time-sharing
Time-sharing exposed the problem of programs larger than memory and many users needing isolation; demand paging on the Manchester Atlas and later Multics' GE 645 answered it with virtual memory.
Carried by Manchester Atlas; Tom Kilburn; GE 645.
Unix reacted against Time-sharing
Thompson and Ritchie built Unix on a spare PDP-7 partly in reaction to the size and complexity of Multics, keeping time-sharing but with a small kernel and simple tools.
Carried by Ken Thompson; Dennis Ritchie; Multics.
Open-source Unix-like systems grew out of Unix
GNU and later Linux built free Unix-compatible systems directly on Unix's design, reimplementing its kernel interface, file system and tools.
Carried by GNU Project; Richard Stallman; Linux.
Microkernel reacted against Monolithic kernel
The microkernel arose as a reaction to the monolithic kernel's weakness that a bug in any driver can crash the system; Mach and L4 moved services out of the privileged core.
Carried by Mach; Jochen Liedtke; L4.
Network-integrated systems replaced Distributed operating system
Fully transparent distributed operating systems proved hard to sustain, and the field shifted to ordinary local systems plus explicit network services such as Sun's NFS and remote procedure calls.
Carried by Sun NFS; Remote procedure call.
Time-sharing grew out of Multiprogramming
Time-sharing took the multiprogrammed machine and added preemptive time slicing so interactive users could share it; CTSS demonstrated this on an IBM 709.
Carried by Compatible Time-Sharing System (CTSS).
General-purpose family operating systems influenced by Virtual memory
Family operating systems such as OS/360 and Multics depended on virtual memory and protection hardware to isolate jobs and users across a compatible machine line.
Carried by Multics.
Unix influenced by Virtual memory
Unix adopted virtual memory and protection concepts from Multics and the Atlas tradition, later adding paging in BSD; the privileged kernel/user split rests on this hardware mechanism.
Carried by Berkeley Software Distribution (BSD).
Unix influenced by General-purpose family operating systems
Unix inherited the idea of a general-purpose, portable family system from the System/360 and Multics lineage, but implemented it small and in C so it could move across machines.
Carried by Multics; C language.
Distributed operating system influenced by Unix
Distributed operating systems such as Amoeba and Plan 9 extended Unix's small-kernel, file-and-tool model across networks, aiming for a single namespace over many machines.
Carried by Amoeba; Plan 9.
Mobile operating system influenced by Unix
Android and iOS built their kernels and much of their system software on Unix-like foundations, carrying Unix's process and file abstractions into phones.
Carried by Android; iOS.
Mobile operating system influenced by Graphical user interface
Mobile operating systems adopted the graphical, touch-driven interface pioneered at Xerox PARC and Apple, adapting windows and icons to phones.
Carried by Apple iPhone; iOS.
Mobile operating system influenced by Microkernel
Mobile systems borrowed microkernel ideas in their hybrid kernels, running drivers and services with more isolation than a classic monolithic design.
Carried by Mach; XNU.
Beyond the field
Where Operating Systems's ideas came from in other fields, and what they led to there: the strongest 12 of 92 links.
Batch processing monitors led to Operating System as Resource Manager in Computer Systems
The resource-manager view of the operating system grew directly out of batch monitors: the resident monitor's job scheduling and device handling were generalized into allocating processor, memory and peripherals among competing jobs.
Multiprogramming led to Time-Sharing in Computer Systems
Time-sharing grew directly out of multiprogramming: keeping several jobs in memory and switching the processor among them was extended with rapid timer-driven switching so interactive users could each feel they had the machine.
Carried by Christopher Strachey; John McCarthy.
Multiprogramming grew out of Batch Processing in Computer Systems
Multiprogramming grew directly out of batch processing: monitors that had run one job at a time were extended to hold several jobs in memory and overlap their I/O with computation. The batch monitor is the immediate ancestor of the multiprogrammed system.
Virtual memory influenced by Time-Sharing in Computer Systems
Virtual memory was devised to let time-sharing systems hold many users' programs without fitting them all in physical memory. The Atlas and MULTICS designs tied paging directly to the demands of multi-user time-sharing.
Carried by Atlas computer (1962); MULTICS (1965).
Hypervisor influenced Virtualization and Workload Isolation in Systems Security
The hypervisor, developed from IBM's CP-67 and later Xen, is the mechanism by which virtualized workloads are isolated; Xen's 2003 design made the hypervisor the security boundary for multi-tenant workloads.
Carried by CP-67 (1967); Xen (2003).
Hypervisor led to Virtualization in Computer Systems
Modern virtualization is a direct descendant of the hypervisor concept introduced with IBM's CP-67/CMS in the 1960s; the virtual machine monitor idea was revived and extended for commodity x86 hardware around 2000.
Carried by IBM CP-67/CMS (1967); VMware.
Hypervisor influenced Infrastructure as a service in Cloud Computing
IaaS providers run hypervisors to create and manage the virtual machines they rent to customers. The hypervisor is the core enabling technology of infrastructure clouds.
Hypervisor influenced by Virtual Memory in Memory Hierarchy
The hypervisor depends on virtual memory's address translation and protection to give each virtual machine its own isolated address space. Without hardware paging the isolation the hypervisor provides would not be practical.
Hypervisor influenced by Virtual Memory in Computer Systems
The hypervisor depends on virtual memory's address translation and protection to give each virtual machine its own isolated address space. Without hardware paging the isolation the hypervisor provides would not be practical.
Hypervisor influenced Virtualization in Cloud Computing
Modern virtualization revived the hypervisor concept from IBM's 1960s CP/CMS and VM systems, which first separated a control program from guest operating systems. The x86 hypervisors of the late 1990s and 2000s reimplemented that architecture on commodity hardware.
Carried by IBM CP/CMS.
Unix influenced by Operating System as Resource Manager in Computer Systems
Unix's designers built on the resource-manager conception of an operating system developed in projects like CTSS and Multics, treating the kernel as the arbiter of CPU, memory and devices. Thompson and Ritchie carried this conception into Unix's design.
Carried by Multics; Ken Thompson; Dennis Ritchie.
Unix influenced by Time-Sharing in Computer Systems
Unix was created at Bell Labs by people who had worked on Multics, the time-sharing system, and it was itself a time-sharing system from the start. The interactive multi-user model of CTSS and Multics passed directly into Unix.
Carried by Multics; CTSS; Ken Thompson.

Operating Systems is a planet in Nousfarer
Its city has a tower for each of these 17 frameworks. Land, walk in, and climb one concept at a time.
Land on Operating SystemsRelated fields
Fields its ideas are linked to
- Computer Systems 36 links
- Embedded Systems 12 links
- Distributed Systems 6 links
- Systems Security 5 links
- Cloud Computing 5 links
- Storage Systems 5 links
- Memory Hierarchy 2 links
- Parallel Computing 2 links
- Human Computer Interaction 2 links
- Ubiquitous Computing 2 links
- Concurrency Models 2 links
- Computer Architecture 1 link
More in Computer Systems
See where Operating Systems sits on the Map of Human Knowledge