My research focuses on developing methods and techniques that support engineering autonomous software systems, especially systems that adapt themselves and impact the environment based on automated decisions (cf. self-aware and self-adaptive software systems). This particularly includes methods and techniques for the quality assurance and explanations of autonomous behavior to make such systems dependable and trustworthy. In my work, I combine software engineering research with artificial and computational intelligence, formal methods, control theory, and model-driven engineering.

My Ph.D. research was about the Model-Driven Engineering of Self-Adaptive Software where models and model-driven engineering techniques are exceedingly leveraged at run-time to achieve a higher degree of flexibility in the design, evolution, and operation of such software systems than the state of the art with code-based solutions (cf. EUREMA and MORISIA projects).

In my postdoctoral studies I broadened my research along three lines, which inspire and benefit from each other:

(1) Methods and techniques to achieve and cope with the increasing level of autonomy of software systems

We aim for an increasing level of autonomy of software systems, which enables them to operate in uncertain and dynamic environments (e.g., cyber-physical systems that autonomously adapt themselves to changing environmental conditions). This requires novel means to engineer such self-adaptive systems. In this context, I research methods and techniques from computational and artificial intelligence, formal methods, control theory, software quality assurance, and software architecture and design to increase as well as cope with the autonomous behavior of software systems:

• Learning and optimization from computational and artificial intelligence to automatically identify optimal system configurations, adaptation rules, and adaptation decisions under uncertainty, which increases the level of autonomy (TAAS’20, SEAMS’20a, SASO’19, SEAMS’18b, ICAC’17), and to generate explanations for property violations in cyber-physical systems (IEEE Software’24)
• Synthesis and model checking from formal methods to generate optimal controllers for adaptation decisions with guarantees (SEAMS’24) and to formally verify self-adaptive systems (SEAMS’19, SEAMS’18b)
• Control-theoretical principles to systematically engineer self-adaptive systems with guarantees (SEAMS’20a, SEAMS’20b, TAAS’17, CASaS’17, SEAMS’15)
• Verification and testing from software quality assurance to verify and validate self-adaptive systems, among others, regarding safety and reliability (SEAMS’23a, SEAMS’19, SEAMS’18b, SEfSAS’17a, SEfSAS’17b, SASOW’15)
• Developing architecture and design principles for self-aware/self-adaptive systems (see ACSOSC’20, SACS’17a, SACS’17b, SACS’17c)

Additionally, I am promoting rigor evaluation of self-adaptive software systems research (SEAMS’21) and industry-relevant research in this area (SEAMS’23b, SIGSOFT SEN’22), for instance, using artifacts such as mRUBiS (SEAMS’18a).

(2) Explaining intelligent methods and making intelligent methods self-adaptive

Methods from computational and artificial intelligence are typically black-box and arcane for software engineers, which impedes an understanding why such intelligent methods work well and others do not for a specific problem. My goal is to develop explanations that enable such an understanding, and I particularly use software engineering tools such as test case generators as target systems that use intelligent methods (e.g., evolutionary algorithms).

With the FLASH project, I developed explanations of the difficulty of optimization problems in search-based software engineering based on a fitness landscape analysis. The explanations enable a better understanding of the search problems and intelligent methods, which helps in manually configuring a method to yield better results for a specific problem. In this context, I envision self-adaptive intelligent methods that automatically and dynamically configure themselves at run-time.

As an example, I developed analytical explanations of the difficulty of generating test cases for mobile apps with Sapienz and devised an ad-hoc solution for a self-adaptive Sapienz that achieves better or ar least similar test results (SSBSE’19, IST’21, project Self-Adaptive Search for Sapienz).

The goal of the recent project Controlling Search-Based Test Case Generation and Program Repair is to systematically develop controlled (self-adaptive) solutions for test case generation and program repair based on dynamic features identified in an evolution analysis.

Since the techniques to develop explanations are generic, they can be also applied to optimization problems in autonomous software systems such as finding optimal adaptation decisions and system configurations.

Besides aiming for a better understanding of intelligent methods, I am interesting in developing and applying such methods to software engineering problems such as testing (SSBSE’20b), fuzzing (SSBSE’20a), and vulnerability detection (IST’22b).

(3) Practical and explainable verification of software systems

Given the increasing level of autonomy, large configuration spaces, or uncertainty of software systems, assuring such systems has become a major challenge (SEfSAS’17a, SE4Science’19). The use of formal methods (e.g., model checking), and the interpretation of the results of such methods (e.g., a counterexample) are often difficult, error-prone, and costly. My goal is to make such methods practically usable, for instance, by:

• following a model-based approach to tame the complexity of safety analysis (IMBSA’19)
• leveraging natural language-based property specification patterns (IST’22c)
• improving the explainability and interpretation of counterexamples (EMSE’23, IST’22a, ICSME-RR’21, IMBSA’20)
• automatically deriving verifiable models from higher-level user input such as goal models (SEAMS’19)