pith. machine review for the scientific record. sign in

arxiv: 2604.07919 · v2 · submitted 2026-04-09 · 💻 cs.SE

Recognition: no theorem link

Investigating Code Reuse in Software Redesign: A Case Study

Xiaowen Zhang , Huaien Zhang , Shin Hwei Tan
Authors on Pith no claims yet

Pith reviewed 2026-05-10 18:16 UTC · model grok-4.3

classification 💻 cs.SE
keywords software redesigncode reuseclone detectionsemantic alignmenttest portingstatic analysiscase studyprecision improvement
0
0 comments X

The pith

Retrofitting clone detection with semantic alignment heuristics reduces irrelevant clones by 33-99% and improves precision up to 86% when mapping code between original and redesigned software projects.

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

Software redesign keeps existing functionality while raising quality, yet manually locating and porting code and tests between repositories remains costly and error-prone. The work studies real redesign practices to uncover recurring patterns such as non-linear migration that demands reuse in both directions, deferred changes marked by placeholders, overlooked test code, and carry-over of defects. These patterns point to the central difficulty of reliably pairing corresponding elements across versions. The authors meet this difficulty by adapting existing clone detectors with heuristics that encode the observed semantic patterns and by applying a hierarchical filtering strategy. Tests on two redesign pairs confirm that the adapted method removes most irrelevant matches and raises the share of useful mappings to as high as 86 percent on a benchmark of 1,749 samples.

Core claim

Through direct study of redesign activity the authors isolate the problem of locating matching code and tests across versions. They encode the reuse patterns they observed into semantic alignment heuristics and combine them with a hierarchical detection process that refines results from standard clone tools. When applied to two redesign pairs the method cuts the volume of likely irrelevant clones by 33-99 percent at a 0.5 similarity threshold and reaches 86 percent precision on the 1,749-sample benchmark.

What carries the argument

Semantic alignment heuristics that encode observed reuse patterns, applied inside a scalable hierarchical detection process to filter and map corresponding code and tests between versions.

Load-bearing premise

The reuse patterns observed in the primary case supply heuristics that remain effective for other redesign scenarios without introducing many missed mappings or false alignments.

What would settle it

A new redesign pair in which the heuristics leave most clones unchanged or produce precision well below 86 percent on a comparable benchmark of corresponding elements would show the approach does not generalize.

Figures

Figures reproduced from arXiv: 2604.07919 by Huaien Zhang, Shin Hwei Tan, Xiaowen Zhang.

Figure 1
Figure 1. Figure 1: Relationship between non-clones, genuine clones, code mappings and irrelevant [PITH_FULL_IMAGE:figures/full_fig_p003_1.png] view at source ↗
Figure 2
Figure 2. Figure 2: Overview of Our Bidirectional Study of an Ongoing Redesigned Project [PITH_FULL_IMAGE:figures/full_fig_p006_2.png] view at source ↗
Figure 3
Figure 3. Figure 3: SootUp method body copied from Soot code as TODO comments for future reuse In issues, commits, and PRs, we focused on keyword-related descriptions and patches. We also obtained all commits related to code reuse that belong to the collected PRs. Comparing the code in PR patches with the corresponding code in the latest Soot release, we manually identified code clones in 8 PRs. We excluded 19 PRs as they wer… view at source ↗
Figure 4
Figure 4. Figure 4: Identifier name reuse with type change in SootUp (SootUp 2021b) compared to Soot 1 -protected void internalTransform(Body b, String phaseName , Map<String , String > options) ... 2 +public void interceptBody(@Nonnull Body.BodyBuilder builder) ... 3 // Make a first pass through the statements , noting the statements we must absolutely keep. 4 ... // Stmt is of the form a = a which is useless ... 5 // Remove… view at source ↗
Figure 6
Figure 6. Figure 6: Similar Javadoc comments in a SootUp patch (SootUp 2020a) and the corresponding in Soot (4.5.0) [PITH_FULL_IMAGE:figures/full_fig_p008_6.png] view at source ↗
Figure 7
Figure 7. Figure 7: Overview of our redesign-aware clone filtering workflow that retrofit existing clone [PITH_FULL_IMAGE:figures/full_fig_p010_7.png] view at source ↗
Figure 8
Figure 8. Figure 8: An example of irrelevant clones that are not code mappings in test code of [PITH_FULL_IMAGE:figures/full_fig_p015_8.png] view at source ↗
Figure 9
Figure 9. Figure 9: A non-clone pair identified by NiCad due to high syntactic similarity [PITH_FULL_IMAGE:figures/full_fig_p015_9.png] view at source ↗
Figure 10
Figure 10. Figure 10: An example of a bug in correctly mapped clones [PITH_FULL_IMAGE:figures/full_fig_p015_10.png] view at source ↗
Figure 11
Figure 11. Figure 11: SAS and baseline integration across thresholds [PITH_FULL_IMAGE:figures/full_fig_p018_11.png] view at source ↗
Figure 12
Figure 12. Figure 12: Impact of rule exclusion across SAS thresholds [PITH_FULL_IMAGE:figures/full_fig_p019_12.png] view at source ↗
read the original abstract

Software redesign preserves functionality while improving quality attributes, but manual reuse of code and tests is costly and error-prone, especially in crossrepository redesigns. Focusing on static analyzers where cross-repo redesign needs often arise, we conduct a bidirectional study of the ongoing Soot/SootUp redesign case using an action research methodology that combines empirical investigation with validated open-source contributions. Our study reveals: (1) non-linear migration which necessitates bidirectional reuse, (2) deferred reuse via TODOs, (3) neglected test porting, and (4) residual bug propagation during migrations. We identify tracking corresponding code and tests as the key challenge, and address it by retrofitting clone detection to derive code mappings between original and redesigned projects. Guided by semantic reuse patterns derived in our study, we propose Semantic Alignment Heuristics and a scalable hierarchical detection strategy. Evaluations on two redesigned project pairs (Soot/SootUp and FindBugs/SpotBugs) show that our approach achieves an average reduction of 33-99% in likely irrelevant clones at a SAS threshold of 0.5 across all tool results, and improves precision up to 86% on our benchmark of 1,749 samples. Moreover, we contribute to the redesigned projects by submitting five issues and 10 pull requests, of which eight have been merged.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit. Tearing a paper down is the easy half of reading it; the pith above is the substance, this is the friction.

Referee Report

2 major / 3 minor

Summary. The manuscript reports an action research study of code reuse during redesign of static analysis tools, centered on the Soot/SootUp migration with FindBugs/SpotBugs as a second case. It identifies four empirical patterns (non-linear bidirectional migration, deferred reuse via TODOs, neglected test porting, and residual bug propagation), proposes Semantic Alignment Heuristics plus a hierarchical strategy to retrofit clone detectors for mapping corresponding code and tests, and evaluates the approach on the two project pairs. The evaluation reports an average 33-99% reduction in likely irrelevant clones at SAS threshold 0.5 across tools and up to 86% precision on a 1,749-sample benchmark; the authors also contributed five issues and ten pull requests (eight merged) to the target projects.

Significance. If the evaluation methodology and benchmark construction are sound, the work supplies rare empirical data on practical reuse challenges in cross-repository redesign and demonstrates a lightweight, tool-agnostic enhancement to clone detection that measurably reduces noise while preserving recall. The merged pull requests provide external corroboration of utility. The quantitative results and real-world contributions could inform both migration tooling and future empirical studies of software evolution.

major comments (2)
  1. [Evaluation] Evaluation section: the construction of the 1,749-sample benchmark, the precise definition of 'likely irrelevant clones,' and the procedure used to label ground truth are not described in sufficient detail to allow independent verification of the reported 33-99% reduction and 86% precision figures.
  2. [Approach] Approach and Evaluation sections: the Semantic Alignment Heuristics are derived from the primary Soot/SootUp case; the manuscript does not report a separate false-negative analysis or mapping accuracy study on FindBugs/SpotBugs, leaving the generalization claim and the assumption that the heuristics 'accurately identify corresponding code and tests' only partially supported.
minor comments (3)
  1. [Abstract] The broad 33-99% range would be more informative if broken down by tool and by project pair rather than aggregated.
  2. [Evaluation] SAS threshold and the acronym SAS itself should be expanded on first use and justified with a brief sensitivity discussion.
  3. [Study Findings] A small number of sentences in the patterns section contain forward references to later heuristics; reordering or adding brief forward pointers would improve readability.

Simulated Author's Rebuttal

2 responses · 0 unresolved

We thank the referee for the positive assessment, detailed reading, and recommendation of minor revision. The comments identify opportunities to strengthen reproducibility and the support for generalization. We address each point below and will revise the manuscript to incorporate the requested clarifications.

read point-by-point responses

  1. Referee: [Evaluation] Evaluation section: the construction of the 1,749-sample benchmark, the precise definition of 'likely irrelevant clones,' and the procedure used to label ground truth are not described in sufficient detail to allow independent verification of the reported 33-99% reduction and 86% precision figures.

    Authors: We agree that the current description of the benchmark is insufficient for full reproducibility. In the revised manuscript we will expand the Evaluation section with: (1) the exact sampling procedure used to select the 1,749 instances from the clone-detection output, (2) the operational definition of 'likely irrelevant clones' (including the semantic mismatch criteria and any automated filters applied before manual review), and (3) the ground-truth labeling protocol, including how annotators were instructed, whether multiple raters were used, and any agreement statistics. These additions will allow independent verification of the reduction and precision numbers. revision: yes

  2. Referee: [Approach] Approach and Evaluation sections: the Semantic Alignment Heuristics are derived from the primary Soot/SootUp case; the manuscript does not report a separate false-negative analysis or mapping accuracy study on FindBugs/SpotBugs, leaving the generalization claim and the assumption that the heuristics 'accurately identify corresponding code and tests' only partially supported.

    Authors: The referee is correct that the heuristics were induced from the Soot/SootUp observations and that no dedicated false-negative or mapping-accuracy study was performed on FindBugs/SpotBugs. The manuscript instead relies on the quantitative results obtained when the same heuristics were applied to the second project pair. In the revision we will add an explicit subsection discussing transferability, noting the absence of a separate false-negative analysis as a limitation, and explaining why the cross-case evaluation (identical reduction ranges and precision gains on both pairs) still provides supporting evidence for the heuristics' utility. We will not claim stronger generalization than the data warrant. revision: partial

Circularity Check

0 steps flagged

No significant circularity in empirical case study

full rationale

The paper is an empirical case study employing action research on two external open-source redesign pairs (Soot/SootUp, FindBugs/SpotBugs) plus a 1,749-sample benchmark. Central claims consist of measured reductions in irrelevant clones and precision improvements obtained from clone detection runs on real project code, plus external corroboration via merged pull requests. No equations, fitted parameters, self-definitional constructs, or load-bearing self-citation chains appear in the derivation of these results; the reported numbers are direct outputs of the applied heuristics on the chosen projects rather than tautological restatements of inputs.

Axiom & Free-Parameter Ledger

1 free parameters · 1 axioms · 1 invented entities

The work is empirical and relies on observations from action research plus quantitative evaluation on two project pairs; no mathematical derivations or external physical axioms are involved.

free parameters (1)
  • SAS threshold = 0.5
    Value of 0.5 used to filter clones and achieve the reported reduction in irrelevant matches.
axioms (1)
  • domain assumption Clone detection can be retrofitted to derive reliable code mappings between original and redesigned projects when guided by semantic patterns
    Core premise enabling the proposed heuristics and hierarchical strategy.
invented entities (1)
  • Semantic Alignment Heuristics no independent evidence
    purpose: To guide clone detection toward semantically corresponding code based on patterns observed in the case study
    Newly introduced rules derived from the bidirectional study findings.

pith-pipeline@v0.9.0 · 5535 in / 1451 out tokens · 73393 ms · 2026-05-10T18:16:48.595001+00:00 · methodology

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

90 extracted references · 21 canonical work pages

  1. [1]

    ://github.com/AntennaPod/AntennaPod

    AntennaPod (2025) Antennapod. ://github.com/AntennaPod/AntennaPod

    2025

  2. [2]

    In: Runtime Verification: 4th International Conference, RV 2013, Rennes, France, September 24-27, 2013

    Arzt S, Rasthofer S, Bodden E (2013) Instrumenting android and java applications as easy as abc. In: Runtime Verification: 4th International Conference, RV 2013, Rennes, France, September 24-27, 2013. Proceedings 4, Springer, pp 364--381

    2013

  3. [3]

    ACM SIGPLAN Not 49(6):259--269

    Arzt S, Rasthofer S, Fritz C, Bodden E, Bartel A, Klein J, Le Traon Y, Octeau D, McDaniel P (2014) Flowdroid: Precise context, flow, field, object-sensitive and lifecycle-aware taint analysis for android apps. ACM SIGPLAN Not 49(6):259--269

    2014

  4. [4]

    In: 2017 IEEE/ACM 4th International Conference on Mobile Software Engineering and Systems (MOBILESoft), IEEE, pp 13--24

    Arzt S, Rasthofer S, Bodden E (2017) The soot-based toolchain for analyzing android apps. In: 2017 IEEE/ACM 4th International Conference on Mobile Software Engineering and Systems (MOBILESoft), IEEE, pp 13--24

    2017

  5. [5]

    Commun ACM 42(1):94--97

    Avison DE, Lau F, Myers MD, Nielsen PA (1999) Action research. Commun ACM 42(1):94--97

    1999

  6. [6]

    https://backports.wiki.kernel.org/index.php/Main_Page, accessed: 2020-12-20

    Backports (2020) Backports project. https://backports.wiki.kernel.org/index.php/Main_Page, accessed: 2020-12-20

    2020

  7. [7]

    Comput Stand Interfaces 81:103598, doi:https://doi.org/10.1016/j.csi.2021.103598

    Bessghaier N, Soui M, Ghaibi N (2022) Towards the automatic restructuring of structural aesthetic design of android user interfaces. Comput Stand Interfaces 81:103598, doi:https://doi.org/10.1016/j.csi.2021.103598

    work page doi:10.1016/j.csi.2021.103598 2022

  8. [8]

    In: 2016 IEEE 24th International Conference on Program Comprehension (ICPC), pp 1--10, doi:https://doi.org/10.1109/ICPC.2016.7503722

    Cheng X, Zhong H, Chen Y, Hu Z, Zhao J (2016) Rule-directed code clone synchronization. In: 2016 IEEE 24th International Conference on Program Comprehension (ICPC), pp 1--10, doi:https://doi.org/10.1109/ICPC.2016.7503722

    work page doi:10.1109/icpc.2016.7503722 2016

  9. [9]

    De Sutter B, De Bus B, De Bosschere K (2002) Sifting out the mud: low level c++ code reuse. In: Proceedings of the 17th ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications, Association for Computing Machinery, New York, NY, USA, OOPSLA '02, p 275–291, doi:https://doi.org/10.1145/582419.582445

    work page doi:10.1145/582419.582445 2002

  10. [10]

    Ding Y, Chakraborty S, Buratti L, Pujar S, Morari A, Kaiser G, Ray B (2023) Concord: Clone-aware contrastive learning for source code. In: Proceedings of the 32nd ACM SIGSOFT International Symposium on Software Testing and Analysis, Association for Computing Machinery, New York, NY, USA, ISSTA 2023, p 26–38, doi:https://doi.org/10.1145/3597926.3598035

    work page doi:10.1145/3597926.3598035 2023

  11. [11]

    In: Astronomical Data Analysis Software and Systems X, vol 238, p 415

    Dorman B, Arnaud K (2001) Redesign and reimplementation of xspec. In: Astronomical Data Analysis Software and Systems X, vol 238, p 415

    2001

  12. [12]

    Int J Inform Vis 8(3):1055--1063

    Fuada S, Setyowati E, Restyasari N, Heong YM, Hasugian LP (2024) Ui/ux redesign of sh-upi app using design thinking framework. Int J Inform Vis 8(3):1055--1063

    2024

  13. [13]

    In: Proceedings of the 14th International Conference on Mining Software Repositories, IEEE Press, Piscataway, NJ, USA, MSR '17, pp 291--301

    Gharehyazie M, Ray B, Filkov V (2017) Some from here, some from there: Cross-project code reuse in github. In: Proceedings of the 14th International Conference on Mining Software Repositories, IEEE Press, Piscataway, NJ, USA, MSR '17, pp 291--301

    2017

  14. [14]

    https://github.com/orgs/community/discussions/13733, accessed: 2024-6-16

    GitHubCommunity (2022) Cross-repository (or, project-level) pr with multiple branches from different repositories. https://github.com/orgs/community/discussions/13733, accessed: 2024-6-16

    2022

  15. [15]

    Symmetry 13(3):447

    Gupta A, Goyal R (2021) Identifying high-level concept clones in software programs using method’s descriptive documentation. Symmetry 13(3):447

    2021

  16. [16]

    ://news.ycombinator.com/item?id=12885549

    HackerNews (2025) Findbugs project in its current form is dead. ://news.ycombinator.com/item?id=12885549

    2025

  17. [17]

    Manag Sci 54(1):180--193

    Haefliger S, Von Krogh G, Spaeth S (2008) Code reuse in open source software. Manag Sci 54(1):180--193

    2008

  18. [18]

    He N, Wu L, Wang H, Guo Y, Jiang X (2020) Characterizing code clones in the ethereum smart contract ecosystem. In: Financial Cryptography and Data Security: 24th International Conference, FC 2020, Kota Kinabalu, Malaysia, February 10--14, 2020 Revised Selected Papers 24, Springer, pp 654--675

    2020

  19. [19]

    Proc ACM Softw Eng 1(FSE):1656--1678

    He W, Di P, Ming M, Zhang C, Su T, Li S, Sui Y (2024) Finding and understanding defects in static analyzers by constructing automated oracles. Proc ACM Softw Eng 1(FSE):1656--1678

    2024

  20. [20]

    Higo Y, Kusumoto S (2014) How should we measure functional sameness from program source code? an exploratory study on java methods. In: Proceedings of the 22nd ACM SIGSOFT International Symposium on Foundations of Software Engineering, Association for Computing Machinery, New York, NY, USA, FSE 2014, p 294–305, doi:https://doi.org/10.1145/2635868.2635886

    work page doi:10.1145/2635868.2635886 2014

  21. [21]

    ://findbugs.sourceforge.net/, accessed: 2015-03-07

    Hovemeyer D (2015) Findbugs - find bugs in java programs. ://findbugs.sourceforge.net/, accessed: 2015-03-07

    2015

  22. [22]

    ://github.com/javaparser/javaparser

    JavaParser (2024) JavaParser. ://github.com/javaparser/javaparser

    2024

  23. [23]

    Jiang L, Misherghi G, Su Z, Glondu S (2007) Deckard: Scalable and accurate tree-based detection of code clones. In: Proceedings of the 29th International Conference on Software Engineering, IEEE Computer Society, Washington, DC, USA, ICSE '07, pp 96--105, doi:https://doi.org/10.1109/ICSE.2007.30

    work page doi:10.1109/icse.2007.30 2007

  24. [24]

    In: Proceedings of the 39th IEEE/ACM International Conference on Automated Software Engineering, pp 319--330

    Kaindlstorfer D, Isychev A, W \"u stholz V, Christakis M (2024) Interrogation testing of program analyzers for soundness and precision issues. In: Proceedings of the 39th IEEE/ACM International Conference on Automated Software Engineering, pp 319--330

    2024

  25. [25]

    Karakaya K, Schott S, Klauke J, Bodden E, Schmidt M, Luo L, He D (2024) Sootup: A redesign of the soot static analysis framework. In: Tools and Algorithms for the Construction and Analysis of Systems: 30th International Conference, TACAS 2024, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2024, Luxembourg City, L...

    work page doi:10.1007/978-3-031-57246-3_13 2024

  26. [26]

    In: 2024 IEEE/ACM 32nd International Conference on Program Comprehension (ICPC), pp 161--165

    Khajezade M, Wu JJ, Fard FH, Rodríguez-Pérez G, Shehata MS (2024) Investigating the efficacy of large language models for code clone detection. In: 2024 IEEE/ACM 32nd International Conference on Program Comprehension (ICPC), pp 161--165

    2024

  27. [27]

    Program Comput Softw 50(1):85--89

    Koznov DV, Ledeneva EY, Luciv DV, Braslavski P (2024) Calculating similarity of javadoc comments. Program Comput Softw 50(1):85--89

    2024

  28. [28]

    In: 2022 IEEE 16th International Workshop on Software Clones (IWSC), IEEE, pp 1--7

    Krinke J, Ragkhitwetsagul C (2022) Bigclonebench considered harmful for machine learning. In: 2022 IEEE 16th International Workshop on Software Clones (IWSC), IEEE, pp 1--7

    2022

  29. [29]

    Int J Comput Sci Inf Secur 18(11)

    Kuttal SK, Ghosh A (2020) Source code comments: Overlooked in the realm of code clone detection. Int J Comput Sci Inf Secur 18(11)

    2020

  30. [30]

    In: Cetus Users and Compiler Infastructure Workshop (CETUS 2011), vol 15

    Lam P, Bodden E, Lhot \'a k O, Hendren L (2011) The soot framework for java program analysis: a retrospective. In: Cetus Users and Compiler Infastructure Workshop (CETUS 2011), vol 15

    2011

  31. [31]

    In: International Conference on the Quality of Information and Communications Technology, Springer, pp 144--151

    Lavazza L, Tosi D, Morasca S (2020) An empirical study on the persistence of spotbugs issues in open-source software evolution. In: International Conference on the Quality of Information and Communications Technology, Springer, pp 144--151

    2020

  32. [32]

    Li K, Chen S, Fan L, Feng R, Liu H, Liu C, Liu Y, Chen Y (2023) Comparison and evaluation on static application security testing (sast) tools for java. In: Proceedings of the 31st ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering, Association for Computing Machinery, New York, NY, USA, ESEC/FSE 202...

    work page doi:10.1145/3611643.3616262 2023

  33. [33]

    In: 2017 32nd IEEE/ACM International Conference on Automated Software Engineering (ASE), pp 601--612, doi:https://doi.org/10.1109/ASE.2017.8115670

    Liew D, Schemmel D, Cadar C, Donaldson AF, Zahl R, Wehrle K (2017) Floating-point symbolic execution: A case study in n-version programming. In: 2017 32nd IEEE/ACM International Conference on Automated Software Engineering (ASE), pp 601--612, doi:https://doi.org/10.1109/ASE.2017.8115670

    work page doi:10.1109/ase.2017.8115670 2017

  34. [34]

    In: Proceedings 16th Annual International Conference on Automated Software Engineering (ASE 2001), pp 107--114, doi:https://doi.org/10.1109/ASE.2001.989796

    Marcus A, Maletic J (2001) Identification of high-level concept clones in source code. In: Proceedings 16th Annual International Conference on Automated Software Engineering (ASE 2001), pp 107--114, doi:https://doi.org/10.1109/ASE.2001.989796

    work page doi:10.1109/ase.2001.989796 2001

  35. [35]

    In: 2012 34th International Conference on Software Engineering (ICSE), pp 364--374, doi:https://doi.org/10.1109/ICSE.2012.6227178

    McMillan C, Grechanik M, Poshyvanyk D (2012) Detecting similar software applications. In: 2012 34th International Conference on Software Engineering (ICSE), pp 364--374, doi:https://doi.org/10.1109/ICSE.2012.6227178

    work page doi:10.1109/icse.2012.6227178 2012

  36. [36]

    Proc ACM Program Lang 7(OOPSLA2), doi:https://doi.org/10.1145/3622839

    Mehta MK, Krynski S, Gualandi HM, Thakur M, Vitek J (2023) Reusing just-in-time compiled code. Proc ACM Program Lang 7(OOPSLA2), doi:https://doi.org/10.1145/3622839

    work page doi:10.1145/3622839 2023

  37. [37]

    J Syst Softw 158:110407

    Mondal M, Roy B, Roy CK, Schneider KA (2019) An empirical study on bug propagation through code cloning. J Syst Softw 158:110407

    2019

  38. [38]

    Log parsing with prompt-based few-shot learning

    Mordahl A, Zhang Z, Soles D, Wei S (2023) Ecstatic: An extensible framework for testing and debugging configurable static analysis. In: 2023 IEEE/ACM 45th International Conference on Software Engineering (ICSE), pp 550--562, doi:https://doi.org/10.1109/ICSE48619.2023.00056

    work page doi:10.1109/icse48619.2023.00056 2023

  39. [39]

    In: 2023 38th IEEE/ACM International Conference on Automated Software Engineering (ASE), IEEE, pp 837--849

    Mukelabai M, Derks C, Kr \"u ger J, Berger T (2023) To share, or not to share: Exploring test-case reusability in fork ecosystems. In: 2023 38th IEEE/ACM International Conference on Automated Software Engineering (ASE), IEEE, pp 837--849

    2023

  40. [40]

    ://openai.com/index/introducing-gpt-oss

    OpenAI (2025) Introducing gpt-oss. ://openai.com/index/introducing-gpt-oss

    2025

  41. [41]

    J Wirel Mob Netw Ubiquitous Comput Dependable Appl 13(4):94--104

    Park J, Jung S (2022) Android adware detection using soot and cfg. J Wirel Mob Netw Ubiquitous Comput Dependable Appl 13(4):94--104

    2022

  42. [42]

    Int J Sci Technol 2(1):73–79, doi:https://doi.org/10.56127/ijst.v2i1.866

    Pradana MR, Nuryuliani (2023) Redesign of ipusnas application using user centered design method. Int J Sci Technol 2(1):73–79, doi:https://doi.org/10.56127/ijst.v2i1.866

    work page doi:10.56127/ijst.v2i1.866 2023

  43. [43]

    In: Proceedings of the 2015 11th European Dependable Computing Conference, IEEE Computer Society, USA, EDCC'15, pp 132--143, doi:https://doi.org/10.1109/EDCC.2015.23

    Rodriguez LR, Lawall J (2015) Increasing automation in the backporting of linux drivers using coccinelle. In: Proceedings of the 2015 11th European Dependable Computing Conference, IEEE Computer Society, USA, EDCC'15, pp 132--143, doi:https://doi.org/10.1109/EDCC.2015.23

    work page doi:10.1109/edcc.2015.23 2015

  44. [44]

    In: 2008 16th IEEE international conference on program comprehension, IEEE, pp 172--181

    Roy CK, Cordy JR (2008) Nicad: Accurate detection of near-miss intentional clones using flexible pretty-printing and code normalization. In: 2008 16th IEEE international conference on program comprehension, IEEE, pp 172--181

    2008

  45. [45]

    Empir Softw Eng 14(2):131--164

    Runeson P, H \"o st M (2009) Guidelines for conducting and reporting case study research in software engineering. Empir Softw Eng 14(2):131--164

    2009

  46. [46]

    In: Proceedings of the 2018 26th ACM joint meeting on European software engineering conference and symposium on the foundations of software engineering, pp 354--365

    Saini V, Farmahinifarahani F, Lu Y, Baldi P, Lopes CV (2018) Oreo: Detection of clones in the twilight zone. In: Proceedings of the 2018 26th ACM joint meeting on European software engineering conference and symposium on the foundations of software engineering, pp 354--365

    2018

  47. [47]

    In: Proceedings of the 38th international conference on software engineering, pp 1157--1168

    Sajnani H, Saini V, Svajlenko J, Roy CK, Lopes CV (2016) Sourcerercc: Scaling code clone detection to big-code. In: Proceedings of the 38th international conference on software engineering, pp 1157--1168

    2016

  48. [48]

    Salvatore M, Pamuji GC (2025) A design thinking approach to redesigning application x based on user reviews. In: Proceedings of the 8th International Conference on Informatics, Engineering, Science & Technology (INCITEST 2025), Atlantis Press, pp 96--109, doi:https://doi.org/10.2991/978-94-6463-924-7_9

    work page doi:10.2991/978-94-6463-924-7_9 2025

  49. [49]

    Shariffdeen R, Gao X, Duck GJ, Tan SH, Lawall J, Roychoudhury A (2021) Automated patch backporting in linux (experience paper). In: Proceedings of the 30th ACM SIGSOFT International Symposium on Software Testing and Analysis, Association for Computing Machinery, New York, NY, USA, ISSTA 2021, p 633–645, doi:https://doi.org/10.1145/3460319.3464821

    work page doi:10.1145/3460319.3464821 2021

  50. [50]

    ://github.com/soot-oss/soot/pull/1834

    Soot (2022) fix asmmethodsource assignreadops(...). ://github.com/soot-oss/soot/pull/1834

    2022

  51. [51]

    ://github.com/soot-oss/soot/pull/2046

    Soot (2024 a ) Fix always-false condition in <asmmethodsource: void assignreadops(local l)>. ://github.com/soot-oss/soot/pull/2046

    2024

  52. [52]

    ://github.com/soot-oss/soot/pull/2047

    Soot (2024 b ) Fix issue \#1577, and port test cases for issue \#1577. ://github.com/soot-oss/soot/pull/2047

    2024

  53. [53]

    ://github.com/soot-oss/SootUp/pull/311

    SootUp (2020 a ) Feature: jimple.parser. ://github.com/soot-oss/SootUp/pull/311

    2020

  54. [54]

    ://github.com/soot-oss/SootUp/pull/315

    SootUp (2020 b ) Feature/dead assignment eliminator. ://github.com/soot-oss/SootUp/pull/315

    2020

  55. [55]

    ://github.com/soot-oss/SootUp/pull/405

    SootUp (2021 a ) Add test cases for fix from old soot. ://github.com/soot-oss/SootUp/pull/405

    2021

  56. [56]

    ://github.com/soot-oss/SootUp/commit/69058cd

    SootUp (2021 b ) fix cast exception and add fix from old soot. ://github.com/soot-oss/SootUp/commit/69058cd

    2021

  57. [57]

    ://github.com/soot-oss/SootUp/pull/472

    SootUp (2022) Fix asmmethodsource assignreadops(...) always false. ://github.com/soot-oss/SootUp/pull/472

    2022

  58. [58]

    ://github.com/soot-oss/SootUp/pull/867

    SootUp (2024 a ) Adapt identityvalidator with test cases. ://github.com/soot-oss/SootUp/pull/867

    2024

  59. [59]

    ://github.com/soot-oss/SootUp/issues/960

    SootUp (2024 b ) [bug]: Potential issue in gettype method of jushrexpr.java. ://github.com/soot-oss/SootUp/issues/960

    2024

  60. [60]

    ://github.com/soot-oss/SootUp/issues/994

    SootUp (2024 c ) [bug]: Potential missing nulll check in soot but not in sootup. ://github.com/soot-oss/SootUp/issues/994

    2024

  61. [61]

    ://github.com/soot-oss/SootUp/issues/983

    SootUp (2024 d ) [bug]: Potential missing type check for constantdynamic in soot but not in sootup. ://github.com/soot-oss/SootUp/issues/983

    2024

  62. [62]

    ://github.com/soot-oss/SootUp/issues/855

    SootUp (2024 e ) Fix suggestions for soot1577test. ://github.com/soot-oss/SootUp/issues/855

    2024

  63. [63]

    https://github.com/soot-oss/SootUp/, accessed: 2024-09-30

    SootUp (2024 f ) Sootup: A new version of soot with a completely overhauled architecture. https://github.com/soot-oss/SootUp/, accessed: 2024-09-30

    2024

  64. [64]

    ://github.com/soot-oss/SootUp/pull/866

    SootUp (2025 a ) Adapt method validator and add test cases. ://github.com/soot-oss/SootUp/pull/866

    2025

  65. [65]

    ://github.com/soot-oss/SootUp/pull/872

    SootUp (2025 b ) Adapt traps validator from old soot with a test case. ://github.com/soot-oss/SootUp/pull/872

    2025

  66. [66]

    In: Proceedings of the 16th Koli Calling International Conference on Computing Education Research, pp 110--119

    Stuurman S, Passier H, Barendsen E (2016) Analyzing students' software redesign strategies. In: Proceedings of the 16th Koli Calling International Conference on Computing Education Research, pp 110--119

    2016

  67. [67]

    Suh H, Tafreshipour M, Li J, Bhattiprolu A, Ahmed I (2025) An empirical study on automatically detecting ai-generated source code: How far are we? In: Proceedings of the IEEE/ACM 47th International Conference on Software Engineering, IEEE Press, ICSE '25, p 859–871, doi:https://doi.org/10.1109/ICSE55347.2025.00064

    work page doi:10.1109/icse55347.2025.00064 2025

  68. [68]

    In: 2015 IEEE international conference on software maintenance and evolution (ICSME), IEEE, pp 131--140

    Svajlenko J, Roy CK (2015) Evaluating clone detection tools with bigclonebench. In: 2015 IEEE international conference on software maintenance and evolution (ICSME), IEEE, pp 131--140

    2015

  69. [69]

    In: Proceedings of the 2018 26th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering, pp 980--982

    Tomassi DA (2018) Bugs in the wild: examining the effectiveness of static analyzers at finding real-world bugs. In: Proceedings of the 2018 26th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering, pp 980--982

    2018

  70. [70]

    Vall \'e e-Rai R, Gagnon E, Hendren L, Lam P, Pominville P, Sundaresan V (2000) Optimizing java bytecode using the soot framework: Is it feasible? In: Compiler Construction: 9th International Conference, CC 2000 Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2000 Berlin, Germany, March 25--April 2, 2000 Proceeding...

    2000

  71. [71]

    In: 2020 IEEE 27th International Conference on Software Analysis, Evolution and Reengineering (SANER), pp 492--500, doi:https://doi.org/10.1109/SANER48275.2020.9054798

    Van Bladel B, Demeyer S (2020) Clone detection in test code: An empirical evaluation. In: 2020 IEEE 27th International Conference on Software Analysis, Evolution and Reengineering (SANER), pp 492--500, doi:https://doi.org/10.1109/SANER48275.2020.9054798

    work page doi:10.1109/saner48275.2020.9054798 2020

  72. [72]

    J Syst Softw 176:110940, doi:https://doi.org/10.1016/j.jss.2021.110940

    van Bladel B, Demeyer S (2021) A comparative study of test code clones and production code clones. J Syst Softw 176:110940, doi:https://doi.org/10.1016/j.jss.2021.110940

    work page doi:10.1016/j.jss.2021.110940 2021

  73. [73]

    In: Proceedings of the 2015 international symposium on software testing and analysis, pp 71--82

    Wang H, Guo Y, Ma Z, Chen X (2015) Wukong: A scalable and accurate two-phase approach to android app clone detection. In: Proceedings of the 2015 international symposium on software testing and analysis, pp 71--82

    2015

  74. [74]

    In: Proceedings of the 30th IEEE/ACM International Conference on Program Comprehension, pp 516--527

    Wang J, Huang Y, Wang S, Wang Q (2022) Find bugs in static bug finders. In: Proceedings of the 30th IEEE/ACM International Conference on Program Comprehension, pp 516--527

    2022

  75. [75]

    In: Proceedings of the 40th International Conference on Software Engineering, pp 1066--1077

    Wang P, Svajlenko J, Wu Y, Xu Y, Roy CK (2018) Ccaligner: a token based large-gap clone detector. In: Proceedings of the 40th International Conference on Software Engineering, pp 1066--1077

    2018

  76. [76]

    J Syst Softw 199:111618

    Wang W, Deng Z, Xue Y, Xu Y (2023) Ccstokener: Fast yet accurate code clone detection with semantic token. J Syst Softw 199:111618

    2023

  77. [77]

    In: Proceedings of the 2016 24th ACM SIGSOFT International Symposium on Foundations of Software Engineering, pp 1028--1032

    Wang Y, Feng Y, Martins R, Kaushik A, Dillig I, Reiss SP (2016) Hunter: next-generation code reuse for java. In: Proceedings of the 2016 24th ACM SIGSOFT International Symposium on Foundations of Software Engineering, pp 1028--1032

    2016

  78. [78]

    In: Ahmed A (ed) Programming Languages and Systems, Springer International Publishing, Cham, pp 653--682

    Wei S, Mardziel P, Ruef A, Foster JS, Hicks M (2018) Evaluating design tradeoffs in numeric static analysis for java. In: Ahmed A (ed) Programming Languages and Systems, Springer International Publishing, Cham, pp 653--682

    2018

  79. [79]

    In: 2022 IEEE/ACM 37th International Conference on Automated Software Engineering (ASE), doi:https://doi.org/10.1145/3551349.3560426

    Wu Y, Feng S, Zou D, Jin H (2022) Detecting semantic code clones by building ast-based markov chains model. In: 2022 IEEE/ACM 37th International Conference on Automated Software Engineering (ASE), doi:https://doi.org/10.1145/3551349.3560426

    work page doi:10.1145/3551349.3560426 2022

  80. [80]

    In: Proceedings of the 31st ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering, pp 237--249

    Zhang H, Pei Y, Chen J, Tan SH (2023 a ) Statfier: Automated testing of static analyzers via semantic-preserving program transformations. In: Proceedings of the 31st ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering, pp 237--249

    2023

Showing first 80 references.