Pith. sign in

REVIEW 3 major objections 5 minor 27 references

Descriptor: C++ Self-Admitted Technical Debt Dataset (CppSATD)

T0 review · 3 major / 5 minor · reviewed 2026-08-16 · deepseek-v4-flash

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

Pith's one-line read The paper presents CppSATD, a dataset of 531,367 C++ comments labeled into five self-admitted technical debt types or NON-SATD, with surrounding code context, claimed to be the first multiclass C++ SATD dataset.

desk verdict Genuinely useful first C++ multiclass SATD dataset with code contexts, but the NON-SATD set is inferred, and 25 known SATD comments are shipped as negatives. read the letter →

arxiv 2505.01136 v2 pith:JQXUTTW6 submitted 2025-05-02 cs.SE cs.IRcs.LGcs.PL

Phuoc Pham , Murali Sridharan , Matteo Esposito , Valentina Lenarduzzi This is my paper · ORCID
classification cs.SEcs.IRcs.LGcs.PL
keywords technicaldebtself-admittedSATDC++codecommentscontextmulticlassannotationminingsoftwarerepositories
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

This paper introduces CppSATD, a dataset of 531,367 comments mined from five large, active open-source C++ projects, each labeled as one of five self-admitted technical debt (SATD) types — Design/Code, Requirement, Defect, Test, Documentation — or as NON-SATD, and paired with the code immediately before and after it. The authors' central claim is that this is the first C++ SATD dataset with multiclass annotations and surrounding code contexts, filling a gap left by the Java-dominated SATD literature. If the claim holds, researchers gain a large labeled resource for training and evaluating C++ SATD detection, for testing whether Java-era findings generalize across languages, and for studying how debt is admitted in C++ code.

What carries the argument

The mechanism that carries the argument is a two-stage labeling pipeline. Stage one uses pattern matching: 21 Easy-to-Find (ETF) patterns and 656 Hard-to-Find (HTF) patterns — short markers such as 'todo' and longer phrasings such as 'needs to be improved' — to split 531,367 comments into 18,973 candidate SATD comments and 512,394 candidate NON-SATD comments. Stage one also extracts, via the XML-marker tool srcML, the code context preceding and succeeding each comment. Stage two is human annotation: one annotator labels every candidate SATD comment, a second annotator labels a random sample of 16,125 from the candidate NON-SATD pool, and a kappa agreement coefficient on 385-comment subsets (0.86 and 1.0) is used to certify agreement. The statistical sampling step is what converts 'no pattern matched' into a defended NON-SATD label.

What would settle it

Take a fresh random sample of at least 1,000 comments from the 512,394 pattern-missed pool, have two independent annotators label them with the same reference document, and compare the SATD rate to the paper's claimed below-one-percent bound; also re-examine the 16,125-comment sample to see whether the 25 SATD comments were correctly handled. SATD rates meaningfully above one percent, or a re-annotation that finds many missed debt comments, would falsify the NON-SATD certification.

Watch

Extended reading notes

Core claim

On the paper's own terms, the contribution is an artifact with a validation argument. CppSATD is a dataset of 531,367 comments from five popular open-source C++ projects, each comment carrying one of five SATD type labels or NON-SATD, plus the preceding and succeeding code snippets. The authors report that they built it by pattern-filtering with 21 easy-to-find and 656 hard-to-find SATD patterns to isolate 18,973 candidate debt comments, manually annotating those plus a 16,125-comment random sample of the remaining pool, and validating with inter-rater agreement scores of 0.86 for SATD and 1.0 for NON-SATD. Their stated result is that 13,044 comments are positively labeled SATD, the most common types being Design/Code and Requirement debt, and that the rest can be treated as NON-SATD with claimed 99% confidence that hidden SATD in the unfiltered pool is below 1%.

Load-bearing premise

The NON-SATD label on the roughly 512,000 comments that matched no debt pattern is certified by a single random sample of 16,125 comments annotated by one person; if that sample was not representative, or if the 25 debt comments it found were not the only ones, the 'clean' half of the dataset is silently contaminated.

Editorial extensions

If this is right

  • C++ SATD detectors can now be trained and evaluated on five debt types rather than a single binary label, using both comment text and surrounding code context as input.
  • Java-trained SATD detectors can be benchmarked against C++ data, producing direct evidence on whether SATD patterns and type distributions transfer across languages.
  • The 13,044 positively labeled debt comments provide a large corpus for discovering recurring C++ SATD patterns that existing pattern lists miss.
  • The inclusion of code context enables experiments measuring how much preceding and succeeding code improves detection accuracy over comment text alone.
  • Because the dataset comes from five active projects in different domains, it supports studies of how SATD type distributions vary across project domains.

Reading between the lines

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

  • Since the 25 SATD comments found inside the NON-SATD sample were left labeled NON-SATD rather than reclassified, the dataset's 'clean' pool contains known label noise; models trained on it will likely underestimate SATD prevalence and show optimistic precision.
  • A natural next experiment the paper does not run is a context-ablation study: train the same classifier on comment text with and without the code context fields to quantify the value of the surrounding snippets.
  • Cross-language comparisons with the standard Java SATD benchmark will require taxonomy reconciliation, because this dataset merges design and code debt into a single category; headline rate differences between languages should be read after that mapping.
  • The pipeline is repeatable, so the same five repositories could be re-extracted with an expanded pattern list to produce versioned dataset releases with cleaner NON-SATD pools.
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

3 major / 5 minor

Summary. The paper introduces CppSATD, a dataset of 531,367 C++ comments extracted from five large open-source repositories (TensorFlow, React Native, Godot, Bitcoin, Swift), labeled into five SATD types (Design/Code, Requirement, Defect, Test, Documentation) or NON-SATD, and augmented with preceding and succeeding code contexts. The construction pipeline uses srcML for comment extraction, then filters comments against 21 ETF and 656 HTF patterns from Sridharan et al. [12], producing 18,973 candidate SATD comments that were manually annotated by the first author (13,044 SATD and 5,929 NON-SATD). The remaining 512,394 comments are treated as NON-SATD after a random sample of 16,125 was manually annotated by the second author; that sample found 25 SATD comments. Inter-rater agreement was assessed on 385-comment samples, yielding Cohen's kappa 0.86 for SATD annotations and 1.0 for NON-SATD annotations. The authors position CppSATD as the first C++ SATD dataset with multiclass annotations and code contexts, intended to support detection and cross-language SATD research.

Significance. If the label quality is trustworthy, CppSATD fills a real gap: it offers a large C++ corpus with code contexts, a rare multiclass SATD annotation, and a replication package containing scripts, patterns, and the annotation reference document. The manually annotated core (13,044 positives and the 18,973-comment candidate set) is a solid starting point, and the reported kappa of 0.86 for the SATD set is credible. However, the dataset's usefulness for training and, especially, for evaluation depends on the validity of the 512,394 NON-SATD labels, and this is precisely where the descriptor overstates the evidence and ships known label errors. The artifact is valuable in principle, but the descriptor needs substantive corrections to make the provenance and limitations of each label explicit.

major comments (3)
  1. [Abstract, Section D, Records and Storage] The central claim that CppSATD contains 531,367 'annotated' comments is not supported by the described procedure. Section D and Records and Storage show that only 35,098 comments (18,973 candidate SATD plus 16,125 candidate NON-SATD) were manually annotated; the remaining 496,269 comments received the NON-SATD label by pattern-based inference. Moreover, Section D reports that the second author found 25 SATD comments in the 16,125-comment random sample, yet then states that 'we applied the NON-SATD label to all leftover comments after ETF and HTF pattern filtering.' The released dataset therefore contains known false negatives, and the abstract overstates the annotation effort. Please revise the wording to distinguish 'manually annotated' from 'inferred/labeled,' document the 25 known SATD instances explicitly, and either correct their labels in cppsatd.csv or provide a supplementary file listing known mislabeled comments.
  2. [Section D, Eq. (1), Construct Validity] The statistical statement 'we can conclude with a confidence level of 99% that the remaining set has less than 1% chance of containing some SATD comments' misstates what the confidence interval supports. With 25 SATD comments out of 16,125, the observed proportion is 0.155%, and a 99% confidence interval's upper bound is around 0.24%, not a 1% probability that the set contains any SATD. The correct claim is that the data are consistent at 99% confidence with a true prevalence below about 0.24% (and hence also below 1%). In addition, Equation (1) with z=2.58, p=0.5, and E=0.01 gives n=16,589, not 16,125; if a finite-population correction was used, it should be stated. Please report the interval, the correction, and the exact claim precisely.
  3. [Section C and Construct Validity] The decision to label all 512,394 non-matching comments as NON-SATD assumes that the 21 ETF and 656 HTF patterns have near-complete recall for C++. The paper provides no precision/recall evaluation of these patterns on C++ comments, and the only empirical check, the 16,125-comment random sample, already falsifies the zero-hidden-SATD assumption by finding 25 SATD comments. Under simple random sampling, 25/16,125 extrapolates to roughly 794 mislabeled comments in the full 512,394 set. I request a direct estimate: report pattern precision and recall against the 18,973 manually annotated candidate set and the 16,125-comment sample, and use the resulting false-negative rate to state the expected number of mislabeled NON-SATD comments in the full dataset. This number should appear in the dataset descriptor so that downstream users can calibrate evaluation metrics.
minor comments (5)
  1. [Abstract and Records and Storage] Please replace 'annotated' with 'labeled' when referring to all 531,367 comments and reserve 'manually annotated' for the 35,098 comments in manual_annotations.csv; this would align the text with the actual annotation effort.
  2. [Background] The phrase 'the first C++ SATD dataset with multiclass SATD annotations' should be substantiated with a brief literature search or softened to 'to our knowledge, the first'; otherwise the novelty claim is unverifiable.
  3. [Section C, Equation (1)] Please state whether the sample size of 16,125 was computed with a finite-population correction and which z-value and margin of error were used in the final calculation, since the formula and parameter values as printed yield a different number.
  4. [Section C, Table 3] The headers 'ETFSATD' and 'HTFSATD' should read 'ETF SATD' and 'HTF SATD' for consistency with the text.
  5. [References] The dataset DOI appears as 10.5281/zenodo.15275192 in the article metadata and as 10.5281/zenodo.15562944 in reference [22]; please verify which DOI is current and use it consistently.

Circularity Check

1 steps flagged · score 6.0 of 10

NON-SATD labels are defined by the ETF/HTF pattern filter, not by annotation; 25 known SATD comments ship as NON-SATD.

  1. self definitional [Section C 'Data Preparation'; Section D 'Data Annotation'; Records and Storage]
    "The remaining comments that did not match the SATD patterns were conjectured to be NON-SATD. ... we applied the NON-SATD label to all leftover comments after ETF and HTF pattern filtering, thereby finalizing the data annotation."

    The NON-SATD class for the 512,394 leftover comments is defined as the complement of the ETF/HTF pattern matches; no independent manual annotation is performed for these comments. The paper's own random sample found 25 SATD comments in this set (Table 6), yet the final dataset still labels those 25 comments as NON-SATD. Therefore the negative labels are the pattern filter output by construction, not an independently measured or predicted outcome, while Records and Storage claims all 531,367 comments are 'annotated as one of the five SATD types or NON-SATD.' This is a self-definitional reduction: the label is identical to the filtering rule.

full rationale

The paper has one definitional circularity in the negative class. The multiclass positive labels come from manual annotation of the 18,973 candidate SATD comments and are not reduced to the pattern set; however, the 512,394 NON-SATD labels are assigned by the absence of ETF/HTF pattern matches, and the sample-based validation did not correct the 25 known SATD comments, so the 'annotated' claim is partially circular. The citation of [12] (Pentacet) is a self-citation because Murali Sridharan is an author of both works, but it is used as a filtering tool rather than as proof of the target labels; the paper's own sample is the evidence offered, so that self-citation is not in itself load-bearing. The statistical statement that the leftover set has 'less than 1% chance of containing some SATD comments' is incorrect on the paper's own data (25 SATD comments were already found in the sample), but that is a correctness and reporting issue rather than a circularity. Overall, the dataset's negative class reduces by construction to the pattern filter, warranting a score of 6.

Assumptions & free parameters 3 free parameters · 6 assumptions · 0 invented entities

The dataset is a constructed artifact, so the ledger records the design choices, statistical tolerances, tooling assumptions, and representativeness claims it rests on. No new physical or formal entities are introduced; the main epistemic burden is the recall of the external pattern set and the transfer of a Java-era annotation taxonomy to C++.

free parameters (3)
  • NON-SATD sample confidence and margin = z=2.58, E=0.01, p=0.5; formula n=16,641, but 16,125 used
    Hand-chosen design targets for the statistical validation of the NON-SATD label; the sample used is 516 below the formula's requirement.
  • IRA validation sample size = 385 per annotation set
    Derived from 95% confidence and 5% margin, then scaled to equal size; used only for Cohen's kappa assessment, Section V.
  • Repository selection thresholds = at least 65,000 stars, recent commit activity, five repositories
    Hand-chosen inclusion criteria to ensure popularity and activeness; determines the population the dataset represents.
assumptions (6)
  • domain assumption Comments that admit technical debt can be reliably distinguished from other comments by human annotators reading the comment and its code context.
    The manual annotation stage presupposes that SATD is a stable, recognizable property of code comments; the premise enters at Section D (Data Annotation) and underlies the kappa validation.
  • domain assumption The Alves et al. SATD ontology can be reduced to five mutually exclusive categories in code comments: Design/Code, Requirement, Defect, Test, Documentation.
    The paper merges design and code debt and excludes types that rarely appear in comments, following [4] and [5]; it enters in BACKGROUND and Table 1.
  • domain assumption The 21 ETF and 656 HTF patterns from Sridharan et al. [12] transfer to C++ comments with near-complete recall.
    Used to select candidates for manual annotation; the assumption that unselected comments are NON-SATD is only statistically tested on a 16,125-comment sample. Section C, Data Preparation.
  • domain assumption srcML v1.0.0 correctly parses C++ comments from the five repositories at the pinned versions.
    Tooling dependency for comment and context extraction; enters in Section B, Data Extraction.
  • domain assumption The five selected repositories (TensorFlow, React Native, Godot, Bitcoin, Swift) represent C++ development practice.
    Selection criteria are popularity, activeness, and domain diversity; the authors acknowledge limits for smaller projects in External Validity.
  • standard math Standard random sampling with p=0.5 justifies a one-sided bound on the SATD proportion in the unlabelled set.
    Formal basis for concluding the unlabelled set is mostly NON-SATD; enters via Equation 1 and Section D.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Descriptor: C++ Self-Admitted Technical Debt Dataset (CppSATD)." pith.science (2026). https://pith.science/paper/JQXUTTW6

@misc{pith2026250501136,
  author       = {Pith},
  title        = {Pith review of: Descriptor: C++ Self-Admitted Technical Debt Dataset (CppSATD)},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/JQXUTTW6}},
  note         = {Machine review of arXiv:2505.01136}
}
read the original abstract

In software development, technical debt (TD) refers to suboptimal implementation choices made by the developers to meet urgent deadlines and limited resources, posing challenges for future maintenance. Self-Admitted Technical Debt (SATD) is a sub-type of TD, representing specific TD instances ``openly admitted'' by the developers and often expressed through source code comments. Previous research on SATD has focused predominantly on the Java programming language, revealing a significant gap in cross-language SATD. Such a narrow focus limits the generalizability of existing findings as well as SATD detection techniques across multiple programming languages. Our work addresses such limitation by introducing CppSATD, a dedicated C++ SATD dataset, comprising over 531,000 annotated comments and their source code contexts. Our dataset can serve as a foundation for future studies that aim to develop SATD detection methods in C++, generalize the existing findings to other languages, or contribute novel insights to cross-language SATD research.

Figures

Figures reproduced from arXiv: 2505.01136 by the authors.

Figure 1
Figure 1. FIGURE 1 [PITH_FULL_IMAGE:figures/full_fig_p004_1.png] view at source ↗
Figure 2
Figure 2. FIGURE 2 [PITH_FULL_IMAGE:figures/full_fig_p005_2.png] view at source ↗

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

27 extracted references · 17 canonical work pages

  1. [12]

    Pentacet data-23 million contextual code comments and 250,000 satd comments,

    M. Sridharan, L. Rantala, and M. M ¨antyl¨a, “Pentacet data-23 million contextual code comments and 250,000 satd comments,” in2023 IEEE/ACM 20th International Conference on Mining Software Repos- itories (MSR). IEEE, 2023, pp. 412–416

    work page 2023

  2. [1]

    The wycash portfolio management system,

    W. Cunningham, “The wycash portfolio management system,”ACM Sigplan Oops Messenger, vol. 4, no. 2, pp. 29–30, 1992

    1992

  3. [2]

    Early Career Developers’ Perceptions of Code Understandability. A Study of Com- plexity Metrics,

    M. Esposito, A. Janes, T. Kilamo, and V . Lenarduzzi, “Early Career Developers’ Perceptions of Code Understandability. A Study of Com- plexity Metrics,”A Study of Complexity Metrics, 2023

    work page 2023

  4. [3]

    Can We Trust the Default Vulnerabilities Severity?

    M. Esposito, S. Moreschini, V . Lenarduzzi, D. H ¨astbacka, and D. Falessi, “Can We Trust the Default Vulnerabilities Severity?” in23rd IEEE International Working Conference on Source Code Analysis and Manipulation, SCAM 2023, Bogot ´a, Colombia, October 2-3, 2023, L. Moonen, C. D. Newman, and A. Gorla, Eds. IEEE, 2023, pp. 265–270. [Online]. Available: h...

    arXiv 2023

  5. [4]

    Towards an ontology of terms on technical debt,

    N. S. Alves, L. F. Ribeiro, V . Caires, T. S. Mendes, and R. O. Sp ´ınola, “Towards an ontology of terms on technical debt,” in2014 Sixth International Workshop on Managing Technical Debt, 2014, pp. 1– 7

    work page 2014

  6. [5]

    Using natural language processing to automatically detect self-admitted technical debt,

    E. da Silva Maldonado, E. Shihab, and N. Tsantalis, “Using natural language processing to automatically detect self-admitted technical debt,”IEEE Transactions on Software Engineering, vol. 43, no. 11, pp. 1044–1062, 2017

    2017

  7. [6]

    An empirical study on the effectiveness of large language models for satd identification and classification,

    M. S. Sheikhaei, Y . Tian, S. Wang, and B. Xu, “An empirical study on the effectiveness of large language models for satd identification and classification,”Empirical Software Engineering, vol. 29, no. 6, p. 159, 2024

    work page 2024

  8. [7]

    Self-admitted technical debt classification using lstm neural network,

    R. M. Santos, M. C. R. Junior, and M. G. de Mendonc ¸a Neto, “Self-admitted technical debt classification using lstm neural network,” in17th International Conference on Information Technology–New Generations (ITNG 2020), S. Latifi, Ed. Cham: Springer International Publishing, 2020, pp. 679–685

    work page 2020

Show all 27 references
  1. [8]

    Multiclass clas- sification for self-admitted technical debt based on xgboost,

    X. Chen, D. Yu, X. Fan, L. Wang, and J. Chen, “Multiclass clas- sification for self-admitted technical debt based on xgboost,”IEEE Transactions on Reliability, vol. 71, no. 3, pp. 1309–1324, 2022

    2022

  2. [9]

    Detecting multi-type self-admitted technical debt with generative adversarial network-based neural networks,

    J. Yu, X. Zhou, X. Liu, J. Liu, Z. Xie, and K. Zhao, “Detecting multi-type self-admitted technical debt with generative adversarial network-based neural networks,”Information and Software Technology, vol. 158, p. 107190, 2023. [Online]. Available: https: //www.sciencedirect.co...

    2023

  3. [10]

    Identifying self-admitted technical debt through code comment analysis with a contextualized vocabulary,

    M. A. de Freitas Farias, M. G. de Mendonc ¸a Neto, M. Kalinowski, and R. O. Sp ´ınola, “Identifying self-admitted technical debt through code comment analysis with a contextualized vocabulary,” Information and Software Technology, vol. 121, p. 106270, 2020. [Online]. Available...

    2020

  4. [11]

    Notation (bpmn) version 2.0,

    B. P. Model, “Notation (bpmn) version 2.0,”OMG Specification, Object Management Group, vol. 19, pp. 52–60, 2011

    2011

  5. [13]

    Scoring popularity in github,

    A. Al-Rubaye and G. Sukthankar, “Scoring popularity in github,” in2020 International Conference on Computational Science and Computational Intelligence (CSCI), 2020, pp. 217–223

    2020

  6. [14]

    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,” in2013 IEEE International conference on software maintenance. IEEE, 2013, pp. 516–519. VOLUME 00, 2024 7 Phamet al.:...

    2013

  7. [15]

    Detecting and quantifying different types of self-admitted technical debt,

    E. d. S. Maldonado and E. Shihab, “Detecting and quantifying different types of self-admitted technical debt,” in2015 IEEE 7th International Workshop on Managing Technical Debt (MTD), 2015, pp. 9–15

    2015

  8. [16]

    A coefficient of agreement for nominal scales,

    J. Cohen, “A coefficient of agreement for nominal scales,”Educational and psychological measurement, vol. 20, no. 1, pp. 37–46, 1960

    1960

  9. [17]

    Enhancing the defectiveness prediction of methods and classes via JIT,

    D. Falessi, S. M. Laureani, J. C ¸ arka, M. Esposito, and D. A. d. Costa, “Enhancing the defectiveness prediction of methods and classes via JIT,”Empir. Softw. Eng., vol. 28, no. 2, p. 37, 2023. [Online]. Available: https://doi.org/10.1007/s10664-022-10261-z

    2023 doi

  10. [18]

    An Extensive Comparison of Static Application Security Testing Tools,

    M. Esposito, V . Falaschi, and D. Falessi, “An Extensive Comparison of Static Application Security Testing Tools,” inProceedings of the 28th International Conference on Evaluation and Assessment in Software Engineering, EASE 2024, Salerno, Italy, June 18- 21, 2024. ACM, 2024, ...

    2024

  11. [19]

    The kappa statistic in reliability studies: Use, interpretation, and sample size requirements,

    J. Sim and C. C. Wright, “The kappa statistic in reliability studies: Use, interpretation, and sample size requirements,”Physical Therapy, vol. 85, no. 3, pp. 257–268, 03 2005

    2005

  12. [20]

    Beyond Words: On Large Language Models Actionability in Mission- Critical Risk Analysis,

    M. Esposito, F. Palagiano, V . Lenarduzzi, and D. Taibi, “Beyond Words: On Large Language Models Actionability in Mission- Critical Risk Analysis,” inProceedings of the 18th ACM/IEEE International Symposium on Empirical Software Engineering and Measurement, ESEM 2024, Barcelon...

    2024

  13. [21]

    Leveraging Large Language Models for Preliminary Security Risk Analysis: A Mission-Critical Case Study,

    M. Esposito and F. Palagiano, “Leveraging Large Language Models for Preliminary Security Risk Analysis: A Mission-Critical Case Study,” inProceedings of the 28th International Conference on Evaluation and Assessment in Software Engineering, EASE 2024, Salerno, Italy, June 18-2...

    2024

  14. [22]

    Cppsatd: A reusable self-admitted technical debt dataset in c++,

    P. Pham, M. Sridharan, M. Esposito, and V . Lenarduzzi, “Cppsatd: A reusable self-admitted technical debt dataset in c++,” May 2025. [Online]. Available: https://doi.org/10.5281/zenodo.15562944

    2025 doi

  15. [23]

    An exploratory study on self-admitted technical debt,

    A. Potdar and E. Shihab, “An exploratory study on self-admitted technical debt,” in2014 IEEE International Conference on Software Maintenance and Evolution. IEEE, 2014, pp. 91–100

    2014

  16. [24]

    The evolution of technical debt in the apache ecosystem,

    G. Digkas, M. Lungu, A. Chatzigeorgiou, and P. Avgeriou, “The evolution of technical debt in the apache ecosystem,” inSoftware Architecture: 11th European Conference, ECSA 2017, Canterbury, UK, September 11-15, 2017, Proceedings 11. Springer, 2017, pp. 51–66

    2017

  17. [25]

    Tracing the lifecycle of architecture technical debt in software systems: A dependency approach,

    E. Sutoyo, P. Avgeriou, and A. Capiluppi, “Tracing the lifecycle of architecture technical debt in software systems: A dependency approach,” 2025. [Online]. Available: https://arxiv.org/abs/2501.15387

    2025 arXiv

  18. [26]

    Generative AI for Software Architecture. Applications, Trends, Challenges, and Future Direc- tions,

    M. Esposito, X. Li, S. Moreschini, N. Ahmad, T. Cerny, K. Vaid- hyanathan, V . Lenarduzzi, and D. Taibi, “Generative AI for Software Architecture. Applications, Trends, Challenges, and Future Direc- tions,”arXiv preprint arXiv:2503.13310, 2025

    2025 arXiv

  19. [27]

    Wohlin, P

    C. Wohlin, P. Runeson, M. H ¨ost, M. C. Ohlsson, B. Regnell, and A. Wessl ´en,Experimentation in Software Engineering, Second Edition. Springer, 2024. [Online]. Available: https://doi.org/10.1007/ 978-3-662-69306-3 8 VOLUME 00, 2024

    2024

Pith tools

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