urbanisation-si

urbanisation-si

Modélisation de système


Le meilleur du meilleur des outils de modélisation de Systèmes d’Information pour 2017 : les « Modsars » de « urbanisation-si.com » récompensent les plus innovants

Les Modsars de « urbanisation-si.com » récompensent les meilleurs logiciels de modélisation de Systèmes d’Information.

Nos critères sont sans commune mesure avec les récompenses de références comme par exemple celles du Gartner.

Nous privilégions l’open source, la communauté et le partage d’informations, l’innovation, la fiabilité en production, la documentation.

 

meilleur-du-meilleur-des-outils-de-modelisation-de-systemes-d-information-2017-les-plus-innovants.png

 

Les domaines concernés sont ceux des catégorie du site de « urbanisation-si.com » :

 

  • les normes de l’OMG comme UML, BPMN, SysML, DMN, BMM, OCL, MDA, QVT, XMI,
  • les architecture d’entreprise comme TOGAF, l'urbanisation du SI, Praxeme,
  • l’Ingénierie Dirigée par les Modèles avec MDE, ATL, Ecore, ….,
  • les processus métiers et le BPM
  • les règles métiers et les BRMS
  • la simulation et la validation de modèles
  • la génération de code à partir de modèles
  • la gestion de projet avec les méthodes agiles, les méthodes d’estimation et de recettes.

 

A la 1ère place : Eclipse Modeling Tools, un « killer » avant d’être un « winner »

Pour commencer je rappellerais que l’open source Eclipse a d’abord été financé par IBM pour couler, ou devrais-je dire pour éclipser JBuilder de Borland qui fut longtemps le standard des IDEs Java qui a effectivement disparu dès la sortie d’Eclipse, plus personne ne voulant payer des licences alors qu’il y avait sur la marché un outil similaire et gratuit.

 

Avec Eclipse Modeling Tools vous modélisez gratis en UML, BPMN, SysML, OCL et si cela ne vous suffit pas, vous pouvez concevoir vos propres outils de modélisation pour le langage de votre choix ( DMN, BMM, …, et créez votre propre DSL ) avec Sirius, générer le code avec Acceleo, mettre en pratique MDA avec ATL et même QVTo/QVTd, pour dériver les modèles sémantiques et pragmatiques en modèles logiques.

 

Avec Eclipse Modeling Tools, vous avez une documentation (dans la langue de Shakespeare) complète sur tous les langages ainsi que des tutoriaux et des exemples qui fonctionnent !

Une communauté de jeunes innovateurs passionnés qui répondent rapidement à vos questions.

 

Je vois déjà les experts métiers, dire oui mais cela reste un environnement réservé aux développeurs.

Croyez-moi, l’organisation Eclipse a énormément progressé sur le plan ergonomie et rigueur.

C’est un gros avantage pour une entreprise d’avoir un socle commun que ce soit pour les outils MOA ou MOE.

Ainsi les experts métiers pourront modéliser leurs règles métiers avec DMN et leurs processus métiers avec BPMN et générer les codes qui sont récupérés par les développeurs utilisant Eclipse avec les plugins DROOLS et jBPM.

 

Il faudra bien sûr installer un outil de gestion de version pour travailler en équipe (Git, …).

 

A la 2ème place : Signavio, en rupture avec les approches et outils BPM traditionnels qui ne répondent plus à la réalité d’aujourd’hui

Attention, là vous sortez du monde gratuit pour entrer dans celui du payant.

La bonne surprise, l’outil s’exécute dans un navigateur, rien à télécharger, et tout est dans la langue de Molière.

 

Vous pouvez modéliser vos processus métiers avec BPMN, vos règles métiers avec DMN et votre architecture avec Archimate, le langage de modélisation de TOGAF de plus en plus remplacé par EAP (Enterprise Architecture Planning) qui intègre les normes UML et BPMN.

 

J’ai bien apprécié les exemples très représentatifs comme les processus de support, par exemple le processus en BPMN de la « Réception de la candidature » et le modèles DMN de règles métiers qui est lié : « Vérifier le candidat ».

 

En sélectionnant l’icône du modèle DMN, puis le menu « Importer/Exporter », l’option « Exporter en DROOLS », Signavio produit un zip contenant le fichier source DRL pour l’exécution dans le moteur open source de règles métiers DROOLS.

Signavio Process Manager génère aussi un JAR( exécutable Java).

Pour l’utiliser, les développeurs doivent se reporter à la section « 10. Decision Model and Notation » de la documentation en ligne de DROOLS ( https://docs.jboss.org/drools/release/7.5.0.Final/drools-docs/html_single/index.html#drools.DMN )

 

Dans le menu « Importer/Exporter » on peut aussi choisir « Exporter en XML ».

On obtient un fichier RDF.

Vous vous demandez surement comme moi qu’est-ce qu’un fichier RDF ?

Un fichier « Resource Description Framework » est un modèle de graphe destiné à décrire de façon formelle les ressources Web et leurs métadonnées, de façon à permettre le traitement automatique. Développé par le W3C, RDF est le langage de base du Web sémantique.

Ce fichier RDF, au format technique XML, peut être analysé par un programme qu’il faut écrire à moins qu’il existe un outil capable d’interpréter un tel RDF ? Si quelqu’un à la réponse, je suis preneuse.

La documentation, là encore en français, est complète et opérationnelle.

 

Je trouve l’interface web très ergonomique, la traduction française excellente, les outils de modélisation BPMN et DMN de bonne facture ainsi que la fonctionnalité de génération de code DROOLS pour les modèles DMN très innovante.

 

D’autres modules concernant la collaboration, le workflow, et le process mining sont disponibles.

 

La liste des clients (SAP, Société Générale, BNP, MNT, Valéo, Véolia, …) montre la maturité du produit.

 

Pour ceux qui veulent installer une version d’essai de 30 jours :

https://www.signavio.com/fr/

Il faudra passer par l’épreuve de remplissage d’un formulaire et plusieurs aller retours avec votre mail, pour arriver à vous connectez à l’outil Process Manager.

 

A la 3ème place :  Sparx Systems Enterprise Architect, un univers composé de clickodromes

Enterprise Architect de Sparx Systems est aux outils de modélisation ce que Stars Wars est aux films de science-fiction c’est-à-dire un univers intergalactique avec une pluralité de mondes.

 

Je vous laisse juger :

 

  • Modélisation UML
  • Domain Specific Modeling, User Interface Modeling, WSDL, Entity Relationship, profils UML, ecosystems
  • Traçabilité
  • Architecture d’Entreprise, UAF (Unified Architecture Framework), Archimate, TOGAF, Zachman Framework
  • Outils d’analyse des capacités métiers, matrice de capacités
  • Modélisation du domaine
  • Modélisation de la structure de l’organisation
  • Planning
  • Processus métiers, BPMN
  • Gestion de projet : calendrier, audit, Gantt, Kanban, gestion d’équipe, métriques, estimations, gestion des ressources
  • Tests
  • Reporting
  • Modélisation de base de données, DDL, génération SQL
  • Génération de XSD (XML Schema)
  • Modélisation de System, SysML
  • Développement, génération de code Microsoft C#, C++, Java, à partir des modèles UML
  • Transformation de modèles (MDA)
  • Simulation de modèles, diagrammes d’activité UML, processus BPMN, diagrammes d’interactions UML, diagrammes d’états UML

 

L’outil peut s’exécuter en version standalone, ou bien s’intégrer entièrement à Eclipse ou Microsoft Visual Studio

 

Comme clickodrome, on ne fait pas mieux.

L’outil est très ergonomique pour celui qui sait le dompter.

Cela fait plus de 10 ans que je connais Enterprise Architecte.

Cependant je suis obligée de le réapprendre à chaque nouvelle version tellement il y a de nouvelles fonctionnalités ajoutées, des réorganisations de menus et le look constamment modifié.

 

Je n’aime pas du tout leur technologie propriétaire MDG (Model Driven Generator) de transformation de modèles, mais tout le monde n’est pas forcément intéressé par l’Ingénierie Dirigée par les Modèles.

 

Vous pouvez installer une version d'essai gratuite pendant 30 jours :

http://www.sparxsystems.com/

 

4 ème place : Modeliosoft

J’ai bien aimé les 5 exemple fournis sur l’architecture TOGAF que j’ai trouvés très pédagogiques.

 

Vous pouvez installer une version gratuite pendant seulement 10 jours :

https://www.modeliosoft.com/fr/telecharger/telechargez-produits.html

 

5 ème place : BOC-GROUP ADOIT

En décembre 2016 lors de la parution de l'article :

 

Les meilleurs outils de modélisation UML, SysML, BPMN, DMN de l'année 2016 et les gagnants sont ... 

 

« phoforjob », un membre assidu de notre communauté, nous proposait d’évaluer les produits BOC GROUP.

Voilà qui est fait.

 

Ce produit devrait intéresser les « corporate » peut être en remplacement d’institution comme « MEGA » nouvellement renommé « HOPEX » (voir ci-après).

Pour ceux qui veulent installer une version d’essai de 30 jours :

https://fr.boc-group.com/

Il faudra passer par l’épreuve de remplissage d’un formulaire et plusieurs aller retours avec votre mail, pour arriver à vous connectez à l’outil qui s’exécute entièrement dans un navigateur ce qui est bon point.

 

Et les autres, les mamouths (en voie d’extinction ?) de la modélisation

MEGA est mort vive HOPEX

HOPEX est une offre complète de logiciels intégrés, qui fait converger en une plateforme unique les meilleures pratiques dans les domaines de l’architecture d’entreprise (EA), la gestion de portefeuille IT (ITPM), l’analyse de processus métier (BPA) et l’activité de Gouvernance, risques et conformité (GRC).

  • HOPEX ArchiMate
  • HOPEX Business Architecture
  • HOPEX Business Process Analysis
  • HOPEX Enterprise Architecture for TOGAF
  • HOPEX IT Architecture
  • HOPEX UML

J’ai eu l’occasion de travailler avec pendant des années pour établir les cartographies applicatives existantes et concevoir les cartographies fonctionnelles cibles de SI de grandes mutuelles.

A l’époque chaque module était vendu séparément pour un nombre d’utilisateurs donnés.

MEGA possède tout un environnement propriétaire et très fermé, personnalisable avec un langage.

Ici point de version d’essai, aucune documentation téléchargeable, le fonctionnement doit rester entre les mains de quelques experts qui gardent jalousement leurs secrets !

 

Voir les articles que j’avais consacrés à cet outil :

 

A titre indicatif voici le site :

http://www.mega.com/fr/produit/produits-z

 

Je terminerais avec 2 ancêtres : PowerAMC (renommé SAP PowerDesigner) et Rational Rose (maintenant IBM Rational Software Architect).

 

SAP PowerDesigner

Commençons par SAP PowerDesigner avec lequel j’ai fait plusieurs missions, connu à l’époque pour générer les MCD, MLD et autres modèles de notre méthode antédiluvienne franco- française MERISE !

SAP PowerDesigner : Enterprise Architecture tools

https://www.sap.com/products/powerdesigner-data-modeling-tools.html )

 

IBM Rational Software Architect

Et enfin, pour ceux qui comme moi ont connu Rational Rose avec ses 3 salariés célèbres Grady Booch, James Rumbaugh et Ivar Jacobson qui ont eu la juteuse idée d’unifier leurs méthodes pour faire la norme UML avec la bénédiction de leur société qui fut racheter des années plus-tard par IBM.

IBM Rational Software Architect

https://www.ibm.com/developerworks/downloads/r/architect/index.html )

 

Conclusion

Vous vous en doutez, l’idéal est d’utiliser les 3 :

  • Signavio Process Manager pour modéliser ses processus métiers BPMN et règles métiers DMN et éventuellement générer le code DROOLS,
  • Eclipse Modeling Tool : avec le plugin Papyrus pour modéliser en UML et SysML, avec le plugin Sirius pour avoir la totale liberté de concevoir votre propre DSL, avec le plugin ATL pour transformer vos modèles en conformité avec MDA et avec le plugin DROOLS pour exécuter le code générer par Signavio Process Manager et le plugin jBPM pour exécuter les processus métiers en BPMN.
  • Sparx Systems Enterprise Architect : pour modéliser vos modèles d’architecture d’entreprise TOGAF et gérer vos projets IT.

Et pour finir, je suis sûr que tout au long de cet article, vous vous êtes demandé qui a eu les médailles d’or et d’argent du Gartner pour les logiciels de modélisation de Système d’Information ...

 

La médaille d’or revient à Orbus Software ( https://www.orbussoftware.com/ ) et la médaille d’argent pour celui qui est la 3ème place de notre classement des « Modsars urbanisation-si.com », Sparx Systems Enterprise Architect ( http://www.sparxsystems.com/ ).

 

Annexe : voici comment installer le meilleur outil entièrement gratuit de modélisation, et vous allez voir comme c’est simple !

Comment installer Eclipse Modeling Tools ?

Le site :  

http://www.eclipse.org/downloads/packages/eclipse-modeling-tools/oxygen2

Vous téléchargez, dézippez et c’est tout (après toutefois avoir installé Java dans les règles de l’art https://www.oracle.com/java/technologies/java-se.html  ).

Par défaut EMF (Eclipse Modeling Framework) et Ecore sont installés

 

Comment installer les plugins : Papyrus, Sirius, Acceleo, Xpand, ATL, QVTo et OCL ?

Allez encore un petit effort, dans la page « Welcome » cliquer sur « Install more Modeling Tools »

Voici les plugins que je recommande d'installer, il suffit de les sélectionner.

 

Papyrus

Papyrus, pour modéliser en UML et SysML

Voici les principaux articles consacrés  à UML et SysML :

UML

SysML

 

Sirius

Sirius ( vous pouvez aussi télécharger « Obeo Designer Community » https://www.obeodesigner.com ) pour concevoir vos propres DSL (Domain Specific Language). Souvenez-vous, pour nous familiariser avec le métamodèle DMN, on avait créé notre propre outil de modélisation DMN, il manquait juste la génération de code DROOLS qu’on aurait pu réaliser avec l’outil Acceleo. 
Voici quelques articles sur DMN et Sirius :

 

Acceleo

Acceleo : permet de transformer des modèles en texte (code)

 

Xpand

Xpand : un autre bon plugin qui permet aussi de transformer des modèles en texte (code)

 

ATL

ATL (Atlas Transform Language) : le meilleur outil MDA (Model Driven Architecture), 
Voici les articles constituant  un cours complet sur ATL en français :

 

QVTo

Operational QVT : qui fait la même chose qu’ATL mais d’une manière impérative, mais c’est la norme de l’OMG

Voici un tutorial :

  

OCL

OCL (Object Constraint Language) Tools : le langage normalisé OMG complément d’UML, permettant d’exprimer les règles d’un modèle.

Voir les articles sur OCL :

 

BPMN

Pour modéliser vos processus métiers avec BPMN, il faudra aller dans le menu : Help – Install New Software – Add – copier coller les 2 adresses ci-dessous :

https://projects.eclipse.org/projects/modeling.mdt.bpmn2/downloads

pour le méta modèle BPMN2

et

http://www.eclipse.org/bpmn2-modeler/downloads.php

pour l’outil de modélisation BPMN2

 

Voici les principaux articles consacrés à BPMN :

 

QVTd

Pour les geeks de MDA, les afficionados de la transformationde modèles, pour pouvez installer : QVT declarative, le langage déclaratif, complément de QVto

http://www.eclipse.org/mmt/downloads/

http://www.eclipse.org/mmt/downloads/index.php?project=qvtd&showAll=0&showMax=5

 

 

Rhona Maxwel

@rhona_helena

  

"Je me sens toujours heureux, savez-vous pourquoi ?

Parce que je n'attends rien de personne.

Les attentes font toujours mal, la vie est courte.

Aimez votre vie, soyez heureux, gardez le sourire, et souvenez-vous : avant de parler, écoutez.

Avant d'écrire, réfléchissez.

Avant de prier, pardonnez.

Avant de blesser, considérez l'autre.

Avant de détester, aimez et, avant de mourir, vivez."

William Shakespeare

 

 

Articles conseillés :

 

Les meilleurs outils de modélisation UML, SysML, BPMN, DMN de l'année 2016 et les gagnants sont ... 

 

Le meilleur outil pour transformer, dériver, parcourir, requêter sur des modèles afin de mettre en œuvre MDA (Model Driven Architecture)

 

Transformation de modèles et Ingénierie Dirigées par les Modèles (IDM ou MDE Model Driven Engineering ou bien encore MDA Model Driven Architecture)


16/01/2018
0 Poster un commentaire

Les meilleurs outils de modélisation UML, SysML, BPMN, DMN de l'année 2016 et les gagnants sont ...

C'est la période vous n'y couperez pas, tout le monde y va de son classement du meilleur de l’année qu’il s'agisse de l'homme (ou de la femme) de l'année, du livre, du film, de la chanson, du personnage politique, …

 meilleur-outil-de-modelisation-2016-2017.png

 

Urbanisation-si n'échappera pas à la règle et nous vous proposons donc nos « best of the year » à notre manière bien sur.

 

En compétition pour le prix du meilleur outil de modélisation généraliste, UML, SysML, BPMN, MDA, ... de l’année 2016, les nommés sont :

 

  1. Modelio (gratuit) ( https://www.modelio.org/ )

  2. Papyrus (gratuit) ( https://eclipse.org/papyrus/ )

  3. Sirius (gratuit) ( permet de créer son propre formalisme de modélisation ) ( http://www.eclipse.org/sirius/ )

  4. Enterprise Architect ( http://www.sparxsystems.com/ )

  5. IBM Rational Rhapsody family (gratuit) ( http://www-03.ibm.com/software/products/en/ratirhapfami )

  6. IBM Rational Modeler (gratuit) ( http://www.ibm.com/developerworks/downloads/r/modeler/ )

  7. Open ModelSphere (gratuit) ( http://www.modelsphere.com/org/fr/open_modelsphere.html )

  8. MEGA ( http://www.mega.com/fr/produit/hopex-uml )

  9. Magic Draw ( https://www.nomagic.com/products/magicdraw.html )

 

Et le gagnant est ………. Enterprise Architect de Sparx Systems.

Il s'agit de l'AGL commercial le plus complet, présentant le meilleur rapport qualité + fonctionnalités / prix. Différentes versions, correspondent à différents profils utilisateurs, cela va de l'expert métier au développeur en passant par l'architecte fonctionnel ou technique. Tous les langages sont présents : UML, SysML, BPMN, ... A mon avis c'est très certainement l'outil le plus convivial et le plus robuste et puissant du marché.
Voir l'article : AGL (Atelier de Génie Logiciel) : les ministères recommandent Enterprise Architect de Sparx System

 

 

En compétition pour le prix du meilleur outil de modélisation dans la catégorie processus métier BPMN (Business Process Modeling Notation) de l’année 2016, les nommés sont :

 

  1. Modelio gratuit) ( https://www.modelio.org/ )

  2. Sirius (gratuit) ( permet de créer son propre formalisme de modélisation ) ( http://www.eclipse.org/sirius/ )

  3. Enterprise Architect ( http://www.sparxsystems.com/ )

  4. TBM Blueworkslive ( https://www.blueworkslive.com/home )

  5. IBM Business Process Manager ( http://www-03.ibm.com/software/products/fr/business-process-manager-family )

  6. MEGA - HOPEX Business Process Analysis ( http://www.mega.com/fr/produit/hopex-business-process-analysis )

  7. Bizagi ( https://www.bizagi.com/ )

  8. Eclipse BPMN2 Modeler (gratuit) ( http://www.eclipse.org/bpmn2-modeler/ )

  9. Bonitasoft (gratuit) ( http://fr.bonitasoft.com/ )

  10. jBPM (gratuit) ( https://www.jbpm.org/ )

  11. Activiti (gratuit) ( http://activiti.org/ )
     
  12. Camunda (gratuit) ( https://camunda.org/ )
     
Et le gagnant est ………. Bonitasoft

Grâce à ces trois composants majeurs : Bonita Studio permettant à l'utilisateur de modifier graphiquement les processus métier suivant la norme BPMN. L'utilisateur peut également connecter les processus à d'autres éléments du système d'information (telles que la messagerie, la planification des ressources d'entreprise, la gestion de contenu d'entreprise et bases de données) afin de générer une application commerciale autonome accessible comme un formulaire Web. Bonita Studio permet également à l'utilisateur de concevoir graphiquement les formulaires qui seront présentées à l'utilisateur final afin d'interagir avec le processus. Il s'agit d'un plugin Eclipse ; Bonita BPM Engine qui est une application Java qui exécute les processus métier créés avec Bonita Studio et enfin Bonita Portal permettant à chaque utilisateur final de gérer toutes les tâches dans lesquelles il est impliqué. Le portail permet également le propriétaire d'un processus d'administrer et d'obtenir des rapports sur les processus.

 

 

En compétition pour le prix du meilleur outil de modélisation dans la catégorie règles métiers DMN (Decision Modeling Notation) de l’année 2016, les nommés sont :

 

  1. FICO DMN Modeler ( http://www.ficoanalyticcloud.com/decision-management-suite/dmn-modeler/ )

  2. Decision First Modeler ( http://decisionsfirst.com/ )

  3. OpenRules (gratuit) ( http://openrules.com/ )

  4. Signavio Decision Manager ( http://www.signavio.com/fr/products/decision-manager/ )

  5. Camunda (gratuit) ( https://camunda.org/ )

 

Et le gagnant est ………. OpenRules

Permet à tous les acteurs, des experts métiers aux développeurs de créer, tester, exécuter et maintenir des règles métiers (tables de décisions, …). Supporte le norme de l'OMG DMN (le langage FEEL, les tables de décisions, …) et un gros effort a été apporté à la documentation et aux exemples.

 

 

En compétition pour le prix du meilleur outil de transformation de modèles de l’année 2016, les nommés sont :

 

  1. Enterprise Architect ( http://www.sparxsystems.com/ )

  2. Eclipse QVTo (Query View Transform Operational) (gratuit) ( http://www.eclipse.org/mmt/?project=qvto )

  3. Eclipse QVTd (Query View Transform Declarative) (gratuit, en cours de finalisation)) ( https://projects.eclipse.org/projects/modeling.mmt.qvtd )

  4. Eclipse ATL (Atlas Transformation Language) (gratuit) ( https://www.eclipse.org/atl/ )

 

  

Et le gagnant est ATL.

Le plus ancien et le plus stable des outils de transformation de modèles.
Voir l'article : Ingénierie Dirigée par les Modèles (IDM) : tutoriel ATL (ATLAS Transformation Language), le "Da Vinci code" de la transformation AT

 

Rhona Maxwel

@rhona_maxwel

 

« C'est là, dans le va-et-vient des jours et le fouillis des non-dits, que la vie perd le sens des choses profondes et se réfugie dans le superficiel et le faux-semblant. »

Boualem Sansal

 

 

Articles conseillés :

 

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

 

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

 

Urbanisation SI : la méthode ultime pour modéliser les besoins d'un projet - 2ème partie - Processus métiers - Profil UML Eriksson Penker

 

Urbanisation SI : la méthode ultime pour modéliser les besoins d'un projet - 3ème partie - Processus métiers - BPMN

 

Urbanisation SI : la méthode ultime pour modéliser les besoins d'un projet - 5ème partie - Règles métier- UML - Profil spécifique

 

Urbanisation SI : la méthode ultime pour modéliser les besoins d'un projet - 6ème partie - Rule Flow – UML – Diag. Activité

 

Urbanisation SI : la méthode ultime pour modéliser les besoins d'un projet - 7ème partie - Domaine métier – UML – Diag. Classe


11/12/2016
3 Poster un commentaire

Modélisation de système : comment utiliser OCL avec Eclipse, c'est bien la question que tout le monde se pose

 

ingenierie-dirigee-par-les-modeles-IDM-tutoriel-eclipse-ecore.png

Lors des articles précédents nous avons vu "le kit de survie" d'OCL c'est à dire les bases fondamentales du langage de règles de l'OMG.

Mais cela reste très théorique et on aimerait bien mettre tout ça en pratique et bien regardons quelques fonctionnalités que propose Eclipse EMF (Eclipse Modeling Framework).

Concevez le métamodèle Family (voir l'article "Ingénierie Dirigée par les Modèles (IDM) : tutoriel Eclipse Ecore, le corps à corps avec les méta modèles"  http://www.urbanisation-si.com/ingenierie-dirigee-par-les-modeles-idm-tutoriel-eclipse-ecore-le-corps-a-corps-avec-les-meta-modeles).

Créez un objet de type Family :

  • Double cliquez sur sur le fichier Families.ecore
  • Dans l'arborescence, clic droit sur Family - Create Dynamic Instance ...
  • Le fichier Family.xmi est créé.
  • Remarque : attention a bien renseigné les propriétés Name, Ns Prefix et Ns URI du EPackage Families de Families.ecore sinon vous un message d'erreur dans le fichier XMI stipulant que l'URL est nulle !
  • Double cliquez sur Family.xmi, le fichier s'ouvre en mode texte.
  • Clic droit sur le fichier - Open With -  Sample Reflective Ecore Model Editor
  • En dessous de Platform - cliquez sur Family - Properties Last Name=Dupond
  • Clic droit sur Family - New Child - Daughters Member - une instance de Member est créée, sélectionnez et renseignez First Name=Elsa
  • Créez une 2ème fille Emma.

Pour tester des expressions OCL, utilisons la console OCL :

  • Sélectionnez Family - clic droit - OCL - Show OCL Console. C'est la où les Athéniens atteignirent.
  • Un objet sélectionné dans l'éditeur graphique Family.xmi représente l'objet courant donc self. 
    Sélectionnez Family Dupond

La console est divisée en 2 partie : la partie supérieure est réservée aux résultats et la partie inférieurs aux expressions OCL

Exemple :

  • Saisissez daughters et faites Entrée, la partie résultats affichent Elsa et Emma
  • La touche Page précédente rappelle les dernières expressions saisies.
  • Saisissez daughters->s la completion automatique s'affiche, double cliquez sur size() et Entrée
  • Results=2
  • La completion s'obtient avec CTRL espace
  • Saisissez : daughters->size()<2
  • Results=false

Une fois les expressions OCL testées dans le console, nous pouvons les ajouter en Java :

  • Clic droit sur Families.ecore - Open With - OCLinEcore Editor - l'éditeur Ecore Java s'ouvre avec les classeEcore : Family et Member :
  • Ajouter dans la classe Family la contrainnte :
invariant maxFilles:
   Family.daughters->size()<2;

 

tutoriel-ocl-eclipse-1.png

 

Cliquez dans l'éditeur graphique Family.ecore

 

tutoriel-ocl-eclipse-2.png

 

On constate que la contrainte a été ajoutée. On pourrait la créer et la modifier directement dans l'éditeur :

  • Sélectionnez Families.ecore - Family - New Child - EAnnotation - Properties - Key=maxFilles - Value=Family.daughters->size()<2

N'oubliez pas Save All régulièrement.

Pour finir, vérifions la validation :

  • Family.xmi -  clic droit sur Family Dupond - Validate - une popup "Validation Problems" s'affiche avec le message concernant la contriante maxfilles qui n'est pas respectée.

Voilà fin de cette petite mise en jambe pour la mise en pratique d'OCL, nous aurons l'occasion de pratiquer OCL plus intensivement dans nos prochains articles consacrés à la transformation de modèles et à ATL (ATLAS Transformation Language).

 
"Chacun rêve de changer l'humanité, mais personne ne pense à se changer lui-même."
Léon Tolstoï

 

Voir aussi :  

 

http://urbanisation-si.wix.com/blog

http://urbanisme-si.wix.com/blog

http://urbanisation-si.wix.com/urbanisation-si

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

http://rhonamaxwel.over-blog.com/

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

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

http://urbanisation-si.eklablog.com/


23/08/2015
0 Poster un commentaire

Modélisation de système : tutoriel OCL, la gestion des évènements

 

tutoriel-ocl-omg-gestion-des-evenements.png

Ce tutoriel OCL (Object Constraint Language) est consacré à la gestion des évènements.

Pour illustrer ce concept, nous utiliserons le fameux design pattern du GoF (Gang of Four d'après la bande des 4 experts qui ont écrit en 1995 le livre contenant une vingtaine de solutions de conception objet génériques et qui ont révolutionné le monde du développement et de l'architecture logiciel).

Pour ceux qui ne ne connaissent pas leurs gammes, une description du problème, d'un exemple classique de gestion et bien entendu de la solution  se trouvent dans mon article publié sur ce blog :  http://www.urbanisation-si.com/urbanisation-du-systeme-d-information-creez-l-evenement

En OCL pour spécifier qu'un message signalant un évènement a été envoyé, on utilise l'opérateur ^

Exemple :

context Subject::hasChanged()
   post: observer^update(12, 14)

Le résultat de observer^update(12, 14) est vrai si le message update avec les arguments 12 et 14 a été envoyé à "observer" pendant l'exécution de l'opération.

Update() est soit une opération de la classe Oserver ou bien un signal spécifié dans le modèle UML.

Si les valeurs des paramètres sont inconnues au moment de l'appel, on remplace par des ?

context Subject::hasChanged()
   post: observer^update(? : Integer, ? : Integer)

OCL défini un type message spécial OclMessage qui peut être reçu par l'opérateur ^^

context Subject::hasChanged()
   post: observer^^update(12, 14)

Le résultat est une Sequence de OclMessage.

context Subject::hasChanged()
   post: let messages : Sequence(OclMessage) = observer^^update(? : Integer, ? : Integer) in
      messages->notEmpty() and
      messages->exists( m | m.i > 0 and m.j >= m.i )

Un OclMessage peut être envoyé à plusieurs cibles. Messages est une Sequence d'OclMessage dont chaque occurrence est envoyée à un observer cible :

context Subject::hasChanged()
  post: let messages : Sequence(OclMessage) =
    observers->collect(o | o^^update(? : Integer, ? : Integer) ) in
      messages->forAll(m | m.i <= m.j )

Autre exemple, soit une opération Company::getMoney(amount :Integer) : Boolean

context Person::giveSalary(amount : Integer)
   post: let message : OclMessage = company^getMoney(amount) in
      message.hasReturned() -- getMoney a été envoyée et retournée
and
      message.result() = true -- l'appel à  getMoney a retourné true

Voilà à travers ces quelques articles, nous avons appris les rudiments d'OCL.

Ce kit de survie nous servira pour nos futurs articles sur l'ingénierie dirigée par les modèles et les transformations de modèles. 

 

"Soyons reconnaissants envers les personnes qui nous donnent du bonheur ; elles sont les charmants jardiniers par qui nos âmes sont fleuries."
Marcel Proust

 

Voir aussi :  

 

http://urbanisation-si.wix.com/blog

http://urbanisme-si.wix.com/blog

http://urbanisation-si.wix.com/urbanisation-si

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

http://rhonamaxwel.over-blog.com/

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

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

http://urbanisation-si.eklablog.com/


22/08/2015
0 Poster un commentaire

Modélisation de système : OCL vous en redemandez ?

modelisation-systeme-tutoriel-OCL-UML-2.png

Pour spécifier une classe d'association (Job ou Marriage dans le diagramme de classe UML) :

context Person inv:
   self.Job[employer]

On peut naviguer à partir de la classe d'association vers les objets participants :

context Job
   inv: self.employer.numberOfEmployees >= 1
   inv: self.employee.age > 21

Naviguez à travers des associations qualifiées : pour obtenir la personne possédant le compte bancaire 123456789

context Bank inv:
   self.customer[123456789]

Pour spécifier un chemin complet avec des package :

Packagename1::Packagename2::Typename

Accédez aux propriétés d'un supertype :

context B inv:
   self.oclAsType(A).p1 -- accède à la propriété p1 définie dans le supertype A (B hérite de A)
   self.p1 -- accède à la propriété p1 définie dans B (B est l'objet courant)

Propriétés prédéfinies pour tous les objets :

oclIsTypeOf (t : Classifier) : Boolean
oclIsKindOf (t : Classifier) : Boolean
oclIsInState (s : OclState) : Boolean
oclIsNew () : Boolean
oclAsType (t : Classifier) : instance de Classifier
context Person
   inv: self.oclIsTypeOf( Person ) -- = true
   inv: self.oclIsTypeOf( Company) -- = false

Membres statiques d'une classe :

context Employee::id : String init:
   Employee::uniqueID()

Si nous voulons que toutes les instances de Personne aient un nom unique :

context Person inv:
   Person.allInstances()->forAll(p1, p2 | p1 <> p2 implies p1.name <> p2.name)

La gestion des collections : Set = pas de doublons ; Bag = doublons possible ; Sequence = Bag ordonné ; OrderedSet = Set ordonné

Ces collections sont définies dans "OCL Standard Library".

Exemples :

Set { 1 , 88, 5, 2 }
Set { 'strawberry', 'apple', 'orange' }
Sequence { 45, 3, 3, 2, 1 }
Sequence { 'ape', 'nut' }
Bag {1, 3, 4, 3, 5 }

Selectionner les personnes qui ont plus de 50 ans (les 2 expressions suivantes sont équivalentes) :

context Company inv:
   self.employee->select(age > 50)->notEmpty()

context Company inv:
   self.employee->select(p | p.age > 50)->notEmpty()

Pour obtenir tous les éléments pour lesquels la condition est fausse (l'inverse du select), exemple, pour avoir les célibataires :

context Company inv:
   self.employee->reject( isMarried )->isEmpty()

Pour obtenir des collections différentes (les 3 expressions suivantes sont équivalentes) :

self.employee->collect( birthDate )
self.employee->collect( person | person.birthDate )
self.employee->collect( person : Person | person.birthDate )

Pour savoir (le résultat sera vrai) si une condition s'applique (est vraie) sur toutes les occurrences :

context Company
   inv: self.employee->forAll( age <= 65 )
   inv: self.employee->forAll( p | p.age <= 65 )
   inv: self.employee->forAll( p : Person | p.age <= 65 )

Pour savoir si une condition s'applique sur au moins une occurrence :

context Company inv:
   self.employee->exists( forename = 'Jack' )
context Company inv:
   self.employee->exists( p | p.forename = 'Jack' )
context Company inv:
   self.employee->exists( p : Person | p.forename = 'Jack' )

Itération (les 2 expressions suivantes sont équivalentes) :

collection->collect(x : T | x.property)
-- est identique à :
collection->iterate(x : T; acc : T2 = Bag{} |
acc->including(x.property))

Nous verrons dans un prochain article la gestion des messages.

 

"Assume ton destin. Derrière les soucis, le chagrin et la peur, tu découvriras alors l'extraordinaire bonheur qu'est la confiance en soi."
Richard Dehmel

 

Voir aussi :  

 

http://urbanisation-si.wix.com/blog

http://urbanisme-si.wix.com/blog

http://urbanisation-si.wix.com/urbanisation-si

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

http://rhonamaxwel.over-blog.com/

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

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

http://urbanisation-si.eklablog.com/


21/08/2015
0 Poster un commentaire

Modélisation de système : OCL ça se complique !

modelisation-systeme-OCL-UML-OMG-03.png

Dans l'article précédent, nous avons vu une introduction et quelques bases d'OCL (Object Constraint Language).

Le moment est arrivé, pour aller un peu plus loin dans des éléments de syntaxe plus complexes toujours avec notre diagramme de classe (voir http://www.urbanisation-si.com/modelisation-de-systeme-uml-n-est-rien-sans-ocl ).

 

Exemple d'énumération :

context Person inv: gender = Gender::male

Réutiliser une variable :

context Person inv:
   let income : Integer = self.job.salary->sum() in 
if isUnemployed then
   income < 100
else
   income >= 100
endif

Pour réutiliser des variables/opérations à partir de plusieurs expressions OCL :

context Person
def: income : Integer = self.job.salary->sum()
def: nickname : String = ‘Little Red Rooster’
def: hasTitle(t : String) : Boolean = self.job->exists(title = t)

 

Pour les opérations/attributs statiques :

context MyClass
static def : globalId() : Integer = ...

Quand on est certain qu'un type courant d'un objet est un sous-type alors on peut le transtyper (caster) :

object.oclAsType(Type2) --- change le type statique de l'expression en Type2

Les opérateurs de naviagation sont . pour les attributs/opérations et -> pour les collections, opération ou itération :

anObject.name aString.indexOf(':')
aBag->elementType aSet->union(anotherSet) aSet->collect(name)

Les mots clés :

and body context def derive else endif endpackage false if implies in init inv invalid let not null or package 
post pre self static then true xor

Les mots restreints :

Bag Boolean Collection Integer OclAny OclInvalid OclMessage OclVoid OrderedSet Real Sequence Set 
String Tuple UnlimitedNatural

Commentaire : tout ce qui suit 2 signes moins -- et se trouve avant la fin de la ligne est un commentaire.

Les attributs :

context Person inv:
self.age > 0

Les opérations

L'appel :

aPerson.income(aDate)
aPerson.income(aDate).bonus = 300 and
aPerson.income(aDate).result = 5000

La définition :

context Person::income (d: Date) : Integer
post: result = age * 1000

Les associations :

context Company
   inv: self.manager.isUnemployed = false
   inv: self.employee->notEmpty()

context Person inv:
self.employer->size() < 3

context Person inv:
   self.wife->notEmpty() implies self.wife.gender = Gender::female

context Person inv:
   (self.wife->notEmpty() implies self.wife.age >= 18) and
   (self.husband->notEmpty() implies self.husband.age >= 18)

context Company inv:
self.employee->size() <= 50


On ne peut pas tout dévoiler tout de suite, le reste fera l'objet d'un prochain article.
 

"Les seuls beaux yeux sont ceux qui vous regardent avec tendresse."
Coco Chanel

 

Voir aussi :  

 

http://urbanisation-si.wix.com/blog

http://urbanisme-si.wix.com/blog

http://urbanisation-si.wix.com/urbanisation-si

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

http://rhonamaxwel.over-blog.com/

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

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

http://urbanisation-si.eklablog.com/


21/08/2015
0 Poster un commentaire

Modélisation de système : UML n'est rien sans OCL !

modelisation-systeme-tutoriel-OCL-UML-2.png

L'Object Constraint Language (OCL) est un langage normalisé par l'OMG (Object Management Group) qui permet d'ajouter des containtes aux objets d'un modèle UML (Unified Modeling Language) en évitant les ambiguités du langage naturel.

C'est un langage de pure spécification sans effets de bord.

Quand une expression OCL est évaluée, elle retourne une valeur sans rien changer dans le modèle.

L'état du système n'est jamais modifié à cause de l'évaluation d'une expression OCL même si l'expression est utilisée pour spécifier le changement d'état dans une post condition.

OCL n'est pas un langage de programmation. Il est impossible d'invoquer des process ou d'activer des opérations qui ne seraient pas des requêtes.

OCL n'est pas directement exécutable. Nous verrons qu'avec le plugin OCL d'Eclipse et son framework EMF (Eclipse Modeling Framework), il est possible de lancer la validation d'un modèle comportant des contraintes OCL. Le framework permet du reste d'intégrer des contraintes OCL dans du code Java manipulant le modèle.

OCL est typé.

OCL peut être utilisé :

  • Comme un langage de requêtes
  • Pour spécifier des invariants
  • Pour décrire des pré et post conditions
  • Pour décrire des conditions
  • Pour spécifier des messages et des actions
  • Pour spécifier des contraintes sur des opérations
  • Pour spéciifer les règles de déduction sur les attributs (attributs dérivés ou déduits)

Le mot clé self (même sémantique que le this du C++, Java ou C#) fait référence à une instance du contexte.

Le mot clé context : permet de définir le contexte (classe, attribut, opération).

Une expression OCL est un « invariant », si elle est vraie pour toutes les instances du type auquel elle est associée.

Exemple : comment spécifier en UML que les sociétés de notre modèle doivent avoir un nombre d'employés strictement supérieur à 50 ?

context Societe inv: self.nombreEmploye>50 

Dans le contexte Societe :

  • le nombre d'employés doit toujours être > à 50, 
  • self est une instance de Societe
  • inv: est une étiquette déclarant la contrainte comme un invariant.

Les pré et post condition d'une opération :

context Typename::operationName(param1 : Type1, ... ): ReturnType
pre : param1 > ...
post: result = ...

Exemple :

context Person::income(d : Date) : Integer
post: result = 5000

Dernier exemple pour la route, écrivons une opération qui renvoie la liste des employés mariés :

context Societe::getEmployesMaries():Set
pre: self.employes.notEmpty()
body: self.employes->select(e | e.estMarie=true)

Dans un prochain article nous verrons des concepts avancés d'OCL qui sont très utiles pour les transformations de modèles.

 

"Fais preuve de gentillesse envers tous ceux que tu rencontres, leur combat est peut-être plus dur que le tien."
Platon

 

Voir aussi :  

 

http://urbanisation-si.wix.com/blog

http://urbanisme-si.wix.com/blog

http://urbanisation-si.wix.com/urbanisation-si

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

http://rhonamaxwel.over-blog.com/

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

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

http://urbanisation-si.eklablog.com/


20/08/2015
0 Poster un commentaire

Modélisation de système : rien n'est parfait du premier coup alors mettez en place une gestion de version

modelisation-de-systeme-gestion-de-configuration-logicielle.png

 

Réfléchissez à comment vous allez gérer vos differentes versions de modèles dans l'AGL que vous avez choisi pour vos projet.

Ne faites pas comme dans ce projet ou MEGA était utilisé sans gestion de version.

Au fil des itérations et des évolutions, il fallut bien faire quelque chose.

Alors l'administrateur eût la brillante idée de concevoir un méta modèle en créant une entité changement et une série de scripts pour qu'à chaque fois que l'utilisateur apporte une modification, il aille lui même dans un nouvel onglet créer un changement en indiquant son type et ce sur quoi il porte.

Cela permet de connaître les évolutions d'une iteration et de générer juste le différentiel dans le Modèle Physique de Données.

Par contre, rien n'est automatique, il faut que l'utilisateur pense lorsqu'il fait une modification à créer un changement, indiquer le type, ... Si finalement il décide d'annuler son changement, il faut aussi qu'il supprime le changement. Et s'il oublie de le faire ?

La seule et unique bonne solution consiste à installer au départ une Gestion de Configuration Logicielle comme Microsoft Visual Source Safe ou pour les opensource Subversion ou GIT. 

Ceci n'est pas un luxe mais une nécessité.

L'urbaniste ou l'architecte doit convaincre les sponsors que le surcoût sera largement rentabilisé à très court terme. 

 

"Nous portons en nous des merveilles que nous cherchons en dehors de nous."

Thomas Browne

  

Voir aussi :  

http://urbanisation-si.wix.com/blog

http://urbanisme-si.wix.com/blog

http://urbanisation-si.wix.com/urbanisation-si

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

http://rhonamaxwel.over-blog.com/

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

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

http://urbanisation-si.eklablog.com/


06/06/2015
0 Poster un commentaire

Modélisation de système : Soyez maniaque, croisez et recroisez vos modèles UML pour être certain qu'ils soient valides (12)

Automatisation de la vérification des modèles UML.

modelisation-de-systeme-verification-des-modeles-UML-12.png

En s'inspirant des techniques de compilation, la vérification dans le langage UML est découpée en deux parties : syntaxe et sémantique.

La syntaxe abstraite (les structures réelles du langage, indépendamment du sucre syntaxique) est celle définie par le métamodèle.

En compilation, toujours, les vérifications lexicales, syntaxiques et certaines vérifications sémantiques sont dirigées par la syntaxe.

Dans UML, comme nous I'avons vu, bon nombre de règles lexicales, syntaxiques et de sémantique statique peuvent être formulées à partir du métamodèle.

La structuration des règles est induite par Ia syntaxe : elles sont rangées par élément de rnodélisation. Ces règles, pour peu quelles soient formalisées, sont décrites sous forme d'assertions OCL. Pour vérifier les règles, il faut disposer d'outils d'évaluation et de preuve pour OCL.

Pour automatiser la vérification des règles, il faut les formuler dans le langage OCL et disposer d'outils pour Ie contrôle, la preuve et l'évaluation avec OCL.

En résumé, il faut qu'OCL soit un langage formel à part, entière et outillié.

Un premier travail consiste, à partir de la description du langage OCL, à développer un environnement de développement autour d'OCL (edition, compilateur, évaluateur, débogueur, etc.) et une interface avec le métamodèle.

Ce travail permettra alors d'étudier en profondeur le langage et de lui donner une sémantique formelle, condition indispensable pour vérifier la pertinence, la cohérence ou mieux la complétude des règles.

Pour que la vérification puisse s'intégrer avec le processus de développement, il faut pouvoir associer des degrés de vérification au niveau d'itération atteint. On accordera plus d'importance à certaines propriétés du système et des modèles dans les premières itérations et plus d'importance à d'autres dans les dernières itérations. La vérification va de pair avec le niveau de détail exigé.

 

"Il ne faut pas pleurer pour ce qui n'est plus mais être heureux pour ce qui a été."

Marguerite Yourcenar

   

Voir aussi :  

http://urbanisation-si.wix.com/blog

http://urbanisme-si.wix.com/blog

http://urbanisation-si.wix.com/urbanisation-si

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

http://rhonamaxwel.over-blog.com/

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

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

http://urbanisation-si.eklablog.com/


31/05/2015
0 Poster un commentaire

Modélisation de système : Soyez maniaque, croisez et recroisez vos modèles UML pour être certain qu'ils soient valides (11)

Quels besoins en pratique ?

modelisation-de-systeme-verification-des-modeles-UML-11.png

La vérification repose sur des descriptions complètes des modèles, une liste exhaustive et cohérente de règles de vérification, un ordre d'application de ces règles. En pratique, elle repose aussi sur une automatisation du processus, dans I'AGL qui permet de saisir les modèles puis de les exploiter.

Une vérification de cohérence n'est pas possible si les diagrammes sont volontairement incomplets c'est-à-dire si tout ce qui est noté dans un diagramme n'a pas besoin d'être noté dans I'autre, l'union des deux donnant le modèle global.

Par exemple, si dans un diagramme états-transitions les opérations et les événements émis ne sont pas modélisés, il est difficile de vérifer la cohérence avec le diagramme de classes, les diagrammes d'objets et les autres diagrammes états-transitions.

En résumé, des vérifications sont possibles si les diagrammes ont un niveau de détail suffisant.

Dans un processus itératif et incrémental, les seuls modèles complets sont ceux qu'on obtient à la fin du processus.

La seule sémantique formelle est celle du langage de programmation cible. A chaque itération du processus unifié, les différents modèles du systèmes sont enrichis, sachant que les modèles d'analyse des besoins, d'analyse et de conception sont plus complets dans les premières phases (préparation, élaboration) tandis que les modèies de déploiement, d'implantation et de test sont plus riches dans les dernières phases (construction, transition).

La vérification doit s'adapter à cette réalité : on travaille rarement avec des modèles complets.

Il est en effet souhaitable dans un modèle d'analyse de donner I'allure générale sans trop de détails. Ainsi, pour conserver un certain niveau d'abstraction, on peut omettre le profil des opérations, la description interne des opérations, ne définir que des interfaces pour certains paquetages ou certaines classes, etc.

L'usage de la vérification doit prendre en compte ces contraintes pratiques. On peut imaginer plusieurs niveaux de vérification, un filtrage de certaines règies, des priorités dans les erreurs relevées, des degrés de vérification) une qualité de la vérification, etc. 

 

"Nous sous-estimons souvent le pouvoir d'un contact, d'un sourire, d'un mot gentil, d'une oreille attentive, d'un compliment sincère, ou d'une moindre attention ; ils ont tous le pouvoir de changer une vie."

Leo Buscaglia

  

Voir aussi :  

http://urbanisation-si.wix.com/blog

http://urbanisme-si.wix.com/blog

http://urbanisation-si.wix.com/urbanisation-si

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

http://rhonamaxwel.over-blog.com/

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

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

http://urbanisation-si.eklablog.com/


31/05/2015
0 Poster un commentaire