Concepts
Relaxed consistency semantics
Intuition
Imagine a shared bulletin board where several people can stick notes at the same time. If only one person sticks up a note at a time, everyone who looks at the board afterward sees exactly that note, whole and legible. But if two people try to stick up notes at the same time, in the same space, the result can become an illegible mix of the two — even so, everyone who looks afterward sees the SAME mix, but no one can say for sure what each person wrote. This is the trade-off that GFS accepts: instead of always guaranteeing a clean note, it guarantees that at least everyone sees the same thing.
How it works
After a sequence of successful mutations, GFS distinguishes two weak guarantees instead of traditional strong consistency. A region is 'defined' when it was written by a single successful mutation without interference from concurrent writers — in that case all clients see exactly the same data, reflecting that mutation in full. When multiple concurrent writers compete for the same region, the result may be only 'consistent': all clients still see the same bytes, but those bytes may be an unpredictable mix of the data from the concurrent writers — 'undefined'. A failed mutation may leave the region inconsistent, with different chunk replicas holding data that differs from one another. To make this workable in practice, GFS offers a stronger guarantee for only one specific write pattern: record append, in which the client does not choose the offset — GFS itself chooses an offset and appends the record there atomically, at least once. This favors multiple concurrent producers writing to the same file, at the cost of allowing duplicate records or occasional padding, which applications must tolerate (for example, by embedding checksums or unique identifiers in each record to detect and skip duplicates).
In practice
The authors accepted this weaker contract deliberately, judging that most applications — co-designed along with the file system itself, such as a MapReduce job that has many workers append results to a single output file — could live with it in exchange for avoiding the coordination cost that a strong guarantee would require at that scale. This is the kind of trade-off you take on when you control both ends (system and application) and prioritize throughput and implementation simplicity over clean, predictable consistency semantics.
Use it in a design
Practice the cases that rely on this concept in the System Design school.