- Atlas
- Computer Science
- Computer Systems
Computer Systems
Computer systems is the branch of computing that builds whole machines and the software that makes them usable: processors, memories, operating systems, networks, and the data centres that house them.
18 frameworks, from 1945 to today · Computer Systems · Computer Science
- Von Neumann architecture 1945-Present
- Batch Processing 1956-1975
- Operating System as Resource Manager 1960-Present
- Time-Sharing 1961-1985
- Memory Hierarchy 1962-Present
- Virtual Memory 1962-Present
- Instruction Set Architecture 1964-Present
- Parallel and Vector Computing 1967-Present
- Packet Switching 1969-Present
- Unix Philosophy 1971-Present
- Vector Processing 1976-2000
- Client–server model 1980-Present
- Reduced instruction set computer 1981-Present
- Open Systems 1985-Present
- Energy-Efficient Systems-on-Chip 2000-Present
- Virtualization 2000-Present
- Cache-Coherent Shared Memory 2005-Present
- Warehouse-Scale Computing 2006-Present
Overview
Computer systems is the branch of computing that builds whole machines and the software that makes them usable: processors, memories, operating systems, networks, and the data centres that house them. Its practitioners ask how to turn fast but unreliable physical components into a system that is fast, correct, and affordable at the same time. The field's history is a long argument about where to put complexity—in hardware, in software, in interfaces, or in the structure of the machine itself—and each era's answer set the terms for the next.
Stored Programs and the First General-Purpose Machines
Early electronic computers of the 1940s, such as ENIAC, were wired for each problem: setting up a calculation meant physically reconnecting units12. The stored-program idea, worked out in drafts by John von Neumann and collaborators around 1945 and embodied in machines like the Manchester Baby (1948) and EDSAC (1949), put both data and instructions in the same rewritable memory13. A program became a pattern of bits that could be loaded, modified, and reused. This is the single most consequential abstraction in the field: the machine no longer had to be rebuilt for each task, and software could become a thing in its own right.
The immediate consequence was the need for a layer that managed the machine's resources. Early systems ran one job at a time, with operators loading tapes and cards. Batch processing monitors of the late 1950s, such as the systems built for IBM mainframes, automated the sequencing of jobs so the expensive machine was not idle between them.
Memory Hierarchies and the Operating System as Manager
Processors grew fast; memory did not keep pace. The memory hierarchy—small, fast registers and caches close to the processor, larger and slower main memory, and vast but slow disks behind them—became the organizing principle of system design. The key insight, formalized in the 1960s and 1970s, is that programs exhibit locality: they reuse recently touched data and nearby addresses. A cache exploits this so that most accesses hit fast storage, and the slow levels are rarely consulted. Virtual memory extended the idea: each program sees a large, private address space, while hardware and the operating system translate addresses and move pages between memory and disk. The Atlas computer (1962) and the IBM System/360 (1964) are landmarks in making these ideas practical.
With many programs sharing one machine, the operating system became a resource manager: it schedules the processor, allocates memory, and arbitrates devices. Time-sharing systems of the 1960s, notably CTSS and Multics at MIT, let many users interact with one computer at once, and Multics pushed virtual memory and protection to an ambitious extreme. The intellectual shift was from "run this program" to "share this machine safely and fairly."
Families, Instruction Sets, and Compatibility
IBM's System/360, announced in 1964, introduced the computer family: a range of machines at different prices and speeds that all ran the same instruction set, so software written for one ran on all. The instruction set architecture (ISA)—the contract between hardware and software—became a stable object that could outlive any particular implementation4. This separation let customers protect their software investment and let manufacturers build new, faster machines without breaking old programs4. It also framed a debate that would dominate later decades: how complex should an instruction set be?
Parallelism, Vectors, and the Supercomputer
Some problems—weather models, physics simulations—demanded more arithmetic than any single processor could supply. Parallel computing attacked this by doing many operations at once. Vector machines, most famously the Cray-1 (1976), applied one instruction to whole arrays of numbers, matching the structure of scientific code. Around the same time, Seymour Cray and others showed that careful engineering of memory bandwidth and cooling could make a single machine extraordinarily fast. The lesson that performance comes from feeding the arithmetic units steadily, not just from raw clock speed, has never gone out of date.
Unix and Portable Systems Software
In the late 1960s and early 1970s, Ken Thompson and Dennis Ritchie at Bell Labs built Unix, initially on a discarded PDP-7 and then on the PDP-11. Unix's lasting contribution was portability: it was rewritten in the C language, so it could be moved to new hardware with modest effort5. Its design philosophy—small tools that do one thing well, composed through pipes and a uniform file interface—made systems software modular and teachable5. Unix spread through universities and industry, and its ideas (processes, hierarchical file systems, the shell) became the common vocabulary of operating systems.
RISC and Pipelined Processors
By the late 1970s, instruction sets had grown baroque, and complex instructions were hard to execute quickly. The RISC movement—reduced instruction set computing—argued that simple, uniform instructions could be pipelined: overlapping the execution of successive instructions so that one finishes nearly every cycle6. Work at Berkeley (David Patterson) and Stanford (John Hennessy) in the early 1980s produced working RISC machines, and commercial designs such as MIPS and SPARC followed. The debate with the complex-instruction camp (CISC) was genuine: CISC claimed denser code and easier compilation, RISC claimed simpler, faster hardware. RISC's pipelining advantages largely won for general-purpose processors, though modern chips blend both ideas.
Networks, Client–Server, and Open Systems
Computing escaped the single machine. Packet-switched networks, culminating in the ARPANET (1969) and later the Internet, let independent computers exchange messages. The client–server model—one machine requests a service, another provides it—became the standard way to structure applications, and local-area networks in the 1980s connected offices. Alongside this, the open systems movement pushed for standardized interfaces so that hardware and software from different vendors could interoperate. Standards for networking, operating systems (notably POSIX), and data formats reduced lock-in and made heterogeneous systems the norm. The system was no longer a box; it was a collection of communicating parts.
Multicore and Shared Memory
By the mid-2000s, clock speeds stopped rising as fast because power and heat became limiting7. The response was to put multiple processor cores on one chip7. Multicore designs raised a hard problem: how do cores share data efficiently and correctly8? Cache-coherent shared memory—hardware that keeps each core's cached copy of memory consistent with the others—became the standard answer, letting programmers treat the machine as one shared address space. But coherence does not make parallel programming easy, and the gap between hardware capability and programmers' ability to exploit it remains a central open problem.
Virtualization and the Cloud Data Centre
Virtualization lets one physical machine host several independent operating systems, each believing it owns the hardware9. Though the idea dates to 1960s mainframes, it became transformative in the 2000s when efficient x86 virtualization made it cheap to pack many workloads onto one server. Combined with large-scale networking and automated management, this enabled cloud data centres, where computing is rented by the hour and machines are provisioned by software. The system boundary moved again: from the box to the warehouse-scale computer.
Energy-Efficient Systems-on-Chip
As computing moved into phones, sensors, and embedded devices, energy became the binding constraint. A systems-on-chip (SoC) integrates processor, memory, and specialized accelerators on one die, and designers now trade performance against power at every level. Techniques such as dynamic voltage and frequency scaling, heterogeneous cores that switch between fast and frugal modes, and dedicated accelerators for common tasks let a battery-powered device do useful work for hours. The same concerns now shape data-centre design, where electricity and cooling dominate cost.
Where the Field Stands
Today's systems descend directly from these turns: stored-program machines with layered memory hierarchies, operating systems that manage shared resources, standardized interfaces that let parts interoperate, and parallel hardware from multicore chips to warehouse-scale clusters1101147. The open questions are familiar in new clothes—how to program many-core and heterogeneous machines without heroic effort, how to keep energy and cost in check as scale grows, and how to build systems that remain correct and secure when their components are numerous and failure-prone. The argument over where to put complexity continues, now across chips, networks, and clouds.
References
- Computer (Vacuum tubes and digital electronic circuits, Stored programs, introduction), Wikipedia
- Von Neumann architecture, Wikipedia
- First Draft of a Report on the EDVAC, Wikipedia
- Instruction set architecture, Wikipedia
- Unix (introduction, History), Wikipedia
- Reduced instruction set computer, Wikipedia
- Parallel computing (Background, introduction), Wikipedia
- Memory coherence, Wikipedia
- Virtualization, Wikipedia
- Memory hierarchy, Wikipedia
- Operating system, Wikipedia
The frameworks of Computer Systems
Each framework is a way of working the field has used: when it held, and the question it answers.
- 1945-Present
- 1956-1975
- 1960-Present
Operating System as Resource Manager
How should a machine share its resources?
- 1961-1985
- 1962-Present
- 1962-Present
- 1964-Present
Instruction Set Architecture
What contract should hardware offer software?
- 1967-Present
- 1969-Present
- 1971-Present
- 1976-2000
- 1980-Present
- 1981-Present
Reduced instruction set computer
How simple should an instruction set be?
- 1985-Present
- 2000-Present
Energy-Efficient Systems-on-Chip
How can a chip do useful work on little energy?
- 2000-Present
- 2006-Present
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.
Reduced instruction set computer reacted against Instruction Set Architecture
RISC arose as a reaction against the complex instruction sets that had grown out of the ISA family concept, arguing that simple uniform instructions pipeline better.
Carried by David Patterson; John Hennessy.
Cache-Coherent Shared Memory grew out of Parallel and Vector Computing
Cache-coherent shared memory grew out of parallel computing as the standard way to let multiple cores on a chip share data through one coherent address space.
Warehouse-Scale Computing influenced by Virtualization
Efficient virtualization made it cheap to pack many workloads onto one server, which combined with large-scale networking and automated management enabled warehouse-scale cloud data centres.
Batch Processing influenced by Von Neumann architecture
The stored-program machine made programs into loadable data, which let batch monitors sequence jobs automatically instead of requiring rewiring or manual setup between runs.
Operating System as Resource Manager influenced by Von Neumann architecture
Once programs and data shared rewritable memory, a supervisor program could reside in the machine and manage other programs, which is the basis of the operating system as resource manager.
Instruction Set Architecture influenced by Von Neumann architecture
The stored-program concept made the instruction set a stable interface between software and hardware, which IBM's System/360 formalized as an architecture shared across a family of machines.
Carried by IBM System/360 (1964).
Time-Sharing reacted against Batch Processing
Time-sharing arose as a direct response to the long turnaround times of batch processing, letting users interact with the machine instead of submitting jobs to a queue.
Carried by CTSS (1961).
Time-Sharing grew out of Operating System as Resource Manager
Time-sharing extended the resource-manager view of the operating system to many interactive users, requiring scheduling and protection to share one machine fairly.
Carried by CTSS (1961); Multics (1965).
Virtual Memory influenced by Operating System as Resource Manager
Virtual memory required the operating system to manage address translation and page movement, extending the resource-manager role to memory itself.
Carried by Atlas (1962).
Unix Philosophy influenced by Operating System as Resource Manager
Unix built on the operating-system-as-manager idea but recast it around small composable tools, processes, and a uniform file interface rather than a monolithic supervisor.
Carried by Ken Thompson; Dennis Ritchie.
Virtualization revived Operating System as Resource Manager
Virtualization on x86 revived the 1960s mainframe idea of a hypervisor managing multiple operating systems, applying the resource-manager concept to whole machines rather than processes.
Unix Philosophy influenced by Time-Sharing
Unix grew out of the time-sharing tradition at Bell Labs, inheriting interactive multi-user processes and a hierarchical file system from Multics and CTSS experience.
Carried by Ken Thompson; Dennis Ritchie.
Vector Processing influenced by Memory Hierarchy
Vector machines were designed around feeding arithmetic units steadily from memory, applying the memory hierarchy insight that performance depends on data supply, not just clock speed.
Carried by Seymour Cray.
Cache-Coherent Shared Memory influenced by Memory Hierarchy
Cache coherence applies the memory hierarchy insight at the multicore level, keeping each core's cached copy consistent so programmers see one shared memory.
Client–server model influenced by Packet Switching
Packet switching let independent computers exchange messages reliably, which made the client-server model practical as a way to structure applications across a network.
Carried by ARPANET (1969).
Open Systems influenced by Unix Philosophy
Unix's portability and its spread across vendors made standardized interfaces attractive, feeding the open systems movement's push for interoperable operating systems such as POSIX.
Warehouse-Scale Computing influenced by Client–server model
The client-server model scaled up into warehouse-scale computing, where services are requested by clients and provided by large clusters managed as one machine.
Energy-Efficient Systems-on-Chip influenced by Reduced instruction set computer
RISC's simple pipelined cores became the basis for energy-efficient systems-on-chip, where designers trade performance against power at every level of the core and its accelerators.
Open Systems influenced by Client–server model
Client-server computing across heterogeneous machines created pressure for standardized network and system interfaces, which the open systems movement supplied.
Warehouse-Scale Computing influenced by Open Systems
Open systems' standardized interfaces and commodity components made it practical to build and operate very large data centres from interoperable parts.
Beyond the field
Where Computer Systems's ideas came from in other fields, and what they led to there: the strongest 12 of 173 links.
Von Neumann architecture provoked Dataflow architecture in Parallel Computing
Dataflow architecture was defined largely as a rejection of the von Neumann model's single program counter and shared mutable store, proposing instead token-driven execution with no central control.
Carried by Jack Dennis.
Von Neumann architecture influenced by Turing machine in Computability
Von Neumann's stored-program design took the abstract tape-based machine of Turing's 1936 paper and made its universal machine concrete, giving instructions and data a single addressable memory. The EDVAC report explicitly builds on Turing's universal computing machine.
Carried by Alan Turing; On Computable Numbers (1936); John von Neumann.
Batch Processing influenced Back-office batch automation in Digital And Open Banking
General-purpose batch processing on mainframes, with punched-card input and scheduled job runs, supplied the technique banks adopted for cheque clearing, interest posting and statement production.
Batch Processing led to Multiprogramming in Operating 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.
Batch Processing influenced Automated clearing house in Payments
Automated clearing houses were built on batch processing: payments were accumulated on tape and processed in scheduled runs, the technique developed for mainframe data processing.
Operating System as Resource Manager grew out of Batch processing monitors in Operating 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.
Operating System as Resource Manager influenced Unix in Operating 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.
Time-Sharing influenced Virtual memory in Operating 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).
Time-Sharing influenced Unix in Operating 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.
Time-Sharing grew out of Multiprogramming in Operating 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.
Memory Hierarchy led to Three C's Miss Taxonomy in Memory Hierarchy
The three C's taxonomy is a refinement of the computer-systems memory hierarchy, explaining cache misses within it. It grew directly out of that hierarchy model.
Memory Hierarchy led to Scratchpad Memory in Memory Hierarchy
Scratchpad memory is a software-managed level within the memory hierarchy, so it grew directly out of that layered model. It is a refinement of the hierarchy for explicitly addressed on-chip storage.

Computer Systems is a planet in Nousfarer
Its city has a tower for each of these 18 frameworks. Land, walk in, and climb one concept at a time.
Land on Computer SystemsRelated fields
Fields its ideas are linked to
- Operating Systems 36 links
- Memory Hierarchy 17 links
- Cloud Computing 10 links
- Instruction Set Architecture 9 links
- Parallel Computing 8 links
- Distributed Systems 8 links
- Computer Architecture 7 links
- Embedded Systems 6 links
- Digital Systems 6 links
- Parallel Algorithms 5 links
- Big Data Processing 5 links
- Microarchitecture 4 links
More in Computer Systems
See where Computer Systems sits on the Map of Human Knowledge