Du brouillon au programme propre
Un premier jet qui fonctionne, c'est déjà une victoire. Mais on peut presque toujours le rendre plus court, plus clair et plus facile à modifier. Améliorer un programme sans changer ce qu'il fait est une vraie compétence. Suivons les étapes sur un exemple.
Le brouillon
Ce programme affiche le bilan de trois élèves. Il marche :
affiche 'Léa : 14'
si 14 >= 10 alors
affiche ' admise'
sinon
affiche ' refusée'
fin si
affiche 'Tom : 8'
si 8 >= 10 alors
affiche ' admis'
sinon
affiche ' refusé'
fin si
affiche 'Inès : 17'
si 17 >= 10 alors
affiche ' admise'
sinon
affiche ' refusée'
fin si
Mais le même bloc est copié trois fois. Pour trente élèves, il faudrait 150 lignes. Et si la note d'admission passe à 12, il faut corriger trente endroits sans en oublier un.
Étape 1 : sortir les données
Les prénoms et les notes sont des données : on les range dans des tableaux, à part du code.
prenoms est un tableau vaut ['Léa', 'Tom', 'Inès']
notes est un tableau vaut [14, 8, 17]
Étape 2 : remplacer la répétition par une boucle
Les trois blocs font la même chose avec des valeurs différentes. Une boucle suffit :
prenoms est un tableau vaut ['Léa', 'Tom', 'Inès']
notes est un tableau vaut [14, 8, 17]
pour i de 0 à longueur(prenoms) - 1
affiche prenoms[i] + ' : ' + notes[i]
si notes[i] >= 10 alors
affiche ' admis'
sinon
affiche ' refusé'
fin si
fin pour
De 18 lignes à 9. Surtout, ajouter un élève ne demande plus de toucher au code : il suffit d'allonger les deux tableaux.
Question : Quel est le principal défaut du copier-coller dans un programme ? — Une correction doit être refaite à chaque endroit copié. Chaque copie est un endroit de plus à corriger. Un seul oubli, et le programme devient incohérent.
Étape 3 : nommer une décision avec une fonction
« La note est-elle suffisante ? » est une vraie question du programme : elle mérite une fonction avec un nom.
fonction decision(note)
si note >= 10 alors
retourne 'admis'
fin si
retourne 'refusé'
fin fonction
prenoms est un tableau vaut ['Léa', 'Tom', 'Inès']
notes est un tableau vaut [14, 8, 17]
pour i de 0 à longueur(prenoms) - 1
affiche prenoms[i] + ' : ' + notes[i] + ' -> ' + decision(notes[i])
fin pour
La boucle se lit maintenant d'un trait, et la règle d'admission est rangée à un seul endroit.
Étape 4 : nommer les nombres
Que représente ce 10 ? Une constante le dit, et permet de le changer en une ligne :
NOTE_ADMISSION est une constante vaut 10
fonction decision(note)
si note >= NOTE_ADMISSION alors
retourne 'admis'
fin si
retourne 'refusé'
fin fonction
prenoms est un tableau vaut ['Léa', 'Tom', 'Inès']
notes est un tableau vaut [14, 8, 17]
admis est un nombre vaut 0
pour i de 0 à longueur(prenoms) - 1
affiche prenoms[i] + ' : ' + notes[i] + ' -> ' + decision(notes[i])
si notes[i] >= NOTE_ADMISSION alors
admis ajoute 1
fin si
fin pour
affiche admis + ' admis sur ' + longueur(prenoms)
Au passage, on a pu ajouter un compteur d'admis en trois lignes. Dans le brouillon, il aurait fallu le recopier dans chaque bloc !
La méthode
Améliorer un programme se fait par petits pas, et jamais à l'aveugle :
- On part d'un programme qui marche.
- On fait une amélioration.
- On relance pour vérifier que le résultat n'a pas changé.
- On recommence.
Les signaux qui disent qu'un programme peut être amélioré :
- des lignes copiées-collées : une boucle ou une fonction ;
- des nombres sans explication : des constantes ;
- des noms comme
x ou tmp2 : des noms qui ont du sens ; - un très long bloc : plusieurs procédures.
Ce travail s'appelle le refactoring. Les programmeurs professionnels y passent une bonne partie de leur temps : un code propre aujourd'hui, c'est du temps gagné demain.
En résumé
- Un programme qui marche peut encore être amélioré, sans changer ce qu'il fait.
- Données dans des tableaux, répétitions dans des boucles, décisions dans des fonctions, nombres dans des constantes.
- Une amélioration à la fois, suivie d'un test.
- Moins de répétitions, c'est moins d'erreurs et des changements plus faciles.
