Hand-built counters and flag loops

Code longer than it needs to be: one of the ways AI coding agents bloat software, from lessloc's pattern catalog. lessloc catches it as simpler.

What makes hand-built counters and flag loops a bad practice?

The standard that calls it a bad practice: Fowler: Replace Loop with Pipeline.

What does lessloc do about hand-built counters and flag loops?

lessloc catches it as simpler.

• simpler (tier 2): Brute-force code with a shorter idiom: == True, an if/else that returns the condition, an index loop that only reads xs[i], .filter(...).length > 0, a catch that only rethrows, a flag loop that is any(), a hand-built counter, an __init__ that @dataclass writes, a React Effect that only sets state. ruff and clippy add more.

Examples

Caught as simpler:

def has_refund(orders):
    found = False
    for order in orders:
        if order.refunded:
            found = True
            break
    return found

Written well:

def has_refund(orders):
    return any(order.refunded for order in orders)

Caught as simpler:

def tally(words):
    counts = {}
    for w in words:
        if w in counts:
            counts[w] += 1
        else:
            counts[w] = 1
    return counts

Written well:

from collections import Counter


def tally(words):
    return Counter(words)

Related patterns

The other patterns in Code longer than it needs to be:

• Brute-force idioms: lessloc catches it as simpler, built in for Python, JS/TS, Go, Rust, Java and C#. ruff (in every hook) and clippy (in ci) go deeper.
• A catch that only rethrows: lessloc catches it as simpler.
• A promise wrapped in new Promise: lessloc catches it as simpler.
• Annotating types the compiler infers: lessloc catches it as simpler.
• A React Effect that only sets state from other values: lessloc catches it as simpler.
• Functions with many parameters (8 or more): lessloc catches it as long-params.
• Deep nesting: lessloc catches it as deep-nesting.
• Long functions: lessloc catches it as long-function.
• If-chains on literal values: lessloc catches it as if-chain.
• A file that keeps growing: lessloc catches it as swollen-file.
• Reformatting lines the task did not change: lessloc gives every session a rule against it and catches it as churn.
• Net growth past a budget: lessloc catches it as net-growth.
• Golfed code: lessloc catches it as clever and dense-lines.