Aller au contenu
Encyclopédie informatique Édition 2026

Le génie logiciel et le cycle de vie

Écrire un petit programme pour soi est un exercice de programmation. Faire un logiciel que dix personnes écrivent ensemble, que des milliers d’utilisateurs emploient pendant quinze ans, qui doit rester juste, sûr et modifiable, est un tout autre métier : c’est le génie logiciel. Le terme a été choisi en 1968 par comparaison avec le génie civil : on ne construit pas un pont en posant des briques au hasard. Cet article présente les activités qui jalonnent la vie d’un logiciel (besoins, conception, codage, tests, mise en service, maintenance), les grands modèles qui les organisent (cascade, V, itératif, agile), les outils qui les soutiennent, de l’ancien atelier de génie logiciel aux chaînes automatisées d’aujourd’hui, et la place qu’y prend désormais la sécurité.

Rubrique
Développement
Niveau
Débutant à intermédiaire
Lecture
31 min (essentiel)
33 min (complet)
Révision
4 novembre 2026
Niveau de lecture :

En bref

  • Le génie logiciel organise la fabrication d’un logiciel comme un chantier : il couvre la programmation mais aussi les besoins, la conception, les tests, la mise en service, la maintenance et la gestion du projet.
  • Le cycle de vie découpe ce travail en étapes pour pouvoir valider chacune ; l’idée de départ est qu’une erreur coûte d’autant plus cher qu’on la découvre tard.
  • Les modèles diffèrent par l’ordre : la cascade enchaîne les phases une fois, le modèle en V prépare les tests dès la conception, les modèles itératifs et agiles font plusieurs petits tours avec le client.
  • Après la mise en service, la maintenance occupe la plus grande part de la vie, et donc du coût, d’un logiciel : corriger, adapter, améliorer, prévenir.
  • Les outils ont changé de nature : l’ancien atelier de génie logiciel est devenu une chaîne automatisée (gestion des versions, tests automatiques, déploiement), et la sécurité s’y intègre à chaque étape plutôt qu’à la fin.

Prérequis conseillés : Les langages de programmation

1Pourquoi un « génie » du logiciel ?

Le génie logiciel (en anglais software engineering) se définit comme l’ensemble des méthodes, des techniques et des outils concourant à la production d’un logiciel, au-delà de la seule activité de programmation. Le choix du mot « génie » faisait référence au génie civil, c’est-à-dire à l’art de construire : pour bâtir un ouvrage, poser brique et ciment ne suffit pas. Un bâtiment est un tout, avec de la conception architecturale, de la maçonnerie, de la plomberie, de l’électricité, qu’il faut coordonner pour tenir les délais et le budget. De la même manière, un logiciel suppose de la gestion de projet, afin d’être livré à temps, avec un budget maîtrisé, et de donner satisfaction au client : c’est la notion de qualité.

Cette définition tient toujours, avec deux nuances que nous allons développer. D’abord, l’analogie avec le bâtiment a des limites : un logiciel ne se voit pas, il peut être modifié à tout instant et il ne s’use pas, mais il se dégrade parce que le monde autour de lui change. Ensuite, la manière de s’organiser a beaucoup évolué depuis une quinzaine d’années : les méthodes agiles, les chaînes automatisées et la sécurité intégrée ont déplacé le centre de gravité du métier.

1.1Une discipline née d’une crise

L’expression est lancée en octobre 1968, lors d’une conférence organisée par l’OTAN à Garmisch, en Allemagne, qui réunit des chercheurs et des industriels inquiets. Dans les années 1960, les ordinateurs sont devenus assez puissants pour que l’on écrive de très gros logiciels, notamment des systèmes d’exploitation, et ces projets accumulent les retards, les dépassements de budget et les défauts. On parle alors de « crise du logiciel ». Les participants choisissent à dessein un terme provocateur, software engineering, pour suggérer que la fabrication de logiciels devrait acquérir la rigueur des disciplines d’ingénieur. Depuis, la discipline a produit des normes, des méthodes, des outils et un corpus de connaissances. Le plus connu est le « guide du corpus de connaissances en génie logiciel » (SWEBOK), publié par l’association professionnelle IEEE, dont la version 4 est parue en 2024.

1.2Ce que couvre la discipline

Le génie logiciel moderne s’intéresse à de nombreux domaines : le recueil des exigences (ce que le logiciel doit faire), la conception et l’architecture, la construction (programmation), les tests, la maintenance, la gestion des versions et des configurations, la gestion de projet, les processus, les modèles, la qualité et la sécurité. Une norme internationale, ISO/IEC/IEEE 12207 (« Processus du cycle de vie du logiciel »), décrit cet ensemble de processus et sert de référence aux contrats et aux audits. Elle ne dit pas comment travailler, elle liste ce dont un projet bien mené doit s’occuper.

1.3Le plan de l’article

La partie 2 présente les activités du cycle de vie (figure 1). La partie 3 explique pourquoi on les découpe ainsi. La partie 4 présente les modèles, dont le modèle en V (figure 2). Les parties 5 à 10 reprennent les grandes activités : exigences, conception, codage, tests, mise en service, maintenance. La partie 11 traite des outils, de l’atelier de génie logiciel aux chaînes actuelles (figure 3). La partie 12 traite de la sécurité, la partie 13 de la qualité de la gestion de projet, et la partie 14 résume ce qui a changé.

2Le cycle de vie : les onze activités

Le cycle de vie d’un logiciel (en anglais software lifecycle) désigne toutes les étapes de son développement, de sa conception à sa disparition. On en liste classiquement onze, qui forment le vocabulaire commun du métier. La figure 1 les place dans l’ordre ; en voici le sens.

LES ONZE ACTIVITÉS DU CYCLE DE VIE 1. Objectifs but du projet 2. Besoins et faisabilité 3. Conception générale 4. Conception détaillée 5. Codage programmation 6. Tests unitaires 7. Intégration assembler 8. Qualification recette client 9. Documentation pour utiliser 10. Mise en production 11. Maintenance corriger, évoluer Les demandes d’évolution rouvrent un nouveau tour du cycle ; le modèle choisi fixe l’ordre et le rythme.
Figure 1. Les onze activités du cycle de vie d’un logiciel, dans l’ordre classique.
  1. Définition des objectifs. À quoi servira le logiciel, et comment s’inscrit-il dans la stratégie de l’organisation ? Pourquoi le faire ?
  2. Analyse des besoins et faisabilité. On recueille, on écrit et on met en forme les besoins du demandeur (le client) et l’ensemble des contraintes (budget, délais, lois, matériel), puis l’on juge si le projet est réalisable. Le résultat est un document de spécification.
  3. Conception générale. On élabore l’architecture d’ensemble : de quels grands morceaux (modules) le logiciel est-il fait, et comment communiquent-ils ?
  4. Conception détaillée. On définit précisément chaque sous-ensemble : ses données, ses fonctions, ses règles.
  5. Codage (ou implémentation, ou programmation). On traduit la conception dans un langage de programmation (voir les langages de programmation).
  6. Tests unitaires. On vérifie séparément que chaque sous-ensemble est conforme à ce qui a été spécifié.
  7. Intégration. On assemble les morceaux et l’on vérifie qu’ils s’entendent (interfaces, échanges de données). Les tests d’intégration sont consignés dans un document.
  8. Qualification (ou recette). On vérifie, avec le client, la conformité du logiciel aux spécifications initiales, avant de l’accepter.
  9. Documentation. On produit les informations nécessaires pour utiliser le logiciel (manuel) et pour le faire évoluer (documentation technique).
  10. Mise en production. On installe le logiciel là où il servira, et on le met à disposition des utilisateurs. On la traitait autrefois comme une simple ligne ; c’est aujourd’hui une activité à part entière (partie 9).
  11. Maintenance. Elle comprend toutes les actions correctives (réparer les défauts) et évolutives (ajouter ou modifier des fonctions) sur le logiciel.

Un point est important : la séquence et la présence de chacune de ces activités dépend du choix d’un modèle de cycle de vie, convenu entre le client et l’équipe de développement. Ces onze activités sont donc un vocabulaire, pas un ordre obligatoire. Une petite application peut les mener en une journée, une méthode agile les répète toutes les deux semaines, un logiciel de pilotage d’avion les documente chacune sur des milliers de pages.

3Pourquoi découper ?

La raison de ce découpage est qu’il permet de définir des jalons intermédiaires (des points de contrôle) qui servent à la validation du développement (le logiciel est-il conforme aux besoins exprimés ?) et à la vérification du processus (les méthodes employées sont-elles adaptées ?). Les deux mots se confondent facilement dans l’usage courant ; on les distingue ainsi :

  • Valider, c’est répondre à la question « construisons-nous le bon logiciel ? », celui dont l’utilisateur a réellement besoin.
  • Vérifier, c’est répondre à « construisons-nous le logiciel correctement ? », c’est-à-dire conforme à ce qui a été spécifié.

Un logiciel peut être parfaitement vérifié (il fait exactement ce que dit la spécification) et pourtant inutile, parce que la spécification passait à côté du besoin. Les deux contrôles sont donc nécessaires, à des moments différents.

3.1Le coût des erreurs tardives

L’origine du découpage vient du constat que les erreurs ont un coût d’autant plus élevé qu’elles sont détectées tardivement. Le cycle de vie sert à détecter les erreurs au plus tôt, et donc à maîtriser la qualité, les délais et les coûts. L’idée est intuitive : une erreur dans le texte des besoins, si on la trouve en relisant, se corrige en changeant une phrase ; si on la trouve après trois mois de programmation, il faut défaire du travail ; si on la découvre chez le client, il faut corriger, tester, redéployer et parfois dédommager. Des études menées depuis les années 1970, notamment par l’ingénieur américain Barry Boehm, ont mesuré cette croissance. Les rapports chiffrés (« corriger en production coûte cent fois plus ») sont très discutés : ils varient selon les projets et les méthodes, et il vaut mieux retenir la tendance que les valeurs exactes. Elle explique deux pratiques qui traversent tous les modèles : relire tôt (revues de spécifications et de conception) et tester tôt, ce que l’on appelle parfois, en anglais, shift left (« décaler vers la gauche » dans le calendrier).

Les méthodes récentes tempèrent un point : dans un projet agile, un défaut découvert au bout de deux semaines coûte peu, parce que le cycle est court et que l’automatisation rend la correction et le redéploiement bon marché. Le coût d’une erreur tardive dépend donc beaucoup du temps qui sépare l’erreur de sa découverte, et c’est précisément ce que les cycles courts réduisent.