Le génie logiciel et le cycle de vie
Partie 2 sur 5
4Les modèles de cycle de vie
Un modèle de cycle de vie fixe l’ordre des activités, les documents à produire à la fin de chacune et les revues qui valident le passage à la suivante. Il fournit « une méthodologie commune entre le client et la société de service réalisant le développement ». Voici les principaux.
4.1Le modèle en cascade
Le modèle en cascade (en anglais waterfall) enchaîne les phases l’une après l’autre : besoins, conception, codage, tests, mise en service. À la fin de chacune, on produit des documents et l’on tient une revue pour vérifier la conformité avant de passer à la suivante. On situe sa mise au point en 1966 et sa formalisation autour de 1970. L’article qu’on cite le plus souvent est celui de l’ingénieur américain Winston Royce, publié en 1970, mais l’histoire est ironique : Royce y présente le schéma séquentiel pour dire qu’il est risqué et qu’il « invite à l’échec » s’il n’est pas complété par des retours en arrière, des essais anticipés et la participation du client. Le modèle n’a donc été défendu que par ceux qui l’ont mal lu.
La cascade a des qualités : elle est simple à comprendre, elle laisse des documents, elle convient quand les besoins sont stables et connus d’avance (un logiciel embarqué dans un équipement dont la spécification est figée, un contrat public avec un cahier des charges complet). Son défaut est qu’elle retarde le moment où le client voit quelque chose : les malentendus sur les besoins apparaissent à la recette, c’est-à-dire au moment où les corrections sont les plus coûteuses.
4.2Le modèle en V
Le modèle en V part du principe que les procédures de vérification de la conformité aux spécifications doivent être élaborées dès les phases de conception. À chaque étape de descente (besoins, spécifications, conception générale, conception détaillée) correspond, en face, un niveau de tests dans la remontée : la recette valide les besoins, les tests système valident les spécifications, les tests d’intégration valident la conception générale, les tests unitaires valident la conception détaillée. Au creux du V se trouve le codage (figure 2).
L’intérêt du V est de forcer à se demander, en rédigeant chaque étape de conception, comment on saura que ça marche. Il est très employé dans les domaines où l’on doit prouver la conformité (transports, aéronautique, santé, industrie). Il garde de la cascade son principal défaut : il suppose que l’on connaît bien les besoins au départ.
4.3Itératif, incrémental, spirale
Les modèles itératifs refont plusieurs fois le tour du cycle, en raffinant à chaque fois : on produit une première version approximative, on la montre, on l’améliore. Les modèles incrémentaux livrent le logiciel par morceaux : chaque livraison ajoute des fonctions à celles déjà en service. Les deux idées se combinent. Le modèle en spirale, proposé par Barry Boehm en 1986, y ajoute une analyse des risques à chaque tour : avant d’investir dans une partie, on identifie ce qui peut mal tourner et on construit un prototype pour lever les incertitudes les plus graves (voir la gestion des risques).
Parmi les approches de cette famille, la méthode RAD (Rapid Application Development, développement rapide d’applications, popularisée par James Martin en 1991) mise sur des prototypes réalisés vite avec les utilisateurs ; le processus unifié (UP, et sa version commerciale RUP) organise le projet en phases itératives pilotées par l’architecture et les cas d’utilisation ; la méthode XP (eXtreme Programming, programmation extrême) pousse à l’extrême des pratiques comme les tests écrits avant le code et les revues permanentes en binôme. Ces méthodes sont présentées plus en détail dans l’article sur les méthodes agiles.
4.4Agile et DevOps
En 2001, dix-sept praticiens publient le manifeste agile, qui place « les individus et leurs interactions », « un logiciel qui fonctionne », « la collaboration avec le client » et « l’adaptation au changement » avant leurs contreparties (processus et outils, documentation exhaustive, négociation de contrat, suivi d’un plan). Dans la pratique, on travaille par périodes courtes (une à quatre semaines) à la fin desquelles on livre un logiciel qui fonctionne ; le cycle de vie complet est repassé dans chaque période, à petite échelle. Plus récemment, le mouvement DevOps (contraction de development et operations, exploitation) rapproche ceux qui écrivent le logiciel et ceux qui le font tourner, et automatise la chaîne qui va du code à la production (partie 11).
4.5Comment choisir ?
| Situation | Modèle plutôt adapté | Pourquoi |
|---|---|---|
| Besoins stables, preuve de conformité exigée (pilotage d’un train, dispositif médical) | V, ou cascade avec revues | chaque exigence doit être suivie jusqu’à son test |
| Produit nouveau, besoins incertains, retours rapides possibles | agile (itératif, incrémental) | on apprend en livrant et on corrige la route |
| Risque technique élevé (nouvelle technologie) | spirale, prototypes | on traite les risques graves en premier |
| Application interne simple, utilisateurs proches | RAD, prototypage, agile léger | le retour direct vaut mieux que le document |
| Logiciel déjà en service, évolutions fréquentes | agile et DevOps | de petites livraisons automatisées réduisent le risque |
La réalité est rarement pure. Beaucoup d’organisations pratiquent un mélange : une phase de cadrage rédigée comme en cascade, puis un développement par itérations, avec des tests organisés en V. Le bon modèle est celui que l’équipe applique réellement et qui correspond au niveau d’incertitude du projet.
Pour s’exercer
Exercice 1 : classer des tâches
Associez chaque tâche à une activité du cycle de vie : (a) rédiger avec le client la liste de ce que doit faire l’application ; (b) vérifier qu’une fonction de calcul de remise renvoie les bons montants ; (c) installer la nouvelle version sur le serveur ; (d) adapter le logiciel à une nouvelle règle de TVA ; (e) décider de la division en modules.
Voir la réponse
(a) analyse des besoins. (b) test unitaire. (c) mise en production. (d) maintenance : ici adaptative ou évolutive, car la cause est un changement de l’environnement (la loi). (e) conception générale (architecture).
Exercice 2 : valider ou vérifier ?
Une équipe livre un logiciel qui respecte à la lettre la spécification, mais les utilisateurs refusent de s’en servir : il ne répond pas à leur usage réel. A-t-on échoué à valider ou à vérifier ? Que changer dans l’organisation ?
Voir la réponse
La vérification était bonne (le logiciel est conforme à la spécification) ; c’est la validation qui a échoué : on a construit correctement le mauvais logiciel. La cause est une spécification qui ne correspondait pas au besoin réel. On y remédie en impliquant les utilisateurs tôt et souvent (prototypes, démonstrations à chaque période, essais avec des utilisateurs réels) plutôt qu’à la seule recette finale.
Exercice 3 : le coût d’une erreur
Une règle de gestion est mal comprise : le client voulait « livraison gratuite à partir de 50 euros » mais la spécification dit « au-dessus de 50 euros ». Décrivez ce qu’il en coûte de trouver l’erreur (a) en relisant la spécification, (b) pendant les tests unitaires, (c) chez le client. Qu’en conclure ?
Voir la réponse
(a) Une phrase à corriger, quelques minutes. (b) Si le test est écrit d’après la spécification, il passe : il ne détecte pas l’erreur, qui est dans la spécification elle-même ; on la trouvera plus tard. Cela montre que les tests unitaires vérifient, ils ne valident pas. (c) Corriger le code, retester, redéployer, répondre aux réclamations de clients lésés, peut-être rembourser. L’écart de coût entre (a) et (c) illustre l’intérêt des revues précoces et de la participation du client aux phases amont. La tendance est ce qui compte, non un rapport chiffré précis.
Exercice 4 : cascade, V ou agile ?
Choisissez et justifiez un modèle pour : (a) le logiciel de freinage d’un train, dont la spécification est figée et soumise à certification ; (b) une application mobile de réservation, pour un marché encore mal connu ; (c) une migration de base de données utilisant une technique que personne dans l’équipe n’a jamais pratiquée.
Voir la réponse
(a) Le modèle en V (ou une cascade avec revues) : les besoins sont stables, et il faut prouver que chaque exigence est testée. (b) Une méthode agile : les besoins sont incertains, il faut livrer vite une version minimale et apprendre des retours. (c) Une approche en spirale, ou un projet itératif commençant par un prototype : le risque technique est le plus grand, donc on le traite en premier avant de s’engager sur un calendrier.
Exercice 5 : types de maintenance
Classez : (a) un bouton « Valider » qui ne répond plus sur un navigateur récent ; (b) l’ajout d’un export en format tableur demandé par les utilisateurs ; (c) le remplacement d’une bibliothèque dont l’éditeur annonce la fin du support, avant que des problèmes apparaissent ; (d) la correction d’une erreur de calcul d’arrondi.
Voir la réponse
(a) Maintenance adaptative (changement de l’environnement : le navigateur), même si le résultat se perçoit comme un défaut. (b) Évolutive (nouvelle fonction demandée). (c) Préventive (on agit avant la panne, à cause de la fin de support). (d) Corrective (un défaut constaté).
5Comprendre le besoin : les exigences
La première cause d’échec des projets informatiques n’est pas technique : c’est de construire autre chose que ce qu’il fallait. L’activité d’analyse des besoins (aussi appelée ingénierie des exigences) consiste à découvrir, écrire, vérifier et suivre ce que le logiciel doit faire. On distingue :
- les exigences fonctionnelles, qui décrivent ce que le logiciel fait (« le client peut payer en ligne par carte ») ;
- les exigences non fonctionnelles, qui décrivent comment il le fait : vitesse, nombre d’utilisateurs simultanés, disponibilité, facilité d’emploi, sécurité, accessibilité aux personnes handicapées, conformité à la loi ;
- les contraintes : budget, calendrier, matériel imposé, langage imposé.
Une bonne exigence est claire, vérifiable (on peut dire sans discussion si elle est satisfaite : « la page s’affiche en moins de deux secondes pour 95 % des requêtes » plutôt que « la page est rapide »), cohérente avec les autres et justifiée. Les approches traditionnelles les rédigent dans un cahier des charges ou un document de spécification. Les méthodes agiles les notent sous forme de courtes histoires d’utilisateur (« en tant que client, je veux suivre ma commande, afin de savoir quand elle arrivera »), discutées en continu et affinées à chaque période.
La faisabilité est un jugement porté dès le début : le projet est-il possible techniquement, rentable, acceptable juridiquement et organisationnellement ? Dire non à ce stade est parfois le meilleur résultat d’une analyse.
5.1Les qualités d’un logiciel
La norme internationale ISO/IEC 25010 (« modèle de qualité du produit logiciel ») propose une liste de qualités que l’on peut exiger d’un logiciel : adéquation fonctionnelle (il fait ce qu’il faut), performance, compatibilité avec d’autres logiciels, utilisabilité (facilité d’emploi), fiabilité, sécurité, maintenabilité (facilité à modifier) et portabilité (facilité à changer d’environnement). La version de 2011 en compte huit ; une révision de 2023 a élargi la liste et précisé certains termes. Cette liste sert de grille pour ne rien oublier lors de la rédaction des exigences. Elle rappelle aussi que ces qualités sont souvent en tension : un logiciel très sûr peut être moins commode, un logiciel très rapide plus difficile à maintenir.