urbanisation-si

urbanisation-si

Ingénierie Dirigée par les Modèles (IDM)


Pour trouver les services logiques, les modèles sémantiques et pragmatiques tu dériveras. (« Praxeme 4ème commandement extrait de la bible de l’aspect logique »).

La bible de la méthodologie d’architecture d’entreprise franco française Praxeme, énonce entre autres que l’architecture logique prolonge les décisions d’urbanisation du SI et que les services et données dérivent des modèles amont c’est-à-dire des aspects sémantique (entités métiers) et pragmatique (processus métiers et cas d’utilisation).

  

praxeme-service-logique-derivation-aspect-semantique-aspect-pragmatique.PNG

 

En 2006, le buzz était sur l’architecture SOA (Service Oriented Architecture) et je me suis intéressée à Praxeme qui était une des seules méthodes SOA open source et cerise sur le gâteau en français.

  

Aujourd’hui, Praxeme est à l’architecture d’entreprise ce que la théorie unifiée est à la physique.

 

Praxeme agrège toutes les bonnes pratiques en cours, allant de la stratégie d’entreprise à la réalisation d’applications informatiques en passant par l’urbanisation du Système d’Information, la gouvernance SI, l’architecture technique, SOA, l’ingénierie dirigée par les modèles jusqu’aux bonnes pratiques de conception.

 

 

On peut dire que Praxeme n’a rien inventé, mais elle a le mérite d’avoir intégré avec succès toutes ces bonnes pratiques avec une terminologie bien à elle.

 

Par exemple, la dérivation des aspects sémantique et pragmatique en aspect logique s'inspire de MDA (Model Driven Architecture, norme OMG) à la transformation du niveau CIM (Computational Independent Model) en PIM (Platform Independent Model) ou bien encore dans le monde de l’urbanisation du Système d’Information, à la cartographie métier qui se projette sur la cartographie fonctionnelle.

 

Voici quelques articles que nous avions consacrés sur ces sujets :

1) Sur les transformations des vues de l'urbanisation du Système d'Information

 

2) Sur l'Ingénierie Dirigée par les Modèles (MDE Model Driven Engineering)

  

Pour pouvoir manipuler un modèle, on doit avoir son méta-modèle.

 

Mais où est passé le méta-modèle Praxeme ?

 

Sur le site officiel :

//www.praxeme.org/telechargements/catalogue/

il est indiqué que le document PxMDS-05 traitant du méta-modèle est « en cours ».

Mais il y a un bouton « Visiter » qui nous renvoie sur la page : 

//wiki.praxeme.org/index.php?n=Modus.PraxemeMetamodel

Le lien « Le méta-modèle Praxeme » nous envoie à : 

//wiki.praxeme.org/Praxeme.MetaModel/index.html

Nous arrivons sur un diagramme de package cliquable mais malheureusement quand on clique sur un package, on arrive sur une description textuelle des entités mais point de diagramme de classe représentant le méta-modèle.

Plus grave, quand on clique sur le deuxième lien « Caisse d’allocations Familiales », un autre lien « méta-modèle Praxeme » nous répond « Error 404, page not-found ».

 

meta-modele-praxeme-error-404-page-not-found.PNG

 

Notre objectif est de réaliser des prototypes, les extraits fournis dans les différents évangiles Praxeme seront donc parfaits pour nos démonstrateurs.

 

Voyons d’un peu plus près à quoi ressemblent les règles de dérivation. 

 

praxeme-service-logique-derivation-BRMS-BPM.PNG

 

Par exemple une classe sémantique (métier) devient une Machine Logique Métier élémentaire (attributs, opérations, associations et navigations) et une Machine Logique Métier ensembliste (services sur les collections).

 

Le modèle pragmatique composé de la vue de l’utilisation (use case) et la vue de l’organisation (processus métier, diagramme d’activité).

Par exemple, concernant la première, un use case devient une Machine Logique Organisation et un Service Logique Transactionnel.

Pour la dérivation des processus métier, la méthode parle d’un dispositif transverse chargé de l’ordonnancement et de l’exécution des services autrement dit un moteur de processus exécutables, BPM Business Process Management.

Pour la dérivation des règles métiers 2 solutions sont envisagées :

  • La programmation de la règle en dur
  • L’enregistrement dans un dispositif ad hoc autrement dit un moteur de règles, BRMS Business Rules Management System.

 

La méthode devrait intégrer plus clairement le couple de normes (BPMN, DMN).

BPMN (Business Process Model and Notation)  pour les processus métiers (aspect pragmatique vue organisation), et la norme DMN (Decision Model and Notation) pour les règles métiers (aspect sémantique).

Et pourquoi pas SOAML (SOA Modeling Language) pour les aspects logiques et les services ?

 

L’OMG (Object Management Group) fourni pour toutes ces normes, les méta-modèles complets avec leurs diagrammes de classes accompagnés des description textuelles.

 

Ainsi en utilisant des outils de transformation de modèles, il est possible d'industrialiser les processus et les règles de dérivation des aspects Praxeme.

 

Les aspects stratégiques peuvent être modélisés en utilisant la norme BMM (Business Motivation Model) que l'on pourrait dériver en aspects sémantique et pragmatique.

 

Et pourquoi pas dériver le couple (BPMN, DMN) en modèle de code (PSM Platform Specific Model) d’un moteur de processus métier ou de règles métiers, par exemple le couple open source bien intégré (jBPM, Drools).

 

Voir la série d’articles sur jBPM :

 

Voir la série d’articles sur les moteurs de règles métiers :

 

Comment automatiser ces transformations, (en praxemien on parle de dérivations car le terme transformation implique une modification du modèle source) ?

 

De nombreuses solutions existent comme XSLT (XML Stylesheet Language Transformation), ATL (Atlas Transformation Language), QVT (Query View Language), …

 

Voir par exemple le cours complet sur ATL et le tutoriel QVT.

1) ATL (Atlas Transformation Language)

 

2) QVT

 

Mais laquelle choisir ?

C’est ce que nous verrons prochainement.

 

Rhona Maxwel

@rhona_helena

 

"Et le secret de toute la méthode est là : en toute choses repérer soigneusement ce qui est le plus absolu."

René Descartes

 

 

Articles conseillés :

 

Comment être efficace dans la modélisation de vos cas d'utilisation (UML use case diagram) ?

  

Vous cherchez désespérement un formalisme pour vos processus métiers mettant en accord MOA et MOE, la solution miracle existe, elle s'appelle BPMN 

 

Tutoriel – didacticiel – exemple complet sur la norme de modélisation des règles métiers DMN ( Decision Model Notation ) : le processus métier BPMN 

 

Tutoriel – didacticiel – exemple complet sur la norme de modélisation des règles métiers DMN ( Decision Model Notation ) : La vue des exigences des décisions

 

Tutoriel – didacticiel – exemple complet sur la norme de modélisation des règles métiers DMN ( Decision Model Notation ) : Le niveau logique de décision

 

Tutoriel – didacticiel – exemple complet sur la norme de modélisation des règles métiers DMN ( Decision Model Notation ) : Exemple d'exécution du modèle de décisions

 

Positionnement des processus et règles métiers dans la norme BMM Business Motivation Model de l’OMG et autres artefacts génériques

 

SysML pour les nuls : de la modélisation des exigences à la réalisation du système


18/08/2017
0 Poster un commentaire

Query View Transform (QVT) Operational : tutoriel, plus simple tu meurs !

query-view-transform-qvt-operational-tutoriel.png

Le métamodèle source et cible. 

 

Mes derniers articles sont consacrés au langage de transformation de modèles ATL (Atlas Transformation Language). 

Voir par exemple le tutoriel complet :

//www.urbanisation-si.com/ingenierie-dirigee-par-les-modeles-idm-tutoriel-atl-atlas-transformation-language-le-da-vinci-code-de-la-transformation-atl

ou bien le cours complet qui commence :

//www.urbanisation-si.com/ingenierie-dirigee-par-les-modeles-idm-documentation-atl-atlas-transformation-language-vous-saurez-tout-ou-presque-sur-les-modules

 

ATL est un langage opensource, largement utilisé utilisé dans l'industrie. Son implémentation est robuste et performante. Et surtout il existe des outils fiables comme le plugin pour Eclipse.

 

Mais ATL n'est pas une norme.

 

Son concurrent à l'avantage d'être une norme de l'OMG Object Management Group , l'organisation qui a fait notamment UML, MDA, ...

Il s'agit de QVT (Query View Transform). Il existe 2 types de QVT : QVTd (déclaratif, diisé en QVTr Relation et QVTc Core), équivalent des "matched rules" ATL et QVT Operational (impératif), équivalent des "called rules" ATL.

QVT avec son pédigré, pourrait être "La Solution" ultime pour transformer des modèles.

Seulement voilà, comme très souvent dans les normes, QVT souffre d'une grande complexité.

Mais il y a pire ! Les outils l'implémentant sont rares et incomplet. Seul QVTo commence à être implémenté alors que QVT-Relation est à l'état d'embryon.

 

Eclipse propose un plugin pour QVT Operational et un autre non finalsé pour QVT Relation.

 

Pour l'installer :

  1. //projects.eclipse.org/projects/modeling.mmt.qvt-oml/downloads
  2. Décompressez le zip dans un répertoire.
  3. Dans Eclipse, allez dans le menu Help - Install new software - Add - Local - sélecionnez le répertoire - nommez et OK

N'échapperons pas à la règle de commencer par le traditionnel "Hello world" que font tous les débutants dans un langage.

 

Tout d'abord le métamodèle source et cible dans notre cas de tutoriel "plus simple tu meurs", voici son fichier Ecore (ABC.ecore) : 

 

<?xml version="1.0" encoding="UTF-8"?>
<ecore:EPackage xmi:version="2.0" xmlns:xmi="//www.omg.org/XMI" xmlns:xsi="//www.w3.org/2001/XMLSchema-instance"
xmlns:ecore="//www.eclipse.org/emf/2002/Ecore" name="ABC" nsURI="///ABC.ecore" nsPrefix="ABC">
<eClassifiers xsi:type="ecore:EClass" name="Root">
<eStructuralFeatures xsi:type="ecore:EReference" name="element" upperBound="-1"
eType="#//Element" containment="true"/>
</eClassifiers>
<eClassifiers xsi:type="ecore:EClass" name="A" eSuperTypes="#//Element">
<eStructuralFeatures xsi:type="ecore:EAttribute" name="a" eType="ecore:EDataType //www.eclipse.org/emf/2002/Ecore#//EString"/>
</eClassifiers>
<eClassifiers xsi:type="ecore:EClass" name="B" eSuperTypes="#//Element">
<eStructuralFeatures xsi:type="ecore:EAttribute" name="b" eType="ecore:EDataType //www.eclipse.org/emf/2002/Ecore#//EString"/>
</eClassifiers>
<eClassifiers xsi:type="ecore:EClass" name="C" eSuperTypes="#//Element">
<eStructuralFeatures xsi:type="ecore:EAttribute" name="c" eType="ecore:EDataType //www.eclipse.org/emf/2002/Ecore#//EString"/>
</eClassifiers>
<eClassifiers xsi:type="ecore:EClass" name="Element" abstract="true">
<eStructuralFeatures xsi:type="ecore:EAttribute" name="id" lowerBound="1" eType="ecore:EDataType //www.eclipse.org/emf/2002/Ecore#//EInt"/>
<eStructuralFeatures xsi:type="ecore:EReference" name="abc" upperBound="-1" eType="#//Element"
containment="true"/>
</eClassifiers>
</ecore:EPackage>

Créer un nouveau projet : File - New - Project - Eclipse Modeling Framework -Empty EMF Project

 

Clic droit sur ABC.ecore - Initialize ecore diagram : pour générer le diagramme du modèle, cela ne peut pas faire de mal !

 

Double clic droit sur ABC.genmodel - clic droit sur ABC (2 ème icône dans la hiérarchie) - Generate All

 

Clic droit sur le projet - run As - Run Configurations - onglet Arguments - VM arguments :

-Dosgi.requiredJavaVersion=1.6  -Xms256m  -Xmx768m  -XX:MaxPermSize=256m

puis Run

 

Une nouvelle instance d'Eclipse se lance pour exécuter le nouveau plugin.

 

File - New - Project - Model to Model Transformation - Operational QVT Project.

Nommez votre projet

 

Ecrire le source de la transformation :

 

modeltype ABC uses ABC('///ABC.ecore');

transformation NewTransformation(in source:ABC, out target:ABC);

main() {
      source.rootObjects()[Root]->map Root2Root();
}

mapping Root :: Root2Root() : Root {
      element += self.element->select(a |
            a.oclIsKindOf(A))[A]->map A2B();
}

mapping A :: A2B() : B
      when {
            self.id > 0
      }
      {
      result.id := self.id;
      result.b := self.a + " World!";
}

 A est transformé en B, en utilisant le même id et en concaténant l'attribut "a" à la chaîne "World" pour créer l'attribut "b".

 

Créer le modèle à transformer : 

Clic droit sur le projet - New - Other - Example EMF Model Creation Wizards - ABC Model 

Double clic sur le modèle vide - clic droit sur Root - New chlid - ajouter et modifier dans la vue Properties : 

  • A: id=1, A=”Hello”
  • A: id=-1, A=”World”
  • C: id=1, C=”C'est quoi ce truc ?”

query-view-transform-qvt-operational-tutoriel-1.png

 

Pour exécuter la transformation :

Clic droit sur le fichier de transformation (.qvto) - Run As - Run Configuration - Operational QVT Interpreter - New_configuration - Run

 

query-view-transform-qvt-operational-tutoriel-2.png

 

Le modèle transformé se trouve dans le fichier "sortie.abc" :

 

query-view-transform-qvt-operational-tutoriel-3.png

 

 

"La vraie valeur d'un homme réside, non dans ce qu'il a, mais dans ce qu'il est."
Oscar Wilde

 

Voir aussi :  

 

//urbanisation-si.wix.com/blog

//urbanisme-si.wix.com/blog

//urbanisation-si.wix.com/urbanisation-si

//urbanisation-si.over-blog.com/

//rhonamaxwel.over-blog.com/

//urbanisation-des-si.blogspot.fr/

//bonnes-pratiques-si.eklablog.com/

//urbanisation-si.eklablog.com/


20/10/2015
0 Poster un commentaire

Le plugin ATL (ATLAS Transformation Language) pour Eclipse : les étapes pour réaliser une transformation (2/2)

Surcharge de module et exécution de la configuration de lancement

plugin-eclipse-atlas-transformation-language-surcharge-module.png

Tandis que les modules et requêtes ATL sont exécutés un par un, il est aussi possible d'exécuter des modules par dessus d'autres.

Le résultat final est une transformation contenant l'union de toutes les règles de transformations et helpers, quand il est possible pour un module de surcharger des règles et helpers du module inférieur.

 

Exemple :

 

 

Ce module est réutilisé et surchargé quand c'est nécessaire par le module :

 

La transformation UML2Copy inclu la règle de transformation pour chaque instance de méta-classe qu'il doit copier.

Ce qui fait approximativement 200 règles pour la totalité du métamodèle  

 

Chaque transformation spécifique doit copier toutes les méta-classse exceptées les quelques méta-classes qui sont redéfinies.

La transformation UML2Profiles applique un profil aux instances de "uml::Model" instance, tous les autres éléments sont juste copiés.

Pour terminer, le module UML2Profiles est exécuté par dessus le module UML2Copy.

Il redéfini la règle "Model" qui copie chaque instance de "uml::Model", avec une version vérifiant que le profil que nous voulons appliqué  a déjà été appliqué.

Il introduit aussi une nouvelle règle "ModelProfile", qui vérifie que le profil que nous voulons appliquer n'a pas été appliqué et dans ce cas applique le profil.

Le résultat de la transformation contient toutes les règles figurant ci-dessus qui n'ont pas été barrées.  

La surimpression se est faite à l'exécution : il n'y a pas de module représentant la surimpression des différents modules les uns par dessus les autres.

Il y a juste plusieurs modules chargés les uns au dessus des autres, surchargeant les règles existantes et en ajoutant des nouvelles.

 

La surimpression est configurée dans l'onglet "Advanced",  "Run..."  de la configuration de l'exécution.

Attention : quand on ajoute des modules en surimpression, dans l'onglet "Advanced",  ils surchargent le module "main" spécifié dans l'onglet  "ATL Main Configuration".

 

Exécution de la configuration

Une fois la configuration de la transformation correctement effectuée, elle peut être lancée autant de fois que l'on désire.

Il suffit juste d'aller dans la fenêtre Run,  pour sélectionner la transformation et clique sur "Run".

 
"Tu dois devenir l'homme que tu es. Fais ce que toi seul peux faire. Deviens sans cesse celui que tu es, sois le maître et le sculpteur de toi-même."
Friedrich Nietzsche

 

Voir aussi :  

 

//urbanisation-si.wix.com/blog

//urbanisme-si.wix.com/blog

//urbanisation-si.wix.com/urbanisation-si

//urbanisation-si.over-blog.com/

//rhonamaxwel.over-blog.com/

//urbanisation-des-si.blogspot.fr/

//bonnes-pratiques-si.eklablog.com/

//urbanisation-si.eklablog.com/


18/10/2015
0 Poster un commentaire

Le plugin ATL (ATLAS Transformation Language) pour Eclipse : les étapes pour réaliser une transformation (1/2)

Comment réaliser une transformation ATL avec l'IDE ATL d'Eclipse

 

plugin-eclipse-atlas-transformation-language-concevoir-une-transformation-1.png
    

Check liste des fichiers :

  • métamodèle source (ecore)
  • métamodèle  cible (ecore)
  • modèle source à transformer (xmi)
  • fichier de transformation (atl)

 

Créer un projet ATL.

Les métamodèles source et cible peuvent être importés. La tache la plus ardue consistant bien sur à concevoir la transformation elle même.

Pour créer un projet ATL :  New->ATL Project

Une bonne pratique de nommage consiste à nommer le projet avec le nom du métamodèle source, puis "2" et pour finir le nom du métamodèle cible  (par ex.  Author2Person).

Pour avoir la  "completion" des éléments de modèle, vous devez préciser en début de fichier ATL :

 

  1. '-- @nsURI' : l'URI d'un métamodèle pour le charger à partir de l'EMF registry,
  2. '-- @path' : le chemin d'un métamodèle, si vous voulez le charger dynamiquement à partir d'un fichier ecore.  

Seuls les métamodèles EMF sont supportés.

Vous devez spécifier les chemins relatifs des fichiers dans le workspace.

Exemple du début d'une transformation "UML2AnyMM" :

 

-- @path AnyMM=/AnyProject/AnyFolder/AnyMM.ecore
-- @nsURI UML=//www.eclipse.org/uml2/2.1.0/UML
module Class2Relational;
create OUT : AnyMM from IN : UML;
-- ...transformation helpers and rules

 

La "completion" est exécutée en appuyant sur  Ctrl + espace, ou en tapant un espace si le contexte le permet.

Pour inclure la liste des librairies dans la completion :

 


'-- @lib' : le chemin relatif par rapport au workspace de la librairie.

 

Création du fichier ATL

Il existe 2 manière de créer un fichier ATL de transformation :

  1. l'assistant
  2. directement en créant le fichier source atl

L'assistant ATL

Il est appelé par New->ATL File dans le menu contextuel, vous pouvez spécifier :

  • le nom du module
  • le type (module, query ou librairie)
  • les noms des variables  métamodèles, modéles sources et cibles
  • les librairies
  • L'entête est généré avec ces informations.

Vous pouvez optionnellement généré les URIs ou chemins aux métamodèles pour activer la completion.

La checkbox "Generate configuration" génère la configuration de lancement en donnant les chemins des modèles.

Sinon vous créez le fichier atl "from scratch".

 

Compilation du fichier ATL

La compilation génère le fichier ASM.

 

La configuration de l'exécution

Elle donne toutes les information nécessaire à l'exécution de la transformation : les chemins des fichiers ATL, modèles, métamodèles et librairies).

L'onglet ATL Configuration permet de spécifier les chemins et URIs de la configuration de lancement. Les champs sont pré-remplis à partir du module ATL, mais vous pouvez en ajouter.

 

plugin-eclipse-atlas-transformation-language-concevoir-une-transformation-2.png

 

L'onglet Advanced permet de configurer :

  1. des modules supplémentaires en  surimposition avec les boutons  Add/Remove.
  2. l'ATL Virtual Machine
  3. les paramètres de lancement

plugin-eclipse-atlas-transformation-language-concevoir-une-transformation-3.png

 

L'onglet Common offre aux développeurs la possibilité de configurer l'environnement d'exécution de la transformation.

 

plugin-eclipse-atlas-transformation-language-concevoir-une-transformation-4.png

 

  1. Le bouton Save as permet se sauvegarder la configuration de lancement dans un fichier par ex. Author2Person.launch.
  2. Display in favorites : la configuration apparaît dans les menus Run et/ou Debug.
  3. Console Encoding : le type d'encodage pour la console
  4. Vous pouvez définir les entrées et les sorties
  5. La dernière option permet d'exécuter la transformation en tache de fond.

 
"Se réunir est un début ; rester ensemble est un progrès ; travailler ensemble est la réussite." 
Henry Ford

 

Voir aussi :  

 

//urbanisation-si.wix.com/blog

//urbanisme-si.wix.com/blog

//urbanisation-si.wix.com/urbanisation-si

//urbanisation-si.over-blog.com/

//rhonamaxwel.over-blog.com/

//urbanisation-des-si.blogspot.fr/

//bonnes-pratiques-si.eklablog.com/

//urbanisation-si.eklablog.com/


18/10/2015
0 Poster un commentaire

Cours complet sur ATL (ATLAS Transformation Language) : pour terminer, une dernière chose à laquelle il faut prendre garde !

cours-complet-atlas-transformation-language-atl-piege-et-fin.png

 

Dans l'article précédent :

//www.urbanisation-si.com/cours-complet-sur-atl-atlas-transformation-language-les-mots-cles-atl

nous avion abordé les mots clés ATL. Voyons à présent pour terminer, une dernière chose à laquelle il faut prendre garde !

 

Avec ATL, un élément du modèle d'entrée ne peut pas être mis en correspondance plus d'une fois.

Cette contrainte n'est pas vérifiée à la compilation et peut conduire à des résultats inattendus.

Un cas typique de correspondance multiple se produit lorsque dans le modèle d'entrée, on est en présence d'un héritage avec la super classe qui n'est pas abstraite :

 

                       

La correspondance multiple apparaît ici en essayant respectivement de faire correspondre A et B dans les règles ( ruleA et ruleB).

Avec la pattern source : MM!A, la règle ruleA correspondra avec l'élément  A ainsi qu'un élément B.

Comme ce dernier aura une correspondance dans ruleB, on aura le problème de la correspondance multiple.  

Pour résoudre ce problème, on doit s'assurer que ruleA fait les correspondances avec seulement les éléments strictement A (et pas hérités).

Pour cela il faut filtrer dans le pattern source de la règle ruleA, le type d'élément mis en correspondance par la règle :

 

rule ruleA {
      from
            a : MM!A (
                  a.oclIsTypeOf(MM!A)
            )
 ...

 

La fonction OCL oclIsTypeOf  teste si dans le modèle d'entrée, les éléments sont des instances du métamodèle  passé en paramètre.

 

Et voilà qui termine ce cours sur le langage ATL, nous passerons bientôt à une application dans le domaine du processus d'urbanisation du système d'information pour les projections (transformations) des cartographies.

 

"Je veux être fort, non pour dominer mon frère, mais pour vaincre mon plus grand ennemi - moi-même."
Chef Iakota Yellow Lark

 

Voir aussi :  

 

//urbanisation-si.wix.com/blog

//urbanisme-si.wix.com/blog

//urbanisation-si.wix.com/urbanisation-si

//urbanisation-si.over-blog.com/

//rhonamaxwel.over-blog.com/

//urbanisation-des-si.blogspot.fr/

//bonnes-pratiques-si.eklablog.com/

//urbanisation-si.eklablog.com/


17/10/2015
0 Poster un commentaire