In my keynote talk at the Model-Driven Service Engineering workshop in Malaga (co-located with ICMT and TOOLS) I gave a presentation of mobl, the domain-specific language for mobile (web) application development that we (Zef Hemel) are developing.
The MODELS 2010 program committee has selected 54 papers from the 253 submissions.
Dorina Petriu, the program chair of MODELS 2010 allowed me to upload the list of accepted papers to researchr.
The MODELS 2010 proceedings entry on researchr contains the complete list of accepted papers with authors. The paper pages provide bibtex entries for the papers. (Of course, page numbers and DOIs are still missing.)
Researchr is a bibliography management tool that enables users to correct and complement the bibliographic records in its database.
If you are an author of one of the MODELS papers, please add abstracts, tags, and links to further information about the work described in the paper to the researchr record for the paper.
"In the beginning were the words, and the words were trees,
and the trees were words. All words were made through
grammars, and without grammars was not any word made
that was made. Those were the days of the garden of Eden.
And there where language engineers strolling through the
garden. They made languages which were sets of words by
making grammars full of beauty. And with these grammars,
they turned words into trees and trees into words. And the
trees were natural, and pure, and beautiful, as were the grammars.
Among them were software engineers who made software
as the language engineers made languages. And they
dwelt with them and they were one people. The language engineers
were software engineers and the software engineers
were language engineers. And the language engineers made
language software. They made recognizers to know words,
and generators to make words, and parsers to turn words
into trees, and formatters to turn trees into words.
But the software they made was not as natural, and pure,
and beautiful as the grammars they made. So they made software
to make language software and began to make language
software by making syntax definitions. And the syntax definitions
were grammars and grammars were syntax definitions.
With their software, they turned syntax definitions into
language software. And the syntax definitions were language
software and language software were syntax definitions. And
the syntax definitions were natural, and pure, and beautiful,
as were the grammars."
Thus starts our essay on declarative syntax definition, which has been accepted for presentation at the Onward! 2010 conference:
Abstract
Syntax definitions are pervasive in modern software systems,
and serve as the basis for language processing tools
like parsers and compilers. Mainstream parser generators
pose restrictions on syntax definitions that follow from their
implementation algorithm. They hamper evolution, maintainability,
and compositionality of syntax definitions. The
pureness and declarativity of syntax definitions is lost. We
analyze how these problems arise for different aspects of
syntax definitions, discuss their consequences for language
engineers, and show how the pure and declarative nature of
syntax definitions can be regained.
In the fifth lecture in the Model-Driven Software Development course at TU Delft I talked about strategies for design and implementation of domain-specific languages, illustrated with a sketch of the mapping from WebDSL to Java.
The Stratego transformation language was originally developed on and for the C/Linux platform. A couple of years ago we started porting the language and the Stratego/XT infrastructure to Java, which eventually enabled us to build the Spoofax Language Workbench. The back-end of the Stratego compiler was fairly unproblematic; the back-end for C is a bit over 1000 lines of code translating the compact Stratego Core language. Porting this was a matter of replacing the translation scheme. However, the extensive library, partly consisting on primitives implemented in C, depended on the Linux platform. To adapt the library to the Java platform, we extended Stratego with a simple aspect mechanism. Using override and proceed stragey definitions from libraries can be replaced with new definitions. The aspect extension and its application for achieving portability is discussed in the following paper (which has been accepted for the SCAM 2010 conference):
Abstract:
Software platforms such as the Java Virtual Machine or the CLR .NET virtual machine have their own ecosystem of a core programming language or instruction set, libraries, and developer community. Programming languages can target multiple software platforms to increase interoperability or to boost performance. Introducing a new compiler backend for a language is the first step towards targeting a new platform, translating the language to the platform's language or instruction set. Programs written in modern languages generally make extensive use of APIs, based on the runtime system of the software platform, introducing additional portability concerns. They may use APIs that are implemented by platform-specific libraries. Libraries may perform platform-specific operations, make direct native calls, or make assumptions about performance characteristics of operations or about the file system.
This paper proposes to use aspect weaving to invasively adapt programs and libraries to address such portability concerns, and identifies four classes of aspects for this purpose. We evaluate this approach through a case study where we retarget the Stratego program transformation language towards the Java Virtual Machine.
The third and fourth lectures in the course on model-driven software development that I teach at TU Delft. I talked about domain-specific abstractions in the domain of web programming, as incarnated in the design of WebDSL.
The material is based on the following publications:
The big contribution with respect to the earlier paper is a new approach to type checking with Stratego. Instead of defining a type checker as a single traversal that takes care of name resolution, type analysis, error checking and generation of error messages, these aspects are defined separately and can also be used separately. This allows a much cleaner style for defining type checkers and it enables a smooth combination of type analysis and normalizing transformations. The style also turned out to work very well in Spoofax setting where analyses such as name resolution are used for multiple purposes in the IDE.
The paper is published under the open access regime, so you can read it even without subscription to the journal.
Abstract
The realization of model-driven software development requires effective techniques for implementing code generators for domain-specific languages. This paper identifies techniques for improving separation of concerns in the implementation of generators. The core technique is code generation by model transformation, that is, the generation of a structured representation (model) of the target program instead of plain text. This approach enables the transformation of code after generation, which in turn enables the extension of the target language with features that allow better modularity in code generation rules. The technique can also be applied to ‘internal code generation’ for the translation of high-level extensions of a DSL to lower-level constructs within the same DSL using model-to-model transformations. This paper refines our earlier description of code generation by model transformation with an improved architecture for the composition of model-to-model normalization rules, solving the problem of combining type analysis and transformation. Instead of coarse-grained stages that alternate between normalization and type analysis, we have developed a new style of type analysis that can be integrated with normalizing transformations in a fine-grained manner. The normalization strategy has a simple extension interface and integrates non-local, context-sensitive transformation rules. We have applied the techniques in a realistic case study of domain-specific language engineering, i.e. the code generator for WebDSL, using Stratego, a high-level transformation language that integrates model-to-model, model-to-code, and code-to-code transformations.
