III. Nous pouvons
être tous développeurs
1. Le logiciel
A. La génération
de code
Nous allons voir deux exemples de projet qui vont permettre de
générer du code via l'ingénierie dirigée par les
modèles. Pour rappel l'idée est de générer du code
à partir de modèles que nous allons au préalable
créer. Comme vu dans l'état de l'art, il y a deux langages de
modélisation: le MDA via l'UML et le DSML. Nous allons traiter un
exemple pour chacun, et voir que créer un programme peut être
à la portée de tous, et ce même dès aujourd'hui.
Exemple d'un projet avec UML
Nous allons traiter le cas d'une application que nous
appellerons "QCM".
QCM est une application de passages d'examens de type
"questions à choix multiples" en ligne et possède deux aspects
:
· Système côté enseignants
· Système côté étudiants
Ainsi, les professeurs peuvent, à partir de fichiers
XML ou en revisitant les anciens QCM, créer des QCMs pour évaluer
le niveau de leurs étudiants.
Les étudiants de leur côté, sont
prévenus par l'administration qu'un compte leur est affecté sur
le programme et leur fournis leur identifiant afin de procéder à
la validation de celui-ci.
Ces jeunes diplômants peuvent ainsi, lorsqu'ils entrent
dans la période de passage d'un QCM d'un des modules suivis, se
connecter au site et passer leur examen en ligne pendant un temps défini
par le créateur du QCM.
Une fois la date de passage du QCM arrivée à
échéance, les notes peuvent être récoltées
par le professeur et s'il le désire, envoyées aux
étudiants. Les étudiants peuvent, quant à eux, visualiser
les réponses aux QCMs qu'ils ont passé et savoir où ils
ont commis des erreurs.
Pour traiter ce sujet, nous avons les étapes classiques
d'un projet : recueil des besoins, modélisation, etc. Les modèles
vont nous permettre de générer du code. A la fin du projet nous
avons une synchro entre le code et les modèles, sous prétexte que
le code n'ait pas été modifié par un
développeur.
Dans un premier temps, dans un souci de communication nous
commençons par un diagramme de Use Case (ou cas d'utilisation), qui est
très parlant pour tout le monde.
Figure 23 : Etape 1, le point de vue fonctionnel (Use
Case)
Dans notre cas, tout accès à QCM
nécessite une authentification. Il y a deux types d'authentification :
soit professeur, soit étudiant. Un professeur pourra créer un
QCM, gérer les notes et collecter des réponses. Un
étudiant pourra quant à lui passer un QCM et le consulter.
La deuxième étape consiste à passer au
point de vue structurel avec des diagrammes de classes. Cela va permettre de
présenter les classes et les interfaces du système ainsi que les
différentes relations entre celles-ci. Avec ceci nous avons des
"classes" et des "associations" au lieu de "widget", "menu", "champs". Il y
également une notation graphique sans aucun lien avec le domaine,
l'utilisateur manit ainsi des noms qui lui parlent, ce n'est pas du code
incompréhensible qu'il doit manipuler.
Figure 24 : Etape 2, diagramme de classe
Ensuite vient le point de vue comportemental via le diagramme
de séquences, qui permet à l'utilisateur d'avoir une
représentation graphique des interactions entre les acteurs et le
système selon un ordre chronologique.
Figure 25 : Etape 3, diagramme de
séquence
Par le biais de ces trois étapes, nous avons fait le
strict minimum niveau modélisation pour pouvoir générer du
code. Cela se fait par un simple clic :
Figure 26 : Etape 4, générer du code via
la modélisation
Nous avons même plusieurs choix de langage concernant la
génération. Nous nous en tiendrons au Java. Vous pouvez voir un
exemple de génération de code en Annexe 3 concernant la partie
Utilisateurs de l'application. Seulement nous pouvons voir sur cette annexe,
qu'avec cette technique, le corps des méthodes reste vide. Pour cela, il
y a deux solutions : soit spécifier le corps des opérations avec
les activités et actions UML 2.0 soit associer des notes aux
opérations contenant le code des opérations.
Figure 27 : Un exemple de notes.
L'association de notes nécessitent des connaissances en
programmation, nous ne l'expliquerons pas davantage.
L'idée, avec le diagramme d'activité c'est de
pouvoir en faire pour chaque opération du diagramme de séquence.
Ainsi chaque action du diagramme de séquence saura quand se
déclencher et quand s'arrêter. Le tout pourra être ainsi
interprété par le générateur de code et être
retranscrit.
Beaucoup d'outils UML permettent la génération
de code tels que :
· EclipseUML
· JDeveloper
· MagicDraw UML
· ModelSphere
· Objecteering
· PowerAMC
· QDesigner
· Visual Paradigm
· Visual UML
Ces outils permettent la création de langage de
modélisation et de suite outillée dans leur environnement
respectif (Eclipse par exemple). Ils permettent de créer des
modèles et des méta-modèles, générer des
bibliothèques permettant la manipulation de modèles. Tout ceci
grâce à des facilités dédiées
(transformation, éditeur graphique, vérificateur de contraintes,
...).
| 
