# 🌀 Entropy Reduction — Combattre le chaos **Entropie** = mesure du désordre dans un système. En code : plus d'entropie = plus de chaos = impossible à maintenir. > **Ton job principal : réduire l'entropie.** --- ## 🎯 Le principe L'entropie augmente naturellement dans un système : - Nouveaux devs = nouveaux styles - Features urgentes = shortcuts - Code legacy = accumulation de dette **Entropy Reduction** = lutter activement contre cette tendance. > 💡 **L'invariant** : "Sans effort constant, le code tend vers le chaos" --- ## 🧠 Pourquoi c'est crucial ? Haute entropie : - bugs imprévisibles - refactoring impossible - vélocité qui s'effondre - devs qui fuient le projet Basse entropie : - **comportement prévisible** - **refactoring safe** - **onboarding rapide** - **vélocité constante** --- ## 📊 Évolution de l'entropie --- ## 🔍 Signaux d'entropie élevée ### 1. **Incohérence** ```ts // 3 façons différentes de gérer les erreurs function a() { throw new Error(); } function b() { return null; } function c() { return { error: true }; } ``` ### 2. **Duplication** ```ts // Même logique copiée 5 fois function validateUserA(user) { /* ... */ } function validateUserB(user) { /* ... */ } // Quasi identique function checkUser(user) { /* ... */ } // Pareil ``` ### 3. **Couplage implicite** ```ts // Module A dépend de l'ordre d'exécution de B // Sans que ce soit documenté A.init(); // Doit être avant B.start() B.start(); // Sinon crash silencieux ``` ### 4. **État global mutable** ```ts // État partagé partout, modifié n'importe où window.globalState = { /* ... */ }; // 50 fichiers modifient globalState // Impossible de tracer qui fait quoi ``` --- { /* ... */ } // Fichier 2 function fetchUser(userId) {/* ... */} // Fichier 3 class UserRetriever { get(identifier) {/* ... */} }`, description: "3 façons différentes de faire la même chose, aucun standard" }, problem: "Nouveau dev ne sait pas laquelle utiliser. Duplication de logique. Bugs divergents.", solution: "Convention : UN seul pattern pour une même opération", goodExample: { code: `// Standard projet : Repository pattern class UserRepository { async findById(id: string): Promise {/* ... */} } // Partout dans le projet, même pattern`, description: "Cohérence = entropie réduite" } }, { title: "Tolérer la duplication", badExample: { description: "Copier-coller du code 'juste pour cette feature urgente', ne jamais refactoriser" }, problem: "Bug dans l'original → 5 endroits à fixer (mais tu en oublies 2)", solution: "DRY religieux : extraire immédiatement en fonction/classe commune", goodExample: { code: `// Au lieu de copier function validateEmail(email: string) {/* ... */} // Utiliser partout import { validateEmail } from '@/utils/validation';`, description: "Une seule source de vérité" } }, { title: "État global non contrôlé", badExample: { code: `// État partagé mutable accessible partout export const appState = { user: null, settings: {}, cache: new Map() }; // 100 fichiers font appState.cache.set(...)`, description: "Chaos total : impossible de tracer les mutations" }, problem: "Bugs de concurrence, état inconsistant, debugging cauchemar", solution: "Centraliser les mutations : Redux, Zustand, ou au minimum des setters", goodExample: { code: `// Store avec API contrôlée class AppStore { private state = {/* ... */}; getUser() { return this.state.user; } setUser(user: User) { console.log('User updated:', user); this.state.user = user; } }`, description: "Toutes les mutations passent par l'API = traçable" } } ]} /> --- ## 🧪 Techniques de réduction d'entropie ### 1. **Conventions strictes** ```ts // ✅ Convention : tous les services suivent la même structure interface Service { init(): Promise; shutdown(): Promise; } class EmailService implements Service { async init() { /* ... */ } async shutdown() { /* ... */ } } class PaymentService implements Service { async init() { /* ... */ } async shutdown() { /* ... */ } } ``` **Résultat** : Prévisibilité maximale --- ### 2. **Elimination de la duplication** ```ts // ❌ Avant : duplication function formatUserName(user) { return `${user.firstName} ${user.lastName}`; } function getFullName(person) { return `${person.firstName} ${person.lastName}`; } // ✅ Après : DRY function formatFullName(entity: { firstName: string; lastName: string }) { return `${entity.firstName} ${entity.lastName}`; } ``` --- ### 3. **Immutabilité par défaut** ```ts // ❌ Mutable = entropie haute const config = { timeout: 3000 }; someFunction(config); // config.timeout modifié sans qu'on le sache // ✅ Immutable = entropie basse const config = Object.freeze({ timeout: 3000 }); // Toute modification lève une erreur ``` --- ### 4. **Types stricts** ```ts // ❌ any = entropie haute function process(data: any) { // data.foo? data.bar? Qui sait? } // ✅ Types stricts = entropie basse interface ProcessData { id: string; value: number; } function process(data: ProcessData) { // data.id et data.value sont garantis } ``` --- ## 📏 Métriques d'entropie ### Mesurer l'entropie de ton code : | Métrique | Faible entropie | Haute entropie | | ------------------------- | ----------------- | -------------- | | **Cyclomatic Complexity** | < 10 par fonction | > 20 | | **Code Duplication** | < 3% | > 15% | | **Naming Consistency** | 1 convention | 5+ patterns | | **Test Coverage** | > 80% | < 40% | | **Linter Warnings** | 0 | 500+ | --- humains pour la cohérence", }, { key: "Review", value: "2 reviewers minimum, checklist : tests, naming, duplication", explanation: "Filtre avant merge = entropie bloquée", }, { key: "Refactoring", value: "1 jour/sprint dédié au nettoyage (remboursement dette)", explanation: "Réduction active, pas seulement prévention", }, ], explanation: "Entropie ∝ nombre de devs. Discipline > taille d'équipe.", }, ]} /> --- --- ## 🗺️ Carte mentale de synthèse --- ## 🚀 Résultat attendu En maîtrisant Entropy Reduction, tu deviens capable de : - **Détecter** les signaux de chaos avant qu'il ne soit trop tard - **Maintenir** la cohérence malgré la croissance du projet - **Refactoriser** en toute sécurité - **Onboarder** rapidement de nouveaux devs Et surtout : Tu construis des systèmes qui **vieillissent bien** au lieu de pourrir. Réduire l'entropie, c'est jardiner ton code.