About fifteen months ago I announced
my ``Domain-Specific Language Engineering'' project that would result in a tutorial for the GTTSE'07 summerschool. "This tutorial gives an overview of all aspects of DSL engineering: domain analysis, language design, syntax definition, code generation, deployment, and evolution, discussing research challenges on the way. The concepts are illustrated with DSLs for web applications built using several DSLs for DSL engineering: SDF for syntax definition, Stratego/XT for code generation, and Nix for software deployment." A rather bold statement, since at time I didn't have a DSL, yet. But I did manage to design and implement a first version of WebDSL before the summerschool in July 2007. I also wrote a paper for the participants proceedings. That version discussed the design process from analyzing programming patterns in Seam/JSF/Java to the design and implementation of the DSL using SDF and Stratego. (I never got around to the deployment part; Sander van der Burg has by now developed Nix expressions for building and deploying a WebDSL application on a web server.)
Now I have finished the
final version of the paper
for the proceedings to be published by Springer.
The discussion of the WebDSL design and implementation has been much improved.
But more importantly, the paper has two introductory sections about the 'domain-specific language engineering' process
and three discussion sections evaluating WebDSL as a web engineering solution, discussing related DSL engineering approaches,
and research challenges for language engineering.
The resulting paper counts 85 pages (LNCS format) and 109 references.
And still, it is only scratching the surface.
There is so much more to say about DSL design and implementation.
The last couple of months I have been teaching a course on
program transformation and generation
in which we have explored paradigms for expressing analysis and transformation.
During this time I have been contemplating how to structure the course entitled "model-driven software development"
that I'll be teaching next year to a much larger group of master's students.
I haven't resolved the issue yet.
But my project for the next 10 months will be to write a comprehensive set of lecture notes (let's call it a book) on
"domain-specific language engineering"
covering methods and techniques for designing and implementing
in particular, of course domain-specific languages. In all likelihood, languages for the web will again play a central role as examples.
WebDSL: A Case Study in Domain-Specific Language Engineering.
In R. Laemmel, J. Saraiva, and J. Visser, editors,
Generative and Transformational Techniques in Software Engineering
(GTTSE 2007), Lecture Notes in Computer Science. Springer,
2008. Tutorial for International Summer School GTTSE 2007.
The goal of domain-specific languages (DSLs) is to increase the
productivity of software engineers by abstracting from low-level
boilerplate code. Introduction of DSLs in the software development
process requires a smooth workflow for the production of DSLs
themselves. This requires technology for designing and implementing
DSLs, but also a methodology for using that technology. That is, a
collection of guidelines, design patterns, and reusable DSL components
that show developers how to tackle common language design and
implementation issues. This paper presents a case study in
domain-specific language engineering. It reports on a project in which
the author designed and built WebDSL, a DSL for web applications with
a rich data model, using several DSLs for DSL engineering: SDF for
syntax definition and Stratego/XT for code generation. The paper
follows the stages in the development of the DSL. The contributions of
the paper are three-fold. (1) A tutorial in the application of the
specific SDF and Stratego/XT technology for building DSLs. (2) A
description of an incremental DSL development process. (3) A
domain-specific language for web-applications with rich data models.
The paper concludes with a survey of related approaches.