- Atlas
- Computer Science
- Reliability Fault Tolerance
Reliability Fault Tolerance
Computers are built from parts that fail.
12 frameworks, from 1950 to today · Computer Systems · Computer Science
- Error detection and correction 1950-Present
- Reliability Engineering 1950-Present
- Hardware Redundancy and Voting 1956-Present
- Fault-Tolerant Computing 1965-Present
- Application checkpointing 1970-Present
- Transactions and ACID 1970-Present
- End-to-end principle 1984-Present
- RAID 1988-Present
- State machine replication 1990-Present
- CAP and Consistency Trade-offs 2000-Present
- Software Fault Tolerance at Internet Scale 2010-Present
- Chaos Engineering 2011-Present
Overview
Computers are built from parts that fail1. A disk head crashes, a memory cell flips a bit under cosmic radiation, a power supply browns out, a network cable is cut, a program has a bug that only appears under load. Reliability and fault tolerance is the branch of computer systems that asks how to build machines and software that keep giving correct answers anyway—or, when they cannot, fail in a way that is predictable and contained1. The field's central move is to trade something (space, time, redundancy, money) for the probability of correctness1. Its history is the story of learning where that trade is worth making, and of discovering that the hardest failures are not the ones in hardware but the ones nobody anticipated.
Error-Correcting Codes and the Mathematical Foundation
The field begins with information theory. Claude Shannon's 1948 paper "A Mathematical Theory of Communication" established that a noisy channel has a capacity below which reliable communication is possible, and it framed the problem of encoding messages so that errors can be detected and corrected. Richard Hamming, working at Bell Labs and frustrated by punched-card machines that halted on a single parity error, published the Hamming code in 1950: by placing several parity bits at overlapping positions, a machine could not only detect that a bit had flipped but identify which one and fix it2. This was the first practical demonstration that redundancy could be structured—that a few extra bits bought a guaranteed correction capability rather than just a warning.
The decades that followed produced a family of codes that still underpin storage and communication: Reed–Solomon codes (1960), used in CDs, DVDs, QR codes, and deep-space telemetry; Bose–Chaudhuri–Hocquenghem (BCH) codes; and later convolutional and turbo codes. The key idea for systems builders is that error-correcting codes let a subsystem absorb faults locally, without the rest of the machine knowing. A memory with error-correcting code (ECC) silently corrects single-bit flips; a disk with Reed–Solomon parity reconstructs a lost sector. This local absorption is cheap and fast, and it remains the first line of defense in nearly every system today.
Reliability Engineering and the Statistics of Failure
In parallel, reliability engineering grew out of mid-century aerospace and electronics work. The question it asked was quantitative: given components with known failure rates, what is the probability a whole system survives a given mission? The bathtub curve—high infant mortality, a long flat useful life, then wear-out—became the standard mental model. The 1950s and 1960s saw the formalization of mean time between failures (MTBF), reliability block diagrams, and fault tree analysis, much of it driven by military and space programs where a failed component meant a lost mission. For computer systems, this tradition supplied the vocabulary of availability (the fraction of time a system is usable) and the discipline of reasoning about failure rates rather than just fixing bugs after the fact13.
Redundancy, Voting, and the Birth of Fault-Tolerant Computing
The idea that made fault tolerance a distinct engineering discipline was triple modular redundancy (TMR): run three copies of a computation and take a majority vote45. A single failure is outvoted; the system continues45. John von Neumann analyzed reliable computation from unreliable components in a 1956 paper, showing in principle that arbitrarily reliable machines could be built from unreliable parts given enough redundancy. The practical push came from a specific customer: the space program and, later, telephone switching. In the 1960s, IBM's System/360 Model 75 and the Saturn V launch computers incorporated redundancy; the Apollo Guidance Computer used a mix of hardware and software recovery.
The decisive institutional moment was the Jet Propulsion Laboratory's STAR (Self-Testing And Repairing) computer, designed in the late 1960s, and then the founding of the IEEE Technical Committee on Fault-Tolerant Computing in 1969, with the first International Symposium on Fault-Tolerant Computing (FTCS) held in 1971. Around the same time, the French company Thomson-CSF built the C.vmp and later the Intel 432 and Tandem systems pursued different routes. Tandem's NonStop line (1976) is the landmark commercial case: pairs of processors running in lockstep, comparing outputs, with a failover path so that a single hardware fault caused no interruption to transaction processing. The lesson Tandem taught the industry was that fault tolerance could be a product feature sold to banks and airlines, not just a research curiosity.
Checkpointing, Recovery, and the Software Side
Hardware redundancy is expensive1. A cheaper strategy is to let the system fail and then restart it from a saved state6. Checkpointing—periodically writing a process's memory and registers to stable storage—and rollback recovery—restoring that state after a failure—became a major research thread in the 1970s and 1980s. The problem is subtle: in a distributed system, processes must coordinate their checkpoints so that a consistent global state can be recovered, or they must log messages so that a rollback does not produce an impossible history. Work by K. Mani Chandy and Leslie Lamport on distributed snapshots (1985) and by David Johnson and Willy Zwaenepoel on pessimistic and optimistic message logging gave the field its standard techniques. Checkpointing remains the backbone of high-performance computing, where a job running for days on thousands of nodes must survive the loss of any one of them.
Transactions and the ACID Guarantee
A parallel and arguably more influential line of work came from databases. The transaction—a group of operations that either all happen or none do—with the properties atomicity, consistency, isolation, and durability (ACID) became the standard contract for reliable data management78. Jim Gray's work at IBM in the 1970s on transaction processing, write-ahead logging, and two-phase commit gave the field its core mechanisms. The insight was that reliability could be expressed as a programming model: the application programmer writes as if failures do not happen, and the system underneath handles the recovery. This abstraction—failures are hidden, not exposed—proved enormously productive and spread from databases into file systems (journaling), message queues, and eventually distributed systems.
Replicated State Machines and Consensus
If one machine can fail, run several and keep them in agreement9. The replicated state machine approach, formalized by Fred Schneider in 1990, says: if all replicas start in the same state and receive the same commands in the same order, they stay identical, and a client can tolerate the failure of a minority. The hard part is agreeing on the order—the consensus problem1011. Leslie Lamport's Paxos algorithm, circulated in the late 1980s and published in 1998, became the canonical solution, though its reputation for difficulty is legendary. The practical breakthrough came with Diego Ongaro and John Ousterhout's Raft (2014), designed explicitly for understandability, which spread rapidly through industry. Today consensus protocols underpin virtually every distributed database and coordination service.
End-to-End Reliability and the Argument Against In-Network Guarantees
A countercurrent ran through all of this. In 1984, Jerome Saltzer, David Reed, and David Clark published "End-to-End Arguments in System Design," arguing that reliability functions—error checking, delivery confirmation—are best placed at the endpoints of a communication, not in the network itself. The network should be simple; the endpoints should be smart12. This principle shaped the Internet's design and, more broadly, taught systems builders to ask where a reliability mechanism belongs13. It also set up a long-running tension: local mechanisms (ECC, checksums, retries) are cheap but can mask faults; end-to-end checks catch faults that local mechanisms miss. Modern systems use both, layered.
RAID and the Economics of Redundant Storage
In 1988, David Patterson, Garth Gibson, and Randy Katz at Berkeley published "A Case for Redundant Arrays of Inexpensive Disks" (RAID), showing that many cheap disks with parity could match the reliability of expensive ones at a fraction of the cost. RAID levels 1 through 5—mirroring, striping with parity, and their variants—became standard, and the paper's title (later softened to "independent") captured a shift in thinking: reliability was not only a property of individual components but of how they were arranged. RAID made the trade-off explicit and quantitative, and it remains the default way storage systems survive disk failure.
CAP, Consistency, and the Distributed Trade-off
In 2000, Eric Brewer articulated what became the CAP theorem—later proved by Seth Gilbert and Nancy Lynch—that a distributed system cannot simultaneously guarantee consistency, availability, and partition tolerance. The practical reading, popularized in the 2000s, was that under network partition you must choose between answering correctly and answering at all. This reframed reliability as a design choice rather than an absolute: different applications need different points on the spectrum14. The ensuing debate over "eventual consistency" and the rise of systems like Amazon's Dynamo (2007) pushed the field toward explicit, documented trade-offs rather than the assumption that ACID was always the goal.
Software Fault Tolerance at Internet Scale and Chaos Engineering
As systems grew to thousands of machines, the dominant failure mode shifted from component failure to emergent failure: cascading timeouts, retry storms, configuration drift, partial failures that no single component reports. The response was a set of software-level patterns—circuit breakers, bulkheads, graceful degradation, idempotent retries—codified in practices like Netflix's Hystrix and the broader discipline of site reliability engineering (SRE), named in a 2016 Google book. The most distinctive recent development is chaos engineering: deliberately injecting failures (killing instances, adding latency, partitioning networks) in production to discover weaknesses before they cause outages1516. Netflix's Chaos Monkey (2011) popularized the idea, and it has become a standard practice. Its logic descends directly from the field's oldest insight—that you cannot trust a system's reliability until you have tested it under the conditions it will actually face—but applies it to systems too complex to analyze on paper.
The Present
Today the field is layered. At the bottom, error-correcting codes and hardware redundancy absorb the common faults217. Above that, replication and consensus protocols tolerate whole-machine failures9. At the application level, transactions and idempotent retries handle the messy partial failures that distributed systems produce. And across all layers, chaos engineering and observability practices test whether the layers actually work together. The open questions are the ones the field has always faced in new form: how to reason about failures that emerge from interaction rather than from any single component; how to make formal verification of fault-tolerant protocols practical; and how to keep reliability affordable as systems scale beyond what any human can hold in mind. The history suggests the answer will again be a trade—some new structure of redundancy, placed where the last generation did not think to look.
References
- Fault tolerance (introduction, Criteria, Requirements, Disadvantages), Wikipedia
- Hamming code (introduction, History), Wikipedia
- Reliability engineering, Wikipedia
- Triple modular redundancy, Wikipedia
- Redundancy (engineering), Wikipedia
- Application checkpointing, Wikipedia
- ACID, Wikipedia
- Database transaction, Wikipedia
- State machine replication, Wikipedia
- Consensus (computer science), Wikipedia
- Paxos (computer science), Wikipedia
- End-to-end principle, Wikipedia
- Reliability (computer networking) (History), Wikipedia
- CAP theorem, Wikipedia
- Chaos engineering, Wikipedia
- Fault injection, Wikipedia
- ECC memory, Wikipedia
The frameworks of Reliability Fault Tolerance
Each framework is a way of working the field has used: when it held, and the question it answers.
- 1950-Present
Error detection and correction
How can errors be detected and corrected?
- 1950-Present
- 1956-Present
Hardware Redundancy and Voting
How can unreliable parts compute reliably?
- 1965-Present
- 1970-Present
Application checkpointing
How can a failed computation resume from saved state?
- 1970-Present
- 1984-Present
- 1988-Present
- 1990-Present
- 2000-Present
CAP and Consistency Trade-offs
What must be traded off under network partition?
- 2010-Present
Software Fault Tolerance at Internet Scale
How can large services tolerate constant failure?
- 2011-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.
Fault-Tolerant Computing grew out of Hardware Redundancy and Voting
Fault-tolerant computing grew directly out of hardware redundancy and voting: triple modular redundancy and von Neumann's reliable-from-unreliable-components argument were its founding techniques. The STAR computer and the first FTCS symposium in 1971 institutionalized the field around these ideas.
Carried by John von Neumann; JPL STAR computer; FTCS (1971).
Chaos Engineering grew out of Software Fault Tolerance at Internet Scale
Chaos engineering grew directly out of internet-scale software fault tolerance as a deliberate practice of injecting failures to test recovery mechanisms. Netflix's Chaos Monkey (2011) turned the assumption that failures are inevitable into routine experimentation.
Carried by Netflix Chaos Monkey.
Hardware Redundancy and Voting influenced by Error detection and correction
Von Neumann's 1956 analysis of reliable computation from unreliable components drew on Shannon's information theory and the coding framework to show redundancy could overcome component error. The structured-redundancy idea from Hamming codes passed into voting-based hardware redundancy.
Carried by John von Neumann; Claude Shannon.
Fault-Tolerant Computing influenced by Reliability Engineering
Reliability engineering supplied fault-tolerant computing with its quantitative vocabulary: failure rates, MTBF, availability, and fault tree analysis. The JPL STAR computer and the founding of the IEEE Technical Committee on Fault-Tolerant Computing in 1969 carried these methods into computer design.
Carried by JPL STAR computer; IEEE Technical Committee on Fault-Tolerant Computing.
Application checkpointing influenced by Fault-Tolerant Computing
Checkpointing and rollback recovery emerged as the cheaper software alternative within the fault-tolerant computing community, which supplied the failure models and recovery goals. Distributed snapshot and message-logging work in the 1980s built on that community's framing of consistent recovery.
Carried by K. Mani Chandy; Leslie Lamport; David Johnson.
Transactions and ACID influenced by Fault-Tolerant Computing
Tandem's NonStop line (1976) joined hardware fault tolerance to transaction processing, showing that paired processors with failover could make the ACID contract hold across failures. Jim Gray's transaction mechanisms were developed in dialogue with this fault-tolerant systems tradition.
Carried by Tandem NonStop; Jim Gray.
State machine replication influenced by Transactions and ACID
Replicated state machines took the transaction's ordering and atomicity concerns and generalized them to agreement among replicas. Schneider's 1990 formalization framed replication as ordered command delivery, echoing the database tradition's insistence on a single serial history.
Carried by Fred Schneider.
CAP and Consistency Trade-offs influenced by State machine replication
CAP framed the consistency that replicated state machines and consensus provide as one side of an unavoidable trade-off under partition. Brewer's argument took the replication-and-consensus setting as its object and asked what must be given up.
Carried by Eric Brewer.
Software Fault Tolerance at Internet Scale influenced by CAP and Consistency Trade-offs
Internet-scale software fault tolerance adopted CAP's consistency-versus-availability framing when designing services that must survive partition and node loss. The trade-off vocabulary shaped how large operators chose between strong and eventual consistency.
Carried by Eric Brewer; Seth Gilbert; Nancy Lynch.
Software Fault Tolerance at Internet Scale influenced by RAID
RAID's lesson that reliability is a property of how components are arranged, not just of individual parts, carried into internet-scale software fault tolerance, where replication and placement across many cheap machines replaced reliance on any single reliable node.
Carried by David Patterson; Garth Gibson; Randy Katz.
Beyond the field
Where Reliability Fault Tolerance's ideas came from in other fields, and what they led to there: the strongest 12 of 57 links.
Error detection and correction influenced Quantum error correction in Quantum Information
Classical error-detecting and correcting codes, especially the linear and Hamming codes, provided the constructions that Shor and Steane adapted to quantum states. The stabiliser formalism was built directly on classical coding theory.
Carried by Peter Shor; Andrew Steane; Richard Hamming.
Error detection and correction influenced by Shannon information theory in Coding Theory
Shannon's 1948 paper framed communication over noisy channels and proved that reliable transmission is possible below channel capacity, setting the problem that error-correcting codes were built to solve.
Carried by Claude Shannon; A Mathematical Theory of Communication (1948).
Error detection and correction influenced Quantum error correction in Coding Theory
Quantum error correction took the classical scheme of encoding logical states into redundant physical states and measuring syndromes to detect and correct errors, adapting it to the no-cloning constraint. Shor's 1995 nine-qubit code is explicitly modelled on classical repetition and linear codes.
Carried by Peter Shor; Andrew Steane.
Error detection and correction influenced Quantum error correction in Quantum Computation
Quantum error correction took the classical scheme of encoding, syndrome measurement and recovery from error-correcting codes and adapted it to the no-cloning constraint of quantum states. Shor's 1995 nine-qubit code and Steane's CSS construction built directly on classical coding theory.
Carried by Peter Shor; Andrew Steane.
Reliability Engineering grew out of Statistical Quality Control and Life Testing in Reliability Engineering
Reliability engineering grew directly out of statistical quality control and life testing: Shewhart's control charts and Weibull's failure distributions were taken up by military and electronics reliability programmes after 1950.
Carried by Walter A. Shewhart; Waloddi Weibull.
Reliability Engineering influenced Site reliability engineering in Devops And Sre
Site reliability engineering took reliability engineering's core apparatus, especially service level objectives, error budgets and failure-rate measurement, and applied it to large-scale software services.
Carried by Benjamin Treynor Sloss.
Reliability Engineering provoked Resilience engineering in Human Factors
Resilience engineering was framed by Hollnagel and colleagues as a corrective to classical reliability engineering, arguing that safety comes from adaptive capacity rather than from eliminating variance and error.
Carried by Erik Hollnagel; David Woods.
Reliability Engineering influenced Software Safety in System Safety
Software safety grew out of reliability engineering's concepts of failure modes, redundancy and quantitative reliability, applied to software. Software reliability engineering and safety-critical software practice extended reliability methods to programs.
Carried by Reliability Engineering.
Reliability Engineering led to Software Reliability Engineering in Reliability Engineering
Software reliability engineering is the application of reliability engineering's concepts—failure rate, reliability growth, operational profile—to software, developed as its branch from the 1970s.
Carried by Musa.
Fault-Tolerant Computing led to Byzantine Fault Tolerance in Distributed Algorithms
Byzantine fault tolerance grew directly out of fault-tolerant computing: the Lamport-Shostak-Pease problem generalized earlier work on reliable systems from benign crash failures to arbitrary (Byzantine) failures.
Carried by Leslie Lamport; Robert Shostak; Marshall Pease.
Transactions and ACID led to Weak Isolation Levels in Transaction Processing
Weak isolation levels were defined by weakening the isolation guarantee of ACID transactions; the ANSI SQL-92 isolation levels and later work by Berenson et al. specify anomalies permitted when full serializability is not enforced.
Carried by ANSI SQL-92; Hal Berenson; A Critique of ANSI SQL Isolation Levels (1995).
Transactions and ACID influenced Journaling file system in Storage Systems
Journaling file systems applied the write-ahead logging and atomic-commit techniques of database transactions and ACID guarantees to file-system metadata updates.

Reliability Fault Tolerance 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 Reliability Fault ToleranceRelated fields
Fields its ideas are linked to
- Reliability Engineering 19 links
- Distributed Algorithms 7 links
- Transaction Processing 5 links
- Distributed Systems 3 links
- Storage Systems 3 links
- Coding Theory 2 links
- Human Factors 2 links
- Aerospace Structures 1 link
- Structural Engineering 1 link
- Extremal Combinatorics 1 link
- Data Science 1 link
- Database Theory 1 link
More in Computer Systems
See where Reliability Fault Tolerance sits on the Map of Human Knowledge