Tutorial 6

[ Presenter | Abstract | Relevance | Context | Objectives | TOC | Background | Format | Presenter Biography ]

7th International Conference on the
Unified Modeling Language

<<UML>> 2004

October 12, 2004
Lisbon, PORTUGAL

How to design and use Domain Specific Modeling Languages

Abstract

Software development can be accelerated and made more agile, by designing a language that is specialised to model your domain of interest. A user interface, a database queries, or a page layout is rarely designed these days without using a language (and supporting tools) specific to that purpose - a language that may be textual or graphical or both. A domain-specific language captures an ontology of its domain; and each implementation (a generator, interpreting engine, or simulator that executes the language's statements) encapsulates a framework of components and design patterns. This tutorial will explain how to create and use domain specific languages, and how to make this pattern more applicable to narrower and more specialized domains. We will discuss some related patterns such as adaptive assembly, software product lines and model driven development, and how these form an integrated pattern language we call the "Software Factory". Finally, we will explore in some detail techniques for designing a domain specific language; and look at the tools and processes that go along with such a language.

Relevance

This tutorial is about how to design languages that model a domain, from which software implementations and other enterprise artefacts can be derived. Nearly all participants in a UML conference will be interested in this topic, particularly in the light of the widespread discussion of MDA.

Context

The background for this tutorial is the forthcoming book from Jack Greenfield and Keith Short called "Software Factories: Assembling Applications with Languages, Patterns, Frameworks and Tools", to be published by John Wiley and Sons in July 2004. This book sets out a strategic context for the development of model based software development tools from Microsoft Corporation. The presenters of the tutorial are working in the same group at Microsoft as the authors of this book, and Stuart Kent with Steve Cook also contributed material to the book.

Related tutorials will be offered at the OOPSLA, GPCE, and Agile Development conferences in 2004. Successful workshops have been run at FMOODS 2003 ((http://fedconf.enst.fr/) and OT2004 (see http://www.spa2005.org/cgi-bin/wiki.pl/?DomainSpecificLanguages) .

Objectives

• Scope of appropriateness of domain specific languages to a problem
• How to design a good DSL
  • Variance analysis
  • Choice of language styles
  • Distinguishing the ontology of the domain from languages that state the variances
  • Tools and processes coupled with the language
• Issues in the application of DSLs

Table of Contents

Part 1: Patterns and principles

1.1The Software Factory Pattern Language
1.2. Domain Specific Languages
1.3. How DSLs accelerate software development
1.4. Processes, tools and frameworks supporting DSLs

1.4.1. Attaching DSLs to viewpoints in a Software Factory Schema
1.4.2. Relationships between viewpoints
1.4.3. Transformations between DSLs in related viewpoints

1.5. How to design a DSL

1.5.1. Ontology of the domain
1.5.2. Variance
1.5.3. Designing a good tool-supported language
1.5.4. Executing the DS

Part 2: Exercises in designing DSLs

2.1. Group 1 - Baggage Handling

2.1.1. Sketch a domain model of bag handling
2.1.2. Identify variances between one system and another
2.1.3. Graphical language that distinguishes one system from another
2.1.4. Tools - what can authors using this language do?

2.2. Group 2 - Language for expressing types of tree-like data

2.2.1. Sketch a domain model of tree-like data types
2.2.2. Identify variances between one set of types and another
2.2.3. Graphical language that succinctly expresses a set of tree-like types
2.2.4. Tools - what can authors using this language do?

3. Comparison of results
4. Discussion

Participant background

Participants should be competent practitioners familiar with current software development methods, practices and technologies.

Tutorial Format

Part 1 will be a seminar on the principles and issues in the topic; discussion will be welcome.

Part 2 will be group exercises, followed by comparison and discussion of the results.

Presenter Biographies

Alan Cameron Wills is a software architect in the Enterprise Frameworks and Tools group in Microsoft. He was previously a consultant in analysis and development methods with Trireme International Ltd, mentoring groups in a wide variety of fields. He co-authored the Catalysis approach to component based development. Alan is a frequent presenter at conferences, and is a member of the SoSYM editorial board. His PhD was in the application of formal methods to object-oriented programming.

Alan has given workshops and tutorials in the field of Domain Specific Languages at other conferences including an invited talk at FMOODS 2003 (http://fedconf.enst.fr/), OT 2004 (see http://www.spa2005.org/cgi-bin/wiki.pl/?DomainSpecificLanguages), and Agile Development 2004 (http://www.agiledevelopmentconference.com/).

Stuart Kent is a Program Manager in the Enterprise Frameworks and Tools group at Microsoft where he works on infrastructure and tools to support domain specific modeling. Before joining Microsoft, he was Senior Lecturer at the University of Kent and held a Royal Society Industry Fellowship supported by IBM. He participated and contributed to the UML 2 and MOF 2 standardization efforts for over two years. He has published over 60 papers, is on the editorial board for the Journal of Software and Systems Modeling (SoSyM), has participated in numerous conference programme committees, and speaks frequently at international events. He has a PhD in Computer Science from Imperial College, London.