Alexander Behring’s research while affiliated with Technical University of Darmstadt and other places

The Internet of Things (IoT) and the Internet of Services (IoS) are two well-known exemplars of the emerging 'Internet variants'. These variants will be tightly interwoven yet specific with respect to the supporting technologies needed. The present paper discusses the five variants identified as essential by the authors: IoT, IoS, Internet-of-Humans, Internet-of-Crowds, and Internet-of-Clouds. For each variant, a non-comprehensive set of research challenges is cited and related to the state of the art and to ongoing projects of the lab.

User Interface Development is increasingly facing the demand that an application must provide different User Interfaces (UIs) for different contexts of use, e.g., interaction device and primary task. This leads to two key challenges: how to create these multiple UIs for one application (creation challenge), and how to consistently modify them (modification challenge). The creation challenge has been addressed in various works utilizing automatic UI generation. We present a domain specific language (DSL) suitable to address the modification challenge. The DSL makes use of explicit relations between different UI versions, along which modications of the UIs can be propagated. With the presented approach, modifications can be applied more easily, which is important for iterative (UI) design.

Constraint programming holds many promises for model driven software development (MDSD). Up to now, constraints have only started to appear in MDSD modeling languages, but have not been properly reflected in model transformation. This paper introduces constraint programming in model transformation, shows how constraint programming integrates with QVT Relations - as a pathway to wide spread use of our approach - and describes the corresponding model transformation engine. In particular, the paper will illustrate the use of constraint programming for the specification of attribute values in target models, and provide a qualitative evaluation of the benefit drawn from constraints integrated with QVT Relations.

The recent success of various Apple products affirms that usability engineering can be a beneficial asset in software product development. But considerable problems exist in integrating usability engineering and software engineering. In this paper, we argue that the technical basis-the disciplines' artifacts and used tools-are a potential hurdle for integration. Model-driven development (MDD) is put forward to address these problems. The Mapache approach persued in our research specializes MDD for User Interface (UI) engineering. Four of its concepts are discussed in the light of integrating usability and software engineering.

An increasing demand for supporting users in diverse contexts of use, e.g., depending on interaction device and primary task, results in new challenges for User Interface (UI) development. Two key challenges are: how to create these multiple UIs for one application (creation challenge), and how to consistently modify them (modification challenge). The creation challenge has been addressed in various works utilizing automatic UI generation. We present our approach (Dialogue Refinement) and its tool-support to address the modification challenge by allowing one modification to be applied to multiple UIs at once.

Declarative modeling and model driven software engineering seem to be two fields of research with completely different focus. However, the term modeling is used by both communities and both communities claim to use declarative techniques. In this paper we give a small overview on some of the differences of both fields and present our model-to-model transformation language which brings together constraint solving, optimization, and model-to-model transformation. The language can be seen as an example how intuitively both communities can integrate to explore new applications.

Efficient usage of applications often requires context-aware applications. We assume that context-aware adaption can be useful in the case of crisis management tools as well, where fast responses are crucial and can be supported by information technology. A small user study performed with a crisis response team mostly composed of fireman supports our assumptions for the important case of role-aware messaging applications. We demonstrate our way to develop context-aware user interfaces using our model-to-model transformation language with constraint solving and apply it to the case of a crisis management system.

Developing applications comprising service composition is a complex task. Service composition requires the knowledge of various process languages (e.g. WS-BPEL, XPDL, or WSFL) or the knowledge of languages like WS-CDL which focus more on messaging aspects. To choose the right language for the problem at hand requires a lot of research as different aspects of various languages need to be considered. Therefore, to lower the skill barrier for developers it is important to describe the problem on an abstract level and not to focus on implementation details. This can be done using declarative programming which fosters to describe only the result of the problem (which is what the developer wants) rather than the description of the implementation. We therefore use purely declarative model-to-model transformations written in a universal model transformation language which is capable of handling even non-function properties using optimization and mathematical programming. This makes it easier to understand and describe service composition and non-fuctional properties for the developer.

Developers of transformation rules for user interface models should have the option to support usability in their transformations. As different aspects of usability highly depend on each other, transforma-tion rules should be able to model these dependencies. We provide an example how this can be done in a transformation language through a QVT Relations dialect.

We propose an approach how to develop and integrate usability metrics in (multimodal) dialog systems and user interfaces with Model Driven Software Development (MDSD). It enables the developer to start early with simple metrics and allows him to refine them during the ongoing work. Additionally, we show how the resulting metrics can be used to estimate the usability in advance, so that the developer may care about critical parts of the application before testing it.