Engineering software for modern systems of systems demands integrating
solutions from multiple domains. The successful deployment of complex robotics
applications, autonomous vehicles, or the smart cyber-pysical production
systems of Industry 4.0 is impossible without integrating the modules provided
by participating domain experts. As each domain features their own specific and
optimized methods, tools, and languages, their successful integration is a
crucial prerequisite for engineering the stable software of the future.

Model-driven engineering reduces the conceptual gap between the problem
domains (such as navigation, grasping, or business process description) domains
and the solution domains (programming) of discourse. Modeling languages enables
domain experts to describe solutions without facing the
accidental complexities and idiosyncracies of programming languages.
For instance, employing an optimized modeling language to describe robotic
assembly tasks such as LightRocks
liberates the assembly expert from handling pointers, exceptions, or networking
otherwise encountered when programming the tasks using general-purpose
programming languages (such as C++ or Java) instead. Smart model transformations
and code generators embody such programming expertise and can ensure that
translation of domain-specific models conforms to state-of-the-art software
engineering practices.

Research Question #1: How can we enable the efficient development, evolution, and
maintenance of domain-specific modeling languages and related software tools?

With the complexity of modern systems demanding for participation of experts
different domains, this entails integrating models of the respective languages.
As the integration of two languages might be domain-specific as well, e.g.,
which parts of the languages are integrated (syntax, semantics, tools), how
integration is performed (extension, merging, aggregation), and when it is
performed (at language design time, at language instantiation, or at model run
time), various patterns for specific technological language engineering tools
have emerged, yet a common theory is missing.

Research Question #2: What are the theoretical foundations of modeling
language integration and how can we exploit these to enable language
components that support off-the-shelf reuse?

Having such a theory in place requires understanding how to decompose the
tooling associated to modeling languages, such as editors, analyses,
transformations, or code generators. Modularzing such model processing unleashes
the flexibility of component-based language engineering in which domain experts
can easily (re)combine modeling language parts to achieve the most suitable
languages for the problems at hand without having to adjust their tooling
manually.

Research Question #3: How can we modularize language processing tooling
along the language integration degrees of freedom to easily reusing
the same tooling with different language combinations?

Component-based software engineering (CBSE) has proven useful to enable a separation
of concerns between experts from different domains by encapsulating their
contributions behind stable, well-defined interfaces. As CBSE is subject
to the conceptual gap also, architecture description languages have
emerged that list component models to the primary reusable artifacts. We found
that encapsulating the models provided by different experts in components
enables a model reuse comparable to CBSE.

Therefore, we employ the MontiArcAutomaton
component & connector architecture description language as research vehicle
for language integration. Based on architecture models composed from components
containing behavior models of different languages, we translate these models
into executable systems using template-based code generators. Hence, we also
investigate architecture description languages.

Research Question #4: How can we leverage architecture description languages
to facilitate the separation of concerns required for efficient language
integration and reuse?

With the rise of automated driving, autonomous drones, self-adaptive automation systems,
and smart cities, robots are everywhere nowadays. Many challenges the younger
field face have been research similiary in robotics and consequently the fields
are growing closer. We consider robotics,
in the sense of fully automated systems operating in dynamic and unstructured
environments one of the most interesting challenges to software engineering.
Hence, applying our methods, tools, and languages to robotics allows us to
produce interesting demonstration and evaluation scenarios, such as with the
project classes of winter term 2012/13,
winter term 2013/14,
summer term 2014

Research Question #5: How can we transfer our research contributions to robotics?

In consequence, we applied our research results in various projects, such as

the iserveU
project, where we, together with Bosch and others, employed a pervasive model-driven engineering process to
deploy a service robot to a German hospital,

the RedCarpet
project, in which we investigated employing big data and simulation techniques
to improve machine learning for automated driving, or

the CrESt project, in which we collaborate
with Siemens, Bosch and others to investigate future software engineering techniques
for collaborative autonomous systems that operate in open and dynamic contexts.

Our research activities and their results influence the courses we offer.
In the past, research in model-driven engineering, software language engineering,
and their application to robotics manifested in project classes and seminars:

Videos of the project classes' results and more are available on my
youtube channel.

Accordingly, our research also influences the bachelor theses and master theses we offer.
Currently, we have the following interesting theses
in the intersections of model-driven engineering, software language
engineering, and robotics for you:

My Erdös Number is five: I coauthored with Gerhard Lakemeyer, who coauthored with Joseph Y. Halpern, who coauthored with Ashok K. Chandra, who coauthored with Shmuel Zaks, who coauthored with Paul Erdös.