Clean Code — Chapitre 14 : Le Raffinement Successif
Le chapitre 14 est un cas d'étude unique. Martin y montre comment il a écrit puis refactoré un programme complet en plusieurs itérations. C'est le chapitre de l'honnêteté : personne n'écrit du code propre du premier coup. Le code propre émerge d'un processus de raffinement successif.
💡 L'idée clé du chapitre :
"Le code propre n'est pas écrit d'un seul jet. Il faut d'abord faire fonctionner le système (sale si nécessaire), puis le nettoyer systématiquement jusqu'à ce qu'il soit lisible."
- Draft first — Écrivez pour faire fonctionner, pas pour être élégant
- Refactor relentlessly — Nettoyez sans concession quand les tests passent
- Iterate continuously — Le raffinement est un processus
- Keep tests green — Chaque refactoring garde les tests au vert
1. La philosophie du raffinement
Martin compare l'écriture de code à l'écriture d'un livre : le premier jet est toujours sale. Les auteurs n'écrivent pas une prose parfaite du premier coup — ils écrivent vite, puis réécrivent méthodiquement.
Citation de Martin :
"Writing clean code is a lot like painting a picture. Most of us know when a picture is painted well or badly. But being able to recognize good art from bad does not mean that we know how to paint. So too being able to recognize clean code from dirty code does not mean that we know how to write clean code!"
2. Les 3 étapes du raffinement
Le processus de raffinement se déroule en 3 étapes claires :
Make it work
Écrivez le code rapidement pour faire fonctionner le système. Autorisez-vous à être sale, verbeux, inefficace. L'objectif : tests verts.
⏱️ Temps : 30-40% du total
Make it right
Maintenant que ça marche, nettoyez méthodiquement. Renommez, extrayez, réorganisez. Gardez les tests verts à chaque étape.
⏱️ Temps : 50-60% du total
Make it fast
Seulement si nécessaire, optimisez les performances. Ne jamais optimiser avant que le code soit propre.
⏱️ Temps : 10% (si besoin)
3. Techniques de refactoring
Martin applique systématiquement ces techniques pour nettoyer le code :
📝 Extract Function
Dès qu'un bloc de code fait plus d'une chose, l'extraire dans une fonction avec un nom explicite.
🏷️ Rename
Renommer variables, fonctions, classes pour révéler l'intention. Si besoin d'un commentaire, c'est que le nom est mauvais.
🔨 Extract Variable
Remplacer les expressions complexes par des variables bien nommées qui expliquent l'intention.
🗑️ Remove Dead Code
Supprimer impitoyablement le code inutilisé. Si nécessaire un jour, Git se souvient.
🔀 Simplify Conditionals
Inverser les conditions, extraire en fonctions, utiliser early returns pour réduire la complexité.
🎯 Reduce Scope
Déplacer les variables au plus près de leur utilisation. Scope minimal = moins de bugs.
4. Cas d'étude : Composant React
Voyons le processus de raffinement sur un vrai composant React, de la version "sale qui marche" à la version "propre et testable".
Version 1 : Make it work (sale mais fonctionnel)
❌ Version initiale (sale)
function UserDashboard() {
const [users, setUsers] =
useState([]);
const [loading, setLoading] =
useState(false);
const [error, setError] =
useState(null);
const [filter, setFilter] =
useState("");
useEffect(() => {
setLoading(true);
fetch("/api/users")
.then(r => r.json())
.then(data => {
setUsers(data);
setLoading(false);
})
.catch(e => {
setError(e.message);
setLoading(false);
});
}, []);
const filtered = users.filter(
u => u.name
.toLowerCase()
.includes(
filter.toLowerCase()
)
);
if (loading)
return <div>Loading...</div>;
if (error)
return <div>Error: {error}</div>;
return (
<div>
<input
value={filter}
onChange={e =>
setFilter(e.target.value)
}
/>
{filtered.map(u => (
<div key={u.id}>
{u.name} - {u.email}
</div>
))}
</div>
);
}
// ⚠️ Fonctionne mais :
// - Tout dans 1 composant
// - Logique métier mélangée
// - Difficile à tester
✅ Version raffinée (propre)
// Hook custom : logique isolée
function useUsers() {
const [data, setData] =
useState([]);
const [loading, setLoading] =
useState(true);
const [error, setError] =
useState(null);
useEffect(() => {
fetchUsers()
.then(setData)
.catch(setError)
.finally(() =>
setLoading(false)
);
}, []);
return { data, loading, error };
}
// Logique métier pure
function filterUsers(
users: User[],
query: string
) {
const term = query
.toLowerCase()
.trim();
return users.filter(u =>
u.name
.toLowerCase()
.includes(term)
);
}
// Composant : présentation pure
function UserDashboard() {
const { data, loading, error } =
useUsers();
const [filter, setFilter] =
useState("");
if (loading)
return <LoadingSpinner />;
if (error)
return <ErrorMessage {...error} />;
const filtered =
filterUsers(data, filter);
return (
<div>
<SearchInput
value={filter}
onChange={setFilter}
/>
<UserList users={filtered} />
</div>
);
}
// ✅ Propre :
// - Séparation des responsabilités
// - Testable unitairement
// - Réutilisable
Étapes de raffinement détaillées
🔄 Process de raffinement étape par étape
Étape 1 : Extraire le hook useUsers
Déplacer toute la logique de fetching dans un hook custom. Tests passent toujours ✅
Étape 2 : Extraire filterUsers
Logique de filtrage dans une fonction pure testable. Tests passent toujours ✅
Étape 3 : Extraire les sous-composants
SearchInput, UserList, LoadingSpinner, ErrorMessage. Tests passent toujours ✅
Étape 4 : Renommer pour clarifier
Variables claires (data → users, u → user). Tests passent toujours ✅
Étape 5 : Ajouter TypeScript types
Types explicites partout. Tests passent toujours ✅
✅ Résultat du raffinement :
- Testabilité ×10 — filterUsers testable sans React, useUsers testable avec React Testing Library
- Réutilisabilité ×5 — useUsers réutilisable dans d'autres composants
- Lisibilité ×3 — Le composant principal fait 15 lignes au lieu de 50
- Maintenabilité — Changer le fetching ne touche que useUsers
Tests avant/après raffinement
// ❌ AVANT : Difficile à tester
test("filtre les utilisateurs", () => {
render(<UserDashboard />);
// Doit mocker fetch
// Doit attendre le loading
// Doit interagir avec l'input
// Test lent et fragile
});
// ✅ APRÈS : Facile à tester
describe("filterUsers", () => {
test("filtre par nom", () => {
const users = [
{ id: 1, name: "Alice" },
{ id: 2, name: "Bob" }
];
const result =
filterUsers(users, "ali");
expect(result).toHaveLength(1);
expect(result[0].name).toBe("Alice");
});
test("insensible à la casse", () => {
const users = [
{ id: 1, name: "Alice" }
];
expect(
filterUsers(users, "ALICE")
).toHaveLength(1);
});
});
// Test pur, rapide, fiable ✅
À Retenir — Chapitre 14
- Personne n'écrit du code propre du premier coup. Les meilleurs développeurs écrivent vite et sale d'abord, puis raffinent.
- Make it work, make it right, make it fast — Dans cet ordre. Ne jamais optimiser avant que le code soit propre.
- 55% du temps en refactoring — Le nettoyage prend plus de temps que l'écriture initiale. C'est normal.
- Tests verts à chaque étape — Refactorer sans tests est du cowboy coding. Chaque modification doit garder les tests verts.
- Extract, Extract, Extract — La technique la plus utilisée. Extraire fonctions, variables, composants dès qu'un bloc fait >1 chose.
- Renommer sans pitié — Si un nom ne révèle pas l'intention, le changer immédiatement. Les bons noms sont 50% du code propre.
- Small steps — Refactorer par petits pas. Une modification à la fois. Tests verts entre chaque.
- Delete dead code — Supprimer impitoyablement. Git se souvient si besoin un jour.
- Isoler la logique métier — En React : hooks custom + fonctions pures. Testable sans UI.
- Le code propre est un processus, pas un événement — Raffiner continuellement, ne jamais considérer le code comme "terminé".
🎯 Pratique : La prochaine fois que vous écrivez une feature, chronomètre-vous. Combien de temps en "make it work" vs "make it right" ? L'objectif : 35% / 55% / 10%.