Skip to topic | Skip to bottom


MoDSE.Colloquiumr1.10 - 03 Jul 2009 - 09:23 - EelcoVisser

Start of topic | Skip to actions

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


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


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


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


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.


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.

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


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


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


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


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:

- - -

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


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


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)


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


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


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.


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


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


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.


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.


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


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)


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


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)


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)


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)


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


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 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 (the application is not yet online)

22-11-2007 : Model-Driven Software Evolution. Research Agenda Revisited

Speaker: Tom Mens (Mons, Belgie)


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.

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.

Edit | Attach | Printable | Raw | More topic actions
Revisions: | r1.10 | > | r1.9 | > | r1.8 | Page history | Backlinks
You are here: MoDSE > Colloquium

to top

Copyright © 2003-2018, Software Engineering Research Group, Delft University of Technology, The Netherlands