BASE vs ACID: Visual walkthrough — Coding deep dive

Step 1 — What a "node" is, and why there is more than one

WHAT. A node is one computer that stores a copy of your data. When we say a system is distributed, we mean the same piece of data lives on several nodes at once — this copying is called replication (see Replication and Partitioning).

WHY start here. The whole ACID-vs-BASE argument only appears once there is more than one copy. On a single machine, being strict is cheap and free of dilemmas. The tension is born the moment a second copy exists, because now two copies can disagree.

PICTURE. Two nodes, $N_{1}$ and $N_{2}$ , each holding a value we'll call $x$ . A wire connects them so they can tell each other about changes.

Step 2 — What "consistent" and "available" mean, drawn as promises

WHAT. We name the two promises a database might try to keep:

Consistency (C) — every read returns the newest write. If someone just set $x = 6$ , nobody anywhere is allowed to read the old $5$ .
Availability (A) — every request gets a real answer (never an error, never an endless wait).

WHY define them so sharply. The CAP theorem is a statement about these exact words. Loose definitions hide the conflict; sharp ones make it unavoidable. Notice $C$ is about never being wrong and $A$ is about always answering — already they smell like opposites.

PICTURE. A reader asks node $N_{2}$ "what is $x$ ?". Green speech bubble = a fresh, correct answer (both C and A happy). We'll break this in the next step.

Step 3 — The partition: what happens when the wire dies

WHAT. A partition (P) is when the wire between nodes stops delivering messages. $N_{1}$ and $N_{2}$ are both alive and serving users, but they cannot talk to each other.

WHY this is the crux. Networks are physical — cables cut, routers reboot, packets drop. So partitions are not a choice, they are a fact (this is why distributed systems must tolerate them). The theorem asks: while the wire is dead, what can you still promise?

PICTURE. The same two nodes, but the wire is now a broken red dashed line. A write $x = 6$ arrives at $N_{1}$ ; $N_{2}$ has no way to hear about it.

Step 4 — The forced fork: a reader arrives during the partition

WHAT. During the partition, a user asks $N_{2}$ for $x$ . But $N_{2}$ 's copy still says $5$ , while the true latest write (at $N_{1}$ ) is $6$ . $N_{2}$ faces a fork with exactly two options — there is no third.

WHY only two. By the sharp definitions in Step 2, $N_{2}$ must either return a value or not:

Answer with $5$ → it responded, so A holds; but $5 \neq = 6$ , so C breaks.
Refuse / wait until the wire heals → the answer is correct-or-nothing, so C holds; but it did not respond, so A breaks.

PICTURE. A single fork diagram: one arrow to "return 5 (stale)" marked A ✓ C ✗, the other to "refuse / block" marked C ✓ A ✗.

Step 5 — Naming the two roads: CP and AP

WHAT. The two branches of Step 4 are the two families of databases:

CP (Consistency + Partition-tolerance): pick the "refuse/block" road. This is the ACID-leaning choice — it would rather make you wait than tell you $5$ .
AP (Availability + Partition-tolerance): pick the "return stale" road. This is the BASE-leaning choice — it answers $5$ now and fixes it later.

WHY these labels. Both keep $P$ (mandatory, Step 3). They differ only in which of $C$ / $A$ they sacrifice — precisely the fork of Step 4. So the abstract theorem becomes a concrete engineering label.

PICTURE. Two panels. Left (CP): $N_{2}$ shows a "please wait" stop-sign. Right (AP): $N_{2}$ cheerfully returns $5$ with a small clock icon meaning "I'll be right soon."

Step 6 — Degenerate case: the wire is healthy

WHAT. Rewind to before the partition, when the wire works. Now a write $x = 6$ at $N_{1}$ is copied to $N_{2}$ almost instantly. A reader at $N_{2}$ gets $6$ — both C and A hold at once.

WHY show this. It stops a false lesson. CAP does not say "you can never have C and A together." It says you can't have them together only while a partition is active. When the network is fine, a good system gives you both. The trade-off is a partition-time trade-off.

PICTURE. Healthy wire (solid green). Write $6$ flows $N_{1} \to N_{2}$ ; both nodes read $6$ ; reader gets a green correct answer.

Step 7 — Degenerate case: partition heals (how AP "catches up")

WHAT. The wire comes back. The AP system, which had answered stale $5$ , now lets $N_{2}$ hear the missed write and update to $6$ . After this reconciliation both copies agree again.

WHY this matters. It shows why "eventual" is a promise, not a hope. AP didn't abandon correctness — it deferred it. Given no new writes, the copies are guaranteed to converge. You lost the timing of correctness, never the destination.

PICTURE. Three frames left→right: (1) split copies $N_{1} = 6, N_{2} = 5$ ; (2) wire heals, sync message flies; (3) both $= 6$ , labelled "converged".

Recall Why this rescues the "eventual" objection

Question: does AP mean the data is wrong forever? ::: No — once the partition heals and no new writes arrive, replicas converge to the same value; you only lost the moment, not the outcome.

The one-picture summary

Everything above is a single decision tree. Is the wire alive? If yes → you get C and A (Step 6). If no (a partition) → you hit the fork (Step 4) and must pick a road: CP blocks to stay correct (ACID), AP answers stale then reconciles (BASE, Steps 5 & 7).

Recall Feynman retelling — the whole walkthrough in plain words

Two friends each keep a copy of a number in a shared notebook, linked by a phone line. While the phone works, one tells the other the moment the number changes, so both are correct and both answer instantly — no problem at all. Now the phone line dies. Friend A changes the number to 6; friend B never hears. Someone asks friend B, "what's the number?" B has only two honest choices: say "5" (fast, but out of date), or say "hang on, I can't reach A" (correct, but leaves you waiting). There is no third option — B simply doesn't know the new value. Choosing "wait until I can check" is the CP / ACID friend — never wrong, sometimes silent. Choosing "here's 5 for now, I'll fix it when the line's back" is the AP / BASE friend — always answers, briefly stale, and truly does catch up the instant the phone works again. That's the entire theorem: broken line ⇒ pick correct or always-answering, not both. Working line ⇒ you happily get both.