On a tendance à penser que la complexité est le résultat de mauvais choix : une mauvaise architecture, un mauvais design, une mauvaise décision technique. Dans la réalité, ce n’est presque jamais le cas.
La plupart des systèmes ne deviennent pas complexes parce qu’ils sont mal conçus. Ils deviennent complexes parce qu’ils évoluent.
Le point de départ
Un projet démarre toujours de manière simple. Le code est lisible, les responsabilités sont claires, les fonctions font peu de choses, et tout le monde comprend facilement ce qui se passe.
Un exemple typique :
function getUserFullName(array $user): string {
return $user['first_name'] . ' ' . $user['last_name'];
}
Rien d’exceptionnel, mais rien de problématique non plus.
L’évolution naturelle
Puis le produit évolue. On ajoute une première règle :
function getUserFullName(array $user): string {
if ($user['is_company']) {
return $user['company_name'];
}
return $user['first_name'] . ' ' . $user['last_name'];
}
Puis une deuxième :
if ($user['country'] === 'JP') {
return $user['last_name'] . ' ' . $user['first_name'];
}
Puis une exception métier :
if ($user['vip']) {
return strtoupper($user['first_name'] . ' ' . $user['last_name']);
}
À chaque étape, le code reste raisonnable et chaque modification est justifiée.
Le point de bascule
Le problème n’apparaît pas immédiatement, il apparaît lorsque ces changements finissent par s’accumuler.
function getUserFullName(array $user): string {
if ($user['is_company']) {
return $user['company_name'];
}
if ($user['country'] === 'JP') {
return $user['last_name'] . ' ' . $user['first_name'];
}
if ($user['vip']) {
return strtoupper($user['first_name'] . ' ' . $user['last_name']);
}
if ($user['legacy_format']) {
return formatLegacyName($user);
}
return $user['first_name'] . ' ' . $user['last_name'];
}
Individuellement, rien n’est choquant mais collectivement, le code devient difficile à lire, à maintenir, et à faire évoluer.
Le vrai problème
Le problème n’est pas une mauvaise décision, c’est l’absence de simplification. Chaque feature ajoute de la complexité, et rien ne vient la réduire.
Une autre forme de complexité
Cette dérive ne se limite pas aux fonctions, elle apparaît aussi dans les structures.
Un exemple courant :
$service->handle($command);
Sur le papier, c’est propre mais dans la réalité, pour comprendre ce que fait cette ligne, il faut naviguer à travers :
- plusieurs classes
- plusieurs couches
- plusieurs transformations
On perd progressivement le lien direct entre le code et ce qu’il fait réellement.
Le coût réel
Cette complexité a un coût, mais il est rarement immédiat. Elle se manifeste progressivement :
- le temps de lecture augmente
- le debug devient plus difficile
- les effets de bord apparaissent
- la confiance dans le code diminue
Et surtout :
👉 chaque nouvelle feature devient plus lente à développer
Pourquoi cela arrive
Plusieurs facteurs expliquent cette accumulation. Le premier est simple : on ajoute plus qu’on ne retire. Le second est plus subtil : on évite de toucher à ce qui fonctionne. Modifier du code existant est perçu comme risqué. Ajouter une condition semble plus sûr.
Enfin, il y a le contexte produit. Les besoins évoluent, les exceptions apparaissent, les contraintes changent. Le code suit cette évolution, sans être réorganisé.
Ce que font les systèmes qui tiennent
Avec le temps, une différence apparaît entre les systèmes qui deviennent ingérables et ceux qui restent maintenables. Ce n’est pas une question de technologie, c’est une question de discipline.
Les systèmes qui tiennent sont ceux où la simplification est active.
Simplifier est un travail
Simplifier ne consiste pas à “nettoyer un peu”, c’est une action volontaire :
- supprimer du code
- regrouper des cas
- renommer
- restructurer
Par exemple, dans notre cas :
function getUserDisplayName(User $user): string {
if ($user->isCompany()) {
return $user->getCompanyName();
}
return $this->formatPersonName($user);
}
Puis :
private function formatPersonName(User $user): string {
if ($user->isJapanese()) {
return $user->getLastName() . ' ' . $user->getFirstName();
}
$name = $user->getFirstName() . ' ' . $user->getLastName();
return $user->isVip()
? strtoupper($name)
: $name;
}
Ce n’est pas “plus intelligent”, c’est simplement plus lisible.
Le point d’équilibre
Un système simple n’est pas un système figé. C’est un système qui évolue, mais qui reste compréhensible. La complexité n’est pas un problème en soi.
Elle devient un problème lorsqu’elle n’est plus maîtrisée.
Conclusion
Un système devient complexe non pas parce qu’il est mal conçu.
Mais parce qu’il n’est jamais activement simplifié.
TL;DR
- La complexité est une accumulation, pas une décision
- Chaque feature ajoute, rien ne retire
- Le code devient difficile à comprendre avant de devenir difficile à maintenir
- Simplifier est une action volontaire
- La maintenabilité est un effort continu