Fault tolerance

Fault tolerance is a system’s ability to continue providing service despite component faults. It relies on detecting, containing, masking, or recovering from failures.

Redundancy (engineering): Redundancy is the duplication of components or capabilities so a system can retain function when one fails. Spare components or paths let service continue after a component fault.
Fault (technology): A fault is an underlying defect or abnormal condition that can cause a system to behave incorrectly. Component faults are the starting conditions that fault-tolerant designs must handle.
Distributed system: A distributed system consists of independent computers that communicate and coordinate to provide a service. Its components can fail independently, making continued service a central design problem.
Fault prevention: Fault prevention uses design and process measures to reduce the chance that faults are introduced or occur. It seeks to avoid faults rather than maintain service after they occur.
Common-mode failure: A common-mode failure occurs when multiple components fail in the same way because they share a cause. Shared causes can defeat redundant components that appear independent.
Failure detection: Failure detection is the process of determining whether a component or service has stopped working correctly. Recovery depends on recognizing faults quickly without mistaking delay for failure.
Failure (computing): A failure occurs when a system or component does not deliver its required service. Fault tolerance aims to prevent component faults from becoming service failures.
Replication (computing): Replication maintains copies of data or services on multiple nodes. Copies can keep data or service available when a replica becomes faulty or unreachable.
Fault avoidance: Fault avoidance steers a system away from operating conditions likely to cause faults or failures. It reduces exposure to faults instead of tolerating their effects.
N-version programming failure: N-version programming failure occurs when supposedly independent software versions produce the same incorrect result. Correlated design mistakes can defeat software diversity as a fault-tolerance strategy.

Linked from 12 pages