MoDSE Colloquium
A series of in depth lectures on topics related to the
Model-Driven Software Evolution project.
Future Presentations
Past Presentations
14-05-2009: Comparative Study of Code Query Technologies
- Speaker: Tiago Alves (Software Improvement Group)
- Title: Comparative Study of Code Query Technologies
- Room: HB 09.130, TUD, Mekelweg 4, Delft
- Time: 11:00-12:00
Abstract:
We determine the current state of the art for code query technologies
by comparing seven tools: Grok, Rscript, JRelCal, SemmleCode, JGraLab,
CrocoPat and JTransformer.
Our comparison involves twelve criteria, some of which are concerned
with properties of the tool (output formats, interactive interface,
API support, interchange formats, extraction support, and licensing),
and some of which are concerned with the query language itself (style/
paradigm, types, parametrization, polymorphism, modularity, and
libraries). The comparison between the query languages is performed
by specifying an example query in each of them.
We conclude that there is not a particularly weak or dominant tool
among them.
As important points of improvement, we identified the provision of
libraries, the support of interchange formats, and the integration
with source code extraction components.
14-05-2009: Introduction to the Microsoft Oslo Modeling Platform
- Speaker: Felienne Hermans (TUD) and Gerben van Loon (Avanade)
- Title: Introduction to the Microsoft Oslo Modeling Platform
- Room: HB 19.130, TUD, Mekelweg 4, Delft
- Time: 10:30-12:00
Abstract:
Oslo is the codename for the upcoming Microsoft Modeling Platform which is announced last October at the Microsoft Professional Developer conference in Los Angeles. Oslo is a rich modeling platform that allows you to define and work with textual and visual domain specific languages. Oslo consists of the following three components
- M, the language to create and work with textual DSL's. M consists of three different languages: MGrammar, MSchema and MGraph.
- Quadrant, a tool to interact with DSL's in a visual manner.
- A relational repository that makes models available to tooling.
In this session we will give an introduction to these components and show you in an interactive live demonstration how they work together.
We will explain you how to define some interesting data types and relations in MSchema and how to enter your data in MGraph, which can be inserted into the database along with your schema. We will then show you how to visualize the data using Quadrant. Finally, we will also show how you to write your own custom language using MGrammar.
We will also discuss the limitations of the platform when comparing with other language workbenches, like xText/EMF, Lex/Yacc, XML/XSD/XSLT, and explain how it relates to other Microsoft initiatives like DSL-Tools. For example, Oslo seems to focus primarily on the runtime interpretation of models, where DSL tools provides options to generate source code from models.
23-04-2009: Supporting Data Model Evolution by Automatic Data Migration
- Speaker: Sander Vermolen (TUD)
- Title: Supporting Data Model Evolution by Automatic Data Migration
- Room: HB 09.130, TUD, Mekelweg 4, Delft
- Time: 10:30-12:00
Abstract:
Data models and data are integral parts of software systems. Due to
changing requirements, or maintenance, data models need to evolve over
time. However, evolution of data models frequently invalidates existing
data. To cope with evolving data models, data is generally migrated by
manually written migrations. These manual migrations are labor-intensive
to develop and error-prone, thus holding back the software development
process.
To deal with evolving data models, we have developed a tool set to
support full-automatic migration of data along an evolving data model.
The tool set includes detection of data model changes, mapping data
model changes to data migrations and executing data migrations. We have
validated the tools by performing a migration of DBLP, a large
publication database, to test the quality of detection and ensure
scalability of the tool set.
19-03-2009: Decorated Attribute Grammars. Attribute Evaluation Meets Strategic Programming
- Speaker: Lennart Kats (TUD)
- Title: Decorated Attribute Grammars. Attribute Evaluation Meets Strategic Programming
- Room: HB 09.130, TUD, Mekelweg 4, Delft
- Time: 10:30-12:00
Abstract:
Attribute grammars are a powerful specification formalism for
tree-based computation, particularly for software language
processing. Various extensions have been proposed to abstract over
common patterns in attribute grammar specifications. These include
various forms of copy rules to support non-local dependencies,
collection attributes, and expressing dependencies that are
evaluated to a fixed point. Rather than implementing extensions
natively in an attribute evaluator, we propose attribute
decorators that describe an abstract evaluation mechanism for
attributes, making it possible to provide such extensions as part of
a library of decorators. Inspired by strategic programming,
decorators are specified using generic traversal operators. To
demonstrate their effectiveness, we describe how to employ
decorators in name, type, and flow analysis.
Paper:
Lennart C. L. Kats, Anthony M. Sloane, Eelco Visser.
Decorated Attribute Grammars. Attribute Evaluation Meets
Strategic Programming. In Proceedings of the 18th International
Conference on Compiler Construction (CC 2009), Lecture Notes in
Computer Science. York, United Kingdom, Springer-Verlag, March 2009.
http://www.lclnet.nl/publications/TUD-SERG-2008-038a.pdf
http://strategoxt.org/Stratego/Aster
26-02-2009: Magnolia - a mouldable language
- Speaker: Anya Bagge, Magne Haveraaen (University of Bergen)
- Title: Magnolia - a mouldable language
- Room: HB 09.130, TUD, Mekelweg 4, Delft
- Time: 10:15-12:00
http://magnolia-lang.org/
Abstract:
Magnolia is an experimental, general purpose programming language
being developed at the University of Bergen. The design aims to
* support experimentation with language features,
* be transformation friendly,
* have a sound formal basis,
* have a look-and-feel compatible with widespread languages (C/C++).
Although these goals are quite demanding, they also see to support
each other very well, hopefully making it feasible for a small team to
build the language and its tools.
Features we are experimenting with include:
- exploiting the relationship between specification (concepts) and code
- guarding of operations / alerts
- mutification: relating updating procedure calls and pure expressions
- semantics supporting transformations
- specification-based testing
We implement Magnolia with the newest language technology, i.e.,
Stratego/XT.
18-02-2009: COPE - Coupled Evolution of Metamodels and Models
- Speaker: Markus Herrmannsdörfer
- Room: HB09.130 (EWI)
- Time: 10:30
- Title: COPE - Coupled Evolution of Metamodels and Models
Abstract:
Like other software artifacts, metamodels need to be evolved. When a
metamodel is evolved, existing models may no longer conform to the
evolved metamodel. To reduce the effort for the resulting migration of
models, adequate tool support is required.
This presentation gives an overview of the integrated approach COPE to
incrementally compose the [CO]u[P]led [E]volution of metamodels and
models. COPE is based on the requirements derived from an analysis of
the histories of two industrial metamodels. These requirements are
fulfilled by a language to specify the in-place transformation of
metamodels and models. To provide abstraction from this language, COPE
is integrated into an editor for authoring metamodels. Using this tool
support, a number of case studies have been performed to show the
applicability of the approach in practice.
22-01-2009: Practical Scope Recovery using Bridge Parsing
- Speaker: Emma Nilsson-Nyman (Lund University)
- Title:Practical Scope Recovery using Bridge Parsing
- Room: HB 09.130, TUD, Mekelweg 4, Delft
- Time: 11:00-12:00
http://www.cs.lth.se/home/Emma.Nilsson_Nyman/
Abstract:
Interactive development environments (IDEs) increase programmer
productivity, but unfortunately also the burden on language
implementors since sophisticated tool support is expected even for
small domain-specific languages. Our goal is to alleviate that burden,
by generating IDEs from high-level language specifications using the
JastAdd meta-compiler system. This puts increased tension on scope
recovery in parsers, since at least a partial AST is required by the
system to perform static analysis, such as name completion and context
sensitive search.
In this paper we present a novel recovery algorithm called bridge
parsing, which provides a light-weight recovery mechanism that
complements existing parsing recovery techniques. An initial phase
recovers nesting structure in source files making them easier to
process by existing parsers. This enables batch parser generators with
existing grammars to be used in an interactive setting with minor or
no modifications.
We have implemented bridge parsing in a generic extensible IDE for
JastAdd based compilers. It is independent of parsing technology,
which we validate by showing how it improves recovery in a set of
typical interactive editing scenarios for three parser generators:
ANTLR (LL(variable lookahead) parsers), LPG (LALR(k) parsers), and
Beaver (LALR(1) parsers). ANTLR and LPG both contain sophisticated
support for error recovery, while Beaver requires manual error
productions. Bridge parsing complements these techniques and yields
better recovery for all these tools with only minimal changes to
existing grammars.
11-12-2008: Hera-S - Web Design Using Sesame
- Speaker: Jan Hidders (TU Delft)
- Title: Hera-S - Web Design Using Sesame
- Room: HB 09.130, TUD, Mekelweg 4, Delft
- Time: 10:00-12:00
Abstract:
Web application design methods traditionally aim to reduce complexity
in implementing Web applications. However, these methods struggle with
providing the necessary dynamics and flexibility to keep up with the
increasing users' demand for personalization and feedback mechanisms.
We present Hera-S, based on Sesame and the SeRQL query language that
does provide the necessary flexibility. Hera-S allows designers the
plain use of the Semantic Web languages RDFS and OWL for designing the
domain model and the context data model, thus enabling re-use of
existing data models and opening up the RDF instance data to queries
and updates via the Sesame RDF-framework.
Some links:
-
http://www.adrem.ua.ac.be/~hidders/
-
http://www.wis.ewi.tudelft.nl/
-
http://wwwis.win.tue.nl/~hera/
20-11-2008: Kiama: Embedding language processing in Scala
- Speaker: Anthony M Sloane (Macquarie University and TU Delft)
- Title: Kiama: Embedding language processing in Scala
- Room: HB 09.130, TUD, Mekelweg 4, Delft
- Time: 10:00-12:00
Abstract:
Embedding domain-specific languages (DSLs) in general-purpose
programming languages offers a simpler path to implementation than
developing standalone DSL processors. However, sacrifices must be
made, particularly in formal analysis of DSL programs. This talk
explores these tradeoffs in the context of the Kiama project that is
investigating embedding of language processing DSLs in the Scala
language. Examples will be presented from preliminary experiments with
embedding packrat parsing, strategy-based term rewriting and attribute
grammars. Particular attention will be paid to the novel features of
Scala that assist with this effort, including case classes, implicit
conversion, syntax simplification, advanced support for pattern
matching, scalable components and access to the Java ecosystem.
16-10-2008: Mixing source and bytecode. A case for compilation by normalization
- Speaker: Lennart Kats
- Title: Mixing source and bytecode. A case for compilation by normalization
- Room: HB 09.130, TUD, Mekelweg 4, Delft
- Time: 10:00-12:00
Abstract:
Language extensions increase programmer productivity by providing
concise, often domain-specific syntax, and support for static
verification of correctness, security, and style constraints. Language
extensions can often be realized through translation to the base
language, supported by preprocessors and extensible compilers. However,
various kinds of extensions require further adaptation of a base
compiler's internal stages and components, for example to support
separate compilation or to make use of low-level primitives of the
platform (e.g., jump instructions or unbalanced synchronization). To
allow for a more loosely coupled approach, we propose an open compiler
model based on normalization steps from a high-level language to a
subset of it, the core language. We developed such a compiler for a
mixed Java and (core) bytecode language, and evaluate its effectiveness
for composition mechanisms such as traits, as well as statement-level
and expression-level language extensions.
The presentation is based on the following paper:
L. C. L. Kats, M. Bravenboer, and E. Visser. Mixing Source and Bytecode.
A Case for Compilation by Normalization. In G. Kiczales, editor,
Proceedings of the 23rd ACM SIGPLAN Conference on Object-Oriented
Programing, Systems, Languages, and Applications (OOPSLA 2008),
Nashville, Tenessee, USA, October 2008. ACM Press. (to appear)
Pre-print:
http://swerl.tudelft.nl/twiki/pub/Main/TechnicalReports/TUD-SERG-2008-030.pdf
16-10-2008: Atomic Upgrading of Distributed Systems
- Speaker: Sander van der Burg
- Title: Atomic Upgrading of Distributed Systems
- Room: HB 09.130, TUD, Mekelweg 4, Delft
- Time: 10:00-12:00
Abstract:
Upgrading distributed systems is a complex process. It requires
installing the right services on the right computer, configuring them
correctly, and so on, which is error-prone and tedious. Moreover, since
services in a distributed system depend on each other and are updated
separately, upgrades typically are not atomic: there is a time window
during which some but not all services are updated, and a new version of
one service might temporarily talk to an old version of another service.
Previously we implemented the Nix package management system, which
allows atomic upgrades and rollbacks on single computers. In this paper
we show an extension to Nix that enables the deployment of distributed
systems on the basis of a declarative deployment model, and supports
atomic upgrades of such systems.
The presentation is based on the paper
Sander van der Burg, Eelco Dolstra, and Merijn de Jonge. Atomic
Upgrading of Distributed Systems. HotSWup 2008
25-09-2008: Heterogenous Coupled Evolution of Software Languages
- Speaker: Sander Vermolen
- Title: Heterogenous Coupled Evolution of Software Languages
- Room: Snijderzaal LB 01.010, TUD, Mekelweg 4, Delft
- Time: 10:00-12:00
Abstract:
As most software artifacts, meta-models can evolve. Their evolution
requires conforming models to co-evolve along with them. Coupled
evolution supports this. Its applicability is not limited to the
modeling domain. Other domains are for example evolving grammars or
database schemas. Existing approaches to coupled evolution focus on a
single, homogeneous domain. They solve the co-evolution problems
locally and repeatedly. In this paper we present a systematic,
heterogeneous approach to coupled evolution. It provides an
automatically derived domain specific transformation language; a means
of executing transformations at the top level; a derivation of the
coupled bottom level transformation; and it allows for generic
abstractions from elementary transformations. The feasibility of the
architecture is evaluated by applying it to data model evolution.
The first presentation is based on the following paper:
Sander Vermolen and Eelco Visser. Heterogeneous Coupled Evolution of
Software Languages. In K. Czarnecki, editor, Model Driven Engineering
Languages and Systems (MODELS 2008), Lecture Notes in Computer Science.
Springer, October 2008.
Pre-print:
http://swerl.tudelft.nl/twiki/pub/Main/TechnicalReports/TUD-SERG-2008-028.pdf
25-09-2008: Parse Table Composition
- Speaker: Eelco Visser
- Title: Parse Table Composition
- Room: Snijderzaal LB 01.010, TUD, Mekelweg 4, Delft
- Time: 10:00-12:00
Abstract:
Module systems, separate compilation, deployment of binary
components, and dynamic linking have enjoyed wide acceptance
in programming languages and systems. In contrast, the syntax
of languages is usually defined in a non-modular way, cannot
be compiled separately, cannot easily be combined with the
syntax of other languages, and cannot be deployed as a
component for later composition. Grammar formalisms that do
support modules use whole program compilation.
Current extensible compilers focus on source-level
extensibility, which requires users to compile the compiler
with a specific configuration of extensions. A compound parser
needs to be generated for every combination of extensions. The
generation of parse tables is expensive, which is a particular
problem when the composition configuration is not fixed to
enable users to choose language extensions.
In this paper we introduce an algorithm for parse table
composition to support separate compilation of grammars to
parse table components. Parse table components can be
composed (linked) efficiently at runtime, i.e. just before
parsing. While the worst-case time complexity of parse table
composition is exponential (like the complexity of parse table
generation itself), for realistic language combination
scenarios involving grammars for real languages, our parse
table composition algorithm is an order of magnitude faster
than computation of the parse table for the combined grammars,
making online language composition feasible.
This presentation is based on the paper
Martin Bravenboer and Eelco Visser. Parse Table Composition. In Laemmel,
Gasavic, and Van Wyk (editors). First International Conference on
Software Language Engineering (SLE 2008). Lecture Notes in Computer
Science. Springer, October 2008.
18-09-2008: WebWorkFlow: An Object-Oriented Workflow Modeling Language for Web Applications
- Speaker: Zef Hemel
- Title: WebWorkFlow: An Object-Oriented Workflow Modeling Language for Web Applications
- Room: HB 09.130, TUD, Mekelweg 4, Delft
- Time: 10:00-12:00
Abstract:
Workflow languages are designed for the high-level description
of processes and are typically not suitable for the generation
of complete applications. In this paper, we present WebWorkFlow,
an object-oriented workflow modeling language for the high-level
description of workflows in web applications. Workflow
descriptions define procedures operating on domain objects.
Procedures are composed using sequential and concurrent process
combinators. WebWorkFlow is an embedded language, extending
WebDSL, a domain-specific language for web application
development, with workflow abstractions. The extension is
implemented by means of model-to-model transformations. Rather
than providing an exclusive workflow language, WebWorkFlow
supports interaction with the underlying WebDSL language.
WebWorkFlow supports most of the basic workflow control
patterns.
The presentation is based on the following paper:
Z. Hemel, R. Verhaaf, and E. Visser. WebWorkFlow: An
Object-Oriented Workflow Modeling Language for Web Applications.
In K. Czarnecki, editor, Model Driven Engineering Languages and
Systems (MODELS 2008), Lecture Notes in Computer Science.
Springer, October 2008.
Pre-print:
http://swerl.tudelft.nl/twiki/pub/Main/TechnicalReports/TUD-SERG-2008-029.pdf
10-07-2008 : Declarative Access Control for WebDSL
- Speaker: Danny Groenewegen
- Title: Declarative Access Control for WebDSL: Combining Language Integration and Separation of Concerns
- Room: HB 09.130, TUD, Mekelweg 4, Delft
- Time: 10:00-12:00
In this paper, we present the extension of WebDSL, a domain-specific
language for web application development, with abstractions for
declarative definition of access control. The extension supports the
definition of a wide range of access control policies concisely and
transparently as a separate concern. In addition to regulating the
access to pages and actions, access control rules are used to infer
navigation options not accessible to the current user, preventing the
presentation of inaccessible links. The extension is an illustration
of a general approach to the design of domain-specific languages for
different technical domains to support separation of concerns in
application development, while preserving linguistic integration. This
approach is realized by means of a transformational semantics that
weaves separately defined aspects into an integrated implementation.
The presentation is based on the following paper:
D. Groenewegen and E. Visser. Declarative Access Control for WebDSL:
Combining Language Integration and Separation of Concerns. In D. Schwabe
and F. Curbera, editors, International Conference on Web Engineering
(ICWE 2008). IEEE CS Press, July 2008.
Pre-print:
http://swerl.tudelft.nl/twiki/pub/Main/TechnicalReports/TUD-SERG-2008-021.pdf
12-06-2008 : Generative programming with Java compile-time reflection
- Speaker: Ron Kersic (Capgemini)
- Title: Generative programming with Java compile-time reflection
- Room: HB 09.130, TUD, Mekelweg 4, Delft
- Time: 10:00-12:00
Abstract
Compile-time reflection is a branch of metaprogramming that lets
programmers access and modify the program's abstract syntax tree. It is
a flexible, intrusive technique with which any kind of program
transformation can be implemented. For instance, interfaces, methods, or
fields can be added or removed; method bodies, statements, and
expressions can be manipulated; and new classes or interfaces can be
generated from scratch. More concrete (Java) examples are:
- Force the use of comments on methods and fields (reporting an error if not so).
- Report a warning if the Singleton design pattern is used.
- Transform the body of a setter method of a @Persistent class to save the object's state change into a data store.
Although available to Java programmers since version 5, compile-time
reflection is not as well-known as its run-time brethren. This talk
discusses in detail the construction of compile-time processors that
enhance or restrict the Java language through validations and
transformations to better fit a given problem context. Special attention
is paid on how to integrate warnings, errors and other messages emitted
by the processors into the Eclipse environment.
24-04-2008 : MDSE in action: a gallery of real-life applications of openArchitectureWare
Speakers: Jeroen Bernards and Meinte Boersma (ATOS Origin)
Abstract
We will present several examples of the use of the open source, light
weight MDSE Java framework oAW in projects at Atos Origin. Main features
of oAW which we'll demonstrate in the context of real-life projects:
Xpand (templating), Xtend (transformations), Xtext (DSL generation),
workflow engine, easily expandable/customisable. Experiences with oAW
are compared to experiences using other MDSE frameworks.
27-03-2008 : Generating Editors for Embedded Languages
Speaker: Lennart Kats
Abstract
Integrated Development Environments (IDEs) increase productivity by
providing a rich user interface and rapid feedback for a specific
language. Creating an editor for a specific language is not a trivial
undertaking, and is a cumbersome task even when working with an
extensible framework such as Eclipse. A new IBM-guided effort, the
IMP framework, relieves the IDE developer from a significant portion
of the required work by providing various abstractions for this. For
embedded languages, such as embedded regular expressions, SQL queries,
or code generation templates, its LALR parser generator falls short,
however. Scannerless parsing with SGLR enables concise, modular
definition of such languages. In this paper, we present an
integration of SGLR into IMP, demonstrating that a scannerless parser
can be successfully integrated into an IDE. Given an SDF syntax
definition, the sdf2imp tool automatically generates an
editor plugin based on the IMP API, complete with syntax checking,
syntax highlighting, outline view, and code folding. Using
declarative domain-specific languages, these services can be
customized, and using the IMP metatooling framework it can be extended
with other features.
This is a presentation of the paper
L. C. L. Kats, K. T. Kalleberg, and E. Visser. Generating Editors for
Embedded Languages. Integrating SGLR into IMP. In A. Johnstone and J.
Vinju, editors, Language Descriptions, Tools, and Applications
(LDTA'08), Electronic Notes in Computer Science, Budapest, Hungary,
April 2008. Elsevier.
21-02-2008 : Modeling Enterprise Applications: Closing the gap between UML and the PIM
Speaker: Hendrik Jan van Randen (ATOS Origin)
Abstract
When applying MDA (as defined by the OMG) to develop an enterprise
application, the functionality of the target system is specified in a
PIM (Platform Independent Model). Much of this functionality can be
expressed using UML. However, UML lacks the power to formally express
certain aspects of the functionality, especially authorisations.
In this colloquium Hendrik Jan van Randen presents a methodology
(primarily consisting of a set of extensions to UML) to close this gap.
Atos Origin applies this methodology in real world customer projects,
and will participate in the OMG to enhance future versions of UML with
these language extensions and their semantics.
24-01-2008 : Procedural Content Development for Next Generation Games
Speaker: Igor Frid (Playlogic Game Factory)
Abstract
With ever increasing expectations of the quantity / quality of videogame
content the methodologies used within game development turn out to be
less scalable than we would have hoped for in this industry. Realizing
this a few years ago, Playlogic took the opportunity to start putting
substantial effort into solving the problem at hand. The result is a
unique method with accompanying custom software that allows us to
provide an answer to these expectations as well as an incentive for
others to follow.
Where alternative approaches, like Rapid Application Development, try to
acknowledge familiar patterns in domain specific as well as commodity
applications, we on the other hand provide a playground for our
developers and artists to build and reuse patterns themselves in
no-time. The fact that we are using this methodology with success is
best shown by the high-profile prospects we've acquired from large
enterprises based on the premise of our Rapid Prototyping software.
Our presentation will visualize the ubiquitous necessity for embracing
change in the way we all work, how our method and tooling is already
helping us and we'll elaborate on the specific details and issues we
encounter in our daily routine.
03-01-2008 : Disciplined Meta-Programming for Java
Speaker: Shan Shan Huang (University of Oregon)
Abstract
Many software engineering tasks can be automated by using
meta-programming. However, there is much to be desired in the static
safety guarantees provided by meta-programming mechanisms. In this
presentation, I will discuss two meta-programming tools, SafeGen and MJ.
Both can guarantee at the compile-time of a meta-program that the output
program will always be well-formed, given any input satisfying the
meta-program's stated assumptions. To provide such guarantees, both
SafeGen and MJ allow controlled reflection over the input programs and
restricted use of reflectively retrieved values for generation. Whereas
SafeGen is a stand-alone generator language that uses the power of a
theorem prover in providing its static guarantees, MJ is an extension of
Java, where a generic class can be thought of as a code template whose
output program can vary depending on the inputs to the template.
20-12-2007 : WebDSL (0712) Demonstration
Speaker: WebDSL Team
Abstract
WebDSL is a domain-specific language for development of web applications
with a rich data model. The language includes features for the
definition of data models, queries, page presentations, page flow, and
access control.
In this lecture we will demonstrate the progress made in WebDSL since
the last presentation in June. This will include (mini-) presentations
on the following topics:
- The webdsl.org developers application : Eelco Visser
- Core language extensions : Zef Hemel
- Declarative access control : Danny Groenewegen
- User interface : Jippe Holwerda
- Data migration : Sander Vermolen
- Eclipse editor plugin generation : Lennart Kats
- Deployment and release : Sander van der Burg
http://www.webdsl.org (the application is not yet online)
22-11-2007 : Model-Driven Software Evolution. Research Agenda Revisited
Speaker: Tom Mens (Mons, Belgie)
Abstract
In this talk, I will expand upon the report TUD-SERG-2007-006 on
"Model-Driven Software Evolution - A Research Agenda", and I will
provide an alternative list of important challenges in model-driven
software evolution.
As a second part of the talk, based on my own personal experience with
the formalism of graph transformation, I will explain how and why this
is an adequate formalism for supporting model evolution activities, and
how it compares to other approaches. This will be motivated by
explaining a number of concrete case studies (undertaken by various
researchers) in using graph transformation for model refactoring,
domain-specific modeling, and model inconsistency management.
http://staff.umh.ac.be/Mens.Tom/
1-11-2007 : Towards Intelligent Coding Assistance for Code Generation in Modeling Frameworks
Development environments for domain-specific language tools and
model-driven development are currently mostly focusing on supporting
the metamodelling and modelling aspects of model-driven
engineering. The actual code generators are usually implemented in
conventional template languages. Such template languages allow the
metaprogrammer to write code templates using the syntax of the
generated program, i.e. the syntax of the object language. The literal
code of the program to generate can typically be mixed with meta
constructs to generate code conditionally, iteratively, or based on
properties of the input model.
Unfortunately, the development environment nor the template engine
give feedback about syntactic or semantic errors in the code
templates. Hence, the only way to check if the code generator produces
programs that actually compile is to apply the code generator to an
input model. The disadvantage of this approach is that the
metaprogrammer does not get immediate feedback about the validity of
code generator when he is writing the code templates. During testing
the syntactic or semantic errors need to be traced back to the code
generator. Moreover, test models might not cover the entire code
generator or the possible input models, so errors might be reported
even after deployment of the code generator. Finally, there is no
support for various forms of code completion and assistance, which are
widely appreciated IDE features.
Despite code generators being a major aspect of model-driven
development, this makes the development of the actual code generator
feel rather unsupported. Basically, the metaprogrammer leaves the
shiny and supportive development environment for this important part
of a model-driven engineering project. In academic research, a range
of solutions have been proposed to make code generation tools
syntactically or semantically aware of the object language. This
awareness of the object language can be used to guarantee that the
generated programs are always syntactically correct, or in the case of
semantical awareness might even always compile. Also, this awareness
could be used to support coding assistance.
In this talk, I will first give a brief overview of the research in
this area. I will discuss the various levels of understanding of the
object program that have been researched. After this overview, I will
take a closer look at a method for adding syntactical awareness of an
object language to code generation tools. In particular, I will
discuss the parsing techniques required for parsing combinations of a
template language and possibly multiple object languages. These
parsing techniques are applied in several academic tools that can be
applied for code generation, e.g. the ASF+SDF MetaEnvironment,
Stratego/XT, StringBorg, and Repleo. Finally, I will discuss the
usability issues of the current academic tools that support
syntactical awareness and challenges to apply these ideas in
interactive development environments.
27-09-2007 : Hate & Fear in Model-Driven Software Evolution
Discussion chaired by Arie van Deursen
Abstract: We're at the start of a long term research project on model-driven software evolution, conducted jointly by industry and academia. Since many of us have earlier experience with program generation technology, we propose to have a look at the past, to see what we should do in the future.
Thus, the first question we'll discuss is what you loved and what you hated about the 4GLs from the past. After that we'll look at the future, and ask ourselves what we hope and what we fear about model-driven engineering.
The outcomes of the discussion will be used to guide the MoDSE research. Furthermore, it will make the MoDSE partners aware of the key problems in model-driven engineering, and the current best practices that may help to reduce the negative effects of these problems.
20-06-2007 : MoDSE workshop
14-06-2007 : Domain-Specific Language Engineering (Part II)
In the first part of this lecture I showed the design of a domain modeling language and an implementation in Stratego/XT generating a web application with basic CRUD pages on top of a standard framework stack for web applications (EJB3/Hibernate/JSF/Seam).
In the second part I will discuss the extension of my WebDSL with a language for defining presentations, including the following ingredients:
- A presentation language to define the structure of pages based on data from a domain model.
- A navigation model with parameterized page navigation.
- Action definitions to define the semantics of page actions (e.g., save, add element to association)
- A template mechanism to support reuse with models of web applications.
- Embedding of the object-oriented Hibernate Query Language (HQL) to state queries in terms of the domain model.
The resulting language allows very rapid definition of domain models and a user interface for viewing, editing, and linking domain models.
In the lecture I will discuss the process that led me to the design of the current language, sketching the growing of the language along the way. An important technique that combines both a large degree of flexibility to application programmers, and automatic generation of boilerplate code is that of desugaring, that is, model-to-model transformations that rewrite high-level model constructs to lower-level ones.
08-06-2007 Reuseware -- Generic Invasive Software Composition
Traditionally, most composition systems have been either black or white box. Black box composition systems allow no knowledge about the internal structure of components to be used in composing them. White box composition systems, on the other hand, allow complete knowledge about internal structures to be used and allow these structures to be manipulated in any manner when performing compositions. Invasive software composition is maintaining a middle ground in this area by following a grey-box approach to composition. Here, the structure of a component is exposed and made available for manipulation in a controlled manner. Components specify explicitly what parts of their structure should be exposed and the composition system uses this specification to construct a composition interface for the components.
The presentation gives an overview of Reuseware, a generic implementation of invasive software composition based on Eclipse. Reuseware allows invasive composition concepts to be integrated with any arbitrary language and generates parsing, editing, and composition tooling for these languages.
24-05-2007 : Domain-Specific Language Engineering (Part I)
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 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.
Because of the amount of material I have decided to split this tutorial
in two parts. The lectures will present a snapshot of work in progress
that was motivated by (1) an invited tutorial for the Summer School on
Generative and Transformational Techniques in Software Engineering
(GTTSE'07) and (2) an exploration of 'enterprise software' as the main
application domain of the MoDSE project.
The tutorial has two goals:
- a tutorial on techniques for DSL development using SDF and Stratego/XT
- reporting on an experiment in DSL development: can we approach DSL design with a systematic (and effective) method
A secondary goal, that emerged during discussions with partners and in
previous colloquia, is to explain how techniques from programming
language design and implementation can contribute to modeling. [While
this is obvious to me (people with a PL background), it does not seem
obvious to everone (in the modeling community).] I will try to weave
some meta considerations about this topic into the presentation,
although this probably requires a more thorough treatment.
26-04-2007 : Domain-Specific Languages in Perspective
Domain-specific languages (DSLs) are languages tailored to a specific application domain. They offer substantial gains in expressiveness and ease of use compared with general-purpose programming languages in their domain of application. While the use of DSLs is by no means new, it is receiving increased attention in the context of software technologies such as software product-line engineering, software factories, language-oriented programming, and generative programming. These approaches advocate the development and use of DSLs as essential to the construction of software system families. We discuss these trends from the perspective of the roles DSLs have traditionally played.
05-04-2007 : Towards the Generation of a Text-Based IDE from a Language Metamodel
In the model driven world languages are usually specified by a (meta) model of their abstract syntax. For textual languages this is different from the traditional approach, where the language is specified by a (E)BNF grammar. Support for the designer of textual languages, e.g. a parser generator, is therefore normally based on grammars. This paper shows that similar support for language design based on metamodels is not only possible, but is even more powerful than the support based on grammars. In this paper we describe how an integrated development environment for a language can be generated from the language’s abstract syntax metamodel, thus providing the language designer with the possibility to quickly, and with little effort, create not only a new language but also the tooling necessary for using this language.