Visual walkthrough — RAID — levels 0, 1, 5, 6, 10 — trade-offs

We only need one tool the whole way through: an operation called XOR. So we start there.

Step 1 — Meet XOR, the "are they different?" switch

WHAT. Before any disks, we define the single operation this whole page rests on. Write it as $\oplus$ (a plus inside a circle). It takes two bits — a bit is just a $0$ or a $1$ — and outputs one bit. The rule is: output $1$ if the two inputs differ, output $0$ if they are the same.

Here $\oplus$ is the operation; each $0$ and $1$ on the left is an input bit; each result on the right is the output bit. That is the entire definition — there is nothing hidden.

WHY this tool and not addition? Ordinary addition would give $1+1=2$, which is not a bit — it overflows. We need an operation that stays inside $\{0,1\}$ and can be undone. XOR does both. (This is the same $\oplus$ you met in XOR and Boolean Algebra.)

PICTURE. The truth table drawn as a light-switch: same inputs → light off ($0$), different inputs → light on ($1$).

Step 2 — The two properties that make magic possible

WHAT. From the table in Step 1, read off two facts. Every symbol below is a single bit.

• $x\oplus x=0$: a value XORed with itself vanishes — because a thing never differs from itself, so the switch is off.
• $x\oplus 0=x$: a value XORed with $0$ is unchanged — because $0$ agrees where $x$ is $0$ and differs where $x$ is $1$, leaving $x$ exactly.

Two more bookkeeping facts, straight from the table:

• Commutative: $a\oplus b=b\oplus a$ (order does not matter).
• Associative: $(a\oplus b)\oplus c=a\oplus (b\oplus c)$ (grouping does not matter).

WHY we collect these. These four rules are the only algebra we will use. "Vanishes with itself" is the trick that recovers a lost disk; "commutative + associative" is what lets us shuffle terms freely to make that cancellation happen.

PICTURE. Two bits meeting: identical pair → annihilate to $0$; anything meeting $0$ → passes through untouched.

Step 3 — Lay out the disks and build the parity block $P$

WHAT. Now the disks. Picture $n$ disks side by side. On one stripe (one horizontal row across all disks) we store data blocks $D_1,D_2,\dots ,D_{n-1}$ — one per disk — and reserve the last disk for a computed parity block $P$. Each $D_i$ is just a string of bits living on disk $i$. We define:

Read left to right: XOR the first two data blocks, then XOR the third into that running result, and so on. $P$ is the final running total — the "summary number" the Feynman story in the parent called magic.

WHY define it this way? Because of Step 2, this single block secretly "remembers" every $D_i$ in a way we can peel back out. We are not storing a copy of any disk — $P$ is smaller than that (one block, not $n-1$) — yet it holds enough to reconstruct any one lost block. That is the whole economy of RAID 5.

PICTURE. A stripe: data blocks flowing into an XOR gate, out comes the parity block on the dedicated cell.

Step 4 — A disk dies: set up the rescue

WHAT. Suppose disk $k$ fails, so $D_k$ is gone. We still hold every other data block and $P$. Collect everything we still have and XOR it all together:

$R$ is our candidate rescue value — call it "everything left, XORed." We have not proven anything yet; we have only gathered what survived.

WHY start here? XOR is self-inverse (Step 2), so the natural move to undo a mixture is to XOR again. We throw the survivors back into $P$ hoping they cancel their own contributions and leave only the missing one.

PICTURE. The array with one greyed-out dead disk; arrows drag every surviving block plus $P$ into a single XOR machine.

Step 5 — Watch the survivors cancel, term by term

WHAT. Substitute the definition of $P$ from Step 3 into $R$. Every survivor now appears twice: once as itself, once buried inside $P$.

Now use commutative + associative (Step 2) to pair each survivor with its twin:

Every pair $D_i\oplus D_i$ becomes $0$ by $x\oplus x=0$. The only term without a partner is $D_k$ — because $D_k$ never showed up among the survivors, it only lives inside $P$. All those zeros pass through by $x\oplus 0=x$, and what remains is:

WHY it works. This is the punchline: $P$ carried a copy of $D_k$'s contribution, and XORing every other block against $P$ erased everything except $D_k$. The dead disk is reborn.

PICTURE. A cancellation ladder: each survivor pairs with its ghost inside $P$, both collapse to $0$, and $D_k$ is left standing alone in the spotlight.

Step 6 — Concrete numbers (the derivation, checked)

WHAT. Take three 4-bit blocks and run the whole machine.

• $D_1=1011,D_2=0110,D_3=1100$.
• Build $P$ (Step 3): first $1011\oplus 0110=1101$ (XOR each column), then $1101\oplus 1100=0001$. So $P=0001$.
• Now disk 2 dies. Rescue (Step 5): $D_2=P\oplus D_1\oplus D_3$.
  • $0001\oplus 1011=1010$,
  • $1010\oplus 1100=0110$.
• Result $0110$ — exactly the original $D_2$. ✓

WHY show numbers. The algebra was symbolic; this proves the ghosts really cancel on a real stripe. Column-by-column, the "different?" rule reproduces the lost data with zero guessing.

PICTURE. The four bit-strings stacked as coloured columns, the XOR sweeping down each column, recovered $D_2$ glowing to match the original.

Step 7 — The edge case: why parity fixes ONE disk, never two

WHAT. What if two disks die at once — say $D_j$ and $D_k$? Run the rescue: XOR everything we still have. Now two terms have no twin, so instead of a clean answer we get:

WHY this is a dead end. That is a single equation with two unknowns — like being told "$x+y=5$" and asked for $x$. Infinitely many $(D_j,D_k)$ give the same $R$; parity cannot tell them apart. One parity block = one equation = can solve for exactly one missing block. This is the precise reason RAID 5 survives only a single failure.

The RAID 6 fix (why a second XOR would not help). Adding another plain XOR parity $P^{\prime }$ just gives $P^{\prime }=P$ — the same equation again, useless. RAID 6 instead computes a second, independent check $Q={⨁}_i{g}^i{D}_i$, where the $g^i$ are distinct nonzero multipliers from a Galois field $GF(2^8)$. Because each block is weighted differently, $P$ and $Q$ are two different equations in the two unknowns — now solvable. Two independent equations → two failures survivable.

PICTURE. Left: one line through a plane (one equation), the unknown pair slides freely along it — unsolvable. Right: two crossing lines (P and Q) pin a single point — solved.

The one-picture summary

WHAT. The whole journey on one canvas: define $\oplus$ → fold data into $P$ → a disk dies → XOR survivors against $P$ → ghosts cancel → $D_k$ returns; and the wall at two failures where one equation cannot hold two unknowns.

Active recall