Humboldt-Universität zu Berlin - Faculty of Mathematics and Natural Sciences - Model Driven Software Development


Model Driven Software Development


Available topics


  • An Efficient Graph Matcher for the Henshin Model and Graph Transformation Framework
    Henshin is a model transformation framework which is based on graph transformation concepts implemented on top of the Eclipse modeling framework. The computationally most expensive part supported by the Henshin transformation engine is to find all occurrences of the left-hand side graph of a transformation rule in a larger host graph. The problem to be solved is a variant of the well-known subgraph isomorphism problem, namely to find all subgraphs of the host graph which are isomorphic to the left-hand side graph. The current implementation translates the problem to a constraint satisfaction problem amenable to an off-the-shelf constraint solver. While this approach is generic and works reasonably well for small to medium sized graphs, it suffers from performance and scalability problems for larger host and/or rule graphs. The goal of this thesis is to implement a simple pattern matching algorithm and to try out heuristic methods similar to those for the special case of triangle listing [Ortmann & Brandes 2014] for speeding up the search. Furthermore, experiments on finding partial patterns will be made to determine whether a suitable ordering of the pattern search leads to a speed up. The thesis will be co-supervised by Prof. Kratsch.
  • Development of a Framework for Example-based Specification of Complex Editing Operations
    Complex editing operations like refactoring operations are an important configuration parameter for many tools which support the evolution of models in the context of Model-Based Software Engineering (MBSE). This often requires declarative, rule-based specifications of editing operations, which can be expressed using dedicated model transformation languages. A precise specification is not easy for domain experts to create for various reasons, e.g. model transformations working on the abstract syntax of models often differ significantly from the concrete syntax. “Model transformation by example” presents a promising approach to overcome these obstacles. Domain experts demonstrate the transformation using examples of their familiar modeling environment. The transformation specification is then derived automatically from those examples. Yet, the specification is only as good as the examples provided. The objective of this thesis is to create a framework which allows including modelers in the process of example-driven transformation specification by means of a feedback loop. The basic idea is to integrate editing operations inferred from examples into standard editors to use them on other models. Corresponding results should be evaluated by the modeler in order to create new examples for the incremental refinement of the transformation rules.
  • Methodical Examination of Variability in the Generation of Editing Operations for Models in Model-Based Software Engineering
    Editing operations on models are an important configuration parameter for many variable tools which assist model evolution in the field of Model-Based Software Engineering (MBSE). Research literature agrees that the set of available editing operations must be adapted to the model type; editing operations which are suitable for UML class diagrams are different from those for Matlab/Simulink models, for example. There is also consensus that available editing operations can be roughly classified into complex and elementary operations. This work will concentrate on elementary editing operations. Different variation points in the specification of editing operations actually already exist, but have not been systematically examined so far. Subject of this work is a systematical analysis to create a formal documentation of a variability model. The results should also be used for the configuration of an already existing generation tool for editing operations.
  • Comparison of Object-oriented Data Models via Methods of Ontology Matching
    In all phases of model-based software development projects, tools for the comparison of models are needed for various purposes. Common methods for model comparison mostly assume a set of model characteristics which significantly facilitate the identification of corresponding model elements, for example the availability of unique identifiers for model elements or the stability of names of evolving models. These favorable conditions are not meet in early project phases, because models are often created independently at this stage, for example to represent the different views of various stakeholders. Additionally, a project-wide uniform terminology for business/domain-specific entities does usually not exist yet. This work aims to investigate how far methods of ontology matching, i.e. methods to determine corresponding concepts within ontologies, are suitable for this purpose. It will focus on object-oriented analysis data models, because their description/modeling languages, e.g. class diagrams of UML, are highly similar to ontology description languages.
  • Graph Grammar-Based Fuzzing for Testing Model-Based Software Engineering Tools
    Fuzzing is an established technique for testing programs that take structured inputs; desktop publishing tools, web browsers etc. being typical examples of this. The basic idea is to systematically generate input documents causing unexpected program behaviors, typically program crashes. Grammar-based fuzzing has been studied in the context of textual documents whose structure may be described using traditional context-free grammars. That is, documents used as test inputs are generated with the help of the production rules specified by the grammar. This thesis shall investigate how this idea can be transferred from context-free grammars to graph grammars, which provide a constructive means for specifying the abstract syntax of visual models in model-based software engineering. The ultimate goal is to come up with an effective yet generic technique for fuzz testing model-based software engineering tools.