Maîtriser la complexité logicielle : un guide complet de la modélisation UML

Introduction

Dans le paysage en constante évolution du génie logiciel, la gestion de la complexité est devenue l’un des défis les plus critiques auxquels font face les équipes de développement. À mesure que les systèmes grandissent en taille et en sophistication, les approches traditionnelles de documentation et de conception s’avèrent souvent insuffisantes, entraînant des malentendus, des erreurs coûteuses et des échecs de projet. C’est ici que les langages de modélisation jouent un rôle fondamental, servant de pont entre les concepts abstraits et les implémentations concrètes.

Le langage de modélisation unifié (UML) est devenu la norme de facto pour la modélisation logicielle, offrant un vocabulaire commun qui permet aux parties prenantes de domaines différents de communiquer efficacement. Que vous soyez analyste métier capturant des exigences, architecte logiciel concevant la structure du système ou développeur implémentant des fonctionnalités, UML fournit les outils nécessaires pour visualiser, spécifier, construire et documenter des systèmes intensifs en logiciel.

Cette étude de cas complète explore les concepts fondamentaux de la modélisation, retrace l’évolution historique d’UML et examine comment ce langage unifié a transformé notre approche du développement logiciel. En comprenant les principes d’UML et ses applications pratiques, les organisations peuvent tirer parti de ces techniques puissantes pour maîtriser des systèmes complexes, réduire les risques de développement et livrer des solutions logicielles de meilleure qualité.

---

Comprendre les modèles : la fondation de la communication efficace

Qu’est-ce qu’un modèle ?

Au fond, un modèle est une représentation simplifiée de la réalité. Tout comme un plan architectural capte les éléments essentiels d’un bâtiment tout en omettant des détails superflus, comme la couleur de chaque brique, un modèle logiciel se concentre sur les aspects importants d’un système tout en abstrayant les détails d’implémentation. Cette représentation sélective nous permet de travailler avec des systèmes complexes de manière gérable.

Le pouvoir des modèles réside dans leur capacité à être représentés sous diverses formes : diagrammes bidimensionnels, visualisations tridimensionnelles, descriptions textuelles ou prototypes interactifs. Cette flexibilité signifie que nous pouvons choisir la représentation la plus adaptée à nos besoins spécifiques et à notre public cible.

Un modèle d’un système logiciel développé à l’aide d’un langage de modélisation comme UML possède à la foissémantique (le sens) etnotation (symboles et syntaxe). Ces modèles peuvent prendre plusieurs formes, combinant des diagrammes visuels à des spécifications textuelles. L’avantage principal est que les modèles sont conçus pour être plus faciles à manipuler et à comprendre dans un but spécifique que le système final pleinement implémenté.

Figure 1 : Un modèle fournit une vue simplifiée qui capte les aspects essentiels tout en filtrant la complexité inutile

Pourquoi avons-nous besoin de modèles ?

Les modèles remplissent plusieurs fonctions essentielles tout au long du cycle de vie du développement logiciel :

1. Capturer les exigences et les connaissances du domaine
Les modèles permettent une formulation précise des exigences et des connaissances du domaine, garantissant que toutes les parties prenantes — des utilisateurs métiers aux équipes techniques — comprennent et s’entendent sur ce qui doit être construit. Cette compréhension partagée réduit l’ambiguïté et évite les malentendus coûteux plus tard dans le projet.

2. Faciliter la pensée de conception
Avant d’écrire une seule ligne de code, les modèles permettent aux architectes et aux concepteurs de réfléchir à la structure du système, à son comportement et à ses interactions. Cette réflexion préalable aide à identifier les problèmes potentiels tôt, quand ils sont les moins coûteux à corriger.

3. Documenter les décisions de conception
Les modèles capturent les décisions de conception sous une forme modifiable, tout en restant séparés des exigences. Cette séparation permet aux équipes d’explorer différentes alternatives de conception sans compromettre les exigences initiales, et fournit un historique des raisons pour lesquelles certains choix ont été faits.

4. Générer des produits de travail
Les modèles bien construits peuvent servir de fondation à la génération de divers produits de travail, notamment des squelettes de code, des cas de test, de la documentation et des configurations de déploiement. Cette automatisation améliore la cohérence et réduit les efforts manuels.

5. Gérer l’information dans les grands systèmes
Pour les systèmes à l’échelle d’entreprise comprenant des millions de lignes de code et des centaines de composants, les modèles fournissent des mécanismes pour organiser, filtrer, récupérer, examiner et modifier efficacement les informations. Ils agissent comme des aides à la navigation au sein de la complexité.

6. Explorer des solutions de manière économique
Les modèles permettent une exploration rapide de multiples alternatives de conception à une fraction du coût de l’implémentation complète. Les équipes peuvent évaluer les compromis, évaluer la faisabilité et choisir des solutions optimales avant d’engager des ressources importantes.

7. Maîtriser les systèmes complexes
Peut-être plus important encore, les modèles aident les humains à comprendre des systèmes qui autrement seraient trop complexes pour être entièrement compris. En offrant différentes perspectives et niveaux d’abstraction, les modèles rendent compréhensible ce qui était incompréhensible.

---

Le langage de modélisation unifié : une norme pour la modélisation logicielle

Qu’est-ce que le UML ?

Le langage de modélisation unifié (UML) est un langage de modélisation visuelle standardisé spécifiquement conçu pour les systèmes intensifs en logiciels. Il fournit un ensemble complet de types de diagrammes et de règles de notation qui permettent aux praticiens de :

• Visualiser l’architecture et le comportement du système

• Spécifier les exigences et les conceptions détaillées

• Construire des plans de système qui guident l’implémentation

• Documenter les décisions et les structures pour une référence future

En essence, le UML sert de langage commun qui comble le fossé de communication entre les différents acteurs des projets logiciels, des analystes métiers et gestionnaires de projet aux développeurs et testeurs.

Les créateurs du UML

Le UML a été développé par trois figures pionnières de l’ingénierie logicielle orientée objet :

• Grady Booch: Connus pour la méthode Booch, qui mettait l’accent sur l’analyse et la conception orientées objet

• James Rumbaugh: Créateur de la technique de modélisation objet (OMT), axée sur la modélisation des données et la structure du système

• Ivar Jacobson: Développeur d’Objectory, qui a introduit le développement piloté par les cas d’utilisation

Ces trois visionnaires se sont réunis chez Rational Corporation, combinant leurs méthodologies complémentaires en une approche unifiée qui deviendrait finalement la norme de l’industrie.

UML : un langage, pas une méthodologie

Il est crucial de comprendre que le UML est unlangage de modélisation, pas une méthodologie de développement logiciel. Bien qu’il fournisse la notation et les sémantiques pour créer des modèles, il ne prescrit pas comment gérer les projets, organiser les équipes ou séquencer les activités de développement.

Un système logiciel comprend de nombreux éléments au-delà du simple code :

Figure 2 : Un système logiciel complet inclut des programmes, une infrastructure matérielle, des personnes, des processus et des documents

Le UML aide à modéliser les artefacts logiciels au sein de cet écosystème plus large, mais ne dicte pas comment construire ou gérer l’ensemble du système. Les organisations combinent généralement le UML à des méthodologies spécifiques telles qu’Agile, en cascade ou le Processus unifié rational (RUP) afin de créer des cadres de développement complets.

---

L’évolution du UML : un voyage historique

Le développement du UML représente l’un des efforts les plus réussis de normalisation dans l’histoire de l’ingénierie logicielle. Son évolution reflète la reconnaissance croissante par l’industrie de la nécessité de standards communs de modélisation.

Chronologie du développement du UML

1993 : Le début
Grady Booch travaillait chez Rational Corporation, en développement et en perfectionnement de sa méthode Booch pour l’analyse et la conception orientées objet. Son approche mettait l’accent sur le développement itératif et des techniques de modélisation complètes.

1994 : Première tentative d’unification
James Rumbaugh rejoint Rational Corporation, apportant avec lui sa technique de modélisation des objets (OMT). La première grande tentative d’unification commence, visant à combiner :

• Les concepts méthodologiques de Booch

• La notation et les techniques OMT de Rumbaugh

• Les cartes CRC (Classe-Responsabilité-Collaboration) pour la conception

Cette collaboration initiale a posé les bases de ce qui deviendrait le UML, bien que la notation résultante évoluait encore.

1995 : Le troisième pionnier rejoint
Ivar Jacobson rejoint Rational Corporation, introduisant sa méthodologie Objectory, fortement axée sur les cas d’utilisation et la conception centrée sur l’utilisateur. La deuxième tentative d’unification, plus complète, a combiné :

• Les concepts et la notation de Booch

• L’OMT de Rumbaugh

• La méthodologie Objectory et l’approche par cas d’utilisation de Jacobson

Cette fusion à trois a été officiellement nommée le Langage de modélisation unifié (UML), marquant une étape importante dans la normalisation de la modélisation logicielle.

1996 : Recherche de reconnaissance industrielle
Rational Corporation a soumis une proposition au Groupement de gestion des objets (OMG), un consortium d’entreprises technologiques axé sur l’établissement de normes industrielles. L’objectif était que le UML soit reconnu comme une norme ouverte et neutre quant au fournisseur, plutôt qu’un produit propriétaire de Rational.

1997 : Normalisation par l’OMG
Le Groupement de gestion des objets a officiellement adopté le UML comme langage de modélisation standard. Cette reconnaissance était cruciale car elle :

• Assurait que le UML resterait ouvert et accessible

• Encourageait l’adoption généralisée par l’industrie

• Empêchait la fragmentation en standards propriétaires concurrents

• Établit une gouvernance pour l’évolution future

2000 : Reconnaissance internationale
L’Organisation internationale de normalisation (ISO) a reconnu la version 1.0 du UML comme norme internationale. Ce soutien mondial a encore renforcé la position du UML en tant que langage de modélisation logicielle de premier plan et facilité son adoption à l’échelle mondiale.

2004 : Mise à jour majeure vers le UML 2.0
Une révision importante a abouti au UML 2.0, qui a introduit :

• Précision et clarté améliorées dans les sémantiques

• Nouveaux types de diagrammes pour des objectifs spécifiques

• Meilleure prise en charge du développement basé sur des composants

• Meilleure alignement avec les pratiques modernes du génie logiciel

• Fondations formelles plus rigoureuses

UML 2.0 représentait une maturité de la langue, en répondant aux limites identifiées au cours des années d’utilisation pratique.

2011 : Dernière version
La version 2.4.1 d’UML a été publiée en août 2011, représentant des améliorations progressives et des clarifications apportées à la spécification 2.0. Cette version continue de servir de norme actuelle, démontrant la stabilité et la maturité de la spécification UML.

Figure 3 : Le chronogramme historique montrant les jalons clés du développement d’UML, du concept initial à la norme internationale

---

Le sens du mot « Unifié » dans UML

Le terme « Unifié » dans le langage de modélisation unifié porte une signification importante, reflétant le périmètre global et la nature intégrative du langage. UML réalise une unification sur plusieurs dimensions :

1. À travers les méthodes et notations historiques

UML a réussi à intégrer trois approches précédemment concurrentes :

• Méthode Booch: Mettait l’accent sur la conception orientée objet avec une notation riche pour les classes et les objets

• OMT (Technique de modélisation des objets): Se concentrait sur la modélisation des données et la structure du système

• Objectory: A introduit les cas d’utilisation et le développement basé sur des scénarios

En synthétisant les meilleurs éléments de chacun, UML a créé une notation plus puissante et plus flexible que chacun de ses prédécesseurs pris individuellement.

2. À travers les phases du cycle de développement

Contrairement aux approches de modélisation antérieures qui se concentraient principalement sur l’analyse ou la conception, UML prend en charge l’intégralité du cycle de vie du développement logiciel :

• Recueil des exigences: Les diagrammes de cas d’utilisation captent les exigences fonctionnelles

• Analyse: Les diagrammes de classes et les diagrammes d’activité modélisent le domaine du problème

• Conception: Les diagrammes de composants et les diagrammes de déploiement spécifient l’architecture

• Implémentation: Les diagrammes de classes détaillés guident la codification

• Test: Les diagrammes d’états soutiennent le développement des cas de test

• Déploiement: Les diagrammes de déploiement montrent la distribution physique

Cette couverture de bout en bout assure la continuité et la traçabilité tout au long du projet.

3. À travers les domaines d’application

UML n’est pas limité à des types spécifiques de logiciels. Il a été appliqué avec succès à :

• Modélisation des processus métiers

• Systèmes embarqués en temps réel

• Applications web

• Systèmes d’entreprise

• Applications mobiles

• Conception de bases de données

• Architectures orientées services

Cette indépendance par rapport au domaine rend UML un outil polyvalent applicable à travers les industries.

4. À travers les langages et les plateformes d’implémentation

Les modèles UML sont indépendants des langages de programmation ou des plateformes spécifiques. Le même diagramme UML peut guider l’implémentation dans :

• Java

• C++

• C#

• Python

• JavaScript

• Et de nombreux autres langages

Cette neutralité linguistique protège les investissements dans la modélisation et facilite la migration entre les technologies.

5. À travers les plateformes de développement

Quel que soit l’outil utilisé par les équipes :

• IDE traditionnelles

• Environnements de développement basés sur le cloud

• Outils spécialisés de modélisation

• Cadres open source

UML fournit une notation cohérente qui dépasse les limites des outils, permettant la collaboration indépendamment de l’infrastructure technique.

6. À travers les concepts internes

UML unifie diverses perspectives conceptuelles sur les systèmes logiciels :

• Vues structurelles: Ce qui existe (classes, objets, composants)

• Vues comportementales: Comment les choses se comportent et interagissent (activités, états, séquences)

• Vues architecturales: Comment les choses sont organisées (paquets, couches, niveaux)

• Vues d’implémentation: Comment les choses sont réalisées (code, bases de données, interfaces)

Cette approche à plusieurs perspectives garantit une couverture complète des préoccupations du système.

---

Applications pratiques : UML en action

Exemple de cas : Développement d’une plateforme de commerce électronique

Pour illustrer comment UML répond aux défis du monde réel, envisagez une entreprise qui développe une nouvelle plateforme de commerce électronique. Voici comment différents diagrammes UML servent des objectifs spécifiques :

Phase de besoins

• Diagrammes de cas d’utilisation: Capturer les interactions des clients (parcourir les produits, ajouter au panier, passer à la caisse)

• Diagrammes d’activité: Modéliser les processus métiers (flux de traitement des commandes)

Phase d’analyse

• Diagrammes de classes: Identifier les entités du domaine (Produit, Client, Commande, Paiement)

• Diagrammes de séquence: Montrer les interactions entre les objets lors de scénarios clés

Phase de conception

• Diagrammes de composants: Définir une architecture modulaire (service de catalogue, passerelle de paiement, système de gestion des stocks)

• Diagrammes de déploiement: Préciser l’infrastructure (serveurs web, clusters de bases de données, CDN)

Support de mise en œuvre

• Diagrammes de classes détaillés: Guide les développeurs avec les attributs, les méthodes et les relations

• Diagrammes d’états-machine: Modélise les cycles de vie complexes des objets (transitions d’état des commandes)

Documentation et maintenance

• Diagrammes de paquetages: Organise la structure de la base de code pour les nouveaux membres de l’équipe

• Diagrammes de communication: Documente les interactions en temps réel pour le dépannage

Grâce à cette approche de modélisation complète, l’équipe maintient une clarté malgré la complexité du système, facilite l’intégration des nouveaux développeurs et crée une documentation vivante qui évolue avec le système.

---

Avantages et limites du UML

Principaux avantages

Standardisation
Le UML fournit un langage commun compris mondialement, réduisant les courbes d’apprentissage lorsque les membres d’équipe changent ou lorsqu’ils collaborent au-delà des frontières organisationnelles.

Précision
Une sémantique bien définie élimine l’ambiguïté qui affecte les spécifications en langage naturel, réduisant les malentendus et les reprises.

Abstraction
Plusieurs types de diagrammes permettent d’observer les systèmes à différents niveaux de détail, allant de l’architecture de haut niveau aux spécificités d’implémentation.

Support des outils
Écosystème étendu d’outils de modélisation propose des fonctionnalités telles que :

• Génération automatique de code

• Ingénierie inverse à partir du code

• Vérification de cohérence

• Intégration au contrôle de version

• Fonctionnalités de collaboration

Détection précoce des problèmes
La modélisation révèle les défauts de conception avant le début de l’implémentation, lorsque les coûts de correction sont minimaux par rapport aux corrections post-implémentation.

Limites reconnues

Courbe d’apprentissage
Maîtriser le UML nécessite un investissement important en formation et en pratique. Les équipes doivent apprendre à la fois la notation et les concepts fondamentaux.

Risque de surconception
Une attention excessive à la modélisation complète peut entraîner une « paralysie par l’analyse », retarder le développement réel et créer des charges de maintenance.

Dépendance aux outils
Bien que le UML lui-même soit indépendant des outils, une modélisation efficace à grande échelle nécessite souvent des outils sophistiqués, ce qui peut entraîner un verrouillage vers un fournisseur.

Pas une solution miracle
Le UML ne remplace pas les bonnes pratiques d’ingénierie, l’expertise du domaine ou la communication efficace. C’est un outil qui amplifie les compétences existantes plutôt que de les remplacer.

Tension avec l’agilité
Certains praticiens agiles considèrent que la modélisation approfondie en amont est contradictoire avec le développement itératif et adaptable, bien que l’utilisation légère du UML puisse compléter efficacement les pratiques agiles.

---

Meilleures pratiques pour l’adoption du UML

Basées sur des décennies d’expérience industrielle, plusieurs meilleures pratiques se sont dégagées pour une utilisation efficace du UML :

1. Adapter l’échelle de votre modélisation

Créez des modèles proportionnels à la complexité du système et au risque du projet. Les systèmes simples nécessitent des modèles simples ; les systèmes complexes justifient une modélisation complète.

2. Concentrez-vous sur la communication

Souvenez-vous que les modèles existent pour faciliter la compréhension. Privilégiez la clarté plutôt que la complétude, et adaptez les diagrammes à votre public.

3. Maintenez des modèles vivants

Maintenez les modèles synchronisés avec l’implémentation grâce à des mises à jour régulières, à la génération automatisée lorsque possible, et en traitant les modèles comme des artefacts de première importance.

4. Utilisez plusieurs points de vue

Utilisez différents types de diagrammes pour répondre aux préoccupations de différents parties prenantes. Aucun type de diagramme unique ne capture tout.

5. Itérez et affinez

Commencez par des croquis sommaires, affinez-les en fonction des retours, et faites évoluer les modèles au fur et à mesure que la compréhension s’approfondit. La perfection n’est pas l’objectif ; l’utilité l’est.

6. Intégrez avec la méthodologie

Intégrez le UML à votre méthodologie de développement choisie, qu’il s’agisse d’Agile, de Waterfall ou d’approches hybrides, en adaptant les pratiques à votre contexte.

7. Investissez dans la formation

Assurez-vous que les membres de l’équipe comprennent à la fois la notation UML et les principes de modélisation. Des modèles mal construits peuvent induire en erreur plutôt que de clarifier.

Visual Paradigm : Pont entre les objectifs métiers et la mise en œuvre technique grâce au UML

Modélisation UML 2.x complète

• Diagrammes structurels : Inclut les diagrammes de classe, d’objet, de composant, de déploiement, de paquetage et de structure composite.
• Diagrammes comportementaux : Couvre les diagrammes de cas d’utilisation, de séquence, d’activité, de machine à états, de communication, de temporisation et d’aperçu des interactions.

Ingénierie du code et synchronisation

• Ingénierie en boucle fermée : Les utilisateurs peuvent générer du code directement à partir des modèles de classes UML. Inversement, les mises à jour du code source poussent automatiquement les modifications vers le modèle visuel.
• Prise en charge de plusieurs langages : La plateforme prend en charge l’ingénierie ascendante et descendante pour une large gamme de langages, notamment Java, C#, C++, Python, PHP, Ruby et VB.NET.
• Intégration à l’IDE : Visual Paradigm peut être intégré en tant que plugin directement dans des environnements de développement intégrés (IDE) populaires tels qu’IntelliJ IDEA, Eclipse, NetBeans, Visual Studio et Android Studio.
• Génération de code de séquence : Les équipes peuvent étudier le comportement en temps réel des applications en effectuant une ingénierie inverse de diagrammes de séquence UML fonctionnels directement à partir de la logique du code Java actif.

Générateur de diagrammes intégré à l’IA

• Langage naturel vers UML : Les utilisateurs peuvent interagir avec un chatbot d’IA pour décrire la logique du système. L’IA interprète ces exigences et cartographie instantanément les entités, les relations et les éléments.
• Flux de travail avec IA : Le système fournit des flux de travail guidés pour applications web afin de modifier dynamiquement, mettre à jour et valider la syntaxe des diagrammes complexes.

Disposition efficace et gestion du modèle

• Catalogue des ressources : Cet outil d’efficacité permet aux utilisateurs de créer rapidement des formes et de valider automatiquement les connexions entre les éléments afin d’éviter les erreurs de syntaxe.
• Réutilisabilité des éléments : Un seul élément de modèle peut être réutilisé dans plusieurs vues et diagrammes distincts tout en conservant ses propriétés universelles.
• Traçabilité du modèle : Le système suit les effets en cascade à l’aide de sous-diagrammes et de « Modèles Transitors », permettant aux utilisateurs de voir comment une modification dans un emplacement affecte les composants connectés ailleurs.

Espace de travail agile et collaboration

• Collaboration en cloud : Plusieurs membres d’une équipe peuvent simultanément co-créer des architectures de systèmes complexes tout en gérant des historiques de versions automatiques et des fusionnages.
• PostMania : Une plateforme de boucle de retour qui permet aux parties prenantes internes et externes de partager, discuter et fixer des commentaires directement sur des actifs visuels en ligne.
• Cartographie des histoires et listes de tâches : L’outil relie directement les diagrammes UML aux cartographies des histoires utilisateur, aux listes de tâches des sprints, aux gestionnaires de tâches et aux tableaux Kanban.
• Rapports à la demande : Un concepteur de documents par glisser-déposer génère des maquettes système professionnelles au format Word, PDF ou HTML.

Éditions disponibles

• Édition Communautaire (Bureau) : Complètement gratuit à usage non commercial, offrant une modélisation UML 2.x de base hors ligne.
• Visual Paradigm en ligne (Édition gratuite) : Une alternative web sans installation offrant des limites illimitées sur les formes pour les diagrammes de base avec synchronisation Google Drive.
• Niveaux commerciaux payants : Les abonnements vont du package « Modeler » aux niveaux d’entreprise qui débloquent une rétro-ingénierie avancée du code, l’ingénierie de base de données d’équipe et des espaces de projet agile complets.

---

Conclusion

Le langage de modélisation unifié représente une réalisation remarquable dans la standardisation du génie logiciel, offrant un vocabulaire commun qui a transformé la manière dont les organisations abordent le développement de systèmes complexes. Depuis ses origines au milieu des années 1990, grâce aux efforts collaboratifs de Booch, Rumbaugh et Jacobson, jusqu’à sa reconnaissance comme norme internationale, UML a prouvé sa valeur dans de nombreux secteurs et domaines d’application.

Comprendre les modèles comme des représentations simplifiées qui captent les aspects essentiels tout en filtrant le bruit est fondamental pour tirer pleinement parti de UML. Les modèles remplissent plusieurs fonctions critiques — de la capture des exigences à l’accompagnement de la pensée de conception, en passant par la gestion de l’information dans les grands systèmes et l’exploration économique de solutions. Ces avantages expliquent pourquoi la modélisation est devenue indispensable dans l’ingénierie logicielle moderne.

La nature « unifiée » de UML — qui englobe les méthodes historiques, les phases de développement, les domaines d’application, les technologies d’implémentation et les perspectives conceptuelles — la position de manière unique pour répondre aux défis multifacettes du développement logiciel contemporain. Bien qu’elle ne soit pas sans limites, et certainement pas un substitut au jugement ingénieur solide, UML fournit des outils puissants pour maîtriser la complexité lorsqu’elle est appliquée avec réflexion et à l’échelle appropriée.

Alors que les systèmes logiciels continuent de gagner en sophistication, les principes incarnés par UML restent de plus en plus pertinents. Que vous entrez dans votre premier projet de modélisation ou que vous cherchez à affiner vos pratiques existantes, comprendre les fondements, l’évolution et l’application appropriée de UML renforcera votre capacité à concevoir, communiquer et livrer des solutions logicielles réussies. Le parcours allant des exigences abstraites à l’implémentation concrète devient plus gérable, plus prévisible et finalement plus réussi lorsqu’il est guidé par des modèles bien conçus.

L’avenir de la modélisation logicielle pourrait apporter de nouvelles notations et outils, mais les insights fondamentaux que UML codifie — la valeur de l’abstraction, l’importance de multiples perspectives et la puissance de la communication standardisée — perdureront comme des principes intemporels d’une ingénierie logicielle efficace.

---

Références

Cette publication est également disponible en Deutsch, English, Español, فارسی : liste des langues séparées par une virgule, Bahasa Indonesia : dernière langue.