Distributed Computing Fundamentals
Distributed computing runs a computation across multiple networked machines that coordinate to solve a problem no single machine could handle alone. It introduces the challenges of partial failure, network latency, consistency, and the fundamental trade-offs every distributed system must navigate.
itComputer fundamentals | OpenSkills.info
Course pathWalk it in order
Look it upDip in anytime
Go furtherLeaves this page
Don't Panic
Don't Panic — Distributed Computing Fundamentals
Distributed computing is what happens when one job or service moves from one computer to several independent ones. The machines exchange messages, which sounds civilised until a message takes a scenic route, a machine stops, or both clocks confidently disagree about Tuesday.
The arrangement exists for sensible reasons. One machine may not hold the data, finish the work quickly enough, sit near the people who need it, or survive the failure you care about. Split the input into partitions, give workers separate pieces, and combine the results. This is the MapReduce shape: map work produces intermediate key-value pairs, reduce work combines values by key, and the runtime handles scheduling, movement, and failed tasks. The impressive part is not the arrows. It is deciding which arrows are allowed to misbehave.
The first surviving idea is partial failure. A local function usually returns, errors, or keeps running. A remote operation adds the wonderfully unhelpful fourth state: no reply. After a timeout, the server may have missed the request, completed it, or still be working. The timeout reports waiting time, not history. That is why an idempotent operation, one whose repeat has the same intended effect, needs a stable operation ID. It lets a retry ask about the same logical work instead of quietly ordering a second helping.
The second idea is that time is not a shared household appliance. Happened-before records causal order: work earlier in one process, a sent message before its received message, and chains of those relations. Events with no such path are concurrent. A logical clock can respect this order, but it is not a tiny judge wearing a wall-clock costume.
Then there is shared state, which is where the furniture begins to move. Replication keeps copies of logical state, improving some failure and read options while creating rules about accepted updates and reads. A consistency model names the observations clients may see. When one ordered history matters, consensus and a replicated log let a communicating majority commit commands for deterministic state machines. The minority does not get a competing history merely because it is feeling independent.
Start with the Intro for the full architecture and failure model. Use Slides when you want the relationships in one pass. Keep the Cheatsheet beside design and incident work for timeout outcomes, partitioning, consistency, safety, and liveness. The Practice Reference and exercise turn the lost-reply problem into a testable operation registry. The Timeline supplies the older landmarks; Field Notes covers the operational traps those landmarks do not politely announce.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://aws.amazon.com/builders-library/challenges-with-distributed-systems/
Supports
- Independent failures and nondeterminism in distributed systems
- Ambiguous outcomes for network operations and timeouts
- Failure combinations, testing difficulty, and recursive distributed dependencies
- https://www.microsoft.com/en-us/research/publication/time-clocks-ordering-events-distributed-system/
Supports
- Distributed processes coordinating through messages
- Happened-before as a partial causal order
- Concurrent events and logical clocks
- Ordered inputs as a foundation for distributed state machines
- 1978 publication of logical clocks and causal ordering
- https://research.google/pubs/mapreduce-simplified-data-processing-on-large-clusters/
Supports
- Map and reduce functions over key-value pairs
- Input partitioning, task scheduling, inter-machine communication, and failure handling by the runtime
- Large computations divided across cluster workers
- Communication, partitioning, and scheduling as distributed-computation concerns
- 2004 publication of MapReduce
- https://aws.amazon.com/builders-library/making-retries-safe-with-idempotent-APIs/
Supports
- Idempotent API semantics for safe retries
- Stable client request identifiers and duplicate request recognition
- Repeated requests returning the result of one logical operation
- Durable operation identity for a lost-reply retry exercise
- https://www.cs.cornell.edu/courses/cs6464/2009sp/papers/brewer.pdf
Supports
- Formal definitions of atomic consistency, availability, and partition tolerance
- Impossibility of guaranteeing atomic consistency and availability together during message loss in the asynchronous model
- Scope and assumptions of the CAP result
- https://raft.github.io/raft.pdf
Supports
- Consensus through leader election, log replication, and safety
- Replicated state machines applying identical ordered commands
- Majority availability under crash-stop and communication assumptions
- Majority overlap and safe committed history
- Separation of safety from progress conditions
- 2014 publication of Raft
- https://research.google/pubs/spanner-googles-globally-distributed-database-2/
Supports
- Synchronously replicated, globally distributed data
- Distributed transactions and external consistency
- Explicit exposure of physical-clock uncertainty
- 2012 publication of Spanner
- https://aws.amazon.com/builders-library/minimizing-correlated-failures-in-distributed-systems/
Supports
- Redundancy and continued operation through some server failures
- Correlated infrastructure, dependency, software, and operator failures
- Failure boundaries, controlled deployment, shuffle sharding, and jitter
- https://lamport.azurewebsites.net/pubs/lamport-paxos.pdf
Supports
- 1998 publication of The Part-Time Parliament
- Agreement protocols and ordered decisions despite failures
- https://research.google/pubs/the-google-file-system/
Supports
- 2003 publication of the Google File System
- Fault-tolerant, data-intensive storage on commodity hardware
- https://research.google/pubs/bigtable-a-distributed-storage-system-for-structured-data/
Supports
- 2006 publication of Bigtable
- Distributed structured storage across commodity servers
- https://www.amazon.science/publications/dynamo-amazons-highly-available-key-value-store
Supports
- 2007 publication of Dynamo
- Availability and consistency trade-offs in distributed key-value storage
- https://aws.amazon.com/builders-library/timeouts-retries-and-backoff-with-jitter/
Supports
- Retry amplification through layered dependencies
- Timeout selection, retry limits, backoff, and jitter
- https://kafka.apache.org/documentation/
Supports
- Kafka partitions, replicas, brokers, and distributed event streaming
- https://cassandra.apache.org/doc/stable/cassandra/architecture/overview.html
Supports
- Cassandra partition keys, replication, and consistency semantics
- https://github.com/etcd-io/etcd
Supports
- etcd as a Raft-backed distributed reliable key-value store
- https://flink.apache.org/documentation/
Supports
- Flink documentation for distributed stateful data processing
- https://github.com/cockroachdb/cockroach/blob/master/docs/design.md
Supports
- CockroachDB partitioned ranges, Raft replication, and distributed transactions
