Searcharxiv⌕ Search

subject

cs.SE

cs.SE: explore 370 source-linked works published from 2025 to 2026, with original documents and citations.

This collection is a preview while coverage and quality are evaluated.

Search within this collection

Coverage and selection

Includes records with this source-supplied label or an explicit phrase match in their metadata. Matches indicate a mention, not proof that a paper uses a method or tests a material. Source versions are consolidated by DOI.

Sources: arxiv. Collection updated 2026-09-16. Counts describe this index, not the complete source archives.

arXiv2026

Audit-First Rollback Semantics for Safety-Critical Deployment Pipelines

Distributed deployment runtimes carry a coherence obligation that classical fault-tolerance frameworks do not name directly: the live state a component is configured to run and the audit chain that records how it got there must agree at every terminal configuration. Prior works mainly focus on individual aspects of the deploy-time fault surface (canary controllers, configuration rollback, signed attestations), leaving the cross-cutting question of audit/live coherence under fail-stop crash only loosely specified. Yet a key systems question remains unresolved: how can a deployment runtime guarantee that the audit chain answers truthfully about live state even when a transition crashes mid-flight? We present audit-first rollback semantics, a fault-tolerance mechanism that guarantees audit/live coherence at every committed terminal under fail-stop crashes during transition phases. The mechanism pairs with provisional state machines, pipelines whose "active but not yet promoted" states carry an explicit rollback contract and a bounded deadline. We instantiate both in a runtime deployment system and run a dependability evaluation against a fail-open variant of the same pipeline across twelve fault-injection points spanning three structural failure classes. Across 1,200 injected-failure trials, audit-first rollback achieves 100% audit/live-state coherence (600/600, Wilson 95% CI [0.994,1.000]) with per-cell p95 recovery latency below 500 ms (SLO PASS in 12/12 cells); the fail-open variant preserves coherence on only 33% of trials (200/600, Wilson 95% CI [0.297,0.372]). We further lift the construction to a cross-bridge coordination protocol with a safety argument for fleets of fail-stop bridges, leaving fleet-scale empirical evaluation to follow-on work.

cs.SE↗
arXiv2026

Robustness and Trade-offs for Code LLMs on Protected Code

Code large language models (LLMs) are increasingly used on software artifacts that may be intentionally obfuscated for intellectual-property protection, reverse-engineering resistance, or controlled access. In reverse engineering and security analysis, deobfuscation is commonly treated as the preprocessing step before downstream analysis or inference, yet its utility for code LLM pipelines has not been systematically validated across models and protection methods. We present an execution-based study of seven code LLMs on protected-code translation and completion, spanning source programs from C++, Go, Java, and JavaScript, five obfuscation methods, and three inference protocols: plain, obfuscated, and deobfuscated. Our results show that direct inference on obfuscated code often matches or exceeds inference on restored code. In this controlled benchmark, higher-capability models such as GPT-4.1 and Qwen3-Coder-30B retain about 90% Pass@1 on obfuscated translation inputs, indicating that explicit restoration is often unnecessary. Same-model restoration does recover some obfuscation-induced failures, but it also degrades many cases that already succeed, with lower-capability models showing the largest net losses. Across settings, model capability is the primary factor, while source language and obfuscation method have secondary but consistent effects. Overall, our findings support model-aware pipeline design and indicate that protected-code workflows should be evaluated primarily with execution-based metrics rather than static similarity alone.

cs.SE↗
arXiv2026

Automated Deployment of Real-Time Tasks for Phased Execution on Scratchpad-Based Multicore Platforms

The increasing throughput demands in real-time systems and the consolidation of functionality on few, high-performance platforms are driving a shift towards parallel architectures. A key challenge for multicore real-time systems is the interference from contention for access to shared memory. Phased execution approaches address this challenge by restricting shared memory access to mutually exclusive memory phases, while computation is limited to memories local to each core. However, the complexity of managing and scheduling said memory phases hinders the adoption of phased execution in real-time applications. To address this challenge, we propose a model-based deployment methodology that automates the process of adapting applications to phased execution. We present an integrated tool-based deployment process that extends the application through the necessary memory phases and provides a runtime environment to orchestrate execution on the target hardware platform. Our approach requires minimal changes to the application implementation since the deployment tool directly extracts the required information from the generated application binaries. We validate our methodology using an avionics case study on a RISC-V multicore system, showcasing its key components and principles of operation.

cs.SE↗
arXiv2026

Large Language Models for Fuzz Testing in Microservices: A Systematic Literature Review

Microservice systems (MSS) increasingly rely on heterogeneous APIs whose combinatorial input space and stateful dependencies challenge traditional fuzz testing. Meanwhile, Large Language Models (LLMs) have recently been introduced to enhance fuzzing with semantic reasoning over specifications, inputs, and runtime feedback. This paper presents a systematic literature review (SLR) of LLM-assisted fuzz testing for microservices to synthesise how LLMs are applied, evaluated, and what challenges remain. Following established SLR guidelines, we analyze 20 primary studies published between 2024 and 2026. Results show LLMs are mainly used as semantic input generators in black-box fuzzing, with a growing shift towards agent-based and retrieval-augmented architectures, improving valid input generation and modestly increasing coverage and vulnerability detection. However, evaluation remains heterogeneous, with limited benchmark standardization, scarce cost reporting, and a bias toward single-service experiments, highlighting a gap with real-world multi-service systems. This review provides a taxonomy of LLM roles and integrations, a consolidated view of evaluation practices, and a mapping of open challenges to research directions, supporting the design and deployment of LLM-driven fuzzing in microservices.

cs.SE↗
arXiv2026

Engineering as Code: Bringing Software Engineering Methodology to Engineering Design

Large language models have made significant progress in verifiable domains such as code generation and chip design, yet remain limited on engineering design tasks in fields like architecture, mechanical engineering, and HVAC. This paper argues the root cause is not model capability but the absence of a "Design as Code" computable foundation: design representations that can be consumed, verified, and versioned by machines. Existing CAD/BIM systems couple design logic with geometry, causing quality assurance to drift downstream; Automated Compliance Checking (ACC) suffers from geometric false positives and naming-dependent model reconstruction overhead. We propose the Engineering as Code (EaC) paradigm: expressing engineering design as text-native declarative language with automated rule engines, version control, and package management as quality gates. Core contributions: (1) the Information Representation Hypothesis, arguing the engineering AI bottleneck stems from missing computable design representations rather than model capability; (2) ADL (Assembly Definition Language) with Part as atom, organized into three orthogonal sub-languages -- PDL (Part Definition), PML (Part Mating), and PLL (Part Layout); (3) ESA (Engineering Static Analysis), shifting compliance checking from downstream review to design-time, operating on semantic categories (Family types, Mate relations) rather than geometry, eliminating false positives and naming dependencies. A prototype validates ADL expressiveness and ESA detection across three cross-domain samples (telecom rack expansion, modular datacenter, mechanical keyboard), checking 69 rules in under 200ms. A controlled violation injection experiment achieves 100% detection rate with zero false positives. The SD-HWE-Bench benchmark design is complete as an empirical testbed for the hypothesis.

cs.SE↗
arXiv2026

A systematic literature review on logging smell detection

Context:Logging is an important part of software development that helps developers monitor systems, understand behavior, and fix problems. But when logging is done poorly, it can introduce logging smells, which are defects that reduce the usefulness of logs or even make them problematic. Objective:This study looks at how logging smells are currently detected. The goal is to better understand the existing research on automatic detection techniques, datasets, and evaluation methods. Method:We conducted a systematic literature review (SLR) of 21 studies focused on detecting logging smells. In this review, we define key logging-related terms, identify and map the types of smells to an existing taxonomy, and examine the detection techniques, datasets, and evaluation strategies used across the studies. Results:We found that the research is still scattered and inconsistent. For example, there is no common benchmark or standardized approach for evaluating results, making it difficult to compare studies. In addition, we observe inconsistencies in the way log smells are addressed, as studies differ in the types and number of smells they target. Conclusion:There is still room for improvement in how logging smells are studied and detected. We point out several challenges and suggest future directions, such as developing better tools, using large language models (LLMs), and building more standardized datasets for evaluation.

cs.SE↗
arXiv2026

Toward Model-Driven Digital Twin Configuration: Separating Structure Semantics and Runtime with SysML SAREF and Ditto

Energy communities, neighbourhoods that jointly produce, store, and consume electricity, increasingly rely on \emph{digital twins}: live software copies of physical devices such as a solar panel, a battery, or a heater, kept in sync for monitoring and control. Setting up such a twin is today mostly manual: an engineer hand-writes a configuration whose field names are arbitrary, whose units are implicit, and which carries no machine-readable description of how devices relate, so other systems cannot reliably interpret it. This position paper argues that the task should be split across three complementary tools, each doing what it does best: a modelling language for the system's structure (SysML), a standard energy vocabulary for its meaning (SAREF4ENER), and a digital-twin platform for the running representation (Eclipse Ditto, via the W3C Web-of-Things Thing Description). We give conceptual rules (not yet an executable generator) for deriving a Ditto configuration from a SysML model annotated with that vocabulary, illustrate them on a greenhouse energy-community node modelled in Modelio, and argue that the split improves traceability and configuration consistency, and establishes the semantic hooks needed for interoperability, over hand-written alternatives. We scope the contribution to design-time configuration and discuss its limits.

cs.SE↗
arXiv2026

A Mixed-Method Empirical Study of LLM Assistance in Software Engineering Workflows

Large Language Models (LLMs) are increasingly integrated into software development workflows, yet their effects are often discussed without distinguishing between task types, developer seniority, and verification demands. This paper presents a mixed-method empirical study of LLM-assisted software engineering with first-year and fourth-year undergraduates. Phase 1 is a preliminary survey (n=157) that characterizes LLM exposure, reliance, and trust calibration among the two groups. Phase 2 is a task-based quasi-experiment with a purposive sample from both cohorts (n=20). Here, we compare AI-assisted and non-AI conditions on a structured set of software engineering tasks spanning implementation, constraint-driven algorithm selection, and architectural reasoning. We then analyze performance outcomes alongside behavioral traces captured via screen recording and a qualitative coding process. Survey results indicate widespread LLM adoption and substantial verification effort, alongside cohort differences in perceived LLM capability for constraint-heavy scenarios. The quasi-experiment further shows that AI assistance changes workflow structure. For example, participants frequently adopt AI-first task entry, copy-transfer integration, and AI-mediated debugging, whereas non-AI workflows rely more on documentation, prior templates, and iterative trial-error refinement. Overall, our findings suggest that the benefits of LLM assistance are task-dependent and mediated by expertise and verification practices, rather than by generation speed alone.

cs.SE↗
arXiv2026

Data-Related Challenges and Requirements for Event Log Generation in Process Mining: A Systematic Literature Review

Process mining is becoming an essential technology that not only supports the improvement of business processes but also enables the software technologies underlying the future digital economy. Among the multiple challenges discussed by the process mining community, data quality is emerging as the most pressing one. However, insufficient attention has been paid to event log generation as the very first phase of process mining and to its relationship with data engineering and requirements engineering. To address this gap, we conducted a systematic literature review of data-related challenges, requirements, and solutions in event log generation. Our results show that a wide range of 29 challenges can be addressed with 5 basic categories of requirements. Existing solutions already embed some form of data engineering and domain knowledge engineering techniques for event log generation. This review can support researchers and practitioners in understanding current trends in event log generation for process mining and in leveraging data and requirements engineering techniques to improve log generation and, ultimately, process mining outcomes.

cs.SE↗
arXiv2026

Big Questions on Software Architecture: Report of the ICSE 2026 BoF on Software Architecture

Software Architecture (SA) is more important than ever, from the need to master the pervasive impact of technology in society and planet earth, to balancing the role of humans versus technology, flexibility versus chaos, economic convenience versus digital autonomy. Despite SA importance, we feel that the SA research community needs to reflect on what are the big questions that deserve scientific research, and what are instead technology trends or hypes. In this paper, we report the results of a community initiative aiming to identify and discuss the big questions in SA research. Organised in two sessions hosted in 2026 at the ICSE and ICSA conferences, respectively, this paper reports on the results collected during the first session, and looks forward to complementing them with the results of the second one. To be continued ...

cs.SE↗
arXiv2026

SH-PDOPS: AI-Driven Cloud Native Enterprise Reliability Framework for Predictive Analytics and Intelligent DevOps Automation

This paper presents an AI-driven cloud-native enterprise reliability framework designed to improve predictive analytics, intelligent DevOps automation, and system resilience in modern distributed infrastructures. The proposed framework integrates machine learning models, Kubernetes orchestration, observability pipelines, and automated incident response mechanisms to enhance reliability engineering practices. The study explores predictive failure detection, anomaly monitoring, self-healing infrastructure, and CI/CD optimization using cloud-native technologies. Experimental evaluation demonstrates improved operational efficiency, reduced downtime, and enhanced scalability for enterprise environments. The framework provides a practical approach for combining artificial intelligence with DevOps methodologies to achieve adaptive and autonomous infrastructure management.

cs.SE↗
arXiv2026

The Prompt Triangle: A Registered Report on Prompts as Hybrid Artifacts

AI-based coding assistants are transforming software development by shifting effort from writing code to crafting prompts that guide code generation. Despite their growing importance, little empirical evidence exists on how prompts function as software engineering artifacts. Building on prior work framing prompts as mixed artifacts combining requirement intent and solution guidance, we build on the Prompt Triangle, a conceptual model describing prompts along three components: Functionality and Quality (requirements), General Solutions (architectural guidance), and Specific Solutions (implementation constraints). This registered report presents the Stage 1 protocol for a confirmatory study investigating how prompts evolve and how their alignment with requirements engineering (RE) activities predicts development outcomes. We preregister four hypotheses examining prompt evolution, developer characteristics, RE activity alignment, and temporal patterns. We employ a controlled experiment (n=30), community uploads, and mined data using dual-coding to test whether prompting patterns predict development success.

cs.SE↗
arXiv2026

Structuring agentic AI for HPC code modernization

Modernization of legacy scientific codes is often necessary to keep up with the ever-evolving changes in the compute resource ecosystem. Parallelization and migration from poorly supported software ecosystems are two of the most time-consuming activities in the research software engineering field. This paper presents our experience in the successful, two-phase AI-assisted modernization of NMAP-RKPM, a roughly 60,000-line, 3D explicit solid mechanics physics engine based on the Reproducing Kernel Particle Method (RKPM). We converted this single-threaded, Fortran based MPI application into a OpenMP-parallel C++ based MPI tool in the span of a few months. While Large Language Model (LLM) based tools on their own proved inadequate, we developed a highly structured "hand-holding" agentic AI methodology, like providing manually created examples, ensuring continuous buildability and limiting session scope, that was instead highly effective. The paper provides both the AI-assisted steps that were successful and the problems that we had to overcome, alongside the reasoning behind the chosen path.

cs.SE↗
arXiv2026

AI Writes Code, Humans Pay the Debt. An Empirical Study on the Sustainability and Evolution of Agent-Generated Code

Context. The increasing adoption of Generative AI coding agents in software engineering is transforming how developers implement and maintain code. While these systems provide short-term productivity benefits, their long-term impact on software quality and technical debt remains unclear. Aim. We aim to investigate how agent-generated code affects software quality, focusing on issue localization accuracy, the introduction of technical debt, and its evolution over time. Method. We will conduct a large-scale mining software repositories study using the SQuaD dataset, employing a candidate set of 628k issue tickets. We will generate agent-based implementations for these issues, and compare them with the actual commits done by developers using static analysis metrics and tools. We will analyze differences at the commit level and across releases, and we will consider multiple LLM-based Agents selected through a systematic benchmarking strategy. Expected Results. We expect to provide empirical evidence on the trade-offs introduced by agent-based development, including differences in localization accuracy, variations in technical debt introduction, and potential divergence in long-term evolution. We expect the results to highlight variability across LLMs, to enrich our understanding of software evolution with Agents, and to inform more responsible adoption of Agents in software development.

cs.SE↗
arXiv2026

The State of Peer Review in Empirical Software Engineering: A Community Survey on Review Load, Quality, and GenAI Use

The scientific peer review system has been slowly deteriorating over the last years, and not just within empirical software engineering (ESE) research. Increased submission numbers, high workload, and the rise of generative AI use with all its associated issues have made many cracks in the system more visible. To get a better understanding of the current state of peer review in the ESE community, we conducted a questionnaire survey, which accumulated 120 responses. We report on (i) the perceived review load of community members, (ii) review quality perception as well as frequent challenges for and issues with reviews, (iii) the use of LLM-based tools in the reviewing process, and (iv) the community's suggestions for improving the peer review system. We hope that these community opinions can facilitate more evidence-based discussions about how people want to see the review system change for the better.

cs.SE↗
arXiv2026

Seeing Without Understanding: Large Language Model Evaluation of Mobile User Interface Quality, Failure Taxonomy, and Architectural Explanation

Evaluating mobile user interface quality at scale remains a persistent challenge in software engineering and human-computer interaction. Rule-based heuristic methods offer structural reliability but demand significant engineering effort, while human annotation does not scale to the volume of applications produced annually. Large language models present a promising alternative, yet their reliability for structured UI judgment has not been systematically examined, and the patterns behind their failures remain insufficiently characterized. This paper addresses both gaps. We begin with the complete RICO dataset of 66,261 real-world mobile application screens, from which we derive a refined evaluation corpus of 15,000 screens through a rigorous, literature-guided selection process. Each screen is assessed across seven criteria: structural JSON validity, minimum visible element count, clickable component presence, non-zero layout bounds, image integrity, and perceptual duplicate removal. Against this corpus, we apply a heuristic baseline built from severity-weighted usability signals, normalized layout metrics, and pixel-ratio complexity measures calibrated to real user sentiment. Multiple language models independently rate each screen across usability, layout quality, and visual complexity from structured JSON descriptions and raw screenshots. Dimension-level comparison against the heuristic uses agreement rates, Cohen's Kappa, and confidence calibration. Recurring divergence patterns are organized into a failure taxonomy and interpreted through transformer architectural signatures: MLE plausibility bias, attention misgrounding, and autoregressive over-commitment.

cs.HC↗
arXiv2026

Breaking the Alphabet: Rethinking File Ordering in Code Review

Effective code review is central to maintaining software quality, yet there is limited research about how the ordering of changed files in Pull Requests (PRs) influences review effectiveness. Most popular code review tools default to alphabetical ordering, favoring predictability over contextual relevance. While prior studies examined how file position shapes reviewer attention, it remains unclear how such ordering influences cognitive load and perceived review thoroughness. This study presents the first large-scale survey of 1,355 professional developers across 182 widely used open-source projects to investigate how file ordering impacts review behavior, comprehension, and perceived effectiveness. Our mixed-methods analysis reveals that only 10.2% of reviewers consider alphabetical ordering optimal, underscoring a cognitive misalignment in their interpretation of code changes. Although some developers appreciate its predictability, more than half (57.6%) report that it increases context switching, disrupts logical reasoning, and contributes to review fatigue, and 63.9% expressed concern that the default ordering may cause them to miss bugs. We further identify key challenges in multi-file reviews and elicit developers' expectations for improved tooling, including dependency-aware grouping and customizable file ordering (requested by 66% of reviewers). These findings highlight the need for reviewer-centric interface designs that better align tool behavior with human cognition.

cs.SE↗
arXiv2026

DTM: Deterministic Approaches for Black-box Test Suite Minimization with Tree-based Similarity

Black-box Test Suite Minimization (TSM) techniques reduce testing costs without requiring access to production code. However, existing effective approaches rely on evolutionary search algorithms, introducing non-determinism that produces inconsistent results across runs, undermining reliability in automated testing pipelines. We propose DTM (Deterministic approaches for black-box Test suite Minimization), a framework that ensures deterministic test suite reduction while preserving effectiveness and efficiency. DTM converts test cases into Abstract Syntax Trees and computes pairwise similarities using four tree-based measures. For subset selection, it employs three deterministic algorithms: Modified Minimum Spanning Tree, Spectral Clustering, and Dynamic Programming. We evaluated DTM on 16 Java projects from Defects4J with 661 buggy versions. Experimental results show that DTM achieved an average accuracy of 0.74 with an execution time of just 0.98 minutes, outperforming all state-of-the-art approaches. Moreover, it consistently produced identical results across multiple runs, ensuring full determinism.

cs.SE↗
Compare source metadata on this page
WorkPublishedSource identifierSource
Audit-First Rollback Semantics for Safety-Critical Deployment Pipelines2026-07-092609.00406arxiv
Robustness and Trade-offs for Code LLMs on Protected Code2026-07-032609.04220arxiv
Automated Deployment of Real-Time Tasks for Phased Execution on Scratchpad-Based Multicore Platforms2026-07-032609.04221arxiv
Large Language Models for Fuzz Testing in Microservices: A Systematic Literature Review2026-07-022609.04219arxiv
Engineering as Code: Bringing Software Engineering Methodology to Engineering Design2026-06-222609.04216arxiv
A systematic literature review on logging smell detection2026-06-212609.04215arxiv
Toward Model-Driven Digital Twin Configuration: Separating Structure Semantics and Runtime with SysML SAREF and Ditto2026-06-192609.04213arxiv
A Mixed-Method Empirical Study of LLM Assistance in Software Engineering Workflows2026-06-192609.04214arxiv
Data-Related Challenges and Requirements for Event Log Generation in Process Mining: A Systematic Literature Review2026-06-162609.04211arxiv
Big Questions on Software Architecture: Report of the ICSE 2026 BoF on Software Architecture2026-06-162609.04212arxiv
SH-PDOPS: AI-Driven Cloud Native Enterprise Reliability Framework for Predictive Analytics and Intelligent DevOps Automation2026-06-142609.04210arxiv
The Prompt Triangle: A Registered Report on Prompts as Hybrid Artifacts2026-06-112609.04209arxiv
Structuring agentic AI for HPC code modernization2026-06-072606.08710arxiv
AI Writes Code, Humans Pay the Debt. An Empirical Study on the Sustainability and Evolution of Agent-Generated Code2026-06-062609.04208arxiv
The State of Peer Review in Empirical Software Engineering: A Community Survey on Review Load, Quality, and GenAI Use2026-06-032606.04716arxiv
Seeing Without Understanding: Large Language Model Evaluation of Mobile User Interface Quality, Failure Taxonomy, and Architectural Explanation2026-05-242609.05423arxiv
Breaking the Alphabet: Rethinking File Ordering in Code Review2026-05-222609.04207arxiv
DTM: Deterministic Approaches for Black-box Test Suite Minimization with Tree-based Similarity2026-05-162609.04205arxiv

These are bibliographic comparisons, not experimental rankings. Follow the original document for methods and conditions.