Pieter Van Gorp

Safety checklist is a type of cognitive tool enforcing short term memory of medical workers with the purpose of reducing medical errors caused by overlook and ignorance. To facilitate the daily use of safety checklists, computerized systems embedded in the clinical workflow and adapted to patient-context are increasingly developed. However, the current hard-coded approach of implementing checklists in these systems increase the cognitive efforts of clinical experts and coding efforts for informaticists. This is due to the lack of a formal representation format that is both understandable by clinical experts and executable by computer programs. We developed a dynamic checklist meta-model with a three-step approach. Dynamic checklist modeling requirements were extracted by performing a domain analysis. Then, existing modeling approaches and tools were investigated with the purpose of reusing these languages. Finally, the meta-model was developed by eliciting domain concepts and their ...

Graph transformation provides an intuitive mechanism for capturing model transformations. In the current paper, we investigate and compare various graph transformation tools using a compact practical model transformation case study carried out as part of the AGTIVE 2007 Tool Contest [22]. The aim of this case study is to generate formal CSP processes from high-level UML activity diagrams, which enables to carry out mathematical analysis of the system under design.

This event is the second instance of the contest for graph transformation-based tools, which was first held as part of the AGTIVE workshop. The aim is to stimulate tool development by providing a sense of competitiveness, as well as the chance to get to know and learn from the features of other, related tools.

This report summarises the results of the discussions of a working group on model transformation of the Dagstuhl Seminar on Lan- guage Engineering for Model-Driven Software Development. The main contribution is a taxonomy of model transformation. This taxonomy can be used to help developers in deciding which model transformation ap- proach is best suited to deal with a particular problem.

Increasingly more developers are applying refactorings - program transformations that can improve the design of existing source code - to make their software more easily adaptable to new requirements. Because small changes to object-oriented software (such as renaming a class) can require a lot of up- dates to several source files, tools that automatically update the affected files can save

Model-driven engineering is a software development method to model applications at a high level of abstraction and introduce platform specific details automatically using model transformations. Similarly, models specified in human-readable languages can be mapped automatically onto languages that support the analysis of formal properties. In an industrial context, the transformations that automate such mappings should be able to consume input models from various commercial tools. Unfortunately, such tools tend to store models in slightly different ways, not fully compliant to standards. Additional techniques are necessary to develop transformations in a platform independent manner instead of specific ones for each modeling tool. This paper illustrates such techniques on an example related to the transformation of visual process models (UML activity diagrams) into low-level algebraic (CSP) programs that support formal verification. In turn, the platform independent and human-readable transformation model is translated into code that can transform UML inputs even when these are non-standard.

For about two decades, researchers have been constructing tools for applying graph transformations on large model transformation case studies. Instead of incrementally extending a common core, these competitive tool builders have repeatedly reconstructed mechanisms that were already supported by other tools. Not only has this been counter-productive, it has also prevented the definition of new language constructs independently of a specific transformation tool. Moreover, it has complicated the comparison of transformation languages. This paper describes a light-weight solution to this integration problem. The approach is based on executable transformation modeling using a small UML profile and on higher order transformations. It enables the integration of graph transformation tools such as Fujaba, VMTS and GReAT. The paper illustrates the approach by discussing the contribution of a Copy operator to any of these tools. Other language constructs can be realized similarly, without locking into specific tools.

This special section is the outcome of the graph transformation tool contest organised during the Graph-Based Tools (GraBaTs) 2008 workshop, which took place as a satellite event of the International Conference on Graph Transformation (ICGT) 2008. The contest involved two parts: three “off-line case studies” which were published before the contest, and to which solutions were submitted and reviewed; and a “live contest” for which the case description was only handed out during the event, and to which solutions had to be constructed during a single afternoon session. Here we briefly sketch the off-line cases, and the setup and topic of the live contest in somewhat more detail. We also evaluate the results of the workshop, and give some recommendations for future editions. Finally, we introduce the research papers appearing in this special section.

The “model-driven development of model transformations” requires both a technique to model model transformations as well as a means to transform transformation models. Therefore, the thesis underlying this paper evaluates and extends state-of-the-art model transformation approaches. For example, the thesis contributes a new language construct for modeling subgraph-copy operations. Perhaps surprisingly, this thesis intentionally does not propose a fundamentally new transformation language and toolset. Instead, the thesis is based on a small UML profile for controlled graph transformation. The profile only relies on class diagrams, activity diagrams, and the UML’s extension mechanism. The proposed techniques have emerged from several case studies that involve model evolution, model refinement, as well as model synchronization.

With the increased interest in refactoring, UML tool vendors seek ways to support software developers in applying a (sequence of) refactoring(s). The problem with such tools is that the UML metamodel – on which their repository is based – is inadequate to maintain the consistency between the model and the code while one of them gets refactored. Therefore, we propose a set of minimal extensions to the UML metamodel, which is sufficient to reason about refactoring for all common OO languages. For instance, by specifying pre- and postconditions in OCL, we are able to compose primitive refactorings, verify preservation of program behavior, and trigger refactorings based on code smells. This way, we provide future MDA tools with the ability to improve existing UML designs, yet keeping them in synch with the underlying code base.