Principle: Prefer composition over configuration

Systems become hard to understand and maintain when behavior is controlled by extensive configuration objects with many flags and options.

Instead of one configurable thing, compose small focused things:

# Bad: one function with many config options
def process_data(data, validate=True, transform=True,
                 cache=True, log=True, retry=3,
                 timeout=30, format='json'):
    ...

# Good: compose focused functions
def process_data(data):
    data = validate(data)
    data = transform(data)
    return serialize(data, format='json')

# With middleware/decorator composition:
@retry(times=3)
@cache(ttl=300)
@log_calls
def process_data(data):
    return transform(validate(data))

Composition benefits:

• Each piece is independently testable
• Easy to add/remove behavior
• No combinatorial explosion of flag interactions
• Self-documenting through function names

Use configuration for values that genuinely change between environments (timeouts, URLs, feature flags). Use composition for behavior.

Configuration flags grow combinatorially and create implicit coupling. N boolean flags create 2^N possible behaviors, most of which are untested.

Designing APIs and systems that need flexible behavior