Software is the driving force behind the ongoing digital innovation in many different areas in society. Consequently, the process of software development must ensure the creation of software that satisfies user needs while meeting cost and time constraints.

We, at the Institute of Software Engineering and Programming Languages, conduct research at the highest international level in many areas of software engineering and programming languages. Particularly, our main expertise is in the areas of domain-specific languages, software configuration, declarative programming languages.

Our research spans from basic research, funded by the German Science Foundation (DFG), over applied research, funded by various funding agencies on a national and European level, to industry research, directly funded by our network of industrial partners.

Particularly, we are internationally leading experts in the following areas:

Domain-Specific Languages

Domain Specific Languages (DSLs) are languages that are specifically designed for usage by domain experts. Compared to general purpose languages, they increase productivity for the specific purpose and the quality of the resulting programs. They do this by embedding key domain abstractions into the language and the corresponding tools. Furthermore, they can be designed specifically for non-computer scientists. Application areas of domain specific languages range from controlled natural language requirement boilerplates over languages for big data analytics and AI to languages simplifying the use of formal methods.

The Institute of Software Engineering and Programming Languages is one of the few research groups in Europe which covers the whole development pipeline of domain specific languages starting with the empirical identification of needs by domain experts, the design of the language itself (syntax and semantics) and corresponding state-of-the-art tools (e.g., textual and graphical editors, analysis tools, debuggers), as well as an empirical evaluation with domain experts.

We have developed domain specific languages in various areas and domains. In basic science projects, we co-develop the graph transformation language Henshin which enables the declarative specification of complex graph patterns and changes. Our specific research focus lies on the performance of the execution of those specifications including an execution on high-performance clusters. In applied research, we developed a domain-specific language and innovative tooling for the interactive roadmapping of innovative systems. Our special interest here is to provide a high user experience and innovative collaboration features. In direct industry research, we developed and introduced a natural language-based domain-specific language for defining automotive system tests. Our focus here has been on ensuring an easy introduction into daily usage in industrial practice.

Related Research Projects

Tools to accelerate innovation along the automotive value chain

Self-organizing resilient execution platform for IoT services

Model TransformatIon PerformanCe Engineering

Software Configuration

Today, new innovations typically happen in software. Instead of writing software from scratch, software is typically built by reusing existing software. Reuse is the major driving factor in software product lines, in which new software variants can be generated for selection of features, also known as configuration. While product lines are a powerful tool for the efficient development, the analysis of the configuration space has become a major challenge for many software engineering tasks, such as quality assurance of safety and security properties. With FeatureIDE, we develop and maintain the most-used open-source tool for feature modeling. While it was originally designed as an integrated development environment for the implementation of software product lines to be used in teaching, it is nowadays used by researchers and practitioners world-wide. In particular, it is not only used for software configuration but also to model configuration spaces of hardware, goods, or even financial products.

The power of FeatureIDE lies in its reasoning capabilities which are built using classical artificial intelligence. Many algorithms reduce analysis problems to satisfiability problems, which can efficiently be solved by means of satisfiability (SAT) solvers. While this is state-of-the-art for more than two decades, we help to transfer research results into industrial practice. We are one of the leading research groups applying knowledge compilation techniques (e.g., #SAT solvers) to huge configuration spaces. In the future, our research may facilitate counting the number of Linux configurations or to scale analyses that are infeasible right now. We also employ product-line technology to clone-and-own, a very common practice to copy and adapt software instead of actual reuse. In the project VariantSync funded by the German Research Foundation (DFG), we aim to automate development tasks, such as fixing merge conflicts, a task that is manually performed by developers and a major obstacle in their daily business.

Related Research Projects

Eclipse Plugin for Feature Oriented Software Development

Automating the Synchronization of Software Variants

Declarative und Functional Programming Languages

Our research is concerned with the development, analysis and application of declarative programming languages in the field of Computational Logic and Artificial Intelligence.

Constraint Programming can model and specify problems with uncertain, incomplete information and to solve combinatorial problems, as they are abundant in industry and commerce, such as scheduling, planning, transportation, resource allocation, layout, design, and analysis. Constraint-based programming languages enjoy elegant theoretical properties, conceptual simplicity, and practical success. The idea of constraint-based programming is to solve problems by simply stating constraints (conditions, properties) which must be satisfied by a solution of the problem. Constraints can be considered as pieces of partial information. Constraints describe properties of unknown objects and relationships between them.

Constraint Handling Rules (CHR) is a concurrent committed-choice constraint logic programming language consisting of guarded rules that transform multi-sets of constraints until exhaustion. CHR can embed many rule-based formalisms and systems. It can describe algorithms in a compact declarative way without compromising efficiency. The clean logical semantics of CHR facilitates non-trivial program analysis and transformation. About a dozen implementations of CHR exist in Prolog, Haskell, Java, Javascript and C. CHR is used in academia and industry worldwide. Applications range from stock broking to injection mold design.

Functional Programming
The functional programming paradigm has experienced an upswing in recent years. The higher abstraction allows for a significant improvement of the clarity of code which is one reason for the integration of functional aspects of almost all modern languages. Another reason is the eliminiation of side-effects that makes languages like Haskell very suitable for concurrent programming and AI. Our research focuses on the learnability of this paradigm by developing tools that visualize the data and control flow of functional languages.

Related Research Projects

Software Evolution

In the last century, software was delivered with hardware or storage media. Due to the world wide web and the ongoing trend to connect all devices with the internet of things, the importance of continuous software updates has grown. Software updates are fast and cheap, but also necessary to cope with safety and security flaws. Large development teams and fast release cycles force developers to work in parallel by means of version control systems. Independent of whether software is released quarterly, monthly or with continuous deployment, software is altered in numerous small steps (i.e., commits). Our expertise on software evolution ranges from static program analysis and diffing techniques to program and model transformations. We evaluate new research methods by mining software repositories for patterns that occur when source code or models evolve.

While evolution often deals with functional behavior of software, the impact on the quality (e.g., safety, security, maintenance), is equally important. We specifically work on automatically synchronizing patches between the system architecture and quality evaluation models. For example, our project Ensure funded by the German Research Foundation (DFG)  addresses synchronizing architectural models and fault tree models used in the evaluation of safety requirements. In the project VariantSync, we aim to support developers in storing their knowledge together with their changes. While developers are typically aware of the feature or feature combination they are working right now, the knowledge disappears over time and typically not available to other developers. The project also funded by the German Research Foundation (DFG) tries to automatically record feature traces and uses that knowledge to automatically synchronize patches among other branches.

Related Research Projects

Automating the Synchronization of Software Variants

ENsurance of Software evolUtion by Run-time cErtification

Developer Experience

The development of modern software systems requires the integration of many different languages and tools. Besides textual source code, software and system engineers often deal with textual and graphical models to handle the ever-increasing complexity. Besides the pure functionality, the usability and the interoperability of these tools play an important role regarding the developers’ productivity and efficiency.

We provide knowledge and experience in several aspects of supporting and enhancing the developer experience (derived from user experience). Our expertise ranges from the empirical identification of problems in existing tools, to the development of improved (textual and graphical) editors including innovative editing and collaboration concepts, to interactive development approaches for autonomous systems.

We currently develop a framework for relaxed conformance editing enabling a more productive graphical modeling experience and invent concepts for synchronous and asynchronous collaborative graphical modeling. We also develop and integrate innovative concepts into textual editors which enable completely new user interactions like live evaluation of source code inside code editors as well as propagating changes injected into the simulation of an autonomous system back to the corresponding source code. We develop an augmented reality application that allows developers of autonomous systems to have a deeper insight into the goals and decisions to achieve self-explainable software.

Related Research Projects

Tools to accelerate innovation along the automotive value chain

The lab offers a tangible approach to various SE & robotics problems.

Quality Assurance

Software is increasingly used in safety-critical and security-critical applications. Quality assurance aims to improve or even guarantee the quality of software including its functional and non-functional properties. In our research, we cover a large range of constructive and analytical methods for quality assurance. These methods span over the whole development cycle from requirements engineering to software testing and program verification, whereas we strive to establish formal methods whenever feasible.

We maintain CoreASM, a tool for writing, executing and exploring formal specifications in the abstract state machine (ASM) formalism. CoreASM can be easily extended via plugins, while maintaining its precise semantics. While ASMs can be used for the stepwise refinement of requirements into executable code, we also contribute techniques devoted to specific phases of the development cycle. For manual system testing of automotive systems, we designed a semi-formal test case editor complemented by review checklists increasing the quality of test cases. For combinatorial testing, we provide algorithms (e.g., IncLing and YASA) establishing t-wise coverage and tool support within FeatureIDE. For program verification, we proposed a feature-oriented extension of the Java Modeling Language (JML) that can be efficiently verified using the theorem prover KeY or the model checker JavaPathfinder. With CorC, we contribute to a tool applying the correct-by-construction paradigm to various safety and security properties. The DFG-funded project SafeSec develops a modeling and analysis approach for the interplay of safety and security properties specifically for self-adaptive systems. With respect to performance as quality attribute, we develop a performance engineering approach for model transformations in the project MICE funded by the German Research Foundation (DFG).


Related Research Projects

Debugging support for Abstract State Machines

Integrated Safety and Security Engineering of Self-Adaptive Systems.

Eclipse Plugin for Feature Oriented Software Development