Thématiques principales

jeudi 14 décembre 2017

Supervisory Control Theory

Introduction

Supervisory Control Theory ou théorie de la supervision des systèmes à évènements discrets introduit par P.J.Ramadge et W.M.Wonham [1] se base sur la théorie des langages et des automates [10]. Elle définit l’utilisation de trois entités : le SED, une spécification souhaitée et un superviseur. Cette théorie définit la possibilité de synthétiser un modèle de superviseur dit valide à partir du modèle du SED et de la spécification. Le premier objectif de cette démarche est de fiabiliser un système susceptible d’avoir un comportement qui peut être gênant ou dangereux. Le deuxième objectif est la possibilité pour un système dit ouvert, dont les comportements possibles sont multiples, de réaliser différents superviseurs dont les rôles seront de contraindre le système dans un comportement donné pour un contexte donné.

Principe de la théorie de la supervision

La théorie  de la supervision définit que ces trois entités, le SED, la spécification souhaitée et le superviseur sont modélisés par leurs langages conformément à la théorie des langages et des automates. Ceci permet de bénéficier des opérations liées aux langages et aux automates à états finis puisque les langages utilisés sont des langages réguliers. Dans l’ensemble de ce chapitre, ces entités sont considérées comme des automates notés G pour le système, K pour la spécification et S pour le superviseur de langage respectif L(G), L(K) et L(S).


Idéalement, le superviseur, une fois réalisé, est composé avec le SED pour former le système supervisé. A chaque changement d’état du système, le superviseur va suivre l’évolution du système et lui notifier l’ensemble des évènements qu’il est autorisé à générer (figure 35). Cependant, deux situations prises en compte par la théorie peuvent survenir. La première est que certains évènements, par nature, ne peuvent pas être interdits. La seconde situation est que certaines transitions du système ne peuvent être vues par le superviseur, l’empêchant de fournir un ensemble d’évènements autorisés cohérent. Ces deux situations sont définies dans la théorie de la supervision sous les notions de commandabilité et d’observabilité. Ainsi, un alphabet  est divisé en plusieurs ensembles notés c pour l'alphabet des évènements commandables, uc l'alphabet des évènements non commandable, o l'alphabet des évènements observables et uo l'alphabet des évènements non observables tel que

ce qui signifie qu'un évènement peut être à la fois non commandable et non observable, commandable et non observable, observable mais non commandable ou enfin commandable et observable. Ces notions de commandabilité et d'observabilité sont très importantes car elles vont conditionner les limites du superviseur et sa réalisation. De nombreux travaux approfondissent ces notions dans [1], [3], [5], [6].
Pour la réalisation du système supervisé, la théorie de la supervision définit que le modèle du superviseur, donc le langage L(S), peut être concrétisé par une fonction ou une table d'associations qui à une séquence d'évènements donnée renvoie une liste d'évènements autorisés. Une autre approche, illustrée par la figure 36, utilise l’intersection (ou le produit strict pour les automates) du langage du système et celui du superviseur afin d’obtenir le langage du système supervisé. Ainsi, le modèle du système supervisé est obtenu par:





La théorie de la supervision définit enfin la notion de superviseur bloquant par L(S/G)=Lmpréf(S/G).

Définition d'une spécification

La définition de la spécification est l'opération la plus difficile pour la théorie de la supervision car celle-ci doit répondre à différents critères afin d'être utilisable pour la génération du superviseur [1], [9]. Le but de la spécification est de définir le comportement du système bouclé, ainsi, si K est un automate décrivant la spécification valide, il faut avoir L(K)=L(S/G), comme illustré par la figure 37.




Pour cela, une méthode consiste à définir une première spécification par un automate E en considérant le comportement global voulu en s'intéressant à tous les évènements présents dans le système. Il est possible de réaliser l'opération de produit synchronisé de façon à obtenir L(K) qui sera égal à l'intersection de L(E) et de L(G), comme illustré par la figure 38.




Une autre méthode permet de définir le comportement voulu en ne considérant que certains évènements. Cependant, la spécification E doit être augmentée afin de correspondre au système. Ainsi, l'opération de produit synchronisé permet d'obtenir cette spécification (illustré par la figure 39). Cette méthode a pour avantage d’être simple mais elle implique une attention particulière aux évènements non utilisés pour la définition de E à cause du produit synchronisé qui va augmenter son langage.





L’opération de produit synchronisé est alors utilisée dans les deux cas tels que : K=G||sE car dans la première approche cela amène à faire un produit strict puisque E et G ont le même alphabet, dans la deuxième approche, cela va permettre l'augmentation du langage de E sur la considération du comportement intrinsèque de G. Enfin, il est nécessaire de valider la spécification K obtenue pour le système en vérifiant que celle-ci est non bloquante.

Une autre approche est de définir un automate qui invalide une séquence donnée. Ainsi, un automate est réalisé pour modéliser cette séquence dont tous les états sont marqués sauf le dernier qui représente la survenue de l'évènement qui réalise la séquence comme illustré par la figure 40. Ceci permet de réaliser des spécifications ciblées pour certains cas précis.





Il faut retenir que la théorie de la supervision ne fait pas état de méthode générique pour la définition de spécification. Chose qui n'est d'ailleurs pas son objectif puisque son but n'est que la synthèse d'un superviseur par la validation de la spécification K souhaitée sur le principe du blocage et de l'inclusion dans le langage de SED G. La réalisation d'une spécification reste donc un problème dans la démarche de synthèse de superviseur.

Synthèse du superviseur

La spécification étant définie, la synthèse du superviseur selon [1], [10] s’effectue par le produit du système G et de la spécification K suivi de l’opération Trim. Ceci est la base de la démarche pour la synthèse du superviseur mais elle ne prend pas en compte les aspects liés à la commandabilité et à l’observabilité des évènements. Cette opération de base s’explique par la relation

qui existe entre le superviseur, la spécification et le système, comme ré-illustré par la figure 41. Cette relation signifie que la spécification est l’objectif du système supervisé par l’égalité L(S/G)=L(K). Elle signifie également que le  langage du superviseur ne se limite pas nécessairement au langage de la spécification.




Commandabilité et Observabilité dans la synthèse du superviseur

Les notions de commandabilité et d’observabilité du superviseur pour le système sont liées aux événements commandables et observables. La nature de ces événements amène des particularités dans la relation entre le système et le superviseur lors de la supervision. Les événements non commandables ne peuvent pas être interdits par le superviseur et le système sera toujours susceptible de les réaliser. Les événements non observables ne permettent pas au superviseur de suivre l’évolution du système de manière cohérente. Le superviseur est alors susceptible après la survenue d’un évènement non observable de fournir une commande erronée.

Problèmes liés à la commandabilité

Comme il a été dit précédemment, les évènements non commandables ne peuvent pas être interdit pas le superviseur. Cette particularité, si elle n’est pas prise en compte lors de la synthèse amène à la réalisation d’un superviseur qui composé avec le système sera susceptible de violer la spécification comme illustré par la figure 42.



Pour prendre en compte cette particularité, la spécification est alors l’élément sur lequel vont intervenir les éventuelles corrections pour que la synthèse donne un superviseur commandable. La théorie de la supervision définit alors une spécification comme étant commandable si


Si la spécification n’est pas commandable, alors la théorie de la supervision définit qu'il existe un langage suprême commandable L(K') inclus dans L(K) qui est commandable (illustré par la figure 43). Ce langage est obtenu à l’aide de l’algorithme de Kumar [5]. Cet algorithme identifie dans l’automate K les états à partir desquels, dans le système, des évènements non commandables sont susceptibles d’être générés.



Problémes liés à l’observabilité

La notion d’observabilité caractérise les évènements de l’alphabet selon deux types, les évènements observables et les évènements non observables. Lors de la supervision, à chaque changement d’état du système, le superviseur, par la lecture de l’évènement qui vient d’être réalisé, est mis à jour afin de produire un nouvel ensemble d’évènements autorisés. Lors de la survenue d’un évènement non observable, le superviseur n’est pas notifié du changement d’état du système et n’est pas capable de fournir un ensemble d’évènements autorisés cohérent. Pour cela, la théorie de la supervision impose que la commande souhaitée pour le système soit la même avant et après un évènement non observable sinon le superviseur synthétisé sera non observable et la spécification risque alors d’être violée comme l’illustre les figures 44 et 45.

Exemple:
En considérant "c" comme étant non observable, si l'état 4 est interdit dans le système G alors il y a un problème d'observabilité dans la spécification K qui définit une commande différente avant et après l’évènement non observable. Un superviseur ne pourra donc pas savoir s'il se trouve dans l'état 1 ou l'état 3.








La théorie de la supervision caractérise alors la spécification K comme étant observable si elle permet la synthèse d’un superviseur observable. Si K n’est pas observable alors, contrairement à la notion de commandabilité, il n’existe pas de langage suprême observable qui puisse être calculé. Dans pareil cas, il est nécessaire de se rattacher à la notion de normalité.

Normalité et observabilité

La normalité, c’est l’invariance d’un langage par rapport à un autre suivant un alphabet donné. La normalité permet de vérifier qu’un langage prend en compte tous les évènements contenus dans un alphabet pour un autre langage. Dans le cadre de la théorie de la supervision, la normalité est rapprochée de l’observabilité en définissant l’alphabet intéressant comme étant celui des évènements non observables. Ainsi, la spécification K est définie comme normale pour le système G et pour les évènements non observable si :

La notion de normalité décrite dans [1] et [11] est très pratique car elle permet d'assimiler la notion d'observabilité. En fait, si un langage est normal alors il est observable et de plus il est possible de la même manière que pour la commandabilité de construire un langage suprême normal (cf. algorithme de Kumar [5]) si K n'est pas normal. A cela, il faut tout de même observer quelques restrictions, c'est à dire qu'il faut considérer les évènements non observables comme étant non commadables et ainsi il y a équivalence entre observabilité et normalité.

Supervision modulaire

La supervision modulaire, illustrée à la figure 46 et définie dans [1], [6], [11], [12] a pour intérêt de diviser le problème de la définition de la spécification en plusieurs modules. Pour un système G, n spécifications K seront définies qui permettront la génération de n superviseurs. Ceci permet de limiter la taille et la complexité de la spécification globale si plusieurs objectifs de commandes sont à réaliser. L'intersection des n superviseurs donnera alors le superviseur global. Les spécifications ne doivent pas être en conflit sinon le superviseur sera bloquant. Ainsi, si pour K1 et K2, deux spécifications, l'égalité

 
est respectée alors elles ne sont pas en conflits. Si K1 et K2 sont commandables alors leur intersection l'est aussi sinon leur langage suprême commandable l'est. Pour l'observabilité, il faut utiliser la notion de normalité afin d'obtenir un langage normal pour que le superviseur soit observable.


Supervision décentralisée

La supervision décentralisée [1], [11], [12], illustrée à la figure 47, propose de voir le système sous plusieurs points de vues locaux (en utilisant la projection) et de définir pour chaque point de vue une spécification restreinte afin de générer un superviseur local. Chaque superviseur aura la responsabilité de la gestion d'un sous-ensemble de l'alphabet du système, ces différents sous-ensembles de l’alphabet ne devant pas avoir d’intersection non vide sans un risque de conflit entre les différents superviseurs. Pour le superviseur généré en local, la supervision du système G revient à considérer les évènements supprimés par la projection comme non observables. Il ne va donc s'intéresser qu'à l'aspect du système pour lequel il a été conçu.





La conjonction des différents superviseurs va être réalisée par l'intersection des différents superviseurs en ayant réalisée une projection inverse sur l'ensemble de l'alphabet afin de préserver leurs comportements respectifs. Il faut cependant rester prudent car, si par l'utilisation de la supervision décentralisée il est possible de simplifier localement le problème en plusieurs sous système, la supervision ne prendra pas en compte les interactions possibles entre ces sous systèmes et ces dernières ne pourront pas être supervisées.

Conclusions

La théorie de la supervision donne un cadre théorique idéal pour la modélisation et la commande de systèmes à évènements discrets par la génération d'un superviseur valide en prenant en compte de nombreux aspects susceptibles de poser des problèmes tels que ceux liés aux événements non commandables ou non observables. Ceci reste un cadre théorique qui ne prend pas en compte les problèmes liés à l'implantation d'un superviseur dans un environnement d’exécution. Cet environnement n’est pas défini dans le cadre théorique de la supervision mais importe pourtant dans la réalisation de modèles de SED cohérents et dans la manière dont le ciblage sera effectué. Pour cela, l'ingénierie dirigée par les modèles propose une approche pour la définition et la transformation de modèles et établit alors comment réaliser et cibler un système supervisé dans un environnement d'exécution spécifique.

Références


[1] Ramadge P.J., Wonham W.M. The control of discrete-event systems. IEEE Transactions on Automatic Control, 1989, Vol. 77, N° 1, p. 81-98.

[3] V. K. Garg, R. Kumar, S. I. Marcus. On controllability and Normality of discrete event dynamical systems. Systems and control letters, 1991, Vol. 13, N°3, p. 157-168.

[5] R. Kumar, M. A. Shayman. Formulae relating controllability, observability and Co-observability. Automatica, 1998, Vol. 34, p. 211-215.

[6] H. Flordal. Modular controllability verification and synthesis of discrete event systems, Mémoire de these, Chalmers University of Technology, 2001.

[9] A. Overkamp, and J. H. van Schuppen. Control of discrete event systems. Amsterdam (NL), Stichting Mathematisch Centrum, 1994 p. 453-467.

[10] C. G. Cassandras, and S. Lafortune. Introduction to discrete event systems, Kluwer Academic Publishers, 1999, ISBN: 0-7923-8609-4.

[11] M. H. Lamouchi. Synthèse de superviseur pour des systèmes à évènements discrets partiellement observés,  Mémoire de thèse, Université de Montréal, département de génie électrique et de génie informatique de l'école polytechnique de Montréal, 2002.

[12] B. Gaudin. Synthèse de contrôleurs sur des systèmes à évènements discrets structurés. Mémoire de thèse, Université de Rennes, Institut de Formation Supérieure en Informatique et Communication, 2004.

dimanche 10 décembre 2017

Maven : Introduction

Qu'est ce que Maven ? Je vais vous en faire un résumé rapide mais pour ceux qui veulent une bible et de details, consulter ce livre.

Généralités

Maven est un gestionnaire de build ou constructeur de projet. Il est open source et soutenu par la fondation Apache. Maven a pour but de simplifier, rationaliser et automatiser la construction d'un projet sur l’ensemble de ses phases et activités de façon a garantir la qualité de no build.

Initialement orienté pour les projet Java, Maven est maintenant capable de construire des projets de tout type de nature, c++, Python, etc....

Ainsi, et c'est sa fonction première, Maven va permettre de compiler le code de notre application, ceci en fournissant des moyens de gestion simple pour les dépendances du projet. Cependant, s’arrêter a cela, serait hyper réducteur car Maven a plus la vocation de couvrir tout le périmètre de build.

En fait avec Maven, il est possible de:
  • préparer la compilation (en générant du code par exemple) 
  • effectuer la compilation
  • exécuter des tests unitaire, 
  • faire de l'analyse de code,
  • faire du packaging (construction de jar, war, tar.gz ou même des deb) 
  • exécuter des procédures d'installation sur des plateformes spécifiques de tests, exécuter des tests fonctionnels (avec roboframework par exemple)
  • préparer un livrable
  • générer differentes doc (technique ou utilisateur)
  • etc... car il est possible d'adjoindre des plugins supplémentaires pour compléter son fonctionnement.
Tout ceci concerne les activités directement lié au build de notre projet mais avec maven, il sera aussi possible d'aller plus loin en permettant la constitution de processus plus générique autour de la gestion du projet comme :
  • la construction automatique de template de projet
  • la gestion de multi-projet, de leurs dépendances et de leur orchestration dans un même process
  • la gestion d'un cache local de vos dépendances
  • la gestion des builds passés sous la forme de SNAPSHOT et de RELEASE
  • du deployement de documentation web en ligne

Configuration

Maven s'articule autour d'un runner que l'on telecharge ici. Je ne vais pas rentrer dans le details de l'installation de Mave, mais celle-ci se résume globalement a spécifier convenablement JAVA_HOME qui exécutera Maven. (Attention, ce dernier n'est pas forcement celui employé pour la compilation). On pourra specifier ce JAVA_HOME directement lors de l'appele de Maven en faisant un alias par exemple sous unix/cygwin.

Il est ensuite nécessaire de configurer ce que l'on appelle les Settings. Ce setting est constitué de deux fichiers, le fichier système présent dans le répertoire conf de Maven et un fichier utilisateur présent dans le répertoire .m2 de l'utilisateur courant.

Comme on peut se le douter, le setting système permet de configurer Maven pour toutes ses utilisations alors que celui de l'utilisateur sera spécifique au compte utilisateur lançant le processus Maven. (la commande mvn, que nous verrons plus loin)

L'ordre de chargement de ces settings se réalisera toujours dans le sens Systeme puis Utilisateur, le dernier chargé faisant fois de sa configuration en cas de conflits. A noter qu'il est possible de spécifier un setting lors du build afin de personnaliser celui-ci avec l'option -s

Le settings est le fichier de configuration dans lequel seront définis les variables d’environnement locales (comme les differentes versions Java installées sur la machine),  les repositories de dépendances (artifactory ou nexus, SNAPSHOT ou RELEASE), les serveur web, des serveurs de base de données, des server de vérification de code (Sonar par exemple) , des secrets éventuels pour s'y connecter, etc.... en fait toute configuration et ressource spécifique a l'environnement de build, utilisable non directement par les projets.

Par convention (unix) on build dans un compte spécifique (maven par exemple) et on initialise ces données dans le settings utilisateur, le settings système étant réservé aux configurations partagées.

Par exemple un settings spécifiant les variables pour la compilation en java 6, 7 ou 8, les variables pourront alors être utiliser dans les pom.xml des projets (nous verrons par la suite ce que sont les pom):


<?xml version="1.0" encoding="UTF-8"?>
<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0" 
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
          xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">
  <localRepository>/home/m2Repo</localRepository>
  <profiles>
    <profile>
      <id>compiler</id>
        <properties>
          <JAVA_1_6_HOME>jdk1.6.0_33_win_x64</JAVA_1_6_HOME>
          <JAVA_1_7_HOME>jdk1.7.0_80_win_x64</JAVA_1_7_HOME>
          <JAVA_1_8_HOME>jdk1.8.0_66_win_x64</JAVA_1_8_HOME>
        </properties>
    </profile>
  </profiles>  
  <activeProfiles>
    <activeProfile>compiler</activeProfile>
  </activeProfiles>
</settings>


Ici nous avons spécifique un répertoire différents du répertoire par défaut du repository maven locale qui permet a Maven de stoker toutes les dépendances dont il aura besoin lors des builds (nous verrons également ce point par la suite)

Dans ce cas ci, nous n'utilisons pas de repository distant permettant a Maven de resoudre les dépendances manquantes de son repository locale. Nous sommes donc dans une configuration hors-ligne. Donc si lors du build Maven, il manque une dépendance dans le repository locale, Maven finira en echec.

Pour permettre a Maven de résoudre des dépendances manquantes et de les mettre dans son repository locale, on ajoutera le serveur central Maven :


<profile>
  <id>securecentral</id>
  <!--Override the repository (and pluginRepository) "central" from the
     Maven Super POM -->
  <repositories>
    <repository>
      <id>central</id>
      <url>https://repo1.maven.org/maven2</url>
      <releases>
        <enabled>true</enabled>
      </releases>
    </repository>
  </repositories>
  <pluginRepositories>
    <pluginRepository>
      <id>central</id>
      <url>https://repo1.maven.org/maven2</url>
      <releases>
        <enabled>true</enabled>
      </releases>
    </pluginRepository>
  </pluginRepositories>
</profile>


Processus Maven

Maintenant que Maven est configuré (sommairement) intéressons nous aux processus de build en lui-même.

Nous l'avons vu précédemment, Maven répond a un grand nombre de besoin, son processus va s'appuyer sur de nombreux plugin décrits sur cette page qui vont interagir afin de procéder a l’exécution de tout ou partie du cycle de vie.

Le cycle de vie Maven est ce que l'on pourra appelé complet. Il se compose d'un cycle par défaut contenant les processus de compilation, test, packaging et déploiement précédé optionnellement d'un cycle de nettoyage des projets et suivi optionnellement d'un cycle de génération de site documentant les projets.




Ainsi via l'appel de la commande mvn (répertoire bin de Maven) et en se plaçant dans notre projet, il sera alors possible de faire appel a un processus déroulant les phases décrites par le schéma ci dessus. A noter que les deux cycles de vie optionnels clean et site ne seront déroulés que si appeler explicitement via la commande Maven alors que le cycle de vie Default sera de toutes façon exécuter jusqu’à l’étape (ou phase dans le jargon Maven) explicitement appelée

Ainsi, la commande


$ mvn compile 


exécute les phases validate a compile du cycle default, tandis que


$ mvn clean test


exécute toutes les phases du cycle clean et les phases validate a test du cycle default.

Ainsi, la commande


$ mvn clean deploy site-deploy


exécute toutes les phases, mais ce ne sera pas forcement une bonne idée....

Mais on a parler de plugins ? qu'est ce que c'est?

Et bien tout le processus présenté ci dessus est la modélisation des activités classiques auxquelles les builds vont répondre. Cependant, on peut facilement imaginer que d'un projet a l'autre les builds ne vont pas s'appuyer sur les même concepts selon les phases. Ainsi tout bêtement la compilation d'un projet Java ne sera pas la même chose qu'une compilation d'un projet C++. De même, certains projets vont s'appuyer sur des configurations differentes de packaging, de compilations, de test. Et même sur des projets relativement semblables, des choix technologiques peuvent amener des outils différents.

Face a cette richesse de besoin et de possibilité, Maven a adopté le principe du : voici un plugin implémentant le comportement par défaut pour le cas le plus général et si le plugin ne correspond pas, est bien il existe des moyens de créer les siens (nous reviendrons sur ce point dans un autre article).

Ainsi pour que pour chaque phase soit proposée  les outils et les moyens de configuration adaptés, Maven va s'appuyer sur ces fameux plugins pour donner une implémentation et une opérationnabilité liés aux spécificités de chaque projet. Le plugin selon le cas sera configuré difficilement ou simplement substitué par un autre, voir même parfois ajouter et exécuté parallèlement.

Pour une liste exhaustive de l'ensemble des plugins "standard" utilisable je vous invite a consulté cette page. Cela donnera une idée des possibilités par défaut, et les plugins utilisables selon les phases des cycles de vie Maven.

Il manque maintenant un dernier élément a tout cela. Comment donner a Maven la carte des plugins a utiliser pour son cycle de vie et leur configuration? Le POM!

Project Object Model

Le POM ou fichier pom.xml est ce qui permet à Maven de connaitre le comment builder le projet courant.

Il va en exister de différents types, si l'on veut suivre de bonnes pratiques Maven, on va s'appuyer sur le pattern parent/module/projet (décrit aussi dans cet article):

  • Des pom projet supportant la production d'un composant logiciel spécifique de type jar, deb, ear, etc... Il s'agit de ce que l'on peut considérer comme étant la composante Maven qui nous vient en premier a l'esprit. Ce pom va donc définir les variables locales au projet, les processus spécifiques nécessaire à la compilation du composant, les dépendances et ou encore de quel pom parent le projet va hériter.
  • Des pom parent qui ont pour but de factoriser des comportements standard de build dont vont heriter des pom projets . Dans ces pom on trouvera alors l'ensemble des spécificités propre à des familles de projets partageant des processus ou des propriétés de compilation commune.
  • Des pom module permettant d'orchestrer la construction d'un ensemble de projets techniquement interdépendant en les agrégeant.

Attention un POM se définit en XML, de ce fait, ce dernier est conforme a ce que l'on appelle un schéma (XSD) pour en structurer les informations a la manière d'une grammaire. Ainsi, tous les types de pom se base sur le même XSD amenant souvent a des utilisations fusionnées des précédents concepts présentés. Alors bien sur, Maven aurait pu simplement définir des XSD différent pour répondre aux différents types. Le choix a été fait de ne pas brider leur utilisation et de permettre malgré tout quelques digressions. Quelques digressions ne signifie pas que cela doit être une généralité car suivre le pattern parent/module/projet permet largement de couvrir 90% des cas d'utilisation. Et comme dans tous les cas d'utilisation des patterns, si vous faites autrement, c'est que vous avez une vraie bonne raison technique (et pas une raison du type : on livre demain...)

Pour avoir une illustration plus précise de cette décomposition, je vous invite a consulter cette question sur stackoverflow. Elle traite bien de la question et nous ramène comme souvent au problème de la division des préoccupations et des besoins comme en POO et ce selon la complexité du problème. En effet, dans un cas simple, on préférera avoir un POM projet classique.... ensuite lorsque les projets commenceront a se multiplier un peu on décidera de construire un POM parent pour factoriser les propriétés et donc on y déposera également une définition des modules à construire (la liste des POM projets). Finalement, lorsque l'on aura des projets dont les POM parent n'auront plus de points communs et qu'il faudra les diviser, alors on placera des POM modules afin d'orchestrer le ou les builds possibles pour les lots de projets a gérer...

Ainsi rien que par cet exemple, certes, on se rend compte que progressivement on en arrivera de toute façon a tendre vers l'application du pattern parent/module/projet... cependant, afin d’éviter des modifications douloureuses dans les dépendances des builds, il est vraiment préférable de définir de suite un structure de POM parent, factorisant des processus standard de build, et des modules définissant séparément les lots de builds.

Je ne vous ferais pas l'affront de vous donner un exemple, avec les differentes références que je vous ai donné ci dessus, vous avez largement les moyens de soit débuter, soit enrichir l'architecture des builds de vos projets.

Voila, un grand tour d'horizon de Maven, ce que l'on en fait et ce qui est important de faire des le départ au niveau structure des projets. Ceci n’était cependant qu'une introduction donc dans les prochains articles sur Maven sous essayeront de voir les points suivant:

  • un POM et une architecture parent/module/projet en vrai
  • comment faire son propre plugin
  • c'est quoi les archétypes

vendredi 8 décembre 2017

La modélisation

La réalisation d'un logiciel informatique nécessite de nombreuses taches de nature multiples. Généralement on définit les activités de production d'un logiciel au travers d'un processus de développement. Il en exige de plusieurs comme par exemple en  V, en cascade, en cycle, etc... Leur point commun est de poser un certain nombre de phases indispensable a la bonne marche du développement.

Ces phases sont généralement : Analyse, Modélisation, Conception, Développement, Test. Il peut en existe plus, on peut en considérer moins en allant parfois dans le pire des cas a se restreindre à la seule phase de développement.

Je traiterai des phases de développement dans un autre article mais j'aimerai me focaliser sur une phase que j'estime fondamentale et pourtant très souvent mise de coté : la modélisation.

Comprise entre la phase d'analyse et la phase de conception, la modélisation est très souvent négligée car assimilée soit à l'analyse soit à la conception, quand elle n'est pas complètement ignorée.

Revenons sur ce qu'est la modélisation et ses concepts:
La modélisation est l'activité consistant a produire des modèles. 
Nous avons deux termes a définir:
  • Produire: la production est la mise en œuvre de quelque chose au moyen d'outils sur la base de plans et schémas de construction ainsi que de méthodes. Produire est donc une activité intentionnelle permettant l'apparition par différents moyens de l'artefact voulu
  • Modèle: élément de représentation, de simplification ou d'abstraction réalisée dans une intention et un contexte particulier.
Ainsi produire des modèles c'est faire usage de moyens pour abstraire, simplifier, mettre en évidence quelque chose pour faire la mise en perspective de notre compréhension d'un problème et ce avec les outils dont nous disposons, c'est a dire langage de modélisation, schéma ou encore langage naturel, etc.

Cette description pourrait être assimiler à de l'analyse , sauf que l'analyse ne se réduit qu'a la compréhension du problème sans l’établissement de solution, de même on pourrait l'associer à de la conception sauf que la conception  nécessite une décomposition fonctionnelle cohérente pour être menée.

En fait on le voit ici la modélisation se superpose clairement sur l'analyse et la conception sans les remplacer complètement non plus. Mais alors qu'apporte la modélisation ? Et bien elle rempli le gap existant entre les deux. Voyons comment :

La modélisation apporte la possibilité de traduire le résultat de l'analyse pas forcement formel en des modèles compréhensibles pour la phase de conception et ce par le biais de langage de modélisation (UML, AADL, SysML, etc... tout langage permettant la mise en perspective des points de vue à aborder)

Et c'est la que c'est important, car concevoir une application c'est souvent s'appuyer sur des architecture connues et maîtrisées (en couche, décentralisées, agents, etc...) mais l’intégration du besoin dans ces architecture nécessite forcement la conceptualisation de ces modèles sans lesquels les concepts seraient dilués (comme on le voit souvent) dans la solution;  les mécanismes techniques associés mis en œuvre se retrouvent alors mal définis et mal identifiable.

En conclusion, on dit que le langage forme les idées, qu'il est impossible de conceptualiser sa penser sans le support de notre langue, il est important a ce titre que nous utilisions les langages de modélisation pour former correctement les programmes. Ces langages nous donne des outils et des méthodes adapter pour combler le vide entre spécification et conception par cette phase qui s’appelle la modélisation.