Le génie logiciel et le cycle de vie
Partie 3 sur 5
6Concevoir : de l’architecture au détail
La conception générale (ou architecture) décide de la structure d’ensemble : quels modules, quelles responsabilités, quelles communications, quelles technologies. La conception détaillée précise l’intérieur de chaque module. Les deux cherchent à rendre le logiciel facile à comprendre et à modifier. Deux notions guident ce travail :
- la cohésion : à l’intérieur d’un module, tout concourt au même but (un module « calcul des prix » ne s’occupe pas aussi d’envoyer des courriels) ;
- le couplage : entre modules, les dépendances sont minimales et clairement définies, de sorte qu’un changement dans l’un n’oblige pas à réécrire les autres.
Les concepteurs s’appuient sur des solutions éprouvées à des problèmes récurrents, les patrons de conception (voir les patrons de conception), sur des notations graphiques comme UML (un langage de dessin normalisé pour représenter les classes, les échanges, les états d’un logiciel), et sur des styles d’architecture : application d’un seul bloc, services séparés qui communiquent par le réseau (voir les microservices), interfaces de programmation normalisées entre morceaux (voir les API). Chaque choix a un coût : découper en nombreux services réduit certains risques et en crée d’autres (réseau, cohérence des données, exploitation).
Un bon réflexe est de noter les décisions d’architecture importantes dans de courtes fiches datées (« nous avons choisi telle base de données pour telle raison, en sachant que… »). Dans cinq ans, quand l’équipe aura changé, ces fiches expliqueront pourquoi le logiciel est ainsi fait.
7Coder, relire, versionner
Le codage traduit la conception en programme. Au-delà du langage, le génie logiciel recommande quelques pratiques qui font la différence entre un code qui marche aujourd’hui et un code qui marchera encore dans dix ans.
- Des conventions d’écriture partagées (noms, mise en page), vérifiées automatiquement par des outils.
- La gestion des versions : tout le code, et son historique, vit dans un dépôt géré par un outil comme Git (voir Git), qui permet de retrouver qui a changé quoi, quand et pourquoi, de travailler à plusieurs et de revenir en arrière.
- La revue de code : un second regard lit chaque modification avant son intégration. Elle repère des défauts, mais aussi diffuse la connaissance dans l’équipe.
- Le traitement des erreurs : un programme ne doit pas supposer que tout ira bien (voir les exceptions).
- La lutte contre la dette technique. L’expression désigne ce qui s’accumule quand on choisit la solution rapide au lieu de la solution propre : le programme marche, mais chaque modification devient plus lente et plus risquée, comme les intérêts d’un emprunt. On la rembourse par du remaniement (refactoring), c’est-à-dire la réécriture du code sans changer son comportement, protégée par des tests.
8Tester : montrer que ça marche, ou chercher qu’il casse
Les tests forment l’étage de vérification du cycle de vie. Un adage célèbre du mathématicien néerlandais Edsger Dijkstra le résume : les tests peuvent montrer la présence de défauts, jamais leur absence. Tester, c’est donc chercher activement ce qui ne va pas, avec les moyens dont on dispose, en sachant qu’on ne peut pas tout essayer.
8.1Les niveaux de test
- Les tests unitaires vérifient séparément chaque petit morceau (une fonction, une classe). Ils sont rapides, nombreux et automatisés.
- Les tests d’intégration vérifient que les morceaux fonctionnent ensemble, notamment aux interfaces (échanges de données, appels entre modules).
- Les tests système vérifient le logiciel complet dans un environnement proche de la production.
- La recette (ou qualification) est faite avec le client ou ses représentants pour décider de la réception.
- Les tests de non-régression rejouent les tests existants après chaque modification, pour vérifier qu’on n’a rien cassé. C’est l’usage le plus précieux de l’automatisation.
On représente souvent leur répartition idéale par une « pyramide » : beaucoup de tests unitaires à la base (rapides, bon marché), moins de tests d’intégration, encore moins de tests complets (lents, coûteux) au sommet.
8.2Un exemple de test unitaire
Imaginons la règle suivante : un musée est gratuit pour les moins de 4 ans, à 5 euros de 4 à 17 ans, à 10 euros à partir de 18 ans. Voici la fonction, avec ses tests, en Python (voir les langages de programmation) :
import unittest
def tarif(age):
if age < 4:
return 0
if age < 18:
return 5
return 10
class TestTarif(unittest.TestCase):
def test_gratuit(self):
self.assertEqual(tarif(3), 0)
def test_limite_basse(self):
self.assertEqual(tarif(4), 5)
def test_limite_haute(self):
self.assertEqual(tarif(17), 5)
self.assertEqual(tarif(18), 10)
unittest.main()
Les trois tests passent. Si un programmeur écrit par erreur age <= 18 à la place de age < 18, la fonction rendra 5 pour un adulte de 18 ans, et le test test_limite_haute échouera aussitôt. Remarquez où se logent les tests : aux limites (3, 4, 17, 18). La plupart des défauts de programmation se cachent là, dans les « un de trop, un de moins ». Remarquez aussi que ce test dit ce que le programme fait par rapport à une règle écrite ; il ne dit pas si la règle est la bonne, qui est la question de la validation. La technique du développement piloté par les tests (en anglais test-driven development) pousse l’idée plus loin : on écrit le test d’abord, on le voit échouer, puis on écrit le code qui le fait passer.
8.3Mesurer sans s’illusionner
La couverture de tests mesure la part du code exécutée par les tests. C’est un indicateur utile, qui signale les zones jamais testées, mais un taux élevé ne prouve pas que les tests soient bons : un test qui exécute du code sans rien vérifier fait monter la couverture sans protéger de rien. D’autres techniques complètent : les tests à données aléatoires (on soumet à la fonction des milliers d’entrées inattendues pour voir si elle plante), la revue et les analyses statiques (des outils qui lisent le code sans l’exécuter pour repérer des défauts typiques).
Pour s’exercer
Exercice 6 : écrire des tests aux limites
Une fonction livraison(montant) renvoie 0 euro de frais si le montant est d’au moins 50 euros, 4,90 euros sinon. Quels tests unitaires écrivez-vous, au minimum ? Quelle erreur de programmation sont-ils censés détecter ?
Voir la réponse
Au minimum quatre tests : un montant très inférieur (par exemple 10 euros, résultat 4,90), un montant juste en dessous de la limite (49,99, résultat 4,90), le montant exactement égal à la limite (50, résultat 0), un montant supérieur (80, résultat 0). Les valeurs 49,99 et 50 détectent l’erreur classique de comparaison, où l’on écrit « strictement supérieur à 50 » au lieu de « au moins 50 » (ou l’inverse). Les montants comme 0 ou négatifs sont à ajouter si la règle doit les traiter à part.