Cognitive Load — Find the Bug¶

12 snippets where high cognitive load hides a real bug. The defect is not exotic — it is a missing else, a transposed argument, an inverted clause. What makes it invisible is the surrounding complexity: deep nesting, dense one-liners, long positional argument lists, and mixed abstraction levels. Find the bug in the dense version; then watch it become obvious the moment the load drops.

Table of Contents¶

1. Snippet 1 — Dangling else bound to the wrong if — Java, Medium
2. Snippet 2 — Missing else lets a branch fall through — Python, Medium
3. Snippet 3 — Boolean flags passed in the wrong order — Go, Hard
4. Snippet 4 — Operator precedence in a clever one-liner — Python, Medium
5. Snippet 5 — Long parameter list with two same-typed args transposed — Java, Hard
6. Snippet 6 — Hidden side effect in a getter fires twice — Java, Hard
7. Snippet 7 — Inverted sub-clause (De Morgan mistake) — Go, Hard
8. Snippet 8 — Off-by-one buried in nested loops — Python, Medium
9. Snippet 9 — Short-circuit hides a skipped side effect — Java, Hard
10. Snippet 10 — Mixed abstraction levels hide an unchecked return — Go, Medium
11. Snippet 11 — Acronym-soup names hide a swapped assignment — Python, Easy
12. Snippet 12 — Ternary chain with the wrong association — Java, Hard

How to Use¶

Each snippet shows the dense, high-cognitive-load version first. Before opening the answer:

1. Read it cold, once, at full speed — the way a reviewer skims a 600-line PR. Did you catch the bug? If not, that is the lesson: the load hid it.
2. Now trace one concrete input by hand. State the value of every variable at every branch. The bug surfaces when you stop reading and start simulating.
3. Mentally apply one load-reducing move — a guard clause, a named boolean, a parameter object, an extracted variable — and check whether the bug becomes self-evident.

Then open the <details> block. It shows the bug and the de-loaded version where the defect is impossible to miss. The point is never "be more careful." Careful readers miss these every day. The point is: structure the code so the bug has nowhere to hide.

Snippet 1 — Dangling else bound to the wrong if¶

Difficulty: Medium · Language: Java

A risk engine decides whether to auto-approve, flag, or reject a transaction.

public Decision evaluate(Transaction txn, Account account) {
    Decision decision = Decision.REJECT;
    if (account.isVerified())
        if (txn.getAmount().compareTo(account.getDailyLimit()) <= 0)
            if (!txn.isFlaggedByFraudModel())
                decision = Decision.APPROVE;
            else
                decision = Decision.MANUAL_REVIEW;
    else
        decision = Decision.MANUAL_REVIEW;
    return decision;
}

The intent: verified accounts get evaluated; unverified accounts go to manual review (a human checks them out). What actually happens?

if (account.isVerified())
    if (amount <= dailyLimit)
        if (!flagged) APPROVE; else MANUAL_REVIEW;
    else                          // ← binds HERE, to the amount check
        MANUAL_REVIEW;
// no else on isVerified at all

public Decision evaluate(Transaction txn, Account account) {
    if (!account.isVerified()) {
        return Decision.MANUAL_REVIEW;
    }
    if (txn.getAmount().compareTo(account.getDailyLimit()) > 0) {
        return Decision.MANUAL_REVIEW;
    }
    if (txn.isFlaggedByFraudModel()) {
        return Decision.MANUAL_REVIEW;
    }
    return Decision.APPROVE;
}

Snippet 2 — Missing else lets a branch fall through¶

Difficulty: Medium · Language: Python

A tax bracket resolver returns the marginal rate for an annual income.

def marginal_rate(income):
    rate = 0.0
    if income > 0:
        rate = 0.10
    if income > 40_000:
        rate = 0.22
    if income > 85_000:
        rate = 0.24
    if income > 160_000:
        rate = 0.32
    if income > 200_000:
        rate = 0.35
        rate = 0.37 if income > 500_000 else rate
    return rate

Looks like a clean ladder. There is one bracket where it returns the wrong rate. Which input breaks it?

def marginal_rate(income):
    if income <= 0:
        return 0.0
    brackets = [
        (500_000, 0.37),
        (200_000, 0.35),
        (160_000, 0.32),
        (85_000,  0.24),
        (40_000,  0.22),
        (0,       0.10),
    ]
    for threshold, rate in brackets:
        if income > threshold:
            return rate
    return 0.0

Snippet 3 — Boolean flags passed in the wrong order¶

Difficulty: Hard · Language: Go

An export function with a signature soup of booleans.

func ExportReport(
    data []Record,
    includeHeaders bool,
    compress bool,
    encrypt bool,
    overwrite bool,
) error {
    f, err := openTarget(overwrite)
    if err != nil {
        return err
    }
    defer f.Close()

    w := newWriter(f, encrypt, compress)
    if includeHeaders {
        w.WriteHeaders()
    }
    return w.WriteAll(data)
}

// Caller, written months later, exporting a customer PII report:
func exportNightly(records []Record) error {
    return ExportReport(records, true, true, false, true)
}

The nightly export of a PII report has a security bug at the call site. What is it?

ExportReport(records, true,            true,     false,   true)
//                    includeHeaders   compress  encrypt  overwrite

type ExportOptions struct {
    IncludeHeaders bool
    Compress       bool
    Encrypt        bool
    Overwrite      bool
}

func ExportReport(data []Record, opts ExportOptions) error {
    f, err := openTarget(opts.Overwrite)
    if err != nil {
        return err
    }
    defer f.Close()

    w := newWriter(f, opts.Encrypt, opts.Compress)
    if opts.IncludeHeaders {
        w.WriteHeaders()
    }
    return w.WriteAll(data)
}

// Caller — the mistake is now self-evident:
func exportNightly(records []Record) error {
    return ExportReport(records, ExportOptions{
        IncludeHeaders: true,
        Compress:       true,
        Encrypt:        false, // ← jumps out: a PII report unencrypted?
        Overwrite:      true,
    })
}

Snippet 4 — Operator precedence in a clever one-liner¶

Difficulty: Medium · Language: Python

A feature gate, compressed to one expression by someone proud of it.

def can_access_beta(user):
    return user.is_employee or user.opted_in and user.account_age_days > 30

The product spec: "Beta access is for opted-in users who have had an account for more than 30 days. Employees always get access regardless of age or opt-in." The one-liner gets one group of users wrong. Who, and why?

return user.is_employee or (user.opted_in and user.account_age_days > 30)

return user.is_employee or user.opted_in and user.account_age_days > 30 and user.is_active

return user.is_employee and user.is_active or user.opted_in and user.account_age_days > 30

def can_access_beta(user):
    is_employee = user.is_employee
    is_eligible_member = user.opted_in and user.account_age_days > 30
    return is_employee or is_eligible_member

Snippet 5 — Long parameter list with two same-typed args transposed¶

Difficulty: Hard · Language: Java

A money movement API with a long, same-typed signature.

public TransferResult transfer(
        String idempotencyKey,
        String fromAccountId,
        String toAccountId,
        BigDecimal amount,
        String currency,
        String memo) {
    ledger.debit(fromAccountId, amount, currency);
    ledger.credit(toAccountId, amount, currency);
    audit.record(idempotencyKey, fromAccountId, toAccountId, amount, currency, memo);
    return new TransferResult(idempotencyKey, "OK");
}

// Caller: a customer requests a payout to their external bank account.
public void processPayout(Payout payout) {
    transfer(
        payout.getRequestId(),
        payout.getCustomerWalletId(),
        payout.getDestinationBankId(),
        payout.getAmount(),
        payout.getCurrency(),
        payout.getReference()
    );
}

// Caller: a refund — money goes from the merchant's wallet back to the customer.
public void processRefund(Refund refund) {
    transfer(
        refund.getRequestId(),
        refund.getCustomerWalletId(),
        refund.getMerchantWalletId(),
        refund.getAmount(),
        refund.getCurrency(),
        refund.getReference()
    );
}

One of the two callers moves money in the wrong direction. Which one, and how much would you bet on your answer?

transfer(requestId, customerWalletId, merchantWalletId, ...)
//                  ^^^ FROM           ^^^ TO

public final class AccountId {
    private final String value;
    public AccountId(String value) { this.value = Objects.requireNonNull(value); }
}

public record TransferRequest(
        IdempotencyKey key,
        AccountId from,
        AccountId to,
        Money amount,
        String memo) {}

public TransferResult transfer(TransferRequest req) {
    ledger.debit(req.from(), req.amount());
    ledger.credit(req.to(), req.amount());
    audit.record(req);
    return new TransferResult(req.key(), "OK");
}

// Refund caller — direction is named at the site:
public void processRefund(Refund refund) {
    transfer(new TransferRequest(
        refund.requestKey(),
        /* from */ refund.merchantWallet(),
        /* to   */ refund.customerWallet(),
        refund.amount(),
        refund.reference()
    ));
}

Snippet 6 — Hidden side effect in a getter fires twice¶

Difficulty: Hard · Language: Java

A token vendor where the "getter" does more than it says.

public class SessionToken {
    private String token;
    private int useCount;

    public String getToken() {
        useCount++;
        if (useCount > MAX_USES) {
            token = refreshToken();   // rotate when exhausted
            useCount = 1;
        }
        return token;
    }

    public int getUseCount() {
        return useCount;
    }
}

// Logging interceptor, added by the observability team:
public Response handle(Request req, SessionToken session) {
    log.info("Dispatching with token={} (use {})",
             session.getToken(), session.getUseCount());
    return downstream.call(req, session.getToken());
}

The token rotates a use earlier than MAX_USES would suggest, and the log line is inconsistent with the request actually sent. Why?

public class SessionToken {
    private String token;
    private int useCount;

    /** Consumes one use; rotates the token when exhausted. NOT idempotent. */
    public String acquire() {
        useCount++;
        if (useCount > MAX_USES) {
            token = refreshToken();
            useCount = 1;
        }
        return token;
    }

    public int currentUseCount() { return useCount; } // genuinely pure
}

public Response handle(Request req, SessionToken session) {
    String active = session.acquire();               // consumed exactly once
    log.info("Dispatching with token={} (use {})", active, session.currentUseCount());
    return downstream.call(req, active);
}

Snippet 7 — Inverted sub-clause (De Morgan mistake)¶

Difficulty: Hard · Language: Go

A guard that decides whether an order is eligible for same-day shipping.

func eligibleForSameDay(o Order, w Warehouse, now time.Time) bool {
    if !(o.InStock && !o.Hazardous) ||
        !(now.Hour() < w.CutoffHour && w.IsOpen) {
        return false
    }
    return true
}

The rules: an order ships same-day only if it is in stock, not hazardous, placed before the cutoff hour, and the warehouse is open. One of those four rules is enforced backwards. Which one?

!(InStock && !Hazardous)  OR  !(Hour < Cutoff && IsOpen)

(!InStock || Hazardous)  OR  (Hour >= Cutoff || !IsOpen)

InStock && !Hazardous && Hour < Cutoff && IsOpen

if !(o.InStock && !o.Hazardous) ||
    !(now.Hour() < w.CutoffHour && w.IsOpen) ||
    !w.Services(o.Destination) {
    return false
}

func eligibleForSameDay(o Order, w Warehouse, now time.Time) bool {
    inStock      := o.InStock
    safe         := !o.Hazardous
    beforeCutoff := now.Hour() < w.CutoffHour
    warehouseUp  := w.IsOpen

    return inStock && safe && beforeCutoff && warehouseUp
}

Snippet 8 — Off-by-one buried in nested loops¶

Difficulty: Medium · Language: Python

A function that detects whether any value repeats within a sliding window of size k.

def has_duplicate_in_window(nums, k):
    n = len(nums)
    for i in range(n):
        for j in range(i + 1, i + k):
            if j < n and nums[i] == nums[j]:
                return True
    return False

For nums = [1, 2, 3, 1] and k = 3, the two 1s are exactly 3 indices apart — at the very edge of the window. Does the function report them correctly?

def has_duplicate_in_window(nums, k):
    seen = {}
    for index, value in enumerate(nums):
        if value in seen and index - seen[value] <= k:
            return True
        seen[value] = index
    return False

Snippet 9 — Short-circuit hides a skipped side effect¶

Difficulty: Hard · Language: Java

A registration flow that validates and provisions in one boolean chain.

public boolean register(SignupForm form) {
    if (isValidEmail(form.email)
            && reserveUsername(form.username)
            && createAccount(form)
            && sendWelcomeEmail(form.email)) {
        return true;
    }
    return false;
}

reserveUsername, createAccount, and sendWelcomeEmail each return boolean for success and each performs a real side effect (a DB row, an SMTP call). There is a resource-leak bug. Where?

public RegistrationResult register(SignupForm form) {
    if (!isValidEmail(form.email)) {
        return RegistrationResult.invalidEmail();
    }

    UsernameReservation reservation = reserveUsername(form.username);
    if (reservation == null) {
        return RegistrationResult.usernameTaken();
    }

    Account account;
    try {
        account = createAccount(form);
    } catch (Exception e) {
        reservation.release();                 // ← unwind: no leak
        return RegistrationResult.failed("account creation", e);
    }

    sendWelcomeEmail(form.email);              // best-effort; not part of the transaction
    return RegistrationResult.success(account);
}

Snippet 10 — Mixed abstraction levels hide an unchecked return¶

Difficulty: Medium · Language: Go

A high-level "publish" routine with byte-twiddling spliced into it.

func PublishArticle(a *Article, store Store, bus EventBus) error {
    a.Slug = strings.ToLower(strings.ReplaceAll(a.Title, " ", "-"))
    checksum := uint32(0)
    for _, b := range []byte(a.Body) {
        checksum = (checksum << 5) | (checksum >> 27)
        checksum += uint32(b)
    }
    a.Checksum = checksum

    store.Save(a)

    payload, _ := json.Marshal(ArticleEvent{ID: a.ID, Slug: a.Slug})
    bus.Publish("article.published", payload)
    return nil
}

A published article sometimes fails to actually persist, yet downstream consumers still receive the event. What is the bug, and why is it so easy to miss?

func PublishArticle(a *Article, store Store, bus EventBus) error {
    a.Slug = slugify(a.Title)
    a.Checksum = bodyChecksum(a.Body)

    if err := store.Save(a); err != nil {
        return fmt.Errorf("save article %s: %w", a.ID, err)
    }

    payload, err := json.Marshal(ArticleEvent{ID: a.ID, Slug: a.Slug})
    if err != nil {
        return fmt.Errorf("marshal event: %w", err)
    }
    if err := bus.Publish("article.published", payload); err != nil {
        return fmt.Errorf("publish event: %w", err)
    }
    return nil
}

func slugify(title string) string {
    return strings.ToLower(strings.ReplaceAll(title, " ", "-"))
}

func bodyChecksum(body string) uint32 {
    var sum uint32
    for _, b := range []byte(body) {
        sum = (sum << 5) | (sum >> 27)
        sum += uint32(b)
    }
    return sum
}

Snippet 11 — Acronym-soup names hide a swapped assignment¶

Difficulty: Easy · Language: Python

A pricing adjustment using domain shorthand.

def adjust(p, mrp, msrp, cogs, gm_pct):
    np = mrp - (mrp * gm_pct)
    sp = msrp if np < cogs else np
    mrp = sp
    msrp = np
    return mrp, msrp

mrp = manufacturer's retail price, msrp = manufacturer's suggested retail price, cogs = cost of goods sold, gm_pct = target gross-margin fraction, np = new price, sp = safe price. The function is supposed to return (new_retail_price, suggested_price). It returns them swapped — but the swap is invisible. Find it.

def adjust_pricing(suggested_retail_price, cost_of_goods, gross_margin_fraction):
    margin_based_price = suggested_retail_price * (1 - gross_margin_fraction)
    price_above_cost = (
        margin_based_price if margin_based_price >= cost_of_goods
        else cost_of_goods
    )
    new_retail_price = price_above_cost          # never sells below cost
    new_suggested_price = margin_based_price     # internal target, may be < cost
    return new_retail_price, new_suggested_price

Snippet 12 — Ternary chain with the wrong association¶

Difficulty: Hard · Language: Java

A shipping-fee resolver crammed into one nested ternary.

String tier(int weightKg, boolean express, boolean international) {
    return weightKg > 30 ? "FREIGHT"
         : express ? international ? "INTL_EXPRESS" : "DOM_EXPRESS"
         : international ? "INTL_STANDARD"
         : weightKg > 10 ? "DOM_HEAVY"
         : "DOM_STANDARD";
}

The spec for a heavy domestic non-express parcel (say weightKg = 20, express = false, international = false) is "DOM_HEAVY". Does this return it? And is there an input that returns the wrong tier?

String tier(int weightKg, boolean express, boolean international) {
    if (weightKg > 30) {
        return "FREIGHT";
    }
    if (express) {
        return international ? "INTL_EXPRESS" : "DOM_EXPRESS";
    }
    boolean heavy = weightKg > 10;
    if (international) {
        return heavy ? "INTL_HEAVY" : "INTL_STANDARD";   // ← the missing cell, now visible
    }
    return heavy ? "DOM_HEAVY" : "DOM_STANDARD";
}

Scorecard¶

Track which bug classes you caught before opening the answer. The categories that consistently slip past you are the ones whose cognitive-load signature you have not yet internalized.

Reading your score:

• 0–4 caught: Normal for a first pass — these are engineered to hide. Re-read each missed snippet and name the specific load that hid it (nesting depth? same-typed args? a misleading name?).
• 5–8 caught: You are pattern-matching the signatures of load. Now practice the reflex: when you see one (a bare boolean call, a five-deep nest), mentally de-load before trusting the code.
• 9–12 caught: Strong. The remaining skill is doing this at PR speed across hundreds of lines — and, more importantly, writing code that never needs this scan because the load was never introduced.

The deeper lesson runs one direction only: you cannot reliably out-read high cognitive load. Every "fix" in this file is structural — a guard clause, a named boolean, a parameter object, an extracted function, a distinct type. Each removes the place the bug was hiding rather than asking the reader to look harder. That is the entire thesis of the chapter: keep the load low and most of these bug classes simply have nowhere to live.

Related Topics¶

• README.md — the positive rules: what keeps cognitive load low in the first place.
• junior.md — the beginner-level introduction to cognitive load.
• tasks.md — practice exercises: take loaded code and de-load it until latent bugs surface.
• ../README.md — the Clean Code chapter index.
• ../../refactoring/README.md — Guard Clauses, Extract Function, Introduce Parameter Object, and Replace Nested Conditional with Guard Clauses are the concrete moves used in every answer above.
• ../../anti-patterns/README.md — the boolean trap, long parameter list, and arrow-code anti-patterns catalogued as standalone smells.