Chapitre 12 – L’Émergence

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.

Émergence vs Big Design Up Front ❌ Big Design Up Front 1. Conception (3 mois) 2. Développement (6 mois) 3. Tests (2 mois) ⚠️ Changements coûteux ⚠️ Sur-ingénierie ✅ Design Émergent Cycle 1 Cycle 2 Cycle 3 Chaque cycle : • Tests • Code • Refactor ✅ Flexible, adaptable

2. Les 4 règles du Simple Design

Ces règles, dans cet ordre de priorité, garantissent un code propre et évolutif :

1

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

2

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

3

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

4

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)

Ordre de priorité des 4 règles 1. Tests passent 2. Pas de duplication 3. Exprimer intention 4. Minimiser Base solide Maintenabilité Lisibilité Simplicité Priorité décroissante : 1 > 2 > 3 > 4

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

3 types de duplication à éliminer Duplication évidente Copy-paste de code Même logique répétée → Extraire fonction Duplication structurelle Même pattern Noms différents → Abstraire interface Duplication conceptuelle Même idée Implémentations variées → Unifier concept Exemple React ❌ useUsers(), useAdmins(), useProducts() ✅ useList<T>(endpoint: string)

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

Cycle d'émergence du design RED Test échoue GREEN Test passe REFACTOR Améliorer 4 RULES Appliquer DESIGN ÉMERGE Répéter jusqu'à obtenir un design propre

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