Simple Design — Practice Tasks¶

Category: Craftsmanship Disciplines — Kent Beck's four rules for writing code that is no more complicated than it needs to be, in strict priority order.

10 graded hands-on tasks with full Python, Java, and Go solutions. Try each before expanding the solution. Each task names the rule(s) it exercises.

Table of Contents¶

1. Task 1: Reveal Intent via Naming
2. Task 2: Remove Real Duplication
3. Task 3: Don't DRY Coincidental Similarity
4. Task 4: Delete a Needless Abstraction
5. Task 5: Evolve a Design Through All Four Rules
6. Task 6: Apply the Rule of Three
7. Task 7: Remove Speculative Generality
8. Task 8: Resolve a Clarity-vs-DRY Conflict
9. Task 9: Escape the Wrong Abstraction
10. Task 10: Decide Emergent vs. Up-Front
11. Practice Tips

Task 1: Reveal Intent via Naming¶

Rule: 2 (reveals intention). Goal: Rename cryptic identifiers and extract magic numbers so the code's purpose is obvious. Behavior must not change (Rule 1).

Given (Python):

def calc(d, n):
    return d - (d * n * 0.05)

DISCOUNT_PER_UNIT = 0.05

def discounted_price(base_price, units):
    return base_price - (base_price * units * DISCOUNT_PER_UNIT)

static final double DISCOUNT_PER_UNIT = 0.05;

double discountedPrice(double basePrice, int units) {
    return basePrice - (basePrice * units * DISCOUNT_PER_UNIT);
}

const discountPerUnit = 0.05

func discountedPrice(basePrice float64, units int) float64 {
    return basePrice - (basePrice * float64(units) * discountPerUnit)
}

Task 2: Remove Real Duplication¶

Rule: 3 (no duplication). Goal: The same knowledge (line total = price × quantity) is stated three times. Give it one home.

Given (Java):

double subtotal(List<Item> items) {
    double s = 0;
    for (Item i : items) s += i.price() * i.qty();
    return s;
}
double tax(List<Item> items) {
    double s = 0;
    for (Item i : items) s += i.price() * i.qty() * 0.2;   // line total duplicated
    return s;
}

double lineTotal(Item i) { return i.price() * i.qty(); }      // ONE home

double subtotal(List<Item> items) {
    return items.stream().mapToDouble(this::lineTotal).sum();
}
double tax(List<Item> items) {
    return subtotal(items) * TAX_RATE;                        // tax built on subtotal
}

def line_total(item): return item.price * item.qty

def subtotal(items): return sum(line_total(i) for i in items)
def tax(items):      return subtotal(items) * TAX_RATE

func lineTotal(i Item) float64 { return i.Price * float64(i.Qty) }

func subtotal(items []Item) (s float64) {
    for _, i := range items { s += lineTotal(i) }
    return
}
func tax(items []Item) float64 { return subtotal(items) * taxRate }

Task 3: Don't DRY Coincidental Similarity¶

Rule: 3 (no duplication — correctly). Goal: Two functions look identical but encode different rules. Recognize the coincidence and keep them separate.

Given (Python):

def shipping_fee(weight):  return weight * 1.5
def handling_fee(weight):  return weight * 1.5   # looks identical — merge?

SHIPPING_RATE_PER_KG = 1.5
HANDLING_RATE_PER_KG = 1.5    # SAME value today, DIFFERENT rule — keep separate

def shipping_fee(weight): return weight * SHIPPING_RATE_PER_KG
def handling_fee(weight): return weight * HANDLING_RATE_PER_KG

static final double SHIPPING_RATE_PER_KG = 1.5;
static final double HANDLING_RATE_PER_KG = 1.5;

double shippingFee(double weight) { return weight * SHIPPING_RATE_PER_KG; }
double handlingFee(double weight) { return weight * HANDLING_RATE_PER_KG; }

const shippingRatePerKg = 1.5
const handlingRatePerKg = 1.5

func shippingFee(w float64) float64 { return w * shippingRatePerKg }
func handlingFee(w float64) float64 { return w * handlingRatePerKg }

Task 4: Delete a Needless Abstraction¶

Rule: 4 (fewest elements). Goal: Remove a one-implementation interface and its indirection. Behavior unchanged.

Given (Go):

type Clock interface{ Now() time.Time }
type SystemClock struct{}
func (SystemClock) Now() time.Time { return time.Now() }

func timestamp(c Clock) string { return c.Now().Format(time.RFC3339) }
// SystemClock is the only implementation, and timestamp is called once with it.

func timestamp() string { return time.Now().Format(time.RFC3339) }

String timestamp() { return Instant.now().toString(); }

def timestamp(): return datetime.now(timezone.utc).isoformat()

Task 5: Evolve a Design Through All Four Rules¶

Rules: 1 → 2 → 3 → 4. Goal: Take a broken first draft and walk it through every rule in order. State which rule each step satisfies.

Given (Python) — buggy and crude:

def fare(km, t):
    if t == 1:
        c = km * 2
    # missing branches; returns None for other types
    return c

def fare(km, t):
    if t == 1: return km * 2     # standard
    if t == 2: return km * 3     # express
    return km * 1                # economy (default)

RATE_PER_KM = {"economy": 1, "standard": 2, "express": 3}

def fare(distance_km, service_class):
    rate = RATE_PER_KM[service_class]
    return distance_km * rate

static final Map<String,Integer> RATE_PER_KM =
    Map.of("economy", 1, "standard", 2, "express", 3);

int fare(int distanceKm, String serviceClass) {
    return distanceKm * RATE_PER_KM.get(serviceClass);
}

var ratePerKm = map[string]int{"economy": 1, "standard": 2, "express": 3}

func fare(distanceKm int, serviceClass string) int {
    return distanceKm * ratePerKm[serviceClass]
}

Task 6: Apply the Rule of Three¶

Rule: 3 + rule of three. Goal: You have two similar blocks. Decide whether to extract now — and when a third appears, do the extraction shaped by all three.

Given (Python) — two occurrences:

# occurrence 1
total_a = sum(x.amount for x in cart_a)
print(f"Cart A total: ${total_a:.2f}")

# occurrence 2
total_b = sum(x.amount for x in cart_b)
print(f"Cart B total: ${total_b:.2f}")

def print_cart_total(label, cart):
    total = sum(x.amount for x in cart)
    print(f"{label} total: ${total:.2f}")

print_cart_total("Cart A", cart_a)
print_cart_total("Cart B", cart_b)
print_cart_total("Cart C", cart_c)

void printCartTotal(String label, List<LineItem> cart) {
    double total = cart.stream().mapToDouble(LineItem::amount).sum();
    System.out.printf("%s total: $%.2f%n", label, total);
}

func printCartTotal(label string, cart []LineItem) {
    var total float64
    for _, x := range cart { total += x.Amount }
    fmt.Printf("%s total: $%.2f\n", label, total)
}

Task 7: Remove Speculative Generality¶

Rule: 4 + YAGNI. Goal: Strip out flexibility added for an imagined future — unused parameters, config nobody sets, a hook nobody uses.

Given (Java):

String greet(String name, String locale, boolean formal,
             Map<String,Object> extensions, GreetingHook hook) {
    String g = formal ? "Good day, " : "Hi ";   // locale, extensions, hook unused
    return g + name;
}
// Every caller: greet(name, "en", false, Map.of(), null)

String greet(String name, boolean formal) {
    return (formal ? "Good day, " : "Hi ") + name;
}

def greet(name, formal=False):
    return ("Good day, " if formal else "Hi ") + name

func greet(name string, formal bool) string {
    if formal { return "Good day, " + name }
    return "Hi " + name
}

Task 8: Resolve a Clarity-vs-DRY Conflict¶

Rules: 2 vs 3 (clarity wins). Goal: Removing duplication here would create a confusing multi-flag helper. Choose clarity.

Given (Python) — two methods share ~70% of code, but differ in meaningful ways:

# A "DRY" attempt someone proposed:
def render(self, mode, compact, redact, totals):
    out = []
    if mode == "summary":
        out.append(self.title)
        if not compact: out.append(self.subtitle)
    elif mode == "detail":
        for row in self.rows:
            out.append(self._fmt(row, redact))
    if totals: out.append(self._totals())
    return "\n".join(out)   # 4 params, 2 modes, hard to follow

def render_summary(self, compact=False):
    out = [self.title]
    if not compact:
        out.append(self.subtitle)
    out.append(self._totals())
    return "\n".join(out)

def render_detail(self, redact=False):
    out = [self._fmt(row, redact) for row in self.rows]
    out.append(self._totals())
    return "\n".join(out)
# _totals() is the genuinely shared knowledge — it stays DRY.

String renderSummary(boolean compact) {
    var out = new ArrayList<String>(List.of(title));
    if (!compact) out.add(subtitle);
    out.add(totals());
    return String.join("\n", out);
}
String renderDetail(boolean redact) {
    var out = rows.stream().map(r -> fmt(r, redact)).collect(toList());
    out.add(totals());
    return String.join("\n", out);
}

func (d Doc) RenderSummary(compact bool) string {
    out := []string{d.Title}
    if !compact { out = append(out, d.Subtitle) }
    out = append(out, d.totals())
    return strings.Join(out, "\n")
}
func (d Doc) RenderDetail(redact bool) string {
    out := make([]string, 0, len(d.Rows))
    for _, r := range d.Rows { out = append(out, d.fmt(r, redact)) }
    out = append(out, d.totals())
    return strings.Join(out, "\n")
}

Task 9: Escape the Wrong Abstraction¶

Rules: 2, 3, 4 (re-introduce duplication, then re-extract). Goal: A shared abstraction has accreted flags serving divergent callers. Inline it, simplify each caller, re-extract only what's truly shared.

Given (Python) — the wrong abstraction:

def notify(user, kind, urgent=False, digest=False, channel="email"):
    if kind == "welcome":
        subject = "Welcome!"
    elif kind == "receipt":
        subject = "Your receipt"
    elif kind == "alert":
        subject = ("URGENT: " if urgent else "") + "Account alert"
    body = render(kind, user, digest)
    send(channel, user, subject, body)

def send_welcome(user):
    send("email", user, "Welcome!", render_welcome(user))

def send_receipt(user, order):
    send("email", user, "Your receipt", render_receipt(user, order))

def send_alert(user, urgent=False):
    subject = ("URGENT: " if urgent else "") + "Account alert"
    send("email", user, subject, render_alert(user))
# `send(...)` is the genuinely shared knowledge (transport) — it stays.
# The kind-switch, the unused `digest`, and the `channel` flag are gone.

Task 10: Decide Emergent vs. Up-Front¶

Concept: reversibility / one-way doors. Goal: For each decision, say whether to defer (YAGNI/emergent) or design up-front, and why.

Decisions: 1. The internal structure of an order-pricing module. 2. The JSON shape of a public webhook payload third parties consume. 3. Whether to put a repository interface between domain and SQL. 4. The on-disk format for a new event-log file. 5. The names and signatures of private helper methods.

Practice Tips¶

1. Always run the rules in order — correct, then clear, then DRY, then minimal. Never break a higher rule for a lower one.
2. Before DRYing, ask: would a change to one force the same change to the other? If no, it's coincidence — keep them apart.
3. Default to the rule of three for extraction; extract immediately only when the knowledge is provably identical.
4. For every abstraction you add, name the present requirement that forces it. "Might need it later" → don't.
5. To fix a wrong abstraction, inline first (re-introduce duplication), then re-extract only the genuinely shared knowledge.
6. Check reversibility before invoking YAGNI: reversible → defer; one-way door → design up-front.
7. Keep tests green throughout — they're what let you pursue clarity, DRY, and minimalism fearlessly.

← Interview · Craftsmanship Disciplines · Roadmap · Next: Find-Bug