Georg Hinkel

A Domain-Specific Language (DSL) for Integrating Neuronal Networks in Robot Control

Although robotics has made progress with respect to adaptability and interaction in natural environments, it cannot match the capabilities of biological systems. A promising approach to solve this problem is to create biologically plausible robot controllers that use detailed neuronal networks. However, this approach yields a large gap between the neuronal network and its connection to the robot on the one side and the technical implementation on the other. Existing approaches neglect bridging this gap between disciplines and their focus on different abstractions layers but manually hand-craft the simulations. This makes the tight technical integration cumbersome and error-prone impairing round-trip validation and academic advancements. Our approach maps the problem to model-driven engineering techniques and defines a domain-specific language (DSL) for integrating biologically plausible Neuronal Networks in robot control algorithms. It provides different levels of abstraction and sets an interface standard for integration. Our approach is implemented in the Neuro-Robotics Platform (NRP) of the Human Brain Project (HBP). Its practical applicability is validated in a minimalist experiment inspired by the Braitenberg vehicles based on the simulation of a four-wheeled Husky robot controlled by a neuronal network.

Change Propagation in an Internal Model Transformation Language

Despite good results, Model-Driven Engineering MDE has not been widely adopted in industry. According to studies by Staron and Mohaghegi [1, 2], the lack of tool support is one of the major reasons for this. Although MDE has existed for more than a decade now, tool support is still insufficient. An approach to overcome this limitation for model transformations, which are a key part of MDE, is the usage of internal languages that reuse tool support for existing host languages. On the other hand, these internal languages typically do not provide key features like change propagation or bidirectional transformation. In this paper, we present an approach to use a single internal model transformation language to create unidirectional and bidirectional model transformations with optional change propagation. In total, we currently provide 18 operation modes based on a single specification. At the same time, the language may reuse tool support for C#. We validate the applicability of our language using a synthetic example with a transformation from finite state machines to Petri nets where we achieved speedups of upi¾źto 48 compared to classical batch transformations.

Change propagation and bidirectionality in internal transformation DSLs

Despite good results in several industrial projects, model-driven engineering (MDE) has not been widely adopted in industry. Although MDE has existed for more than a decade now, the lack of tool support is still one of the major problems, according to studies by Staron and Mohaghegi (Staron, in: Model driven engineering languages and systems, Springer, Berlin, 2006; Mohagheghi et al. in Empir Softw Eng 18(1):89–116, 2013). Internal languages offer a solution to this problem for model transformations, which are a key part of MDE. Developers can use existing tools of host languages to create model transformations in a familiar environment. These internal languages, however, typically lack key features such as change propagation or bidirectional transformations. In our opinion, one reason is that existing formalisms for these properties are not well suited for textual languages. In this paper, we present a new formalism describing incremental, bidirectional model synchronizations using synchronization blocks. We prove the ability of this formalism to detect and repair inconsistencies and show its hippocraticness. We use this formalism to create a single internal model transformation language for unidirectional and bidirectional model transformations with optional change propagation. In total, we currently provide 18 operation modes based on a single specification. At the same time, the language may reuse tool support for C#. We validate the applicability of our language using a synthetic example with a transformation from finite state machines to Petri nets where we achieved speedups of up to multiple orders of magnitude compared to classical batch transformations.

An empirical study on the perception of metamodel quality

Despite the crucial importance of metamodeling for Model-Driven Engineering (MDE), there is still little discussion about the quality of metamodel design and its consequences in model-driven development processes. Presumably, the quality of metamodel design strongly affects the models and transformations that conform to these metamodels. However, so far surprisingly few work has been done to validate the characterization of metamodel quality. A proper characterization is essential to automate quality improvements for metamodels such as metamodel refactorings. In this paper, we present an empirical study to sharpen the understanding of the perception of metamodel quality. In the study, 24 participants created metamodels of two different domains and evaluated the metamodels in a peer review process according to an evaluation sheet. The results show that the perceived quality was mainly driven by the metamodels completeness, correctness and modularity while other quality attributes could be neglected.

Using internal domain-specific languages to inherit tool support and modularity for model transformations

Model-driven engineering (MDE) has proved to be a useful approach to cope with today’s ever-growing complexity in the development of software systems; nevertheless, it is not widely applied in industry. As suggested by multiple studies, tool support is a major factor for this lack of adoption. In particular, the development of model transformations lacks good tool support. Additionally, modularization techniques are inevitable for the development of larger model transformations to keep them maintainable. Existing tools for MDE, in particular model transformation approaches, are often developed by small teams and cannot keep up with advanced tool support for mainstream general-purpose programming languages, such as IntelliJ or Visual Studio. Internal DSLs are a promising solution to these problems. In this paper, we investigate the impact of design decisions of an internal DSL to the reuse of tool support and modularization concepts from the host language. We validate our findings in terms of understandability, applicability, tool support, and extensibility using three case studies from academia, a model-driven engineering platform, and the industrial automation domain where we apply an implementation of an internal model transformation language on the .NET platform. The results confirm the value of inherited modularity and tool support while conciseness and understandability are still competitive.

Experiences with Model-Driven Engineering in Neurorobotics

Model-driven engineering MDE has been successfully adopted in domains such as automation or embedded systems. However, in many other domains, MDE is rarely applied. In this paper, we describe our experiences of applying MDE techniques in the domain of neurorobotics --- a combination of neuroscience and robotics, studying the embodiment of autonomous neural systems. In particular, we participated in the development of the Neurorobotics Platform NRP --- an online platform for describing and running neurorobotic experiments by coupling brain and robot simulations. We explain why MDE was chosen and discuss conceptual and technical challenges, such as inconsistent understanding of models, focus of the development and platform-barriers.

An NMF solution for the Petri Nets to State Charts case study at the TTC 2013.

Software systems are getting more and more complex. Model-driven engineering (MDE) offers ways to handle such increased complexity by lifting development to a higher level of abstraction. A key part in MDE are transformations that transform any given model into another. These transformations are used to generate all kinds of software artifacts from models. However, there is little consensus about the transformation tools. Thus, the Transformation Tool Contest (TTC) 2013 aims to compare different transformation engines. This is achieved through three different cases that have to be tackled. One of these cases is the Petri Net to State Chart case. A solution has to transform a Petri Net to a State Chart and has to derive a hierarchical structure within the State Chart. This paper presents the solution for this case using NMF Transformations as transformation engine.

NMF: A Multi-platform Modeling Framework

For its promises in terms of increased productivity, Model-driven engineering (MDE) is getting applied increasingly often in both industry and academia. However, most tools currently available are based on the Eclipse Modeling Framework (EMF) and hence based on the Java platform whereas tool support for other platforms is limited. This leads to a language and tool adoption problem for developers of other platforms such as .NET. As a result, few projects on the .NET platform adopt MDE. In this paper, we present the .NET Modeling Framework (NMF), a tool set for model repositories, model-based incrementalization, model transformation, model synchronization and code generation that is now available for a multitude of different operating systems, including Windows, Linux, Android, iOS and Mac. The framework makes intensive use of the C# language as host language for model transformation and synchronization languages, whereas the model repository serialization is compatible with EMF. This solves the language adoption problem for C# programmers and creates a bridge to the EMF platform.

Refinements and Structural Decompositions in Generated Code.

Todays systems are often represented by abstract domain models to cope with an increased complexity. To both ensure suitable analyses and validity checks, it is desirable to model the system in multiple levels of abstraction simultaneously. Doing so, it is often desirable to model that one association is a refinement ofion simultaneously. Doing so, it is often desirable to model that one association is a refinement of another to avoid duplication of concepts. Existing approaches that support refinements request metamodelers to use new modeling paradigms or have less efficient model representations than commonly-used technologies such as EMF with Ecore. In this paper, we propose a non-invasive extension to support refinements and structural decompositions in Ecore-like meta-metamodels, show how these extension can be supported by code generation and show that the fulfillment of refinements can be guaranteed by the underlying type system.

Predicting the Perceived Modularity of MOF-based Metamodels.

As model-driven engineering (MDE) gets applied for the development of larger systems, the quality assurance of model-driven artifacts becomes more important. Here, metamodels are particularly important as many other artifacts depend on them. However, existing metrics have been rarely validated for metamodels or, even more, evaluation results disproved a correlation between these existing metrics and perceived metamodel modularity. In this paper, we present a new entropy-based metric to capture the perception of metamodel modularity and evaluate the metric in multiple case studies. In the case studies, we correlate the metric results of 32 metamodels across three different domains with 164 responses of a quality assessment questionnaire for which we collected responses in two empirical experiments. The results show significant and strong correlations in all three domains between the metric results and the perceived metamodel modularity.