Principes DRY (Don't Repeat Yourself) et KISS (Keep It Simple, Stupid)

DRY (Don't Repeat Yourself) : évitez la duplication de code

Le principe DRY ("Don't Repeat Yourself", "Ne vous répétez pas") est un principe fondamental de la programmation qui encourage à éviter la duplication de code.

Chaque fois que vous vous retrouvez à écrire le même code (ou du code très similaire) à plusieurs endroits, c'est un signe que vous devriez probablement refactoriser votre code pour éliminer la répétition.

La duplication de code pose plusieurs problèmes :

• Elle rend le code plus long et plus difficile à lire.
• Elle rend la maintenance plus difficile : Si vous devez modifier le code dupliqué, vous devez le modifier à plusieurs endroits, ce qui augmente le risque d'oublis et d'erreurs.
• Elle augmente le risque de bugs : Si vous corrigez un bug dans une partie du code dupliqué, vous devez vous assurer que vous avez corrigé le bug partout ailleurs.

Pour éviter la duplication de code, vous pouvez utiliser plusieurs techniques, notamment :

• Fonctions : Regroupez le code répétitif dans une fonction, et appelez cette fonction à chaque fois que vous avez besoin d'exécuter ce code.
• Boucles : Utilisez des boucles pour répéter une opération plusieurs fois.
• Classes et héritage : Utilisez les classes et l'héritage pour partager du code commun entre plusieurs objets.
• Modules et packages : Organisez votre code en modules et packages réutilisables.
• Générateurs et itérateurs : Utilisez des générateurs et des itérateurs pour éviter de créer des listes intermédiaires en mémoire.
• Méta-programmation (avancé) : Utilisez des techniques de méta-programmation (comme les décorateurs) pour générer du code automatiquement.

Exemple : DRY avec une fonction

Voici un exemple simple de code qui viole le principe DRY :

# Calcul de l'aire d'un cercle de rayon 5
rayon1 = 5
aire1 = 3.14159 * rayon1 * rayon1
print(f"L'aire du cercle 1 est : {aire1}")

# Calcul de l'aire d'un cercle de rayon 8
rayon2 = 8
aire2 = 3.14159 * rayon2 * rayon2
print(f"L'aire du cercle 2 est : {aire2}")

#Calcul de l'aire d'un cercle de rayon 12
rayon3 = 12
aire3 = 3.14159 * rayon3 * rayon3
print(f"L'aire du cercle 3 est : {aire3}")

Le code pour calculer l'aire d'un cercle est répété trois fois. Pour respecter le principe DRY, on peut créer une fonction :

def aire_cercle(rayon):
    """Calcule l'aire d'un cercle."""
    return 3.14159 * rayon * rayon

# Utilisation de la fonction
print(f"L'aire du cercle 1 est : {aire_cercle(5)}")
print(f"L'aire du cercle 2 est : {aire_cercle(8)}")
print(f"L'aire du cercle 3 est : {aire_cercle(12)}")

Le code est maintenant plus court, plus lisible, et plus facile à maintenir. Si vous devez modifier la formule de calcul de l'aire, vous n'avez qu'à le faire à un seul endroit (dans la fonction).

KISS (Keep It Simple, Stupid) : privilégiez la simplicité

Le principe KISS ("Keep It Simple, Stupid", "Fais simple, idiot") est un principe de conception qui encourage à privilégier la *simplicité* dans la conception et l'implémentation d'un système (logiciel ou autre).

En programmation, cela signifie qu'il faut essayer d'écrire le code le plus simple possible pour résoudre un problème donné. Evitez les solutions complexes, alambiquées, ou "intelligentes" si une solution simple et directe fonctionne.

Un code simple est :

• Plus facile à comprendre : Il est plus facile à lire, à comprendre et à maintenir.
• Moins susceptible de contenir des bugs : Moins de code signifie moins de possibilités d'erreurs.
• Plus facile à déboguer : Si un problème survient, il est plus facile de l'identifier et de le corriger dans un code simple.
• Plus facile à tester : Il est plus facile d'écrire des tests pour un code simple.

La simplicité ne signifie pas que le code doit être simpliste ou naïf. Il signifie qu'il doit être *aussi simple que possible*, compte tenu du problème à résoudre. Il faut trouver le bon équilibre entre simplicité et fonctionnalité.

Exemple : KISS vs. code complexe

Voici un exemple (un peu artificiel) qui illustre le principe KISS :

Problème : Calculer la somme des nombres pairs d'une liste.

Solution complexe (non KISS) :

def somme_pairs_complexe(nombres):
    somme = 0
    i = 0
    while i < len(nombres):
        if nombres[i] % 2 == 0:
            if i % 2 == 0:
                somme += nombres[i]
            else:
                 somme += nombres[i]
        i += 1

    return somme

Solution simple (KISS) :

def somme_pairs_simple(nombres):
    somme = 0
    for nombre in nombres:
        if nombre % 2 == 0:
            somme += nombre
    return somme

Les deux fonctions font la même chose, mais la deuxième est beaucoup plus simple et plus facile à comprendre.

Une solution encore plus simple et plus "pythonique" serait :

def somme_pairs_pythonique(nombres):
    return sum(nombre for nombre in nombres if nombre % 2 == 0)

La simplicité doit être un objectif constant lors de l'écriture de code. N'ajoutez de la complexité que si c'est *strictement nécessaire*.

DRY et KISS : des principes complémentaires

Les principes DRY et KISS sont complémentaires. En évitant la duplication de code (DRY), vous rendez souvent votre code plus simple (KISS). Et en privilégiant la simplicité (KISS), vous réduisez souvent le besoin de dupliquer du code.

Ces deux principes, lorsqu'ils sont appliqués correctement, conduisent à un code de meilleure qualité, plus facile à comprendre, à maintenir et à étendre.