Pith. sign in

REVIEW 4 major objections 6 minor 63 references

A Comprehensive Study of Bug-Fix Patterns in Autonomous Driving Systems

T0 review · 4 major / 6 minor · reviewed 2026-08-09 · deepseek-v4-flash

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

Pith's one-line read An analysis of 1,331 bug fixes yields the first taxonomy of bug-fix patterns for autonomous driving systems.

desk verdict Useful first ADS bug-fix taxonomy and benchmark, but the single-file PR filter may skew the headline frequencies; worth peer review with a required sensitivity analysis. read the letter →

arxiv 2502.01937 v1 pith:YV6HZK3P submitted 2025-02-04 cs.SE cs.RO

Yuntianyi Chen , Yuqi Huai , Yirui He , Shilong Li , Changnam Hong , Qi Alfred Chen , Joshua Garcia This is my paper · ORCID
classification cs.SEcs.RO
keywords bug-fixpatternsautonomousdrivingsystemsempiricalsoftwarestudyApolloAutowaretaxonomyautomatedprogramrepairdefects
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 tries to establish what kinds of repairs actually recur when autonomous driving software breaks. By examining 1,331 fixed bugs drawn from 15,099 pull requests in two open-source driving systems, Apollo and Autoware, it proposes a hierarchy of ADS bugs and two taxonomies: 15 syntactic patterns that describe code-level edits and 27 semantic patterns that describe the intent behind the fix. The study reports that method-call changes, if-related logic edits, path-planning optimization, and data-flow correction dominate, and it shows that fix frequencies vary across modules and root causes. If correct, the work gives developers and researchers the first classification of ADS bug-fix patterns plus a public benchmark of 1,331 instances to support automated program repair and testing.

What carries the argument

The central object is the modularization-granularity hierarchy, a seven-level labeling scheme that ranges from broad ADS modules down to individual code statements, with syntactic and semantic bug-fix-pattern categories attached at the appropriate layers. The two taxonomies carry the argument: the 15 syntactic patterns classify the literal code edit, such as method call, if-related, or return changes, while the 27 semantic patterns classify the repair's intent in the driving domain, such as Path Planning Optimization, Data Flow Correction, or State Management Enhancement. The hierarchy's role is to make each labeled fix comparable so that frequencies, root-cause links, and module links can be computed and turned into empirical findings.

What would settle it

An independent team, blind to the proposed taxonomies, could re-label a random sample of the 1,331 pull requests and compare category frequencies; if their labels diverge substantially from the paper's, or if applying the semantic taxonomy to a third open-source ADS leaves a large share of fixes uncategorized, the classification's reliability and generality would be cast into doubt.

Watch

Extended reading notes

Core claim

The paper's central claim is that bug fixing in autonomous driving systems follows recognizable, classifiable patterns that span two levels. At the syntactic level, fixes are grouped into 15 patterns such as method-call changes, if-related condition edits, and assignment changes; at the semantic level, 27 patterns capture the underlying intent, split into domain-specific ones such as Path Planning Optimization and Sensor Data Interpretation and domain-independent ones such as Data Flow Correction and Configuration and Environment Management. The paper further organizes this knowledge through a modularization-granularity hierarchy that ties symptoms, root causes, modules, sub-modules, algorithms, and fix actions together. Its findings include that Method Call and If-related fixes together form over 40 percent of syntactic patterns, that Path Planning Optimization accounts for 22.9 percent of semantic patterns, and that the Planning module hosts 548 semantic bug-fix instances across about 50 sub-modules.

Load-bearing premise

The findings stand or fall on whether the manually assigned labels are accurate, since two co-authors who are contributors to Apollo and Autoware labeled all 1,331 fixes and their project familiarity could bias the taxonomy even though inter-rater agreement stayed above 80 percent.

Editorial extensions

If this is right

  • Automated program repair for ADS can be targeted: the frequent Adjust Return Values and Fix API Misuse actions suggest where repair tools would get the most use.
  • Testing can be prioritized by pattern: the dominance of Data Flow Correction points to data-flow coverage and integration testing as high-value investments.
  • The Planning module's 548 semantic fix instances across about 50 sub-modules indicate that architectural modularization, not just fault localization, affects fixability.
  • Config-related bugs cluster in Configuration and Environment Management, Build and Compilation Enhancement, and Module Integration and Interaction, showing that configuration repair deserves dedicated tooling.
  • The benchmark of 1,331 labeled bug-fix instances gives future work a common dataset for evaluating ADS repair and debugging techniques.

Reading between the lines

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

  • The same modularization-granularity labeling could be tested on other cyber-physical systems, since the hierarchy's top semantic levels are domain-agnostic and would reveal whether these fix-pattern frequencies are ADS-specific.
  • Because the taxonomy is built only from merged single-file pull requests in two open-source systems, multi-file fixes and closed-source development processes may follow different patterns; a natural extension would be to check whether the most common actions change when multi-file fixes are included.
  • The high agreement between the two expert labelers does not measure how easily a non-expert or an automated classifier could reproduce the labels, so a practical next step is an annotator study with developers unfamiliar with the taxonomy.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

4 major / 6 minor

Summary. The paper presents an empirical study of bug-fix patterns in two open-source autonomous driving systems, Apollo and Autoware. The authors collect 1,331 bug-fix pull requests from 15,099 pull requests, manually label each with root cause, symptom, module, sub-module, algorithm, syntactic bug-fix pattern, semantic bug-fix pattern, and bug-fix action, and report frequency distributions across these dimensions. They contribute a hierarchy of ADS bugs by modularization granularity, a taxonomy of 15 syntactic and 27 semantic bug-fix patterns, and a publicly available benchmark. The main findings are that Method Call and If-related syntactic patterns, Path Planning Optimization and Data Flow Correction semantic patterns, and actions such as Adjust Return Values and Update System Config are most frequent; they also report module-specific concentrations, such as the Planning module dominating semantic bug-fix patterns. The paper frames this as the first bug-fix pattern study specific to the ADS domain.

Significance. If the results hold, this is a useful empirical contribution: the ADS domain is safety-critical and under-served by bug-fix pattern studies, and the proposed hierarchy and taxonomies could inform automated program repair, testing, and debugging tools. The dataset of 1,331 labeled instances is larger than comparable bug-fix studies in other domains, and the authors make it publicly available. The use of two independent open-source ADSes with different governance models adds breadth. The inter-rater agreement procedure and reconciliation with project developers are appropriate qualitative-research practices. However, the paper's central frequency claims are all derived from a deliberately filtered subset (single-file bug-fix PRs), and the paper does not establish whether that filter biases the reported pattern frequencies; the internal count inconsistency (887 vs. 877 for the Algorithm root cause) and the unsupported use of the word 'significant' further weaken the precision of the conclusions. The descriptive taxonomy itself is plausible, but the empirical support for the strongest frequency-based findings needs strengthening.

major comments (4)
  1. [§3.1, Tables 5–6, Findings 1–16] The dataset is restricted to 'closed and merged single-file pull requests that fix bugs.' This filter is load-bearing because every frequency in Tables 5–6 and every Finding from RQ1–RQ5 is computed on this filtered sample. A single-file PR cannot by construction span multiple modules, so cross-module and multi-file fixes are structurally excluded. This is especially concerning for patterns the paper emphasizes, such as Module Integration and Interaction (MII), Data Flow Correction (DFC), and Configuration and Environment Management (CEM), which commonly require coordinated changes across files. The paper reports no quantification of the excluded multi-file bug-fix PRs and no robustness check comparing single-file vs. multi-file distributions. Without such analysis, the reported 'most common' patterns may reflect the sampling filter rather than properties of ADS bug fixing. The authors should either justify the filter's neutrality, analyze the excluded PRs, or explicitly recast the claims as applying only to single-file fixes.
  2. [§5.3, Finding 8] The text states 'The Algorithm (Alg) root cause has a significant occurrence of 887 bug fixes,' while Finding 8 reports 'Algorithm-related bug fixes, with a total of 877 occurrences.' These numbers are inconsistent and both cannot be correct for the same dataset. Since several findings depend on exact occurrence counts, this discrepancy needs to be reconciled. It also raises a broader concern about whether all counts in Figures 3–5 and Tables 5–7 were checked against the underlying labeled data.
  3. [Abstract and §5.1–§5.5] The abstract claims that 'the frequency distribution of bug-fix patterns varies significantly depending on their nature and types,' and the text repeatedly uses 'significant' for specific counts (e.g., §5.3, Finding 8). However, no statistical tests, confidence intervals, or effect sizes are reported for any comparison between projects, modules, root causes, or symptoms. For example, the difference between Apollo and Autoware for Path Planning Optimization (9.2% vs. 27.3% in Table 6) is discussed as meaningful, but there is no test of whether this difference exceeds sampling variability. The authors should either add appropriate statistical analyses (e.g., chi-square or proportion tests with appropriate corrections) or soften the language to descriptive claims without the word 'significant.'
  4. [§3.3 and §7 (Internal Threats)] All findings depend on manually assigned labels by two co-authors who are contributors to Apollo and Autoware. The paper reports that Cohen's Kappa 'persistently exceeded 80%,' but does not report per-category agreement, which is important because some categories have very low frequencies (e.g., Switch 0.1%, Security Strengthening 0.2%) where kappa values can be unstable. The open-coding procedure also derives and refines the taxonomy on the same dataset that is later used to report frequencies, so label assignment and taxonomy design are not fully independent. The threats-to-validity section mentions bias mitigation through open coding and developer consultation, but it does not assess whether the authors' project familiarity could systematically influence labeling choices. I recommend reporting per-label kappa values and, if feasible, having an independent rater label a random sample to validate the stability of the taxonomy.
minor comments (6)
  1. [§4.1 and Table 5] The taxonomy names the syntactic pattern 'Document Fix (DOC)' in §4.1, but Table 5 labels it 'Documentation (DOC).' Please use consistent terminology.
  2. [Figures 2–5] The heatmaps in Figures 3–5 contain many small numeric cells that are difficult to read in a printed or PDF version. Consider providing the underlying matrices as accessible tables in an appendix or in the artifact repository.
  3. [Figure 2] Several labels contain stray spaces, e.g., 'Modify A voidance Processing' and 'Modify A voidance Processing' should read 'Modify Avoidance Processing.' Please proofread the figure text.
  4. [§3.1] The sentence 'Such pull requests enable us to (1) scrutinize ... and (2) avoid too many bugs and bug-fix patterns that occurred in one pull request to interfere with the evaluation and analysis' is grammatically awkward. Clarify whether the concern is about confounding multiple patterns or about analysis difficulty.
  5. [§5.1, Finding 1] The percentages for IF (18.3%) and MC (23.9%) are computed across syntactic patterns, but the text in the same paragraph switches to describing them as 'nearly one-quarter of all bug-fix patterns.' Since Table 5 percentages are within the syntactic pattern category, the 'all bug-fix patterns' phrasing could be misread as applying to the full dataset; please clarify the denominator.
  6. [§5.4] Finding 13 reports '178 STOP-related bug-fix patterns,' but the immediate context mentions 'the significant count of 178 STOP-related bug-fix patterns'; the preceding sentence says 'State Management Enhancement (SME) patterns are most commonly observed in Stop and Parking (Stop) (23 occurrences).' It would help to explicitly state what 'STOP-related' aggregates include (e.g., all semantic patterns co-occurring with the Stop symptom) to avoid confusion.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the study's taxonomies and frequencies are derived from manual open-coding of 1,331 bug-fix pull requests, not from a fitted parameter or a self-citation chain.

full rationale

This paper is a descriptive empirical study rather than a predictive or derivation chain. The central claims—the frequencies of syntactic and semantic bug-fix patterns, bug-fix actions, and their distributions across root causes, symptoms, and modules—are computed directly from labels that two co-authors assigned to each bug-fix pull request using open coding. There is no fitted parameter that is later renamed as a prediction, and no formal derivation whose conclusion is equal to an input by construction. The reuse of the authors' prior root-cause and symptom taxonomies [37] is transparent: Section 3.3 states that the work 'commenced with the root cause and symptom taxonomies in a previous ADS bug study [37]' and then explicitly extended them via open coding, adding new root causes such as SNT and DEP. The semantic bug-fix taxonomy, which is the paper's main novel contribution, is explicitly stated to have no prior taxonomy and was derived from the data itself. A taxonomy induced from the same data it then describes is descriptive, not circular, and the paper does not claim to have independently validated the inherited taxonomy against an external ground truth. The single-file pull-request filter and the reliance on manual labeling are validity threats that could bias frequencies, but they are not circularity: the data collection and labeling procedure do not assume the results they produce. Therefore, no load-bearing argument reduces to a self-citation or to the study's own inputs.

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

The study rests on methodological assumptions about sampling, labeling reliability, and generalizability rather than mathematical axioms. The main load-bearing premises are listed above; the absence of statistical tests and the reliance on author labeling are the most consequential.

assumptions (4)
  • domain assumption Keyword-based pull request filtering identifies representative bug fixes.
    Section 3.1. The study selects merged single-file PRs whose titles or contexts contain fix-related keywords; this heuristic may miss fixes with unrelated wording and is a standard but imperfect proxy.
  • domain assumption Apollo and Autoware are representative of production ADS software.
    Section 7. The study generalizes from two open-source projects; the authors acknowledge that closed-source or smaller ADS projects may have different patterns.
  • ad hoc to paper Manual labels assigned by two co-authors are accurate and unbiased.
    Section 3.3. Both labelers are contributors to the projects under study; inter-rater agreement is reported as Kappa >80%, but the potential for conflict-of-interest bias is only partially mitigated by reconciliation sessions.
  • domain assumption Root cause and symptom taxonomies from Garcia et al. [37] are valid for this dataset.
    Section 3.3. The study reuses the earlier ADS bug taxonomies as a foundation and augments them with new categories; if the earlier taxonomies are incomplete, the labeling misses relevant bug types.
invented entities (3)
  • Syntactic bug-fix pattern taxonomy (15 patterns) independent evidence
    purpose: Classify code-level structural changes in bug-fix commits, extending prior taxonomies with ADS-relevant patterns such as Syntax, Document Fix, and Library.
    The patterns have explicit definitions and the released benchmark of 1,331 instances allows others to validate or refute the classification; most patterns are adaptations of existing work.
  • Semantic bug-fix pattern taxonomy (27 patterns) independent evidence
    purpose: Classify high-level repair strategies, especially domain-specific ones like Path Planning Optimization and Sensor Data Interpretation.
    The dataset provides a falsifiable handle: other researchers can re-label the PRs and check whether the 27 categories and their frequencies hold.
  • Modularization granularity hierarchy
    purpose: Provide a seven-level framework linking modules, algorithms, code statements, symptoms, root causes, and repair actions for systematic debugging.
    This is a conceptual analytical tool introduced by the paper; it is not directly testable against external data, though it organizes the labeling.

how reviews work

0 comments
Cite this review

Pith. "Pith review of A Comprehensive Study of Bug-Fix Patterns in Autonomous Driving Systems." pith.science (2026). https://pith.science/paper/YV6HZK3P

@misc{pith2026250201937,
  author       = {Pith},
  title        = {Pith review of: A Comprehensive Study of Bug-Fix Patterns in Autonomous Driving Systems},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/YV6HZK3P}},
  note         = {Machine review of arXiv:2502.01937}
}
read the original abstract

As autonomous driving systems (ADSes) become increasingly complex and integral to daily life, the importance of understanding the nature and mitigation of software bugs in these systems has grown correspondingly. Addressing the challenges of software maintenance in autonomous driving systems (e.g., handling real-time system decisions and ensuring safety-critical reliability) is crucial due to the unique combination of real-time decision-making requirements and the high stakes of operational failures in ADSes. The potential of automated tools in this domain is promising, yet there remains a gap in our comprehension of the challenges faced and the strategies employed during manual debugging and repair of such systems. In this paper, we present an empirical study that investigates bug-fix patterns in ADSes, with the aim of improving reliability and safety. We have analyzed the commit histories and bug reports of two major autonomous driving projects, Apollo and Autoware, from 1,331 bug fixes with the study of bug symptoms, root causes, and bug-fix patterns. Our study reveals several dominant bug-fix patterns, including those related to path planning, data flow, and configuration management. Additionally, we find that the frequency distribution of bug-fix patterns varies significantly depending on their nature and types and that certain categories of bugs are recurrent and more challenging to exterminate. Based on our findings, we propose a hierarchy of ADS bugs and two taxonomies of 15 syntactic bug-fix patterns and 27 semantic bug-fix patterns that offer guidance for bug identification and resolution. We also contribute a benchmark of 1,331 ADS bug-fix instances.

Figures

Figures reproduced from arXiv: 2502.01937 by the authors.

Figure 1
Figure 1. Hierarchy of ADS Bug-Fix Pattern by Modularization Granularity On the semantic level, we have Module and Sub-module labels which indicate the major compo￾nents and their subdivisions respectively, facilitating a high-level understanding and management of the system. We also have Algorithm/Function labels that reveal the intricate details of the system’s functionality and operational logic. Finally, at the most granu… view at source ↗
Figure 2
Figure 2. Domain-Specific Bug-Fix Actions with Occurrences Object and obstacle processing emerges as one of the most important ADS functionalities, with bug-fix actions like 98 occurrences of Modify Avoidance Processing, 30 of Modify Obstacle Prediction, and 29 of Modify Object Detection being highly frequent. This demonstrates that ensuring system’s ability to detect, predict, and avoid obstacles is a top priority. These act… view at source ↗
Figure 3
Figure 3. Relation between root causes and Semantic BFPs for both ADSes Finding 9: Most configuration-related bugs are fixed by Configuration and Environment Manage￾ment (CEM), Build and Compilation Enhancement (BCE), and Module Integration and Interaction (MII) patterns (207 occurrences in total), indicating the need for comprehensive fixes that span both source code and configurations. This situation emphasizes the critical… view at source ↗
Figures from the paper (2 more)
Figure 4
Figure 4. Figure 4: Relation between Symptoms and Semantic Bug [PITH_FULL_IMAGE:figures/full_fig_p016_4.png]
Figure 6
Figure 6. Figure 6: Distribution of Sub-modules in Planning Module [PITH_FULL_IMAGE:figures/full_fig_p017_6.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

63 extracted references · 55 canonical work pages

  1. [1]

    Toyota Follows Tesla In Developing A Vision-Based Self-Driving System

    April 2022. Toyota Follows Tesla In Developing A Vision-Based Self-Driving System. https://bit.ly/3TQQNuw

    work page 2022

  2. [2]

    40+ Corporations Working On Autonomous Vehicles

    December 2020. 40+ Corporations Working On Autonomous Vehicles. https://bit.ly/3PdBpGu

    work page 2020

  3. [3]

    Baidu launches Apollo Open Source Platform 9.0

    December 2023. Baidu launches Apollo Open Source Platform 9.0. https://autonews.gasgoo.com/m/70030171.html A Comprehensive Study of Bug-Fix Patterns in Autonomous Driving Systems 21

    work page arXiv 2023

  4. [4]

    Artifacts of the ADS Bug-Fix Pattern Study

    February 2025. Artifacts of the ADS Bug-Fix Pattern Study. https://bit.ly/40HITaA

    work page 2025

  5. [5]

    You can take a ride in a self-driving Lyft during CES - The Verge

    January 2018. You can take a ride in a self-driving Lyft during CES - The Verge. https://bit.ly/3Rh1p6s

    work page 2018

  6. [6]

    Baidu starts mass production of autonomous buses

    July 2018. Baidu starts mass production of autonomous buses. https://bit.ly/3oJXrSy

    work page 2018

  7. [7]

    Waymo’s autonomous cars have driven 8 million miles on public roads

    July 2018. Waymo’s autonomous cars have driven 8 million miles on public roads. https://bit.ly/43uSNwb

    work page 2018

  8. [8]

    CARMA Overview

    June 2019. CARMA Overview. https://bit.ly/44JQ423

    work page 2019

Show all 63 references
  1. [9]

    Baidu is building Level 4 autonomous robotaxis called Apollo Moon in China

    June 2021. Baidu is building Level 4 autonomous robotaxis called Apollo Moon in China. https://bit.ly/3HQ46qH

    2021

  2. [10]

    GM’s Cruise starts charging fares for driverless rides in San Francisco

    June 2022. GM’s Cruise starts charging fares for driverless rides in San Francisco. https://reut.rs/40rtGJu

    2022

  3. [11]

    Udacity: Self-Driving Fundamentals: Featuring Apollo

    March 2022. Udacity: Self-Driving Fundamentals: Featuring Apollo. https://bit.ly/3RnMVC0

    2022

  4. [12]

    Baidu hits the gas on autonomous vehicles with Volvo and Ford deals

    November 2018. Baidu hits the gas on autonomous vehicles with Volvo and Ford deals. https://tcrn.ch/3EL8Prj

    2018

  5. [13]

    Ford unveils new self-driving test vehicle for 2022 launch

    October 2020. Ford unveils new self-driving test vehicle for 2022 launch. https://cnb.cx/3zi2AIQ

    2020

  6. [14]

    Tesla Sold 2 Million Electric Cars: First Automaker To Reach Milestone

    October 2021. Tesla Sold 2 Million Electric Cars: First Automaker To Reach Milestone. https://bit.ly/3G1zDVm

    2021

  7. [15]

    The 18 Companies Most Likely to Get Driverless Cars on the Road First

    September 2017. The 18 Companies Most Likely to Get Driverless Cars on the Road First. https://bit.ly/3sFsNRo

    2017

  8. [16]

    Waymo and Intel Collaborate on Self-Driving Car Technology

    September 2017. Waymo and Intel Collaborate on Self-Driving Car Technology. https://bit.ly/4d71Mbg

    2017

  9. [17]

    Past, Present and the Future of Autoware - Autoware

    September 2022. Past, Present and the Future of Autoware - Autoware. https://bit.ly/4clFkKW

    2022

  10. [18]

    Apollo Architecture Evolution

    September 2024. Apollo Architecture Evolution. https://bit.ly/3PnTVwL

    2024

  11. [19]

    Baidu Apollo: An open autonomous driving platform

    September 2024. Baidu Apollo: An open autonomous driving platform. https://en.apollo.auto/apollo-self-driving

    2024

  12. [20]

    Debug Autoware - Autoware Documentation

    September 2024. Debug Autoware - Autoware Documentation. https://bit.ly/3zkkTRg

    2024

  13. [21]

    GitHub - Apollo: An open autonomous driving platform

    September 2024. GitHub - Apollo: An open autonomous driving platform. https://bit.ly/3XSQUa5

    2024

  14. [22]

    GitHub - Autoware: An open-source software project for autonomous driving

    September 2024. GitHub - Autoware: An open-source software project for autonomous driving. https://bit.ly/3MIaiCH

    2024

  15. [23]

    GitHub - CARMA Platform

    September 2024. GitHub - CARMA Platform. https://bit.ly/45GZGvN

    2024

  16. [24]

    How to Debug Apollo

    September 2024. How to Debug Apollo. https://bit.ly/3TNhvpq

    2024

  17. [25]

    Planning component design - Autoware Documentation

    September 2024. Planning component design - Autoware Documentation. https://bit.ly/3SDUzrE

    2024

  18. [26]

    Waymo - Self-Driving Cars - Autonomous Vehicles

    September 2024. Waymo - Self-Driving Cars - Autonomous Vehicles. https://waymo.com/

    2024

  19. [27]

    Paolo Arcaini, Alessandro Calò, Fuyuki Ishikawa, Thomas Laurent, Xiao-Yi Zhang, Shaukat Ali, Florian Hauer, and Anthony Ventresque. 2021. Parameter-Based Testing and Debugging of Autonomous Driving Systems. In IEEE Intelligent Vehicles Symposium Workshops, IV 2021 - Workshops,...

    2021

  20. [28]

    Holger Banzhaf, Dennis Nienhüser, Steffen Knoop, and Johann Marius Zöllner. 2017. The future of parking: A survey on automated valet parking with an outlook on high density parking. In IEEE Intelligent Vehicles Symposium, IV 2017, Los Angeles, CA, USA, June 11-14, 2017 . IEEE,...

    2017

  21. [29]

    Erik Blair. 2015. A reflexive exploration of two qualitative data coding techniques.Journal of Methods and Measurement in the Social Sciences 6, 1 (2015), 14–29

    2015

  22. [30]

    Eduardo Cunha Campos and Marcelo de Almeida Maia. 2017. Common Bug-Fix Patterns: A Large-Scale Observational Study. In 2017 ACM/IEEE International Symposium on Empirical Software Engineering and Measurement, ESEM 2017, Toronto, ON, Canada, November 9-10, 2017 , Ayse Bener, Bur...

    2017 doi

  23. [31]

    Eduardo Cunha Campos and Marcelo de Almeida Maia. 2019. Discovering common bug-fix patterns: A large-scale observational study. J. Softw. Evol. Process. 31, 7 (2019). https://doi.org/10.1002/SMR.2173

    2019 doi

  24. [32]

    Krzysztof Czarnecki. 2018. Operational design domain for automated driving systems. Taxonomy of Basic Terms “, Waterloo Intelligent Systems Engineering (WISE) Lab, University of Waterloo, Canada (2018)

    2018

  25. [34]

    Marc Eaddy, Alfred Aho, and Gail C. Murphy. 2007. Identifying, Assigning, and Quantifying Crosscutting Concerns. In First International Workshop on Assessment of Contemporary Modularization Techniques (ACoM ’07) . 2–2. https: //doi.org/10.1109/ACOM.2007.4

    2007 doi

  26. [35]

    Sherwood, Vibhav Garg, Gail C

    Marc Eaddy, Thomas Zimmermann, Kaitin D. Sherwood, Vibhav Garg, Gail C. Murphy, Nachiappan Nagappan, and Alfred V. Aho. 2008. Do Crosscutting Concerns Cause Defects? IEEE Trans. Software Eng. 34, 4 (2008), 497–515. https://doi.org/10.1109/TSE.2008.36

    2008 doi

  27. [36]

    Anthony Di Franco, Hui Guo, and Cindy Rubio-González. 2017. A comprehensive study of real-world numerical bug characteristics. In Proceedings of the 32nd IEEE/ACM International Conference on Automated Software Engineering, ASE 2017, Urbana, IL, USA, October 30 - November 03, 2...

    2017

  28. [38]

    Kaifeng Huang, Bihuan Chen, Susheng Wu, Junming Cao, Lei Ma, and Xin Peng. 2023. Demystifying Dependency Bugs in Deep Learning Stack. In Proceedings of the 31st ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering, ESEC/FS...

    2023

  29. [39]

    Kai Huang, Zhengzi Xu, Su Yang, Hongyu Sun, Xuejun Li, Zheng Yan, and Yuqing Zhang. 2023. A Survey on Automated Program Repair Techniques. CoRR abs/2303.18184 (2023). https://doi.org/10.48550/ARXIV.2303.18184 arXiv:2303.18184

    2023 doi arXiv

  30. [40]

    André Ibisch, Stefan Stümper, Harald Altinger, Marcel Neuhausen, Marc Tschentscher, Marc Schlipsing, Jan Salinen, and Alois C. Knoll. 2013. Towards autonomous driving in a parking garage: Vehicle localization and tracking using environment-embedded LIDAR sensors. In 2013 IEEE ...

    2013

  31. [41]

    Md Johirul Islam, Giang Nguyen, Rangeet Pan, and Hridesh Rajan. 2019. A comprehensive study on deep learning bug characteristics. In Proceedings of the ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering, ESEC/...

    2019

  32. [42]

    Md Johirul Islam, Rangeet Pan, Giang Nguyen, and Hridesh Rajan. 2020. Repairing deep neural networks: fix patterns and challenges. In ICSE ’20: 42nd International Conference on Software Engineering, Seoul, South Korea, 27 June - 19 July, 2020, Gregg Rothermel and Doo-Hwan Bae ...

    2020

  33. [43]

    Md Rakibul Islam and Minhaz F. Zibran. 2020. How bugs are fixed: exposing bug-fix patterns with edits and nesting levels. In SAC ’20: The 35th ACM/SIGAPP Symposium on Applied Computing, online event, [Brno, Czech Republic], March 30 - April 3, 2020 , Chih-Cheng Hung, Tomás Cer...

    2020

  34. [44]

    Guannan Lou, Yao Deng, Xi Zheng, Mengshi Zhang, and Tianyi Zhang. 2022. Testing of autonomous driving systems: where are we and where should we go?. InProceedings of the 30th ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engine...

    2022

  35. [45]

    Robert C Martin. 2000. Design principles and design patterns. Object Mentor 1, 34 (2000), 597

    2000

  36. [46]

    Mary L McHugh. 2012. Interrater reliability: the kappa statistic. Biochemia medica 22, 3 (2012), 276–282

    2012

  37. [47]

    Pascal Minnerup, David Lenz, Tobias Kessler, and Alois Knoll. 2016. Debugging Autonomous Driving Systems Using Serialized Software Components. IFAC-PapersOnLine 49, 15 (2016), 44–49. https://doi.org/10.1016/j.ifacol.2016.07.612 9th IFAC Symposium on Intelligent Autonomous Vehi...

    2016 doi

  38. [48]

    Cliodhna O’Connor and Helene Joffe. 2020. Intercoder Reliability in Qualitative Research: Debates and Practical Guidelines. International Journal of Qualitative Methods 19 (2020), 1609406919899220. https://doi.org/10.1177/ 1609406919899220 arXiv:https://doi.org/10.1177/1609406...

    2020 doi

  39. [49]

    James Whitehead Jr

    Kai Pan, Sunghun Kim, and E. James Whitehead Jr. 2009. Toward an understanding of bug fix patterns. Empir. Softw. Eng. 14, 3 (2009), 286–315. https://doi.org/10.1007/s10664-008-9077-5

    2009 doi

  40. [50]

    Morgan Quigley, Ken Conley, Brian Gerkey, Josh Faust, Tully Foote, Jeremy Leibs, Rob Wheeler, Andrew Y Ng, et al

  41. [51]

    Christina Rödel, Susanne Stadler, Alexander Meschtscherjakov, and Manfred Tscheligi. 2014. Towards Autonomous Cars: The Effect of Autonomy Levels on Acceptance and User Experience. In Proceedings of the 6th International Conference on Automotive User Interfaces and Interactive...

    2014

  42. [52]

    Seaman, Forrest Shull, Myrna Regardie, Denis Elbert, Raimund L

    Carolyn B. Seaman, Forrest Shull, Myrna Regardie, Denis Elbert, Raimund L. Feldmann, Yuepu Guo, and Sally Godfrey. 2008. Defect categorization: making use of a decade of widely varying historical data. In Proceedings of the Second International Symposium on Empirical Software ...

    2008

  43. [53]

    Mauricio Soto, Ferdian Thung, Chu-Pan Wong, Claire Le Goues, and David Lo. 2016. A deeper look into bug fixes: patterns, replacements, deletions, and additions. In Proceedings of the 13th International Conference on Mining Software Repositories, MSR 2016, Austin, TX, USA, May ...

    2016

  44. [54]

    Ting Su, Ke Wu, Weikai Miao, Geguang Pu, Jifeng He, Yuting Chen, and Zhendong Su. 2017. A Survey on Data-Flow Testing. ACM Comput. Surv. 50, 1 (2017), 5:1–5:35. https://doi.org/10.1145/3020266

    2017 doi

  45. [55]

    Jie Tang, Shaoshan Liu, Songwen Pei, Stéphane Zuckerman, Chen Liu, Weisong Shi, and Jean-Luc Gaudiot. 2018. Teaching Autonomous Driving Using a Modular and Integrated Approach. In2018 IEEE 42nd Annual Computer Software and Applications Conference, COMPSAC 2018, Tokyo, Japan, 2...

    2018

  46. [56]

    Marius Zöllner, and Christoph Stiller

    Ömer Sahin Tas, Florian Kuhnt, J. Marius Zöllner, and Christoph Stiller. 2016. Functional system architectures towards fully automated driving. In 2016 IEEE Intelligent Vehicles Symposium, IV 2016, Gotenburg, Sweden, June 19-22, 2016 . IEEE, 304–309. https://doi.org/10.1109/IV...

    2016

  47. [57]

    Ferdian Thung, Shaowei Wang, David Lo, and Lingxiao Jiang. 2012. An Empirical Study of Bugs in Machine Learning Systems. In 23rd IEEE International Symposium on Software Reliability Engineering, ISSRE 2012, Dallas, TX, USA, November 27-30, 2012. IEEE Computer Society, 271–280....

    2012 doi

  48. [58]

    Devanbu, and Vladimir Filkov

    Bogdan Vasilescu, Yue Yu, Huaimin Wang, Premkumar T. Devanbu, and Vladimir Filkov. 2015. Quality and productivity outcomes relating to continuous integration in GitHub. In Proceedings of the 2015 10th Joint Meeting on Foundations of Software Engineering, ESEC/FSE 2015, Bergamo...

    2015

  49. [59]

    Vieira, Uzay Kaymak, and João M

    Susana M. Vieira, Uzay Kaymak, and João M. C. Sousa. 2010. Cohen’s kappa coefficient as a performance measure for feature selection. In FUZZ-IEEE 2010, IEEE International Conference on Fuzzy Systems, Barcelona, Spain, 18-23 July, 2010, Proceedings. IEEE, 1–8. https://doi.org/1...

    2010

  50. [60]

    Elaine J. Weyuker. 1990. The Cost of Data Flow Testing: An Empirical Study. IEEE Trans. Software Eng. 16, 2 (1990), 121–128. https://doi.org/10.1109/32.44376

    1990 doi

  51. [61]

    Fiorella Zampetti, Ritu Kapur, Massimiliano Di Penta, and Sebastiano Panichella. 2022. An empirical characterization of software bugs in open-source Cyber-Physical Systems. J. Syst. Softw. 192 (2022), 111425. https://doi.org/10.1016/J. JSS.2022.111425

    2022

  52. [62]

    Quanjun Zhang, Chunrong Fang, Yuxiang Ma, Weisong Sun, and Zhenyu Chen. 2024. A Survey of Learning-based Automated Program Repair. ACM Trans. Softw. Eng. Methodol. 33, 2 (2024), 55:1–55:69. https://doi.org/10.1145/3631974

    2024 doi

  53. [63]

    Yuhao Zhang, Yifan Chen, Shing-Chi Cheung, Yingfei Xiong, and Lu Zhang. 2018. An empirical study on TensorFlow program bugs. In Proceedings of the 27th ACM SIGSOFT International Symposium on Software Testing and Analysis, ISSTA 2018, Amsterdam, The Netherlands, July 16-21, 201...

    2018

  54. [64]

    Hao Zhong and Zhendong Su. 2015. An Empirical Study on Real Bug Fixes. In 37th IEEE/ACM International Conference on Software Engineering, ICSE 2015, Florence, Italy, May 16-24, 2015, Volume 1 , Antonia Bertolino, Gerardo Canfora, and Sebastian G. Elbaum (Eds.). IEEE Computer S...

    2015 doi

  55. [2009]

    In ICRA workshop on open source software , Vol

    ROS: an open-source Robot Operating System. In ICRA workshop on open source software , Vol. 3. Kobe, Japan, 5

Pith tools

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