Sortie de ATL 2

Posté par (page perso) . Modéré par Mouns.
Tags :
0
27
mai
2008
Technologie
Après plusieurs années d'effort, la première version d'ATL intégrée à la distribution standard d'Eclipse sort officiellement. ATL est un projet de transformation de modèles suivant l'approche MDA.

ATL 2 marque un tournant dans le projet car il représente le 1er résultat visible des travaux d'industrialisation par une entreprise française (Obeo) des résultats d'un laboratoire de recherche de l'INRIA.

En plus de cette collaboration et de nombreuses nouveautés techniques, ATL 2 est donc maintenant inclus dans le prochain Eclipse 3.4 au sein de Eclipse Modeling Project. ATL sert dans de nombreux cas :
  • interopérabilité entre outils
  • raffinement (différents niveaux de "zoom" sur un modèle, pour par exemple passer d'une conception générale à une conception détaillée)
  • extraction d'information
  • traductions de sémantique (par exemple, d'un Profil UML vers un métamodèle dédié)
  • refactoring de modèle.

ATL se base sur de nombreux standards tels que XMI, OCL et Ecore, et il a même fait parti des contributions initiales au standard QVT de l'OMG.
Grâce à ce respect des standards, ATL peut s'insérer dans une chaîne d'outils libres et bâtis sur Eclipse : UML2 avec Topcased ou Papyrus, métamodèles avec EMF, modeleurs dédiés avec GMF, génération de code avec Acceleo.
La licence de ATL, comme tous les projets de la fondation Eclipse, est EPL.

Les nouveautés de ATL 2 :
  • machine virtuelle (ATL VM) basée nativement sur EMF
  • performances (jusqu'à x20 ! )
  • complétion dans l'éditeur des règles de transformation
  • intégration au système de build Eclipse.org
  • installation par updatesite
  • stabilisation et correction de bugs.

La collaboration labo / PME est une parfaite illustration de ce qu'essaient de faire les pouvoirs publics demander à des grands industriels d'émettre des besoins de R&D, faire naître des idées par des chercheurs et les laisser faire des prototypes les validant, et enfin proposer à une entreprise d'édition logiciel d'en faire un produit et de porter une offre commerciale viable.
Dans le cas d'ATL, ces travaux ont pris place à travers des projets collaboratifs issus de pôles de compétivité (System@atic à Paris, Aerospace à Toulouse et Images & Réseau à Nantes), notamment grâce au projet Edona financé par la DGE (Direction Générale des Entreprises) qui vise à construire une plateforme de conception de systèmes automobiles.
Obeo, de par son implication déjà très forte dans l'OpenSource (contributions à Acceleo) et dans la fondation Eclipse (8 commiteurs), a ainsi été choisi pour porter à la fois les développements techniques et l'offre de services (formations, support, sur-mesure et conseils) au dessus d'ATL. L'INRIA peut ainsi se recentrer sur ses activités de recherche, et les industriels obtiennent un support professionnel. Cette collaboration montre que le logiciel libre est un vecteur efficace et rentable de distribution d'une technologie innovante.

Historique du projet :
  • 1990 : premiers travaux sur la transformation de modèles
  • 1998 : publication initiale d'une première proposition dans le cadre d'une thèse à l'Université de Nantes (suivie par Jean Bézivin)
  • 2004 : Première mise en œuvre du langage ATL réalisée dans le cadre du projet CARROLL/MOTOR
  • 2005 : Projets collaboratifs tels que ModelWare, ModelPlex, Usine Logicielle ou OpenEmbeDD
  • 2004 : le projet Eclipse GMT est créé afin d'accueillir en incubation des projets de recherche sur les outils de modélisation
  • 2006 : Obeo donne naissance à sa première contribution OpenSource nommée Acceleo
  • fin 2006 : ATL est promu technologie à vocation industrielle au sein de Eclipse M2M
  • 2007 : Obeo commence les travaux d'industrialisation et lance l'initiative ATL Pro (http://www.atl-pro.com)
  • 2008 : sortie d'ATL 2.0.

Aller plus loin

  • # ...

    Posté par . Évalué à -10.

    [BiDe]
  • # C'est pas de chance...

    Posté par . Évalué à 1.

    Marrant, je viens de rendre un travail en utilisant la version 1... ils n'auraient pas pu attendre quelques jours :P ?
    • [^] # Re: C'est pas de chance...

      Posté par (page perso) . Évalué à 2.

      Et ça nous avance à quoi de le savoir ?
      Par contre tes appréciations seraient grandement appréciées :
      - Quelles sont les qualités de ATL 1, ses défauts et ceux qui sont corrigés par ATL 2 ?
      - Facilité d'utilisation
      - Vitesse d'apprentissage.
      - ...
      • [^] # Re: C'est pas de chance...

        Posté par . Évalué à 4.

        Oui c'est vrai, j'aurai du un peu expliquer.

        Déjà, un chouette point, c'est que ATL peut travailler sur un modèle ecore (disponible dans eclipse), et qu'il existe un outil graphique dans eclipse pour créer ses modèles et méta-modèles en ecore: topcased.

        Mon travail était de créer une transformation qui au départ d'une modèle d'architecture hardware ajoutait une couche de sécurité (par l'ajout de composant de sécurité).

        Une transformation est décrite par un ensemble de règle de transformation. Ces règles spécifient comment un objet dans le modèle de départ doit être représenté dans le modèle d'arrivé.

        Les relations entre les eclasses (objets du modèle, un peu comme les classes dans les diagrammes de classes d'UML) sont préservées automatiquement lors de la transformation et ce n'est pas au concepteur de la transformation de le faire.
        Cela permet de simplifier le code énormément puisqu'il suffit de réellement coder la partie "modifiée" du modèle.

        Le langage en lui-même est assez "bizarre" au premier abord. On dirait un peu un mélange de différent paradigme de programmation.

        Voici un exemple de règle (juste pour donner une idée) :

        rule CopyInterfaces {
        from
        oa: adl!Interface
        to
        na: adl!Interface (
        -- copy the attributes
        name <- oa.name
        )
        }


        En ce qui concerne les défauts, il faut d'abord savoir que si le script ATL n'est pas dans un projet ATL, ca ne marchera pas.
        Ensuite, les erreurs sont assez peu explicites.

        Il paraît qu'il y a un outil de debug intégré, mais je ne l'ai pas trouvé. Et c'est vraiment ce qu'il manquait dans ATL.
        Car quand la transformation ne s'exécute pas correctement, il est souvent difficile de savoir d'où vient le problème.

        Enfin, je vais un peu regarder cette nouvelle version, on va voir ce qui est vraiment amélioré.
        • [^] # Re: C'est pas de chance...

          Posté par . Évalué à 6.

          Ça à l'air génial (et je bosse dans le même labo que quelques contributeurs), mais punaise, j'ai rien compris.

          En langage naturel, ça donne quoi ? Ça sert à quoi ?

          Sinon, félicitation à toutes les équipes, c'est une belle collaboration !
          • [^] # Re: C'est pas de chance...

            Posté par . Évalué à 3.

            Je ne connais pas atl mais si j'essaie d'imaginer.

            On a une transformation qui prend un modèle en entrée (oa ?) décrit par métamodèle et crée un autre modèle en sortie (na ?)

            Ici on décrit un règle qui se contente de recopier le concept "Interface" (UML?) d'un modèle à l'autre et qui lui affecte le champ name de l'interface de épart

            C'est un langage déclaratif.
            Après il y a un runtime qui passe en revue le modèle d'entrée et lui applique toutes les régles définies.
            Ca finit par reconstruire un modèle en sortie
            Un peu comme le ferait Prolog avec son moteur d'inférence
  • # OMG

    Posté par (page perso) . Évalué à 10.

    les sigles (ATL, XMI, OCL, XML, EMG, UML, GMF, EPL, OMG, PME, DGE ...) ça rend tout de suite un article plus pro.
    • [^] # Re: OMG

      Posté par (page perso) . Évalué à 6.

      C'est vrai que ça rend pros mais il faut bien appeler les organisme et normes par leurs noms.

      Heureusement que certains documents explique le trus car sinon c'est vrai que pour un non spécialiste il y a un niveau de différence.

      Excellent intro sur le méta-modèle et eclipse en français : [http://www.topcased.org/IMG/pdf/TOPCASED_neptune_2005_A4.pdf]
      • [^] # Re: OMG

        Posté par . Évalué à 7.

        >C'est vrai que ça rend pros mais il faut bien appeler les organisme et normes par leurs noms.

        Sauf que ce ne sont *pas* des noms, ce sont des sigles.

        Et la mauvaise habitude d'utiliser des sigles sans les détailler la première fois, c'est franchement désagréable..
        • [^] # Re: OMG

          Posté par . Évalué à 4.

          Pour la défense de l'auteur je dirais qu'il à quand même fait des wikiliens pour chaque *sigle*. Même s'il aurait était mieux d'avoir une légère inclusion dans la page.
          • [^] # Re: OMG

            Posté par (page perso) . Évalué à 5.

            + le fait que la balise acronym soit utilisée, il "suffit" donc pour certains d'entre eux de passer le curseur dessus...
            • [^] # Re: OMG

              Posté par (page perso) . Évalué à 3.

              Si tu regardes le lien wikipedia, je fais toujours l'effort de prendre celui avec le nom complet plutôt que l'acronyme (le lien apparaît dans le navigateur dans la fenêtre de statut chez moi). Là c'est un autre relecteur que moi qui a fait l'effort de rajouter en plus la balise acronym pour afficher une info-bulle ;-)
            • [^] # Re: OMG

              Posté par . Évalué à 2.

              Bonne remarque merci: je n'ai pas l'habitude faire ça, mauvaise habitude: changer habitude.
        • [^] # Re: OMG

          Posté par (page perso) . Évalué à 3.

          Tu dis souvent le projet "Gnu's Not Unix" ? ou "Digital Versatil Disk" ? Même seulement la première fois que tu les emplois devant une personne ? "Visual", à la place de Vi ( http://fr.wikipedia.org/wiki/Vi ) ? "Editing MACroS running on TECO" pour Emacs ( http://fr.wikipedia.org/wiki/Emacs ) ?

          Les sigles expriment souvent quelquechose de complexe et évitent les néologismes à la mort moi le noeud.

          Au bout d'un certain temps, il faudrait leur donner un vrai nom par contre... Mais rassurons nous, l'académie française veille, et nous trouve des mots tels que "cédérom" pour remplacer les sigles! Une grande avancée pour l'humanité.

          Quelqu'un de familier avec Eclipse aura reconnu la plupart des sigles en sachant ce qu'ils font, mais pas forcément en connaissant leur signification.

          Bref d'une manière générale, c'est l'abus de vocabulaire complexe (par rapport au public visé par l'article) qui est a condamner, pas les sigles en particulier.
    • [^] # Re: OMG

      Posté par (page perso) . Évalué à 1.

      Les TLA, il n'y a que ça de valable.
  • # Ca a l'air vachement bien

    Posté par (page perso) . Évalué à 10.

    Dommage qu'on n'ait pas la moindre idée de l'intérêt de ce genre de choses.

    Un exemple "dans la vraie vie" c'aurait été mieux.

    Parce que pour moi, ces histoires de transformation de modèle, ça sent la masturbation intellectuelle à plein nez.
    • [^] # Re: Ca a l'air vachement bien

      Posté par (page perso) . Évalué à 3.

      C'est vrai qu'on a pas grand chose à se mettre sous la dent. J'ai fureté sur le site de Bézivin (dont j'ai entendu parler comme d'un espèce de mandarin, à Nantes), et j'ai trouvé ça http://www.softmetaware.com/oopsla2003/bezivin.pdf qui est censé montrer un exemple de la vrai vie.

      Ca ressemble à un chaipaskoi, mais bitable, ce qui est à relever dans le monde universitaire, avec un espèce de SQL pour filtrer les données.

      A part ça, si l'auteur de la news pouvait nous expliquer l'apport de tout cela par rapport à un énième méta-truc générateur de code....

      Je vais quand même esssayer de creuser....

      « Il n’y a pas de choix démocratiques contre les Traités européens » - Jean-Claude Junker

      • [^] # Re: Ca a l'air vachement bien

        Posté par . Évalué à 10.

        Bon je vais m'essayer à un petit laïus sur le sujet bien que ne faisant pas autorité en la matière.

        Attention ! victoire au Business Loto garantie


        Dans les MDA, MDE, MDSD, ... et consorts, ce qui revient est le modèle qui est placé au coeur du processus de développement d'où le MD (Model Driven)
        Déjà il faut voir un intérêt dans la modélisation pour le génie logiciel.
        Les modèles permettent de s'abstraire de la complexité des systèmes réels pour n'en retenir que certains aspects qui nous intéressent. Le réel ne pouvant souvent pas être appréhendé dans sa globalité par un être humain.

        Les modèles, on en trouve un peu partout. On a les standards: UML pour l'objet, SysML, le BPMN pour les services, .... mais aussi certains outils, métiers ou entreprises ont développé leur propre formalisme. Les projets EMF/GMF d'Eclipse visent d'ailleurs à faciliter la vie de celles-ci. Plutôt que d'utiliser un langage généraliste comme UML qui devient gigantesque et dont seule une partie nous est utile , ils permettent de se fabriquer une notation graphique sur mesure. Mais ils permettent de décrire UML aussi (plugin uml2 au dessu de EMF/GMF). On parlera de DSL (Domain Specific Language). A un certain niveau les langages de programmation eux-même peuvent être perçus en tant que modèles. Tout ca est bien beau mais si j'utilise une notation pour représenter mes écrans d'IHM, que je rajoute un formalisme pour la modélisation des données relationnelles (MCD Merise) , un peu d'UML par ci et encore une notation propriétaire pour la description des mes processus métiers par là. Comment je fais pour vérifier la cohérence de l'ensemble et surtout pour la maintenir lorsque je fais le moindre changement. A la mimine ca décourage un peu.

        Et c'est là que l'OMG a sorti sa grande idée. Déjà on a les modèles.
        Chaque modèle est décrit par un langage. Et si on décrivait chacun de ces langages de modélisation par un modèle (le metamodèle) en utilisant un seul et même langage de description ? Et voici que le MOF (Meta Object Facility) fait son apparition. Il permet d'unifier tous les langages de modélisation et il s'auto-décrit. (Voir la fameuse pyramide 4 layers qui décrit tout ça - pas trouvé la photo). MOF étant une spec ,Eclipse avait donc besoin de l'implementer pour son projet EMF. Il s'agit d'Ecore (un sous-ensemble de MOF en fait). A partir de là on devient capable de faire des transformations de modèles entre 2 modèles d'un même langage mais aussi entre 2 modèles exprimé avec des formalismes différents puisqu'on maitrise la description de leur métamodèles. On parle de transformation M2M (Model 2 Model). Soyons joueur et décrivons la spec de ce langage de transformation. Nous l'appellerons QVT. ATL c'est une impléméntation de QVT même si elle en a un peu dérivé car QVT trainait un peu.
        Reste un problème: Comment à partir d'un modèle peut on arriver à générer du code ? En soi, le code est décrit par un langage qui dispose de sa propre grammaire et donc de son métamodèle.
        Toutefois écrire une transformation de M2M en considérant le code comme un modèle n'est pas chose aisée.
        On préfère souvent utiliser d'autres techniques comme des langages à base de template décrivant le code généré par un fichier d'exemple qui contient des balises. Elles pointent sur des éléments du métamodèle associé au modèle à partir duquel on génère. Un peu à la manière des JSPs par exemple. On parle alors de langages de transformation M2T (Model 2 Text)

        Acceleo par exemple joue dans cette catégorie et c'est pourquoi avec ATL, ils sont souvent complémentaires.
        OpenArchitectuware propose les 2 types de langages ainsi que d'autres outils propriétaires comme MIA. Certains préfèrent s'appuyer sur un tooling pour les transfo M2M comme par exemple Rational Software Architect.

        Dernière problématique. Passer d'un modèle à un autre n'est pas toujours évident car parfois on souhaite orienter la transformation ou lui rajouter des informations. Par exemple, passer d'un modèle UML d'analyse à un modèle de conception ou d'un modèle de conception à du code. Quitte a faire, ces infos de transfo ca n'est ni plus ni moin qu'un modèle . Appelons le modèle de marquage. Mais comment faire ? Soit on rajoute cette information dans le modèle de départ mais ca le pollue avec des informations inutiles pour ce niveau d'abstraction. C'est à ca que servent par exemple les profils UML qui sont des regroupements de stéréotypes.
        On peut aussi les rajouter au modèle d'arrivée. Là la difficulté est de les placer dans le modèle alors que celui-ci n'existe pas. La troisième
        est de l'associer à la transformation elle-même.

        On se retrouve avec une jolie querelle de chapelle entre les protagoniste de UML et ses profils et les zélotes des DSL.
        UML est standardisé et répandu. Il dispose d'outils graphiques et les profils sont faciles à mettre en oeuvre. Toutefois, il est trop riche pour les besoins et la mise au point des transformations ne s'en trouve pas facilitée. Les DSL quant à eux ne fournissent que le strict nécessaire. Mais on ne dispose pas encore de moyens simple pour en créer et notamment au niveau graphique même si ca s'améliore.
        Autre reproche ca nécessite à chaque fois de s'approprier un nouveau formalisme.
    • [^] # Re: Ca a l'air vachement bien

      Posté par . Évalué à 10.

      L'idée c'est de modéliser les langages de programmation comme tu modélises une application.
      J'ai ma méta-classe "classe" qui hérite de la méta-classe "type", qui contient un méta-attribut "nom" et qui est lié à la méta-classe "attribut", elle même ayant un méta-attribut "type" etc ...

      Ainsi, un programme écrit en java pourra se représenter comme une instance de ce méta-modèle. La classe "Personne" que j'ai écrit en java sera une instance de la méta-classe "classe", etc, etc ...

      Bon, comme tu le dis, si on s'en arète là, ça s'apparente fortement à de l'onanisme cérébral.

      Une idée c'est ensuite d'ajouter des méta-méthodes au méta-classes. Par exemple, une méta-méthode "rename" à la méta-classe "classe". Cette méthode renommera la classe mais aussi toutes les références à cette classe. Tu viens de créer un outil de refactoring de manière relativement aisée.

      Une autre idée est l'approche MDA (Model Driven Architecture) de l'OMG (Object Management Group).
      On commence par décrire l'application dans un modèle générique (disons UML puisqu'il vient aussi de l'OMG), c'est ce qu'on apelle le PIM (Platform Independant Model).
      On utilise ensuite une transformation de modèle pour transformer notre application en son équivalent dans un modèle spécifique, par exemple Java, c'est ce qu'on appelle le PSM (Platform Specific Model).
      Cette transformation est effectuée par un programme de niveau méta qui remplace chaque instance de "UML::Classe" par une instance de "Java::Classe" et ainsi de suite pour toutes les méta-classes du modèle de départ en s'appuyant sur un PDM (Platform Description Model).
      On obtient ainsi un équivalent Java de notre application UML initiale.

      Pourquoi s'emmerder à faire ça ? Eh bien, l'idée est de coder de manière indépendante de la plateforme d'exécution, puis, les spécificités de la plateforme sont décrites dans le PDM. Tu as donc une sorte de phase de compilation pour s'adapter à la plateforme et tu obtiens en résultat différent en fonction de tes ressources, de tes contraintes, etc ... Y compris, peut être dans un langage différent.
      • [^] # Re: Ca a l'air vachement bien

        Posté par (page perso) . Évalué à 5.

        eh beh c'est vraiment la classe et même la méta-classe, chapeau ! ;-)
      • [^] # Re: Ca a l'air vachement bien

        Posté par . Évalué à 4.

        Il me semble qu'ATL est un langage de transformation de modèles, ce qui peut aider dans les migation, genre pour l'exemple :

        Cobol vers java, j'ai un pote qui a bossé là dessus.

        L'idée, tu fais un meta-modèle de Cobol, un meta-modèle de java, et tu écris les règles de transformation au niveau du meta-modèle, genre au pif tu décris comment une description de fichier en cobol devient une une classe correspondante (un iterateur sur les lignes qui donne accès à chacune des collones, que sais-je, ...) avec qui va gérer ce fichier en java, etc, en ATL.

        Pour info, une description de fichier en ça ressemble à ça:

        http://www.labri.fr/perso/billaud/travaux/COBOL/poly-cobol-3(...)

        un fichier est une suite d'enregistremnt, tu décris un enregistremnt un peu à la SQL en donnant les champs et leur taille.
        Tu peux imaginer créer une classe en java qui a les attributs correspondants aux champs de l'enregistrement par exemple. Sauf que là tu fais ça au niveau du metamo


        Ensuite tu as simplement les outils pour générer du java à partir de ton appli cobol : Tu écris une règle de transfo et tu transforme toutes les descriptions de fichiers en Cobol que tu veux en la classe correspondante en java.
      • [^] # Ouille ouille

        Posté par (page perso) . Évalué à 4.

        L'idée est de coder de manière indépendante de la plateforme d'exécution. Moi qui croyait qu'un bon programme était presque à 100% indépendant de ce côté...
        Si Java a été créé, c'est bien pour cela.
        Si les langages tels que Ruby, Python, etc ont été créés, c'est bien avec cela en tête (entre autre).
        Si les bibliothèques pour le C ont été créées...
        etc.

        Je conçois qu'un programme tel qu'un défragmenteur de partitions NTFS avec un GUI Windows soit TRES lié à Windows: le programmeur n'en a probablement rien à fiche des autres systèmes.
        Mais pour ceux qui s'en préoccupent, les bonnes options prises dès le départ font que le programme est portable avec des modifications très mineures.
        En principe. :-) Car on a vite fait de dériver, d'aller dans une direction précise en oubliant un des buts initiaux.
        • [^] # Re: Ouille ouille

          Posté par . Évalué à 4.

          Par plate forme d'exécution ici, on entend bien plus que système d'exploitation.

          Genre : imagine, tu fais un modèle de blog, une démo d'un truc pour faire ça était passée ici il n'y a pas si logtemps.

          Le modèle contient les infos genre (en très gros)

          -> un blog c'est un ensemble de billets, un billet c'est un texte et un ensemble de commentaire (modèle de données)
          -> pour poster un nouveau billet, on a besoin d'entrer un texte, dans un champ texte
          -> pour afficher un billet, on affiche son texte, puis ses commentaire, puis un truc pour ajouter un commentaire
          -> un ajout de commentaire ajoute un commentaire dans la liste des commentaire du billet

          Vient ensuite la transformation, qui crée un programme blog à partir du modèle : les infos de la tranformation c'est par exemple :

          -> pour récupérer le texte d'un commentaire on affiche un champ html "< input type=text>"
          -> ...

          C'est là qu'on voit la puissance : suivant la transformation tu peux : générer du code html, pour apache, générer du QT, ...

          En gros tu laisse le programmeur se concentrer sur ce qu'il veut faire faire à son programme, c'est la transformation qui s'occupe de l'implémentation pure.
          • [^] # Re: Ouille ouille

            Posté par . Évalué à 4.

            En gros tu laisse le programmeur se concentrer sur ce qu'il veut faire faire à son programme, c'est la transformation qui s'occupe de l'implémentation pure.

            Si tant est que l'on puisse encore appeler ça un programmeur.
            Q: Dis papa, c'est quoi un programmeur ?
            A: C'est un monsieur qui a une énÖrme machine (eclipse (tm)(r) inside) et qui clique sur des boiboites pour créer un programme.

            M'enfin je dis ça, il y a 20 ans on s'est fait la même réflexion quand on a sérieusement commencer à remplacer l'assembleur par du C. Dans 20 ans, on sera un ringard à programmer en utilisant encore le clavier ;)
            • [^] # Re: Ouille ouille

              Posté par . Évalué à 5.

              Héhé, peut être pas, mais je crois qu'on a là effectivement quelque chose de comparable au passage de l'assembleur à des langages objets ou structurés.

              Genre tu monte en abstraction pour faire ressortir l'information essentielle.
          • [^] # Re: Ouille ouille

            Posté par (page perso) . Évalué à 3.

            J'ai compris, c'est un RAD.

            Le même genre que WinDev :-)

            Comme l'indique 'left' ça fait polémique.
            • [^] # Re: Ouille ouille

              Posté par . Évalué à 3.

              Rien à voir, déjà créer l'appli en quelque clic ce n'est qu'une des applications possible de la techno.

              D'ailleurs regarde du code ATL, tu verras qu'on est bien loin du Windev.
          • [^] # Re: Ouille ouille

            Posté par . Évalué à 6.

            C'est là qu'on voit la puissance : suivant la transformation tu peux : générer du code html, pour apache, générer du QT, ...

            C'est une vision très optimiste et j'attends de voir un lecteur de MP3 multi-toolkit (Qt et GTK+) générés par une approche MDA.

            Je vois quelques problèmes ; les transformations ont l'air d'être simples et magiques mais j'imagine qu'il y a de quoi s'arracher les cheveux pour écrire des règles de transformations qui marchent pour des cas un peu plus compliqués qu'un « Hello World ».

            D'autre part il faut trouver une correspondance entre les méta-modèles ce qui n'est pas à la portée de tout le monde.

            Enfin, ça a l'air de bien s'appliquer à la structure statique mais moins bien à l'aspect dynamique. Est-ce que vous proposez d'écrire le code en XML comme ce qu'on voit souvent pour les modèles ? Ou alors faut-il inclure du code directement dans les modèles (mais dans ce cas bye bye le PIM) ?
            • [^] # Re: Ouille ouille

              Posté par . Évalué à 2.

              Disclaimer : je suis pas du tout un spécialiste de l'ingénierie des modèles, ce que j'en dis c'est ma compréhension du truc.

              Et peut-être (sûrement) que FredFrisk pourrait passer derrière moi pour corriger mes erreurs et mes approximations.

              Mon exemple est tiré de la news http://linuxfr.org/2008/01/21/23592.html et la vidéo de démo est très parlante si tu veux mon avis.

              Sur le papier, et sur la vidéo, à voir en pratique sur de vraies applications évidemment, on sent que le modèle de dev est vraiment souple et puissant. On peut spécifier les aspects statiques, mais aussi dynamiques style workflow et chaîne de traitements, etc, en se concentrant sur le coeur du truc et en évitant de noyer ce coeur dans un paquet de lignes de code, c'est vraiment ça la force du modèle.


              Les faiblesses, sur la vidéo en tout cas : comme n'importe quelle approche générique, ça manque de "personnalisation" question présentation des données, mais

              Alors, oui, n'importe qui ne peut pas forcément écrire les règles de transformations, mais en y réfléchissant :
              -> si on reprends mon exemple de migration Cobol/java, si tu fais faire la migration par un développeur "à la mano", genre migrer pleins de formulaire,
              * c'est répétitif, et il va forcément passer un peu de temps au début à réfléchir à comment migrer certains trucs, à se créer des patterns
              * si tu fais faire ça par une équipe, tu vas donner des règles pour éviter de perpétuellement réinventer la roue, voire créer une biblio pour migrer

              Ben c'est exactement le genre de travail que tu vas faire pour créer les règles de migration si tu veux mon avis.

              Une fois que tu as fait ce travail le reste ce n'est qu'un boulot chiant et refaire sans cesse là même chose.



              Bref, ce que permettent de faire ces technos : gagner en abstraction pour faire ressortir et se concentrer sur l'essentiel, automatiser, donc fournir des méthodologies toutes faites pour les migrations par exemple.

              Tout ça c'est bien sûr modulo la complexité de la techno elle même et des biais technique qu'elle introduit, là je manque de recul pour ne voir ça que de loin.

              Mais je suis plutôt optimiste:
              -> C'est vraiment souple, tu peux représenter n'importe quoi comme un modèle, haut niveau, bas niveau, tout ce que tu veux
              -> C'est vraiment générique, de la modélisation tu en fais dans tous les domaines, voire dans toutes les sciences, tu le fait DE TOUTE FAÇON d'une manière ou d'une autre quand tu codes, tes données, ton programme. Et du coup cette modélisation tu l'explicite et tu ne la noie pas dans le code.
              -> C'est déjà utilisé avec succès industriellement.


              C'est vraiment un niveau d'abstraction éle
              • [^] # Re: Ouille ouille

                Posté par . Évalué à 1.

                Problème de copier-coller et la colle n'a pas bien tenu ?

                Est-ce que Acceleo ne fait pas double emploi avec ATL ? Car finalement la génération de code consiste à passer d'un modèle (UML par exemple) à un autre (Java, SQL...).

                Je vois bien l'intérêt et je fournis un autre exemple : à partir d'un modèle de données modélisé en UML on génère des scripts de création de table en SQL ainsi que des classes d'accès en C++. Je comprends le divertissement intellectuel qu'il y a à faire cela, mais je ne suis pas certain que l'on y gagne grand chose. Si les tables ont besoin d'index, est-ce qu'il faut « polluer » le modèle en faisant remonter cette information ? Quand le modèle change, comment sont générés les scripts « ALTER TABLE », est-ce qu'il faut méta-modéliser ce genre de changement ? Bref, j'ai l'impression que l'on retombe vite dans les détails d'implémentation donc les joies de l'abstraction ne durent pas très longtemps.

                Vous l'avez compris, je ne suis pas très enthousiaste ; j'attends de voir les applications grand public développées en un éclair pour être persuadé des bienfaits du MDE. En même temps, si tout le monde était comme moi les choses n'évolueraient pas bien vite...
                • [^] # Re: Ouille ouille

                  Posté par . Évalué à 2.

                  Je dirais plutôt que les deux technologies Acceleo et ATL sont complémentaires. On peut très bien imaginer un enchaînement de plusieurs transformations ATL, puis une génération de code avec Acceleo. Par exemple, si tu veux fusionner deux modèles et ensuite générer du code à partir de ce modèle résultant, tu utiliseras une technologie de transformation de modèle à modèle (ATL) puis une technologie de transformation de modèle vers code (Acceleo).

                  Le fait d'utiliser de genre de technologie (Acceleo ou ATL) permet (très souvent) de gagner du temps en développement. De plus tu as travaillé à un niveau plus abstrait (grâce aux métamodèles), donc la maintenance est grandement facilitée. Si le modèle source change, il suffira de relancer la chaîne de transformations pour répercuter les changements. Par contre la réflexion modèle/métamodèle n'est pas forcement triviale au début.
        • [^] # Re: Ouille ouille

          Posté par . Évalué à 2.

          Je ne pense pas que l'idée soit d'indépendance de plateforme d'exécution concerne ici l'OS. Ici on parle plutôt de composant logiciel, de frameworks et d'architecture.

          Par exemple, à partir d'un Platform Independant Model on peut dériver des Platform Specific Model qui ciblent une architecture JEE , Dotnet , Zope ou encore LAMP. L'idée est là et un langage n'est rien sans ses bibliothèque de composants.

          Java est donc "théoriquement "indépendant de l'OS mais passer du Java au C# n'implique pas uniquement un changement de langage mais aussi de "plateforme d'execution"
      • [^] # Re: Ca a l'air vachement bien

        Posté par . Évalué à 7.

        Donc, c'est un n-ième système de génération de code à partir d'UML, ou d'UML à partir de code.

        Ce que ça fait ces trucs-là, c'est faciliter la conception, et compliquer la maintenance (va chercher un bug d'implémentation perdu au milieu du squelette pondu par le merdier - déjà si il est pas lui-même merdé, le squelette).

        Ca fait des années que ces trucs là c'est en gestation, et perso, j'arrive pas à m'y faire à toutes ces modes qui expliquent qu'il suffit d'écrire un méta-truc *ML pour quel tout marche automagiquement: c'est dit, je déteste l'IoC, la méta-pignolle UML, et autres. Tous ces "outils" sont faits par des gens qui n'ont jamais passé un mois à se faire ch... dans un service de support ou d'exploitation.

        Dernièrement, j'ai vu une application pas hyper compliquée (workflows simples de gestion demandes utilisateurs), avec une volumétrie ridicule, arriver à ramer sur deux E450 avec 16Go de mémoire chacun et je sais plus combien de CPUs. Ah ouais le dev nickel, clica-clica XML UML conception machin.. ben bravo, tout ça pour remplacer une appli LAMP qui tournait sur un serveur monoprocesseur avec 1Go de mémoire.

        Quand aux méta-modèles, j'ai assisté de près à la conception d'un super-méta-modèle multidimensionnel (un truc censé représenter tout le SI de la boite, en zoomant sur chaque composant "banalisé"), vendu très cher par une SSII peu scrupuleuse. Le résultat était à mourir de rire, et, au final, inimplémentable, ce qui révèle une difficulté supplémentaire de ces outils: ils sont difficiles à maitriser, parfois même par des gens relativement brillants.

        C'est dit, je suis un vieux con ;-) Allez, ça finira bien par marcher un jour ! :-D
        • [^] # Re: Ca a l'air vachement bien

          Posté par . Évalué à 2.

          Ce n'est pas un système de génération de code à partir d'UML, c'est un cran au dessus au niveau de l'abstraction.
          UML est dans un statut batare(non péjoratif ici), c'est à la fois un langage qui est au niveau métamétamodèle et au niveau métamodèle.

          ATL permet de passer d'un modèle conforme à un MétaModèle d'un langage à un autre modèle conforme à un autre Métamodèle de langage en spécifiant la transformation.
          Donc ATL prend en entrée un métamodèle spécifié dans un fichier ecore et un modèle conforme à ce métamodèle spécifié lui dans un fichier XMI.
          Ce que l'on obtient donc est un fichier XMI qui est le modèle conforme au langage cible.
          Ce même fichier xmi peut ensuite être tranformé par une extraction TCS vers un fichier texte si le langage est textuel par exemple.

          Donc on peut créer une transformation Java->UML ou UML->Java mais se limiter à cette vision d'ATL est extrêmement réducteur, cette transformation est d'ailleurs disponible sur le Zoo d'ATL avec une transformation pour avoir la représentation d'UML dans un fichier DOT par exemple.

          Enfin pour spécifier un métamodèle on le définit généralement en KM3, plus facile à manipuler qu'un fichier ecore qui est du xml.
          De ce fichier KM3 on génère le fichier ecore correspondant.
          Pour le modèle deux solutions, on peut peupler le xmi à la main ou alors on définit un fichier TCS qui va nous servir à l'injection pour obtenir un xmi conforme.

          J'espère avoir été clair (j'ai un doute :) )
          • [^] # Re: Ca a l'air vachement bien

            Posté par (page perso) . Évalué à 3.

            Prenons un exemple concret de laboratoire, j'ai un code Fortran 95, c'est capable de me le transformer en C++ ou en Ada 95 ou pour le moment, il n'y a que le Java qui marche ?
            • [^] # Re: Ca a l'air vachement bien

              Posté par . Évalué à 1.

              ATL ne permettra pas directement de transformer Fortran 95 vers un autre langage. Cela va devoir nécessiter une étape de reverse-engineering code vers modèle.
              De plus une fois que tu auras fait la transformation ATL entre le métamodèle Fortran 95 vers un autre métamodèle, il faudra utiliser un générateur de code pour l'opération inverse.

              Si le reverse-engineering basé sur une approche "modèle" (MDA/MDE) t'intéresse, tu peux jeter un coup d'oeil sur le projet MoDisco (http://www.eclipse.org/gmt/modisco/).
              • [^] # Re: Ca a l'air vachement bien

                Posté par . Évalué à 2.

                C'est partiellement faux.
                ATL peut permettre la transformation direct d'un programme en fortran 95 vers un autre langage.
                Il faut pour celà que quelqu'un ait fait le méta-modèle du langage fortran95, que l'autre langage (supposé textuel ici) ait également un méta-modèle disponible.
                Il faut ensuite qu'il y ait une transformation ATL Fortran2OtherLanguage.
                Et enfin il faut qu'il y ait un fichier TCS pour décrire la grammaire du langage.

                Une fois ces étapes passées, tous tes programmes fortran95 opurront être transformés automatiquement, j'ai bien dit tous du moment que les précédentes étapes ont été bien programmées(par quelqu'un les ayant mis sur les zoos d'eclipse ou bien par toi).
                • [^] # Re: Ca a l'air vachement bien

                  Posté par . Évalué à 1.

                  J'entendais reverse-engineering au sens large, c'est à dire passage du code vers un modèle. J'aurais sûrement dû employer le terme d'injection (qui est le passage d'un espace technique autre que le MDE vers l'espace technique MDE).

                  Par contre je ne vois pas bien ce que viennent faire les zoos ici. Les zoos sont juste des bibliothèques de modèles, métamodèles, etc.
                • [^] # Re: Ca a l'air vachement bien

                  Posté par (page perso) . Évalué à 3.

                  Bonjour,

                  Je ne voudrais pas paraître trop négatif, mais je constate que beaucoup de réponses apportées dans cette discussion sur les applications concrètes de ces outils et concepts sont du type "Il n'y a qu'à...", "Il suffirait que quelqu'un écrive....", "Il faut que...", etc.

                  J'aimerais bien quelques réponses moins méta et plus réalistes ;)

                  Farzy (qui utilise sa main gauche pour taper ce message, main gauche qu'il manipule avec sa main droite, main droite qu'il tient et dirige avec les dents, pour que ça fasse méta-méta-niveau..).
                  • [^] # Re: Ca a l'air vachement bien

                    Posté par . Évalué à 1.

                    Sur le site ATL, il y a une section "Use Cases" présentant des exemples concrets d'utilisation de transformations de modèle : http://www.eclipse.org/m2m/atl/usecases/
                    • [^] # Re: Ca a l'air vachement bien

                      Posté par (page perso) . Évalué à 1.

                      J'ai regardé mais je dois dire que ce n'est pas du tout dans les domaines que j'utilise et donc les 3/4 ne me parlent pas plus que cela.

                      Dommage.
                      • [^] # Re: Ca a l'air vachement bien

                        Posté par . Évalué à 3.

                        Je n'ai jamais pratiqué ce genre de transformation entre 2 langages de programmation et je pense personnellement que c'est une mauvaise idée pour plusieurs raisons.


                        2 approches seraient possibles à mon sens et de ce que je crois comprendre à lire nos 2 posteurs qui ont tenté de te répondre.

                        La première est de reverser à partir du fortran pour obtenir un modèle de plus haut niveau puis effectuer une transformation M2T à partir de ce modèle vers le langage cible.
                        Pour ce faire, ATL ne t'apporte rien, Acceleo pour la 2e étape.
                        L'inconvénient c'est qu'en remontant on perd de la sémantique du langage Fortran.
                        C'est pourquoi l'approche MDA préconise toujours une approche descendante à partir de modèles de plus haut-niveau.

                        L'autre approche est de considérer les 2 codes comme des modèles et les langages comme des métamodèles (on dispose d'un grammaire BNF). Ecrire une transformation de ce type ne doit pas être chose aisée à mon sens car chaque langage dispose de ces idiomes quand ils n'utilisent pas des paradigmes différents et ne parlons pas des bibliothèques standards. Après tu as tout le code à reprendre et étant donné le niveau de détail, j'ai peur que le refactoring soit gargantuesque


                        Si vraiment on doit migrer un SI d'une plateforme vers une autre, une chaîne viable serait peut-être la suivante mais elle n'a rien d'automatique non plus :
                        Remonter du fortran à un modèle de plus haut niveau représentant la plateforme (PSM) remonter à un modèle métier et affiner ce modèle avec la maitrise d'ouvrage. On dispose d'un capital précieux pour l'entreprise si par la suite on doit envisage de nouveaux projets de changement sur le SI.
                        Ensuite on peut dériver vers un PSM et avec une transfo M2T vers le code avec une approche descendante classique MDA

                        Voilà en espérant ne pas avoir été à coté du sujet.
                        J'imagine que ce n'est pas la réponse que tu espérais mais il faut garder à l'esprit que le MD apporte un gain de productivité pour certaines tâches répétitives et c'est là qu'est sa valeur ajoutée. Mais il est "encore" illusoire de vouloir développer un SI complet avec une approche MD.
                        C'est le doux rêve de l'OMG mais il est de plus en plus controversé par l'industrie et les faits.
                        • [^] # Re: Ca a l'air vachement bien

                          Posté par (page perso) . Évalué à 1.

                          > J'imagine que ce n'est pas la réponse que tu espérais

                          En fait, je n'esperais pas grand chose si ce n'est de faire avancer le débat et essayer qu'un grand nombre de personne comprenne vraiment le sujet (dont moi). J'ai donc pris un exemple classique dans un laboratoire de recherche, pas si anodin que cela car il y a une grande histoire Fortran et pouvoir passer par exemple du Fortran à l'Ada serait dans certain cas intéressant.

                          Ta réponse finalement ne m'éclairicie malheureusement pas les idées. Tout cela me donne l'impression d'un truc énorme qui nécessite des projets énormes avec des moyens humains énormes...
                          • [^] # Re: Ca a l'air vachement bien

                            Posté par . Évalué à 2.

                            Tu as bien résumé.
                            Le but est d'automatiser un certain nombre de tâches de programmation.
                            Plus elles sont génériques et plus elles sont réutilisables et plus on aura de retour sur l'investissement.
        • [^] # Re: Ca a l'air vachement bien

          Posté par . Évalué à 2.

          +1

          Les quelques tentatives de modélisation 'a postéiori' que j'ai vue ont explosée a cause de la complexité du code..

          Personellement, ça me rend très, très méfiant ce genre de techno, je préférerais utiliser un langage de haut niveau comme Scala: c'est déjà pas mal comme abstraction, et ça reste un langage de programmation..
          • [^] # Re: Ca a l'air vachement bien

            Posté par . Évalué à 1.

            J'ai dû être incompréhensible dans mon précédent post d'après ce dernier commentaire.

            ATL n'est pas une nouvelle techno servant à générer automatiquement du code!
            ATL passe d'un modèle à un autre modèle, ces deux modèles sont en XMI (comprenez XML grosso modo).

            TCS permet de générer du code depuis un modèle en XMI. En l'occurence si cette génération est mauvaise ce ne sera ni à cause du langage TCS mais uniquement à cause du programmeur, lui seul définit la syntaxe du langage et donc lui seul est responsable de la génération.

            Là je pense que c'est assez clair.
  • # Standard ?

    Posté par . Évalué à 1.

    Ca ne serait pas un peu abusé de dire "Grâce à ce respect des standards" alors que le standard pour la transformation de modèles est QVT ?
    • [^] # Re: Standard ?

      Posté par . Évalué à 2.

      Le standard OMG ... Je ne pense pas que l'OMG soit un organisme de normalisation. Ses standards n'ont donc pas plus de valeur qu'un autre contrairement à ce qu'ils ont l'air de penser.
      Sinon, pourquoi a t'on vu la disparition de CORBA des bureaux libres si c'était un standard ?
      • [^] # Re: Standard ?

        Posté par . Évalué à 1.

        Puisque ATL a été proposé à l'OMG et qu'il utilse d'autres standards de l'OMG, ils doivent bien le reconnaître comme un organisme de normalisation...
        • [^] # Re: Standard ?

          Posté par . Évalué à 3.

          A la base, ATL était une implémentation de la spécif QVT. Mais à cause des longueurs de le process OMG pour cette spécif, ATL a continué à évoluer de son côté en privilégiant les besoins utilisateurs (concernant le langage) par rapport à un respect total de QVT. On décrit ATL comme un QVT-like.
  • # Outillage dans Eclipse

    Posté par (page perso) . Évalué à 1.

    Juste pour dire que le niveau de qualité de l'outillage au sein d'Eclipse pour ATL est excellent et sans conteste le meilleur actuellement en transformations de modèles.

    Editeurs, complétion , tout ce qu'il faut pour transformer des modèles de manière efficace et intuitives :)
    • [^] # Re: Outillage dans Eclipse

      Posté par . Évalué à 5.

      Petit Canaillou ;)

      C'est futé de faire de la pub pour ses petits collègues.
      http://www.obeo.fr/pages/atl-pro/fr

      http://www.obeo.fr/pages/acceleo-pro-compare/fr

      Obeo est leader de ce projet hebergé pas la fondation Eclipse (leader : Cedric Brun).


      Bon, on ne vous en veut pas pour une fois qu'une boîte française sort des produits innovants. Mais que je vous y reprenne pas :O)
      • [^] # Re: Outillage dans Eclipse

        Posté par (page perso) . Évalué à 1.

        Nan nan c'est en toute objectivité :D

        Si l'on compare les outils actuels de transformations de modèle (qu'on est évidemment ammené à utiliser quand on travaille chez Obeo) ATL est sans conteste le plus agréable à utiliser :)

        Je dirais que c'est probablement également pour cela qu'Obeo à choisit de travailler à partir de cette base !
  • # C'est pour faire des BLURP ?

    Posté par . Évalué à 5.

    Des Business Logic Unified Rational Processes bien sur :-)
  • # MDW

    Posté par . Évalué à 1.

    Ouais, c'est pas mal mais je préfére MDWorkbench de Sodius qui est encore plus user-friendly, également basé sur eclipse et qui offre beaucoup de connecteurs vers d'autres outils.
    • [^] # Re: MDW

      Posté par . Évalué à 1.

      Si mes souvenirs sont bons, les transformations dans MDWorkbench peuvent être écrites aussi en ATL ;-)

Suivre le flux des commentaires

Note : les commentaires appartiennent à ceux qui les ont postés. Nous n'en sommes pas responsables.