DRY (Don't Repeat Yourself)

Le principe DRY (Don't Repeat Yourself) est un paradigme de conception logicielle qui stipule que chaque élément de connaissance doit avoir une représentation unique, non ambiguë et faisant autorité au sein d'un système. Formulé par Andy Hunt et Dave Thomas dans 'The Pragmatic Programmer', ce principe vise à réduire la redondance et améliorer la maintenabilité du code.

Fondements du principe DRY

Centralisation de la logique métier pour éviter les incohérences lors des modifications
Réduction de la dette technique en éliminant les duplications qui compliquent l'évolution du code
Amélioration de la testabilité grâce à des composants isolés et réutilisables
Facilitation de la maintenance en concentrant les changements en un point unique

Avantages du principe DRY

Réduction significative du temps de développement à long terme grâce à la réutilisation
Diminution des bugs en éliminant les copies divergentes de la même logique
Cohérence accrue du comportement applicatif sur l'ensemble du système
Facilité de refactoring avec des impacts localisés et prévisibles
Amélioration de la lisibilité en évitant le code verbeux et répétitif

Exemple concret d'application

Voici une transformation typique d'un code violant le principe DRY vers une solution optimisée :

user-validation.ts

// ❌ Violation du principe DRY
function validateUserEmail(email: string): boolean {
  const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  return regex.test(email);
}

function validateAdminEmail(email: string): boolean {
  const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  return regex.test(email);
}

function validateGuestEmail(email: string): boolean {
  const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  return regex.test(email);
}

// ✅ Application du principe DRY
class EmailValidator {
  private static readonly EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;

  static validate(email: string): boolean {
    return this.EMAIL_REGEX.test(email);
  }

  static validateWithDomain(email: string, allowedDomains: string[]): boolean {
    if (!this.validate(email)) return false;
    const domain = email.split('@')[1];
    return allowedDomains.includes(domain);
  }
}

// Utilisation centralisée
const isValidUser = EmailValidator.validate(userEmail);
const isValidAdmin = EmailValidator.validateWithDomain(adminEmail, ['company.com']);

Mise en œuvre stratégique

Identifier les patterns de duplication dans la codebase existante via analyse statique
Extraire la logique commune dans des fonctions, classes ou modules réutilisables
Créer des abstractions appropriées (helpers, services, utilitaires) selon le contexte
Documenter les composants centralisés pour encourager leur réutilisation
Établir des règles de linting pour détecter automatiquement les duplications
Équilibrer DRY avec la simplicité : éviter la sur-abstraction prématurée

Conseil professionnel

Appliquez la 'règle de trois' : attendez d'avoir trois occurrences d'un pattern avant de créer une abstraction. Cela évite la sur-ingénierie tout en capitalisant sur les véritables besoins de réutilisation. Privilégiez toujours la clarté à l'élimination absolue de toute redondance.

Outils et techniques associés

ESLint avec plugins de détection de duplication (no-duplicate-code, sonarjs)
SonarQube pour l'analyse continue des duplications de code
Frameworks de composition comme React Hooks ou Vue Composables
Systèmes de design tokens pour centraliser les valeurs visuelles
Générateurs de code (Yeoman, Plop) pour standardiser les patterns répétitifs

Le principe DRY représente un investissement stratégique dans la qualité logicielle. En réduisant la surface de maintenance et en améliorant la cohérence du code, il permet aux équipes de développement de gagner en vélocité sur le long terme tout en minimisant les risques d'incohérences. Son application judicieuse, sans tomber dans l'excès d'abstraction, constitue un marqueur de maturité technique des projets.