- Atlas
- Computer Science
- Distributed Systems
Distributed Systems
A distributed system is a collection of independent computers that appears to its users as a single coherent system.
12 frameworks, from 1961 to today · Computer Systems · Computer Science
- Time-sharing 1961-1975
- Message Passing and Process Algebra 1973-Present
- Remote Procedure Call and Client–Server 1975-Present
- Replication and Consensus 1978-Present
- Distributed File Systems 1984-2005
- Middleware and Service-Oriented Architecture 1991-2015
- Grid Computing 1995-2010
- Peer-to-Peer Systems and Distributed Hash Tables 1999-2012
- CAP and Consistency Models 2000-Present
- MapReduce 2004-2015
- Cloud computing 2006-Present
- Eventual Consistency and CRDTs 2007-Present
Overview
A distributed system is a collection of independent computers that appears to its users as a single coherent system1. That definition, in one form or another, has guided the field since the 1970s, and it captures the central tension: the machines are separate, so they can fail separately, communicate only by messages that arrive late or not at all, and have no shared clock—yet the software must behave as if they were one. What is at stake is scale and reliability. A single computer can be made fast only up to a point; a network of computers can grow without bound and survive the loss of individual members, but only if the software confronts the physics of partial failure. Distributed systems is the discipline of building that software.
Time-sharing and the first remote terminals
The prehistory lies in the 1960s, when computers were batch machines fed by decks of punched cards. Time-sharing changed that: a single computer switched rapidly among many users, each at a terminal, giving the illusion that the machine belonged to each of them alone2. Project MAC at MIT, running the Compatible Time-Sharing System from 1961, and the Dartmouth Time-Sharing System of 1964 were early landmarks. The terminals were remote—connected by telephone lines—so users were already interacting with a machine at a distance. The step to distributed systems came when researchers asked whether several computers could cooperate rather than merely serve terminals. ARPANET, whose first link was established in 1969, made that question practical by connecting machines at different sites.
Remote procedure calls and the client–server model
Early networked programs spoke in raw messages over sockets, and every application had to invent its own protocol. The idea of the remote procedure call (RPC), developed at Xerox PARC in the 1970s and published in a widely read 1984 paper by Andrew Birrell and Bruce Nelson, made a network call look like an ordinary function call: the programmer writes result = f(x) and a stub on the client marshals the arguments, sends them, and waits for the reply. This hid the network behind a familiar abstraction and gave rise to the client–server model, in which one program requests services and another provides them34. The abstraction is seductive but leaky—a local call either succeeds or crashes the program, while a remote call can hang forever if the reply is lost—and much later work on timeouts, retries, and idempotency grew from that gap.
Message passing and process algebra
Where RPC assumed request and reply, other systems were built around asynchronous messages. The actor model, proposed by Carl Hewitt in 1973, treated computation as independent actors that only communicate by sending messages, with no shared state. In parallel, a theoretical strand asked how to reason about concurrent processes at all. Tony Hoare's Communicating Sequential Processes (CSP), published in 1978, and Robin Milner's Calculus of Communicating Systems (CCS) from 1980 gave formal languages in which processes and their interactions could be described and compared56. These calculi mattered because they let designers prove properties of protocols before building them, and CSP's ideas later shaped the concurrency model of the Go programming language5.
Distributed file systems
If many machines must cooperate, they need a shared view of stored data. The Network File System (NFS), released by Sun Microsystems in 1984, let a client mount a directory on a remote server as if it were local7. The Andrew File System, developed at Carnegie Mellon in the 1980s, took a different route: it cached whole files on client machines and used callbacks to keep caches coherent, trading fine-grained consistency for scalability across thousands of workstations. These systems taught the field that caching is essential and that keeping caches consistent is where the difficulty hides.
Replication and consensus
The deepest problem is agreement. If data is copied onto several machines for availability, the copies must not diverge, and machines must agree on an order of operations even when some are unreachable. Leslie Lamport's 1978 paper on clocks and the ordering of events in a distributed system showed that physical clocks cannot establish a reliable global order, so logical clocks and timestamps must do the work. The state machine replication approach—run the same deterministic operations in the same order on every replica—reduced the problem to agreeing on a sequence. Lamport's Paxos, circulated in the late 1980s and published in 1998, became the canonical consensus protocol; it guarantees that a majority of replicas agree on a value despite crashes and message delays. Practical systems such as Google's Chubby lock service (described in 2006) and later Raft, designed by Diego Ongaro and John Ousterhout in 2014 for understandability, brought consensus into everyday infrastructure.
Middleware and service-oriented architecture
As networks grew, a layer of software called middleware emerged to connect heterogeneous machines and languages. The Open Software Foundation's Distributed Computing Environment (DCE) in the early 1990s bundled RPC, naming, and security. Object-oriented middleware followed—CORBA, standardized in 1991, and Microsoft's DCOM—letting programs call methods on remote objects. In the 2000s, service-oriented architecture (SOA) recast applications as collections of loosely coupled services communicating through standard web protocols such as SOAP and later REST. The recurring lesson was that loose coupling and standard interfaces buy interoperability at the cost of performance and complexity.
Grid computing
The 1990s and early 2000s saw grid computing, which aimed to pool computing power across institutions—often universities and research labs—the way an electrical grid pools generators. Projects such as Globus, begun in 1995, built toolkits for authentication, job scheduling, and data movement across administrative domains. Grids proved that large-scale resource sharing was possible, but they struggled with heterogeneity and with the absence of a single owner, problems that the commercial cloud would later address with centralized control.
CAP and consistency models
In 2000, Eric Brewer articulated what became the CAP theorem: a distributed data store cannot simultaneously guarantee consistency, availability, and partition tolerance8. Since network partitions are unavoidable, real systems must choose between strong consistency and availability during a partition. Seth Gilbert and Nancy Lynch gave a formal proof in 20028. CAP forced designers to state their consistency guarantees explicitly, and a spectrum of models—linearizability, sequential consistency, causal consistency—entered common vocabulary. The theorem is often oversimplified, but its practical effect was to make consistency a design decision rather than an afterthought.
Peer-to-peer systems and distributed hash tables
Around the same time, peer-to-peer file sharing showed that millions of ordinary machines could cooperate without any central server. Napster (1999) still relied on a central index; Gnutella (2000) removed it but flooded the network with queries. The structured answer was the distributed hash table: Chord, from MIT in 2001, and CAN and Pastry placed keys on a ring or space so that any node could locate any key in a logarithmic number of hops. These systems demonstrated self-organization at scale and influenced later content distribution and storage designs.
MapReduce and data-parallel batch processing
Google's MapReduce, described in a 2004 paper by Jeffrey Dean and Sanjay Ghemawat, took a different tack: rather than expose the network, it hid it behind two simple operations—map, which transforms records, and reduce, which aggregates them—and let the framework handle partitioning, scheduling, and recovery from failed workers. The open-source Hadoop implementation made the model widely available910. Its limitation was latency: batch jobs took minutes to hours, which motivated later stream-processing systems.
Cloud computing and data-center resource management
The 2006 launch of Amazon Web Services' Elastic Compute Cloud turned distributed systems into a utility: users rented virtual machines by the hour, and the provider's job became packing many tenants onto shared hardware. Google's papers on the Google File System (2003), Bigtable (2006), and later Borg (2015) described how a single company managed clusters of thousands of machines. Resource managers such as Apache Mesos (2011) and Kubernetes (2014) generalized scheduling and orchestration. The data center itself became the unit of design, and concerns shifted to energy, isolation, and automated failure recovery.
Eventual consistency and CRDTs
For geo-replicated services, waiting for consensus on every write is too slow. The Dynamo system at Amazon, described in 2007, embraced eventual consistency: replicas may diverge temporarily but converge if writes stop. The risk is conflicting updates, and conflict-free replicated data types (CRDTs), formalized by Marc Shapiro and colleagues around 2011, offered data structures—counters, sets, registers—whose operations commute so that replicas merge automatically without coordination11. These ideas underpin many modern collaborative applications and globally distributed databases.
The present
Today the field runs on a layered inheritance. Consensus protocols such as Paxos and Raft sit inside coordination services and replicated databases; RPC and its modern descendants (gRPC, REST) carry most inter-service traffic; orchestration platforms schedule containers across data centers; and consistency is chosen per application, from strong linearizability to CRDT-based eventual convergence. Open questions remain sharp: how to verify large distributed protocols, how to reason about failures that are rare but correlated, how to keep latency low across continents without weakening guarantees, and how to make the whole stack comprehensible to the engineers who must operate it. The machines are still separate, and the software still must pretend otherwise.
References
- Distributed computing (Introduction), Wikipedia
- Time-sharing, Wikipedia
- Remote procedure call, Wikipedia
- Client–server model, Wikipedia
- Communicating sequential processes, Wikipedia
- Process calculus (History), Wikipedia
- Network File System, Wikipedia
- CAP theorem (introduction, History), Wikipedia
- MapReduce, Wikipedia
- Apache Hadoop, Wikipedia
- Conflict-free replicated data type, Wikipedia
The frameworks of Distributed Systems
Each framework is a way of working the field has used: when it held, and the question it answers.
- 1961-1975
- 1973-Present
Message Passing and Process Algebra
How do independent processes communicate and coordinate?
- 1975-Present
Remote Procedure Call and Client–Server
How can a program call code on another machine?
- 1978-Present
- 1984-2005
- 1991-2015
Middleware and Service-Oriented Architecture
How can heterogeneous systems be connected by common software?
- 1995-2010
Grid Computing
How can institutions pool computing resources across domains?
- 1999-2012
Peer-to-Peer Systems and Distributed Hash Tables
How can millions of peers cooperate without a central server?
- 2000-Present
CAP and Consistency Models
What must a distributed store give up during a partition?
- 2004-2015
- 2006-Present
- 2007-Present
Eventual Consistency and CRDTs
How can replicas converge without waiting for agreement?
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.
Middleware and Service-Oriented Architecture grew out of Remote Procedure Call and Client–Server
Middleware such as DCE and CORBA was built directly on RPC stubs, adding naming, security and object interfaces on top of the remote-call mechanism.
Carried by Open Software Foundation; CORBA (1991).
Remote Procedure Call and Client–Server rival of Message Passing and Process Algebra
RPC and the actor/message-passing tradition were contemporary answers to how networked programs should communicate: RPC hid the network behind synchronous calls, while message passing kept communication explicit and asynchronous.
Carried by Andrew Birrell; Bruce Nelson.
Distributed File Systems influenced by Remote Procedure Call and Client–Server
Network file systems used client-server RPC protocols to let a client mount and access a remote server's files as if local.
Carried by Sun Microsystems; NFS (1984).
CAP and Consistency Models influenced by Replication and Consensus
Consensus and replication work established that agreement under partitions is costly, which CAP later framed as a forced choice between consistency and availability.
Carried by Eric Brewer.
Eventual Consistency and CRDTs influenced by Replication and Consensus
The cost of consensus on every write, established by replication and consensus research, motivated systems such as Dynamo to accept eventual consistency and later CRDT designs.
Carried by Amazon Dynamo (2007).
Cloud computing replaced Grid Computing
Cloud computing replaced grid computing as the working model for pooling large-scale resources, solving grid heterogeneity and multi-owner problems through centralized commercial control.
Carried by Amazon Web Services.
Eventual Consistency and CRDTs grew out of CAP and Consistency Models
Eventual consistency and CRDTs grew out of the CAP-era recognition that strong consistency must sometimes be traded for availability, making weaker consistency models explicit design targets.
Carried by Amazon Dynamo (2007).
Cloud computing influenced by MapReduce
MapReduce's data-parallel batch model and its open-source Hadoop implementation shaped how cloud providers offered large-scale data processing as a service.
Carried by Jeffrey Dean; Sanjay Ghemawat; Hadoop.
Grid Computing influenced by Distributed File Systems
Grid toolkits reused distributed file system techniques for moving and staging data across administrative domains.
Carried by Globus.
Grid Computing influenced by Middleware and Service-Oriented Architecture
Grid computing borrowed middleware ideas for authentication, naming and remote invocation to connect heterogeneous institutional resources.
Carried by Globus.
Cloud computing influenced by Middleware and Service-Oriented Architecture
Service-oriented middleware concepts of loosely coupled services and standard interfaces carried into cloud service design and orchestration.
Eventual Consistency and CRDTs influenced by Peer-to-Peer Systems and Distributed Hash Tables
Peer-to-peer systems demonstrated self-organizing replication at scale, and their decentralized replication concerns fed into eventual-consistency and CRDT designs.
Beyond the field
Where Distributed Systems's ideas came from in other fields, and what they led to there: the strongest 12 of 93 links.
Remote Procedure Call and Client–Server influenced Networked and distributed storage in Storage Systems
Distributed file systems such as NFS and AFS were built directly on the remote procedure call mechanism developed in the 1970s and 1980s (Birrell and Nelson's RPC, Sun RPC). RPC provided the transparent client-server invocation that made remote file access look like local calls.
Carried by Andrew Birrell; Bruce Nelson; Sun RPC.
Remote Procedure Call and Client–Server influenced Distributed operating system in Operating Systems
Distributed operating systems were built on remote procedure call and client-server structuring, which provided the basic communication mechanism. Systems like Amoeba and Sprite used RPC as their central abstraction.
Carried by Remote Procedure Call (1984); Amoeba; Sprite.
Remote Procedure Call and Client–Server influenced Request/response application protocols in Network Protocols
Request/response application protocols generalise the client-server and remote procedure call model developed in distributed systems from the mid-1970s. HTTP's request/response exchange is a direct descendant of the RPC call-and-reply pattern.
Carried by RFC 1945 (1996).
Replication and Consensus influenced CAP theorem and eventual consistency in Nosql Systems
Brewer's CAP conjecture and Gilbert and Lynch's proof rest on the replication and consensus literature: the impossibility of simultaneous consistency and availability under partition is a statement about replicated state. Replication protocols and quorum results supplied the concepts the theorem formalized.
Carried by Eric Brewer; Seth Gilbert; Nancy Lynch.
Replication and Consensus led to State machine replication in Distributed Algorithms
Replication and consensus, including the replicated-state-machine approach to fault-tolerant agreement, is the direct source of state machine replication as a named framework. The later formulation generalized the replicated state machine into a general deterministic-service replication method.
Carried by Leslie Lamport; Fred Schneider.
Replication and Consensus influenced Eventual Consistency and NoSQL Data Models in Distributed Databases
Replication and consensus theory, from Lamport's Paxos through viewstamped replication, supplied the replication protocols that Dynamo-style and later NoSQL systems adapted; Dynamo's design drew directly on this literature when it chose availability over strong consistency.
Carried by Leslie Lamport; Amazon Dynamo (2007).
Replication and Consensus influenced Permissionless and Blockchain Consensus in Distributed Algorithms
Nakamoto's Bitcoin consensus adapted the classical replication-and-consensus problem to an open network, replacing known participants with proof-of-work to reach agreement.
Carried by Satoshi Nakamoto.
Replication and Consensus influenced Consensus-Based Replicated State in Distributed Databases
Consensus-based replicated state builds directly on replication and consensus protocols, using agreement to order operations across replicas. The consensus machinery is the core of the replicated state approach.
CAP and Consistency Models grew out of Distributed databases and CAP in Databases
The CAP theorem was formulated by Eric Brewer from experience with distributed databases and proved by Gilbert and Lynch, growing directly out of distributed database replication and partitioning practice. CAP and consistency models are the refinement of that database trade-off into a general framework.
Carried by Eric Brewer.
MapReduce led to Hadoop Ecosystem in Big Data Processing
Hadoop's distributed processing engine is a direct open-source implementation of the MapReduce model described by Google in 2004.
Carried by Doug Cutting.
Cloud computing led to Serverless Computing in Cloud Computing
Serverless computing is a direct outgrowth of cloud computing, extending the pay-per-use model from rented servers to event-driven functions. AWS Lambda (2014) generalised the cloud provider's managed infrastructure into on-demand execution.
Carried by AWS Lambda (2014).
Cloud computing led to Hybrid and Multi-Cloud in Cloud Computing
Hybrid and multi-cloud is a direct extension of cloud computing: it generalises the single-provider model to combinations of public and private clouds. The idea grew out of enterprise adoption of cloud services in the late 2000s.

Distributed Systems is a planet in Nousfarer
Its city has a tower for each of these 12 frameworks. Land, walk in, and climb one concept at a time.
Land on Distributed SystemsRelated fields
Fields its ideas are linked to
- Cloud Computing 16 links
- Distributed Algorithms 12 links
- Distributed Databases 10 links
- Computer Systems 8 links
- Big Data Processing 6 links
- Operating Systems 6 links
- Storage Systems 6 links
- Transaction Processing 5 links
- Parallel Computing 4 links
- Databases 3 links
- Networks 3 links
- Reliability Fault Tolerance 3 links
More in Computer Systems
See where Distributed Systems sits on the Map of Human Knowledge