The advent of strong generative AI has a considerable impact on various software engineering tasks such as code repair, test generation, or language translation. While tools like GitHub Copilot are already in widespread use in interactive settings, automated approaches require a higher level of reliability before being usable in industrial practice. In this paper, we focus on three aspects that directly influence the quality of the results: a) the effect of automated feedback loops, b) the choice of Large Language Model (LLM), and c) the influence of behavior-preserving code changes. We study the effect of these three variables on an automated C-to-Rust translation system. Code translation from C to Rust is an attractive use case in industry due to Rust's safety guarantees. The translation system is based on a generate-and-check pattern, in which Rust code generated by the LLM is automatically checked for compilability and behavioral equivalence with the original C code. For negative checking results, the LLM is re-prompted in a feedback loop to repair its output. These checks also allow us to evaluate and compare the respective success rates of the translation system when varying the three variables. Our results show that without feedback loops LLM selection has a large effect on translation success. However, when the translation system uses feedback loops the differences across models diminish. We observe this for the average performance of the system as well as its robustness under code perturbations. Finally, we also identify that diversity provided by code perturbations can even result in improved system performance.

Program understanding is a prerequisite for several software activities, such as maintenance, evolution, and reengineering. Code in itself is so detailed that it is often hard to understand. More abstract models describing its behaviour may ease program understanding. Manually building understandable abstractions from complex source code - as an explicit or just mental model - requires in-depth analysis of the code in the first place. Therefore, it is a time-consuming and tedious activity for developers. Model mining can support program comprehension by semi-automatically extracting high-level models from code. One helpful model is a state machine, which is an established formalism for specifying the behaviour of a software component. In this paper, we report on a controlled experiment that investigates the question: Do semi-automatically extracted state machines make understanding of complex embedded code more effective? The experiment was conducted with 30 participants on two industrial embedded C code functions. The results show that the share of correct answers increases and the required time to solve the tasks decreases significantly when extracted state machines are available. We conclude that mined state machines do in fact help in program understanding.

The extraction of state machines from complex software systems can be very useful to understand the behavior of a software, which is a prerequisite for other software activities, such as maintenance, evolution and reengineering. However, using static analysis to extract state machines from real-world embedded software often leads to models that cannot be understood by humans: The extracted models contain a high number of states and transitions and very complex guards (transition conditions). Integrating user interaction into the extraction process can reduce these state machines to an acceptable size. However, the problem of highly complex guards remains. In this paper, we present a novel approach to reduce the complexity of guards in such state machines to a degree that is understandable for humans. The conditions are reduced by a combination of heuristic logic minimization, masking of infeasible paths, and using transition priorities. The approach is evaluated with software developers on industrial embedded C code. The results show that the approach is highly effective in making the guards understandable. Our controlled experiment shows that guards reduced by our approach and presented with priorities are easier to understand than guards without priorities.

The development of software-intensive systems, such as automotive systems, is becoming more and more complex. To cope with this complexity, the developers use several modelling formalisms and languages to describe the same system from different viewpoints at multiple levels of abstraction. The used heterogeneous models can share common semantics and are usually separately developed and reused in different projects. This poses a challenge to the developer to keep them consistent along the development process.

Program understanding is a time-consuming and tedious activity for software developers. Manually building abstractions from source code requires in-depth analysis of the code in the first place. Model mining can support program comprehension by semi-automatically extracting high-level models from code. One potentially helpful model is a state machine, which is an established formalism for specifying the behavior of a software component. There exist only few approaches for state machine mining, and they either deal with object-oriented systems or expect specific state implementation patterns. Both preconditions are usually not met by real-world embedded control software written in procedural languages. Other approaches extract only API protocols instead of the component's behavior. In this paper, we propose and evaluate several techniques that enable state machine mining from embedded control code: 1) We define criteria for state variables in procedural code based on an empirical study. This enables adaptation of an existing approach for extracting state machines from object-oriented software to embedded control code. 2) We present a refinement of the transition extraction process of that approach by removing infeasible transitions, which on average leads to more than 50% reduction of the number of transitions. 3) We evaluate two approaches to reduce the complexity of transition conditions. 4) An empirical study examines the limits of transition conditions' complexity that can still be understood by humans. These techniques and studies constitute major building blocks towards mining understandable state machines from embedded control software.

High-level design models are often used for describing the behavior or structure of a software system. It is generally much easier and more adequate to understand a software system on this level than on the level of individual code lines. Such models are also created by developers as they gain an understanding of the software. Unfortunately, these models often do not correspond to what is really in the code. Murphy et al. introduced the idea of reflexion models in 1995 to overcome this problem. Their approach is today widely used for architecture conformance checking and reconstruction. In this paper, we introduce reflexion models for state machines. Our approach allows to check the correspondence of a hypothetical state machine model with the code. It returns information about convergence, partial convergence, divergence, or absence of the specified states and transitions. Similar to the original reflexion model, the approach can be used for conformance checking as well as interactive reverse engineering of state machine models. We concentrate on the latter and show the potential of the approach in several case studies.

Model based approaches are widely used to develop today's automotive software systems. They promise to reduce development effort by raising the level of abstraction and making the software better accessible to domain experts. On the other hand, the same effects as for classical code occur: Complexity inevitably increases over time, and models become hard to understand. This is where software analysis can help. Other use cases of software analysis, like test case generation or quality assurance, are of similar importance. Unfortunately, only limited support by analysis tools is available on model level - mainly because each modeling language is different and would require a specific analysis tool. Analyzing the generated code is also not an option, because that code can be arbitrarily far away from the models. We introduce an abstract model interpreter as a way to get out of this situation. It exploits the specialties of automotive embedded software and allows efficient realization of a whole class of software analyses on the model level. In this paper, we introduce the ideas of the interpreter and describe some of its real-world use cases for software maintenance and calibration.

Abstract interpretation, symbolic execution, concolic testing and other techniques all require interpretation of a program. They all share common requirements for the interpreter, but also have their specialties. In this paper, we present a pragmatic interpreter framework that allows easy realization of all these use cases. This is possible because the interpreter supports arbitrary abstractions and strategies for the varying decisions that have to be considered for different analyses. Furthermore, since the interpreter works on an abstraction of the program, it is applicable for multiple input languages as well as models from model-based development. In this paper, we describe the design of the interpreter and demonstrate how easy it can be adapted to several analyses.

The fact that software ages holds for embedded automotive software as well as for any other kind of software. In comparison to IT software, the automotive domain has to deal with different kinds of requirements, such as real time properties, feedback control, and constrained resources. Therefore, used programming languages are C - to meet resource constraints - and data flow oriented graphical languages - to meet the used engineering method and notation of feedback control engineers. This makes the software quite different from what the software maintenance and reengineering community is usually working on, and their results are seldom directly applicable. In this paper, we describe results of a Bosch-internal research project that focused on the adaption of existing reengineering techniques and methods to embedded automotive software development. The goal was to make software maintenance more efficient by a) preventing software ageing and b) supporting program comprehension. Our approach was to make existing reengineering techniques usable for series development in an effective and efficient way. The result is a set of reengineering tools and practices that are specialized for the needs of the automotive domain and usable in practice.

The Industrial Program Comprehension Challenge is a two-year-old track of the International Conference on Program Comprehension that provides a venue for researchers and industrial practitioners to communicate about new research directions that can help address real world problems. This year, 2011, a scenario-based challenge was created to inspire researchers to apply the best "archaeological" techniques for understanding the complexity of industrial software, and foster appreciation for the delicate "anthropological" scenario which drives the behavior of the software engineers, management, and customers. Participants had two months to work on the challenge and submit write-ups of their solutions. Acceptable submissions were exhibited as posters, while the best solutions were presented during the Industrial Challenge conference session. This new challenge format gives researchers the opportunity to present their novel techniques, tools and ideas to the community.

Using automatic program analysis techniques for extracting architectural information and its visualization is widely considered useful for program understanding. However, it has to be empirically validated if a given technique is beneficial in practice. This is usually done by performing a set of case studies. To find out for sure whether a technique really has any effect, controlled experiments have to be conducted. Dynamic object process graphs are one such technique. These graphs describe the control flow of an application from the perspective of a single object. In previous research, we conducted case studies which indicated that they may be useful for program understanding, but this assumption has not been validated so far. We report on a controlled experiment which investigated this question: Does the availability of such graphs support program understanding or not? We describe the research questions that were investigated, the hypotheses, experimental setup, conduction, and discuss the results and lessons learned.

Feature location aims at locating pieces of code that implement a given set of features (requirements). It is a necessary first step in every program comprehension and maintenance task if the connection between features and code has been lost.We have developed a semi-automatic technique for feature location using a combination of static and dynamic program analysis. Formal concept analysis is used to explore the results of the dynamic analysis.We describe new experiences with our technique. Specifically, we investigate the gain of information and increase of costs when the system under analysis is profiled at basic block level rather than routine level as in our earlier work. Furthermore, we explore the influence of the scenarios used for the dynamic analysis (minimal versus combined scenarios).