DRY — Don't Repeat Yourself: Worked examples — Coding deep dive

The scenario matrix

Think of every DRY decision as a point on a grid. The two questions that decide everything are:

Do the copies encode the same knowledge? (same rule / fact / structure)
Would they change together, for the same reason?

Only when both are "yes" is it a true violation. Here is the full space of cells this topic can throw at you:

Cell	Name	Same knowledge?	Change together?	Verdict
A	Real logic duplication	yes	yes	DRY it (extract function)
B	Real fact/data duplication	yes	yes	DRY it (single source of truth)
C	Structural duplication	yes	yes	DRY it (loop / template)
D	Coincidental duplication	no	no	Leave apart
E	Not-yet-a-pattern (2 copies)	maybe	unknown	Wait (Rule of Three)
F	Over-DRY god abstraction	yes	but diverging	Undo — re-duplicate
G	Degenerate: 1 copy ( $n = 1$ )	—	—	already DRY, do nothing
H	Limiting: many copies, exam-style	yes	yes	quantify the risk

The rest of the page is eight worked examples, one per cell A–H. Every symbol used ( $n$ , $c$ , $p$ ) is exactly the one built in the parent's cost model — nothing new is smuggled in.

Look at the figure above: the grid axis "Same knowledge?" runs left→right, "Change together?" runs bottom→top. The amber region (top-right) is the only place you DRY. Everything else is a trap or a no-op.

Cell A — Real logic duplication

Worked example Statement

Two invoice paths both compute a total as price plus 18% tax:

total_a = price_a + price_a * 0.18
total_b = price_b + price_b * 0.18

Is this a DRY violation? If so, what is the edit cost before and after fixing it?

Forecast: Guess now — same knowledge? same reason to change? What's $n$ before and after?

Identify the knowledge. The rule is "total = price + 18% of price". Why this step? DRY is about knowledge, so we must first name the knowledge, not stare at characters.
Count the homes. That rule lives in two places → $n = 2$ . Why this step? The parent's cost model $C_{edit} = n \cdot c$ needs $n$ .
Ask the test. "Do both change together, for the same reason?" If the tax law changes, both must change. → Yes → true duplication, Cell A. Why this step? This separates A from D.

Extract. Give the fact and the logic one home each:

TAX_RATE = 0.18
def with_tax(price):
    return price + price * TAX_RATE
total_a = with_tax(price_a)
total_b = with_tax(price_b)

Why this step? Now

n = 1

: one edit changes the rule everywhere.

Verify: Cost model. Take $c = 1$ (one unit per edit). Before: $C = n \cdot c = 2$ . After: $C = 1 \cdot 1 = 1$ . Halved. Numerically, with_tax(100) = 100 + 100*0.18 = 118, and the original 100 + 100*0.18 = 118 — identical output, so behaviour is preserved. See Refactoring — Extract Method.

Cell B — Real fact/data duplication (single source of truth)

Forecast: Guess the number of edits, and guess the consistency probability.

Name the knowledge. "The set of states we accept." One fact. Why this step? Data facts are still knowledge — Cell B, not C.
Count homes. Frontend + backend → $n = 2$ . Why this step? Needed for both cost formulas.
Apply consistency model. With slip probability $p = 0.1$ per copy, the parent gives $P_{consistent} = (1 - p)^{n} = (0.9)^{2} = 0.81$ . Why this step? Quantifies the drift risk before fixing.
DRY it. Store the list in one config/table; both layers read it → this is a Single Source of Truth. Now $n = 1$ , so $P = (0.9)^{1} = 0.9$ . Why this step? One authoritative home removes the drift entirely for future edits.

Verify: $(0.9)^{2} = 0.81$ and $(0.9)^{1} = 0.9$ . Editing 2 copies is 9 percentage points more likely to drift than editing 1. Adding "WA" under WET touches 2 files; under the fix, 1.

Cell C — Structural duplication (loop / template)

Worked example Statement

Three near-identical UI calls:

draw_button("Save")
draw_button("Cancel")
draw_button("Help")

Is the knowledge here logic, data, or structure — and how do we DRY it without a god-function?

Forecast: Guess what varies and what stays fixed.

Separate the constant from the variable. The procedure draw_button(...) is fixed; only the label varies. Why this step? DRY structure = express the fixed part once, feed it the varying data.
Verdict. Same procedure, changes together (fix a bug in drawing → fixes all) → Cell C, a real violation. Why this step? Confirms it's not coincidental.
Extract the loop.
```
for label in ["Save", "Cancel", "Help"]:
    draw_button(label)
```
Why this step? The drawing procedure now appears once; the data list carries the variation.

Verify: Count of draw_button calls executed is unchanged: 3 buttons drawn either way. Count of draw_button lines written dropped from 3 to 1. Behaviour identical, source-of-truth for "how to draw a button" is now singular.

Cell D — Coincidental duplication (the #1 trap)

Worked example Statement

Two constants happen to be equal today:

MAX_UPLOAD_MB = 100     # storage limit
PAGE_SIZE     = 100     # rows per page

They look identical. Must you merge them into SHARED_100 = 100?

Forecast: Same characters — but is it the same knowledge? Guess before reading.

Name each knowledge. One is "max upload size"; the other is "rows per page." Different facts. Why this step? DRY is knowledge, not the digits 100.
Apply the test. "Do they change together, for the same reason?" If we later allow 500 MB uploads, page size should not jump to 500. → No. Why this step? This is the exact test the parent's mnemonic gives.
Verdict. Cell D — coincidental (accidental) duplication. Merging would couple two unrelated decisions. Leave them apart. Why this step? See The Wrong Abstraction and Single Responsibility Principle — "one reason to change".

Verify: Suppose we later set upload to 500 while page size stays 100. With the (wrong) merge SHARED_100, we cannot express two different values — the abstraction breaks. With two constants, both values are freely expressible. So keeping them separate strictly preserves capability the merge destroys.

Cell E — Not yet a pattern (Rule of Three)

Forecast: $n = 2$ . Does two copies already justify an abstraction?

Count occurrences. Two. Why this step? The Rule of Three triggers on the third.
Judge confidence. With only 2 examples you can't yet see which parts are essential vs coincidental to the pattern — extracting now risks Premature Abstraction. Why this step? An abstraction built from 2 data points often fits neither future case.
Decision. Wait. Tolerate the duplication; when the third occurrence appears, the true shape is clear, then extract. Why this step? Sandi Metz: "duplication is far cheaper than the wrong abstraction."

Verify: Risk arithmetic. With $p = 0.1$ , two copies drift with probability $1 - (0.9)^{2} = 0.19$ . That 19% risk is real but cheaper than paying for a wrong abstraction you must later unwind (Cell F shows that unwind cost). The Rule of Three is a bet that seeing 3 examples beats guessing from 2.

Cell F — Over-DRY: undoing a god-abstraction

Forecast: More flags, or split it back apart? Guess the direction.

Diagnose. The single function is drowning in parameters/branches — each new requirement adds a flag. Why this step? This is the signature of The Wrong Abstraction: the abstraction is fighting the code.
Recall the rule. "Duplication is far cheaper than the wrong abstraction." The cases are diverging, so they are no longer the same knowledge. Why this step? Once knowledge diverges, the DRY justification evaporates.
Inline and re-split. Copy the function body back into the call sites, delete the flags, and let each case be its own simple function. Why this step? You trade a little duplication for a lot of clarity — the healthy inverse of extraction.

Verify: Complexity count. A function with 3 boolean flags has $2^{3} = 8$ possible branch combinations to reason about. Three plain functions have $3$ paths total. $3 < 8$ : re-duplicating cuts the reasoning surface. See KISS Principle.

Cell G — Degenerate case: only one copy ( $n = 1$ )

Forecast: What is $n$ here, and what does the cost model say?

Count homes. $n = 1$ . Why this step? $n$ is the whole story.
Plug the model. $C_{edit} = n \cdot c = 1 \cdot c = c$ (minimum possible) and $P_{consistent} = (1 - p)^{1} = 1 - p$ (maximum possible). Why this step? These are the best-case values the parent derived.
Verdict. Already DRY. Extracting further (splitting the one function for its own sake) would create abstraction with no duplication to justify it — YAGNI. Do nothing. Why this step? DRY is satisfied at $n = 1$ ; going below is meaningless.

Verify: With $c = 1, p = 0.1, n = 1$ : $C = 1$ and $P = 0.9$ . No arrangement of a single home can beat cost 1 or consistency $0.9$ . The reviewer's request is a no-op.

Cell H — Limiting / exam-style twist: many copies

Forecast: Guess whether 5 copies is "a bit worse" or "dramatically worse" than 1.

Set up. $p = 0.1$ . WET: $n = 5$ . DRY: $n = 1$ . Why this step? Identify the two scenarios to compare.
Consistency, WET. $P_{5} = (1 - p)^{5} = (0.9)^{5}$ . Why this step? Direct use of the parent's $(1 - p)^{n}$ .
Compute. $(0.9)^{5} = 0.59049$ — barely better than a coin flip! Why this step? Shows exponential decay is scary, not academic.
Consistency, DRY. $P_{1} = (0.9)^{1} = 0.9$ . Why this step? The single-source-of-truth baseline.
Failure factor. WET failure $= 1 - 0.59049 = 0.40951$ . DRY failure $= 1 - 0.9 = 0.1$ . Ratio $= 0.40951/0.1 \approx 4.10$ . Why this step? Turns probabilities into a headline: "~4× more likely to break."

Verify: $(0.9)^{5} = 0.59049$ ; $(0.9)^{1} = 0.9$ ; failure ratio $\frac{1 - ( 0.9 ) ^{5}}{1 - ( 0.9 ) ^{1}} = \frac{0.40951}{0.1} \approx 4.0951$ . Five copies are ~4× more likely to leave a stale timeout than one. This is the parent's exponential-decay claim made concrete.

Active Recall

Recall Which single cell of the matrix is the one where you

must leave code apart despite identical text? Cell D — coincidental (accidental) duplication: same characters, different knowledge, different reasons to change.

Recall In Cell H, why is 5 copies so much worse than 2, not just "a bit" worse?

Because $P_{consistent} = (1 - p)^{n}$ decays exponentially: $(0.9)^{2} = 0.81$ but $(0.9)^{5} = 0.590$ . Each extra copy multiplies the survival chance by $(1 - p)$ .

Recall Cell F says to

undo an abstraction. When is that correct? When the merged cases have diverged so they no longer encode the same knowledge, and the flags/branches now make the code harder than the duplication was — "the wrong abstraction."

Recall What is the verdict and reason for Cell G (

$n = 1$ )? Already DRY. $C_{edit} = c$ and $P_{consistent} = 1 - p$ are already optimal; further "DRYing" is abstraction with no duplication to justify it (YAGNI).

Connections

DRY — Don't Repeat Yourself — the parent principle these cases exercise.
Single Source of Truth — Cell B.
Rule of Three — Cell E.
The Wrong Abstraction / Premature Abstraction — Cells D and F.
Single Responsibility Principle — the "one reason to change" test.
Refactoring — Extract Method — the tool for Cells A and C.
KISS Principle / YAGNI — Cells F and G.
WET — Write Everything Twice — the "before" state in most cells.