Exemple d'application qui montre comment utiliser les bonnes pratiques de JEE pour développer un site web de commerce électronique en utilisant les outils :
- Eclipse comme environnement de développement
- Maven comme outil d’intégration
- JUnit comme Framework des tsts unitaire
- Spring IOC pour l'inversion de contrôle
- Spring MVC pour la couche web
- Spring Security pour la sécurité
- JPA, Hibernate
- Web Service SOAP
- Web Service REST
- Service RMI
Ce Support de cours Spring contient :
- Architecture JEE (Over view)
- Spring Overview
- Spring IOC
- Spring MVC
- Spring Integration (RMI, JaxWS, JaxRS, JMS, JMX,...)
- Spring Security
Bon apprentissage à tous
Exemple d'application qui montre comment utiliser les bonnes pratiques de JEE pour développer un site web de commerce électronique en utilisant les outils :
- Eclipse comme environnement de développement
- Maven comme outil d’intégration
- JUnit comme Framework des tsts unitaire
- Spring IOC pour l'inversion de contrôle
- Spring MVC pour la couche web
- Spring Security pour la sécurité
- JPA, Hibernate
- Web Service SOAP
- Web Service REST
- Service RMI
Ce Support de cours Spring contient :
- Architecture JEE (Over view)
- Spring Overview
- Spring IOC
- Spring MVC
- Spring Integration (RMI, JaxWS, JaxRS, JMS, JMX,...)
- Spring Security
Bon apprentissage à tous
Objectif général : Connaître les fondamentaux d’une API REST
Objectifs spécifiques :
Savoir définir une API
Connaître l’architecture REST
Connaître les contraintes du REST
Connaître la structure d’une requêtes HTTP
Connaître les caractéristiques d’une ressources
Se servir des méthodes HTTP
Connaître la structure d’une réponses HTTP
Connaître les codes HTTP
Ce Support explique quelques concepts de base de NodeJS et montre comment mettre en oeuvre la technologie NodeJS pour développer la partie Backend d'une application.
Les vidéos des démonstrations sont publiées sur les adresse suivantes :
- https://www.youtube.com/watch?v=-X_C1tS5-9Y
- https://www.youtube.com/watch?v=rE-xRH28m0s
- https://www.youtube.com/watch?v=tnxjkTvWoKA
Cette série explique les éléments suivants :
- Architecture Web
- Modèles Multi-Threads avec les entrées sorties bloquantes
- Modèles Single Thread avec les entrées sortie non bloquantes
-Technologie Node JS
- Comment créer une simple application Node JS avec java Script
- Architecture du Framwork Express
- Comment créer une application NodeJS avec Type Script
- Comment écrire des tests unitaires avec Jest
- Quelques concepts sur MongoDb
- Comment Créer une API Rest avec NodeJS, Express et MongoDb
- Comment tester l'API Rest
- Comment Créer la partie FrontEnd avec Angular.
Même si la qualité audio n'est pas bonne, ses vidéos peuvent aider ceux qui débutent dans NodeJS en attendant d'autres vidéos avec plus qualité audio et de contenu.
Bonne lecture
Support Complet sur la technologie EJB 3.1. Ce cours Traite l'architecture JEE. Les différents types EJB (Session, Entity, MDB). Des exemple complets sont aussi présentés.
Xcore is a textual format to define ecore models. This not only makes editing and reading much more convenient but has other cool advantages as well. Xcore, for instance, allows to embed Xbase expressions to define logic within EOperations and the like.
In this session you will learn, why and when using Xcore is a good idea and how to use it with Xtext languages. I will explain talk about which URIs to use, and how to properly configure the MWE2 file as well as more complicated setups, with multiple languages and mixtures of ecore, xcore and generated models.
This document summarizes a presentation given by Olivier Le Goaër on executable modeling and dynamic adaptation. It provides a short biography of Le Goaër, discusses domain-specific languages and different shapes they can take, and how models are taking on a more dynamic role at runtime. It explores controversies around executable models and components of executable modeling built with model-driven engineering. Finally, it discusses approaches to executable modeling, model adaptation, and implementation choices for adaptive executable modeling.
Objectif général : Connaître les fondamentaux d’une API REST
Objectifs spécifiques :
Savoir définir une API
Connaître l’architecture REST
Connaître les contraintes du REST
Connaître la structure d’une requêtes HTTP
Connaître les caractéristiques d’une ressources
Se servir des méthodes HTTP
Connaître la structure d’une réponses HTTP
Connaître les codes HTTP
Ce Support explique quelques concepts de base de NodeJS et montre comment mettre en oeuvre la technologie NodeJS pour développer la partie Backend d'une application.
Les vidéos des démonstrations sont publiées sur les adresse suivantes :
- https://www.youtube.com/watch?v=-X_C1tS5-9Y
- https://www.youtube.com/watch?v=rE-xRH28m0s
- https://www.youtube.com/watch?v=tnxjkTvWoKA
Cette série explique les éléments suivants :
- Architecture Web
- Modèles Multi-Threads avec les entrées sorties bloquantes
- Modèles Single Thread avec les entrées sortie non bloquantes
-Technologie Node JS
- Comment créer une simple application Node JS avec java Script
- Architecture du Framwork Express
- Comment créer une application NodeJS avec Type Script
- Comment écrire des tests unitaires avec Jest
- Quelques concepts sur MongoDb
- Comment Créer une API Rest avec NodeJS, Express et MongoDb
- Comment tester l'API Rest
- Comment Créer la partie FrontEnd avec Angular.
Même si la qualité audio n'est pas bonne, ses vidéos peuvent aider ceux qui débutent dans NodeJS en attendant d'autres vidéos avec plus qualité audio et de contenu.
Bonne lecture
Support Complet sur la technologie EJB 3.1. Ce cours Traite l'architecture JEE. Les différents types EJB (Session, Entity, MDB). Des exemple complets sont aussi présentés.
Xcore is a textual format to define ecore models. This not only makes editing and reading much more convenient but has other cool advantages as well. Xcore, for instance, allows to embed Xbase expressions to define logic within EOperations and the like.
In this session you will learn, why and when using Xcore is a good idea and how to use it with Xtext languages. I will explain talk about which URIs to use, and how to properly configure the MWE2 file as well as more complicated setups, with multiple languages and mixtures of ecore, xcore and generated models.
This document summarizes a presentation given by Olivier Le Goaër on executable modeling and dynamic adaptation. It provides a short biography of Le Goaër, discusses domain-specific languages and different shapes they can take, and how models are taking on a more dynamic role at runtime. It explores controversies around executable models and components of executable modeling built with model-driven engineering. Finally, it discusses approaches to executable modeling, model adaptation, and implementation choices for adaptive executable modeling.
Android executable modeling: beyond android programmingOlivier Le Goaër
This document discusses executable modeling for Android applications using statecharts. It presents a toy "Energy Assistant" mobile app modeled as a statechart to demonstrate the approach. The statechart model is executed on Android using the PauWare execution engine and an architecture that interfaces with Android events and actions. Executable modeling shifts efforts from programming to modeling and allows updating an app by loading a new model while keeping action implementations unchanged. This facilitates rapid prototyping and updating of Android apps through modeling rather than traditional programming.
Apprenez à écrire vos macros pour le tableur Excel en Visual Basic. Cette formation couvre les rudiments de programmation ainsi que la découverte de l'API Excel
Ma critique de cette technologie sur http://olegoaer.developpez.com/cours/vba/
Yet another DSL for cross platforms mobile developmentOlivier Le Goaër
This document presents the XMOB solution for cross-platform mobile development. XMOB is a domain-specific modeling language that allows developers to write mobile applications independently of platforms in a platform-independent model. The XMOB compiler then transforms the model into native code for different mobile platforms like Android and iOS. XMOB has sublanguages for defining user interfaces, data sources, and events. The compiler uses EMF and Xtext to parse XMOB models and Kermeta transformations to generate platform-specific UML models and native code. Examples of XMOB code show how to define screens, buttons, lists, data fetching, and event handling.
This document discusses building a Python-like language with Xtext that is indentation aware. It covers parsing indentation aware languages, tokenizing and splitting tokens, defining indentation tokens, adjusting the Xtext workflow, marking tokens as splittable, and formatting indentation in the language. Key challenges discussed are parsing, content assist, formatting, folding and outline for indentation aware languages. The document provides code examples and recap of defining block structures with open and close tokens.
Le cryptage RSA est-il intrinsèquement inviolable ? Pour le savoir, nous essayons de comprendre comment il fonctionne et sur quelles mathématiques il s'appuie.
The document describes the step-by-step parsing of the mathematical expression "(1 + 20) * 2" according to a specified grammar. The parsing breaks the expression down into a stack of syntactic elements including number literals, additions, multiplications, and primaries according to the grammar rules.
The document discusses Acceleo, a code generation tool from Eclipse. It provides an overview of Acceleo's history and capabilities. Key points include: (1) Acceleo allows generating code from models using templates based on the MTL standard; (2) A prototype demonstrates generating an Android app from a model using Acceleo templates; (3) Templates can be customized and extended to override default generation behavior. The tutorial aims to help beginners, experienced Acceleo users, and Android developers learn how to build code generators with Acceleo.
Une révision des principaux concepts du langage JavaScript : variables, fonctions, types, fermetures (closures), objets et prototypes, format JSON. De nombreux exemples téléchargeables sur GitHub.
Conférence Devoxx FR 2022
"Microservices, DDD et bootstrapping pour faire un départ lancé"
Résumé de la présentation :
Associer microservices et conception DDD (Domain-Driven Design) semble une évidence. Le découpage en contextes et les différentes couches d’architecture constituent un cadre séduisant pour bâtir des microservices avec une structure stéréotypée. Mais si on souhaite respecter les fondamentaux du DDD et garantir l’isolation des différentes couches on arrive rapidement à une structure de projet basée sur plusieurs modules qui peuvent devenir complexes à gérer et qui risquent de ralentir le cycle de développement, en particulier lors de la phase de démarrage.
Cette présentation est un retour d’expérience d’un grand projet dans lequel le générateur de code Telosys a été utilisé pour automatiser la phase d’amorçage de chaque microservice.
Environnement technique : Java, SpringBoot, Telosys
Réutilisation de code entre Windows 8 et Windows Phone 8.Microsoft
Windows 8, Windows Phone 8, le même noyau, je ne code alors qu'une fois ? Dans cette session, nous aborderons les différences et les similitudes entre les deux plates-formes, ainsi que la manière de développer du code qui soit portable.
Similaire à Syntaxe concrète des DSL en IDM [avec Xtext] (20)
The document discusses approaches for making software development more environmentally sustainable, referred to as "green coding" or "eco-coding". It outlines code smells and inefficiencies that can negatively impact energy usage and device lifespan. It then introduces ecoCode, an open source plugin for the SonarQube platform that helps developers identify such issues through static analysis and provides metrics to track sustainability improvements over time. The document argues ecoCode can help establish best practices for green software development while avoiding limitations of existing tools through its community-driven approach.
PowDroid: Energy Profiling of Android Applications (ASE 2021 [Workshop] SUSTA...Olivier Le Goaër
While the energy efficiency of mobile apps is receiving considerable attention in recent years, Android developers have little tools to assess the energy footprint of their applications. In this paper, we introduce PowDroid, our tool to estimate the energy consumption of Android application. It uses system-wide metrics and does not require access to applications' source code. We run PowDroid on a use-case scenario comparing the energy footprint of applications in different categories.
Nowadays, energy efficiency is recognized as a core quality attribute of applications (apps) running on Android-powered devices constrained by their battery. Indeed, energy hogging apps are a liability to both the end-user and software developer. Yet, there are very few tools available to help developers increase the quality of their native code by ridding it of energy-related bugs. Android Studio is the official IDE for millions of developers worldwide and there's no better place to enforce green coding rules in everyday projects. Indeed, Android Studio provides a code scanning tool called Android lint that can be extended with lacking green checks in order to foster the design of more eco-responsible apps.
GREEN PAUWARE - For a power-thrifty mobile app marketplaceOlivier Le Goaër
Energy-intensive mobile applications are a burden for both end users and devel-opers, and ultimately are harmful to the planet. The objective of the GREEN PAUWARE project is to break these bad habits by creating an energy label for applications (ranging from A to G), as exists in other areas. Many authors agree on the necessity of an eco-score or ranking within the mobile apps market, but research is hampered by the complexity and lack of available tools.
This presentation proposes milestones to achieve this objective. In particular, it introduces an ecological bonus-malus system applied to Android development projects to try to give a score to applications. Then, it shows how to use a static code analysis tool like Android Lint to implement such a system. Finally, it features a distributed software architecture to collect scores and push labels towards end users so they can make informed decisions when installing applica-tions on their Android-powered devices.
1. Syntaxe des DSL en
IDM [avec Xtext]
Olivier Le Goaer
olivier.legoaer@univ-pau.fr
2. Prérequis du module
● Programmation
Ο Java SE et Java EMF
Ο Dialectes XML
● Ingénierie des langages
Ο Grammaires EBNF
Ο Métamodélisation (voir cours Eric Cariou)
3. Plan du module
● Rappels sur la métamodélisation
● Les langages dédiés (DSL)
● Outillage EMF
5. Pile de modélisation (OMG)
Meta-
modèle
Modèle
« Monde réel »
Meta-
meta-
modèle
M0
M1
M2
M3
Le MOF
Le métamodèle UML et
d'autres métamodèles
Des modèles UML et
d'autres modèles
Usages variés de ces
modèles
6. Sources d'ambiguïté
● MOF est un langage de métamodèlisation
Ο Est orienté objet. Est auto-défini (i.e. réflexif)
Ο Il existe d'autres langages de métamodélisation...
● UML est un langage de modélisation objet
Ο Contient 14 sous-langages (14 types de diagrammes)
Ο Il existe pléthore de langages de modélisation...
● UML ≠ MOF
Ο Le MOF engendre UML. Pas l'inverse.
Ο Le MOF contient certains concepts similaires à ceux
d'UML (logique, à cause de son orientation objet)
7. Les *-tions de l'IDM
Modèle
(syntaxe abstraite)
Modèle
(syntaxe abstraite) code sourcecode source
Transformation
Model-to-model (M2M)
Transformation
Model-to-text (M2T)
Lorem ipsum
dolor sit amet,
consectetur
adipisicing elit,
Lorem ipsum
dolor sit amet,
consectetur
adipisicing elit,
Extraction Injection
(syntaxe concrète textuelle ou graphique)
11. IDM et Langages
● Ingénierie des modèles = ingénierie des
langages
Ο Définir un métamodèle revient à créer un langage (par
sa syntaxe abstraite uniquement)
Ο Définir un modèle conforme à ce métamodèle, c'est
formuler des énoncés dans ce langage
● Des langages pour chaque besoin
Ο Des langages communs et reconnus bien sûr...
Ο ...mais aussi des langages « sur-mesure »
● Le futur du développement logiciel
Ο Le cycle fera intervenir de nombreux micro-langages
12. Domain-Specific Language
● Langage...
Ο Tout type de langage (programmation, interrogation,
modélisation, transformation, build, contrainte...)
Ο On parle de DSML pour le cas spécifique des langages
de modélisation
● ... dédié à un domaine
Ο Expressivité basée sur le vocabulaire/les concepts
propres à un domaine métier
Ο Souvent plus concis (plus simple ?) qu'un langage
généraliste (GPL) qui peut potentiellement traiter toutes
les problématiques
Exemples :
SQL ,
ATL,
Makefile ?
13. Relations DSL/GPL
● DSL interne
Ο Hébergé par
un GPL hôte
GPLGPL
DSLDSL
● DSL externe
Ο Autonome
DSLDSL
● DSL implicite
Ο API d'un GPL
G/DSLG/DSL
C# & Linq SQL Querydsl SQL
Java API
14. Relations DSL/GPL
● DSL interne
Ο Hébergé par
un GPL hôte
● DSL externe
Ο Autonome
● DSL implicite
Ο API d'un GPL
C# & Linq SQL Querydsl SQL
Java API
QCustomer customer;
customer = new QCustomer("c");
SQLQuery<?> query =
new SQLQuery<Void>(connection);
List<String> lastNames =
query.select(customer.lastName)
.from(customer)
.where(customer.firstName.eq("Bob"))
.fetch();
System.out.print(lastNames);
SELECT lastName
FROM customer
WHERE firstName = 'Bob';
var queryBobCustomers =
from cust in customer
where cust.firstName == "Bob"
select cust.lastName;
foreach (var n in queryBobCustomers)
{
Console.WriteLine(n);
}
15. Syntaxe concrète d'un DSL
● Textuelle ?
Ο Approche linéaire,
séquentielle (la lecture)
● Gauche à droite, haut
en bas, indentation, ...
Ο On peut dire les choses
de manière détaillée
● Ex : Expression
mathématiques
Ο Outillage mûre
● highlighting,
autocompletion,
diff/merge
● (Semi)graphique ?
Ο Approche visuelle
● naturelle pour
comprendre et
communiquer
Ο Parce que parfois "un
dessin vaut mieux..."
Ο Devient vite illisible si :
● nombreuses
imbrications
● expressions
complexes
C'est souvent
le cas des
langages de
programmation C'est souvent
le cas des
langages de
modélisation
16. Ateliers pour les DSL
OutilOutil EditeurEditeur
MetaEdit+ MetaCase
Eclipse Modeling Framework (EMF) The Eclipse Foundation
Meta Programming System (MPS) JetBrains
Obeo Designer Obeo
Visualization and Modeling SDK Microsoft
Intentional Workbench Intentional Software
Poseidon for DSLs Gentleware
... ...
18. Pile de modélisation (EMF)
Meta-
modèle
Modèle
« Monde réel »
Meta-
meta-
modèle
M0
M1
M2
M3
Ecore.ecore
UML2.ecore, BPEL.ecore,
Java.ecore, ...
Microwave.uml2,
Shopping.bpel, Bank.java, ...
Usages variés de ces
modèles
100% XMI
19. Ecore
● Implementation Java
de E-MOF
Ο Orientation objet
Ο Minimaliste
● Racine de la
hiérarchie : EObject
Ο Hérite de Object (Java SE)
● Syntaxe concrète
graphique « à la UML »
par défaut
20. Les *-tions avec EMF
Modèle
(syntaxe abstraite)
Modèle
(syntaxe abstraite) code sourcecode source
Transformation
Model-to-model (M2M)
Transformation
Model-to-text (M2T)
Lorem ipsum
dolor sit amet,
consectetur
adipisicing elit,
Lorem ipsum
dolor sit amet,
consectetur
adipisicing elit,
Extraction Injection
(syntaxe concrète textuelle ou graphique)
Kermeta,
QVT, ATL...
Xpand, JET,
MOFScript,
Acceleo...
Xtext,
EMFtext,
Sintaks,TCS,
Spoofax...
Sirius,
Graphiti,
GMF, ...
21. Xtext : principes
● ANTLR3-based parser
● EMF-based metamodel
● Eclipse editor with
Ο syntax highlighting
Ο code completion
Ο customizable outline
Ο code folding
Ο real-time constraint
checkingEn tant que DSL,
Xtext s'applique
à lui-même...
http://www.eclipse.org/Xtext/
23. Intégration Xtext/Ecore
● Approche "(meta)model first" (celle vue en TP)
Ο Vous disposez d'un métamodèle ecore
Ο Vous disposez des metaclasses Java correspondantes,
générées via un fichier genmodel
Ο Il suffit d'indiquer au parseur de les importer (import)
pour les réutiliser
● Approche "grammar first"
Ο Vous de disposez pas d'un métamodèle ecore
Ο Vous vous concentrez sur la grammaire Xtext et il
génerera (generate) au passage les metaclasses Java
24. Catégories de règles Xtext
● Règle terminale
Ο Représente les unités lexicales (les feuilles de l'AST)
Ο terminal EMAIL: ('a'..'z')+ '@' ('a'..'z')+ '.' DN;
● Règle d'énumeration
Ο Représente des valeurs énumérées
Ο enum DN: org='org' | com='com' | fr='fr' | net='net'
● Règle de parsing (non-terminale)
Ο Règle de dérivation (les noeuds de l'AST) car fait appel
à d'autres règles, terminales ou non
Ο Message: 'send from' source=EMAIL 'to' target=EMAIL 'stop'
25. Nommage des règles Xtext
● Soit le nom de la règle se
confond avec le nom de la
metaclasse d'implementation
Ο Message : source=EMAIL
● Soit le nom de la règle est
dissociée de la metaclasse
d'implementation (conseillé !)
Ο R1 returns Message : source=EMAIL
+source : EString
+target: EString
Message
(extends EObject)
+getSource() : EString
+setSource(EString s) : void
+getTarget() : EString
+setTarget(EString s) : void
26. Vue d'ensemble
+source : EString
+target: EString
Message
(extends EObject)
+getSource() : EString
+setSource(EString s) : void
+getTarget() : EString
+setTarget(EString s) : void
terminal EMAIL: …
R1 returns Message:
'from' source=EMAIL
('to' target=EMAIL)? 'stop'
from olivier.legoaer@univ-pau.fr
to eric.cariou@univ-pau.fr stop
Msg.xtext
Sample.msg
Your DSL keywords
Rule ID (=> Type)
Xtext keywords
Ecore model elements (EClass, EAttribute, ...)
Cohérence
Type EMAIL
compatible
avec le type
EString
source=olivier.legoaer@univ-pau.fr
target=eric.cariou@univ-pau.fr
obj#1:Message
instanceOf
27. Mappings Ecore/Xtext
EcoreEcore DSLDSL Motif de règleMotif de règle EcoreEcore DSLDSL Motif de règleMotif de règle
eSuperType A: B|C EAttribute A : price=EFloat
EReference
containment=true
lowerBound=1
upperBound=1
A : r=B EReference
lowerBound=0
upperBound=1
A : (r=B)?
EReference
containment=false
lowerBound=1
upperBound=1
A : r=[B] EReference
lowerBound=0
upperBound=-1
A : (r+=B)*
EAttribute
(cas des booléens
liés à l'existence
de mots-clés)
A : isOk?='ok' EReference
lowerBound=1
upperBound=-1
A : (r+=B)+
ou bien
A : (r+=B)
(r+=B)*
C
<< extends >>
B
A
A B
A B
1
1
+r
+r
isOk : EBoolean
A
price : EFloat
A
A B0..1
+r
A B0..*
+r
A B1..*
+r
28. Injection (Conceptuellement)
● Lors de l'analyse du texte, le parseur ANTLR va
instancier les bonnes metaclasses, avec les
bonnes valeurs (attributs et références)
Ο Syntaxe concrète textuelle vers syntaxe abstraite
Ο Passage du « grammarware » au « modelware »
Ο Production d'un AST (ou plutôt un graphe d'objets)
Modèle
(arbre de
syntaxe abstraite)
Modèle
(arbre de
syntaxe abstraite)
Lorem ipsum
dolor sit amet,
consectetur
adipisicing elit,
Lorem ipsum
dolor sit amet,
consectetur
adipisicing elit, ANTLR
29. Injection (techniquement)
from olivier.legoaer@univ-pau.fr
to eric.cariou@univ-pau.fr stop
Msg.xtext
Sample.msg
Message current = null;
current = new Message();
current.setSource("olivier.legoaer@univ-pau.fr");
current.setTarget("eric.cariou@univ-pau.fr");
return current;
Appel de la
règle R1
Creation d'un
EObject
Code Java EMF réalisé par le parser ANTLR
R1 returns Message:
'from' source=EMAIL
('to' target=EMAIL)? 'stop'
30. Illustration : Le GPL Java
ClassDefRule returns Class :
(isAbstract?="abstract")?
"class" name=ID "{"
(methods+=MethodDefRule)*
"}"
class Voiture {
void demarrer() {...}
void stopper() {...}
}
isAbstract : EBoolean
name : EString
Class
(extends EObject)
isAbstract = false
name = ''Voiture''
c1:Class
name = ''demarrer''
m1:Method
name = ''stopper''
m2:Method
name : EString
Method
(extends EObject)+methods
0..*
M2
M1
« grammarware » « modelware »
Java.xtext
Voiture.java
Java.ecore
Voiture.xmi
31. DSL avec système de types
● Parfois, vous avez besoin d'implémenter un vrai
système de types pour votre DSL
Ο Typiquement le cas des langages de programmation
● Solutions
Ο Natives : invariants OCL/Constraint-Checking de Xtext
Ο Tierces : Xbase, XTS, Xsemantics, ...
def isCool as boolean
def price as integer
isCool <- true //cool
price <- ''foo'' //pas cool
32. DSL exécutable
● L'exécutabilité peut être obtenue en projetant
vers un langage cible, qui lui, est exécutable
Ο Sémantique translationnelle (~Compilateur)
Ο Transformation M2T (ex: MyDSL → code Python)
● Si le DSL doit être exécutable par lui-même
Ο Sémantique opérationnelle (~VM)
Ο Langage d'action (pur Java EMF, Kermeta, ...)
Ο Si votre DSL intègre des expressions "Java-like", on
utilise la grammaire Xbase
● L'utilisation de Xbase va gènèrer des implémentations
Java naturellement exécutables par la VM Java
33. Exercices pratiques
● Recréer des langages bien connus
Ο Redéfinir le langage Java
Ο Redéfinir le langage SQL
Ο ...
● Inventer de nouveaux langages
Ο Définir le langage WDL (Website Description Language)
● http://olegoaer.developpez.com/tutos/model/xtext/wdl/
Ο Définir le langage XMOB
● http://olegoaer.perso.univ-pau.fr/works/GlobalDSL2013.pdf
Ο ...