UML
Avant de construire une maison, on dessine des plans : un plan de masse, un plan des étages, un schéma électrique. Les plans coûtent peu, et une erreur sur le papier se corrige avec une gomme. UML (Unified Modeling Language, « langage de modélisation unifié ») joue ce rôle pour les logiciels : c’est une collection de dessins normalisés qui permettent de réfléchir, de discuter et de se mettre d’accord avant de programmer, ou pendant. Cet article explique d’où vient UML, ce qu’il est et ce qu’il n’est pas, comment on dessine un objet, une classe, un cas d’utilisation, et à quoi servent les autres diagrammes. Il dit aussi ce qu’UML promettait et ce qu’on en pense aujourd’hui, à l’heure des méthodes agiles et des diagrammes écrits en texte.
- Rubrique
- Développement
- Niveau
- Débutant à intermédiaire
- Lecture
- 34 min (essentiel)
37 min (complet) - Révision
- 4 novembre 2026
En bref
- UML est un langage de dessin pour décrire les logiciels : un ensemble de quatorze types de diagrammes normalisés, chacun montrant un aspect différent du même système.
- UML n’est pas une méthode : il dit comment dessiner, pas quoi faire et dans quel ordre. Il est né vers 1995-1997 de la fusion de trois méthodes concurrentes et il est géré par l’OMG (l’organisation qui le publie) ; la version actuelle est la 2.5.1 (2017).
- Le diagramme de classes montre les éléments du logiciel (leurs données et leurs actions) et leurs liens ; le diagramme de cas d’utilisation montre ce que les utilisateurs en attendent ; le diagramme de séquence montre les échanges dans le temps.
- UML sert surtout à communiquer : avec un client, entre équipes, avec soi-même dans six mois. Un croquis rapide vaut mieux qu’un dessin parfait que personne ne met à jour.
- Un dessin ne protège de rien : l’attribut « privé » d’une classe est une règle de rangement du code, pas une défense contre un attaquant.
Prérequis conseillés : La programmation orientée objet
1Qu’est-ce qu’UML ?
Imaginez que vous deviez expliquer à un collègue le fonctionnement d’un logiciel de bibliothèque : les adhérents empruntent des livres, les rendent, paient une pénalité s’ils sont en retard. Vous pouvez parler une heure. Vous pouvez aussi prendre une feuille et dessiner des rectangles reliés par des traits : « ici l’adhérent, ici le livre, entre les deux l’emprunt ». En trois minutes, votre collègue a compris l’essentiel et peut vous dire : « mais un livre peut avoir plusieurs exemplaires ? ». Le dessin a fait apparaître une question que la conversation aurait peut-être laissée dans l’ombre.
UML (Unified Modeling Language, que l’on traduit par « langage de modélisation unifié ») est une manière standard de faire ces dessins. Standard veut dire que les rectangles, les flèches et les symboles ont partout le même sens : un dessin fait à Lyon se lit à Montréal ou à Abidjan sans explication. Il s’est imposé comme la notation de référence pour décrire un logiciel construit à partir d’objets (voir la programmation orientée objet pour cette façon de programmer). On a longtemps dit que sa connaissance était souvent nécessaire pour obtenir un poste de développeur objet. Cette exigence est moins systématique aujourd’hui, mais UML reste un langage commun que beaucoup de personnes du métier savent lire.
1.1Modéliser : une représentation simplifiée
Le mot clé est modèle. Un modèle est une représentation simplifiée d’un problème : il garde ce qui compte et laisse de côté le reste. Une carte du métro n’est pas un plan exact de la ville : elle ne montre ni la largeur des rues, ni la distance réelle entre les stations, mais elle répond très bien à la question « comment aller de la gare au stade ? ». En résumé, la modélisation consiste à créer une représentation simplifiée d’un problème, le modèle, qui permet de le représenter simplement, de le comprendre et de le simuler.
La modélisation comprend deux activités, qui se mêlent en pratique :
- l’analyse, c’est-à-dire l’étude du problème : que veulent les utilisateurs, quelles sont les règles du métier, quels sont les mots employés par les gens du domaine ;
- la conception, c’est-à-dire la mise au point d’une solution : quels éléments logiciels, comment se répartissent-ils le travail, comment communiquent-ils.
Un modèle est toujours un point de vue sur le système, jamais le système tout entier. C’est pourquoi UML ne propose pas un seul dessin, mais plusieurs, qui se complètent (partie 4).
1.2UML n’est pas une méthode
C’est l’une des phrases les plus importantes à retenir : UML n’est pas une méthode, dans la mesure où il ne propose aucune démarche. Une méthode dit « commencez par ceci, puis faites cela, validez à telle étape ». UML ne dit rien de tel : c’est un formalisme, c’est-à-dire un ensemble de règles pour dessiner. On peut s’en servir dans une démarche très rigoureuse, découpée en phases, ou dans une démarche légère où l’on dessine au tableau pendant quinze minutes avant de coder. Quand on parle de « méthode UML » par abus de langage, il faut donc comprendre « notation UML ».
La comparaison avec une langue est utile. Le français permet d’écrire un roman comme un mode d’emploi, mais il ne dit pas comment organiser un roman. UML est le français ; la démarche de projet (agile, en cascade, etc.) est le plan du livre. Pour la démarche, voir les méthodes agiles.
1.3Pourquoi une méthode d’analyse objet ?
L’intérêt d’une notation commune tient en deux idées. La première : chaque langage de programmation orienté objet (Java, C++, Python, etc.) a sa propre manière de mettre en œuvre le paradigme objet. Une notation indépendante des langages permet de poser le problème à haut niveau, sans entrer dans les particularités de l’un d’eux, et de le présenter à toutes les personnes d’un projet, y compris celles qui ne sont pas expertes en programmation (clients, responsables, testeurs).
La seconde : programmer avec un langage objet ne fait pas de vous un concepteur objet. On peut produire un code syntaxiquement correct sans avoir réfléchi à une structure d’objets cohérente, et obtenir ce que l’on appelle parfois, par moquerie, du code procédural déguisé. La programmation orientée objet demande d’abord de concevoir un modèle (c’est le rôle de la notation et de la réflexion qui l’accompagne), puis seulement de l’écrire dans un langage. En pratique les deux se font souvent en même temps, par allers-retours, et c’est très bien ainsi.
Pour s’exercer
Exercice 1 : méthode ou notation ?
Un collègue dit : « Nous travaillons avec la méthode UML. » Que lui répondez-vous, et que lui conseillez-vous de préciser ?
Voir la réponse
UML n’est pas une méthode : c’est une notation, un langage de dessin. Une méthode donne une démarche (quelles étapes, dans quel ordre, avec quelles validations) ; UML ne dit rien de cela. Il faut préciser la démarche réellement suivie (par exemple une démarche agile avec des itérations courtes) et dire quels diagrammes UML y sont utilisés, à quel moment et pour qui.
2D’où vient UML
2.1La guerre des notations
Dans les années 1970 à 1990, de nombreux analystes ont proposé leur façon de concevoir des logiciels à objets. Chacun avait sa notation : ici un nuage pour une classe, là un rectangle, ailleurs un cercle. On comptait plus de cinquante méthodes différentes en 1994. Un dessin fait selon l’une n’était pas lisible par les partisans d’une autre, ce qui rendait les échanges difficiles, les outils logiciels coûteux à développer (il fallait en faire un par notation) et la formation des équipes pénible.
Trois méthodes ont fini par dominer :
- OMT (Object Modeling Technique, technique de modélisation objet), de James Rumbaugh, très forte pour décrire les données et leurs liens ;
- Booch’93, de Grady Booch, forte pour la conception détaillée et l’architecture ;
- OOSE (Object-Oriented Software Engineering, génie logiciel orienté objet), d’Ivar Jacobson, centrée sur les cas d’utilisation, c’est-à-dire sur ce que les utilisateurs attendent du logiciel.
2.2La fusion
À partir de 1994, James Rumbaugh et Grady Booch, qui travaillaient alors dans la même entreprise (Rational Software), unissent leurs efforts ; Ivar Jacobson les rejoint en 1995. Le résultat porte d’abord le nom de « méthode unifiée » (version 0.8, 1995), puis devient UML. Les trois hommes sont restés connus sous le surnom de « trois amis » (the three amigos). L’idée n’était pas d’inventer quelque chose de neuf à partir de rien, mais de réunir les meilleures idées de chaque méthode dans une notation que tout le monde accepterait.
Le projet est soumis en janvier 1997 à l’OMG (Object Management Group, « groupe de gestion des objets »), une organisation à but non lucratif fondée en 1989 par des entreprises de l’informatique pour définir des standards garantissant que des applications écrites avec des langages à objets puissent fonctionner ensemble, même sur des réseaux composés de machines très différentes. Il est accepté en novembre 1997 dans sa version 1.1, et devient alors une norme reconnue et utilisée par de nombreuses entreprises. La normalisation était le point décisif : pour qu’un langage de dessin soit commun, il faut qu’une instance neutre en fixe les règles et les fasse évoluer.
2.3Les versions successives
La version 1.5 date de 2003, et l’histoire a continué (tableau 1). Le changement le plus important est UML 2, adopté en 2005, qui a réorganisé le langage et ajouté plusieurs diagrammes.
| Date | Étape |
|---|---|
| 1995 | méthode unifiée 0.8 (fusion de Booch’93 et d’OMT), puis UML 0.9 qui intègre OOSE |
| 1996 - 1997 | UML 1.0 proposé à l’OMG (janvier 1997) ; UML 1.1 adopté comme standard (novembre 1997) |
| 1998 - 2003 | versions 1.2, 1.3, 1.4 (2000) et 1.5 (2003) : précisions et corrections |
| 2005 | UML 2.0 : nouvelle organisation du langage, nouveaux diagrammes |
| 2012 | UML 2.4.1 publié aussi comme norme internationale de l’ISO (organisation internationale de normalisation), sous la référence 19505 |
| 2017 | UML 2.5.1, version actuelle sur le site de l’OMG |
Depuis 2017 il n’y a pas eu de nouvelle version majeure. Ce n’est pas un signe d’abandon mais plutôt de maturité : le langage est stable, et c’est ce qu’on attend d’un langage de dessin commun. Les spécifications complètes sont disponibles gratuitement sur le site de l’OMG ; elles sont longues (plus de 700 pages) et destinées aux outilleurs bien plus qu’aux utilisateurs.
3Les caractéristiques d’UML
3.1Un langage fondé sur un métamodèle
On présente UML comme un moyen d’exprimer des modèles objet en faisant abstraction de leur implémentation : un modèle UML est valable pour n’importe quel langage de programmation, car il ne dit pas comment tel élément sera écrit en Java ou en C++, seulement quel élément existe et quel rôle il joue. Pour que ce langage de dessin ait des règles précises, il s’appuie sur un métamodèle.
Un métamodèle est un modèle « d’un niveau au-dessus » : il décrit les éléments dont on peut se servir pour fabriquer un modèle (classe, attribut, association, acteur, etc.) et ce que chacun signifie. C’est comme la grammaire d’une langue : la grammaire n’est pas une phrase, elle dit quelles phrases sont permises. Le métamodèle d’UML est lui-même écrit... en UML, ce qui est une jolie boucle : le langage sait se décrire lui-même. Cette base rigoureuse permet aux logiciels de dessin et de génération de code de comprendre sans ambiguïté ce que vous avez tracé.
3.2Ce qu’UML promet, et ce qu’il faut nuancer
On énumère les qualités du langage : sans ambiguïté, universel, capable de définir la structure d’un programme, doté d’une représentation visuelle qui facilite la communication, d’une notation simple compréhensible même par des non-informaticiens. Ces promesses sont à relire avec un peu de recul :
- « Sans ambiguïté » : le métamodèle est précis, mais le sens de certains éléments reste en partie décrit en français dans la norme, et deux équipes peuvent lire différemment un même dessin. UML supprime beaucoup d’ambiguïtés, pas toutes.
- « Universel, pour tout langage objet » : vrai pour les langages classiques à classes. Pour d’autres façons de programmer (programmation fonctionnelle, par exemple), le fit est moins naturel.
- « Compréhensible par des non-informaticiens » : vrai pour un diagramme de cas d’utilisation ou un diagramme d’activités bien fait, beaucoup moins pour un diagramme de classes chargé de détails techniques. Le bon réflexe est d’adapter le niveau de détail au public.
- « Fait pour représenter tout le système » : en pratique, personne ne dessine tout. On dessine ce qui est délicat, nouveau ou risqué, et on laisse le code dire le reste.
3.3UML pour économiser de l’argent ?
Un argument économique tient à la façon dont se commandent les logiciels. Une entreprise qui veut un logiciel le fait parfois fabriquer en interne, plus souvent par une société de services. Dans les deux cas, il faut définir ce que le logiciel doit faire. Le demandeur, qui n’a pas forcément de compétence informatique, exprime ses souhaits dans un cahier des charges fonctionnel (CdCF) : un document en langage courant qui décrit les fonctions attendues, les contraintes (systèmes d’exploitation visés, délais, coût, langages à utiliser) et les pièges à éviter. Ce cahier est envoyé à plusieurs sociétés de services dans un appel d’offres ; chacune répond par un coût et un délai.
Quand une société obtient le marché et choisit un langage objet, elle commence par créer un modèle pour deux raisons : présenter au client la façon dont elle compte développer le logiciel, et mettre d’accord tous les acteurs du projet, car une grande application est découpée en modules fabriqués par plusieurs équipes. Si le modèle ne convient pas au client, il est « simple » à modifier, alors qu’une application déjà programmée aurait mobilisé bien plus de monde pendant bien plus longtemps. C’est ainsi que le modèle ferait gagner de l’argent à la société de services, et augmenterait la probabilité de livrer dans les délais (dead line, « ligne morte », disait le texte) une application conforme aux exigences du client. Celui-ci pouvait même difficilement contester la validité du logiciel, s’il s’était conformé au modèle présenté.
Ce raisonnement contient une part de vérité durable : corriger un dessin coûte beaucoup moins cher que corriger un logiciel fini, et plus une erreur est découverte tard, plus elle est coûteuse. Il porte aussi la marque de son époque, celle des projets en « cascade », où tout était spécifié d’avance puis réalisé d’un bloc. L’expérience a montré les limites de cette vision : le client ne sait souvent pas ce qu’il veut avant d’avoir vu quelque chose qui tourne, et un modèle « validé » par signature peut devenir une arme contractuelle plus qu’un outil de compréhension. Les méthodes agiles (voir les méthodes agiles) répondent en faisant des modèles légers, fréquents, et en montrant très tôt un logiciel utilisable. UML s’y insère très bien à condition d’être utilisé comme un croquis qu’on jette ou qu’on met à jour, non comme un contrat gravé dans le marbre.