740 research outputs found
Identification and Remediation of Self-Admitted Technical Debt in Issue Trackers
Technical debt refers to taking shortcuts to achieve short-term goals, which
might negatively influence software maintenance in the long-term. There is
increasing attention on technical debt that is admitted by developers in source
code comments (termed as self-admitted technical debt or SATD). But SATD in
issue trackers is relatively unexplored. We performed a case study, where we
manually examined 500 issues from two open source projects (i.e. Hadoop and
Camel), which contained 152 SATD items. We found that: 1) eight types of
technical debt are identified in issues, namely architecture, build, code,
defect, design, documentation, requirement, and test debt; 2) developers
identify technical debt in issues in three different points in time, and a
small part is identified by its creators; 3) the majority of technical debt is
paid off, 4) mostly by those who identified it or created it; 5) the median
time and average time to repay technical debt are 872.3 and 25.0 hours
respectively.Comment: The 46th Euromicro Conference on Software Engineering and Advanced
Applications (SEAA
What to Fix? Distinguishing between design and non-design rules in automated tools
Technical debt---design shortcuts taken to optimize for delivery speed---is a
critical part of long-term software costs. Consequently, automatically
detecting technical debt is a high priority for software practitioners.
Software quality tool vendors have responded to this need by positioning their
tools to detect and manage technical debt. While these tools bundle a number of
rules, it is hard for users to understand which rules identify design issues,
as opposed to syntactic quality. This is important, since previous studies have
revealed the most significant technical debt is related to design issues. Other
research has focused on comparing these tools on open source projects, but
these comparisons have not looked at whether the rules were relevant to design.
We conducted an empirical study using a structured categorization approach, and
manually classify 466 software quality rules from three industry tools---CAST,
SonarQube, and NDepend. We found that most of these rules were easily labeled
as either not design (55%) or design (19%). The remainder (26%) resulted in
disagreements among the labelers. Our results are a first step in formalizing a
definition of a design rule, in order to support automatic detection.Comment: Long version of accepted short paper at International Conference on
Software Architecture 2017 (Gothenburg, SE
The lifecycle of Technical Debt that manifests in both source code and issue trackers
Context: Although Technical Debt (TD) has increasingly gained attention in recent years, most studies exploring TD are based on a single source (e.g., source code, code comments or issue trackers). Objective: Investigating information combined from different sources may yield insight that is more than the sum of its parts. In particular, we argue that exploring how TD items are managed in both issue trackers and software repositories (including source code and commit messages) can shed some light on what happens between the commits that incur TD and those that pay it back. Method: To this end, we randomly selected 3,000 issues from the trackers of five projects, manually analyzed 300 issues that contained TD information, and identified and investigated the lifecycle of 312 TD items. Results: The results indicate that most of the TD items marked as resolved in issue trackers are also paid back in source code, although many are not discussed after being identified in the issue tracker. Test Debt items are the least likely to be paid back in source code. We also learned that although TD items may be resolved a few days after being identified, it often takes a long time to be identified (around one year). In general, time is reduced if the same developer is involved in consecutive moments (i.e., introduction, identification, repayment decision-making and remediation), but whether the developer who paid back the item is involved in discussing the TD item does not seem to affect how quickly it is resolved. Conclusions: Investigating how developers manage TD across both source code repositories and issue trackers can lead to a more comprehensive oversight of this activity and support efforts to shorten the lifecycle of undesirable debt.</p
Identifying self-admitted technical debt in issue tracking systems using machine learning
Technical debt is a metaphor indicating sub-optimal solutions implemented for
short-term benefits by sacrificing the long-term maintainability and
evolvability of software. A special type of technical debt is explicitly
admitted by software engineers (e.g. using a TODO comment); this is called
Self-Admitted Technical Debt or SATD. Most work on automatically identifying
SATD focuses on source code comments. In addition to source code comments,
issue tracking systems have shown to be another rich source of SATD, but there
are no approaches specifically for automatically identifying SATD in issues. In
this paper, we first create a training dataset by collecting and manually
analyzing 4,200 issues (that break down to 23,180 sections of issues) from
seven open-source projects (i.e., Camel, Chromium, Gerrit, Hadoop, HBase,
Impala, and Thrift) using two popular issue tracking systems (i.e., Jira and
Google Monorail). We then propose and optimize an approach for automatically
identifying SATD in issue tracking systems using machine learning. Our findings
indicate that: 1) our approach outperforms baseline approaches by a wide margin
with regard to the F1-score; 2) transferring knowledge from suitable datasets
can improve the predictive performance of our approach; 3) extracted SATD
keywords are intuitive and potentially indicating types and indicators of SATD;
4) projects using different issue tracking systems have less common SATD
keywords compared to projects using the same issue tracking system; 5) a small
amount of training data is needed to achieve good accuracy.Comment: Accepted for publication in the EMSE journa
Technical Debt Management in OSS Projects: An Empirical Study on GitHub
Technical debt (TD) refers to delayed tasks and immature artifacts that may
bring short-term benefits but incur extra costs of change during maintenance
and evolution in the long term. TD has been extensively studied in the past
decade, and numerous open source software (OSS) projects were used to explore
specific aspects of TD and validate various approaches for TD management (TDM).
However, there still lacks a comprehensive understanding on the practice of TDM
in OSS development, which penetrates the OSS community's perception of the TD
concept and how TD is managed in OSS development. To this end, we conducted an
empirical study on the whole GitHub to explore the adoption and execution of
TDM based on issues in OSS projects. We collected 35,278 issues labeled as TD
(TD issues) distributed over 3,598 repositories in total from the issue
tracking system of GitHub between 2009 and 2020. The findings are that: (1) the
OSS community is embracing the TD concept; (2) the analysis of TD instances
shows that TD may affect both internal and external quality of software
systems; (3) only one TD issue was identified in 31.1% of the repositories and
all TD issues were identified by only one developer in 69.0% of the
repositories; (4) TDM was ignored in 27.3% of the repositories after TD issues
were identified; and (5) among the repositories with TD labels, 32.9% have
abandoned TDM while only 8.2% adopt TDM as a consistent practice. These
findings provide valuable insights for practitioners in TDM and promising
research directions for further investigation.Comment: 15 pages, 8 images, 10 tables, Manuscript submitted to a Journal
(2022
Artificial Intelligence for Technical Debt Management in Software Development
Technical debt is a well-known challenge in software development, and its
negative impact on software quality, maintainability, and performance is widely
recognized. In recent years, artificial intelligence (AI) has proven to be a
promising approach to assist in managing technical debt. This paper presents a
comprehensive literature review of existing research on the use of AI powered
tools for technical debt avoidance in software development. In this literature
review we analyzed 15 related research papers which covers various AI-powered
techniques, such as code analysis and review, automated testing, code
refactoring, predictive maintenance, code generation, and code documentation,
and explores their effectiveness in addressing technical debt. The review also
discusses the benefits and challenges of using AI for technical debt
management, provides insights into the current state of research, and
highlights gaps and opportunities for future research. The findings of this
review suggest that AI has the potential to significantly improve technical
debt management in software development, and that existing research provides
valuable insights into how AI can be leveraged to address technical debt
effectively and efficiently. However, the review also highlights several
challenges and limitations of current approaches, such as the need for
high-quality data and ethical considerations and underscores the importance of
further research to address these issues. The paper provides a comprehensive
overview of the current state of research on AI for technical debt avoidance
and offers practical guidance for software development teams seeking to
leverage AI in their development processes to mitigate technical debt
effectivel
Towards Automated Performance Bug Identification in Python
Context: Software performance is a critical non-functional requirement,
appearing in many fields such as mission critical applications, financial, and
real time systems. In this work we focused on early detection of performance
bugs; our software under study was a real time system used in the
advertisement/marketing domain.
Goal: Find a simple and easy to implement solution, predicting performance
bugs.
Method: We built several models using four machine learning methods, commonly
used for defect prediction: C4.5 Decision Trees, Na\"{\i}ve Bayes, Bayesian
Networks, and Logistic Regression.
Results: Our empirical results show that a C4.5 model, using lines of code
changed, file's age and size as explanatory variables, can be used to predict
performance bugs (recall=0.73, accuracy=0.85, and precision=0.96). We show that
reducing the number of changes delivered on a commit, can decrease the chance
of performance bug injection.
Conclusions: We believe that our approach can help practitioners to eliminate
performance bugs early in the development cycle. Our results are also of
interest to theoreticians, establishing a link between functional bugs and
(non-functional) performance bugs, and explicitly showing that attributes used
for prediction of functional bugs can be used for prediction of performance
bugs
Architectural technical debt identification:The research landscape
Architectural Technical Debt (ATD) regards sub-optimal design decisions that bring short-term benefits to the cost of long-term gradual deterioration of the quality of the architecture of a software system. The identification of ATD strongly influences the technical and economic sustainability of software systems and is attracting growing interest in the scientific community. During the years several approaches for ATD identification have been conceived, each of them addressing ATD from different perspectives and with heterogeneous characteristics. In this paper we apply the systematic mapping study methodology for identifying, classifying, and evaluating the state of the art on ATD identification from the following three perspectives: publication trends, characteristics, and potential for industrial adoption. Specifically, starting from a set of 509 potentially relevant studies, we systematically selected 47 primary studies and analyzed them according to a rigorously-defined classification framework. The analysis of the obtained results supports both researchers and practitioners by providing (i) an assessment of current research trends and gaps in ATD identification, (ii) a solid foundation for understanding existing (and future) research on ATD identification, and (iii) a rigorous evaluation of its potential for industrial adoption
Investigation on Self-Admitted Technical Debt in Open-Source Blockchain Projects
Technical debt refers to decisions made during the design and development of software that postpone the resolution of technical problems or the enhancement of the software's features to a later date. If not properly managed, technical debt can put long-term software quality and maintainability at risk. Self-admitted technical debt is defined as the addition of specific comments to source code as a result of conscious and deliberate decisions to accumulate technical debt. In this paper, we will look at the presence of self-admitted technical debt in open-source blockchain projects, which are characterized by the use of a relatively novel technology and the need to generate trust. The self-admitted technical debt was analyzed using NLP techniques for the classification of comments extracted from the source code of ten projects chosen based on capitalization and popularity. The analysis of self-admitted technical debt in blockchain projects was compared with the results of previous non-blockchain open-source project analyses. The findings show that self-admitted design technical debt outnumbers requirement technical debt in blockchain projects. The analysis discovered that some projects had a low percentage of self-admitted technical debt in the comments but a high percentage of source code files with debt. In addition, self-admitted technical debt is on average more prevalent in blockchain projects and more equally distributed than in reference Java projects.If not managed, the relatively high presence of detected technical debt in blockchain projects could represent a threat to the needed trust between the blockchain system and the users. Blockchain projects development teams could benefit from self-admitted technical debt detection for targeted technical debt management
- …