Meaningful Names — Find the Bug¶

12 snippets where the name lies. A misleading name is not a style nit — it is a defect waiting to happen. When total is really a count, when users is silently deduped to a set, when isEnabled means the opposite of what it says, the compiler stays quiet and the bug ships. Read each snippet critically, decide what is wrong, then open the answer.

Table of Contents¶

1. How to Use
2. The Lying-Name Failure Loop
3. Snippet 1 — isEnabled that means disabled (Go)
4. Snippet 2 — total that is really a count (Python)
5. Snippet 3 — getUser that mutates (Java)
6. Snippet 4 — users list that is silently a Set (Python)
7. Snippet 5 — last index vs count off-by-one (Go)
8. Snippet 6 — timeout in seconds, used as milliseconds (Java)
9. Snippet 7 — validate that also saves (Python)
10. Snippet 8 — temperature already in Fahrenheit (Go)
11. Snippet 9 — copy that aliases (Python)
12. Snippet 10 — min and max swapped at the call site (Java)
13. Snippet 11 — isValid negated by accident (Go)
14. Snippet 12 — amount in dollars vs cents (Python)
15. Scorecard
16. Related Topics

How to Use¶

Each snippet is a small, self-contained piece of code. Before expanding the answer:

1. Read the name first, the body second. Ask what each identifier promises. getX promises no side effects. total promises a sum, not a count. isEnabled promises true means on.
2. Read the body and check the promise. Does the code keep it? A name that disagrees with its body is the bug — or it will cause one the moment a second person trusts the name without reading the body.
3. Predict the concrete failure. Not "this is confusing" — name the defect: the wrong number charged, the off-by-one crash, the silent data loss, the mutated input.
4. Write the fix. Usually rename to tell the truth, or change the code to match the honest name. Sometimes a type makes the lie impossible.

Difficulty is marked per snippet: Warm-up / Standard / Sharp. Snippets rotate across Go, Python, and Java. Cover the answer block and commit to a diagnosis before reading it — passive reading teaches nothing.

The Lying-Name Failure Loop¶

A misleading name does not fail at the moment it is written. The author knows what the variable really holds. It fails later, when a second reader trusts the name and never checks the body.

The fix is always the same shape: make the name tell the truth, or change the code to match the honest name. A name is a contract. A lying contract is a liability.

Snippet 1 — isEnabled that means disabled (Go)¶

Difficulty: Warm-up

type FeatureFlag struct {
    Name      string
    isEnabled bool // set from config column "suppressed"
}

func loadFlag(row ConfigRow) FeatureFlag {
    return FeatureFlag{
        Name:      row.Name,
        isEnabled: row.Suppressed, // column is true when the feature is OFF
    }
}

func (f FeatureFlag) ShouldShow() bool {
    return f.isEnabled
}

What's wrong?

type FeatureFlag struct {
    Name       string
    suppressed bool
}

func loadFlag(row ConfigRow) FeatureFlag {
    return FeatureFlag{Name: row.Name, suppressed: row.Suppressed}
}

func (f FeatureFlag) ShouldShow() bool {
    return !f.suppressed
}

Snippet 2 — total that is really a count (Python)¶

Difficulty: Warm-up

def summarize_orders(orders):
    total = 0
    for order in orders:
        if order.status == "completed":
            total += 1
    return {
        "total": total,
        "average_order_value": revenue(orders) / total,
    }

What's wrong?

def summarize_orders(orders):
    completed_count = sum(1 for o in orders if o.status == "completed")
    return {
        "completed_count": completed_count,
        "average_order_value": revenue(orders) / completed_count if completed_count else 0,
    }

Snippet 3 — getUser that mutates (Java)¶

Difficulty: Standard

public class SessionManager {
    private final Map<String, User> cache = new HashMap<>();

    public User getUser(String sessionId) {
        User user = cache.get(sessionId);
        if (user == null) {
            user = database.loadUser(sessionId);
            cache.put(sessionId, user);
        }
        user.setLastAccessed(Instant.now()); // touch on every read
        return user;
    }
}

// Caller in an audit job:
for (String id : allSessionIds) {
    User u = sessionManager.getUser(id);
    auditReport.record(u.getName(), u.getLastAccessed());
}

What's wrong?

public User lookupUser(String sessionId) {        // pure-ish: cache fill only, no business mutation
    return cache.computeIfAbsent(sessionId, database::loadUser);
}

public void touchSession(String sessionId) {      // the side effect, named for what it does
    lookupUser(sessionId).setLastAccessed(Instant.now());
}

Snippet 4 — users list that is silently a Set (Python)¶

Difficulty: Standard

def notify_active_users(events):
    users = set()
    for event in events:
        users.add(event.user_id)

    sms_provider.send_batch(users)         # billed per recipient
    return {"users_notified": len(users)}

# events may contain the same user_id many times:
#   user 42 triggered 9 events today

What's wrong?

def notify_active_users(events):
    unique_user_ids = {event.user_id for event in events}   # dedup is now intentional and named
    sms_provider.send_batch(unique_user_ids)
    return {"unique_users_notified": len(unique_user_ids)}

Snippet 5 — last index vs count off-by-one (Go)¶

Difficulty: Sharp

func RingBufferAverage(samples []float64) float64 {
    last := len(samples) // intended: index of the last element
    sum := 0.0
    for i := 0; i <= last; i++ {
        sum += samples[i]
    }
    return sum / float64(last)
}

What's wrong?

func RingBufferAverage(samples []float64) float64 {
    count := len(samples)
    if count == 0 {
        return 0
    }
    sum := 0.0
    for i := 0; i < count; i++ {
        sum += samples[i]
    }
    return sum / float64(count)
}

Snippet 6 — timeout in seconds, used as milliseconds (Java)¶

Difficulty: Standard

public class HttpClientFactory {
    // default request timeout
    private static final int timeout = 30; // seconds

    public HttpClient build() {
        return HttpClient.newBuilder()
            .connectTimeout(Duration.ofMillis(timeout))
            .build();
    }
}

What's wrong?

private static final int connectTimeoutSeconds = 30;

public HttpClient build() {
    return HttpClient.newBuilder()
        .connectTimeout(Duration.ofSeconds(connectTimeoutSeconds))
        .build();
}

private static final Duration CONNECT_TIMEOUT = Duration.ofSeconds(30);
// ...
.connectTimeout(CONNECT_TIMEOUT)

Snippet 7 — validate that also saves (Python)¶

Difficulty: Sharp

def validate_registration(form):
    if not form.email:
        raise ValueError("email required")
    if not form.password or len(form.password) < 8:
        raise ValueError("weak password")

    user = User(email=form.email)
    user.set_password(form.password)
    db.session.add(user)
    db.session.commit()   # persists immediately
    return user

# Caller: a "check before showing step 2" handler
def on_continue_clicked(form):
    try:
        validate_registration(form)   # author thinks: just checking
        show_step_two(form)
    except ValueError as e:
        show_error(e)

What's wrong?

def validate_registration(form):
    """Pure check. Raises on invalid input. Writes nothing."""
    if not form.email:
        raise ValueError("email required")
    if not form.password or len(form.password) < 8:
        raise ValueError("weak password")

def register_user(form):
    """Validates, then persists. The name announces the write."""
    validate_registration(form)
    user = User(email=form.email)
    user.set_password(form.password)
    db.session.add(user)
    db.session.commit()
    return user

Snippet 8 — temperature already in Fahrenheit (Go)¶

Difficulty: Standard

func celsiusToFahrenheit(c float64) float64 {
    return c*9/5 + 32
}

func formatWeather(sensor Sensor) string {
    temperature := sensor.ReadFahrenheit() // sensor reports °F
    display := celsiusToFahrenheit(temperature)
    return fmt.Sprintf("%.0f°F", display)
}

What's wrong?

type Fahrenheit float64
type Celsius float64

func (c Celsius) ToFahrenheit() Fahrenheit {
    return Fahrenheit(c*9/5 + 32)
}

func formatWeather(sensor Sensor) string {
    tempF := Fahrenheit(sensor.ReadFahrenheit())
    return fmt.Sprintf("%.0f°F", float64(tempF))
}

Snippet 9 — copy that aliases (Python)¶

Difficulty: Sharp

def apply_discount(cart, percent):
    cart_copy = cart                 # "work on a copy, leave the original alone"
    for item in cart_copy["items"]:
        item["price"] *= (1 - percent / 100)
    return cart_copy

original = {"items": [{"name": "book", "price": 100.0}]}
discounted = apply_discount(original, 10)

print(original["items"][0]["price"])    # expected 100.0
print(discounted["items"][0]["price"])  # expected 90.0

What's wrong?

import copy

def apply_discount(cart, percent):
    discounted = copy.deepcopy(cart)   # real independent copy
    for item in discounted["items"]:
        item["price"] *= (1 - percent / 100)
    return discounted

Snippet 10 — min and max swapped at the call site (Java)¶

Difficulty: Standard

public List<Product> findInPriceRange(double min, double max) {
    return products.stream()
        .filter(p -> p.getPrice() >= min && p.getPrice() <= max)
        .collect(Collectors.toList());
}

// Caller — search form passes the upper bound first by mistake:
double ceiling = form.getMaxPrice();   // e.g. 500
double floor   = form.getMinPrice();   // e.g. 50
List<Product> results = findInPriceRange(ceiling, floor);

What's wrong?

public record PriceRange(double min, double max) {
    public PriceRange {
        if (min > max) {
            throw new IllegalArgumentException(
                "min (" + min + ") must not exceed max (" + max + ")");
        }
    }
}

public List<Product> findInPriceRange(PriceRange range) {
    return products.stream()
        .filter(p -> p.getPrice() >= range.min() && p.getPrice() <= range.max())
        .collect(Collectors.toList());
}

Snippet 11 — isValid negated by accident (Go)¶

Difficulty: Sharp

func isValidCoupon(code string, now time.Time) bool {
    coupon, err := repo.Find(code)
    if err != nil {
        return false
    }
    // expired or not yet active → still "valid" here?
    return now.Before(coupon.StartsAt) || now.After(coupon.ExpiresAt)
}

func applyCoupon(order *Order, code string) error {
    if !isValidCoupon(code, time.Now()) {
        return errors.New("coupon not valid")
    }
    order.Discount = lookupDiscount(code)
    return nil
}

What's wrong?

func isCouponActive(coupon Coupon, now time.Time) bool {
    return !now.Before(coupon.StartsAt) && !now.After(coupon.ExpiresAt)
}

func applyCoupon(order *Order, code string) error {
    coupon, err := repo.Find(code)
    if err != nil || !isCouponActive(coupon, time.Now()) {
        return errors.New("coupon not valid")
    }
    order.Discount = lookupDiscount(code)
    return nil
}

Snippet 12 — amount in dollars vs cents (Python)¶

Difficulty: Standard

def charge(payment_gateway, amount):
    # gateway.charge expects an integer number of cents
    return payment_gateway.charge(cents=amount)

# Caller, reading a price from the catalog:
price = product.price          # 19.99, a dollar amount as a float
receipt = charge(gateway, price)

What's wrong?

def charge(payment_gateway, amount_cents: int):
    if not isinstance(amount_cents, int):
        raise TypeError("amount_cents must be an integer number of cents")
    return payment_gateway.charge(cents=amount_cents)

def dollars_to_cents(dollars: float) -> int:
    return round(dollars * 100)

# Caller:
receipt = charge(gateway, dollars_to_cents(product.price))

Scorecard¶

Tally how many you diagnosed correctly before opening the answer. A correct diagnosis means naming both the misleading identifier and the concrete defect it produces — "this is confusing" does not count.

The skill being trained is distrust: never assume a name tells the truth until the body confirms it. Better still, write names so honest that the next reader can safely trust them — which is the entire point of the chapter.

Related Topics¶

• README — the positive rules this file inverts: names that reveal intent, avoid disinformation, and make meaningful distinctions.
• junior.md — the beginner-level definition of meaningful names, with the rules each snippet here violates.
• tasks.md — hands-on renaming exercises to drill the fixes shown above.
• naming-recipes.md — a reusable catalog of naming patterns (booleans, units, predicates, collections) that make these bugs impossible by default.
• Chapter README — Meaningful Names chapter overview and the full file set.
• Refactoring — Rename Variable / Rename Method are the mechanical refactorings that apply every fix here safely.
• Anti-Patterns — misleading names are a gateway anti-pattern; many larger smells start with one lying identifier.