DSL et DSL Tools

DSL et DSL ToolsDSL et DSL Tools

Jean-Marc Prieur (ANPROS)[email protected]

Jeudis de l'objet - 30 mars 2006 2 / 53

Plan de la présentationManipuler des « concepts et d’intentions » dans Visual Studio 2005

Custom Tools pour les settings et ressourcesEditeurs de Windows FormsClass Diagram

Formaliser nos solutions … jusqu’aux DSLRetour d’expérience dans le domaine de la simulation

Personnaliser Visual Studio 2005Le Visual Studio SDKLes DSL Tools

DiscussionUML et DSLLimites techniques actuelles des DSL ToolsL’avenir à court terme


Manipulations de conceptsManipulations de concepts dans Visual Studio 2005

L’exemple des fichiers de settings et ressources

Persistance dans des fichiers XML(.settings, .resources)

namespace WindowsApplication1.Properties {

internal class Resources {

internal static string Gagné {

get {return ResourceManager.GetString("Gagné", resourceCulture);}}

internal static string Perdu {

get {return ResourceManager.GetString("Perdu", resourceCulture);}}

}

private static global::System.Resources.ResourceManager resourceMan;private static global::System.Globalization.CultureInfo resourceCulture;internal static global::System.Globalization.CultureInfo Culture { get { return resourceCulture;} set {resourceCulture = value;} }

internal static global::System.Resources.ResourceManager ResourceManager {get { if (object.ReferenceEquals(resourceMan, null)) {global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("WindowsApplication1.Properties.Resources", typeof(Resources).Assembly); resourceMan = temp; } return resourceMan; } }}

ResXFileCodeGenerator

Resources.Designer.cs


Le mécanisme …

Nous manipulons des ressources ou des paramètres de configuration de manière naturelle.

Des Custom Tools génèrent du code basé sur un Framework (.NET 2.0) pour y accéder en runtime (masquant l’utilisation du Framework)

System.Resources et System.GlobalizationSystem.Configuration

Ce mécanisme est unidirectionnel.

Custom Tools de Visual Custom Tools de Visual Studio 2005Studio 2005

demodemo


De la Manipulation bi-directionnellebi-directionnelle de concepts

Pour les Windows.Forms c’est comme pour les ressources ou settings mais

L’éditeur est graphique

la sérialisation s’effectue dans le code

c’est built-in (pas de Custom Tool)

Même chose pour le Class diagram

La notion de classe partialpartial est très intéressante pour les générateurs de code


Et si nous ...

... nous pouvions prendre un modèle (par exemple un automate d’états finis) et en déduire du code source?

« Ajouter StateMachine » à un projet Visual Studio.

C’est possible car Visual Studio 2005 est extensibleextensible

Mais il nous faut d’abord Mais il nous faut d’abord formaliserformaliser nos solutions nos solutions à nos problèmes répétitifsà nos problèmes répétitifs

Normal

Clignottant

Normal

Eteint

Initial

Eteint

Entry actions

Allumer

Exit actions

Eteindre

Initial

Allumé

after(0.5)

after(0.5)

Poussoir

Poussoir


Clignottant

Evolution du processus

solutionssolutions

PatternsPatterns

TemplatesTemplates

FrameworksFrameworks

DesignersDesignersFourniture d’outils pour aider les utilisateurs du framework

Fourniture d’éléments stables sous forme compilée

Automatisation de l’application de patterns

Formalisées issues de l’experience

Automates d’états-finis

State-Pattern

Exemple de code

Designs.StateMachine

DSL SM

Normal

Clignottant

Normal

Eteint

Initial

Eteint

Entry actions

Allumer

Exit actions

Eteindre

Initial

Allumé

after(0.5)

after(0.5)

Poussoir

Poussoir

éteint Allumé Eteint


Les Roles et les Artefacts

Les « architectes » sélectionnent des procédures et conseils et créent deux types d’artefacts :

un Framework

Une codification des conseils (assistant, designer graphique ou non...)

Les « développeurs » utilisent un modèle pour implémenter une solution


Les langages visuelsPermettent d’échanger des informations dans un domaine spécifique

property

Corona

Corona

Corona

label

Shape

GroupBase

members

waiting

runningpause begin

stop

playing

+v

0v0.7CR

R

C

0.1R

C

R0.1R


Retour d’expérience dans le domaine de la simulation

Contexte d’applicationDes études de recherche opérationnelle aux applications de simulation

Un processus outillé.


Expert opérationnel, pilote de l’étude : « Je suis pressé.J’ai besoin d’une réponse

rapidement. »

Le besoin initial : répondre plus efficacement auxdemandes d’études de recherche opérationnelle


CDT : « Je voudrais que les études de RO soient réalisées plus rapidement en maîtrisant

toute la verticalité »

Rêve du chef …


Directeur d’études : « Je comprends son problème. Il faut maintenant que je le modélise.

- Traduire en termes de critères à évaluer sur des scénarii,- Construire un plan d’expérience i.e. développer une application

de simulation dans laquelle je vais mesurer des variables qui seront transformées en critères

Rêve du directeur d’étude …


Problématique

Analyse de l’étudedéfinit un besoin technique

- Reformulation de la problématique-Utilisation de méthodes pour analyser le problème : analyse fonctionnelle, UML non formel,…

Approche Mathématique- théorie des graphes,- probabilités,- programmation linéaire…

Approche par la simulation- Création d’un scénario traduisant la problématique- Utilisation de modèles- Création d’une application à partir d’un environnement de simulation

Etapes de réalisation d’une application d’étude

-Spécification de l’appli de simulation

-Conception

-Développement

-Implémentation

- Tests

Exploitation(Variation des paramètres du modèle et de son

environnement)

Produit Mathématique Produit logiciel

Résultats

ValidationOuModification


Analyse des résultats

Rédaction d’un rapport

L’outilDirectSim

La Démarche

« Etude RO »

Une réponse :Un environnement générique de - développement,- exécution- et exploitation

de simulations.


Directeur d’études : « Je comprends son problème. Il faut maintenant que je le modélise.

Si la traduction du modèle en programme informatique pouvait aller plus vite ...»

Rêve du directeur d’étude… … qui est le maillon entre la demande et la réponse


Développeur : « Je souhaiterais : - Développer avec des langages

et outils modernes, efficaces et adaptés au problème.

- Réutiliser ce que j’ai déjà fait - Que les tâches de

développement répétitives soient faites par l’ordinateur »

Rêve des développeurs


De quoi avons-nous besoin concrètement?Besoin de capitaliser des expertises métiers

Besoin d’usines de développements d’applications de simulation

Assembler des applications de simulation avec des outils, en s’exprimant dans un langage proche de l’opérationnel, et s’appuyant sur des briques de connaissances métier (moyens + concepts d’emploi)

Cette usine de développement doit être intégrée à un environnement de développement moderne

Besoin d’un langage pour le binôme opérationnel / ingénieur pour les applications

La situation passée : notation UML …

Problématique


-Reformulation de la problématique-Utilisation de méthodes pour analyser le problème : analyse fonctionnelle, méthode MARS, UML non formel,…


Approche par la simulation- Création d’un scénario traduisant la problématique- Utilisation de modèles- Création d’une application àpartir d’un environnement de simulation


-Spécificationde l’appli de simulation

-Conception

-Développement

-Implémentation

- Tests


environnement)


Résultats





Problématique







-Conception

-Développement

-Implémentation

- Tests


environnement)


Résultats





Problématique







-Conception

-Développement

-Implémentation

- Tests


environnement)


Résultats






L’environnement de développement, exécution,

et exploitation de simulations

DirectSim


Contexte d’application


Créer des applications de simulationA l’ANPROS, nous créons des applications de simulation pour les études de recherche opérationnelle

Processus de développement basé sur une analyse de haut niveau en privilégiant UML – notation « general purpose » (depuis 1999)

MaisC’est une affaire de spécialiste génie logicielOr ceux qui ont besoin des simulations d’étude peuvent être des opérationnels (qui ne peuvent/veulent pas forcément parler UML) et ne peuvent / veulent pas aller trop loin dans le code. Or il faut pouvoir collaborer.

EtNos applications de simulation sont basées sur un « framework de simulation » générique et complexe qui capture et factorise ce qui est commun aux applications de simulation d’étude.Les modèles représentent visuellement les variations (points d’insertion) que permettent le frameworkOr le modeleur UML ne connaît pas ce framework, et ce n’est pas forcément facile de le lui apprendre.


Créer, maintenir des applications de simulation à partir de modèlesNous avons identifié 4 types de modèles

pour spécifier, concevoir et développer des applications de simulation

Parmi ceux-ci, la notion de « Comportement ».Ex : le comportement du chien ou de l’hélicoptère de la vidéo.

Il est complexe en soi.

Mais les choses sont encore plus compliquées par le manque d’interaction entre le modèle et le framework de simulation sous-jacent ou les composants de simulation réutilisés qui contraignent la modélisation IntelliSense au

niveau du modèle, débugging idem .


Développement d’applications de simulation par les modèles

Nous cherchons à rendre la modélisation d’applications de simulation possible par des non spécialistes (un plus grand nombre)

S’attacher aux conceptsMasquer le plus possible les détails du framework et aider à l’apprendreAvoir des éditeurs graphiques attractifs et ergonomiques qui parlent dans le langage de l’opérationnel.

Les DSL … une solution possible

Assembling Applications with Patterns, Models, Frameworks and ToolsMicrosoft nous fournit des outils « les DSL Tools »pour créer des éditeurs graphiques permettant de manipuler nos modèles spécifiques / métier


DirectSim : pourquoi ça va plus vite !

Des framework génériquesGénie logiciel, métiers techniques.Framework de simulation

Des modèles d’expertise métier « Marine »Capitalisés au fur et à mesure des études

Un environnement de développement d’applications de simulation

Dans Visual Studio.NET 2005 La modélisation y tient une place importante

Un environnement d’exploitation

Ce qui est spécifique à une application de simulation

est capturé dans des modèles

ModModèèleslesUML ou DSLUML ou DSL

.NET Framework

Ductor.NET

Tran

sfo. D

e mo

dèles, g

énératio

nd

e cod

e, rétro-in

g.

Ou

tilsp

ou

r

Composants Génie logiciel IHM automatiques

Base

Modèles d’Expertise

PlatePlate--FormeForme

Cadre Technique informatique, Cadre Technique informatique, architecturearchitecture

DrawCartography

Maths

LogicalSpace

LogicalTime Geography

Physics

Simulation

Composants de simulation

Applications

ModModèèles rles rééutilisablesutilisables

Applications de simulationApplications de simulation

Tools

Technique de simulationTechnique de simulation

Technique MTechnique Méétierstiers

Ce qui est commun aux applications de simulation

est factorisé dans des framework






DiscussionUML et DSLPotentiel et limites techniques actuelles des DSL ToolsL’avenir à court terme


L’extensibilité Visual StudioLes possibilités

Options de Options de personnalisation, Snippetspersonnalisation, Snippets

MacrosMacros

Add-InsAdd-Ins

PackagesPackages

Accessibilité aux développeursAccessibilité aux développeurs

Niv

eau

N

iveau

d

’inté

gra

tion

d’inté

gra

tion

Cou

t C

ou

t d

’in

tég

rati

on

d’inté

gra

tion

Nécessite le VS SDK Cas des Language Packages et en particulier des DSL


Les DSL Tools

Visual Studio 2005Visual Studio 2005

VS 2005 SDKVS 2005 SDK

DSL ToolsDSL ToolsPackagePackage

DSLDSL

Code, DocCode, DocFichiers Fichiers

dedeconfigconfig

ApplicationApplication

Auteur de DSL(Architecte)

Utilisateur de DSL(Développeur)

Utilisateurfinal

crée

génère

produit

Fra

mew

ork

Framework

Framework


Avec des DSL bien faits :

Nous sommes guidés au fur et à mesureLe modèle est validé à tous momentsUn Custom Tool génère du codeLe code généré compile forcément !Il y a des possibilités illimitées d’interactions avec Visual Studio :

Editeurs spécialisés pour les propriétésDrag & DropDebuggerEtc …


Comment créer un DSL ?Un type de projet dans VS 2005 (choix d’un template)

Modification du Domain Model (méta-modèle)

Mise à jour de la Designer Definition (notation graphique)

Ecriture de code personnalisé pour la validation … et les aspects graphiques avancés, l’interaction avec VS

Code T4 pour les générateurs de code

Les détails de tout cela dépassent la portée de cette conférence …


Le processus de création d’un DSL avec les DSLTools

AssistantCrée et configure

une solution Visual Studio.NET pour un éditeur de DSL (à partir d’un patron)

Définition du DSL

Édition du « Domain Model »

Méta modèle (DMD)Sérialisation du modèle

Contraintes

Édition de la définition de l’éditeur graphique

Notation graphique(DD)Lien entre méta modèle et Notation graphique

ExplorateurFenêtre des propriétés

Comportement de validationSérialisation de l’état de l’éditeur

Partie « Package VS.NET »

Ajout de code

Corps des contraintesImport / Export personnaliséAutres enrichissements

Génération de code de l’éditeur

graphique

Création d’un installeur pour le déploiement

du DSL

Build (F5)

ExécutionLancement d’une

instance expérimentale de VS.NET sur la

solution de debugging

Test DebuggingUtilisation du designerGénération d’artefactsModification de patrons


Création d’un Designer avec les DSL Tools

Code généré Code généré par les DSL Toolspar les DSL Tools

NotationNotationGraphiqueGraphique

(Dd)(Dd)

MappingMappingDm <-> DdDm <-> Dd

DéfinitionDéfinitiondu méta-du méta-ModèleModèle

(Dm)(Dm)

ComportementComportementspécifiquespécifique

Validation/Validation/ContraintesContraintes

SérialisationSérialisationXMLXML

spécifiquespécifique

GénérationGénérationCode/Code/

ArtefactArtefact

Code personnaliséCode personnalisé(Utiliser le VS SDK)(Utiliser le VS SDK)


Anatomie d’un DSL

1. Domain Model

2. Designer Definition

3. Correspondance entre les deux.

4. Code sur mesure (validation) (effets élaborés)


Code sur mesure

Règles de cohérence du modèle

Règles de validation du modèle[ValidationState(ValidationState.Enabled)]public partial class State{ /// <summary> /// A final state should not have outgoing transitions /// </summary> /// <param name="context"></param> [ValidationMethod(ValidationCategory.Open | ValidationCategory.Save | ValidationCategory.Menu)] private void ValidateFinalStateHasNoOutgoingTransitions(ValidationContext context) { Transition[] transitions = GetOutgoingTransitions(); if ((Kind == StateKind.Final) && (transitions.Length > 0)) { string error = string.Format(System.Globalization.CultureInfo.CurrentUICulture, DomainModel_Resource.FinalCannotHaveOutgoingTransitions, Name); context.LogError(error, "StateMachines 42", transitions); } } …}

/// <summary>/// When the event / condition / action changes the label is recomputed and/// vice versa/// </summary> [RuleOn(typeof(Transition), FireTime = TimeToFire.TopLevelCommit)]public sealed class TransitionAttributesChanged : ChangeRule{ /// <summary> /// This method is called whenever any attribute of a Transition changes. /// It processes the coherence Label = Event + "["+Condition+"] / "+Action /// </summary> /// <param name="e"></param> public override void ElementAttributeChanged(ElementAttributeChangedEventArgs e) { Transition t = e.ModelElement as Transition; // Compute Label when Event changes if (e.MetaAttribute.Id == Transition.EventMetaAttributeGuid) t.Label = ComputeSummary(e.NewValue as string, t.Condition, t.Action); // Compute Label when Condition changes else if (e.MetaAttribute.Id == Transition.ConditionMetaAttributeGuid) t.Label = ComputeSummary(t.Event, e.NewValue as string, t.Action); // Compute Label when Action changes else if (e.MetaAttribute.Id == Transition.ActionMetaAttributeGuid) t.Label = ComputeSummary(t.Event, t.Condition, e.NewValue as string); // Compute Event, Condition, Action when Label changes else if (e.MetaAttribute.Id == Transition.LabelMetaAttributeGuid) { System.Text.RegularExpressions.Match match = eventLabelRegEx.Match(e.NewValue as string); if (match.Success) { t.Event = match.Groups["EventGroup"].Value.Trim(); t.Condition = match.Groups["Condition"].Value.Trim(); string actionWithSlash = match.Groups["ActionGroup"].Value.Trim(); if (actionWithSlash.StartsWith("/")) t.Action = actionWithSlash.Substring(1).TrimStart(); else t.Action = actionWithSlash; } }


Générateur de codeécrit en T4 (Text Templating Transformation)

On peut en faire un Custom Tool !

/// <summary> /// Method to clean up the resources(such as timers for example) allocated by the state. /// </summary> /// <param name="disposing">Is the state disposing</param> /// <param name="stateMachine">State machine owning this state</param> /// <param name="driven">Driven interface</param> public virtual void Dispose(bool disposing, <#=stateMachineName#> stateMachine, <#=drivenInterface#> driven) { } } <# foreach(State state in StateMachine.AllStates) { // Find base class (class implementing ParentState) string baseName; if (state.ParentState == StateMachine) baseName = baseStateName; else baseName = state.ParentState.GetFullName(); // List of eventsDictionary<string, List<Transition>> transitionsFromStateByEventSignature = state.GetOutgoingTransitionsGroupedByEventSignature(true);#> /// <summary> /// <#=state.Comment#> /// </summary> class <#=state.GetFullName()#> : <#=baseName#> {<# foreach(string transitionEventSignature in transitionsFromStateByEventSignature.Keys) { Transition t = transitionsByEventSignature[transitionEventSignature][0];

/// <summary>/// Declaration of the package providing the Simulation code generator/// </summary>[ProvideCodeGenerator(typeof(StateMachinesGenerator), "StateMachinesGenerator", "Custom tool that generates C# files based on .StateMachine files", true)]public sealed partial class StateMachinesPackage {}

[Guid("9DA6F053-E5B9-4955-A6AE-89FB5505E8E6")]public class StateMachinesGenerator : TemplatedCodeGenerator{ protected override byte[] GenerateCode(string inputFileName, string inputFileContent) { // Replace the supplied file contents with the template we want to run inputFileContent = ASCIIEncoding.UTF8.GetString(Properties.Resources.StateMachinesReport); // Substitute the name of the current model file into the template. FileInfo fi = new FileInfo(inputFileName); inputFileContent = inputFileContent.Replace(@"%MODELFILENAME%", fi.Name); inputFileContent = inputFileContent.Replace(@"FileNameSpace", this.FileNameSpace); // Now just delegate the rest of the work to the base class byte[] data = base.GenerateCode(inputFileName, inputFileContent); byte[] ascii = new byte[data.Length - 3]; Array.Copy(data, 3, ascii, 0, data.Length - 3); return ascii; }}

Anatomie du DSL de Anatomie du DSL de comportement comportement dynamiquedynamique

demodemo

Exemple d’utilisation Exemple d’utilisation des DSL Simulationdes DSL Simulation


Tno fields

guidedReacherTno : Models.Components.Mobility.Parts.Reachers.GuidedReacher.TnostationDuration : double

Init fields

position : Base.LogicalSpace.Locationvelocity : Base.LogicalSpace.VectortargetPosition : Base.LogicalSpace.Locationcarrier : Base.LogicalSpace.IMoveable

Events

Part

Station

IMoveableTno fields

Init fields

position : Base.LogicalSpace.Locationvelocity : Base.LogicalSpace.VectortargetPos : Base.LogicalSpace.Location

Events

Part

RectilinearReacher

Part

AbstractReacher

IMoveableTno fields

Init fields

Events

OnCompleted

Part

AbstractMoveable

IMoveableTno fields

dtMin : doubledtMax : doublecoeff : doublenavigation : Models.Expertise.Mobility.Navigation.AbstractNavigationautoPilotTFdenom : double[]

Init fields

position : Base.LogicalSpace.Locationvelocity : Base.LogicalSpace.Vectortarget : Base.LogicalSpace.IMoveableisSynchro : bool

Events

Part

GuidedReacher

rectilinearReacher

1

guidedReacher

1

/// <summary> /// Position of the behavior Part depending on its state /// </summary> public override Base.LogicalSpace.Location Position { get { switch (state) { case BehaviorState.WayBack: return guidedReacher.Position; case BehaviorState.WayOn: return rectilinearReacher.Position; case BehaviorState.Docked: return carrier.Position; default: return base.Position; } } } /// <summary> /// Velocity of the behavior Part depending on its state /// </summary> public override Base.LogicalSpace.Vector Velocity { get { switch (state) { case BehaviorState.WayBack: return guidedReacher.Velocity; case BehaviorState.WayOn: return rectilinearReacher.Velocity; case BehaviorState.Docked: return carrier.Velocity; default: return base.Velocity; } } }

IMoveableTno fields

guidedReacherTno : Models.Components.Mobility.Parts.Reachers.GuidedReacher.TnostationDuration : double

Init fields

position : Base.LogicalSpace.Location

velocity : Base.LogicalSpace.VectortargetPosition : Base.LogicalSpace.Locationcarrier : Base.LogicalSpace.IMoveable

Events

Part

Station IMoveable (-> station)Tno fields

stationTno : SimulationDebugging.Station.Tno

Init fields

carrier : Base.LogicalSpace.IMoveable

Events

Agent

Helicoptere

station

1

IMoveable (-> pathMover)Tno fields

pathMoverTno : Models.Components.Mobility.Parts.Movers.PathMover.TnohelicoptereTno : Helicoptere.Tno

Init fields

position : Base.LogicalSpace.Location

velocity : Base.LogicalSpace.Vectorpath : Base.LogicalSpace.Location[]

maintenanceDelay : double

Events

Agent

Frigate

IMoveableTno fields

reacherTno : Models.Components.Mobility.Parts.Reachers.AbstractReacher.Tno

Init fields

position : Base.LogicalSpace.Locationvelocity : Base.LogicalSpace.Vector

path : Base.LogicalSpace.Location[]tripCount : int

Events

Part

PathMover

pathMover

1

helicoptere

1

Tno fields

frigateTno : Frigate.Tno

Init fields

frigatePath : Base.LogicalSpace.Location[]

speed : doublemaintenanceDelay : double

Events

Team

Blue

Tno fields

teamTno : SimulationDebugging.Blue.Tno

Init fields

frigatePath : Base.LogicalSpace.Location[]

speed : doublemaintenanceDelay : double

Events

Application

Application

frigate

1team

1

Modèle d’analyse d’une application de simulation

Bibliothèque de modèles capitalisés

Conception de nouveaux composants de simulation

Structure statique

Structure dynamique

Code utilisation expertise

Mise au point

Exécution

Vie d’une application de simulation


Le sujet

Travail d’un hélicoptère en « sentinelle »

Un sous-marin s’approche.

L’hélicoptère arrête sa patrouille pour aller voir.

L’hélicoptère suit un hippodrome et

regarde (au radar)

Lorsqu’il détecte quelque-chose il va pour l’identifier


L’Environnement de développement Simulations


Ce que nous avons vu dans la démo

Des designers qui présentent des concepts spécialisés dans des modèles spécifiques

Des générateurs de code qui savent prendre ces modèles et générer du code ciblant un framework.

Une excellente intégration à VS 2005

Une autre façon d’architecturerses projets


Plan de la présentation

Manipuler des « concepts et d’intentions » dans Visual Studio 2005


Formaliser nos solutions … jusqu’aux DSL


DiscussionUML et DSLPotentiel et limites techniques actuelles des DSL ToolsL’avenir à court terme


DiscussionL’UML est-il mort ?

à l’ANPROS nous utilisons UML et des DSL

Les potentialités et les limites actuelles des DSL Tools ?

Peut-on refaire ‘Rose’ avec des DSL ?Ce qu’on peut faire avec et qu’on ne peut pas faire sans

L’avenir à court termeLa V1 est pour mai.Beaucoup de changements en perspectiveEt ce n’est qu’un début !


Combien couteront les DSLTools ?Ils seront gratuits, dans le VS SDK.

Est-ce qu’on est obligé d’héberger nos DSL dans VS 2005 ?Oui, pour le moment (sauf version Express)

A terme, on pourra se procurer un VS « vide »

Puis, on pourra héberger les designers hors de VS (V2 des DSLTools)

Est-ce qu’on ne pourrait pas faire la même chose en UML ?C’était ce que nous faisions avant, mais :

on a des compartiments spécifiques du métier pour le DSL « Simulation Architecture » et le DSL « State Machine » comporte la notion de « Délégation à une entité de simulation »

Les deux connaissent le Framework et interagissent avec les assemblages de modèles.

Tout est intégré et synchronisé dans le processus de production de code.

FAQ


Conclusion

Utiliser un DSL ne nécessite pas d’être architecte. Le créer : si !

Les langages visuels y ont une place importante dans la Vision « Software Factory » de Microsoft. Un autre « pilier » est GAT (Guidage assisté), non présenté ici

A Vous d’imaginer votre problème factorisé dans un Framework et ses variations capturées dans un DSL


Liens utilesInformations sur les DSL Tools http://msdn.microsoft.com/vstudio/dsltools/default.aspx (Home page)

http://forums.microsoft.com/msdn/showforum.aspx?forumid=61&siteid=1

Présentation ‘DSL Tools’ au symposium DNG 2005http://www.dotnetguru.org/modules.php?op=modload&name=News&file=article&sid=681 (compte-rendus)http://dotnetguru.cledunet.com/SymposiumDNG-2005.zip : (13 Mo, planches 122-180)

http://www.brainsonic.net/DesktopDefault.aspx?tabid=24&parentid=164&site=353 (Webcast)

Lab virtuel en lignehttp://msevents.microsoft.com/CUI/WebCastEventDetails.aspx?EventID=1032285310&EventCategory=3&culture=en-US&CountryCode=US

VS 2005 SDK (Février 2006)http://affiliate.vsipmembers.com/affiliate/downloadfiles.aspx Compléments Indispensables jusqu’à la V1 !http://www.modelisoft.com/Dmd2Dd.aspx (Synchro Dm <-> Dd)

http://www.modelisoft.com/T4LangPackage.aspx (Coloration syntaxique T4)

http://msdn.microsoft.com/vstudio/dsltools/default.aspx

http://forums.microsoft.com/msdn/showforum.aspx?forumid=61&siteid=1

http://www.dotnetguru.org/modules.php?op=modload&name=News&file=article&sid=681

http://dotnetguru.cledunet.com/SymposiumDNG-2005.zip

http://www.brainsonic.net/DesktopDefault.aspx?tabid=24&parentid=164&site=353

http://msevents.microsoft.com/CUI/WebCastEventDetails.aspx?EventID=1032285310&EventCategory=3&culture=en-US&CountryCode=US

http://msevents.microsoft.com/CUI/WebCastEventDetails.aspx?EventID=1032285310&EventCategory=3&culture=en-US&CountryCode=US

http://affiliate.vsipmembers.com/affiliate/downloadfiles.aspx

http://www.modelisoft.com/Dmd2Dd.aspx

http://www.modelisoft.com/T4LangPackage.aspx

DSL et DSL Tools

Documents

Transcript of DSL et DSL Tools