Complex is better than complicated
tl;dr
Complexity comes from hard problems like distributed consensus or fifty tax jurisdictions, and complication comes from what the solution adds, like unused abstraction layers or plugin systems. Accept complexity you can justify in one sentence and that breaks something when removed.
Key takeaway: Keep complexity only when you can name the requirement or failure it handles today, and remove the rest.
The distinction matters
These two words get used interchangeably, but they mean different things.
Complexity is inherent. Some problems are genuinely hard. A distributed consensus algorithm is complex. A tax calculation with fifty jurisdictions is complex. You can’t make these simpler without losing correctness.
Complication is incidental. It’s the complexity you add on top of the problem: the unnecessary layers, the premature abstractions, the clever indirection that serves no current purpose. Complication doesn’t come from the problem. It comes from the solution.
When complexity is warranted
Not all complexity is bad. A circuit breaker in a distributed system adds complexity, but it prevents cascading failures. Randomized jitter on retries adds a little complexity too, but it keeps a thundering herd from knocking a recovering server back over. A caching layer adds complexity, but it keeps your application responsive under load. These are deliberate trade-offs: you accept the cognitive cost because the benefit is real and immediate.
The key word is warranted. Warranted complexity solves a problem you actually have. You can point to the requirement, the failure mode, or the constraint that demands it. If you can’t articulate why the complexity exists, it’s probably complication in disguise.
Retry with jitter is a good example. Without the random delay, this would be a simple loop:
# retry.py
import random
import time
from collections.abc import Callable
def with_retry[T](call: Callable[[], T], attempts: int = 5) -> T:
attempt = 1
while True:
try:
return call()
except Exception:
if attempt == attempts:
raise
# Full jitter: without it, every client retries at the same instant
# and knocks the recovering server back over.
ceiling_seconds = 0.1 * 2**attempt
time.sleep(random.uniform(0, ceiling_seconds))
attempt += 1
The exponential backoff and the random delay make it harder to read. The comment justifies them in one sentence, and taking them out brings back a failure you can name.
How complication sneaks in
Complication rarely arrives as an obvious mistake. It accumulates through reasonable-sounding decisions:
- “Let’s add an abstraction layer so we can swap implementations later.” (You never swap.)
- “Let’s make this configurable so it works for every team.” (Only one team uses it.)
- “Let’s build a plugin system in case we need extensibility.” (You don’t.)
Each decision makes sense in isolation. Together, they bury the actual logic under layers that exist to serve hypothetical futures. This is the same instinct that drives over-engineering: building for problems you don’t have yet.
Here’s the plugin system from that list, built for extensibility nobody used:
# orders.py: a plugin system with one plugin
from collections.abc import Callable
OrderHook = Callable[[Order], None]
_after_save_hooks: list[OrderHook] = []
def register_after_save(hook: OrderHook) -> None:
_after_save_hooks.append(hook)
def place_order(order: Order) -> None:
save_order(order)
for hook in _after_save_hooks:
hook(order)
# receipts.py: the only plugin anyone ever registered
register_after_save(send_receipt)
To find out what happens after an order is saved, a reader has to search the codebase for every call to register_after_save. Remove the hooks and nothing breaks:
# orders.py
def place_order(order: Order) -> None:
save_order(order)
send_receipt(order)
Choosing complexity over complication
The discipline is knowing when to accept complexity and when to refuse complication. A few heuristics:
- Can you explain the complexity in one sentence? If the justification is clear and concrete, it’s probably warranted. If it takes a paragraph of hypotheticals, it’s probably complication.
- Does removing it break something today? Warranted complexity is load-bearing. Complication can be removed without consequence.
- Did you add it to solve a problem, or to prevent one? Solving real problems creates complexity. Preventing imaginary problems creates complication.
The goal isn’t to minimize complexity at all costs. It’s to ensure that every piece of complexity earns its place.
The Zen got it right
“Complex is better than complicated” is not a license to build complex systems. It’s a reminder that when a problem demands complexity, the answer is to embrace that complexity honestly, not to paper over it with layers of complication that make the system harder to understand.
Simple when you can. Complex when you must. Complicated never.