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

still a working view ended · each leads to its entry below

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

  1. Computer (Vacuum tubes and digital electronic circuits, Stored programs, introduction), Wikipedia
  2. Von Neumann architecture, Wikipedia
  3. First Draft of a Report on the EDVAC, Wikipedia
  4. Instruction set architecture, Wikipedia
  5. Unix (introduction, History), Wikipedia
  6. Reduced instruction set computer, Wikipedia
  7. Parallel computing (Background, introduction), Wikipedia
  8. Memory coherence, Wikipedia
  9. Virtualization, Wikipedia
  10. Memory hierarchy, Wikipedia
  11. 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.

  1. 1945-Present

    Von Neumann architecture

    How can one machine run any program?

    Fly to its tower in Nousfarer

  2. 1956-1975

    Batch Processing

    How can jobs be run without idle time?

    Fly to its tower in Nousfarer

  3. 1960-Present
  4. 1961-1985

    Time-Sharing

    How can many users share one computer?

    Fly to its tower in Nousfarer

  5. 1962-Present

    Memory Hierarchy

    How can fast and slow memory work together?

    Fly to its tower in Nousfarer

  6. 1962-Present

    Virtual Memory

    How can each program see a large private memory?

    Fly to its tower in Nousfarer

  7. 1964-Present

    Instruction Set Architecture

    What contract should hardware offer software?

    Fly to its tower in Nousfarer

  8. 1967-Present

    Parallel and Vector Computing

    How can many operations happen at once?

    Fly to its tower in Nousfarer

  9. 1969-Present

    Packet Switching

    How can independent machines exchange messages?

    Fly to its tower in Nousfarer

  10. 1971-Present

    Unix Philosophy

    How should systems software be built and composed?

    Fly to its tower in Nousfarer

  11. 1976-2000

    Vector Processing

    How can one instruction act on whole arrays?

    Fly to its tower in Nousfarer

  12. 1980-Present

    Client–server model

    How should applications be split across machines?

    Fly to its tower in Nousfarer

  13. 1981-Present
  14. 1985-Present

    Open Systems

    How can parts from different vendors interoperate?

    Fly to its tower in Nousfarer

  15. 2000-Present

    Energy-Efficient Systems-on-Chip

    How can a chip do useful work on little energy?

    Fly to its tower in Nousfarer

  16. 2000-Present

    Virtualization

    How can one machine host many systems?

    Fly to its tower in Nousfarer

  17. 2005-Present

    Cache-Coherent Shared Memory

    How can many cores share data correctly?

    Fly to its tower in Nousfarer

  18. 2006-Present

    Warehouse-Scale Computing

    How can a data centre act as one computer?

    Fly to its tower in Nousfarer

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.

Von Neumann architectureBatch ProcessingOperating System as Resource ManagerTime-SharingMemory HierarchyVirtual MemoryInstruction Set ArchitectureParallel and Vector ComputingPacket SwitchingUnix PhilosophyVector ProcessingClient–server modelReduced instruction set computerOpen SystemsEnergy-Efficient Systems-on-ChipVirtualizationCache-Coherent Shared MemoryWarehouse-Scale Computing

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.

A city in Nousfarer: a red-carpeted stair climbing terraces to a crowned tower on an acropolis, more towers round it, forest and snowy mountains beyond.
A city in Nousfarer, the game played in the browser.

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 Systems

Related fields

Fields its ideas are linked to

More in Computer Systems

See where Computer Systems sits on the Map of Human Knowledge