Agile development with DSLs

Transcription

1 Alan Cameron Wills Agile development with DSLs Wizard sample Visual Studio SDK is supplied with a set of examples. We ll look at a DSL that helps developers design wizards. 1

2 Wizard sample The code in this project defines an editor for a diagrammatic domain-specific language. This file is the DSL definition. Most of the code for the DSL editor is generated from it. Wizard sample Build and start the project this starts a new instance of Visual Studio, containing code for a wizard. Most of the code in this project is generated from the DSL. 2

3 Wizard sample Build and start the wizard project this runs the sample wizard. Normally the wizard project would be part of a larger application solution. Roles After debugging the DSL, its author will create and publish an installer enabling other developers to use it. Designing Wizard framework and DSL Architect The developers create applications with wizards in them. Wizard DSL & framework helps with wizard Developer Designing an app containing a wizard Hotel booking using an app with a wizard 3

4 Build model The DSL author has to create the DSL definition, the templates for turning it into code, and the framework code in which the generated code runs. Application FeatureDSL definition templates Feature Framework MyFeature Model Graphical Editor feature = wizard in the case of our example. generator code Code Config files Serialized model <xxx><y yy title= xx ><zzz> The application developer has to create an instance of the DSL (and the parts of the application that the DSL doesn t deal with, of course.) Templates Model Wizard Namesp= UIPSample Page Name= MyFirstWiza rdpage Field Name= MyFirstField Page Field Field Parameterized template code: namespace <#= wizard.namesp #> <# foreach (Page page in wizard.pages) #> public partial class <#= page.name #> public <#= page.name #>() InitializeComponent(); InitializeDelegates(); } public object GetFieldValue(string fieldname) switch(fieldname) <# foreach (Field field in page.fields) #> case <#= field.name #> ": In MS DSL Tools, generation is done with templates. The DSL author creates code that queries the developer s model. In the template, the query code and material being generated are mixed. The generated material need not be code. Generated code: namespace UIPSample public partial class MyFirstWizardPage public MyFirstWizardPage() InitializeComponent(); InitializeDelegates(); } public object GetFieldValue(string fieldname) switch(fieldname) case MyFirstField": 4

5 Combining generated and handwritten code Local modifications templates Inevitably, the DSL author cannot anticipate every application, and developers will want to adapt it. Feature Framework My Model generator Generated stuff What if I don t like all of the generated stuff? And there s some of the Framework I don t like either 5

6 Local modifications templates So there has to be some way of providing for handwritten material to be combined with generated material. My Model generator Generated stuff Feature Framework + Combined stuff Handwritten stuff? One-off generation templates One approach is just to edit the generated material. Unless you have a round-trip mechanism (which only works in some cases) you ve lost the connection, and so the generated material can only be a start. My Model generator Generated stuff Generate first time only Feature Framework Model initial design Hand edit afterwards Hand edited stuff Edit the framework too Not recommended 6

7 Combining generated and hand code One-off generation Only get the advantage of prewritten framework and initial code from model Model useless after code is edited Customizable generation Developer never edits generated code Generated code designed for customization Hooks and overridable code Customizable generation templates My Model generator superclasses Feature Framework compile Combined code Subclass overrides Event definitions Rule definitions More superclasses Generation gap pattern 7

8 Generation Gap Generate Methods to superclass Constructors to subclass Add handwritten code to subclass Can override generated methods Partial classes Generated public partial class FoundRoom private System.ComponentModel.IContainer components = null; protected override void Dispose(bool disposing) Handwritten public partial class FoundRoom public override void InitializeDelegates() base.initializedelegates(); 8

9 Postprocess composition Works for general files templates For material other than C#, post-processing is the answer. A variant of this approach allows the generator to edit only certain marked-out parts of a file. My Model generator Generated config file Feature Framework Postprocess Combined config file Handwritten config file Edit the templates Good for mass changes Edit My Model templates generator Generated Generated Generated files files files Feature Framework Less easy to debug 9

10 Round-tripping templates My Model edit generator parser rules Generated file edit Much more difficult to generalize Much more difficult to write than templates Round-trip tools keep model close to code MS DSL Tools currently don t do round-trip Diff templates My Model generator Old version Generated file Highlight changes and flag need for review! edit occasional edit 10

11 Dynamic configuration Direct API Application Wizard DSL definition MyWizard Model templates Feature Framework Graphical Editor translator API Serialized model <wizard ><state title= xx ><transit ion> 11

12 DSL embedded in bigger application Workflow Server Edits work item state chart Evolving a DSL and Framework 12

13 Template parameters Original unparameterised code: Parameterized template code: Wizard namespace Fabrikam.DSL.WizardUIP.UIPSample public partial class MyFirstWizardPage public MyFirstWizardPage() InitializeComponent(); InitializeDelegates(); } public object GetFieldValue(string fieldname) switch(fieldname) case MyFirstField": namespace <#= wizard.namespace#> <# foreach (Page page in wizard.pages) #> public partial class <#= page.name #> public <#= page.name #>() InitializeComponent(); InitializeDelegates(); } public object GetFieldValue(string fieldname) switch(fieldname) <# foreach (Field field in page.fields) #> case <#= field.name #> ": page field page field field Evolving a framework Original code Templatized code Model Syntax <wizard ><state title= xx ><transit ion> 13

14 Separation of variability Fixed Wizard DSL definition MyWizard Model templates generator Application Patterns of implementation in this domain Wizard Framework MyWizard Code Hand code Language of requirements in this domain Config files Variable Architectural refactoring Generalize to framework, templat es and DSL Enhance Develop instance solutions Use in further instances 14

15 Development feedback loops Architect Wizard framework Developer Application (uses Wizards) Customer Summary Domain-specific language provides a means to express the variable requirements in a domain Framework represents the patterns of implementation in the domain DSL and Framework are developed Together By evolution from instances 15

16 Software factories Benefits of Domain Specific Language = Benefits of clean API: separation of concerns opportunity for clearly-defined contract + Benefits of good language: Communication and comprehension Focus on domain abstractions Readability Clear mental model Communication with customers Explicit grammar Constraint validation + Benefits of suitable modern editor: - Prompting and contextual guidance what s [not] allowed - Navigation and search - Holophraxis collapse/expand, zoom 16

17 Stabilizing the architecture sys 1 sys 2 sys 3 architects developers sys 11 framework patterns guidelines little languages templates tools recipes sys 12 developers developers developers sys 13 sys14 Software Factory Architecture Patterns, Guidance, & Recipes Process and roles Framework, Components domain model Tools Languages and Editors Call base rate: /s Record <CallRecord> <caller><number> </number> call store call length class Magnox : NuclearPowerStation public void droprods () 17

18 Domain-specific Framework, Components, Architecture Implements design patterns in this domain Language Use to understand or define requirements; or design (of some aspect) And maybe generate (some of) solution Tools and Recipes Common refactorings, patterns, in this domain Style guideline conformance Process and roles e.g.: Customer-facing vs framework developers Methods for creating and verifying models in DSLs Nouns and verbs; legacy mining; client doc mining; genetic evolution; consistency tests; reviews; prototyping; run-it-and-see; Sync of hardware and software deployment Patterns and Guidance Written by lead developers to guide implementation of choices Software Factories 19 th Century sweatshop Thousands of people doing repetitive backbreaking labour from scratch with primitive tools 21 st Century Mass Customization Repetitive stuff done by automatic tools People do the interesting stuff that varies between instances 18

19 Software Factory = Domain-specific Languages Guidance Tools Recipes Patterns Templates Frameworks Relationships/constraints between viewpoints Templates Template = Parameterised structure of source files Skeleton source code in Java, C#, Resource files (icons etc) make / config / build control files Debug info IDE parameters Recipes Template defines a type of solution Instantiated template Wizard Template fill in template parameters 19

20 Recipes Recipe = operation on a type of solution item arguments gathered from context and user Add command Add web command Validate command set --- Add Item New Rename --- Build Debug --- Delete new toolbox icon skeleton for new command Skeleton code for command coupling MyNewToolIcon.bmp Summary An integrated domain-specific package of DSLs Tools accelerates development in that area But requires development good for repeated tasks Repeated development tasks if you do a lot of work with The same vertical domain The same horizontal technology 20

21 DSLs in the software development process Brainstorm Requirements 21

22 Refine requirements model Many ways of modeling requirements, depending on domain... 22

23 Use factories to define project backlog Actual Predicte d Jan Feb Mar Apr May Interact with architecture models 23

24 Trace architecture to requirements Software Factory window, allowing users to select from all of the products being worked on. Each view has an editing experience optimized for the problem domain Logical view of the product being developed, constrained by the factory schema and a standard way of viewing the work products belonging to each view. 24

25 Each activity has a number of associated assets The factory guides the Detail pane shows the user through the activities associated sequence of activities with the selected viewrequired to build the product Summary DSLs can be used at several stages in the software development process And in planning 25

26 Bibliography 26