Pith. sign in

REVIEW 5 major objections 4 minor 92 references

ScaMaha: A Tool for Parsing, Analyzing, and Visualizing Object-Oriented Software Systems

T0 review · 5 major / 4 minor · reviewed 2026-08-10 · deepseek-v4-flash

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

Pith's one-line read The paper claims that ScaMaha, a static-analysis tool for Java object-oriented code, recovers every code identifier and relation, and that all evaluation metrics reach 100% on the five systems tested.

desk verdict ScaMaha is a genuine integrated parser/analyzer/visualizer, but its 100% accuracy claim is an artifact of a self-defined entity universe rather than an empirical result. read the letter →

arxiv 2501.11001 v1 pith:R3JEEA4C submitted 2025-01-19 cs.SE cs.PL

Ra'Fat Al-Msie'deen This is my paper · ORCID
classification cs.SEcs.PL
keywords reverseengineeringstaticcodeanalysisobject-orientedsoftwaresourceparsingvisualizationmetricsAbstractSyntaxTreeScaMaha
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

The paper sets out to show that one tool can perform the entire reverse-engineering chain for Java object-oriented code: parse source into an XML model, compute metrics from that model, and generate visualizations, without losing any identifier or relation. ScaMaha is the proposed tool, built around a dedicated meta-model and an Abstract Syntax Tree parser. If the reported evaluation is right, the tool achieves 100% precision, recall, and F-measure on all five case-study systems, making manual code review unnecessary for those extraction tasks. A sympathetic reader would take the central claim as: for the tested Java systems, every code artifact is recovered completely and exactly.

What carries the argument

The central object is the ScaMaha meta-model, an abstract description of object-oriented source code rendered as XML: packages, classes, attributes, methods, plus inheritance, method-invocation, and attribute-access relations. The machinery works as an interchange format: the parser maps Java source through the Abstract Syntax Tree into this XML code file, and both the analyzer and the visualizer consume only that XML, so the three components stay modular and extensible. The same meta-model is presented as language-independent, meaning another object-oriented language could feed it as long as a parser produces the same XML shape.

What would settle it

Run ScaMaha on a Java codebase whose known counts are generated independently by a compiler's symbol table, then compare the metrics file: if the reported number of classes, methods, inheritance relations, invocations, or accesses differs from the independent count, the 100% accuracy claim is false.

Watch

Extended reading notes

Core claim

On the paper's own terms, the discovery is that a static-analysis pipeline organized around a single XML schema can be complete and exact for object-oriented Java source. The parser walks the Abstract Syntax Tree and serializes packages, classes, interfaces, superclasses, attributes, methods, parameters, comments, local variables, exceptions, and the relations of inheritance, attribute access, and method invocation into a code file. The analyzer derives ten metrics, including counts of invocation and access relations, and the visualizer renders organization, inheritance, method-invocation, polymetric, and tag-cloud views from the same file. Across drawing shapes, mobile photo, health watcher, Rhino, and ArgoUML, the paper reports that every code file, metrics file, and visualization matched the reference obtained from documentation and manual review, yielding 100% on precision, recall, and F-measure. The paper states that this means software developers will not lose any code identifier or relation from the software code.

Load-bearing premise

The 100% scores depend on the assumption that the software documentation plus the author's manual reading of the code is a complete and correct list of every identifier, relation, and metric; if that reference list misses or mislabels anything, the perfect precision and recall figures are not established.

Editorial extensions

If this is right

  • Software developers can obtain a complete inventory of packages, classes, methods, attributes, comments, parameters, local variables, exceptions, and structural relations without running the code.
  • The XML code file becomes a reusable intermediate artifact that can feed other reverse-engineering tasks such as feature location, traceability recovery, summarization, and software-product-line analysis.
  • The metrics file gives a fast quantitative read on system size and complexity, as in the reported ArgoUML counts of 1,939 classes, 14,904 methods, and 56,758 invocation relations.
  • The visualizations offer an alternative path to understanding legacy code, including inheritance structure, invocation structure, package-level polymetric views, and identifier tag clouds.
  • A parser written for another object-oriented language could reuse the analyzer and visualizer unchanged, provided it emits the same XML format; the current version is limited to Java.
  • If the complete-extraction claim holds, manual code review for these particular identifiers and relations becomes replaceable by an automated, repeatable process.

Reading between the lines

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

  • Editorial extension: a direct test the paper leaves implicit is to run the same pipeline on a system whose ground truth is generated by an independent compiler-grade AST tool rather than documentation and manual review; any discrepancy would narrow the 100% guarantee.
  • Editorial extension: because XML is an interchange format, the meta-model could serve as a neutral bridge between other analysis tools, but the paper only demonstrates the tool consuming its own XML, not interoperation with third-party parsers.
  • Editorial extension: the reported execution time of roughly 32 seconds for ArgoUML suggests interactive exploration of large systems is plausible, but the paper does not report memory use or behavior under repeated runs, so scalability beyond five systems remains open.
  • Editorial extension: a C++ parser emitting the same XML could extend the guarantee to a second language, but the completeness claim has only been shown for Java, so any cross-language claim would need its own evaluation.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

5 major / 4 minor

Summary. The paper presents ScaMaha, a Java reverse-engineering tool that parses object-oriented source code into an XML code file, computes software metrics from that file, and produces several visualizations (code organization, inheritance, method invocation, polymetric views, tag clouds). The tool is built around a fixed meta-model (Section 3, Figure 6, Listing 1) and uses Eclipse JDT/AST for parsing. It is evaluated on five Java case studies of increasing size, and the paper claims 100% precision, recall, and F-measure for all extracted code identifiers, relations, metrics, and visualizations (Section 4).

Significance. If the 100% accuracy and completeness claims were properly supported, ScaMaha would be a useful, easily extensible analysis and visualization platform, especially for small and medium Java systems. The paper's strengths are its concrete tool architecture, its public availability on GitHub and a companion page, and its use of five case studies of different sizes. However, the current evaluation does not establish the central claims: the ground truth is assembled from the author's own documentation and manual review, the meta-model explicitly omits whole classes of Java constructs, Table III is internally inconsistent about visualization results, and no baseline comparison is made. These issues affect the main contribution, so the manuscript needs substantial revision rather than minor polishing.

major comments (5)
  1. [§4, Table III] Table III marks every visualization column (Codea, Classb, Methodc, Polymetricd, Cloude) with '×' for all five case studies, while the text in Section 4 states that the table 'shows the mined code visualizations for each case study' and the paper claims 100% accuracy for visualizations. If '×' means the visualization was not generated, the text is contradicted; if it means the visualization was generated, the table provides no evidence of content or correctness. The symbol must be defined and the per-case-study visualization results must be reported consistently with Figures 8–14.
  2. [§3 (Figure 6, Listing 1) and §4] The paper's central guarantee that 'ScaMaha guarantees that software developers will not lose any code identifier or relation from the software code' is internally inconsistent with the meta-model definition in Section 3, which explicitly says 'this model doesn't show all OO entities' and Listing 1 has no representation for enums, anonymous/local classes, lambdas, generic type parameters or arguments, annotations, static initializers, or imports. A parser built on this meta-model cannot lose what it does not represent, so the guarantee holds only inside the entity universe chosen by the authors, not for arbitrary Java code. The claim needs to be scoped to the meta-model's entity set or the meta-model must be expanded.
  3. [§4, evaluation methodology] The precision/recall computation is circular. The paper states: 'the author uses two resources to evaluate the obtained results. The first is the available software documents, and the second is the manual review of software code.' Both resources are produced or selected by the same author and look for the same entities that the ScaMaha meta-model defines. Consequently, any construct outside the meta-model is absent from both the tool output and the reference list, so a 100% result is obtained by construction. An independent ground truth is needed, for example counts produced by Eclipse JDT's AST visitor, javap output, or another parser such as Spoon or SrcML, and the comparison should be reported per entity type.
  4. [§4, mobile photo evaluation] The reasoning for the 100% score is not an evaluation. The paper says 'the proposed approach returns 15 classes from the software code' and then asserts that 'the software code actually contains only 15 classes' and 'the retrieved value of each metric is totally correct,' but no independent reference count is given for classes, methods, invocation relations, attribute accesses, or LOC. The paper should provide, for each case study and each artifact, a table with reference values, extracted values, true positives, false positives, false negatives, and the resulting precision and recall, rather than a blanket 100% claim.
  5. [§2 and §4] No comparison is made with existing parsers or reverse-engineering tools, despite Section 2 citing Spoon, SrcML, VerveineJ, MoDisco, and Moose. A baseline comparison on the same case studies (e.g., comparing the number of classes, methods, and relations extracted by ScaMaha with those extracted by Eclipse JDT itself or by Spoon) is necessary to support the claims of soundness and accuracy. Without such a comparison, the paper only demonstrates that the tool runs, not that it is correct or complete.
minor comments (4)
  1. [§4, Table III] The table header uses 'Code' and 'Metrics file' with check marks, but no symbol legend is given; the column symbols should be made uniform and explained in the caption.
  2. [§4, execution times] Execution times are reported as single values without mentioning whether these are medians or averages over multiple runs, or the variance across runs; a sentence on measurement methodology would improve reproducibility.
  3. [§3, Listing 2] Listing 2 is a partial example, but the surrounding text and Figure 6 do not explain why the 'MethodAssignments' section appears in the XML schema but is never populated or discussed in the metrics; the tool should state whether assignments are extracted or reserved for future work.
  4. [§4, 'ScaMaha tool in a nutshell'] This paragraph appears inside the experimentation section but contains no experimental content; moving it to Section 3 or the conclusion would improve readability.

Circularity Check

2 steps flagged · score 6.0 of 10

ScaMaha's no-loss guarantee and 100% accuracy are evaluated against a ground truth defined by the same meta-model, making the completeness claim self-referential rather than independently verified.

  1. self definitional [Section 3 (Figure 6, Listing 1) and Section 4 (guarantee)]
    "The main goal of ScaMaha visualizer is to visualize software code entities and relations. All code entities and relations are defined in ScaMaha core meta-model (cf. Figure 6). ... This model shows the majority of OO entities. ... However, while this model doesn’t show all OO entities, it is also valuable since, for most practical purposes in the reverse engineering (resp. re-engineering) process, it is all software developers need. ... ScaMaha guarantees that software developers will not lose any code identifier or relation from the software code."

    The code-file schema (Listing 1), the meta-model (Figure 6), and the parser are mutually definitional: ScaMaha's output XML contains exactly the entities and relations the meta-model enumerates. The guarantee of 'not losing any identifier or relation' therefore holds relative to that enumeration. Since the paper itself concedes that the model 'doesn’t show all OO entities', any Java construct outside the enumeration (enums, anonymous classes, lambdas, generics, annotations, etc.) is invisible both to the parser and to the evaluation's reference, so 100% recall is obtained by construction and cannot falsify the no-loss claim.

  2. other [Section 3 (mobile photo evaluation) and Section 4 (evaluation resources)]
    "In mobile photo software, the proposed approach returns 15 classes from the software code. In this case, the values of all evaluation metrics are equal to 100% since the software code actually contains only 15 classes. ... Mobile photo is well-documented software [79]. Thus, all code entities, metrics, and relations are known in advance. Therefore, the available software documentation helps in comparing ScaMaha results against it. ... In this study, the author uses two resources to evaluate the obtained results."

    Precision and recall are measured against the author's manual review plus existing documentation, not against an external, independently produced reference model of the Java source code. The statement that 'the software code actually contains only 15 classes' is itself established by the same manual-review/documentation process that defines what counts as a class for this study. The 100% metrics therefore compare ScaMaha output with the author's own expectations rather than with a complete, independent parse of the Java grammar; missing constructs outside the expected entity set would not change the reported scores.

full rationale

The paper does not derive a mathematical result, so the circularity concern is about its empirical validation. The central accuracy claim is that ScaMaha recovers 'all' code identifiers and relations with 100% precision, recall, and F-measure. That claim is made circular by the paper's own construction: the meta-model in Figure 6 and Listing 1 defines the fixed set of entities and relations that ScaMaha extracts, the paper explicitly acknowledges that this set is not all OO entities, and the evaluation oracle consists of the author's manual review and existing documentation rather than an independent parse or external benchmark. Consequently, every Java construct outside the meta-model, such as enum constants, anonymous classes, lambda expressions, generics, and annotations, is systematically absent from both the tool output and the reference list. The reported 100% values are consistent with silently dropping all such constructs, so the no-loss guarantee is true by definition within the chosen universe rather than being an empirically established fact about Java reverse engineering. The extensive self-citations to the author's prior parser-based tools are not load-bearing for this specific flaw; the flaw is the self-referential evaluation. Overall, the central completeness claim partially reduces to the model that defines it, warranting a score of 6 rather than a lower score.

Assumptions & free parameters 0 free parameters · 4 assumptions · 0 invented entities

The central claim rests on the reliability of Eclipse JDT and AST parsing, on the completeness of an unverified documentation and manual review ground truth, on the representativeness of five case studies, and on the sufficiency of the proposed meta-model. No free parameters are fitted, and no new physical or conceptual entities are postulated; the meta-model is a design artifact, not an independently evidenced entity.

assumptions (4)
  • domain assumption Eclipse JDT and AST provide a complete and correct parse of Java source code, so all code identifiers and relations reachable by ScaMaha are captured.
    Section 3 states ScaMaha exploits Eclipse JDT and AST to parse systems; if this assumption fails, the parser misses elements. The paper provides no independent verification of parser completeness.
  • domain assumption The software documentation and the author's manual review constitute the complete ground truth for evaluating precision and recall.
    Section 4 states evaluation uses available software documents and manual review; this baseline is not independently audited.
  • domain assumption The five chosen case studies are representative of object-oriented software systems and their documentation is accurate.
    Section 4 selects well-documented systems; this limits generalization to other Java projects.
  • ad hoc to paper The ScaMaha meta-model is sufficient to represent the important object-oriented entities and relations needed for reverse engineering.
    Section 3 admits the model does not show all object-oriented entities but claims it is all developers need; this is a design judgment.

how reviews work

0 comments
Cite this review

Pith. "Pith review of ScaMaha: A Tool for Parsing, Analyzing, and Visualizing Object-Oriented Software Systems." pith.science (2026). https://pith.science/paper/R3JEEA4C

@misc{pith2026250111001,
  author       = {Pith},
  title        = {Pith review of: ScaMaha: A Tool for Parsing, Analyzing, and Visualizing Object-Oriented Software Systems},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/R3JEEA4C}},
  note         = {Machine review of arXiv:2501.11001}
}
read the original abstract

Reverse engineering tools are required to handle the complexity of software products and the unique requirements of many different tasks, like software analysis and visualization. Thus, reverse engineering tools should adapt to a variety of cases. Static Code Analysis (SCA) is a technique for analyzing and exploring software source code without running it. Manual review of software source code puts additional effort on software developers and is a tedious, error-prone, and costly job. This paper proposes an original approach (called ScaMaha) for Object-Oriented (OO) source code analysis and visualization based on SCA. ScaMaha is a modular, flexible, and extensible reverse engineering tool. ScaMaha revolves around a new meta-model and a new code parser, analyzer, and visualizer. ScaMaha parser extracts software source code based on the Abstract Syntax Tree (AST) and stores this code as a code file. The code file includes all software code identifiers, relations, and structural information. ScaMaha analyzer studies and exploits the code files to generate useful information regarding software source code. The software metrics file gives unique metrics regarding software systems, such as the number of method access relations. Software source code visualization plays an important role in software comprehension. Thus, ScaMaha visualizer exploits code files to visualize different aspects of software source code. The visualizer generates unique graphs about software source code, like the visualization of inheritance relations. ScaMaha tool was applied to several case studies from small to large software systems, such as drawing shapes, mobile photo, health watcher, rhino, and ArgoUML. Results show the scalability, performance, soundness, and accuracy of ScaMaha tool. Evaluation metrics, such as precision and recall, demonstrate the accuracy of ScaMaha ...

Figures

Figures reproduced from arXiv: 2501.11001 by the authors.

Figure 1
Figure 1. Typical infrastructure for re-engineering tools. [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. An overview of ScaMaha tool. In this study, the only input for ScaMaha is the OO source code. The first step is aimed at parsing software source code statically using the AST. The output produced by ScaMaha code parser (i.e., parsed code) can be named as metadata (i.e., an XML file called a code file). The parsed code is saved into a code database for further use. The second step of ScaMaha tool is aimed at analyzin… view at source ↗
Figure 4
Figure 4. The main elements of ScaMaha approach. The rest of this paper is arranged as follows: Current studies related to ScaMaha contributions are presented in Section 2. ScaMaha is detailed in Section 3. Experiments are given and discussed in Section 4. Finally, Section 5 concludes this study and provides proposals for future work. 2. Related Work This section offers a literature review associated with ScaMaha contribution… view at source ↗
Figures from the paper (13 more)
Figure 3
Figure 3. Figure 3: presents the use-case diagram of ScaMaha tool. The use-case diagram shows all possible interactions be￾tween external users (i.e., software engineers) and ScaMaha. The use-case diagram displays a collection of actions (called use-cases) that are supported by the propos…
Figure 5
Figure 5. Figure 5: Analyzing and visualizing OO source code with ScaMaha [PITH_FULL_IMAGE:figures/full_fig_p006_5.png]
Figure 6
Figure 6. Figure 6: The core of ScaMaha meta-model. namely ScaMaha model. To analyze the OO software sys￾tem, you must first create a model of it using ScaMaha [PITH_FULL_IMAGE:figures/full_fig_p007_6.png]
Figure 7
Figure 7. Figure 7: An overview of the core parts of ScaMaha tool. [PITH_FULL_IMAGE:figures/full_fig_p010_7.png]
Figure 8
Figure 8. Figure 8: Code organization visualization of mobile photo software [PITH_FULL_IMAGE:figures/full_fig_p010_8.png]
Figure 10
Figure 10. Figure 10: Visualization of class inheritance relations for mobile [PITH_FULL_IMAGE:figures/full_fig_p011_10.png]
Figure 9
Figure 9. Figure 9: Polymetric view of mobile photo software based on its [PITH_FULL_IMAGE:figures/full_fig_p011_9.png]
Figure 11
Figure 11. Figure 11: Visualization of method invocation relations for mobile [PITH_FULL_IMAGE:figures/full_fig_p012_11.png]
Figure 13
Figure 13. Figure 13: Visualization of class inheritance relations for drawing [PITH_FULL_IMAGE:figures/full_fig_p014_13.png]
Figure 12
Figure 12. Figure 12: Polymetric view of drawing shapes software based on its packages. This view uses the following metrics for each package: LOC, NOC, [PITH_FULL_IMAGE:figures/full_fig_p015_12.png]
Figure 14
Figure 14. Figure 14: Tag cloud extracted from the drawing shapes software [PITH_FULL_IMAGE:figures/full_fig_p015_14.png]
Figure 15
Figure 15. Figure 15: An architectural view of ScaMaha tool in a simplified structure. [PITH_FULL_IMAGE:figures/full_fig_p016_15.png]
Figure 16
Figure 16. Figure 16: The Java implementation of ScaMaha tool. [PITH_FULL_IMAGE:figures/full_fig_p016_16.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

92 extracted references · 64 canonical work pages

  1. [1]

    Modular moose: A new generation of software reverse engineering platform,

    N. Anquetil, A. Etien, M. H. Houekpetodji, B. Verhaeghe, S. Ducasse, C. Toullec, F. Djareddir, J. Sudich, and M. Derras, “Modular moose: A new generation of software reverse engineering platform,” in Reuse in Emerging Software Engineering Practices , S. Ben Sassi, S. Ducasse, and H. Mili, Eds. Cham: Springer International Publishing, 2020, pp. 119–134

    2020

  2. [2]

    Identifying key classes for initial software comprehension: Can we do it better?

    W. Pan, X. Du, M. Hua, D. Kim, and Z. Yang, “Identifying key classes for initial software comprehension: Can we do it better?” in 45th IEEE /ACM International Conference on Software Engineering, ICSE 2023, Melbourne, Australia, May 14-20, 2023 . IEEE, 2023, pp. 1878–1889. [Online]. Available: https://doi.org/10.1109/ICSE48619.2023.00160

    arXiv 2023

  3. [3]

    Flexible and cost-e ffective spherical to cartesian coordinate conversion using 3-D CORDIC algorithm on FPGA,

    N. M. Salem, S. I. Serhan, K. M. Al-Tarawneh, and R. Al- Msie’deen, “Flexible and cost-e ffective spherical to cartesian coordinate conversion using 3-D CORDIC algorithm on FPGA,” International Journal of Intelligent Systems and Applications in Engineering, vol. 12, no. 4, pp. 815–823, Jun. 2024. [Online]. Avail- able: https://www.ijisae.org/index.php/IJI...

    2024

  4. [4]

    Comparison between the rules of data storage tools,

    A. A. Shamailh, R. Al-Msie’deen, and A. Alsarhan, “Comparison between the rules of data storage tools,” International Journal of Database Theory and Application, vol. 8, no. 1, pp. 129–136, 2015. [Online]. Available: https: //article.nadiapub.com/IJDTA/vol8 no1/ 14.pdf

    2015

  5. [6]

    Smart city: Definitions, architectures, devel- opment life cycle, technologies, application domains, case studies, challenges and opportunities,

    R. A. Al-Msie’deen, “Smart city: Definitions, architectures, devel- opment life cycle, technologies, application domains, case studies, challenges and opportunities,” 2024, Mutah University

    2024

  6. [7]

    Opportunities and challenges of static code analysis of IEC 61131-3 programs,

    H. Pr ¨ahofer, F. Angerer, R. Ramler, H. Lacheiner, and F. Grillenberger, “Opportunities and challenges of static code analysis of IEC 61131-3 programs,” in Proceedings of 2012 IEEE 17th International Conference on Emerging Technologies & Factory Automation, ETFA 2012, Krakow, Poland, September 17-21, 2012 . IEEE, 2012, pp. 1–8. [Online]. Available: https...

    work page arXiv 2012

  7. [8]

    Static code analysis: a systematic literature review and an industrial survey,

    I. Elkhalifa and B. Ilyas, “Static code analysis: a systematic literature review and an industrial survey,” Master’s thesis, Blekinge Institute of Technology, Department of Software Engineering, 2016

    2016

  8. [9]

    What really changes when developers intend to improve their source code: a commit-level study of static metric value and static analysis warning changes,

    A. Trautsch, J. Erbel, S. Herbold, and J. Grabowski, “What really changes when developers intend to improve their source code: a commit-level study of static metric value and static analysis warning changes,” Empir. Softw. Eng., vol. 28, no. 2, p. 30, 2023. [Online]. Available: https://doi.org/10.1007/s10664-022-10257-9

    work page doi:10.1007/s10664-022-10257-9 2023

Show all 92 references
  1. [10]

    Reverse engineering feature models from software variants to build software product lines: REVPLINE ap- proach,

    R. Al-Msie’deen, “Reverse engineering feature models from software variants to build software product lines: REVPLINE ap- proach,” Ph.D. dissertation, Montpellier 2 University, France, 2014, [Online]. Available: https: //tel.archives-ouvertes.fr/tel-01015102 (Accessed: Nov. 18, 2024)

    2014

  2. [11]

    A comparative analysis of static and dynamic code analysis techniques,

    D. de silva, P. Samarasekara, and R. Hettiarachchi, “A comparative analysis of static and dynamic code analysis techniques,” TechRxiv, 5 ”2023. [Online]. Available: https: //www.techrxiv.org/articles/preprint/A Comparative Analysis of Static and Dynamic Code Analysis Technique...

    2023

  3. [12]

    Sommerville, Software Engineering, 8

    I. Sommerville, Software Engineering, 8. Auflage , ser. it : Infor- matik. Pearson Studium, 2007

    2007

  4. [13]

    Analysis and transformation of source code by parsing and rewriting,

    J. J. Vinju, “Analysis and transformation of source code by parsing and rewriting,” Ph.D. dissertation, University of Amsterdam, 15 November 2005, [Online]. Available: https: //pure.uva.nl/ws/files/ 3816121/37819 Vinju.pdf (Accessed: Nov. 18, 2024)

    2005

  5. [14]

    Menguy, “Black-box code analysis for reverse engineering through constraint acquisition and program synthesis

    G. Menguy, “Black-box code analysis for reverse engineering through constraint acquisition and program synthesis. (analyse de code en bo ˆıte noire pour la r ´etro ing ´enierie via acquisition de contraintes et synth `ese de code),” Ph.D. dissertation, University of Paris-Sacl...

    2023

  6. [15]

    Reverse engineering: Journey from code to design,

    A. Jain, S. Soner, and A. Gadwal, “Reverse engineering: Journey from code to design,” in 2011 3rd International Conference on Electronics Computer Technology, vol. 5, 2011, pp. 102–106

    2011

  7. [16]

    Reengineering UML class diagram variants into a product line architecture,

    W. K. G. Assunc ¸ ˜ao, S. R. Vergilio, and R. E. Lopez-Herrejon, “Reengineering UML class diagram variants into a product line architecture,” in UML-Based Software Product Line Engineering 18 Ra’Fat Al-Msie’deen with SMarty , E. OliveiraJr, Ed. Springer, 2023, pp. 393–414. [On...

    2023 doi

  8. [17]

    Software re-engineering: An overview,

    M. Majthoub, M. H. Qutqut, and Y . Odeh, “Software re-engineering: An overview,” in 2018 8th International Conference on Computer Science and Information Technology (CSIT) , 2018, pp. 266–270

    2018

  9. [18]

    Multilingual source code analysis: A systematic literature review,

    Z. Mushtaq, G. Rasool, and B. Shehzad, “Multilingual source code analysis: A systematic literature review,” IEEE Access , vol. 5, pp. 11 307–11 336, 2017. [Online]. Available: https: //doi.org/10.1109/ACCESS.2017.2710421

    2017

  10. [19]

    Evidence-based soft- ware engineering,

    B. Kitchenham, T. Dyba, and M. Jorgensen, “Evidence-based soft- ware engineering,” in Proceedings. 26th International Conference on Software Engineering . IEEE, 2004, pp. 273–281

    2004

  11. [20]

    Change impact analysis for maintenance and evolution of variable software systems,

    F. Angerer, A. Grimmer, H. Pr ¨ahofer, and P. Gr ¨unbacher, “Change impact analysis for maintenance and evolution of variable software systems,” Autom. Softw. Eng. , vol. 26, no. 2, pp. 417–461, 2019. [Online]. Available: https://doi.org/10.1007/s10515-019-00253-7

    2019 doi

  12. [21]

    Analyzing the actual execution of a large software-intensive system for determining dependencies,

    T. B. C. Arias, P. Avgeriou, and P. America, “Analyzing the actual execution of a large software-intensive system for determining dependencies,” in WCRE 2008, Proceedings of the 15th Working Conference on Reverse Engineering, Antwerp, Belgium, October 15-18, 2008 , A. E. Hassa...

    2008 doi

  13. [22]

    A survey of automatic source code summarization,

    C. Zhang, J. Wang, Q. Zhou, T. Xu, K. Tang, H. Gui, and F. Liu, “A survey of automatic source code summarization,” Symmetry, vol. 14, no. 3, p. 471, 2022. [Online]. Available: https://doi.org/10.3390/sym14030471

    2022 doi

  14. [23]

    A taxonomy for program metamodels in program reverse engineering,

    H. Washizaki, Y .-G. Gu ´eh´eneuc, and F. Khomh, “A taxonomy for program metamodels in program reverse engineering,” in2016 IEEE International Conference on Software Maintenance and Evolution (ICSME), 2016, pp. 44–55

    2016

  15. [24]

    Evaluating the impact of source code parsers on ML4SE models,

    I. Utkin, E. Spirin, E. Bogomolov, and T. Bryksin, “Evaluating the impact of source code parsers on ML4SE models,” CoRR, vol. abs /2206.08713, 2022. [Online]. Available: https: //doi.org/10. 48550/arXiv.2206.08713

    2022 doi arXiv

  16. [25]

    Visualizing object-oriented software for under- standing and documentation,

    R. Al-Msie’deen, “Visualizing object-oriented software for under- standing and documentation,” International Journal of Computer Science and Information Security (IJCSIS) , vol. 13, no. 5, pp. 18– 27, 2015

    2015

  17. [26]

    A comparison of four reverse engineering tools,

    B. Bellay and H. C. Gall, “A comparison of four reverse engineering tools,” in 4th Working Conference on Reverse Engineering, WCRE ’97, Amsterdam, The Netherlands, October 6-8, 1997 , I. D. Baxter, A. Quilici, and C. Verhoef, Eds. IEEE Computer Society, 1997, pp. 2–11. [Online...

    1997

  18. [27]

    MSE and FAMIX 3.0: an interexchange format and source code model family,

    S. Ducasse, N. Anquetil, M. U. Bhatti, A. C. Hora, J. Laval, and T. G ˆırba, “MSE and FAMIX 3.0: an interexchange format and source code model family,” 2011, [Online]. Available: https: //inria. hal.science/hal-00646884/document (Accessed: Nov. 18, 2024)

    2011

  19. [28]

    Feature location in a collection of software product variants using formal concept analysis,

    R. Al-Msie’deen, A. Seriai, M. Huchard, C. Urtado, S. Vauttier, and H. E. Salman, “Feature location in a collection of software product variants using formal concept analysis,” in Safe and Secure Software Reuse - 13th International Conference on Software Reuse, ICSR 2013, Pisa...

    2013

  20. [29]

    Mining features from the object-oriented source code of software variants by combining lexical and structural similarity,

    R. A. Al-Msie’deen, A. Seriai, M. Huchard, C. Urtado, and S. Vauttier, “Mining features from the object-oriented source code of software variants by combining lexical and structural similarity,” in IEEE 14th International Conference on Information Reuse & Integration, IRI 2013...

    2013

  21. [30]

    Mining features from the object-oriented source code of a collection of software variants using formal concept analysis and latent semantic indexing,

    R. Al-Msie’deen, A. Seriai, M. Huchard, C. Urtado, S. Vauttier, and H. E. Salman, “Mining features from the object-oriented source code of a collection of software variants using formal concept analysis and latent semantic indexing,” in The 25th International Conference on Sof...

    2013

  22. [31]

    The impact of the object-oriented software evolution on software metrics: The iris approach,

    R. Al-Msie’deen and A. Blasi, “The impact of the object-oriented software evolution on software metrics: The iris approach,” Indian Journal of Science and Technology , vol. 11, no. 8, pp. 1–8, 2018

    2018

  23. [32]

    CADV: A software visualization approach for code annotations distribution,

    P. Lima, J. Melegati, E. Gomes, N. S. Pereira, E. M. Guerra, and P. Meirelles, “CADV: A software visualization approach for code annotations distribution,” Inf. Softw. Technol. , vol. 154, p. 107089, 2023. [Online]. Available: https: //doi.org/10.1016/j.infsof. 2022.107089

    2023

  24. [33]

    R. A. A. Al-Msie’deen. (2024) ScaMaha. [Online]. Available: https: //drive.google.com/drive/folders/11 CItJ2pPq 1CAWswcjRsAZnhmQO6OQ8 (Accessed: Nov. 18, 2024)

    2024

  25. [34]

    Al-Msie’deen

    R. Al-Msie’deen. (2024) ScaMaha. Accessed: Nov. 18, 2024. [Online]. Available: https://github.com/rafat66/ScaMaha

    2024

  26. [35]

    Modisco: a generic and extensible framework for model driven reverse engineering,

    H. Bruneliere, J. Cabot, F. Jouault, and F. Madiot, “Modisco: a generic and extensible framework for model driven reverse engineering,” in ASE 2010, 25th IEEE /ACM International Conference on Automated Software Engineering, Antwerp, Belgium, September 20-24, 2010 , C. Pecheur,...

    2010

  27. [36]

    Bruneliere

    H. Bruneliere. (2010) MoDisco. [Online]. Available: https: //www. eclipse.org/MoDisco/ (Accessed: Nov. 18, 2024)

    2010

  28. [37]

    Modisco: A model driven reverse engineering framework,

    H. Bruneliere, J. Cabot, G. Dup ´e, and F. Madiot, “Modisco: A model driven reverse engineering framework,” Inf. Softw. Technol., vol. 56, no. 8, pp. 1012–1032, 2014. [Online]. Available: https://doi.org/10.1016/j.infsof.2014.04.007

    2014 doi

  29. [38]

    (2023) VerveineJ

    Moose VerveineJ. (2023) VerveineJ. [Online]. Available: https: //modularmoose.org/moose-wiki/Developers/Parsers/VerveineJ.html (Accessed: Nov. 18, 2024)

    2023

  30. [39]

    (2022) VerveineJ

    Moose Technology. (2022) VerveineJ. [Online]. Available: https: // github.com/moosetechnology/VerveineJ (Accessed: Nov. 18, 2024)

    2022

  31. [40]

    (2023) MooseTechnology

    Moose. (2023) MooseTechnology. [Online]. Available: https: // modularmoose.org/ (Accessed: Nov. 18, 2024)

    2023

  32. [41]

    How to calculate software metrics for multiple languages using open source parsers,

    A. Janes, D. Piatov, A. Sillitti, and G. Succi, “How to calculate software metrics for multiple languages using open source parsers,” in Open Source Software: Quality Verification - 9th IFIP WG 2.13 International Conference, OSS 2013, Koper-Capodistria, Slovenia, June 25-28, 2...

    2013

  33. [42]

    (2023) Eclipse IDE

    Eclipse. (2023) Eclipse IDE. [Online]. Available: https: //www. eclipse.org/ide/ (Accessed: Nov. 18, 2024)

    2023

  34. [43]

    (2023) Javascript Development Tools (JSDT)

    JSDT. (2023) Javascript Development Tools (JSDT). [Online]. Available: https: //www.eclipse.org/webtools/jsdt/ (Accessed: Nov. 18, 2024)

    2023

  35. [44]

    Modernizing parsing tools: parsing and analysis with object-oriented programming,

    S. O’Hara and R. Slavin, “Modernizing parsing tools: parsing and analysis with object-oriented programming,” in Proceedings of the 8th ACM SIGPLAN International Workshop on State Of the Art in Program Analysis, SOAP@PLDI 2019, Phoenix, AZ, USA, June 22, 2019 , N. Grech and T. ...

    2019

  36. [45]

    Visualizing software systems as cities,

    R. Wettel and M. Lanza, “Visualizing software systems as cities,” in Proceedings of the 4th IEEE International Workshop on Visualizing Software for Understanding and Analysis, VISSOFT 2007, Ban ff, Alberta, Canada, June 25-26, 2007 , J. I. Maletic, A. C. Telea, and A. Marcus, ...

    2007

  37. [46]

    Codecity: A comparison of on-screen and virtual reality,

    D. Moreno-Lumbreras, R. Minelli, A. Villaverde, J. M. Gonz ´alez- Barahona, and M. Lanza, “Codecity: A comparison of on-screen and virtual reality,” Inf. Softw. Technol., vol. 153, p. 107064, 2023. [Online]. Available: https://doi.org/10.1016/j.infsof.2022.107064

    2023

  38. [47]

    Software systems as cities: a controlled experiment,

    R. Wettel, M. Lanza, and R. Robbes, “Software systems as cities: a controlled experiment,” in Proceedings of the 33rd International Conference on Software Engineering, ICSE 2011, Waikiki, Honolulu , HI, USA, May 21-28, 2011 , R. N. Taylor, H. C. Gall, and N. Medvidovic, Eds. A...

    2011

  39. [48]

    Concept lattices: A representation space to structure software variability,

    R. AL-msie’deen, M. Huchard, A.-D. Seriai, C. Urtado, S. Vauttier, and A. Al-Khlifat, “Concept lattices: A representation space to structure software variability,” in 2014 5th International Conference on Information and Communication Systems (ICICS), 2014, pp. 1–6

    2014

  40. [49]

    Mining feature models from the object- oriented source code of a collection of software product variants,

    R. A. A. Al-Msie’deen, “Mining feature models from the object- oriented source code of a collection of software product variants,” in Doctoral Symposium of European Conference on Object-Oriented Programming (ECOOP 2013),, Montpellier, France, July 2013, pp. 1–10

    2013

  41. [50]

    Al-Msie’deen, M

    R. Al-Msie’deen, M. Huchard, and C. Urtado, Reverse Engineering Feature Models. LAP LAMBERT Academic Publishing, 2014, iSBN: 9783659614521

    2014

  42. [51]

    Automatic documentation of [mined] feature implementations from source code elements and use-case diagrams with the REVPLINE approach,

    R. Al-Msie’deen, M. Huchard, A. Seriai, C. Urtado, and S. Vauttier, “Automatic documentation of [mined] feature implementations from source code elements and use-case diagrams with the REVPLINE approach,” Int. J. Softw. Eng. Knowl. Eng. , vol. 24, no. 10, pp. 1413–1438, 2014

    2014

  43. [52]

    Reverse engineering feature models from software configurations using formal concept analysis,

    R. A. A. Al-Msie’deen, M. Huchard, A. Seriai, C. Urtado, and S. Vauttier, “Reverse engineering feature models from software configurations using formal concept analysis,” in Proceedings of the Eleventh International Conference on Concept Lattices and Their Applications, Koˇ si...

    2014

  44. [53]

    Documenting the mined feature implementations from the object- oriented source code of a collection of software product variants,

    R. Al-Msie’deen, A. Seriai, M. Huchard, C. Urtado, and S. Vauttier, “Documenting the mined feature implementations from the object- oriented source code of a collection of software product variants,” in The 26th International Conference on Software Engineering and Knowledge En...

    2013

  45. [54]

    Tag clouds for object-oriented source code visualization,

    R. Al-Msie’deen, “Tag clouds for object-oriented source code visualization,” Engineering, Technology & Applied Science Research, vol. 9, no. 3, pp. 4243–4248, 2019. [Online]. Available: https://doi.org/10.48084/etasr.2706

    2019 doi

  46. [55]

    Softcloud: A tool for visualizing software artifacts as tag clouds,

    R. A. Al-Msie’deen, “Softcloud: A tool for visualizing software artifacts as tag clouds,” Mutah Lil-Buhuth wad-Dirasat - Natural and Applied Sciences Series , vol. 37, no. 2, pp. 93–116, 2022

    2022

  47. [56]

    Tag clouds for software documents visualization,

    R. Al-Msie’deen, “Tag clouds for software documents visualization,” International Journal on Informatics Visualization, vol. 3, no. 4, pp. 361–364, 2019

    2019

  48. [57]

    Naming the identified feature implementation blocks from software source code,

    R. Al-Msie’deen, H. E. Salman, A. H. Blasi, and M. A. Alsuwaiket, “Naming the identified feature implementation blocks from software source code,” Journal of Communications Software and Systems , vol. 18, no. 2, pp. 101–110, 2022

    2022

  49. [58]

    Constructing a software requirements specification and design for electronic IT news magazine system,

    R. Al-Msie’deen, A. H. Blasi, and M. A. Alsuwaiket, “Constructing a software requirements specification and design for electronic IT news magazine system,” International Journal of Advanced and Applied Sciences, vol. 8, no. 11, pp. 104–118, 2021

    2021

  50. [59]

    A requirement model of local news we- b/wap application for rural communities,

    R. A. A. Al-Msie’deen, “A requirement model of local news we- b/wap application for rural communities,” Master’s thesis, Universiti Utara Malaysia, Utara, Malaysian, 2008

    2008

  51. [60]

    Requirements traceability: Recovering and visu- alizing traceability links between requirements and source code of object-oriented software systems,

    R. Al-Msie’deen, “Requirements traceability: Recovering and visu- alizing traceability links between requirements and source code of object-oriented software systems,” International Journal of Comput- ing and Digital Systems , vol. 14, no. 1, pp. 1–17, 2023

    2023

  52. [61]

    Recovering traceability links between feature models and source code of product variants,

    H. E. Salman, A. Seriai, C. Dony, and R. Al-Msie’deen, “Recovering traceability links between feature models and source code of product variants,” in Proceedings of the VARiability for You Workshop - Variability Modeling Made Useful for Everyone, VARY ’12, Innsbruck, Austria, ...

    2012

  53. [62]

    Software evolution un- derstanding: Automatic extraction of software identifiers map for object-oriented software systems,

    R. A. Al-Msie’deen and A. H. Blasi, “Software evolution un- derstanding: Automatic extraction of software identifiers map for object-oriented software systems,” Journal of Communications Soft- ware and Systems , vol. 17, no. 1, pp. 20–28, 2021

    2021

  54. [63]

    Supporting software documen- tation with source code summarization,

    R. A. Al-Msie’deen and A. Blasi, “Supporting software documen- tation with source code summarization,” International Journal of Advanced and Applied Sciences , vol. 6, no. 1, pp. 59–67, 2019

    2019

  55. [64]

    Al-Msie’deen, Object-oriented Software Documentation

    R. Al-Msie’deen, Object-oriented Software Documentation . Lap Lambert Academic Publishing, 2019, iSBN: 9786200477279

    2019

  56. [65]

    Automatic labeling of the object-oriented source code: The lotus approach,

    R. A. Al-Msie’deen, “Automatic labeling of the object-oriented source code: The lotus approach,” Science International-Lahore , vol. 30, no. 1, pp. 45–48, 2018

    2018

  57. [66]

    SPOON: A library for implementing analyses 20 Ra’Fat Al-Msie’deen and transformations of java source code,

    R. Pawlak, M. Monperrus, N. Petitprez, C. Noguera, and L. Seinturier, “SPOON: A library for implementing analyses 20 Ra’Fat Al-Msie’deen and transformations of java source code,” Softw. Pract. Exp. , vol. 46, no. 9, pp. 1155–1179, 2016. [Online]. Available: https://doi.org/10....

    2016 doi

  58. [67]

    SrcML: An infrastructure for the exploration, analysis, and manipulation of source code: A tool demonstration,

    M. L. Collard, M. J. Decker, and J. I. Maletic, “SrcML: An infrastructure for the exploration, analysis, and manipulation of source code: A tool demonstration,” in 2013 IEEE International Conference on Software Maintenance, Eindhoven, The Netherlands, September 22-28, 2013 . I...

    2013

  59. [68]

    Proposing and assessing a software visualization approach based on polymetric views,

    R. Francese, M. Risi, G. Scanniello, and G. Tortora, “Proposing and assessing a software visualization approach based on polymetric views,” J. Vis. Lang. Comput. , vol. 34-35, pp. 11–24, 2016. [Online]. Available: https://doi.org/10.1016/j.jvlc.2016.05.001

    2016 doi

  60. [69]

    Towards the visualization of software systems as 3d forests: the codetrees environment,

    U. Erra and G. Scanniello, “Towards the visualization of software systems as 3d forests: the codetrees environment,” in Proceedings of the ACM Symposium on Applied Computing, SAC 2012, Riva, Trento, Italy, March 26-30, 2012 , S. Ossowski and P. Lecca, Eds. ACM, 2012, pp. 981–9...

    2012

  61. [70]

    Polymetric views - A lightweight visual approach to reverse engineering,

    M. Lanza and S. Ducasse, “Polymetric views - A lightweight visual approach to reverse engineering,” IEEE Trans. Software Eng., vol. 29, no. 9, pp. 782–795, 2003. [Online]. Available: https://doi.org/10.1109/TSE.2003.1232284

    2003 arXiv

  62. [71]

    Systematic software reuse with automated extraction and composition for clone-and-own,

    L. Linsbauer, S. Fischer, G. K. Michelon, W. K. G. Assunc ¸ ˜ao, P. Gr ¨unbacher, R. E. Lopez-Herrejon, and A. Egyed, “Systematic software reuse with automated extraction and composition for clone-and-own,” in Handbook of Re-Engineering Software Intensive Systems into Software...

    2023

  63. [72]

    The story of moose: an agile reengineering environment,

    O. Nierstrasz, S. Ducasse, and T. G ˆırba, “The story of moose: an agile reengineering environment,” in Proceedings of the 10th European Software Engineering Conference held jointly with 13th ACM SIGSOFT International Symposium on Foundations of Software Engineering, 2005, Lis...

    2005

  64. [73]

    Bergel, Agile Visualization

    A. Bergel, Agile Visualization. LULU Press, 2016

    2016

  65. [74]

    Lightweight multilingual software analysis,

    D. M. Lyons, A. M. Bogar, and D. Baird, “Lightweight multilingual software analysis,” in Proceedings of the 12th International Conference on Software Technologies, ICSOFT 2017, Madrid, Spain, July 24-26, 2017 , J. Cardoso, L. A. Maciaszek, M. van Sinderen, and E. Cabello, Eds....

    2017 doi

  66. [75]

    Al-Msie’deen, A

    R. Al-Msie’deen, A. Seriai, and M. Huchard, Reengineering Soft- ware Product Variants Into Software Product Line: REVPLINE Approach. LAP LAMBERT Academic Publishing, 2014

    2014

  67. [76]

    Detecting commonality and variability in use-case diagram variants,

    R. Al-Msie’deen, A. H. Blasi, H. E. Salman, S. S. Alja’afreh, A. Abadleh, M. A. Alsuwaiket, A. Hammouri, A. J. Al Nawaiseh, W. Tarawneh, and S. A. Al-Showarah, “Detecting commonality and variability in use-case diagram variants,” Journal of Theoretical and Applied Information ...

    2022

  68. [77]

    Papers with code or without code? impact of github repository usability on the diffusion of machine learning research,

    D. Kang, T. Kang, and J. Jang, “Papers with code or without code? impact of github repository usability on the diffusion of machine learning research,” Inf. Process. Manag. , vol. 60, no. 6, p. 103477, 2023. [Online]. Available: https: //doi.org/10.1016/j.ipm.2023.103477

    2023

  69. [78]

    Components meet aspects: Assessing design stability of a software product line,

    L. P. Tizzei, M. O. Dias, C. M. F. Rubira, A. Garcia, and J. Lee, “Components meet aspects: Assessing design stability of a software product line,” Inf. Softw. Technol., vol. 53, no. 2, pp. 121–136, 2011. [Online]. Available: https://doi.org/10.1016/j.infsof.2010.08.007

    2011 doi

  70. [79]

    Figueiredo

    E. Figueiredo. (2011) MobileMedia - java implementation. [Online]. Available: https: //homepages.dcc.ufmg.br/∼figueiredo/spl/ icse08/ (Accessed: Nov. 18, 2024)

    2011

  71. [80]

    BushraDBR: An automatic approach to re- trieving duplicate bug reports,

    R. A. Al-Msie’deen, “BushraDBR: An automatic approach to re- trieving duplicate bug reports,” International Journal of Computing and Digital Systems , vol. 15, no. 1, pp. 221–238, 2024

    2024

  72. [81]

    On the evaluation of code smells and detection tools,

    T. Paiva, A. Damasceno, E. Figueiredo, and C. Sant’Anna, “On the evaluation of code smells and detection tools,” J. Softw. Eng. Res. Dev. , vol. 5, p. 7, 2017. [Online]. Available: https://doi.org/10.1186/s40411-017-0041-1

    2017 doi

  73. [82]

    (2023) Rhino: JavaScript in Java - Version 1.7R2

    Mozilla-rhino. (2023) Rhino: JavaScript in Java - Version 1.7R2. [Online]. Available: https: //github.com/mozilla/rhino# rhino-javascript-in-java (Accessed: Nov. 18, 2024)

    2023

  74. [83]

    Open-source software product line extraction processes: the argouml-spl and phaser cases,

    R. A. F. Moreira, W. K. G. Assunc ¸ ˜ao, J. Martinez, and E. Figueiredo, “Open-source software product line extraction processes: the argouml-spl and phaser cases,” Empir. Softw. Eng., vol. 27, no. 4, p. 85, 2022. [Online]. Available: https: //doi.org/10.1007/s10664-021-10104-3

    2022 doi

  75. [84]

    Al-Msie’deen

    R. Al-Msie’deen. (2018) Drawing shapes software. [Online]. Avail- able: https: //sites.google.com/site/ralmsideen/tools (Accessed: Nov. 18, 2024)

    2018

  76. [85]

    (2023) Health watcher software - Version 10

    Health-Watcher. (2023) Health watcher software - Version 10. [On- line]. Available: https: //ptolemy.cs.iastate.edu/design-study/ (Ac- cessed: Nov. 18, 2024)

    2023

  77. [86]

    (2010) ArgoUML software

    ArgoUML. (2010) ArgoUML software. [Online]. Available: https: //argouml-tigris-org.github.io/tigris/argouml/ (Accessed: Nov. 18, 2024)

    2010

  78. [87]

    A. M. Davis, 201 principles of software development . McGraw- Hill, 1995

    1995

  79. [88]

    J. Hunter. (2000) JDOM. [Online]. Available: https: //github.com/ hunterhacker/jdom/ (Accessed: Nov. 18, 2024)

    2000

  80. [89]

    (1991) Graphviz

    AT&T-Labs-Research. (1991) Graphviz. [Online]. Available: https: //graphviz.org/ (Accessed: Nov. 18, 2024)

    1991

  81. [90]

    Software product maintenance: A case study,

    S. A. Butt, M. Acosta-Coll, and S. Misra, “Software product maintenance: A case study,” in Computer Information Systems and Industrial Management - 21st International Conference, CISIM 2022, Barranquilla, Colombia, July 15-17, 2022, Proceedings , ser. Lecture Notes in Computer...

    2022 doi

  82. [519]

    Available: https: //doi.org/10.1109/ICSM.2013.85

    [Online]. Available: https: //doi.org/10.1109/ICSM.2013.85

    2013 doi

  83. [2013]

    IEEE Computer Society, 2013, pp. 586–593. [Online]. Available: https://doi.org/10.1109/IRI.2013.6642522

    2013

  84. [2024]

    Available: https: //arxiv.org/pdf/2408.01454

    [Online]. Available: https: //arxiv.org/pdf/2408.01454

    arXiv

Pith tools

Reviewed August 10, 2026 · model on record in the stance chip above.