The paper presents a longitudinal measurement study on the adoption of the pledge and unveil system calls in OpenBSD. These system calls are used to sandbox programs and libraries. Given a dataset covering 19 releases, many programs and libraries were modified to use the system calls already before their introductions in official releases. The adoption rates have also steadily grown; a linear trend provides a coarse but sensible heuristic. Although particularly programs residing in /usr/bin and /usr/sbin have been modified to use the system calls, the sizes of programs and libraries do not correlate well with the amounts of pledge and unveil system calls invoked. Regarding the pledges made, standard input and output operations have frequently been requested, although the full finegrained arsenal offered by pledge has generally been utilized in OpenBSD. The same observation is seen in that particularly read operations to given paths have frequently been unveiled. All in all, the measurement results indicate that the adoption of system call minimization and sandboxing techniques is not necessarily as troublesome as has often been discussed in the literature.
Building software is a crucial task in today's software projects. Build systems support developers by automating all essential tasks, such as compiling, testing, and assembling software projects. However, they must be maintained regularly to prevent build failures. Neglected maintenance of build configurations remains one of the main causes of build failures. In this paper, we explore an agent-based approach to automatically repair broken builds caused by dependency declaration problems. We leverage the capabilities of large language models (LLMs) to closely collaborate with provided tools. Our approach combines tools for retrieving further information about dependencies and build execution results with the LLMs. In a preliminary evaluation, we show that using the full error log our approach repairs up to 77% of the failing builds with an average of 1.32 repair steps. Using the parsed error log, our approach yields a repair rate up to 83% with 1.27 repair steps on average. In both cases, developers can also use smaller models run on their machine with only small reduction in performance.
Cobol remains widely used in mainframe environments, making the migration of legacy applications to modern languages such as Java essential for improving maintainability, reducing technical debt, and addressing knowledge loss as experienced developers retire. Large Language Models (LLMs) show promise for automating this migration, but their effectiveness is limited by cobol's domain-specific syntax and the scarcity of high-quality training data. We propose enhancing cobol-to-Java translation by augmenting source code with natural language summaries, enabling LLMs to leverage their stronger natural language understanding capabilities. We evaluate this approach on two complementary datasets: an open-source CodeNet benchmark (727 samples) and a curated enterprise-grade benchmark (571 samples). Results with different LLMs show substantial improvements for low-quality baseline translations: summary augmentation improves 36% of eligible CodeNet samples and 50% of low-scoring enterprise benchmark samples, demonstrating effectiveness on the most challenging cases. We further develop routing strategies that dynamically select between baseline and summary-augmented pipelines to balance translation quality and computational cost. Results on enterprise benchmark show that a simple threshold-rule routing strategy achieves up to 8.75% improvement in translation quality with 0.7 additional LLM calls per sample. Overall, this work presents a practical and scalable method for enterprise cobol-to-Java modernization, reducing manual review and refinement effort.
With the growing capabilities of Large Language Models (LLMs), their application to software engineering tasks has garnered increasing attention. While our previous work focused on automated review of software design documents composed of text and tables, diagram-based artifacts such as UML or screen transition diagrams remained outside the scope of analysis. Reviewing such documents requires accurate interpretation of structural and semantic elements, including nodes, edges, and transition conditions. This paper proposes a hybrid diagram-understanding method that leverages multimodal LLMs together with diagram structure extracted from Office Open XML (OOXML) representations, guided by Chain-of-Thought prompting, to incrementally interpret diagrams in real-world design documents. The method enables integrated analysis across diagrams, tables, and textual content within the review process. Evaluation results show that the proposed approach achieves high accuracy in tasks involving structural recognition, such as consistency checking. However, the results also highlight persistent challenges in semantic-level review tasks, particularly in interpreting complex transition conditions. These findings provide insights into the current capabilities and limitations of multimodal LLMs for high-stakes design document reviews.
Version migration within the same programming ecosystem extends the lifespan of software systems by enhancing security and facilitating framework evolution, making it essential for sustainable and reliable software maintenance. However, current approaches still encounter substantial challenges. Rule-based approaches depend on manually constructed migration rules to capture version-specific differences, making them labor-intensive and difficult to adapt to heterogeneous frameworks and rapidly changing interfaces. In contrast, neural network-based automated refactoring methods demonstrate strong pattern-learning capabilities but are often constrained by the scarcity of high-quality annotated data and the inherent complexity of programming semantics. These limitations result in reduced accuracy and generalization when applied to real-world migration scenarios. To address these challenges, we propose CoMRA, a novel automated code migration framework that combines retrieval-augmented generation (RAG) for knowledge-enhanced code understanding with multi-agent collaboration for coordinated task execution. CoMRA was evaluated on a Qt4-to-Qt5 migration task involving 194 independently compilable programs that cover most Qt4 interfaces. It achieved 98% conversion accuracy while reducing migration overhead. We further validate CoMRA through cross-ecosystem case studies in both Python and Java. The results indicate that CoMRA's workflow is extensible to language-version transitions and build/dependency evolution, rather than being limited to a single framework upgrade scenario. This demonstrates its effectiveness in modernizing legacy software systems.
