@inproceedings{boockmann2025_112155,
  title = {On the Generation of Invalid Objects for Inferring More Precise Class Invariants},
  author = {Boockmann, Jan Henrik and Jacob, Kerstin and Lüttgen, Gerald},
  year = {2025},
  booktitle = {Software Engineering and Formal Methods : 23rd International Conference, SEFM 2025, Toledo, Spain, November 10–14, 2025, Proceedings},
  pages = {148-156},
  publisher = {Springer Nature Switzerland},
  address = {Cham},
  series = {Lecture Notes in Computer Science},
  isbn = {9783032104434},
  doi = {10.1007/978-3-032-10444-1\_9},
  url = {https://fis.uni-bamberg.de/handle/uniba/112155},
  language = {eng}
}

@inproceedings{jacob2025_112156,
  title = {Recovering Test-To-Code Trace Links via Program Mutation},
  author = {Jacob, Kerstin and Lüttgen, Gerald},
  year = {2025},
  booktitle = {2025 IEEE International Conference on Software Analysis, Evolution and Reengineering - Companion (SANER-C)},
  pages = {166-173},
  publisher = {IEEE Computer Society},
  address = {Los Alamitos, CA, USA},
  doi = {10.1109/saner-c66551.2025.00032},
  url = {https://fis.uni-bamberg.de/handle/uniba/112156},
  language = {eng}
}

@inproceedings{boockmann2025_111406,
  title = {Comprehending Object State via Dynamic Class Invariant Learning},
  author = {Boockmann, Jan H. and Lüttgen, Gerald},
  year = {2025},
  pages = {143-164},
  publisher = {Otto-Friedrich-Universität},
  address = {Bamberg},
  urn = {urn:nbn:de:bvb:473-irb-111406x},
  url = {https://fis.uni-bamberg.de/handle/uniba/111406},
  language = {eng},
  abstract = {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.},
  keywords = {Dynamic Class Invariant Learning}
}

@inproceedings{luedtke2025_111403,
  title = {SWTbahn : An Embedded Software Demonstrator in Symbiosis with Embedded Software Education},
  author = {Luedtke, Bernhard M. and Yip, Eugene and Lüttgen, Gerald},
  year = {2025},
  pages = {77-82},
  publisher = {Otto-Friedrich-Universität},
  address = {Bamberg},
  urn = {urn:nbn:de:bvb:473-irb-111403x},
  url = {https://fis.uni-bamberg.de/handle/uniba/111403},
  language = {eng},
  abstract = {Demonstrators, such as model railways, are effective in providing real-world examples that help students to grasp abstract concepts in the engineering of embedded software. Although building such a demonstrator yourself can appear overwhelming, we argue how building your own improves your teaching of embedded software. We report on how we have achieved these improvements with a development process that lets our teaching co-evolve with our own demonstrator, share our main lessons learned, and invite educators to discuss remaining challenges.},
  keywords = {model railway demonstrator, evolutionary development, embedded software}
}

@inproceedings{martin2025_106396,
  title = {Fast Pathfinding in Knowledge Graphs Using Word Embeddings},
  author = {Martin, Leon and Boockmann, Jan H. and Henrich, Andreas},
  year = {2025},
  pages = {305-312},
  publisher = {Otto-Friedrich-Universität},
  address = {Bamberg},
  series = {Lecture Notes in Computer Science},
  urn = {urn:nbn:de:bvb:473-irb-1063964},
  url = {https://fis.uni-bamberg.de/handle/uniba/106396},
  language = {eng},
  abstract = {Knowledge graphs, which model relationships between entities, provide a rich and structured source of information. Currently, search engines aim to enrich their search results by structured summaries, e.g., obtained from knowledge graphs, that provide further information on the entity of interest. While single entity summaries are available already, summaries on the relations between multiple entities have not been studied in detail so far. Such queries can be understood as a pathfinding problem. However, the large size of public knowledge graphs, such as Wikidata, as well as the large indegree of its major entities, and the problem of concept drift impose major challenges for standard search algorithms in this context.
In this paper, we propose a bidirectional pathfinding approach for directed knowledge graphs that uses the semantic distance between entity labels, which is approximated using word vectors, as a search heuristics in a parameterized A*-like evaluation function in order to find meaningful paths between two entities fast. We evaluate our approach using different parameters against a set of selected within- and cross-domain queries. The results indicate that our approach generally needs to explore fewer entities compared to its uninformed counterpart and qualitatively yields more meaningful paths.},
  keywords = {Knowledge graphs, Word embeddings, Pathfinding}
}

@article{schwartz2025_107589,
  title = {On domain generators for the evaluation of action reversibility in STRIPS},
  author = {Schwartz, Tobias and Boockmann, Jan H. and Martin, Leon},
  year = {2025},
  journal = {Annals of Mathematics and Artificial Intelligence},
  volume = {93},
  number = {5},
  pages = {699-726},
  publisher = {Springer Science + Business Media B.V},
  address = {Dordrecht [u.a.]},
  issn = {1573-7470},
  doi = {10.1007/s10472-024-09960-8},
  url = {https://fis.uni-bamberg.de/handle/uniba/107589},
  language = {eng},
  abstract = {Robustness is a crucial requirement for the deployment of AI systems in real-world scenarios. In the context of AI planning, the concept of action reversibility, i.e., the ability to undo the effects of an action using a reverse plan, is a promising direction for achieving robust plans. Plans composed exclusively of reversible actions exhibit resilience against goal changes during the execution of the plan. However, the evaluation of action reversibility systems in STRIPS planning presents a challenge, given that standard planning benchmarks are often not suitable. Early experiments using a naive implementation of an action reversibility algorithm show that the available domain generation approach is susceptible to bias. Building on this existing domain generator, we introduce two slight variations that exhibit entirely different search space characteristics. We assess these domain generators using the naive action reversibility implementation and existing ASP implementations, and demonstrate that different generators indeed favor different implementations. As a follow-up to this line of research, we present a generalized domain generator facilitating the creation of domains with diverse search space characteristics. To finally reduce the utilization of contrived generation patterns, we propose another domain generator based on the Barabási-Albert model yielding less rigid domains. Our experiments demonstrate that these new domain generators can produce a variety of domains with diverse search space characteristics, enabling a less biased evaluation of action reversibility systems.},
  keywords = {STRIPS planning, Action reversibility, Benchmark, PDDL domain generation}
}

@inproceedings{jacob2024_106849,
  title = {Integrating Mutation Techniques to Keep Specification and Source Code in Sync},
  author = {Jacob, Kerstin},
  year = {2024},
  booktitle = {Proceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis},
  pages = {1912-1914},
  publisher = {ACM},
  address = {New York, NY, United States},
  isbn = {979-8-4007-0612-7},
  doi = {10.1145/3650212.3685556},
  url = {https://fis.uni-bamberg.de/handle/uniba/106849},
  language = {eng}
}

@inproceedings{boockmann2024_98466,
  title = {Comprehending Object State via Dynamic Class Invariant Learning},
  author = {Boockmann, Jan H. and Lüttgen, Gerald},
  year = {2024},
  booktitle = {Fundamental Approaches to Software Engineering : 27th International Conference, FASE 2024, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2024, Luxembourg City, Luxembourg, April 6–11, 2024, Proceedings},
  pages = {143-164},
  publisher = {Springer Nature Switzerland},
  address = {Cham},
  isbn = {978-3-031-57258-6},
  doi = {10.1007/978-3-031-57259-3\_7},
  url = {https://fis.uni-bamberg.de/handle/uniba/98466},
  language = {eng},
  abstract = {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.},
  keywords = {Dynamic Class Invariant Learning}
}

@inproceedings{luedtke2024_98464,
  title = {SWTbahn : An Embedded Software Demonstrator in Symbiosis with Embedded Software Education},
  author = {Luedtke, Bernhard M. and Yip, Eugene and Lüttgen, Gerald},
  year = {2024},
  booktitle = {Software Engineering im Unterricht der Hochschulen 2024 : Komplettband},
  pages = {77-82},
  publisher = {Gesellschaft für Informatik e.V.},
  address = {Bonn},
  isbn = {978-3-88579-255-0},
  doi = {10.18420/seuh2024\_06},
  url = {https://fis.uni-bamberg.de/handle/uniba/98464},
  language = {eng},
  abstract = {Demonstrators, such as model railways, are effective in providing real-world examples that help students to grasp abstract concepts in the engineering of embedded software. Although building such a demonstrator yourself can appear overwhelming, we argue how building your own improves your teaching of embedded software. We report on how we have achieved these improvements with a development process that lets our teaching co-evolve with our own demonstrator, share our main lessons learned, and invite educators to discuss remaining challenges.},
  keywords = {model railway demonstrator, evolutionary development, embedded software}
}

@inproceedings{boockmann2024_98170,
  title = {On the Hunt for Invalid Objects : Exploring the Object State Space with Program Mutants},
  author = {Boockmann, Jan Henrik and Lüttgen, Gerald},
  year = {2024},
  volume = {31},
  pages = {711-716},
  publisher = {IEEE},
  address = {New York},
  isbn = {979-8-3503-3066-3},
  issn = {2640-7574},
  doi = {10.1109/saner60148.2024.00078},
  url = {https://fis.uni-bamberg.de/handle/uniba/98170},
  language = {eng}
}

@techreport{yip2024_97634,
  title = {Heterogeneous Specification of Spacecraft Software},
  author = {Yip, Eugene and Lüttgen, Gerald},
  year = {2024},
  publisher = {Otto-Friedrich-Universität},
  address = {Bamberg},
  series = {Bamberger Beiträge zur Wirtschaftsinformatik und Angewandten Informatik},
  doi = {10.20378/irb-97634},
  urn = {urn:nbn:de:bvb:473-irb-976349},
  url = {https://fis.uni-bamberg.de/handle/uniba/97634},
  language = {eng},
  abstract = {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.},
  keywords = {operational behaviour, component state machine (CSM), german aerospace center (DLR), VirSat, executable state machines (ESMs)}
}

@techreport{yip2024_97637,
  title = {Concurrency, Shared Variables, Compositionality : An Unlikely Triple},
  author = {Yip, Eugene and Lüttgen, Gerald},
  year = {2024},
  publisher = {Otto-Friedrich-Universität},
  address = {Bamberg},
  series = {Bamberger Beiträge zur Wirtschaftsinformatik und Angewandten Informatik},
  doi = {10.20378/irb-97637},
  urn = {urn:nbn:de:bvb:473-irb-976374},
  url = {https://fis.uni-bamberg.de/handle/uniba/97637},
  language = {eng},
  abstract = {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.},
  keywords = {Interface Automaton (IA), compositionality, shared variables, concurrency}
}

@inproceedings{yip2023_112379,
  title = {LetSynchronise : An Open-Source Framework for Analysing and Optimising Logical Execution Time Systems},
  author = {Yip, Eugene and Kuo, Matthew M.Y.},
  year = {2023},
  booktitle = {Proceedings of 2023 Cyber-Physical Systems and Internet-of-Things Week (CPS-IoT Week) Workshops : May 9-12, 2023, San Antonio, Texas, USA},
  pages = {349-354},
  publisher = {ACM},
  address = {New York},
  isbn = {979-8-4007-0049-1},
  doi = {10.1145/3576914.3587500},
  url = {https://fis.uni-bamberg.de/handle/uniba/112379},
  language = {eng}
}

@article{yip2023_108603,
  title = {Synchronous Deterministic Parallel Programming for Multi-Cores with ForeC},
  author = {Yip, Eugene and Girault, Alain and Roop, Partha S. and Biglari-Abhari, Morteza},
  year = {2023},
  journal = {ACM transactions on programming languages and systems : ACM TOPLAS},
  volume = {45},
  number = {2},
  pages = {1-74},
  publisher = {Association for Computing Machinery},
  address = {New York, NY},
  issn = {1558-4593},
  doi = {10.1145/3591594},
  url = {https://fis.uni-bamberg.de/handle/uniba/108603},
  language = {eng}
}

@inproceedings{jacob2023_90945,
  title = {On Developing an E-Assessment Tool for Agile Practices},
  author = {Jacob, Kerstin and Hallmann, Daniel and Lüttgen, Gerald and Völpel, Vanessa},
  year = {2023},
  pages = {13-18},
  publisher = {Otto-Friedrich-Universität},
  address = {Bamberg},
  urn = {urn:nbn:de:bvb:473-irb-909456},
  url = {https://fis.uni-bamberg.de/handle/uniba/90945},
  language = {eng},
  abstract = {As agile software development processes are widely applied in industry, students need to develop a good understanding of agile principles and practices as part of their education. During our ten years of experience with teaching the Scrum framework in team project modules, we noticed that students frequently struggle with writing good user stories and concise sprint goals. To support students in mastering basic practices and to free limited teaching resources for more in-depth discussions on advanced topics, e-assessment tools should be developed to provide timely feedback on at least common mistakes. This paper argues that, and sketches how, research on quality criteria for artifacts of agile development can serve as the basis for such a tool. However, multiple challenges remain that we invite lecturers and researchers to discuss.},
  keywords = {agile software development, e-assessment tool, Scrum}
}

@inproceedings{jacob2023_90073,
  title = {On Developing an E-Assessment Tool for Agile Practices},
  author = {Jacob, Kerstin and Hallmann, Daniel and Lüttgen, Gerald and Völpel, Vanessa},
  year = {2023},
  booktitle = {Proceedings der SEUH 2023 : 23.-24. Februar 2023 in Paderborn, Deutschland},
  pages = {13-18},
  publisher = {Gesellschaft für Informatik},
  address = {Bonn},
  isbn = {978-3-88579-727-2},
  issn = {1617-5468},
  doi = {10.18420/seuh2023\_01},
  url = {https://fis.uni-bamberg.de/handle/uniba/90073},
  language = {eng},
  abstract = {As agile software development processes are widely applied in industry, students need to develop a good understanding of agile principles and practices as part of their education. During our ten years of experience with teaching the Scrum framework in team project modules, we noticed that students frequently struggle with writing good user stories and concise sprint goals. To support students in mastering basic practices and to free limited teaching resources for more in-depth discussions on advanced topics, e-assessment tools should be developed to provide timely feedback on at least common mistakes. This paper argues that, and sketches how, research on quality criteria for artifacts of agile development can serve as the basis for such a tool. However, multiple challenges remain that we invite lecturers and researchers to discuss.},
  keywords = {agile software development, e-assessment tool, Scrum}
}

@article{ro2022_109401,
  title = {High Fidelity Simulation of Hybrid Systems using Higher Order Hybrid Automata},
  author = {Ro, Jin Woo and Malik, Avinash and Roop, Partha S.},
  year = {2022},
  journal = {IEEE Transactions on Computers},
  volume = {71},
  number = {7},
  pages = {1668-1680},
  publisher = {IEEE Computer Soc.},
  issn = {1557-9956},
  doi = {10.1109/tc.2021.3100746},
  url = {https://fis.uni-bamberg.de/handle/uniba/109401},
  language = {eng}
}

@article{beetz2022_109400,
  title = {GitOps : The Evolution of DevOps?},
  author = {Beetz, Florian and Harrer, Simon},
  year = {2022},
  journal = {IEEE software},
  volume = {39},
  number = {4},
  pages = {70-75},
  publisher = {Soc.},
  address = {Los Alamitos, Calif.},
  issn = {1937-4194},
  doi = {10.1109/ms.2021.3119106},
  url = {https://fis.uni-bamberg.de/handle/uniba/109400},
  language = {eng}
}

@article{boockmann2022_105316,
  title = {Model-driven Engineering for Dynamic Data Structures},
  author = {Boockmann, Jan Henrik and Jacob, Kerstin and Lüttgen, Gerald},
  year = {2022},
  journal = {Softwaretechnik-Trends : Mitteilungen der Fachgruppen},
  volume = {42},
  number = {4},
  pages = {2-7},
  publisher = {Gesellschaft für Informatik e.V.},
  address = {Bonn},
  issn = {0720-8928},
  url = {https://fis.uni-bamberg.de/handle/uniba/105316},
  language = {eng}
}

@inproceedings{boockmann2022_105320,
  title = {Heap Patterns for Memory Graph Visualization},
  author = {Boockmann, Jan and Lüttgen, Gerald},
  year = {2022},
  booktitle = {2022 Working Conference on Software Visualization (VISSOFT)},
  pages = {162-166},
  publisher = {IEEE},
  isbn = {978-1-6654-8092-5},
  doi = {10.1109/VISSOFT55257.2022.00025},
  url = {https://fis.uni-bamberg.de/handle/uniba/105320},
  language = {eng}
}

@inproceedings{boockmann2022_57354,
  title = {Throw Away Student Software At Semester End? : Better Not!},
  author = {Boockmann, Jan and Jacob, Kerstin and Lüttgen, Gerald},
  year = {2022},
  pages = {23-28},
  publisher = {Otto-Friedrich-Universität},
  address = {Bamberg},
  urn = {urn:nbn:de:bvb:473-irb-573544},
  url = {https://fis.uni-bamberg.de/handle/uniba/57354},
  language = {eng},
  abstract = {Software engineering is continuously evolving in order to meet the challenges faced by the ever growing complexity and longevity of digital systems. Students should thus acquire additional practical competencies wrt. software evolution and maintenance. This paper describes how student team projects at our Chair have been redesigned to meet this need, and reports on our first experiences. It also aims at initiating a discussion on the challenges we met, namely the contributions we can expect from students, the effort required from staff, and the individualization of grades.},
  keywords = {long-living software, project-based learning, software evolution and maintenance}
}

@inproceedings{boockmann2022_57001,
  title = {Throw Away Student Software At Semester End? : Better Not!},
  author = {Boockmann, Jan and Jacob, Kerstin and Lüttgen, Gerald},
  year = {2022},
  booktitle = {Software Engineering im Unterricht der Hochschulen SEUH 2022 : 24.-25. Februar 2022, Berlin ; Proceedings},
  pages = {23--28},
  address = {Bonn},
  isbn = {978-3-88579-715-9},
  doi = {10.18420/SEUH2022\_03},
  url = {https://fis.uni-bamberg.de/handle/uniba/57001},
  language = {eng},
  abstract = {Software engineering is continuously evolving in order to meet the challenges faced by the ever growing complexity and longevity of digital systems. Students should thus acquire additional practical competencies wrt. software evolution and maintenance. This paper describes how student team projects at our Chair have been redesigned to meet this need, and reports on our first experiences. It also aims at initiating a discussion on the challenges we met, namely the contributions we can expect from students, the effort required from staff, and the individualization of grades.},
  keywords = {long-living software, project-based learning, software evolution and maintenance}
}

@article{vogler2022_55170,
  title = {A linear-time branching-time perspective on interface automata},
  author = {Vogler, Walter and Lüttgen, Gerald},
  year = {2022},
  pages = {513-550},
  publisher = {Otto-Friedrich-Universität},
  address = {Bamberg},
  urn = {urn:nbn:de:bvb:473-irb-551700},
  url = {https://fis.uni-bamberg.de/handle/uniba/55170},
  language = {eng},
  abstract = {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.},
  keywords = {interface automata, semantics, simulation, de Alfaro and Henzinger’s restriction, Glabbeek’s linear-time branching-time perspective}
}

@inproceedings{ro2022_55364,
  title = {Reinforcement Learning With Imperfect Safety Constraints},
  author = {Ro, Jin Woo and Lüttgen, Gerald and Wolter, Diedrich},
  year = {2022},
  booktitle = {Artificial Intelligence Safety 2022 : Proceedings of the Workshop on Artificial Intelligence Safety 2022 (SafeAI 2022) co-located with the Thirty-Sixth AAAI Conference on Artificial Intelligence (AAAI2022) Virtual, February, 2022.},
  pages = {1-8},
  publisher = {RWTH Aachen},
  address = {Aachen, Germany},
  series = {CEUR workshop proceedings},
  url = {https://fis.uni-bamberg.de/handle/uniba/55364},
  language = {eng}
}

@article{kraas2022_54847,
  title = {On the automation-supported derivation of domain-specific UML profiles considering static semantics},
  author = {Kraas, Alexander},
  year = {2022},
  volume = {21},
  number = {1},
  pages = {51-79},
  publisher = {Otto-Friedrich-Universität},
  address = {Bamberg},
  urn = {urn:nbn:de:bvb:473-irb-548476},
  url = {https://fis.uni-bamberg.de/handle/uniba/54847},
  language = {eng},
  abstract = {In the light of standardization, the model-driven engineering (MDE) is becoming increasingly important for the development of DSLs, in addition to traditional approaches based on grammar formalisms. Metamodels define the abstract syntax and static semantics of a DSL and can be created by using the language concepts of the Meta Object Facility (MOF) or by defining a UML profile.

Both metamodels and UML profiles are often provided for standardized DSLs, and the mappings of metamodels to UML profiles are usually specified informally in natural language, which also applies for the static semantics of metamodels and/or UML profiles, which has the disadvantage that ambiguities can occur, and that the static semantics must be manually translated into a machine-processable language.

To address these weaknesses, we propose a new automated approach for deriving a UML profile from the metamodel of a DSL. One novelty is that subsetting or redefining metaclass attributes are mapped to stereotype attributes whose values are computed at runtime via automatically created OCL expressions. The automatic transfer of the static semantics of a DSL to a UML profile is a further contribution of our approach. Our DSL Metamodeling and Derivation Toolchain (DSL-MeDeTo) implements all aspects of our proposed approach in Eclipse. This enabled us to successfully apply our approach to the two DSLs Test Description Language (TDL) and Specification and Description Language (SDL).},
  keywords = {model-driven engineering (MDE), DSL, Metamodels, UML profiles, machine-processable language}
}

@article{schinko2022_54718,
  title = {Interface Automata for Shared Memory},
  author = {Schinko, Ayleen and Vogler, Walter and Gareis, Johannes and Nguyen, Ngoc Tri and Lüttgen, Gerald},
  year = {2022},
  publisher = {Otto-Friedrich-Universität},
  address = {Bamberg},
  urn = {urn:nbn:de:bvb:473-irb-547181},
  url = {https://fis.uni-bamberg.de/handle/uniba/54718},
  language = {eng},
  abstract = {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.},
  keywords = {Interface Automata, Alfaro and Henzinger’s original IA theory, memory data, ground semantics}
}

@article{kraas2021_54846,
  title = {On the automation-supported derivation of domain-specific UML profiles considering static semantics},
  author = {Kraas, Alexander},
  year = {2021},
  journal = {Software and Systems Modeling},
  volume = {21},
  number = {1},
  pages = {51-79},
  publisher = {Springer},
  address = {Berlin ; Heidelberg ; New York, NY, USA},
  issn = {1619-1374},
  doi = {10.1007/s10270-021-00890-1},
  url = {https://fis.uni-bamberg.de/handle/uniba/54846},
  language = {eng},
  abstract = {In the light of standardization, the model-driven engineering (MDE) is becoming increasingly important for the development of DSLs, in addition to traditional approaches based on grammar formalisms. Metamodels define the abstract syntax and static semantics of a DSL and can be created by using the language concepts of the Meta Object Facility (MOF) or by defining a UML profile.

Both metamodels and UML profiles are often provided for standardized DSLs, and the mappings of metamodels to UML profiles are usually specified informally in natural language, which also applies for the static semantics of metamodels and/or UML profiles, which has the disadvantage that ambiguities can occur, and that the static semantics must be manually translated into a machine-processable language.

To address these weaknesses, we propose a new automated approach for deriving a UML profile from the metamodel of a DSL. One novelty is that subsetting or redefining metaclass attributes are mapped to stereotype attributes whose values are computed at runtime via automatically created OCL expressions. The automatic transfer of the static semantics of a DSL to a UML profile is a further contribution of our approach. Our DSL Metamodeling and Derivation Toolchain (DSL-MeDeTo) implements all aspects of our proposed approach in Eclipse. This enabled us to successfully apply our approach to the two DSLs Test Description Language (TDL) and Specification and Description Language (SDL).},
  keywords = {model-driven engineering (MDE), DSL, Metamodels, UML profiles, machine-processable language}
}

@article{schinko2021_54717,
  title = {Interface Automata for Shared Memory},
  author = {Schinko, Ayleen and Vogler, Walter and Gareis, Johannes and Nguyen, Ngoc Tri and Lüttgen, Gerald},
  year = {2021},
  journal = {Acta Informatica},
  publisher = {Springer},
  address = {Berlin ; Heidelberg ; New York, NY, USA},
  issn = {1432-0525},
  doi = {10.1007/s00236-021-00408-8},
  url = {https://fis.uni-bamberg.de/handle/uniba/54717},
  language = {eng},
  abstract = {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.},
  keywords = {Interface Automata, Alfaro and Henzinger’s original IA theory, memory data, ground semantics}
}

@inproceedings{gretz2020_112860,
  title = {Synchronized Shared Memory and Procedural Abstraction : Towards a Formal Semantics of Blech},
  author = {Gretz, F. and Grosch, F-J. and Mendler, M. and Scheele, S.},
  year = {2020},
  booktitle = {Proceedings of the 2020 Forum on specification \& Design Languages (FDL)},
  publisher = {IEEE},
  address = {Piscataway, New Jersey},
  isbn = {978-1-7281-8928-4},
  doi = {10.1109/fdl50818.2020.9232942},
  url = {https://fis.uni-bamberg.de/handle/uniba/112860},
  language = {eng}
}

@inproceedings{boockmann2020_50153,
  title = {Learning Data Structure Shapes from Memory Graphs},
  author = {Boockmann, Jan and Lüttgen, Gerald},
  year = {2020},
  volume = {73},
  pages = {151-168},
  publisher = {EasyChair},
  address = {Manchester},
  issn = {2398-7340},
  doi = {10.29007/dhpw},
  url = {https://fis.uni-bamberg.de/handle/uniba/50153},
  language = {eng}
}

@article{vogler2020_50150,
  title = {A linear-time branching-time perspective on interface automata},
  author = {Vogler, Walter and Lüttgen, Gerald},
  year = {2020},
  journal = {Acta Informatica},
  volume = {57},
  number = {3},
  pages = {513-550},
  publisher = {Springer},
  issn = {1432-0525},
  doi = {10.1007/s00236-020-00369-4},
  url = {https://fis.uni-bamberg.de/handle/uniba/50150},
  language = {eng},
  abstract = {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.},
  keywords = {interface automata, semantics, simulation, de Alfaro and Henzinger’s restriction, Glabbeek’s linear-time branching-time perspective}
}

@inproceedings{martin2020_49140,
  title = {Fast Pathfinding in Knowledge Graphs Using Word Embeddings},
  author = {Martin, Leon and Boockmann, Jan H. and Henrich, Andreas},
  year = {2020},
  booktitle = {KI 2020: Advances in Artificial Intelligence : 43rd German Conference on AI, Bamberg, Germany, September 21–25, 2020, Proceedings},
  pages = {305-312},
  publisher = {Springer},
  address = {Cham},
  series = {Lecture Notes in Computer Science},
  isbn = {978-3-030-58284-5},
  issn = {0302-9743},
  doi = {10.1007/978-3-030-58285-2\_27},
  url = {https://fis.uni-bamberg.de/handle/uniba/49140},
  language = {eng},
  abstract = {Knowledge graphs, which model relationships between entities, provide a rich and structured source of information. Currently, search engines aim to enrich their search results by structured summaries, e.g., obtained from knowledge graphs, that provide further information on the entity of interest. While single entity summaries are available already, summaries on the relations between multiple entities have not been studied in detail so far. Such queries can be understood as a pathfinding problem. However, the large size of public knowledge graphs, such as Wikidata, as well as the large indegree of its major entities, and the problem of concept drift impose major challenges for standard search algorithms in this context.
In this paper, we propose a bidirectional pathfinding approach for directed knowledge graphs that uses the semantic distance between entity labels, which is approximated using word vectors, as a search heuristics in a parameterized A*-like evaluation function in order to find meaningful paths between two entities fast. We evaluate our approach using different parameters against a set of selected within- and cross-domain queries. The results indicate that our approach generally needs to explore fewer entities compared to its uninformed counterpart and qualitatively yields more meaningful paths.},
  keywords = {Knowledge graphs, Word embeddings, Pathfinding}
}

@phdthesis{rupprecht2020_47325,
  title = {Data Structure Identification from Executions of Pointer Programs},
  author = {Rupprecht, Thomas},
  year = {2020},
  publisher = {University of Bamberg Press},
  address = {Bamberg},
  series = {Schriften aus der Fakultät Wirtschaftsinformatik und Angewandte Informatik der Otto-Friedrich-Universität Bamberg},
  isbn = {978-3-86309-717-2},
  doi = {10.20378/irb-47325},
  urn = {urn:nbn:de:bvb:473-irb-473250},
  url = {https://fis.uni-bamberg.de/handle/uniba/47325},
  language = {eng},
  abstract = {The reverse engineering of binaries is a tedious and time consuming task, yet mandatory when the need arises to understand the behaviour of a program for which source code is unavailable. Instances of source code loss for old arcade games [1] and the steadily growing amount of malware [2] are prominent use cases requiring reverse engineering. One of the challenges when dealing with binaries is the loss of low level type information, i.e., primitive and compound types, which even state-of-the-art type recovery tools often cannot reconstruct with full accuracy. Further programmers most commonly use high level data structures, such as linked lists, in addition to primitive types. Therefore detection of dynamic data structure shapes is an important aspect of reverse engineering. Though the recognition of dynamic data structure shapes in the presence of tricky programming concepts such as pointer arithmetic and casts – which are both fundamental concepts to enable, e.g., the frequently used Linux kernel list [3] – also bring current shape detection tools to their limits. 

A recent approach called Data Structure Investigator (DSI) [4] , aims for the detection of dynamic pointer based data structures. While the approach is general in nature, a concrete realization for C programs requiring source code is envisioned as programming constructs such as type casts and pointer arithmetic will stress test the approach. Therefore, the first research question addressed in this dissertation is whether DSI can meet its goal in the presence of the sheer multitude of existing data structure implementations. The second research question is whether DSI can be opened up to reverse engineer C/C++ binaries, even in the presence of type information loss and the variety of C/C++ programming constructs. Both questions are answered positively in this dissertation. The first is answered by realizing the DSI source code approach, which requires detailing fundamental aspects of DSI’s theory to arrive at a working implementation, e.g., handling the consistency of DSI’s memory abstraction and quantifying the interconnections found within a dynamic pointer based data structure, e.g., a parent child nesting scenario, to allow for its detection. DSI’s utility is evaluated on an extensive benchmark including real world examples (libusb [5], bash [6]) and shape analysis examples, [7,8] . The second question is answered through the development of a DSI prototype for binaries (DSIbin). To compensate for the loss of perfect type information found in source code, DSIbin interfaces with the state-of-the-art type recovery tool Howard [9]. Notably, DSIbin improves upon type information recovered by Howard. This is accomplished through a much improved nested struct detection and type merging algorithm, both of which are fundamental aspects for the reverse engineering of binaries. The proposed approach is again evaluated by a diverse benchmark containing real world examples such as, the VNC clipping library, The Computer Language Benchmarks Game and the Olden Benchmark, as well as examples taken from the shape analysis literature.  

In summary, this dissertation improves upon the state-of-the-art of shape detection and reverse engineering by (i) realizing and evaluating the DSI approach, which includes contributing to DSI’s theory and results in the DSI prototype; (ii) opening up DSI for C/C++ binaries so as to extend DSI to reverse engineering, resulting in the DSIbin prototype; (iii) handling data structures with DSIbin not covered by some related work such as skip lists; (iv) refining the nesting detection and performing type merging for types excavated by Howard. Further, DSIbin’s ultimate future use case of malware analysis is hardened by revealing the presence of dynamic data structures in multiple real world malware samples. In summary, this dissertation advanced the dynamic analysis of data structure shapes with the aforementioned contributions to the DSI approach for source code and further by transferring this new technology to the analysis of binaries. The latter resulted in the additional insight that high level dynamic data structure information can help to infer low level type information. 

1. http://kotaku.com/5028197/sega-cant-find-the-source-code-for-your-favorite-old-school-arcade-games
2. https://www.av-test.org/en/statistics/malware/
3. https://github.com/torvalds/linux/blob/master/include/linux/list.h
4. SWT Research Group, University Bamberg, DFG-Project LU 1748/4-1
5. http://libusb.info/
6. https://www.gnu.org/software/bash/
7. Predator: http://www.fit.vutbr.cz/research/groups/verifit/tools/predator/
8. Forester: http://www.fit.vutbr.cz/research/groups/verifit/tools/forester/
9. http://www.cs.vu.nl/ herbertb/papers/dde\_ndss11-preprint.pdf},
  keywords = {Data structure identification; Dynamic data structures; Pointer programs; Reverse engineering; Type recovery},
  school = {Otto-Friedrich-Universität Bamberg}
}

@inproceedings{boockmann2019_50360,
  title = {Shape Inference from Memory Graphs (Extended Abstract)},
  author = {Boockmann, Jan and Lüttgen, Gerald},
  year = {2019},
  booktitle = {20. Kolloquium Programmiersprachen und Grundlagen der Programmierung KPS 2019 : Tagungsband},
  pages = {69-71},
  publisher = {Shaker Verlag},
  address = {Düren},
  isbn = {978-3-8440-6933-4},
  url = {https://fis.uni-bamberg.de/handle/uniba/50360},
  language = {eng}
}

@inproceedings{yip2019_48659,
  title = {Lightweight Semantics-Preserving Communication for Real-Time Automotive Software},
  author = {Yip, Eugene and Lalo, Erjola and Lüttgen, Gerald and Sailer, Andreas},
  year = {2019},
  booktitle = {13th IEEE International Symposium on Embedded Multicore/Many-core Systems-on-Chip (MCSoC)},
  pages = {372-379},
  publisher = {IEEE},
  isbn = {978-1-7281-4882-3},
  doi = {10.1109/MCSoC.2019.00059},
  url = {https://fis.uni-bamberg.de/handle/uniba/48659},
  language = {eng}
}

@inproceedings{girault2019_48658,
  title = {A Multi-Rate Precision Timed Programming Language for Multi-Cores},
  author = {Girault, Alain and Hili, Nicolas and Jenn, Eric and Yip, Eugene},
  year = {2019},
  booktitle = {2019 Forum for Specification and Design Languages (FDL)},
  pages = {8},
  publisher = {IEEE},
  isbn = {978-1-7281-4113-8},
  issn = {1636-9874},
  doi = {10.1109/FDL.2019.8876950},
  url = {https://fis.uni-bamberg.de/handle/uniba/48658},
  language = {eng}
}

@inproceedings{boockmann2018_50362,
  title = {Generating Inductive Shape Predicates for Runtime Checking and Formal Verification},
  author = {Boockmann, Jan and Lüttgen, Gerald and Mühlberg, Jan Tobias},
  year = {2018},
  booktitle = {Leveraging Applications of Formal Methods, Verification and Validation. Verification : 8th International Symposium, ISoLA 2018, Limassol, Cyprus, November 5-9, 2018, Proceedings, Part II},
  pages = {64-74},
  publisher = {Springer International Publishing},
  address = {Cham},
  isbn = {978-3-030-03420-7},
  doi = {10.1007/978-3-030-03421-4\_5},
  url = {https://fis.uni-bamberg.de/handle/uniba/50362},
  language = {eng}
}

@article{fendrich2018_44798,
  title = {A generalised theory of Interface Automata, component compatibility and error},
  author = {Fendrich, Sascha and Lüttgen, Gerald},
  year = {2018},
  journal = {Acta Informatica},
  volume = {56},
  number = {4},
  pages = {287-319},
  publisher = {Springer},
  address = {Berlin ; Heidelberg [u.a.]},
  issn = {1432-0525},
  doi = {10.1007/s00236-018-0319-8},
  url = {https://fis.uni-bamberg.de/handle/uniba/44798},
  language = {eng},
  abstract = {Interface theories allow system designers to reason about the composability and compatibility of concurrent system components. Such theories often extend both de Alfaro and Henzinger's Interface Automata and Larsen's Modal Transition Systems, which leads, however, to several issues that are undesirable in practice: an unintuitive treatment of specified unwanted behaviour, a binary compatibility concept that does not scale to multi-component assemblies, and compatibility guarantees that are insufficient for software product lines. In this article we show that communication mismatches are central to all these problems and, thus, the ability to represent such errors semantically is an important feature of an interface theory. Accordingly, we present the error-aware interface theory EMIA, where the above shortcomings are remedied by introducing explicit fatal error states. In addition, we prove via a Galois insertion that EMIA is a conservative generalisation of the established Modal Interface Automata theory.}
}

@inproceedings{luttgen2018_44799,
  title = {A Note on Refinement in Hierarchical Transition Systems},
  author = {Lüttgen, Gerald},
  year = {2018},
  booktitle = {Formal Methods for Industrial Critical Systems : 23rd International Conference, FMICS 2018, Maynooth, Ireland, September 3-4, 2018, Proceedings},
  pages = {211-222},
  publisher = {Springer International Publishing},
  address = {Cham},
  series = {Lecture Notes in Computer Science},
  edition = {1},
  isbn = {978-3-030-00244-2},
  doi = {10.1007/978-3-030-00244-2},
  url = {https://fis.uni-bamberg.de/handle/uniba/44799},
  language = {eng},
  abstract = {Software engineers frequently employ notations and tools based on transition systems, such as UML state machines and Statecharts, for specifying and reasoning about reactive behaviour. While these notations are typically supported by an operational semantics, they lack a formal underpinning of the incremental refinement practices of engineers who, e.g., place state machines inside states or add outer transitions to states during design. This note sketches how modal transition systems may be applied to formally capture such refinements along state hierarchies, using a hierarchical extension of labelled transition systems that permits engineers to explicitly allow or disallow state refinement and transition extension at each state. A small example testifies to the utility of this framework for hierarchically refining reactive systems.}
}

@techreport{yip2018_44463,
  title = {Optimized Buffering of Time-Triggered Automotive Software},
  author = {Yip, Eugene and Lalo, Erjola and Lüttgen, Gerald and Deubzer, Michael and Sailer, Andreas},
  year = {2018},
  publisher = {opus},
  address = {Bamberg},
  series = {Bamberger Beiträge zur Wirtschaftsinformatik und Angewandten Informatik},
  doi = {10.20378/irbo-52917},
  urn = {urn:nbn:de:bvb:473-opus4-529175},
  url = {https://fis.uni-bamberg.de/handle/uniba/44463},
  language = {eng},
  abstract = {The development of an automotive system involves the integration of many real-time software functionalities, and it is of utmost importance to guarantee strict timing requirements. However, the recent trend towards multi-core architectures poses significant challenges for the timely transfer of signals between processor cores so as to not violate data consistency. We have studied and adapted an existing buffering mechanism to work specifically for statically scheduled time-triggered systems, called static buffering protocol. We developed further buffering optimisation algorithms and heuristics, to reduce the memory consumption, processor utilisation, and end-to-end response times of time-triggered AUTOSAR designs on multi-core platforms. Our contributions are important because they enable deterministic time-triggered implementations to become competitive alternatives to their inherently non-deterministic event-triggered counterparts. We have prototyped a selection of optimisations in an industrial tool and evaluated them on realistic industrial automotive benchmarks.},
  keywords = {Real-Time Software, Logical-Execution Time, Buffering Mechanism}
}

@inproceedings{rupprecht2017_44806,
  title = {DSI: Automated detection of dynamic data structures in C programs and binary code},
  author = {Rupprecht, Thomas and Boockmann, Jan and White, David and Lüttgen, Gerald},
  editor = {Amme, Wolfram and Heinze, Thomas S.},
  year = {2017},
  booktitle = {Programmiersprachen und Grundlagen der Programmierung : 19. Kolloquium, KPS 2017 ; Weimar, 25.–27. September 2017 ; Tagungsband},
  pages = {134-147},
  publisher = {Friedrich-Schiller-Universität Jena},
  address = {Weimar},
  series = {Jenaer Schriften zur Mathematik und Informatik},
  url = {https://fis.uni-bamberg.de/handle/uniba/44806},
  language = {eng},
  abstract = {Program comprehension is an important task for software engineers who maintain legacy code, as well as for reverse engineers who analyse binary executables such as malware. Detecting dynamic, i.e., pointer-based data structures is a particular challenge due to the complex usage of pointers found in real world software.

This paper presents the key results of the DFG-funded project "Learning Data Structure Behaviour from Executions of Pointer Programs" (DSI), in which dynamic analysis techniques have been developed to identify dynamic data structures in C programs and x86 binary code. DSI's analysis utilizes a novel memory abstraction that allows for a compact description of pointer-based data structures such as linked lists and binary trees, and their interconnections such as parent-child nesting. On top of this abstraction, an evidence-collecting approach calculates a natural language description of the observed data structure with the help of a systematic taxonomy. The inferred data structure information is not only helpful for program comprehension but also for other use cases including software verification and software visualization.}
}

@inproceedings{sailer2017_43006,
  title = {Comparing trace recordings of automotive real-time software},
  author = {Sailer, Andreas and Deubzer, Michael and Lüttgen, Gerald and Mottok, Jürgen},
  year = {2017},
  booktitle = {Proceedings of the 25th International Conference on Real-Time Networks and Systems, 2017, Grenoble, France},
  pages = {118-127},
  publisher = {ACM},
  address = {New York, NY},
  isbn = {978-1-4503-5286-4},
  doi = {10.1145/3139258.3139265},
  url = {https://fis.uni-bamberg.de/handle/uniba/43006},
  language = {eng}
}

@inproceedings{rupprecht2017_42967,
  title = {DSIbin: identifying dynamic data structures in C/C++ binaries},
  author = {Rupprecht, Thomas and Chen, Xi and White, David H. and Boockmann, Jan H. and Lüttgen, Gerald and Bos, Herbert},
  year = {2017},
  booktitle = {Proceedings of the 32nd International Conference on Automated Software Engineering},
  pages = {331-341},
  publisher = {IEEE},
  address = {Urbana, IL},
  isbn = {978-1-5386-2684-9},
  doi = {10.1109/ASE.2017.8115646},
  url = {https://fis.uni-bamberg.de/handle/uniba/42967},
  language = {eng}
}

@inproceedings{kraas2017_42606,
  title = {Automated Tooling for the Evolving SDL Standard: From Metamodels to UML Profiles},
  author = {Kraas, Alexander},
  editor = {Csöndes, Tibor and Kovács, Gábor and Réthy, György},
  year = {2017},
  booktitle = {SDL 2017 : Model-Driven Engineering for Future Internet ; 18th International SDL Forum, Budapest, Hungary, October 9–11, 2017, Proceedings},
  pages = {136-156},
  publisher = {Springer International Publishing},
  address = {Cham},
  series = {Lecture Notes in Computer Science},
  isbn = {978-3-319-68015-6},
  doi = {10.1007/978-3-319-68015-6},
  url = {https://fis.uni-bamberg.de/handle/uniba/42606},
  language = {eng}
}

@phdthesis{fendrich2017_42329,
  title = {Modal Interface Theories for Specifying Component-based Systems},
  author = {Fendrich, Sascha},
  year = {2017},
  publisher = {opus},
  address = {Bamberg},
  urn = {urn:nbn:de:bvb:473-opus4-498515},
  url = {https://fis.uni-bamberg.de/handle/uniba/42329},
  language = {eng},
  abstract = {Large software systems frequently manifest as complex, concurrent, reactive systems and their correctness is often crucial for the safety of the application. Hence, modern techniques of software engineering employ incremental, component-based approaches to systems design. These are supported by interface theories which may serve as specification languages and as semantic foundations for software product lines, web-services, the internet of things, software contracts and conformance testing. Interface theories enable a systems designer to express communication requirements of components on their environments and to reason about the mutual compatibility of these requirements in order to guarantee the communication safety of the system. Further, interface theories enrich traditional operational specification theories by declarative aspects such as conjunction and disjunction, which allow one to specify systems heterogeneously.
However, substantial practical aspects of software verification are not supported by current interface theories, e.g., reusing components, adapting components to changed operational environments, reasoning about the compatibility of more than two components, modelling software product lines or tracking erroneous behaviour in safety-critical systems. The goal of this thesis is to investigate the theoretical foundations for making interface theories more practical by solving the above issues. Although partial solutions to some of these issues have been presented in the literature, none of them succeeds without sacrificing other desired features. The particular challenge of this thesis is to solve these problems simultaneously within a single interface theory. To this end, the arguably most general interface theory Modal Interface Automata (MIA) is extended, yielding the interface theory Error-preserving Modal Interface Automata (EMIA).
The above problems are addressed as follows. Quotient operators are adjoint to composition and, therefore, support component reuse. Such a quotient operator is introduced to both MIA and EMIA. It is the first one that considers nondeterministic dividends and compatibility. Alphabet extension operators for MIA and EMIA allow for the change of operational environment by permitting one to adapt system components to new interactions without breaking previously satisfied requirements. Erroneous behavior is identified as a common source of problems with respect to the compatibility of more than two components, the modelling of software product lines and erroneous behaviour in safety-critical systems. EMIA improves on previous interface theories by providing a more precise semantics with respect to erroneous behaviour based on error-preservation. The relation between error-preservation and the usual error-abstraction employed in previous interface theories is investigated, establishing a Galois insertion from MIA into EMIA that is relevant at the levels of specifications, composition operations and proofs. The practical utility of interface theories is demonstrated by providing a software implementation of MIA and EMIA that is applied to two case studies. Further, an outlook is given on the relation between type checking and refinement checking. As a proof of concept, the simple interface theory Interface Automata is extended to a behavioural type theory where type checking is a syntactic approximation of refinement checking.},
  school = {Otto-Friedrich-Universität Bamberg}
}

@article{bottoni2017_41394,
  title = {Resource-aware Policies},
  author = {Bottoni, Paolo and Fish, Andrew and Heußner, Alexander and Presicce, F. Parisi},
  year = {2017},
  journal = {Journal of Visual Languages and Computation},
  volume = {38},
  pages = {84-96},
  publisher = {Elsevier, Academic Press},
  address = {Amsterdam [u.a.]},
  issn = {1045-926X},
  doi = {10.1016/j.jvlc.2016.10.004},
  url = {https://fis.uni-bamberg.de/handle/uniba/41394},
  language = {eng}
}

@inproceedings{sailer2016_41947,
  title = {CoreTAna : A Trace Analyzer for Reverse Engineering Real-Time Software},
  author = {Sailer, Andreas and Deubzer, Michael and Lüttgen, Gerald and Mottok, Jürgen},
  year = {2016},
  booktitle = {IEEE 23rd Intl. Conf. on Software Analysis, Evolution, and Reengineering (SANER 2016)},
  pages = {657-660},
  publisher = {IEEE Computer Society},
  address = {Osaka, Japan},
  isbn = {978-1-5090-1855-0},
  doi = {10.1109/SANER.2016.36},
  url = {https://fis.uni-bamberg.de/handle/uniba/41947},
  language = {eng}
}

@inproceedings{yip2016_41458,
  title = {The ForeC Synchronous Deterministic Parallel Programming Language for Multicores},
  author = {Yip, Eugene and Girault, Alain and Roop, Partha S. and Biglari-Abhari, Morteza},
  year = {2016},
  booktitle = {IEEE 10th International Symposium on Embedded Multicore/Many-core Systems-on-Chip (MCSoC), 2016},
  pages = {297-304},
  publisher = {IEEE},
  address = {Deutschland},
  isbn = {978-1-5090-3531-1},
  doi = {10.1109/MCSoC.2016.13},
  url = {https://fis.uni-bamberg.de/handle/uniba/41458},
  language = {eng}
}

@inproceedings{heuner2016_41391,
  title = {Preface},
  author = {Heußner, Alexander and Kissinger, Aleks and Wijs, Anton},
  year = {2016},
  booktitle = {EPTCS 231: Proceedings Second : Graphs as Models Workshop ; Eindhoven, The Netherlands, April 2-3, 2016},
  publisher = {NICTA},
  address = {Sydney},
  issn = {2075-2180},
  doi = {10.4204/EPTCS.231},
  url = {https://fis.uni-bamberg.de/handle/uniba/41391},
  language = {eng}
}

@inproceedings{rupprecht2016_41377,
  title = {POSTER: Identifying Dynamic Data Structures in Malware},
  author = {Rupprecht, Thomas and Chen, Xi and White, David H. and Mühlberg, Jan Tobias and Bos, Herbert and Lüttgen, Gerald},
  year = {2016},
  booktitle = {CCS '16: Proceedings of the 2016 ACM SIGSAC Conference on Computer and Communications Security},
  pages = {1772-1774},
  publisher = {ACM},
  address = {New York, NY, USA},
  isbn = {978-1-4503-4139-4},
  doi = {10.1145/2976749.2989041},
  url = {https://fis.uni-bamberg.de/handle/uniba/41377},
  language = {eng},
  abstract = {As the complexity of malware grows, so does the necessity of employing program structuring mechanisms during development. While control flow structuring is often obfuscated, the dynamic data structures employed by the program are typically untouched. We report on work in progress that exploits this weakness to identify dynamic data structures present in malware samples for the purposes of aiding reverse engineering and constructing malware signatures, which may be employed for malware classification. Using a prototype implementation, which combines the type recovery tool Howard and the identification tool Data Structure Investigator (DSI), we analyze data structures in Carberp and AgoBot malware. Identifying their data structures illustrates a challenging problem. To tackle this, we propose a new type recovery for binaries based on machine learning, which uses Howard's types to guide the search and DSI's memory abstraction for hypothesis evaluation.}
}

@inproceedings{corrodi2016_41373,
  title = {A Graph-Based Semantics Workbench for Concurrent Asynchronous Programs},
  author = {Corrodi, Claudio and Heußner, Alexander and Poskitt, Christopher M.},
  editor = {Stevens, Perdita and Wąsowski , Andrzej},
  year = {2016},
  booktitle = {Fundamental Approaches to Software Engineering : 19th International Conference, FASE 2016, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2016, Eindhoven, The Netherlands, April 2–8, 2016, Proceedings},
  pages = {31-48},
  publisher = {Springer},
  address = {Berlin ; Heidelberg},
  series = {Lecture Notes in Computer Science},
  isbn = {978-3-662-49664-0},
  doi = {10.1007/978-3-662-49665-7\_3},
  url = {https://fis.uni-bamberg.de/handle/uniba/41373},
  language = {eng}
}

@article{bujtor2016_41366,
  title = {Nondeterministic Modal Interfaces},
  author = {Bujtor, Ferenc and Fendrich, Sascha and Lüttgen, Gerald and Vogler, Walter},
  year = {2016},
  journal = {Theoretical computer science : the journal of the EATCS},
  number = {642},
  pages = {24-53},
  publisher = {Elsevier},
  address = {Amsterdam [u.a.]},
  issn = {0304-3975},
  doi = {10.1016/j.tcs.2016.06.011},
  url = {https://fis.uni-bamberg.de/handle/uniba/41366},
  language = {eng},
  abstract = {Interface theories are employed in the component-based design of concurrent systems. They often emerge as combinations of Interface Automata (IA) and Modal Transition Systems (MTS), e.g., Nyman et al.'s IOMTS, Bauer et al.'s MIO, Raclet et al.'s MI or our MIA. In this paper, we generalise MI to interfaces, for which we properly resolve the longstanding conflict between unspecified inputs being allowed in IA but forbidden in MTS. With this solution we achieve, in contrast to related work, an associative parallel composition, a compositional preorder, a conjunction on interfaces with dissimilar alphabets supporting perspective-based specifications, and a quotienting operator for decomposing nondeterministic specifications in a single theory. In addition, we define a hiding and a restriction operator, complement conjunction with a disjunction operator and illustrate our interface theory by means of a simple example.}
}

@inproceedings{white2016_41314,
  title = {DSI : an evidence-based approach to identify dynamic data structures in C programs},
  author = {White, David H. and Rupprecht, Thomas and Lüttgen, Gerald},
  year = {2016},
  booktitle = {ISSTA 2016: Proceedings of the 25th International Symposium on Software Testing and Analysis},
  pages = {259-269},
  publisher = {ACM},
  address = {New York, NY},
  isbn = {978-1-4503-4390-9},
  doi = {10.1145/2931037.2931071},
  url = {https://fis.uni-bamberg.de/handle/uniba/41314},
  language = {eng}
}

@inproceedings{fendrich2016_41243,
  title = {A Generalised Theory of Interface Automata, Component Compatibility and Error},
  author = {Fendrich, Sascha and Lüttgen, Gerald},
  editor = {Ábrahám, Erika and Huisman, Marieke},
  year = {2016},
  booktitle = {Integrated formal methods : 12th International Conference, IFM 2016, Reykjavik, Iceland, June 1-5, 2016: proceedings},
  pages = {160-175},
  publisher = {Springer},
  address = {Cham},
  series = {Lecture Notes in Computer Science},
  isbn = {978-3-319-33692-3},
  doi = {10.1007/978-3-319-33693-0\_11},
  url = {https://fis.uni-bamberg.de/handle/uniba/41243},
  language = {eng}
}

@misc{fendrich2016_40287,
  title = {A Generalised Theory of Interface Automata, Component Compatibility and Error},
  author = {Fendrich, Sascha and Lüttgen, Gerald},
  year = {2016},
  publisher = {opus},
  address = {Bamberg},
  series = {Bamberger Beiträge zur Wirtschaftsinformatik und Angewandten Informatik},
  urn = {urn:nbn:de:bvb:473-opus4-464051},
  url = {https://fis.uni-bamberg.de/handle/uniba/40287},
  language = {eng},
  abstract = {Interface theories allow systems designers to reason about the composability and compatibility of concurrent system components. Such theories often extend both de Alfaro and Henzinger’s Interface Automata and Larsen’s Modal Transition Systems, which leads, however, to several issues that are undesirable in practice: an unintuitive treatment of specified unwanted behaviour, a binary compatibility concept that does not scale to multi-component assemblies, and compatibility guarantees that are insufficient for software product lines.
In this paper we show that communication mismatches are central to all these problems and, thus, the ability to represent such errors semantically is an important feature of an interface theory. Accordingly, we present the error-aware interface theory EMIA, where the above shortcomings are remedied by introducing explicit fatal error states. In addition, we prove via a Galois insertion that EMIA is a conservative generalisation of the established MIA (Modal Interface Automata) theory.},
  keywords = {Interface Automata, Modal Transition Systems, Component-based Design, Concurrency, Error States}
}

@inproceedings{muhlberg2015_41306,
  title = {Learning assertions to verify linked-list programs},
  author = {Mühlberg, Jan Tobias and White, David H. and Dodds, Mike and Lüttgen, Gerald and Piessens, Frank},
  editor = {Calinescu, Radu and Rumpe , Bernhard},
  year = {2015},
  booktitle = {Software Engineering and Formal Methods : 13th International Conference, SEFM 2015, York, UK, September 7-11, 2015 ; Proceedings},
  pages = {37-52},
  publisher = {Springer},
  address = {Berlin ; Heidelberg [u.a.]},
  series = {Lecture Notes in Computer Science},
  isbn = {978-3-319-22968-3},
  doi = {10.1007/978-3-319-22969-0\_3},
  url = {https://fis.uni-bamberg.de/handle/uniba/41306},
  language = {eng}
}

@article{luttgen2015_21974,
  title = {Richer interface automata with optimistic and pessimistic compatibility},
  author = {Lüttgen, Gerald and Vogler, Walter and Fendrich, Sascha},
  year = {2015},
  journal = {Acta Informatica},
  volume = {52},
  number = {4/5},
  pages = {305-336},
  publisher = {Springer},
  address = {Heidelberg [u.a.]},
  issn = {1432-0525},
  doi = {10.1007/s00236-014-0211-0},
  url = {https://fis.uni-bamberg.de/handle/uniba/21974},
  language = {eng},
  abstract = {Modal transition systems are a popular semantic underpinning of interface theories, such as Nyman et al.’s IOMTS and Bauer et al.’s MIO, which facilitate component-based reasoning for concurrent systems. Our interface theory MIA repaired a compositional flaw of IOMTS-refinement and introduced a conjunction operator. In this paper, we first modify MIA to properly deal with internal computations including internal must-transitions, which were largely ignored already in IOMTS. We then study a MIA variant that adopts MIO’s pessimistic—rather than IOMTS’ optimistic—view on component compatibility and define, for the first-time in a pessimistic, non-deterministic setting, conjunction and disjunction on interfaces. For both the optimistic and pessimistic MIA variant, we also discuss mechanisms for extending alphabets when refining interfaces, which is a desired feature for perspective-based specification. We illustrate our advancements via a small example.}
}

@inproceedings{bujtor2015_21930,
  title = {Nondeterministic Modal Interfaces},
  author = {Bujtor, Ferenc and Fendrich, Sascha and Lüttgen, Gerald and Vogler, Walter},
  year = {2015},
  booktitle = {SOFSEM 2015: theory and practice of computer science 41th International Conference on Current Trends in Theory and Practice of Computer Science, Pec pod Sněžkou, Czech Republic, January 24 - 29, 2015 ; proceedings},
  pages = {152-163},
  publisher = {Springer},
  address = {Heidelberg [u.a.]},
  series = {Lecture Notes in Computer Science},
  isbn = {978-3-662-46078-8},
  doi = {10.1007/978-3-662-46078-8\_13},
  url = {https://fis.uni-bamberg.de/handle/uniba/21930},
  language = {eng},
  abstract = {Interface theories are employed in the component-based design of concurrent systems. They often emerge as combinations of Interface Automata (IA) and Modal Transition Systems (MTS), e.g., Nyman et al.’s IOMTS, Bauer et al.’s MIO, Raclet et al.’s MI or our MIA. In this paper, we generalise MI to nondeterministic interfaces, for which we resolve the longstanding conflict between unspecified inputs being allowed in IA but forbidden in MTS. With this solution we achieve, in contrast to related work, an associative parallel composition, a compositional preorder, a conjunction on interfaces with dissimilar alphabets supporting perspective-based specifications, and a quotienting operator for decomposing nondeterministic specifications in a single theory.}
}

@article{muhlberg2014_21904,
  title = {Symbolic object code analysis},
  author = {Mühlberg, Jan Tobias and Lüttgen, Gerald},
  year = {2014},
  journal = {International Journal on Software Tools for Technology Transfer},
  volume = {16},
  number = {1},
  pages = {81-102},
  publisher = {Springer},
  address = {Berlin Heidelberg},
  issn = {1433-2787},
  doi = {10.1007/s10009-012-0256-8},
  url = {https://fis.uni-bamberg.de/handle/uniba/21904},
  language = {eng}
}

@inproceedings{luttgen2014_21865,
  title = {Automated Verification of Critical Systems},
  author = {Lüttgen, Gerald and Merz, Stephan},
  year = {2014},
  number = {96 (2014), 3, Special issue on Automated Verification of Critical Systems (AVoCS'12)},
  pages = {277-278},
  publisher = {Elsevier Science},
  address = {Amsterdam [u.a.]},
  doi = {10.1016/j.scico.2014.03.008},
  url = {https://fis.uni-bamberg.de/handle/uniba/21865},
  language = {eng}
}

@inproceedings{white2013_2581,
  title = {Identifying Dynamic Data Structures by Learning Evolving Patterns in Memory},
  author = {White, David and Lüttgen, Gerald},
  editor = {Piterman, Nir},
  year = {2013},
  booktitle = {Tools and algorithms for the construction and analysis of systems : 19th international conference,  TACAS 2013, held as part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2013, Rome, Italy, March 16 - 24, 2013 ; proceedings},
  pages = {354-369},
  publisher = {Springer},
  address = {Berlin},
  series = {Lecture notes in computer science},
  isbn = {978-3-642-36741-0},
  doi = {10.1007/978-3-642-36742-7\_25},
  url = {https://fis.uni-bamberg.de/handle/uniba/2581},
  language = {eng}
}

@article{luttgen2013_2535,
  title = {Modal Interface Automata},
  author = {Lüttgen, Gerald and Vogler, Walter},
  year = {2013},
  journal = {Logical Methods in Computer Science : LMCS},
  volume = {9},
  number = {3},
  pages = {1-28},
  address = {Braunschweig},
  issn = {1860-5974},
  doi = {10.2168/LMCS-9(3:4)2013},
  url = {https://fis.uni-bamberg.de/handle/uniba/2535},
  language = {eng}
}

@inproceedings{geeraerts2013_2539,
  title = {ω-Petri Nets},
  author = {Geeraerts, Gilles and Heußner, Alexander and Praveen, M. and Raskin, Jean-François},
  editor = {Colom, José-Manuel and Desel, Jörg},
  year = {2013},
  booktitle = {Application and Theory of Petri Nets and Concurrency : 34th International Conference, PETRI NETS 2013, Milan, Italy, June 2013 ; Proceedings},
  pages = {49-69},
  publisher = {Springer},
  address = {Heidelberg},
  series = {Lecture Notes in Computer Science},
  isbn = {978-3-642-38696-1},
  doi = {10.1007/978-3-642-38697-8\_4},
  url = {https://fis.uni-bamberg.de/handle/uniba/2539},
  language = {eng}
}

@inproceedings{geeraerts2013_2547,
  title = {Queue-Dispatch Asynchronous Systems},
  author = {Geeraerts, Gilles and Heußner, Alexander and Raskin, Jean-François},
  year = {2013},
  booktitle = {ACSD '13: Proceedings of the 2013 13th International Conference on Application of Concurrency to System Design},
  pages = {150-159},
  publisher = {IEEE Computer Society},
  address = {Washington, DC, USA},
  isbn = {978-0-7695-5035-0},
  doi = {10.1109/ACSD.2013.18},
  url = {https://fis.uni-bamberg.de/handle/uniba/2547},
  language = {eng}
}

@inproceedings{heuner2013_2528,
  title = {Reachability in Higher-Order-Counters},
  author = {Heußner, Alexander and Kartzow, Alexander},
  editor = {Krishnendu, Chatterjee and Sgall, Jiri},
  year = {2013},
  booktitle = {Mathematical Foundations of Computer Science 2013 : 38th International Symposium, MFCS 2013; Klosterneuburg, Austria, August 26-30, 2013 ; Proceedings},
  pages = {528-539},
  publisher = {Springer},
  address = {Berlin, Heidelberg},
  series = {Lecture Notes in Computer Science},
  isbn = {978-3-642-40312-5},
  doi = {10.1007/978-3-642-40313-2\_47},
  url = {https://fis.uni-bamberg.de/handle/uniba/2528},
  language = {eng}
}

@inproceedings{heuner2012_986,
  title = {Safety Verification of Communicating One-Counter Machines},
  author = {Heußner, Alexander and Le Gall, Tristan and Sutre, Grégoire},
  year = {2012},
  booktitle = {IARCS Annual Conference on Foundations of Software Technology and Theoretical Computer Science (FSTTCS 2012)},
  pages = {224-235},
  address = {Wadern},
  series = {LIPIcs - Leibniz International Proceedings in Informatics},
  isbn = {978-3-939897-47-7},
  url = {https://fis.uni-bamberg.de/handle/uniba/986},
  language = {eng}
}

@inproceedings{ditter2012_858,
  title = {On Parallel Software Verification Using Boolean Equation Systems},
  author = {Ditter, Alexander and Češka,  Milan and Lüttgen, Gerald},
  editor = {Donaldson, Alastair},
  year = {2012},
  booktitle = {Model checking software : 19th international workshop, SPIN 2012, Oxford, UK, July 23 - 24, 2012 ; proceedings},
  pages = {80-97},
  publisher = {Springer},
  address = {Berlin [u.a.]},
  series = {Lecture Notes in Computer Science},
  isbn = {978-3-642-31758-3},
  doi = {10.1007/978-3-642-31759-0\_8},
  url = {https://fis.uni-bamberg.de/handle/uniba/858},
  language = {eng}
}

@inproceedings{siirtola2012_839,
  title = {Introducing Fairness into Compositional Verification via Unidirectional Counters},
  author = {Siirtola, Antti and Puhakka, Antti and Lüttgen, Gerald},
  year = {2012},
  booktitle = {Proceedings, 2012 12th International Conference on Application of Concurrency to System Design : ACSD 2012 : 27-29 June 2012, Hamburg, Germany.},
  pages = {32-41},
  address = {Hamburg},
  isbn = {978-0-7695-4709-1},
  url = {https://fis.uni-bamberg.de/handle/uniba/839},
  language = {eng}
}

@inproceedings{luttgen2012_840,
  title = {Modal Interface Automata},
  author = {Lüttgen, Gerald and Vogler, Walter},
  editor = {Baeten, Josephus C. M.},
  year = {2012},
  booktitle = {Theoretical computer science : 7th IFIP TC1/WG2.2 international conference, TCS 2012 : Amsterdam, The Netherlands, September 2012 : proceedings},
  pages = {265-279},
  publisher = {Springer},
  address = {Berlin [u.a.]},
  series = {Lecture Notes in Computer Science},
  isbn = {978-3-642-33474-0},
  issn = {0302-9743},
  doi = {10.1007/978-3-642-33475-7\_19},
  url = {https://fis.uni-bamberg.de/handle/uniba/840},
  language = {eng}
}

@article{muhlberg2012_835,
  title = {Symbolic object code analysis},
  author = {Mühlberg, Jan Tobias and Lüttgen, Gerald},
  year = {2012},
  journal = {International journal on software tools for technology transfer : STTT},
  publisher = {Springer},
  address = {Berlin ; Heidelberg},
  issn = {1433-2779},
  url = {https://fis.uni-bamberg.de/handle/uniba/835},
  language = {eng}
}

@article{muhlberg2012_829,
  title = {Verifying compiled file system code},
  author = {Mühlberg, Jan Tobias and Lüttgen, Gerald},
  year = {2012},
  journal = {Formal Aspects of Computing : the international journal of formal methods},
  volume = {24},
  number = {3},
  pages = {375-391},
  publisher = {Springer},
  address = {London ; Berlin},
  issn = {0934-5043},
  doi = {10.1007/s00165-011-0198-z},
  url = {https://fis.uni-bamberg.de/handle/uniba/829},
  language = {eng}
}

@article{ezekiel2011_3252,
  title = {To Parallelize or to Optimize?},
  author = {Ezekiel, Jonathan and Lüttgen, Gerald and Siminiceanu, Radu},
  year = {2011},
  journal = {Journal of Logic and Computation},
  volume = {21},
  number = {1},
  pages = {85 - 120},
  issn = {0955-792X},
  url = {https://fis.uni-bamberg.de/handle/uniba/3252},
  language = {eng}
}

@article{luttgen2010_3920,
  title = {Ready simulation for concurrency: It's logical!star, open},
  author = {Lüttgen, Gerald and Vogler, Walter},
  year = {2010},
  journal = {Information and computation},
  volume = {208},
  number = {7},
  pages = {845-867},
  issn = {0890-5401},
  url = {https://fis.uni-bamberg.de/handle/uniba/3920},
  language = {eng}
}

@inproceedings{fecher2010_3884,
  title = {On the expressiveness of refinement settings},
  author = {Fecher, Harald and Frutos-Escrig, David de and Lüttgen, Gerald and Schmidt, Heiko},
  year = {2010},
  booktitle = {Fundamentals of software engineering : third IPM international conference, FSEN 2009, Kish Island, Iran, April 15 - 17, 2009 ; revised selected papers},
  pages = {276 - 291},
  address = {Berlin u.a.},
  isbn = {978-3-642-11622-3},
  url = {https://fis.uni-bamberg.de/handle/uniba/3884},
  language = {eng}
}

@inproceedings{muhlberg2010_3886,
  title = {Symbolic Object Code Analysis},
  author = {Mühlberg, Jan Tobias and Lüttgen, Gerald},
  year = {2010},
  booktitle = {Model checking software : 17th International SPIN workshop, Enschede, The Netherlands, September 27-29, 2010 ; proceedings},
  pages = {4 - 21},
  address = {Berlin u.a.},
  series = {Lecture Notes in Computer Science},
  url = {https://fis.uni-bamberg.de/handle/uniba/3886},
  language = {eng}
}

@incollection{roever2010_3847,
  title = {What is in a Step: New Perspectives on a Classical Question},
  author = {Roever, Willem-Paul de and Lüttgen, Gerald and Mendler, Michael},
  year = {2010},
  booktitle = {Time for verification : essays in memory of Amir Pnueli},
  pages = {370 - 399},
  address = {Berlin u.a.},
  isbn = {9783642137532},
  url = {https://fis.uni-bamberg.de/handle/uniba/3847},
  language = {eng}
}

@inproceedings{mendler2010_3806,
  title = {Is observational congruence on µ-expressions axiomatisable in equational horn logic?},
  author = {Mendler, Michael and Lüttgen, Gerald},
  year = {2010},
  volume = {208},
  number = {6 = Special Issue: 18th International Conference on Concurrency Theory (CONCUR 2007)},
  pages = {634 - 651},
  url = {https://fis.uni-bamberg.de/handle/uniba/3806},
  language = {eng}
}

@article{white2010_2607,
  title = {Generative Models for Chemical Structures},
  author = {White, David and Wilson, Richard C.},
  year = {2010},
  journal = {Journal of chemical information and modeling},
  volume = {50},
  number = {7},
  pages = {1257-1274},
  publisher = {American Chemical Society},
  address = {Washington, DC,},
  issn = {1549-960X},
  doi = {10.1021/ci9004089},
  url = {https://fis.uni-bamberg.de/handle/uniba/2607},
  language = {eng}
}

@misc{muhlberg2010_194,
  title = {Symbolic Object Code Analysis},
  author = {Mühlberg, Jan Tobias and Lüttgen, Gerald},
  year = {2010},
  publisher = {opus},
  address = {Bamberg},
  series = {Bamberger Beiträge zur Wirtschaftsinformatik und Angewandten Informatik},
  urn = {urn:nbn:de:bvb:473-opus-2364},
  url = {https://fis.uni-bamberg.de/handle/uniba/194},
  language = {eng},
  abstract = {Current software model checkers quickly reach their limit when being applied to verifying pointer safety properties in source code that includes function pointers and inlined assembly. This paper introduces an alternative technique for checking pointer safety violations, called Symbolic Object Code Analysis (SOCA), which is based on bounded symbolic execution, incorporates path-sensitive slicing, and employs the SMT solver Yices as its execution and verification engine. Extensive experimental results of a prototypic SOCA Verifier, using the Verisec suite and almost 10,000 Linux device driver functions as benchmarks, show that SOCA performs competitively to current source-code model checkers and that it also scales well when applied to real operating systems code and pointer safety issues. SOCA effectively explores semantic niches of software that current software verifiers do not reach.},
  keywords = {bounded model checking , symbolic execution , program slicing , object code analysis , linux device drivers, bounded model checking, symbolic execution, program slicing, object code analysis, linux device drivers}
}

@inproceedings{muhlberg2009_20148,
  title = {Verifying compiled file system code},
  author = {Mühlberg, Jan Tobias and Lüttgen, Gerald},
  year = {2009},
  booktitle = {Formal methods: foundations and applications : 12th Brazilian Symposium on Formal Methods, SBMF 2009 Gramado, Brazil, August 19- 21, 2009 ; revised selected papers},
  pages = {306 - 320},
  address = {Berlin u.a.},
  isbn = {978-3-642-10452-7},
  url = {https://fis.uni-bamberg.de/handle/uniba/20148},
  language = {eng}
}

@inproceedings{mendler2007_18098,
  title = {Is observational congruence axiomatisable in equational horn logic?},
  author = {Mendler, Michael and Lüttgen, Gerald},
  year = {2007},
  booktitle = {CONCUR 2007 - concurrency theory : 18th international conference, CONCUR 2007, Lisbon, Portugal, September 3-8, 2007 ; proceedings},
  pages = {197 - 211},
  address = {Berlin u.a.},
  series = {Lecture notes in computer science},
  doi = {10.1007/978-3-540-74407-8},
  url = {https://fis.uni-bamberg.de/handle/uniba/18098},
  language = {eng}
}

@book{mendler2007_15376,
  title = {Is observational congruence on µ-expressions axiomatisable in equational horn logic?},
  author = {Mendler, Michael and Lüttgen, Gerald},
  year = {2007},
  address = {Bamberg},
  series = {Bamberger Beiträge zur Wirtschaftsinformatik und Angewandten Informatik},
  url = {https://fis.uni-bamberg.de/handle/uniba/15376},
  language = {eng}
}

@inproceedings{luttgen2005_12909,
  title = {Proceedings of the Second Workshop on Semantic Foundations of Engineering Design Languages (SFEDL 2004)},
  author = {Lüttgen, Gerald and Mendler, Michael},
  year = {2005},
  volume = {115},
  pages = {1 - 97},
  issn = {0304-3975},
  url = {https://fis.uni-bamberg.de/handle/uniba/12909},
  language = {eng}
}

@inproceedings{luttgen2004_15256,
  title = {Semantic foundations of engineering design languages :  SFEDL 2004 ; satellite workshop to the seventh European Joint Conferences on Theory and Practice of Software (ETAPS 2004), Barcelona, Spain, April 3, 2004 ; proceedings},
  author = {Lüttgen, Gerald and Martínez Madrid, Natividad and Mendler, Michael},
  year = {2004},
  address = {Bamberg},
  url = {https://fis.uni-bamberg.de/handle/uniba/15256},
  language = {eng}
}

@article{broy2004_13594,
  title = {Editorial: Semantic Foundations of Engineering Design Languages},
  author = {Broy, Manfred and Lüttgen, Gerald and Mendler, Michael},
  year = {2004},
  journal = {Formal aspects of computing : the internat. journal of formal methods},
  volume = {16},
  number = {3 = Special issue},
  pages = {165},
  issn = {0934-5043},
  url = {https://fis.uni-bamberg.de/handle/uniba/13594},
  language = {eng}
}

@inproceedings{broy2003_13602,
  title = {Editorial: Where theory and practice meet},
  author = {Broy, Manfred and Lüttgen, Gerald and Mendler, Michael},
  year = {2003},
  volume = {15},
  number = {4 = Special Issue: Where theory and practice meet},
  pages = {297 - 298},
  url = {https://fis.uni-bamberg.de/handle/uniba/13602},
  language = {eng}
}

@inproceedings{norton2003_9771,
  title = {A compositional semantic theory for synchronous component-based design},
  author = {Norton, B. and Mendler, Michael and Lüttgen, Gerald},
  year = {2003},
  booktitle = {CONCUR 2003 - concurrency theory : 14th International Conference, Marseille, France, September 3 - 5, 2003 ; proceedings},
  pages = {461 - 476},
  address = {Berlin},
  series = {Lecture notes in computer science},
  url = {https://fis.uni-bamberg.de/handle/uniba/9771},
  language = {eng}
}

@inproceedings{luttgen2003_9775,
  title = {Statecharts: from visual syntax to model-theoretic semantics},
  author = {Lüttgen, Gerald and Mendler, Michael},
  year = {2003},
  booktitle = {Wirtschaft und Wissenschaft in der network economy - Visionen und Wirklichkeit : Tagungsband der GI/OCG Jahrestagung 2001, 25. - 28. September 2001, Universität Wien},
  pages = {615 - 621},
  address = {Wien},
  series = {Books@ocg.at},
  url = {https://fis.uni-bamberg.de/handle/uniba/9775},
  language = {eng}
}

@inproceedings{luttgen2002_10081,
  title = {Towards a model-theory for Esterel},
  author = {Lüttgen, Gerald and Mendler, Michael},
  year = {2002},
  volume = {65},
  number = {5 = SLAP'2002 Synchronous Languages, Applications, and Programming, Grenoble, France, April 13, 2002},
  issn = {0304-3975},
  url = {https://fis.uni-bamberg.de/handle/uniba/10081},
  language = {eng}
}

@inproceedings{luttgen2002_9824,
  title = {Axiomatizing an algebra of step reactions for synchronous languages},
  author = {Lüttgen, Gerald and Mendler, Michael},
  year = {2002},
  booktitle = {CONCUR 2002 - Concurrency theory : 13th international conference, Brno, Czech Republic, August 20 - 23, 2002 ; proceedings},
  pages = {386 - 401},
  address = {Berlin u.a.},
  series = {Lecture notes in computer science},
  url = {https://fis.uni-bamberg.de/handle/uniba/9824},
  language = {eng}
}

@article{luttgen2002_9778,
  title = {The intuitionism behind statecharts steps},
  author = {Lüttgen, Gerald and Mendler, Michael},
  year = {2002},
  journal = {ACM transactions on computational logic : TOCL},
  volume = {3},
  number = {1},
  pages = {1 - 41},
  issn = {1529-3785},
  doi = {10.1145/504077.504078},
  url = {https://fis.uni-bamberg.de/handle/uniba/9778},
  language = {eng}
}

