Gerald Lüttgen
Current Organizations / Institutes
The organizations/institutes from the scholar's latest article
Research Subjects
Gerald Lüttgen has a total of 24 co-authors. Here are the top co-authors by number of shared publications:
- Jan H. Boockmann
University of Bamberg
4 shared publications - Walter Vogler
University of Augsburg
4 shared publications Ayleen Schinko
Institut für Informatik, University of Augsburg, Augsburg, Germany
2 shared publications- Eugene Yip
GLIWA GmbH & Co. KG, Oberbayern, Germany
2 shared publications - Jan Tobias Mühlberg
Universite Libre de Bruxelles
2 shared publications Johannes Gareis
Software Technologies Research Group, University of Bamberg, Bamberg, Germany
2 shared publications
Latest Publications
- 12 November 2025
- Published by Springer Nature
- p. 148-156
On the Generation of Invalid Objects for Inferring More Precise Class Invariants
- 12 November 2025
- Published by Springer Nature
- p. 148-156
On the Generation of Invalid Objects for Inferring More Precise Class Invariants
- Open Access
USeR: A Web-based User Story eReviewer for Assisted Quality Optimizations
User stories are widely applied for conveying requirements within agile software development teams. Multiple user story quality guidelines exist, but authors like Product Owners in industry projects frequently fail to write high-quality user stories. This situation is exacerbated by the lack of tools for assessing user story quality. In this paper, we propose User Story eReviewer (USeR) a web-based tool that allows authors to determine and optimize user story quality. For developing USeR, we collected 77 potential quality metrics through literature review, practitioner sessions, and research group meetings and refined these to 34 applicable metrics through expert sessions. Finally, we derived algorithms for eight prioritized metrics using a literature review and research group meetings and implemented them with plain code and machine learning techniques. USeR offers a RESTful API and user interface for instant, consistent, and explainable user feedback supporting fast and easy quality optimizations. It has been empirically evaluated with an expert study using 100 user stories and four experts from two real-world agile software projects in the automotive and health sectors.
Open AccessUSeR: A Web-based User Story eReviewer for Assisted Quality Optimizations
User stories are widely applied for conveying requirements within agile software development teams. Multiple user story quality guidelines exist, but authors like Product Owners in industry projects frequently fail to write high-quality user stories. This situation is exacerbated by the lack of tools for assessing user story quality. In this paper, we propose User Story eReviewer (USeR) a web-based tool that allows authors to determine and optimize user story quality. For developing USeR, we collected 77 potential quality metrics through literature review, practitioner sessions, and research group meetings and refined these to 34 applicable metrics through expert sessions. Finally, we derived algorithms for eight prioritized metrics using a literature review and research group meetings and implemented them with plain code and machine learning techniques. USeR offers a RESTful API and user interface for instant, consistent, and explainable user feedback supporting fast and easy quality optimizations. It has been empirically evaluated with an expert study using 100 user stories and four experts from two real-world agile software projects in the automotive and health sectors.
- Open Access
- 6 April 2024
- Published by Springer Nature
- p. 143-164
Comprehending Object State via Dynamic Class Invariant Learning
Maintaining software is cumbersome when method argument constraints are undocumented. To reveal them, previous work learned preconditions from exemplary valid and invalid method arguments. In practice, it would be highly beneficial to know class invariants, too, because functionality added during software maintenance must not break them. Even more so than method preconditions, class invariants are rarely documented and often cannot completely be inferred automatically, especially for objects exhibiting complex state such as dynamic data structures.This paper presents a novel dynamic approach to learning class invariants, thereby complementing related work on learning method preconditions. We automatically synthesize assertions from an adjustable assertion grammar to distinguish valid and invalid objects. While random walks generate valid objects, a combination of bounded-exhaustive testing techniques and behavioral oracles yield invalid objects. The utility of our approach for code comprehension and software maintenance is demonstrated by comparing our learned invariants to documented invariant validation methods found in real-world Java classes and to the invariants detected by the Daikon tool.
- 6 April 2024
- Published by Springer Nature
- p. 143-164
Open AccessComprehending Object State via Dynamic Class Invariant Learning
Maintaining software is cumbersome when method argument constraints are undocumented. To reveal them, previous work learned preconditions from exemplary valid and invalid method arguments. In practice, it would be highly beneficial to know class invariants, too, because functionality added during software maintenance must not break them. Even more so than method preconditions, class invariants are rarely documented and often cannot completely be inferred automatically, especially for objects exhibiting complex state such as dynamic data structures.This paper presents a novel dynamic approach to learning class invariants, thereby complementing related work on learning method preconditions. We automatically synthesize assertions from an adjustable assertion grammar to distinguish valid and invalid objects. While random walks generate valid objects, a combination of bounded-exhaustive testing techniques and behavioral oracles yield invalid objects. The utility of our approach for code comprehension and software maintenance is demonstrated by comparing our learned invariants to documented invariant validation methods found in real-world Java classes and to the invariants detected by the Daikon tool.
- Open Access
- 1 January 2024
- Published by Universitatsbibliothek Bamberg
Heterogeneous Specification of Spacecraft Software
The operational behaviour of a reactive system is commonly specified or modelled as concurrent state machines, where each machine models the possible states or modes of a software component and its interactions with the environment. However, state machines can quickly become verbose when execution constraints between concurrent states need to be modelled. Alternatively, constraints could be modelled declaratively as special edges between states. Such a heterogeneous modelling approach is employed by Virtual Satellite (VirSat), a model-based systems engineering tool from the German Aerospace Center (DLR). The challenge has been to develop a heterogeneous modelling framework that supports an operational and declarative syntax, defines a unified semantics suitable for formal reasoning, and supports the independent and incremental development of software components. We address this challenge with our Component State Machine (CSM) formalism as a means to operationalise VirSat: the operational syntax of VirSat is preserved in CSM, the declarative VirSat constraints are transformed into CSM atomic propositions and parallel conditions, the CSM parallel operator incrementally composes CSMs and resolves the parallel conditions, and design errors are analysed as inconsistent transitions. CSM permits new constraints to be defined without needing to modify the core VirSat semantics. We also propose an intuitive, practical, and mathematically rigorous notion of refinement that aims to encourage a more systematic development of spacecraft software. Lastly, we offer a modular implementation of CSMs as hierarchically scheduled Executable State Machines (ESMs) that remains open to further composition and refinement.
- 1 January 2024
- Published by Universitatsbibliothek Bamberg
Open AccessHeterogeneous Specification of Spacecraft Software
The operational behaviour of a reactive system is commonly specified or modelled as concurrent state machines, where each machine models the possible states or modes of a software component and its interactions with the environment. However, state machines can quickly become verbose when execution constraints between concurrent states need to be modelled. Alternatively, constraints could be modelled declaratively as special edges between states. Such a heterogeneous modelling approach is employed by Virtual Satellite (VirSat), a model-based systems engineering tool from the German Aerospace Center (DLR). The challenge has been to develop a heterogeneous modelling framework that supports an operational and declarative syntax, defines a unified semantics suitable for formal reasoning, and supports the independent and incremental development of software components. We address this challenge with our Component State Machine (CSM) formalism as a means to operationalise VirSat: the operational syntax of VirSat is preserved in CSM, the declarative VirSat constraints are transformed into CSM atomic propositions and parallel conditions, the CSM parallel operator incrementally composes CSMs and resolves the parallel conditions, and design errors are analysed as inconsistent transitions. CSM permits new constraints to be defined without needing to modify the core VirSat semantics. We also propose an intuitive, practical, and mathematically rigorous notion of refinement that aims to encourage a more systematic development of spacecraft software. Lastly, we offer a modular implementation of CSMs as hierarchically scheduled Executable State Machines (ESMs) that remains open to further composition and refinement.
- Open Access
- 1 January 2024
- Published by Universitatsbibliothek Bamberg
Concurrency, Shared Variables, Compositionality : An Unlikely Triple
This paper reports our experiences with extending Interface Automaton (IA) with shared variables by lifting IA’s intuitive notion of refinement and compositionality to shared variables. Although there are existing works that introduce shared variables to IA, they typically support a very restricted notion of sharing, e.g., the value of a shared variable is only defined for the duration of an atomic operation, with no ability to persist values for subsequent operations. When attempting to formulate the semantics of shared variables that could persist their values across operations, we encountered numerous challenges when defining a notion of refinement that respected compositionality. We conjecture that, even for a basic notion of variable persistence, concurrent shared variable accesses between automata create a tight data dependency that prevents a compositional reasoning. We discuss the generality of this negative result in relation to other concurrency theories.
- 1 January 2024
- Published by Universitatsbibliothek Bamberg
Open AccessConcurrency, Shared Variables, Compositionality : An Unlikely Triple
This paper reports our experiences with extending Interface Automaton (IA) with shared variables by lifting IA’s intuitive notion of refinement and compositionality to shared variables. Although there are existing works that introduce shared variables to IA, they typically support a very restricted notion of sharing, e.g., the value of a shared variable is only defined for the duration of an atomic operation, with no ability to persist values for subsequent operations. When attempting to formulate the semantics of shared variables that could persist their values across operations, we encountered numerous challenges when defining a notion of refinement that respected compositionality. We conjecture that, even for a basic notion of variable persistence, concurrent shared variable accesses between automata create a tight data dependency that prevents a compositional reasoning. We discuss the generality of this negative result in relation to other concurrency theories.
- Open Access
- 30 August 2021
- Published by Springer Nature in Acta Informatica
- Vol. 59 (5) , 521-556
Interface Automata for Shared Memory
Interface theories based on Interface Automata (IA) are formalisms for the component-based specification of concurrent systems. Extensions of their basic synchronization mechanism permit the modelling of data, but are studied in more complex settings involving modal transition systems or do not abstract from internal computation. In this article, we show how de Alfaro and Henzinger’s original IA theory can be conservatively extended by shared memory data, without sacrificing simplicity or imposing restrictions. Our extension IA for shared Memory (IAM) decorates transitions with pre- and post-conditions over algebraic expressions on shared variables, which are taken into account by IA’s notion of component compatibility. Simplicity is preserved as IAM can be embedded into IA and, thus, accurately lifts IA’s compatibility concept to shared memory. We also provide a ground semantics for IAM that demonstrates that our abstract handling of data within IA’s open systems view is faithful to the standard treatment of data in closed systems.
- 30 August 2021
- Published by Springer Nature in Acta Informatica
- Vol. 59 (5) , 521-556
Open AccessInterface Automata for Shared Memory
Interface theories based on Interface Automata (IA) are formalisms for the component-based specification of concurrent systems. Extensions of their basic synchronization mechanism permit the modelling of data, but are studied in more complex settings involving modal transition systems or do not abstract from internal computation. In this article, we show how de Alfaro and Henzinger’s original IA theory can be conservatively extended by shared memory data, without sacrificing simplicity or imposing restrictions. Our extension IA for shared Memory (IAM) decorates transitions with pre- and post-conditions over algebraic expressions on shared variables, which are taken into account by IA’s notion of component compatibility. Simplicity is preserved as IAM can be embedded into IA and, thus, accurately lifts IA’s compatibility concept to shared memory. We also provide a ground semantics for IAM that demonstrates that our abstract handling of data within IA’s open systems view is faithful to the standard treatment of data in closed systems.
- Open Access
- 8 July 2021
- Published by Springer Nature in Acta Informatica
- Vol. 58 (6) , 677
Correction to: A linear-time branching-time perspective on interface automata
- 8 July 2021
- Published by Springer Nature in Acta Informatica
- Vol. 58 (6) , 677
Open AccessCorrection to: A linear-time branching-time perspective on interface automata
- Open Access
- 27 May 2020
- Published by EasyChair
- Vol. 73, 151-168
Learning Data Structure Shapes from Memory Graphs
This paper presents a novel algorithm for automatically learning recursive shape predicates from memory graphs, so as to formally describe the pointer-based data structures contained in a program. These predicates are expressed in separation logic and can be used, e.g., to construct efficient secure wrappers that validate the shape of data structures exchanged between trust boundaries at runtime. Our approach first decomposes memory graph(s) into sub-graphs, each of which exhibits a single data structure, and generates candidate shape predicates of increasing complexity, which are expressed as rule sets in Prolog. Under separation logic semantics, a meta-interpreter then performs a systematic search for a subset of rules that form a shape predicate that non-trivially and concisely captures the data structure. Our algorithm is implemented in the prototype tool ShaPE and evaluated on examples from the real-world and the literature. It is shown that our approach indeed learns concise predicates for many standard data structures and their implementation variations, and thus alleviates software engineers from what has been a time-consuming manual task.
- 27 May 2020
- Published by EasyChair
- Vol. 73, 151-168
Open AccessLearning Data Structure Shapes from Memory Graphs
This paper presents a novel algorithm for automatically learning recursive shape predicates from memory graphs, so as to formally describe the pointer-based data structures contained in a program. These predicates are expressed in separation logic and can be used, e.g., to construct efficient secure wrappers that validate the shape of data structures exchanged between trust boundaries at runtime. Our approach first decomposes memory graph(s) into sub-graphs, each of which exhibits a single data structure, and generates candidate shape predicates of increasing complexity, which are expressed as rule sets in Prolog. Under separation logic semantics, a meta-interpreter then performs a systematic search for a subset of rules that form a shape predicate that non-trivially and concisely captures the data structure. Our algorithm is implemented in the prototype tool ShaPE and evaluated on examples from the real-world and the literature. It is shown that our approach indeed learns concise predicates for many standard data structures and their implementation variations, and thus alleviates software engineers from what has been a time-consuming manual task.
- Open Access
- 6 May 2020
- Published by Springer Nature in Acta Informatica
- Vol. 57 (3-5) , 513-550
A linear-time branching-time perspective on interface automata
Over the past two decades, de Alfaro and Henzinger’s interface automata (IA) have become a popular formal framework for the component-based specification of concurrent systems. IA’s parallel composition assumes that a component may wait on inputs but never on outputs, implying that an output must be consumed immediately or a communication error occurs. By now, the literature contains a number of semantics for IA: linear-time semantics based on traces observing communication errors, quiescence and/or divergence, as well as branching-time semantics based on alternating simulation. This article surveys these semantics from Rob van Glabbeek’s linear-time branching-time perspective, which does not consider settings with communication errors. We shed light onto the subtleties implied by IA’s pruning of all behaviour that might lead a component to autonomously enter an error state, and investigate when exactly de Alfaro and Henzinger’s restriction of input-determinism is needed. In addition, we introduce several new semantics for IA, in particular the linear-time ready semantics and the branching-time ready simulation.
- 6 May 2020
- Published by Springer Nature in Acta Informatica
- Vol. 57 (3-5) , 513-550
Open AccessA linear-time branching-time perspective on interface automata
Over the past two decades, de Alfaro and Henzinger’s interface automata (IA) have become a popular formal framework for the component-based specification of concurrent systems. IA’s parallel composition assumes that a component may wait on inputs but never on outputs, implying that an output must be consumed immediately or a communication error occurs. By now, the literature contains a number of semantics for IA: linear-time semantics based on traces observing communication errors, quiescence and/or divergence, as well as branching-time semantics based on alternating simulation. This article surveys these semantics from Rob van Glabbeek’s linear-time branching-time perspective, which does not consider settings with communication errors. We shed light onto the subtleties implied by IA’s pruning of all behaviour that might lead a component to autonomously enter an error state, and investigate when exactly de Alfaro and Henzinger’s restriction of input-determinism is needed. In addition, we introduce several new semantics for IA, in particular the linear-time ready semantics and the branching-time ready simulation.
- 26 June 2019
- Published by Springer Nature in Lecture Notes in Computer Science
- p. 151-166
Interface Automata for Shared Memory
- 26 June 2019
- Published by Springer Nature in Lecture Notes in Computer Science
- p. 151-166
Interface Automata for Shared Memory