Distributed Systems - Consistency Models & Replication Strategies

A consistency model is a contract between a distributed system and its clients regarding the visibility and ordering of updates to replicated data. It defines how and when a client sees the updates made by other clients.

Linearizability is the strongest consistency model. It guarantees that all operations appear to occur instantaneously at some point between their invocation and response, as if there were only a single copy of the data. This means a read operation will always return the most recent written value, and operations are totally ordered.

Eventual consistency is a weak consistency model where, if no new updates are made to a given data item, eventually all accesses to that item will return the last updated value. There might be a period of inconsistency after an update, but the system converges over time.

Causal consistency guarantees that if one operation causally affects another (e.g., A writes, then B reads A's write and writes something else), then all nodes will see these causally related operations in the same order. Unrelated (concurrent) operations might be seen in different orders by different nodes.

Sequential consistency guarantees that all operations appear to execute in some sequential order, and all nodes see this same sequential order. However, this order doesn't necessarily have to match the real-time order of operations. It's stronger than causal but weaker than linearizability.

Strong consistency (e.g., Linearizability) ensures all clients see the most recent write immediately and in a global total order. Eventual consistency allows for temporary inconsistencies, where different clients might see different values after a write, but guarantees convergence to the same value eventually. Strong consistency prioritizes correctness over availability/performance, while eventual consistency prioritizes availability/performance.

Causal consistency preserves the order of causally related operations across all nodes, but concurrent operations can be seen in different orders. Sequential consistency ensures all operations (causal and concurrent) are seen in the same global total order by all nodes, but this order doesn't have to reflect real-time. Causal is weaker than sequential.

Read-Your-Writes consistency guarantees that if a client performs a write and then subsequently performs a read, it will always see its own latest write. Other clients might not see it immediately, but the writing client is guaranteed to see its own updates.