DRY (Don't Repeat Yourself)

Le principe DRY (Don't Repeat Yourself) constitue l'un des piliers de la conception logicielle moderne. Formulé par Andy Hunt et Dave Thomas dans "The Pragmatic Programmer", il stipule que chaque élément de connaissance doit avoir une représentation unique, non ambiguë et faisant autorité au sein d'un système. Ce principe vise à réduire la redondance, améliorer la maintenabilité et minimiser les risques d'incohérences dans le code.

Fondements du principe DRY

• Éviter la duplication de logique métier en extrayant les fonctionnalités communes dans des fonctions, classes ou modules réutilisables
• Centraliser les configurations, constantes et règles métier pour faciliter leur évolution et maintenance
• Utiliser l'abstraction pour représenter des concepts une seule fois tout en permettant des variations d'implémentation
• Distinguer la duplication accidentelle (à éliminer) de la duplication intentionnelle (domaines métier distincts)

Avantages de l'approche DRY

• Maintenabilité accrue : les modifications se font à un seul endroit, réduisant les risques d'oubli et d'incohérences
• Réduction des bugs : moins de code dupliqué signifie moins d'endroits où les erreurs peuvent se propager
• Productivité améliorée : les développeurs passent moins de temps à synchroniser les changements entre plusieurs copies
• Cohérence renforcée : une source unique de vérité garantit un comportement uniforme dans toute l'application
• Testabilité optimale : le code réutilisable peut être testé une fois et réutilisé en toute confiance

Exemple concret d'application DRY

// ❌ Violation du principe DRY
class UserService {
  createUser(data: UserData) {
    if (!data.email.includes('@')) throw new Error('Email invalide');
    if (data.password.length < 8) throw new Error('Mot de passe trop court');
    // logique de création
  }

  updateUser(id: string, data: UserData) {
    if (!data.email.includes('@')) throw new Error('Email invalide');
    if (data.password.length < 8) throw new Error('Mot de passe trop court');
    // logique de mise à jour
  }
}

// ✅ Application du principe DRY
class UserValidator {
  static validateEmail(email: string): void {
    if (!email.includes('@')) {
      throw new Error('Email invalide');
    }
  }

  static validatePassword(password: string): void {
    if (password.length < 8) {
      throw new Error('Mot de passe trop court');
    }
  }

  static validate(data: UserData): void {
    this.validateEmail(data.email);
    this.validatePassword(data.password);
  }
}

class UserService {
  createUser(data: UserData) {
    UserValidator.validate(data);
    // logique de création
  }

  updateUser(id: string, data: UserData) {
    UserValidator.validate(data);
    // logique de mise à jour
  }
}

Mise en œuvre du principe DRY

1. Identifier les duplications : utiliser des outils d'analyse statique pour détecter le code dupliqué (ex: jscpd, SonarQube)
2. Analyser le contexte : déterminer si la duplication est accidentelle ou représente des concepts métier distincts
3. Extraire les abstractions : créer des fonctions, classes ou modules pour encapsuler la logique commune
4. Paramétrer les variations : utiliser des paramètres, configuration ou stratégies pour gérer les différences
5. Documenter les intentions : clarifier pourquoi certaines abstractions ont été créées pour guider les futurs développeurs
6. Réviser régulièrement : auditer le code lors des revues pour prévenir la réintroduction de duplications

Outils et techniques associés

• Outils de détection : jscpd, PMD Copy/Paste Detector, SonarQube pour identifier les duplications
• Patterns de conception : Factory, Strategy, Template Method pour éviter la duplication structurelle
• Composition over inheritance : privilégier la composition pour réutiliser du code sans hiérarchies complexes
• Hooks personnalisés (React) : extraire la logique stateful réutilisable dans des hooks custom
• Mixins et traits : partager des comportements entre classes sans duplication
• Fonctions d'ordre supérieur : encapsuler des patterns récurrents dans des abstractions fonctionnelles

Le principe DRY reste un guide essentiel pour produire du code maintenable et évolutif. En éliminant la redondance, les équipes réduisent leur dette technique, accélèrent les cycles de développement et diminuent les coûts de maintenance à long terme. Toutefois, son application doit rester pragmatique : une abstraction bien pensée vaut mieux qu'une généralisation forcée qui complexifie inutilement l'architecture.