Due to hardware-software co-development in embedded systems, continuous integration (CI) builds frequently fail because of complex cross-compilation, board configurations, and toolchain constraints. Although CI build logs contain valuable diagnostic information, they are short-lived and difficult to reuse due to heterogeneous runners, toolchains, and log formats. To address these challenges, we present PhantomRun, a unified abstraction layer and publicly reusable dataset that standardizes the retrieval, storage, and reproduction of CI build logs and metadata. Across 4628 failing CI runs, we reconstructed 91.8 PhantomRun provides two core capabilities: retrieving the build log of any commit and faithfully re-executing the corresponding build in a controlled environment. By exposing all build artifacts and metadata in a uniform, machine-readable format, PhantomRun enables reproducible and longitudinal studies of CI failures. An empirical evaluation shows that reproduced builds closely match their originals, typically differing only in timestamps or minor nondeterministic reordering, demonstrating the feasibility of large-scale historical CI reconstruction.

As IEEE Software celebrates its 42nd year, it is hard not to think of the book The Hitchhiker’s Guide to the Galaxy by Douglas Adams, where the supercomputer had the answer 42 of “life, universe and everything” but forgot the question. As with any company, government, industry, university, organization, institution, or research funding agency that I have worked with, there has always been a need to measure success, the progress, and the impact, beyond its sales. The answer always being 42 (the correct answer) as most (managers) are aiming to show (good) results, receive bonuses, and please the organization.

Continuous Integration (CI) pipelines for embedded software sometimes fail during compilation, consuming significant developer time for debugging. We study four major open-source embedded system projects, spanning over 4000 build failures from the project's CI runs. We find that hardware dependencies account for the majority of compilation failures, followed by syntax errors and build-script issues. Most repairs need relatively small changes, making automated repair potentially suitable as long as the diverse setups and lack of test data can be handled. In this paper, we present PhantomRun, an automated framework that leverages large language models (LLMs) to generate and validate fixes for CI compilation failures. The framework addresses the challenge of diverse build infrastructures and tool chains across embedded system projects by providing an adaptation layer for GitHub Actions and GitLab CI and four different build systems. PhantomRun utilizes build logs, source code, historical fixes, and compiler error messages to synthesize fixes using LLMs. Our evaluations show that PhantomRun successfully repairs up to 45

The evolution of AI-supported code generation has taken a major step, where focus on specification and verification is the main skill shift happening from coding as industry is creating intelligent agents solving specific tasks in our software.

The use of large language models (LLMs) is being explored for a multitude of tasks in software engineering (SE), ranging from code generation to bug report assignment. Although LLMs provide impressive results, they require more time and energy than some other machine learning models. For some tasks, simpler models may be more sustainable than LLMs. In this paper, we construct natural language classifiers of different complexity for a use case in the SE domain: commit message classification. We compare the performance of each model with the state-of-the-art with regard to energy consumption for training and inference. We find that simpler models based on Naïve Bayes and LSTM perform similarly to LLMs, while using a fraction of the energy, suggesting that choosing a small model can lead to significant reduction in power usage without compromising performance. Replication package: https://doi.org/10.5281/zenodo.15641782 .

The ACM/IEEE International Conference on Software Engineering (ICSE) celebrated its 50th year in May 2025, and while I was there, I was fortunate to listen to Michael Hilton (Carnegie Mellon University, Pittsburgh, PA, USA), who suggested that, currently, the uncertainty of flaky tests was like the uncertainty of quantum computers. How should we handle this uncertainty or nondeterminism? Flaky tests are tests that give different results when executing the test suite, though the software has not changed. The comparison might not be exactly right, but it has a degree of similarity. Quantum can only solve quantum-framed problems, and not NP-complete problems (i.e., the hardest problems to be verified quickly). On the other hand, there are many published works examining flaky tests in quantum,1,2 as there is uncertainty in the results, even if the causes are rather different.

The co-development of hardware and software in industrial embedded systems frequently leads to compilation errors during continuous integration (CI). Automated repair of such failures is promising, but existing techniques rely on test cases, which are not available for non-compilable code. We employ an automated repair approach for compilation errors driven by large language models (LLMs). Our study encompasses the collection of more than 40000 commits from the product’s source code. We assess the performance of an industrial CI system enhanced by four state-of-the-art LLMs, comparing their outcomes with manual corrections provided by human programmers. LLM-equipped CI systems can resolve up to 63 % of the compilation errors in our baseline dataset. Among the fixes associated with successful CI builds, 83 % are deemed reasonable. Moreover, LLMs significantly reduce debugging time, with the majority of successful cases completed within 8 minutes, compared to hours typically required for manual debugging.

From Fagan Inspections to cleanroom practices, agile code reviews, mob programming, and failing fast. This editorial provides a personal reflection of how the practice of code reviews has changed over the decades.

What is the best pathway to acquire new knowledge, create a positive work-life balance, and to plan and adapt successfully? Acceptance, tolerance, and inclusiveness: embracing these practices is key to transforming our outlook and attaining higher motivation and great results.

Achieving automatic, valid, verified answers from generative AI models, is a goal that many of us are working on. We must find a way to make sure we have reliable and trustworthy results despite numerous challenges in the field.

Impact can be anything from a software solution, a product, or even changing people’s minds about something. Successfully turning an idea into something that has an impact requires alignment among many contributing factors. This issue of IEEE Software gives us more insight into this journey from idea to impact.

Industrial embedded systems often require specialized hardware. However, software engineers have access to such domain-specific hardware only at the continuous integration (CI) stage and have to use simulated hardware otherwise. This results in a higher proportion of compilation errors at the CI stage than in other types of systems, warranting a deeper study. To this end, we create a CI diagnostics solution called ``Shadow Job'' that analyzes our industrial CI system. We collected over 40000 builds from 4 projects from the product source code and categorized the compilation errors into 14 error types, showing that the five most common ones comprise 89 % of all compilation errors. Additionally, we analyze the resolution time, size, and distance for each error type, to see if different types of compilation errors are easier to localize or repair than others. Our results show that the resolution time, size, and distance are independent of each other. Our research also provides insights into the human effort required to fix the most common industrial compilation errors. We also identify the most promising directions for future research on fault localization.

This issue is tackling the Future of Software Engineering Education and Training in the Age of AI. Generative AI tools will change how we learn. A new, more precise language is needed to communicate better with AI tools. Learn prompt engineering!— Sigrid Eldh, EIC IEEE Software.