Chapitre 14 – Le Raffinement Successif

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.

Mythe vs Réalité de l'écriture de code ❌ Le Mythe Écrire le code parfait directement : 1. Penser ↓ 2. Coder (parfait) ↓ 3. Terminer ✅ ✅ La Réalité Écrire sale, puis raffiner : Draft Refactor Clean Iterate Cycle continu

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 :

1

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

2

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

3

Make it fast

Seulement si nécessaire, optimisez les performances. Ne jamais optimiser avant que le code soit propre.

⏱️ Temps : 10% (si besoin)

Répartition du temps de développement Make it work 35% Make it right (refactor) 55% Make it fast 10% Écriture rapide Le plus long : nettoyage méthodique Optionnel

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%.