Clean Code — Chapitre 12 : L'Émergence
Le chapitre 12 est l'un des plus courts mais aussi l'un des plus puissants du livre. Martin y présente les 4 règles du Simple Design, un ensemble de principes qui, appliqués rigoureusement, font émerger une bonne architecture sans planification lourde. C'est la philosophie du design émergent : commencer simple, tester continuellement, refactorer sans cesse.
💡 L'idée clé du chapitre :
"Un bon design émerge de l'application systématique de 4 règles simples. Suivez-les dans l'ordre, et vous n'aurez jamais besoin de tout concevoir d'avance."
- Règle 1 : Tous les tests passent
- Règle 2 : Pas de duplication (DRY)
- Règle 3 : Exprimer l'intention clairement
- Règle 4 : Minimiser les entités
1. Qu'est-ce que l'émergence ?
L'émergence est un concept simple : au lieu de planifier toute l'architecture d'avance (Big Design Up Front), on applique 4 règles simples à chaque itération. Le bon design émerge naturellement de ces contraintes.
2. Les 4 règles du Simple Design
Ces règles, dans cet ordre de priorité, garantissent un code propre et évolutif :
Tous les tests passent
La première condition d'un bon design : il fonctionne. Sans tests qui passent, rien d'autre ne compte.
💡 Force à écrire du code testable → donc découplé et simple
Pas de duplication
Principe DRY (Don't Repeat Yourself). Chaque concept ne doit exister qu'une fois dans le code.
💡 La duplication = maintenance multipliée
Exprimer l'intention
Le code doit se lire comme de la prose. Noms clairs, fonctions courtes, structure évidente.
💡 Si besoin d'un commentaire, c'est que le nom est mauvais
Minimiser les entités
Le moins de classes/fonctions/fichiers possible tout en respectant les 3 premières règles.
💡 Simple > Complexe. YAGNI (You Aren't Gonna Need It)
3. Règle 1 : Tous les tests doivent passer
Sans tests, impossible de savoir si le système fonctionne. Cette règle force à écrire du code testable, ce qui implique automatiquement : fonctions pures, injection de dépendances, composants découplés.
❌ Sans tests
function calculateDiscount(
price: number,
vip: boolean
) {
if (vip) {
return price * 0.9;
}
return price;
}
// ⚠️ Aucune garantie
// ⚠️ Edge cases non vérifiés
✅ Avec tests
describe("calculateDiscount", () => {
test("10% VIP", () => {
expect(
calculateDiscount(100, true)
).toBe(90);
});
test("prix normal", () => {
expect(
calculateDiscount(100, false)
).toBe(100);
});
});
// ✅ Garantie de fonctionnement
4. Règle 2 : Éliminer la duplication
La duplication est l'ennemi n°1 d'un système propre. Chaque bout de code dupliqué = maintenance doublée. Le principe DRY (Don't Repeat Yourself) s'applique partout.
❌ Duplication évidente
function UserCard({ user }) {
return (
<div>
<h2>{user.name}</h2>
<p>{user.email}</p>
</div>
);
}
function AdminCard({ admin }) {
return (
<div>
<h2>{admin.name}</h2>
<p>{admin.email}</p>
</div>
);
}
// ❌ Même structure dupliquée
✅ DRY appliqué
function PersonCard({
person
}: {
person: Person
}) {
return (
<div>
<h2>{person.name}</h2>
<p>{person.email}</p>
</div>
);
}
// Usage
<PersonCard person={user} />
<PersonCard person={admin} />
// ✅ Un seul composant
Types de duplication
5. Règle 3 : Exprimer l'intention
Le code doit se lire comme de la prose. Les noms de variables, fonctions et classes doivent révéler l'intention sans commentaires.
❌ Noms cryptiques
// Intention cachée
function calc(a, b, f) {
if (f) {
return a * 0.9;
}
return a;
}
const r = calc(p, u, true);
// ⚠️ Que fait ce code ?
// ⚠️ f = ?
✅ Intention claire
// Intention évidente
function calculatePrice(
basePrice: number,
user: User,
isVipMember: boolean
): number {
if (isVipMember) {
return basePrice * 0.9;
}
return basePrice;
}
const finalPrice = calculatePrice(
productPrice,
currentUser,
true
);
6. Règle 4 : Minimiser les entités
Une fois les 3 premières règles respectées, simplifiez au maximum. Pas de sur-ingénierie, pas de "au cas où". Le principe YAGNI (You Aren't Gonna Need It).
Exemple d'évolution progressive
// ÉTAPE 1 - Simple (commence ici)
function UserList() {
const [users, setUsers] =
useState<User[]>([]);
useEffect(() => {
fetch("/api/users")
.then(r => r.json())
.then(setUsers);
}, []);
return (
<div>
{users.map(u =>
<div key={u.id}>{u.name}</div>
)}
</div>
);
}
// ✅ Fonctionne, testé
// ÉTAPE 2 - Éliminer duplication
function useUsers() {
const [users, setUsers] =
useState<User[]>([]);
useEffect(() => {
fetch("/api/users")
.then(r => r.json())
.then(setUsers);
}, []);
return users;
}
function UserList() {
const users = useUsers();
return (
<div>
{users.map(u =>
<div key={u.id}>{u.name}</div>
)}
</div>
);
}
// ✅ Réutilisable
// ÉTAPE 3 - Exprimer intention
function UserList() {
const users = useUsers();
if (!users.length) {
return <EmptyState />;
}
return (
<UserGrid>
{users.map(user =>
<UserCard
key={user.id}
user={user}
/>
)}
</UserGrid>
);
}
// ✅ Lisible comme de la prose
// ⚠️ Ne PAS créer d'abstraction
// tant que non nécessaire !
7. Émergence en action — Exemple complet
À Retenir
- Design émergent : Ne pas tout planifier d'avance. Laisser l'architecture émerger de l'application des 4 règles simples.
- Règle 1 (Tests) : La base de tout. Sans tests qui passent, rien d'autre ne compte. Force à écrire du code testable donc découplé.
- Règle 2 (DRY) : Éliminer toute duplication. Chaque concept ne doit exister qu'une fois dans le code.
- Règle 3 (Intention) : Le code se lit comme de la prose. Noms clairs, structure évidente, pas besoin de commentaires.
- Règle 4 (Minimalisme) : Le moins d'entités possible. YAGNI — You Aren't Gonna Need It. Pas de sur-ingénierie.
- Ordre de priorité : 1 > 2 > 3 > 4. Respecter cet ordre dans le refactoring.
- TDD cycle : RED (test échoue) → GREEN (test passe) → REFACTOR (appliquer les 4 règles) → Répéter.
- En React : Commencer simple (tout dans un composant), extraire progressivement (hooks, composants), ne pas abstraire trop tôt.
⏱️ Application pratique : À chaque commit, vérifier les 4 règles. À chaque code review, utiliser ces règles comme checklist. Le bon design émerge de la discipline, pas du génie.