Dennis Wagelaar | Vrije Universiteit Brussel (original) (raw)

Papers by Dennis Wagelaar

Software and Systems Modeling, Oct 15, 2009

As the application of model transformation becomes increasingly commonplace, the focus is shiftin... more As the application of model transformation becomes increasingly commonplace, the focus is shifting from model transformation languages to the model transformations themselves. The properties of model transformations, such as scalability, maintainability and reusability, have become important. Composition of model transformations allows for the creation of smaller, maintainable and reusable transformation definitions that together perform a larger transformation. This paper focuses on composition for two rule-based model transformation languages: the ATLAS Transformation Language (ATL) and the QVT Relations language. We propose a composition technique called module superimposition that allows for extending and overriding rules in transformation modules. We provide executable semantics as well as a concise and scalable implementation of module superimposition based on ATL.

There are two composition mechanisms in ATL that have evolved separately, and therefore are not w... more There are two composition mechanisms in ATL that have evolved separately, and therefore are not well-aligned. These are rule inheritance and module superimposition. Both of these composition mechanisms had different goals in mind: rule inheritance aims to increase reuse at the rule level, as well as optimise the performance of the matching process, while module superimposition aims to increase reuse at the module level, and allows for incremental compilation whenever a single module changes. To achieve these goals, rule inheritance was in-lined at compile-time, while superimposed modules were composed at load-time. As a result, rule inheritance is limited to single modules, while module superimposition rule overriding does not work well on rule inheritance hierarchies. This paper aims to reconcile the two composition mechanisms by defining both at load-time/run-time, while respecting the original goals. In addition, rule inheritance is extended from single to multiple inheritance.

This paper describes the ATL/EMFTVM solution of the TTC 2015 Train Benchmark Case. A complete sol... more This paper describes the ATL/EMFTVM solution of the TTC 2015 Train Benchmark Case. A complete solution for all tasks is provided, three of which are discussed with regard to the three provided evaluation criteria: Correctness and Completeness of Model Queries and Transformations, Applicability for Model Validation, and Performance on Large Models.

... as part of a ready-to-run solution ➔ Ready MDE solutions generally don't do exactly wh... more ... as part of a ready-to-run solution ➔ Ready MDE solutions generally don't do exactly what you need, which means: ... Metaclass transformation module Accessors2; ... ownedParameter <- Sequence{getPar}), getPar : UML2!"uml::Parameter" (name <- 'return', type <- s.type, ...

Ontologies have become increasingly relevant to the modelling community, providing a knowledgebas... more Ontologies have become increasingly relevant to the modelling community, providing a knowledgebase to support several software engineering activities. As such, several efforts have been made to integrate ontology technology with modelling technology. This has resulted in the Ontology Definition Metamodel (ODM), which allows model transformation languages to interact directly with ontologies. The ODM limits itself to data structure, however, and does not integrate the reasoning capabilities within ontologies. Therefore, we have done an experiment with an OWL DL driver for ATL, where ATL has direct access to the reasoning capabilities of the OWL DL ontology language. OWL DL is used as a metamodelling framework, where OWL classes serve as metaclasses and OWL individuals serve as model elements. The envisioned benefits are optimisation possibilities through automatic classification, and static analysis of ATL transformations written using OWL DL expressions. This paper will discuss our findings so far regarding these two envisioned benefits.

Aspect-oriented programming (AOP) has received considerable interest, in particular as an extensi... more Aspect-oriented programming (AOP) has received considerable interest, in particular as an extension of object-oriented programming. However, current object-oriented software design techniques, such as UML, are not well suited to cope with aspect orientation. In this paper we discuss a design approach, called CoCompose, which supports aspect orientation and software evolution. The CoCompose design language adopts a generic concept construct for describing software systems. Design-level relationships between concepts can be expressed by applying the parameterised feature construct. Complete CoCompose models can be translated into executable programs using an automatic translation process.

European Journal of Information Systems, Aug 1, 2007

The Model-Driven Architecture enables the deployment of software applications on different platfo... more The Model-Driven Architecture enables the deployment of software applications on different platforms. It is based on a pattern in which a platform-independent model is transformed into a platform-specific model, given a platform model. Currently the model transformations used for this task implicitly assume this platform model, which makes it unclear whether a model transformation can be used for other platforms than the one assumed. In order to target very specific platforms and platform variants, model transformations must be reusable beyond their assumed platform. We propose an explicit platform model that can be used to reason about platform dependencies of model transformations and their applicability to specific platforms. In addition, we show how platform models can be integrated in a model-driven configuration management framework.

Science of Computer Programming, Jun 1, 2014

h i g h l i g h t s • Many state-of-the-art graph rewriting and model transformation tools compet... more h i g h l i g h t s • Many state-of-the-art graph rewriting and model transformation tools competed at the Transformation Tool Contest 2011. • We give the most encompassing survey of transformation tools so far, based on an illustrative Hello World case. • We compare the tools and their languages in detail, based on an elaborate taxonomy. • Researchers gain an overview of the field, prospective users get help in choosing in between the tools. • All tools can be tested online with a SHARE virtual machine.

Lecture Notes in Computer Science, 2005

An important drive for Model-Driven Architecture is that many software applications have to be de... more An important drive for Model-Driven Architecture is that many software applications have to be deployed on a variety of platforms and within a variety of contexts in general. Using software models, e.g. described in the Unified Modeling Language (UML), one can abstract from specific platforms. A software model can then be transformed to a refined model, given the context in which it should run. Currently, each target context requires its own model transformation. Only a limited number of contexts can be supported in this way. We propose a context-driven modelling framework that models each target context in a context model, described in the Web Ontology Language (OWL). Multiple reusable transformation rules are used, which are annotated with context constraints, based on the OWL context model. The framework can automatically select the transformation rules that are applicable for a concrete context.

Electronic Notes in Theoretical Computer Science, 2005

In this paper, we claim that a specialized aspect module is not required. Instead, we propose an ... more In this paper, we claim that a specialized aspect module is not required. Instead, we propose an expressive aspect-oriented composition mechanism which can be applied upon existing modules. At the design level, the CoCompose modeling framework is introduced which is based on Model Driven Development. CoCompose allows step-wise refinement from a high-level design to the lowest level design or code level. Using these refinements, CoCompose postpones the decision concerning the modularization construct that is chosen for a particular concern. At the lowest level design however, a specialized aspect modularization construct still needs to be chosen because current aspect-oriented technologies typically introduce an aspect module. For resolving this issue, the FuseJ programming language is proposed that allows implementing all possible concerns as regular components. FuseJ introduces an expressive component composition mechanism that supports both regular and aspect-oriented compositions between components. As such, a seamless transition from design to implementation is achieved because no specialized aspect modules exist both at the design and implementation level.

Portable and embedded devices form an increasingly large group of computers. This new variety in ... more Portable and embedded devices form an increasingly large group of computers. This new variety in computing platforms will cause a corresponding diversity in software/hardware platforms and other context factors. Component-based middleware platforms offer a uniform environment for software, but they do not take away specific context differences, such as hardware resources, user identity/role and logical/physical location. Specialised component versions and/or configurations have to be made for each computing context if that computing context is to be used to its full extent. This is because the fine differences between component versions cannot be separated into finer components with the current component models. Aspect-oriented programming and generative programming technologies can be used to provide the fine-grained modularity that is necessary. In addition, the diversity of component-based platforms themselves form an extra reason for different component versions. We propose using a context-driven framework for the development of AmI components, which is based upon a gradual refinement mechanism. This refinement mechanism can cope with the course-grained differences between component models as well as the fine-grained differences between computing configurations.

Lecture Notes in Computer Science, 2006

MDA generally involves applying multiple model transformations. These transformations need to be ... more MDA generally involves applying multiple model transformations. These transformations need to be applied in a particular configuration, depending on the targeted platform. Several techniques exist to manage the configuration of various software elements or components. These techniques focus on the composition rules of the various elements. A well-known application area of such techniques are Software Product Lines, in which the various features that make up a software product need to be configured. In this paper, we will investigate how several of these techniques can be applied to manage the configuration of model transformations in an MDA context.

Springer eBooks, 2005

The main drive for Model-Driven Architecture is that many software applications have to be deploy... more The main drive for Model-Driven Architecture is that many software applications have to be deployed on a variety of platforms. The way MDA achieves this is by transforming a platform-independent model of the software to a platform-specific model, given a platform model. In current MDA approaches, the model transformations implicitly represent this platform model. Therefore, the number of different target platforms is limited to the number of supported model transformations. We propose a separate platform model, based on description logics, that can can be used to automatically select and configure a number of reusable model transformations for a concrete platform. This platform model can be extended to describe the relevant platform information, including concrete platform instances as well as platform constraints for each model transformation. This separates the model transformation concern from the platform concern and, since the model transformations are no longer limited to targeting one platform, more platforms can be supported with the same set of transformations.

Springer eBooks, 2011

As model transformations have become an integral part of the automated software engineering lifec... more As model transformations have become an integral part of the automated software engineering lifecycle, reuse, modularisation, and composition of model transformations becomes important. One way to compose model transformations is to compose modules of transformation rules, and execute the composition as one transformation (internal composition). This kind of composition can provide fine-grained semantics, as it is part of the transformation language. This paper aims to generalise two internal composition mechanisms for rule-based transformation languages, module import and rule inheritance, by providing executable semantics for the composition mechanisms within a virtual machine. The generality of the virtual machine is demonstrated for different rule-based transformation languages by compiling those languages to, and executing them on this virtual machine. We will discuss how ATL and graph transformations can be mapped to modules and rules inside the virtual machine.

Finds and Results from the Swedish Cyprus Expedition: A Gender Perspective at the Medelhavsmuseet, Jul 1, 2008

contains references to elements that match against the "Package" rule "s" translates to "t" → ref... more contains references to elements that match against the "Package" rule "s" translates to "t" → references to "s" translate to references to "t" (Implicit Tracing)

Finds and Results from the Swedish Cyprus Expedition: A Gender Perspective at the Medelhavsmuseet, Nov 3, 2003

The initial design of software systems is modelled using conceptual design language elements. Whe... more The initial design of software systems is modelled using conceptual design language elements. When a refined version of the design is made, each of the original (conceptual) elements is replaced by the refined element(s). Other feasible refinements are eliminated prematurely. This paper presents a software design approach, called CoCompose, that allows for defining several, layered, alternative refinements for each element in a design. The refinements are represented as structures of existing design language constructs, which makes it possible to address advanced software development technologies such as aspect-oriented programming, component-based development and design patterns without introducing new design language constructs. CoCompose uses an automated translation process to determine which refinements to use and to generate an implementation.

Finds and Results from the Swedish Cyprus Expedition: A Gender Perspective at the Medelhavsmuseet, Mar 17, 2003

Current aspect-oriented languages express aspects in many different ways. This diversity contribu... more Current aspect-oriented languages express aspects in many different ways. This diversity contributes to several problems when trying to model aspects in an early stage of the software lifecycle. This paper discusses a software modelling approach, called CoCompose, which supports aspect-oriented mechanisms without committing to one specific mechanism. A model made with CoCompose can be translated into several implementation languages using an automated process.

HAL (Le Centre pour la Communication Scientifique Directe), Jul 1, 2019

In order to optimize the TT2BDD transformation, we used the EMFTVM built-in profiler. This lead u... more In order to optimize the TT2BDD transformation, we used the EMFTVM built-in profiler. This lead us to the three following optimizations: • Leveraging helper attributes caching. ATL provides two kinds of helpers: helper operations, and helper attributes. Helper attributes are basically similar to parameterless helper operations with a significant performance-related difference: their result is cached. Therefore, multiple accesses do not result in multiple computations. The getTree helper operation was thus changed into a tree helper attribute. With a lower performance impact, the getNode helper operation was also changed into a node helper attribute. • Applying the object indexing pattern 5. This pattern uses a Map in order to avoid expensive lookups that can be precomputed. A typical example is the navigation of missing opposite references.

Springer eBooks, 2012

Model-to-model transformations are often employed to establish translational semantics of Domain-... more Model-to-model transformations are often employed to establish translational semantics of Domain-Specific Languages (DSLs) by mapping high-level models into more concrete ones. Such semantics are also executable when there exists a target platform able to execute the target models. Conceiving a transformation that targets a low-level language still remains arduous due to the large semantic gap between the DSL and the corresponding target language. In this respect, depending on the domain of the DSL, this task can be made easier by reusing an existing platform and bytecode language for that domain, as for instance the EMF Transformation Virtual Machine (EMFTVM) for the domain of model transformation. This paper defines executable semantics for EMFMigrate, a model transformation language specifically designed for managing the coupled evolution in model-driven development. To this end, the approach considers EMFTVM as the runtime engine targeted by the proposed semantic mappings.