DRY — Don't Repeat Yourself: Exercises — Coding deep dive

Intuition How to use this page

Each problem is graded L1 → L5. Cover the solution, try it yourself, then reveal the collapsible Solution callout. The goal is not "did you get the right word" but can you defend the decision — because DRY is a judgement call, not a mechanical rule.

Two numbers appear again and again in these exercises, so let us pin them down before we use them (the contract: never use a symbol before it is earned):

$n$ = the number of separate places one single piece of knowledge is written down. If a tax rate lives in 4 files, $n = 4$ .
$c$ = the cost (time, risk) to correctly edit one of those places.
$p$ = the probability you forget one place while editing — a slip, between 0 and 1.

From the parent note we carry two formulas built from these:

Total edit cost $C_{edit} = n \cdot c$ — grows linearly with copies.
Chance all copies stay consistent $P_{consistent} = (1 - p)^{n}$ — decays as $n$ grows.

Level 1 — Recognition

Goal: can you spot whether a piece of text is a real DRY violation or a look-alike?

L1.1

Recall Solution (L1.1)

Here the same fact ("the tax rate is 18%") is written in $n = 3$ places.

WHAT / WHY: we plug into the cost model because we want the concrete pain of this specific duplication. $C_{edit} = n \cdot c = 3 \times 4 = 12 minutes$ $P_{consistent} = (1 - p)^{n} = (0.9)^{3} = 0.729$ So there is a $1 - 0.729 = 0.271$ , i.e. 27.1%, chance you leave one copy wrong. This is a real DRY violation — one fact, three homes.

L1.2

Recall Solution (L1.2)

(B) is the violation. The email-validation rule is one piece of knowledge; if the rule changes (e.g. allow + addressing), you must edit both copies. (A) is not a violation — the two 25s answer different questions and would change for different reasons. Merging them into one constant would couple unrelated decisions. See The Wrong Abstraction.

Level 2 — Application

Goal: perform the extraction and count the savings.

L2.1

Recall Solution (L2.1)

Before ( $n = 5$ ): $C_{edit} = 5 \times 3 = 15 min, P_{consistent} = (0.85)^{5} = 0.4437$ After ( $n = 1$ ): $C_{edit} = 1 \times 3 = 3 min, P_{consistent} = (0.85)^{1} = 0.85$ We cut edit time from 15 → 3 min and raised the "no bug" chance from 44.37% → 85%. This is exactly the Single Source of Truth payoff.

L2.2

Worked example Problem

Refactor this WET snippet with Refactoring — Extract Method. Then state what the value of $n$ (for the "add tax" rule) becomes.

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

Recall Solution (L2.2)

WHAT: extract the fact (0.18) into a constant and the logic (price + price*rate) into a function. WHY: so a tax change touches exactly one place.

TAX_RATE = 0.18                 # the FACT, one home
def with_tax(price):            # the LOGIC, one home
    return price + price * TAX_RATE
 
total_a = with_tax(price_a)
total_b = with_tax(price_b)
total_c = with_tax(price_c)

The "add tax" rule now has $n = 1$ . Changing the rate is a one-line edit.

Level 3 — Analysis

Goal: reason about trade-offs where DRY fights another principle.

L3.1

Recall Solution (L3.1)

Do not extract yet. By the Rule of Three, we wait until the third occurrence before abstracting, because two examples cannot reveal the true axis of variation. A function with 4 boolean flags is a classic Premature Abstraction: every call site must now pass build_report(True, False, True, False) — unreadable, and each flag adds a branch. The duplicated 12 lines are honest and local; the flagged abstraction hides the differences behind parameters. Verdict: tolerate the duplication now. If a third report appears and the same pattern holds, extract then — the real shape will be visible.

L3.2

Recall Solution (L3.2)

Extra cost of the duplication per change: $(n - 1) \cdot c = 1 \times 3 = 3$ min. Extra cost of the wrong abstraction per change: $b = 6$ min. The wrong abstraction is more expensive ( $6 > 3$ ). This is why Sandi Metz says “duplication is far cheaper than the wrong abstraction.” The correct move when you find a wrong abstraction is to inline it back (re-duplicate), then re-extract along the right seam.

Level 4 — Synthesis

Goal: design a solution combining DRY with sibling principles.

L4.1

Recall Solution (L4.1)

Step 1 — separate reasons to change (SRP). Email validation and country-code storage change for different reasons, so they belong in different homes — the Single Responsibility Principle tells us not to merge them just because they sit in the same class. Step 2 — one home each (DRY).

Email rule → a single validate_email() used by both frontend and backend.
Country codes → a Single Source of Truth: one config/table both layers read.

Step 3 — avoid over-DRY. Do not fuse the validator and the country list into one "validation module" god-object; they are unrelated (The Wrong Abstraction risk). Result: two independent single-source homes, each referenced everywhere. Both n values drop to 1.

L4.2

Recall Solution (L4.2)

Country list: before $4 \times 5 = 20$ , after $1 \times 5 = 5$ → saves 15 min. Email rule: before $3 \times 5 = 15$ , after $1 \times 5 = 5$ → saves 10 min. Total saved per change-pair = $15 + 10 = 25$ minutes, and the consistency risk on both drops to the single-copy best case.

Level 5 — Mastery

Goal: derive and defend a general threshold — the deepest reasoning.

L5.1

Recall Solution (L5.1)

WHAT / WHY: we compare "pay $E$ once" against "pay the duplication penalty every change," because whether to DRY depends on how often the code will change — a purely rational, YAGNI-aware criterion.

Extracting is worth it when the saved penalty over $k$ changes exceeds the one-time cost: $k \cdot (n - 1) \cdot c > E ⟹ k^{*} = \frac{E}{( n - 1 ) c}$ Plugging in $E = 30$ , $n = 3$ , $c = 5$ : $k^{*} = \frac{30}{( 3 - 1 ) \times 5} = \frac{30}{10} = 3$ So if you expect more than 3 future changes, extract; fewer, and the duplication is cheaper. Notice this lands right on the spirit of the Rule of Three — a beautiful coincidence that the arithmetic and the folk-rule agree.

L5.2

Recall Solution (L5.2)

WHAT / WHY: we invert the consistency formula because we want a budget — how much duplication a given reliability target allows. Require $(1 - p)^{n} \geq 0.90$ , i.e. $(0.95)^{n} \geq 0.90$ . Take logs (log is the tool that turns an exponent into a multiplier we can solve for): $n \leq \frac{l n 0.90}{l n 0.95} = \frac{- 0.10536}{- 0.051293} = 2.054$ Since $n$ must be a whole number, the largest allowed is $n = 2$ . At $n = 3$ : $(0.95)^{3} = 0.857 < 0.90$ , which fails. So under a 90% reliability bar and a 5% slip, you may keep at most 2 copies — again echoing "two is tolerable, three, extract."

Active Recall

Recall Cost to edit a fact in

$n$ places at $c$ each? $C_{edit} = n \cdot c$ — linear in the number of copies.

Recall Break-even number of future changes to justify extraction, cost

$E$ , penalty $(n - 1) c$ ? $k^{*} = \frac{E}{( n - 1 ) c}$ .

Recall With

$p = 0.05$ , how many copies keep consistency at or above 90%? At most 2, since $(0.95)^{3} = 0.857 < 0.90$ .

Connections

DRY — Don't Repeat Yourself — the parent principle these exercises drill.
Rule of Three — the L3/L5 delay heuristic, confirmed by the break-even arithmetic.
The Wrong Abstraction / Premature Abstraction — the L3 trap.
Single Source of Truth — the L2/L4 data-DRY target.
Single Responsibility Principle — split by reason to change before DRYing (L4).
Refactoring — Extract Method — the L2 mechanical tool.
KISS Principle & YAGNI — bound DRY against over-engineering (L3/L5).
WET — Write Everything Twice — the anti-pattern being removed.