Pith. sign in

REVIEW 3 major objections 9 minor 94 references

Semantic-Enhanced Automatic Refinement of Architecture Recovery Results Using LLMs

T0 review · 3 major / 9 minor · reviewed 2026-07-30 · grok-4.5

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read SemRef uses LLMs plus dependency analysis to automatically refine recovered software architectures, cutting average edit distance to ground truth by about 43%.

desk verdict Solid empirical SE paper: multi-stage LLM+dependency refinement consistently lifts 90 SAR recoveries, with a real but partly mitigated granularity confound in the headline numbers. read the letter →

arxiv 2607.23774 v1 pith:CBOS2FJX submitted 2026-07-26 cs.SE

Yiran Zhang , Chengwei Liu , Yuqiang Sun , Zhengzi Xu , Weisong Sun , Wenke Li , Wuxia Jin , Yang Liu This is my paper
classification cs.SE
keywords SoftwareArchitectureRecoveryLargeLanguageModelDependencyAnalysisModuleClusteringRefinementHierarchicalSummarization
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

Automatic architecture recovery tools cluster source files into modules, but their results are often coarse or wrong, so architects still spend heavy manual effort cleaning them up. This paper introduces SemRef, a refinement framework that takes any existing recovery result and improves it by combining structural dependency checks with an LLM’s ability to judge what files and modules actually mean. On nine projects with published ground-truth architectures and ten recovery tools (ninety inputs total), every refined result scored higher on five standard similarity metrics; the normalized gains ranged from roughly 18% to 43%, with MoJoFM edit distance to ground truth falling by 43% on average. Token cost scales roughly linearly with the number of files, and the method also yields a hierarchical module tree plus natural-language summaries that make the recovered architecture easier to read. The practical claim is that architects can start from any off-the-shelf recovery tool and obtain a measurably closer, more comprehensible architecture without hand-editing every misplacement.

What carries the argument

SemRef: a multi-stage pipeline that first resizes modules, then flags file misplacements via a normalized dependency-strength formula, verifies them with an LLM, builds a hierarchy from cohesive reference modules, and iteratively refines top-level, intermediate, and leaf modules top-down until summaries and structure stabilize.

What would settle it

Run the same ninety-input protocol on a new set of systems that have independently labeled ground-truth architectures never seen by the LLM; if MoJoFM RDP stays near zero or turns negative while dependency-only baselines still improve, the central claim fails.

Watch

Extended reading notes

Core claim

Across all ninety recovery results from ten tools on nine ground-truth projects, SemRef consistently raises accuracy on five metrics; measured by reduction in distance to perfect, the gains run from 17.72% (c2c_cvg) to 43.35% (MoJoFM), equivalent to cutting the number of file-move and module-merge operations needed to reach ground truth by 43% on average.

Load-bearing premise

That the LLM’s judgments of semantic cohesion and correct module placement, guided by the paper’s dependency formulas and prompts, line up with human ground-truth boundaries often enough for iterative refinement to converge on a better architecture rather than a differently wrong one.

Editorial extensions

If this is right

  • Any existing recovery tool can be wrapped by SemRef and produce higher-accuracy flat or hierarchical architectures without changing the tool itself.
  • Pairing the strongest current recovery tool (SARIF) with SemRef yields the best published results on the nine-project suite, beating every standalone baseline.
  • Token cost grows linearly with file count, so the method remains affordable even on multi-million-line systems such as Chromium.
  • Stronger underlying LLMs further raise the same RDP numbers, so future model improvements translate directly into better refined architectures.
  • The produced hierarchy and module summaries give maintainers readable documentation even when original design docs are missing.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • If the same dependency-plus-LLM loop works for recovery refinement, a lighter variant might continuously monitor pull requests and flag architectural drift before it accumulates.
  • Organizations that already own proprietary clustering tools can treat SemRef as a drop-in post-processor rather than replacing their internal pipelines.
  • The nine labeled systems are still a small sample; a public leaderboard of new ground-truth architectures would let the community stress-test whether the 43% MoJoFM gain generalizes.
  • Because leaf-module summaries are generated bottom-up, the same machinery could feed higher-level design-decision or onboarding documents with little extra prompting.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

3 major / 9 minor

Summary. The paper presents SemRef, a multi-stage framework that refines the output of software architecture recovery (SAR) tools by combining LLM semantic judgments with dependency analysis. The pipeline: (i) preprocessing that splits oversized modules and merges singletons; (ii) file-level refinement in which a normalized file–module dependency-strength measure (Eq. 1) flags potential misplacements that an LLM then verifies; (iii) hierarchy construction seeded by high-cohesion, non-overlapping reference modules (Eq. 2); and (iv) iterative top-down refinement of top-level modules, module placement, and leaf contents, with hierarchical re-summarization until fixpoint. The evaluation applies 10 SAR tool variants to 9 projects with published ground-truth architectures (90 recoveries, 25.7K–11.7M NLOC), measures five established metrics (MoJoFM, a2a, ARI, a2a_adj, c2c_cvg), and reports that SemRef improves every recovery on every metric, with Reduction in Distance to Perfect (RDP) of 17.72–43.35%. Supporting studies include one-way ANOVA over tool/project effects, a cumulative stage ablation, token-cost scaling (approximately linear in file count; ~$2.72 for Chromium), a five-LLM comparison, and a Bash case study. Code and data are publicly archived.

Significance. If the results hold, this is the first LLM-based SAR-result refinement framework, and the evaluation is unusually broad for this area: 90 recoveries across 10 tool variants and 9 labeled systems, five standard metrics, statistical testing, ablation, cost analysis, and a multi-LLM generalizability check. Specific strengths worth naming: the use of RDP (normalized gain) to handle a2a's well-known compressed range; reproducibility measures (temperature 0, fixed seed, versioned model IDs); a public artifact on Zenodo; and the Table 5 robustness check using top-level and leaf-level flattening. However, the headline numbers are computed under an oracle granularity selection (the hierarchy depth whose module count best matches ground truth), so the 17.72–43.35% figures are upper bounds; the blind-strategy gains in Table 5 are roughly half as large (11.8–35.1%). The practical contribution is therefore real but more modest than the abstract suggests, and the central quantitative claim needs reframing before the results can be relied upon.

major comments (3)
  1. [§4.2.1, Tables 2–3, Finding 1] The primary comparison flattens SemRef's hierarchy by selecting 'the depth at which the hierarchy has the most similar number of modules to the ground truth.' This is an oracle granularity choice: it uses the evaluation target to pick the representation being evaluated. Finding 1 ('improved the accuracy of all 90 input architectures, regardless of the metric') and the abstract's 17.72–43.35% RDP range are established only under this oracle. Table 5's top-level/leaf strategies are a useful mitigation but report averages only; they do not show that per-recovery improvement survives a blind flattening, and the gains drop to 11.8–35.1%. The authors should (a) report per-recovery results under at least one blind strategy (leaf partition or a fixed-depth rule), (b) lead the abstract/conclusion with the blind numbers, and (c) explicitly label the depth-matched numbers as oracle upper bounds.
  2. [§3.1, §4.1.2, Finding 5] Semantic improvement is not isolated from cardinality correction. Several input tools were run with preset k=50 (and ARC concerns=100) while ground-truth module counts span 11–216 (Table 1), and SemRef's preprocessing explicitly moves cardinality toward a more GT-like range (split oversized modules, merge singletons). All five metrics are sensitive to partition cardinality (MoJoFM merge/split operation costs, ARI's chance correction, c2c overlap at threshold 0.66), and Finding 5 confirms split/merge contribute measurably. Consequently Table 3 conflates better file placement with granularity correction. A control is needed: either re-run the clustering-based input tools with k set to the ground-truth module count, or include an algorithmic-only split/merge baseline (e.g., dependency-based, no LLM), so the LLM's semantic contribution can be quantified separately.
  3. [§5.2 (Threats to Validity)] The data-leakage mitigation is weak relative to its importance. Six of nine ground truths predate GPT-4o-mini's cutoff, and Bash, Hadoop, and Chromium are prominent systems whose module structure is plausibly memorized; instructing the LLM to 'avoid considering the project background' (§3.1.1) is not verifiable. The cross-project ANOVA null result (Table 4) is indirect evidence with low power at n=9 per group. A concrete strengthening: report per-project RDP split by pre- vs post-cutoff ground truths, and/or add one recently released, less prominent system with a freshly labeled ground truth. This is a correctness-risk concern, not a circularity claim: the current evidence does not distinguish learned architectural judgment from recall.
minor comments (9)
  1. [Abstract] 'Projects ranging from thousands to trillions of lines of code' contradicts Table 1, where the largest system is 11.7M NLOC. Presumably 'millions' was intended. Also 'gains ranges from' → 'gains range from'.
  2. [§4.2.1 text vs. Table 3] The text reports RDP 'increases ranging from 28.18% to 43.32%' and a c2c_cvg 'increment of 16.79%', but Table 3 shows 29.39%, 43.35%, and 17.72%. Please reconcile; the discrepancy suggests the text was written against an earlier experiment run.
  3. [§4.2.1, Eq. (4)] Clarify whether average RDP is the mean of per-recovery RDPs or RDP computed on mean scores. Per-recovery RDP is unstable when M(A) approaches 1 (a2a inputs average ~0.81, so denominators ~0.19); a few recoveries with M(A) very close to 1 could dominate the mean. A sensitivity note or median would help.
  4. [§4.3, Fig. 5] The ablation is cumulative (each bar removes all stages after stage k), not leave-one-out. Statements like 'the iterative refinement stage contributes the most' should be framed as marginal contribution given all prior stages; a leave-one-out ablation would support the stronger reading.
  5. [Table 4] Ten ANOVA tests are reported without multiple-comparison correction; the MoJoFM tool effect (p=0.0622) is borderline and worth acknowledging as such.
  6. [§4.1.5] The c2c_cvg similarity threshold of 0.66 (taken from [91]) is a free parameter; a brief sensitivity check over a small threshold grid would strengthen the c2c_cvg claims, which are already the weakest (RDP 17.72%).
  7. [§4.2.2 / §5.1] The comprehensibility benefit (module names and summaries) is supported only by the single Bash case study and one developer-description comparison. Either temper the claim or add a small human assessment of summary quality.
  8. [Table 7] Averaging Llama3.3 over successful projects only introduces survivorship bias (flagged in the footnote, but the table still invites direct comparison). Consider also reporting a failure-inclusive aggregate.
  9. [§4.2.1] Typo: 'this fattening strategy' should read 'this flattening strategy'. Also 'input all the modules together to LLM could caused biased understanding' (§3.3) needs grammatical revision.

Circularity Check

1 steps flagged · score 1.0 of 10

No load-bearing circularity: gains are measured against external human ground truths; mild residual is oracle depth choice in scoring, not a by-construction derivation.

  1. other [§4.2.1 (metric reporting); Table 5 mitigation]
    "As SemRef generates a hierarchical architecture, it cannot be directly compared to the ground truth architecture using these similarity metrics. Therefore, to make it comparable, we first break the hierarchy that best matches the granularity of ground-truth. Specifically, we select the depth at which the hierarchy has the most similar number of modules to the ground truth."

    Not true by-construction circularity of a derivation: GT is still external. But reporting uses oracle knowledge of GT module cardinality to choose the scored cut, so part of the measured lift on MoJoFM/ARI/c2c/a2a_adj can come from cardinality alignment rather than purely from semantic reassignment. Table 5 shows gains remain under top-only and leaf-only cuts, so the main claim is not forced by this step; residual evaluation bias only—hence score contribution is minor.

full rationale

SemRef’s central claim is empirical improvement of existing SAR outputs on five standard partition-similarity metrics versus published human ground-truth architectures (9 projects, 10 tools, 90 recoveries). The method (dependency-strength formulas Eqs. 1–3, LLM prompts, hierarchical refinement) does not define those metrics, does not fit parameters to the GT labels and then re-predict them, and does not rest on a uniqueness theorem or ansatz imported only from overlapping-author citations. SARIF [91] (overlapping authors) appears as one of ten inputs and as the strongest baseline to combine with; improvement is shown on all tools, so the self-citation is not load-bearing for Finding 1. Internal LLM self-checks when cohesion does not rise (§3.4.1) and co-evolution of hierarchy with summaries are algorithm design choices, not circular evaluation. The only mild concern is evaluation procedure, not derivation: hierarchical output is flattened by selecting the depth whose module count is closest to GT (§4.2.1), which can favor cardinality-sensitive metrics; Table 5 (top/leaf) partially mitigates but does not remove oracle granularity. That is an evaluation-validity issue, not self-definitional or fitted-as-prediction circularity. Score 1 reflects that minor residual only.

Assumptions & free parameters 5 free parameters · 5 assumptions · 2 invented entities

The central accuracy claims rest on standard clustering metrics and external ground truths, plus modeling choices that define when a file/module is ‘misplaced’ and when the LLM may override dependency strength. Free parameters are mostly engineering knobs (LLM decoding, tool presets, thresholds), not fits to the reported RDP. Domain assumptions include that static dependencies from DEPENDS and LLM file/module summaries are adequate proxies for architectural intent, and that published GT architectures are the right target.

free parameters (5)
  • LLM temperature and seed = temperature=0, seed=1
    Fixed to 0 and 1 for claimed reproducibility; different settings would change refinement paths.
  • c2c_cvg similarity threshold = 0.66
    Cluster overlap threshold set to 0.66 following prior work; directly affects one of five reported metrics.
  • Preset cluster/concern counts for input SAR tools = k=50, concerns=100
    Tools needing k set to 50 clusters; ARC concerns set to 100—affects input quality that SemRef then refines.
  • Misplacement re-check cap = 3
    Files examined more than three times and left in place are frozen as correct (§3.2.2).
  • Hierarchy flattening depth for metric reporting = depth with closest module count to GT
    Primary tables use the depth whose module count best matches GT; not a fit to scores but a reporting choice that can favor intermediate granularities.
assumptions (5)
  • ad hoc to paper Normalized file–module dependency strength (Eq. 1) and module cohesion (Eq. 2) are valid signals of architectural relatedness for flagging misplacements and choosing reference modules.
    Formulas are motivated but not derived from a validated theory of architecture; they drive candidate generation throughout §3.2–3.4.
  • domain assumption Static dependencies extracted by DEPENDS sufficiently represent the structural relationships needed for recovery refinement.
    Shared with much of the SAR literature the paper builds on; dynamic or build-time edges are not used.
  • domain assumption Published human ground-truth architectures for the nine systems are the correct target for ‘accuracy’.
    Standard evaluation premise in SAR; GT granularity and labeling choices bound all metrics.
  • domain assumption LLM zero-shot/chain-of-thought judgments over file and module summaries can decide splits, merges, and placements consistently enough to improve GT similarity.
    Core capability assumption of the method; supported empirically on the study set but not independently proven.
  • standard math Standard partition similarity metrics (MoJoFM, a2a, ARI, a2a_adj, c2c_cvg) and RDP are appropriate measures of architectural recovery quality.
    Taken from prior SAR evaluation practice cited in the paper.
invented entities (2)
  • SemRef multi-stage refinement pipeline independent evidence
    purpose: Automatically improve flat SAR outputs via LLM+dependency preprocess, file moves, hierarchy construction, and iterative refinement.
    The system is the paper’s main artifact; evaluated end-to-end against GT rather than postulated as a physical entity.
  • Reference-module selection rule (max cohesion, no dependency overlap)
    purpose: Seed a hierarchy with cohesive, non-overlapping modules before LLM placement of the rest.
    Algorithmic construct introduced in §3.3.1; success is only evidenced by downstream metric gains in this study.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Semantic-Enhanced Automatic Refinement of Architecture Recovery Results Using LLMs." pith.science (2026). https://pith.science/paper/CBOS2FJX

@misc{pith2026260723774,
  author       = {Pith},
  title        = {Pith review of: Semantic-Enhanced Automatic Refinement of Architecture Recovery Results Using LLMs},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/CBOS2FJX}},
  note         = {Machine review of arXiv:2607.23774}
}
abstract

Understanding the architecture is crucial for effectively maintaining and managing large software systems. However, discrepancies often exist between the designed and implemented architectures, which can pose significant risks. To identify these discrepancies, architects need to extract the architecture from the system implementation, which is both time-consuming and error-prone. To simplify this procedure, many automatic architecture recovery techniques have been developed. Yet, their accuracy is often limited. Architects must still invest significant effort in refining recovery results to ensure they accurately reflect the implemented architecture. To reduce such manual effort, we introduce Semref, a framework that combines LLMs with dependency analysis to automatically refine architectures recovered by existing architecture recovery tools. By leveraging the LLM's semantic understanding capabilities and integrating structural dependencies, Semref enhances both the accuracy and the comprehension of recovered architectures. To evaluate Semref, we tested on 9 projects with published ground-truth architectures and 10 state-of-the-art architecture recovery tools. 5 commonly used metrics are adopted to evaluate the effectiveness of Semref. The results show that Semref improves accuracy across various metrics, with normalized gains ranges from 17.72\% to 43.35\%. Specifically, for MoJoFM and $a2a_{adj}$ metrics, Semref achieves relative improvements of 118.57\% and 100.41\%, respectively.

Figures

Figures reproduced from arXiv: 2607.23774 by the authors.

Figure 1
Figure 1. Overview of SemRef 𝐷𝑒𝑝(𝑓𝑠𝑟𝑐,𝑚) = 1 |𝑚| · ∑︁ 𝑓 ∈𝑚  1 𝑑𝑒𝑔− (𝑓 ) · 𝛿 (𝑓𝑠𝑟𝑐 , 𝑓 )  (1) where 𝑓𝑠𝑟𝑐 and 𝑚 represent the file and module, respectively. |𝑚| is the number of files in 𝑚, 𝑑𝑒𝑔− (𝑓 ) is the in-degree of 𝑓 (i.e., number of files that depend on 𝑓 ), and 𝛿 (𝑓𝑠𝑟𝑐 , 𝑓 ) is 1 if 𝑓𝑠𝑟𝑐 depends on 𝑓 ; otherwise it is 0. For each file in the project, we calculate its dependency weight to all modules. If any module exhi… view at source ↗
Figure 3
Figure 3. 𝑅𝐷𝑃 averaged over projects [PITH_FULL_IMAGE:figures/full_fig_p008_3.png] view at source ↗
Figure 2
Figure 2. 𝑅𝐷𝑃 averaged over tools break the hierarchy that best matches the granularity of ground￾truth. Specifically, we select the depth at which the hierarchy has the most similar number of modules to the ground truth. Then we take this partition as a flat representation of our result to compare with the input ones [PITH_FULL_IMAGE:figures/full_fig_p008_2.png] view at source ↗
Figures from the paper (2 more)
Figure 4
Figure 4. Figure 4: Case study on Bash Split Merge Refine Hierarchy Iterate 0.00 0.05 0.10 0.15 RDP Metrics MoJoFM a2a ARI a2a_adj c2c_cvg [PITH_FULL_IMAGE:figures/full_fig_p010_4.png]
Figure 5
Figure 5. Figure 5: Acc. improvement of each stage measured by [PITH_FULL_IMAGE:figures/full_fig_p010_5.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

94 extracted references · 11 canonical work pages

  1. [1]

    2022. DEPENDS. https://github.com/multilang-depends/depends

    2022

  2. [2]

    Bassam Adnan, Sathvika Miryala, Aneesh Sambu, Karthik Vaidhyanathan, Mar- tina De Sanctis, and Romina Spalazzese. 2025. Leveraging LLMs for dynamic IoT systems generation through mixed-initiative interaction. In2025 IEEE 22nd International Conference on Software Architecture Companion (ICSA-C). IEEE, 488–497

    2025

  3. [3]

    Amarjeet and Jitender Kumar Chhabra. 2018. Many-objective artificial bee colony algorithm for large-scale software module clustering problem.Soft Computing 22, 19 (Oct. 2018), 6341–6361

    2018

  4. [4]

    Periklis Andritsos, Panayiotis Tsaparas, Renée J Miller, and Kenneth C Sevcik

  5. [5]

    Anonymous. 2025. SemRef. https://sites.google.com/view/semref

    2025

  6. [6]

    Anonymous. 2025. SemRef. https://zenodo.org/records/16150876

    arXiv 2025

  7. [7]

    Lei Bao. 2006. Theoretical comparisons of average normalized gain calculations. American journal of physics74, 10 (2006), 917–922

    2006

  8. [8]

    Robert Benkoczi, Daya Gaur, Shahadat Hossain, and Muhammad A. Khan. 2018. A design structure matrix approach for measuring co-change-modularity of software products. InProceedings of the 15th International Conference on Mining Software Repositories. ACM, Gothenburg Sweden, 331–335

    2018

Show all 94 references
  1. [9]

    Tingting Bi, Peng Liang, Antony Tang, and Chen Yang. 2018. A systematic mapping study on text analysis techniques in software architecture.Journal of Systems and Software144 (Oct. 2018), 533–558. doi:10.1016/j.jss.2018.07.055

    2018 doi

  2. [10]

    Evelien Boerstra, John Ahn, and Julia Rubin. 2022. Stronger Together: On Com- bining Relationships in Architectural Recovery Approaches. (2022), 12

    2022

  3. [11]

    Jitender Kumar Chhabra et al. 2017. Improving modular structure of software sys- tem using structural and lexical dependency.Information and software Technology 82 (2017), 96–120

    2017

  4. [12]

    Choongki Cho, Ki-Seong Lee, Minsoo Lee, and Chan-Gun Lee. 2019. Software Architecture Module-View Recovery Using Cluster Ensembles.IEEE Access7 (2019), 72872–72884. doi:10.1109/ACCESS.2019.2920427

    2019

  5. [13]

    Anna Corazza, Sergio Di Martino, Valerio Maggio, and Giuseppe Scanniello. 2011. Investigating the use of lexical information for software system clustering. In 2011 15th European Conference on Software Maintenance and Reengineering. IEEE, 35–44

    2011

  6. [14]

    Rudra Dhar, Karthik Vaidhyanathan, and Vasudeva Varma. 2024. Can LLMs Generate Architectural Design Decisions? -An Exploratory Empirical study. arXiv:2403.01709 [cs.SE] https://arxiv.org/abs/2403.01709

    2024 arXiv

  7. [15]

    J Andrés Díaz-Pace, Antonela Tommasel, and Rafael Capilla. 2024. Helping novice architects to make quality design decisions using an llm-based assistant. InEuropean Conference on Software Architecture. Springer, 324–332

    2024

  8. [16]

    Tobias Eisenreich, Sandro Speth, and Stefan Wagner. 2024. From Requirements to Architecture: An AI-Based Journey to Semi-Automatically Generate Software Architectures. InProceedings of the 1st International Workshop on Designing Software (Designing ’24). ACM. doi:10.1145/36436...

    2024

  9. [17]

    Milad Elyasi, Muhammed Esad Simitcioglu, Abdullah Saydemir, Ali Ekici, and Hasan Sozer. 2022. HYGAR: a hybrid genetic algorithm for software architec- ture recovery. InProceedings of the 37th ACM/SIGAPP Symposium on Applied Computing. ACM, Virtual Event, 1417–1424. doi:10.1145...

    2022

  10. [18]

    Ronald Aylmer Fisher. 1970. Statistical methods for research workers. InBreak- throughs in statistics: Methodology and distribution. Springer, 66–70

    1970

  11. [19]

    Joshua Garcia, Igor Ivkovic, and Nenad Medvidovic. 2013. A comparative analysis of software architecture recovery techniques. In2013 28th IEEE/ACM International Conference on Automated Software Engineering (ASE). IEEE, 486–496

    2013

  12. [20]

    Joshua Garcia, Ivo Krka, Chris Mattmann, and Nenad Medvidovic. 2013. Obtaining ground-truth software architectures. In2013 35th International Conference on Software Engineering (ICSE). IEEE, 901–910

    2013

  13. [21]

    Joshua Garcia, Mehdi Mirakhorli, Lu Xiao, Yutong Zhao, Ibrahim Mujhid, Khoi Pham, Ahmet Okutan, Sam Malek, Rick Kazman, Yuanfang Cai, and Nenad Medvidovic. 2021. Constructing a Shared Infrastructure for Software Architecture Analysis and Maintenance. In2021 IEEE 18th Internati...

    2021

  14. [22]

    Joshua Garcia, Daniel Popescu, Chris Mattmann, Nenad Medvidovic, and Yuan- fang Cai. 2011. Enhancing architectural recovery using concerns. In2011 26th IEEE/ACM International Conference on Automated Software Engineering (ASE 2011). IEEE, 552–555

    2011

  15. [23]

    Aaron Grattafiori, Abhimanyu Dubey, Abhinav Jauhri, Abhinav Pandey, Abhishek Kadian, Ahmad Al-Dahle, Aiesha Letman, Akhil Mathur, Alan Schelten, Alex Vaughan, et al. 2024. The llama 3 herd of models.arXiv preprint arXiv:2407.21783 (2024)

    2024 arXiv

  16. [24]

    Nathan Hagel, Nicolas Hili, Alexander Bartel, and Anne Koziolek. 2025. Towards LLM-Powered Consistency in Model-Based Low-Code Platforms. In2025 IEEE 22nd International Conference on Software Architecture Companion (ICSA-C). IEEE, 364–369

    2025

  17. [25]

    Adrian Hoff, Michael Nieke, and Christoph Seidl. 2021. Towards immersive software archaeology: regaining legacy systems’ design knowledge via interactive exploration in virtual reality. InProceedings of the 29th ACM Joint Meeting on European Software Engineering Conference and...

    2021

  18. [26]

    Xinyi Hou, Yanjie Zhao, Yue Liu, Zhou Yang, Kailong Wang, Li Li, Xiapu Luo, David Lo, John Grundy, and Haoyu Wang. 2024. Large language models for software engineering: A systematic literature review.ACM Transactions on Software Engineering and Methodology33, 8 (2024), 1–79

    2024

  19. [27]

    Jinhuang Huang, Jing Liu, and Xin Yao. 2017. A multi-agent evolutionary al- gorithm for software module clustering problems.Soft Computing21, 12 (June 2017), 3415–3428. doi:10.1007/s00500-015-2018-5

    2017 doi

  20. [28]

    Lawrence Hubert and Phipps Arabie. 1985. Comparing partitions.Journal of classification2, 1 (1985), 193–218

    1985

  21. [29]

    Jimin Hwa, Shin Yoo, Yeong-Seok Seo, and Doo-Hwan Bae. 2017. Search-Based Approaches for Software Module Clustering Based on Multiple Relationship Factors.International Journal of Software Engineering and Knowledge Engineering 27, 07 (Sept. 2017), 1033–1062. doi:10.1142/S02181...

    2017 doi

  22. [30]

    Khaled Ibrahim, Hesham Hassan, Khaled T Wassif, and Soha Makady. 2023. Context-Aware Expert for Software Architecture Recovery (CAESAR): An au- tomated approach for recovering software architectures.Journal of King Saud University-Computer and Information Sciences35, 8 (2023), 101706

    2023

  23. [31]

    Carlo Ieva, Arnaud Gotlieb, Souhila Kaci, and Nadjib Lazaar. 2018. Discovering Program Topoi via Hierarchical Agglomerative Clustering.IEEE Transactions on Reliability67, 3 (Sept. 2018), 758–770. doi:10.1109/TR.2018.2828135

    2018

  24. [32]

    Habib Izadkhah and Mahjoubeh Tajgardan. 2019. Information Theoretic Objective Function for Genetic Software Clustering. InThe 5th International Electronic Conference on Entropy and Its Applications. MDPI, 18. doi:10.3390/ecea-5-06681

    2019 doi

  25. [33]

    Dongming Jin, Weisong Sun, Jiangping Huang, Peng Liang, Jifeng Xuan, Yang Liu, and Zhi Jin. 2025. iredev: A knowledge-driven multi-agent framework for intelligent requirements development.arXiv preprint arXiv:2507.13081(2025)

    2025 arXiv

  26. [34]

    Angelika Kaplan, Jan Keim, Marco Schneider, Anne Koziolek, and Ralf Reussner

  27. [35]

    Masoud Kargar, Ayaz Isazadeh, and Habib Izadkhah. 2017. Semantic-based Software clustering using hill climbing. (2017), 6

    2017

  28. [36]

    Masoud Kargar, Ayaz Isazadeh, and Habib Izadkhah. 2019. Multi-programming language software systems modularization.Computers & Electrical Engineering 80 (Dec. 2019), 106500. doi:10.1016/j.compeleceng.2019.106500

    2019

  29. [37]

    Takeshi Kojima, Shixiang Shane Gu, Machel Reid, Yutaka Matsuo, and Yusuke Iwasawa. 2022. Large language models are zero-shot reasoners.Advances in neural information processing systems35 (2022), 22199–22213

    2022

  30. [38]

    Duc Minh Le, Pooyan Behnamghader, Joshua Garcia, Daniel Link, Arman Shah- bazian, and Nenad Medvidovic. 2015. An empirical study of architectural change in open-source software systems. In2015 IEEE/ACM 12th Working Conference on Mining Software Repositories. IEEE, 235–245

    2015

  31. [39]

    Junha Lee, Dae-Kyoo Kim, Jiwoo Park, and Sooyong Park. 2017. Class Modu- larization Using Indirect Relationships. In2017 22nd International Conference on Engineering of Complex Computer Systems (ICECCS). IEEE, Fukuoka, 110–119. doi:10.1109/ICECCS.2017.23

    2017 doi

  32. [40]

    Ki-Seong Lee and Chan-Gun Lee. 2020. Identifying Semantic Outliers of Source Code Artifacts and Their Application to Software Architecture Recovery.IEEE Access8 (2020), 212467–212477. doi:10.1109/ACCESS.2020.3040024

    2020

  33. [41]

    Xiaocong Li, Li Zhang, and Ning Ge. 2017. Framework Information Based Java Software Architecture Recovery. In2017 24th Asia-Pacific Software Engineering Conference Workshops (APSECW). IEEE, Nanjing, 114–120. doi:10.1109/APSECW. 2017.15

    2017 doi

  34. [42]

    Daniel Link, Pooyan Behnam, Ramin Moazeni, and Barry Boehm. 2019. The Value of Software Architecture Recovery for Maintenance. arXiv:1901.07700 [cs]

    2019 arXiv

  35. [43]

    Daniel Link, Pooyan Behnamghader, Ramin Moazeni, and Barry Boehm. 2019. Recover and RELAX: Concern-Oriented Software Architecture Recovery for Systems Development and Maintenance. arXiv:1903.06895 [cs]

    2019 arXiv

  36. [44]

    Daniel Link, Kamonphop Srisopha, and Barry Boehm. 2021. Study of the Utility of Text Classification Based Software Architecture Recovery Method RELAX for Maintenance. InProceedings of the 15th ACM / IEEE International Symposium on Empirical Software Engineering and Measurement...

    2021

  37. [45]

    Xu Lu, Weisong Sun, Yiran Zhang, Ming Hu, Cong Tian, Zhi Jin, and Yang Liu. 2025. Requirements Development and Formalization for Reliable Code Generation: A Multi-Agent Vision.arXiv preprint arXiv:2508.18675(2025)

    2025 arXiv

  38. [46]

    Thibaud Lutellier, Devin Chollak, Joshua Garcia, Lin Tan, Derek Rayside, Ne- nad Medvidovic, and Robert Kroeger. 2015. Comparing software architecture recovery techniques using accurate dependencies. In2015 IEEE/ACM 37th IEEE International Conference on Software Engineering, V...

    2015

  39. [47]

    Thibaud Lutellier, Devin Chollak, Joshua Garcia, Lin Tan, Derek Rayside, Nenad Medvidović, and Robert Kroeger. 2017. Measuring the impact of code dependen- cies on software architecture recovery techniques.IEEE Transactions on Software Semantic-Enhanced Automatic Refinement of...

    2017

  40. [48]

    Thibaud Lutellier, Devin Chollak, Joshua Garcia, Lin Tan, Derek Rayside, Nenad Medvidovic, and Robert Kroeger. 2018. Measuring the Impact of Code Depen- dencies on Software Architecture Recovery Techniques.IEEE Transactions on Software Engineering44, 2 (Feb. 2018), 159–181

    2018

  41. [49]

    Spiros Mancoridis, Brian S Mitchell, Yihfarn Chen, and Emden R Gansner. 1999. Bunch: A clustering tool for the recovery and maintenance of software system structures. InProceedings IEEE International Conference on Software Maintenance- 1999 (ICSM’99).IEEE, 50–59

    1999

  42. [50]

    Onaiza Maqbool and Haroon Atique Babri. 2004. The weighted combined algo- rithm: A linkage algorithm for software clustering. InEighth European Conference on Software Maintenance and Reengineering, 2004. CSMR 2004. Proceedings.IEEE, 15–24

    2004

  43. [51]

    João José Maranhão and Eduardo Martins Guerra. 2024. A prompt pattern sequence approach to apply generative AI in assisting software architecture decision-making. InProceedings of the 29th European Conference on Pattern Lan- guages of Programs, People, and Practices. 1–12

    2024

  44. [52]

    Zsuzsanna Marian, Istvan-Gergely Czibula, and Gabriela Czibula. 2017. A Hier- archical Clustering-Based Approach for Software Restructuring at the Package Level. In2017 19th International Symposium on Symbolic and Numeric Algorithms for Scientific Computing (SYNASC). IEEE, Timisoara

    2017

  45. [53]

    Nenad Medvidovic and Richard N Taylor. 2010. Software architecture: founda- tions, theory, and practice. In2010 ACM/IEEE 32nd International Conference on Software Engineering, Vol. 2. IEEE, 471–472

    2010

  46. [54]

    Jorge Miño, Roberto Andrade, Jenny Torres, and Kharol Chicaiza. 2024. Lever- aging Generative Artificial Intelligence for Software Antipattern Detection. In International Conference on Information Management. Springer, 138–149

    2024

  47. [55]

    Wiem Mkaouer, Marouane Kessentini, Adnan Shaout, Patrice Koligheu, Slim Bechikh, Kalyanmoy Deb, and Ali Ouni. 2015. Many-objective software re- modularization using NSGA-III.ACM Transactions on Software Engineering and Methodology (TOSEM)24, 3 (2015), 1–45

    2015

  48. [56]

    Sina Mohammadi and Habib Izadkhah. 2019. A new algorithm for software clustering considering the knowledge of dependency between artifacts in the source code.Information and Software Technology105 (Jan. 2019), 252–256. doi:10.1016/j.infsof.2018.09.001

    2019 doi

  49. [57]

    Rashid Naseem, Onaiza Maqbool, and Siraj Muhammad. 2013. Cooperative clustering for software modularization.Journal of Systems and Software86, 8 (2013), 2045–2062

    2013

  50. [58]

    2022.Incremental Clustering of Source Code: a Machine Learning Approach

    Tobias Olsson. 2022.Incremental Clustering of Source Code: a Machine Learning Approach. Ph. D. Dissertation. ISBN: 9789189460638 OCLC: 1296102631

    2022

  51. [59]

    Gabriele Pandini, Antonio Martini, Adela Nedisan Videsjorden, and Francesca Ar- celli Fontana. 2025. An exploratory study on architectural smell refactoring using Large Languages Models. In2025 IEEE 22nd International Conference on Software Architecture Companion (ICSA-C). IEE...

    2025

  52. [60]

    Marios Papachristou. 2019. Software clusterings with vector semantics and the call graph. InProceedings of the 2019 27th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering. ACM, Tallinn Estonia, 1184–1186. doi...

    2019

  53. [61]

    Saeed Parsa and Omid Bushehrian. 2005. A new encoding scheme and a frame- work to investigate genetic clustering algorithms.Journal of Research and Practice in Information Technology37, 1 (2005), 127–143

    2005

  54. [62]

    Kata Praditwong, Mark Harman, and Xin Yao. 2010. Software module clustering as a multi-objective search problem.IEEE Transactions on Software Engineering 37, 2 (2010), 264–282

    2010

  55. [63]

    2021.Software Module Clustering Using Grid-Based Many- Objective Particle Swarm Optimization

    Amarjeet Prajapati. 2021.Software Module Clustering Using Grid-Based Many- Objective Particle Swarm Optimization. preprint. In Review

    2021

  56. [64]

    Christos Psarras, Themistoklis Diamantopoulos, and Andreas Symeonidis. 2019. A Mechanism for Automatically Summarizing Software Functionality from Source Code. In2019 IEEE 19th International Conference on Software Quality, Reliability and Security (QRS). IEEE, Sofia, Bulgaria,...

    2019

  57. [65]

    Chet Ramey. [n. d.]. The Architecture of Open Source Applications (Volume 1) The Bourne-Again Shell. https://aosabook.org/en/v1/bash.html

  58. [66]

    Amit Rathee and Jitender Kumar Chhabra. 2017. Software Remodularization by Estimating Structural and Conceptual Relations Among Classes and Using Hierarchical Clustering. InAdvanced Informatics for Computing Research. Vol. 712. Springer Singapore, Singapore

    2017

  59. [67]

    Amit Rathee and Jitender Kumar Chhabra. 2018. Improving Cohesion of a Soft- ware System by Performing Usage Pattern Based Clustering.Procedia Computer Science125 (2018), 740–746. doi:10.1016/j.procs.2017.12.095

    2018 doi

  60. [68]

    David Rein, Betty Li Hou, Asa Cooper Stickland, Jackson Petty, Richard Yuanzhe Pang, Julien Dirani, Julian Michael, and Samuel R. Bowman. 2023. GPQA: A Graduate-Level Google-Proof Q&A Benchmark. arXiv:2311.12022 [cs.AI]

    2023 arXiv

  61. [69]

    Michele Risi, Giuseppe Scanniello, and Genoveffa Tortora. 2012. Using fold-in and fold-out in the architecture recovery of software systems.Formal Aspects of Computing24, 3 (2012), 307–330

    2012

  62. [70]

    Riccardo Rubei, Amleto Di Salle, and Alessio Bucaioni. 2025. LLM-Based Rec- ommender Systems for Violation Resolutions in Continuous Architectural Con- formance. In2025 IEEE 22nd International Conference on Software Architecture Companion (ICSA-C). IEEE, 404–409

    2025

  63. [71]

    Nafiseh Sadat Jalali, Habib Izadkhah, and Shahriar Lotfi. 2019. Multi-objective search-based software modularization: structural and non-structural features. Soft Computing23, 21 (2019), 11141–11165

    2019

  64. [73]

    Marcelo Schmitt Laser, Nenad Medvidovic, Duc Minh Le, and Joshua Garcia

  65. [74]

    Anas Shatnawi, Abdelhak-Djamel Seriai, and Houari Sahraoui. 2017. Recovering software product line architecture of a family of object-oriented product variants. Journal of Systems and Software131 (Sept. 2017), 325–346. doi:10.1016/j.jss.2016. 07.039

    2017 doi

  66. [75]

    Mohamed Soliman and Jan Keim. 2025. Do large language models contain software architectural knowledge?: An exploratory case study with gpt. In2025 IEEE 22nd International Conference on Software Architecture (ICSA). IEEE, 13–24

    2025

  67. [76]

    Jiaze Sun. 2018. PSO with Reverse Edge for Multi-Objective Software Module Clustering.International Journal of Performability Engineering(2018). doi:10. 23940/ijpe.18.10.p18.24232431

    2018

  68. [77]

    InProceedings of the 28th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering

    ARCADE: an extensible workbench for architecture recovery, change, and decay evaluation. InProceedings of the 28th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering. 1546–1550

  69. [78]

    Alberto Tagliaferro, Simone Corboe, and Bruno Guindani. 2025. Leveraging LLMs to Automate Software Architecture Design from Informal Specifications. In2025 IEEE 22nd International Conference on Software Architecture Companion (ICSA-C). IEEE, 291–299

    2025

  70. [79]

    Alvin Jian Jia Tan, Chun Yong Chong, and Aldeida Aleti. 2021. E-SC4R: Explaining Software Clustering for Remodularisation. arXiv:2107.01766 [cs]

    2021 arXiv

  71. [80]

    Tarchetti, Luis Amaral, Marcos C

    Ana Paula M. Tarchetti, Luis Amaral, Marcos C. Oliveira, Rodrigo Bonifacio, Gustavo Pinto, and David Lo. 2020. DCT: An Scalable Multi-Objective Module Clustering Tool. In2020 IEEE 20th International Working Conference on Source Code Analysis and Manipulation (SCAM). IEEE, Adel...

    2020

  72. [81]

    Weisong Sun, Yiran Zhang, Jie Zhu, Zhihui Wang, Chunrong Fang, Yonglong Zhang, Yebo Feng, Jiangping Huang, Xingya Wang, Zhi Jin, et al. 2025. Com- menting Higher-level Code Unit: Full Code, Reduced Code, or Hierarchical Code Summarization.arXiv preprint arXiv:2503.10737(2025)

    2025 arXiv

  73. [82]

    Vassilios Tzerpos and Richard C Holt. 2000. Acdc: an algorithm for comprehension-driven clustering. InProceedings Seventh Working Conference on Reverse Engineering. IEEE, 258–267

    2000

  74. [83]

    Lulu Wang, Peng Hu, Xianglong Kong, Wenjie Ouyang, Bixin Li, Haixin Xu, and Tao Shao. 2023. Microservice architecture recovery based on intra-service and inter-service features.Journal of Systems and Software204 (2023), 111754

    2023

  75. [84]

    Bingyang Wei. 2024. Requirements are all you need: From requirements to code with llms. In2024 IEEE 32nd International Requirements Engineering Conference (RE). IEEE, 416–422

    2024

  76. [85]

    Navid Teymourian, Habib Izadkhah, and Ayaz Isazadeh. 2022. A Fast Clustering Algorithm for Modularization of Large-Scale Software Systems.IEEE Transactions on Software Engineering48, 4 (April 2022), 1451–1462. doi:10.1109/TSE.2020. 3022212

    2022 doi

  77. [86]

    Chenchen Xiao and Vassilios Tzerpos. 2005. Software clustering based on dy- namic dependencies. InNinth European Conference on Software Maintenance and Reengineering. IEEE, 124–133

    2005

  78. [87]

    Kaiyuan Yang, Junfeng Wang, Zhiyang Fang, Peng Wu, and Zihua Song. 2022. Enhancing software modularization via semantic outliers filtration and label propagation.Information and Software Technology145 (May 2022), 106818. doi:10. 1016/j.infsof.2021.106818

    2022

  79. [88]

    Keisuke Yano and Akihiko Matsuo. 2020. Moderate detection and removal of omnipresent modules in software clustering. In2020 IEEE International Conference on Software Maintenance and Evolution (ICSME). IEEE, 662–666

    2020

  80. [89]

    Zhihua Wen and Vassilios Tzerpos. 2004. An effectiveness measure for soft- ware clustering algorithms. InProceedings. 12th IEEE International Workshop on Program Comprehension, 2004.IEEE, 194–203

    2004

  81. [90]

    Yiran Zhang, Ruiyin Li, Peng Liang, Weisong Sun, and Yang Liu. 2025. Knowledge- based multi-agent framework for automated software architecture design. In Proceedings of the 33rd ACM International Conference on the Foundations of Soft- ware Engineering. 530–534

    2025

  82. [91]

    Yiran Zhang, Zhengzi Xu, Chengwei Liu, Hongxu Chen, Jianwen Sun, Dong Qiu, and Yang Liu. 2023. Software architecture recovery with information fusion. In Proceedings of the 31st ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Eng...

    2023

  83. [93]

    Maryam Zahid, Zahid Mehmmod, and Irum Inayat. 2017. Evolution in software architecture recovery techniques — A survey. In2017 13th International Conference on Emerging Technologies (ICET). IEEE, Islamabad, 1–6. doi:10.1109/ICET.2017. 8281704

    2017 doi

  84. [2004]

    InInternational Conference on Extending Database Technology

    LIMBO: Scalable clustering of categorical data. InInternational Conference on Extending Database Technology. Springer, 123–146

  85. [2020]

    InProceedings of the 28th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering

    ARCADE: an extensible workbench for architecture recovery, change, and decay evaluation. InProceedings of the 28th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering. ACM, Virtual Event USA, 1546–1550. doi:10....

  86. [2024]

    InSemTech4STLD 2024, co-located with the ESWC 2024, Vol

    Combining knowledge graphs and large language models to ease knowledge access in software architecture research. InSemTech4STLD 2024, co-located with the ESWC 2024, Vol. 3697. 76–82

    2024

Pith tools

Reviewed July 30, 2026 · model on record in the stance chip above.