Prioritization of Code Anomalies Based on Architecture Sensitiveness

Arcoverde, Roberta; Guimarães, Everton; Macia, Isela; Garcia, Alessandro; Cai, Yuanfang

doi:10.1109/sbes.2013.14

Cited by 22 publications

(10 citation statements)

References 30 publications

(56 reference statements)

Supporting

Mentioning

Contrasting

Order By: Relevance

“…The techniques have focused on different methods such as a severity-based technique where code smells with higher severity are given higher priority [11]- [13], a context-based technique where code smells are prioritized according to the specific contexts of developers [14], or by using combinations of multiple factors to prioritize code smells [15]- [17].…”

Section: Introductionmentioning

confidence: 99%

An Investigative Study on How Developers Filter and Prioritize Code Smells

Sae-Lim

Hayashi

Saeki

2018

IEICE Trans. Inf. & Syst.

View full text Add to dashboard Cite

Code smells are indicators of design flaws or problems in the source code. Various tools and techniques have been proposed for detecting code smells. These tools generally detect a large number of code smells, so approaches have also been developed for prioritizing and filtering code smells. However, lack of empirical data detailing how developers filter and prioritize code smells hinders improvements to these approaches. In this study, we investigated ten professional developers to determine the factors they use for filtering and prioritizing code smells in an open source project under the condition that they complete a list of five tasks. In total, we obtained 69 responses for code smell filtration and 50 responses for code smell prioritization from the ten professional developers. We found that Task relevance and Smell severity were most commonly considered during code smell filtration, while Module importance and Task relevance were employed most often for code smell prioritization. These results may facilitate further research into code smell detection, prioritization, and filtration to better focus on the actual needs of developers.

show abstract

Section: Introductionmentioning

confidence: 99%

An Investigative Study on How Developers Filter and Prioritize Code Smells

Sae-Lim

Hayashi

Saeki

2018

IEICE Trans. Inf. & Syst.

View full text Add to dashboard Cite

show abstract

“…The aforementioned need for agglomeration prioritization shows that the time and effort required to identify design problems is a key factor for developers; thus, prioritization should be taken into consideration. As a matter of fact, the prioritization of smelly code has been the focus of recent research [38][39][40]. The work of Vidal et al [40], for example, proposed and assessed a set of criteria for prioritizing smell agglomerations.…”

Section: How To Improve Design Problem Identification?mentioning

confidence: 99%

On the identification of design problems in stinky code: experiences and tool support

et al. 2018

Self Cite

View full text Add to dashboard Cite

Background: Developers often have to locate design problems in the source code. Several types of design problems may manifest as code smells in the program. A code smell is a source code structure that may reveal a partial hint about the manifestation of a design problem. Recent studies suggest that developers should ignore smells occurring in isolation in a program location. Instead, they should focus on analyzing stinkier code, i.e., program locations-e.g., a class or a hierarchy-affected by multiple smells. There is evidence that the stinkier a program location is, the more likely it contains a design problem. However, there is no empirical evidence on whether developers can effectively identify a design problem in stinkier code. Developers may struggle to make an analysis of inter-related smells affecting the same program location. Besides that, the analysis of stinkier code may require proper tool support due to its analysis complexity. However, there is little knowledge on what are the requirements for a tool that helps developers in revealing stinkier program locations. As a result, developers may not be able to identify design problems due to tool issues. Method: To address this matter, we aimed at achieving three goals. In the first case, we proposed Organic-a tool supporting the analysis of stinky code. In the second case, we applied a mixed-method approach to analyze if and how developers can effectively find design problems when reflecting upon stinky code-i.e., a program location affected by multiple smells. We conducted a study with 11 software professionals. Finally, in the third case, we aimed at understanding if Organic could be used by developers to identify design problems. To achieve this goal, we used a method from the Semiotic Engineering theory. This method enabled us to evaluate what are the tool issues that may hinder the identification of design problems in stinky code. Result: Our study revealed that only 36.36% of the developers found more design problems when explicitly reasoning about multiple smells as compared to single smells. Moreover, 63.63% of the developers reported much lesser false positives when using the first approach as compared to the latter. The second study, in its turn, showed that most developers may be unable to identify design problems in stinky code without proper tool support. Conclusion: Our experiences, in particular the second study, helped us to refine the features of Organic for better supporting developers in reflecting upon stinkier code. For example, analyses of stinky code scattered in class hierarchies or packages is often difficult, time-consuming, and requires proper visualization support. Moreover, without effective support, it remains time-consuming to discard stinky program locations that do not represent design problems.

show abstract

“…In [1,4,6], the authors report on the relevance of code anomalies for the identification of architectural problems. As main findings, they observed that single anomalies alone do not suffice to assist developers in revealing architectural problems.…”

Section: Related Workmentioning

confidence: 99%

“…architectural problems. However, well-known anomalies in the source code (also known as code smells [2]) only provide partial hints of the location of architecture problems in a system [1,6] (Section 2).…”

Section: Introductionmentioning

confidence: 99%

On the criteria for prioritizing code anomalies to identify architectural problems

Vidal

Guimarães

Oizumi

et al. 2016

Proceedings of the 31st Annual ACM Symposium on Applied Computing

Self Cite

View full text Add to dashboard Cite

Architectural problems constantly affect evolving software projects. When not properly addressed, those problems can hinder the longevity of a software system. Some studies revealed that a wide range of architectural problems are reflected in source code through code anomalies. However, a software project often contains thousands of code anomalies and many of them have no relation to architectural problems. As a consequence, developers struggle to effectively determine which (groups of) anomalies are architecturally relevant. This work proposes criteria for prioritizing groups of code anomalies as indicators of architectural problems in evolving systems.

show abstract

Prioritization of Code Anomalies Based on Architecture Sensitiveness

Cited by 22 publications

References 30 publications

An Investigative Study on How Developers Filter and Prioritize Code Smells

An Investigative Study on How Developers Filter and Prioritize Code Smells

On the identification of design problems in stinky code: experiences and tool support

On the criteria for prioritizing code anomalies to identify architectural problems

Contact Info

Product

Resources

About