Papers for

software tooling developers

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

Software architecture recovery improves file grouping with adaptive semantic neighborhoods

ASNER: Software Architecture Recovery with Adaptive Semantic Neighborhoods and Evidence-Grounded Refinement

Abstract: Automated software architecture recovery provides architectural context for software engineering and repository-level LLM agents. Existing methods combine structural and semantic signals, but functional relatedness does not necessarily imply shared architectural responsibility. Fixed thresholds or Top-K neighborhoods also ignore repository scale and local similarity distributions, introducing errors that propagate through clustering. Unconstrained LLM refinement may further alter correct assignments without sufficient evidence. We propose ASNER (Adaptive Semantic Neighborhoods and Evidence-Grounded Refinement for Software Architecture Recovery), based on responsibility-aware, project-adaptive relation modeling and evidence-grounded boundary verification. ASNER derives structured file responsibilities with an LLM, constructs semantic neighborhoods that adapt to repository scale and local similarity distributions, and augments a static dependency graph with selected semantic relations and weak directory cues. Community detection recovers the component backbone. A Responsibility-Ownership-Aware (ROA) Agent then examines uncertain boundary files using project-level responsibilities and traceable code evidence, changing assignments only when supported. Experiments on 12 open-source projects spanning C, C++, Java, and Python show that ASNER achieves the best macro-average on all five metrics on the common benchmark, improving ARI and c2c@66 over GAER-GAT by 19.5% and 32.9%, respectively. A downstream evaluation shows that ASNER-guided LocAgent improves file-, module-, and function-level code localization, demonstrating the value of its architectural context for repository-level software engineering tasks.

Tue 27 OctSoftware Engineering
The gist
Understanding how a large software project is organized into parts can be tricky, especially when files that do similar jobs might not really belong to the same section. The authors created ASNER, a new way to group files by looking closely at how responsible each file is, adapting to the size and details of the project, and carefully checking uncertain cases with evidence. They tested ASNER on various programming languages and projects, and it worked better than past methods. ASNER also helps other tools find code parts more accurately by giving them a clearer idea of the software's structure.
Open → 2610.36894v1

Structure-aware AI improves high-level code optimization significantly

Structure-augmented LLMs for High-Level Synthesis Pragma Optimization

Abstract: Pragma insertion drives the quality of high-level synthesis (HLS) designs. Choosing the right directives demands expert knowledge and reasoning about loop nesting, data dependences, and memory layout. While existing large language models (LLMs) show promise in code generation, they lack explicit program-structure awareness, limiting their ability to suggest effective pragmas. We present PRISM, a novel structure-augmented LLM that closes this gap by adding compiler-grade structural reasoning to a pretrained, frozen code LLM. It combines three hierarchical program representations, Abstract Syntax Tree (AST), Control-Flow Graph (CFG), and Data-Flow Graph (DFG), injecting them into a specific transformer layer while keeping original code tokens in a separate stream. The cross-attention gate at the injection point allows falling back to the pretrained representation when its structural signal is unhelpful. On zero-shot evaluation in HLS-Eval, PRISM synthesizes 3.5\times as many kernels as Llama3-8B (26.9\% vs. 7.7\%), and on the kernels where it does succeed, it produces designs that are 2.31\times faster (geomean) than GPT-5-mini's. In the agentic flow, the PRISM codegen outperforms other baselines when optimizing complex code and drives the average normalized improvement across the HLS-Eval suite to 26.4\%.

Tue 29 SeptHardware Architecture
The gist
Writing special instructions called pragmas helps make hardware designs work better, but it's tricky and needs expert knowledge. The authors designed an AI model named PRISM that understands the structure of code better by looking at how the code’s parts connect and flow. This helps PRISM suggest better pragmas than other models, making hardware designs faster and more efficient. It works well even without extra training on new examples.
Open → 2609.38601v1