Towards a prioritization of code debt: A code smell Intensity Index

Fontana, Francesca Arcelli; Ferme, Vincenzo; Zanoni, Marco; Roveda, Riccardo

doi:10.1109/mtd.2015.7332620

Cited by 75 publications

(69 citation statements)

References 30 publications

Supporting

Mentioning

Contrasting

Unclassified

Order By: Relevance

“…Of course, we cannot exclude possible imprecisions in the computation of the dependent variable. Still in this category, we adopted JCodeOdor [32] to identify code smells and assign to them a level of intensity. Our choice was driven by previous results [85] that showed, on the same dataset, that this tool has a high accuracy (i.e., F-Measure=80%).…”

Section: Threats To Construct Validitymentioning

confidence: 99%

“…For severity, we mean a metric able to quantify how much a certain code smell instance is harmful for the design of a source code class. To test our conjecture, we (i) add the intensity index defined by Arcelli Fontana et al [32] in three state of the art change prediction models based on structural [128], process [27], and developer-related metrics [20] and (ii) evaluate-on 43 releases of 14 large systems-how much such addition improves the prediction capabilities of the baseline models. We then compare the performance of the intensity-including change prediction models with the one achievable by exploiting alternative smell-related information such as the antipattern metrics defined by Taba et al [110], which are able to capture historical information on code smell instances (e.g., the recurrence of a certain instance over time).…”

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

Improving change prediction models with code smell-related information

et al. 2019

Self Cite

View full text Add to dashboard Cite

Code smells represent sub-optimal implementation choices applied by developers when evolving software systems. The nagative impact of code smells has been widely investigated in the past: besides developers' productivity and ability to comprehend source code, researchers empirically showed that the presence of code smells heavily impacts the change-proneness of the affected classes. On the basis of these findings, in this paper we conjecture that code smell-related information can be effectively exploited to improve the performance of change prediction models, i.e., models having as goal that of indicating to developers which classes are more likely to change in the future, so that they may apply preventive maintenance actions. Specifically, we exploit the so-called intensity index -a previously defined metric that captures the severity of a code smell-and evaluate its contribution when added as additional feature in the context of three state of the art change prediction models based on product, process, and developer-based features. We also compare the performance achieved by the proposed model with the one of an alternative technique that considers the previously defined antipattern metrics, namely a set of indicators computed considering the history of code smells in files. Our results report that (i) the prediction performance of the intensity-including

show abstract

Section: Threats To Construct Validitymentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

Improving change prediction models with code smell-related information

et al. 2019

Self Cite

View full text Add to dashboard Cite

show abstract

“…In particular, we aim at defining criteria for prioritizing groups of interrelated CAs that might be better indicators of architectural problems. Specifically, we are interested in comparing the anomalies identified as critical by JSpIRIT with other tools for ranking anomalies, such as JCodeOdor . Also, we will investigate improvements to the ranking process.…”

Section: Final Remarks and Future Workmentioning

confidence: 99%

“…Specifically, we are interested in comparing the anomalies identified as critical by JSpIRIT with other tools for ranking anomalies, such as JCodeOdor. 13 Also, we will investigate improvements to the ranking process. In particular, we are interested in new strategies to generate the ranking based on multiple criteria.…”

Section: Final Remarks and Future Workmentioning

confidence: 99%

“…3 Previous studies have focused on analyzing metrics of the source code to detect critical CAs. 12,13 However, source code analysis alone is often not enough to support detection of critical anomalies 2,3 since automatically collected measures just reflect properties of the source code structure. Such measures are often agnostic to the architectural design structure and do not help developers to decide which anomalies are relevant to the architecture.…”

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

Exploring architecture blueprints for prioritizing critical code anomalies: Experiences and tool support

et al. 2018

View full text Add to dashboard Cite

Summary The manifestation of code anomalies in software systems often indicates symptoms of architecture degradation. Several approaches have been proposed to detect such anomalies in the source code. However, most of them fail to assist developers in prioritizing anomalies harmful to the software architecture of a system. This article presents an investigation on how developers, when supported by architecture blueprints, are able to prioritize architecturally relevant code anomalies. First, we performed a controlled experiment where participants explored both blueprints and source code to reveal architecturally relevant code anomalies. Although the use of blueprints has the potential to improve code anomaly prioritization, the participants often made several mistakes. We found these mistakes might occur because developers miss relationships between implementation and blueprint elements when they prioritize anomalies in an ad hoc manner. Furthermore, the time spent on the prioritization process was considerably high. Aiming to improve the accuracy and effectiveness of the process, we provided means to automate the prioritization process. In particular, we explored 3 prioritization criteria, which establish different ways of relating the blueprint elements with code anomalies. These criteria were implemented in the JSpIRIT tool. The approach was evaluated in the context of 2 applications with satisfactory precision results.

show abstract

Context‐based approach to prioritize code smells for prefactoring

Sae-Lim

Hayashi

Saeki

2017

J Software Evolu Process

View full text Add to dashboard Cite

Existing techniques for detecting code smells (indicators of source code problems) do not consider the current context, which renders them unsuitable for developers who have a specific context, such as modules within their focus. Consequently, the developers must spend time identifying relevant smells. We propose a technique to prioritize code smells using the developers' context. Explicit data of the context are obtained using a list of issues extracted from an issue tracking system. We applied impact analysis to the list of issues and used the results to specify the context-relevant smells. Results show that our approach can provide developers with a list of prioritized code smells related to their current context. We conducted several empirical studies to investigate the characteristics of our technique and factors that might affect the ranking quality.Additionally, we conducted a controlled experiment with professional developers to evaluate our technique. The results demonstrate the effectiveness of our technique. KEYWORDScode smell, impact analysis, issue tracking system, prefactoring INTRODUCTIONCode smell, as defined by Fowler, 1-3 is an indicator of design flaws or problems in the source code. Code smells of many types are summarized as smell catalogs. [1][2][3] Code elements that are affected by code smells are recommended for improved quality because they are likely to cause difficulties in the future, as discussed in the literature, eg, making the source code more difficult to understand and maintain or increasing code components' fault-proneness. Moreover, Yamashita et al 4 found that code smells can affect important maintainability aspects. Hermans and Aivaloglou 5 conducted a controlled experiment, which revealed that code smells influence the block-based programming performance of novice programmers.Developers can improve the code by removing the code smells from the elements.Many researchers have examined factors that can introduce code smells into the system. Tufano et al 6 conducted a large-scale empirical study, which revealed that the main activities that tend to introduce code smells are implementing features and enhancing existing ones. Moreover, they found that developers with high workloads and pressure are more likely to introduce a smelly code to the system. Vale et al 7 investigated the factors that can influence code smells based on a software developer's perspective. That investigation revealed that factors such as time pressure, bad design decisions, lack of business knowledge, inexperienced developers, little time for refactoring, and low priority assigned to software quality influence the severity of smelly codes.For issue-driven software development projects, development teams tend to adopt an issue tracking system such as Jira or Bugzilla to manage their lists of issues, so-called backlogs. Such issues can be anything related to software change requests, eg, bug fixing or feature implementation.Developers apply refactoring techniques to source codes before implementing changes ...

show abstract

Towards a prioritization of code debt: A code smell Intensity Index

Cited by 75 publications

References 30 publications

Improving change prediction models with code smell-related information

Improving change prediction models with code smell-related information

Exploring architecture blueprints for prioritizing critical code anomalies: Experiences and tool support

Context‐based approach to prioritize code smells for prefactoring

Contact Info

Product

Resources

About