An approach to prioritize code smells for refactoring

Vidal, Santiago; Marcos, Claudia; Díaz-Pace, J. Andrés

doi:10.1007/s10515-014-0175-x

Cited by 108 publications

(68 citation statements)

References 19 publications

Supporting

Mentioning

Contrasting

Unclassified

Order By: Relevance

“…This comment gives strength to our initial conjecture, namely that textual code smells are easier to identify and refactor with respect to structural code smells. Our preliminary findings seem to confirm the observations made by Vidal et al [104] on the limited support provided by structural-based code smell detectors due to the fact that they tend to highlight a large amount of design problems that developers are not able to deal with. Also, the statistical tests confirmed our results (see Table 6).…”

Section: Analysis Of the Resultssupporting

confidence: 90%

“…Vidal et al [104] observed that the number of code smells suggested by existing metric-based tools usually exceed the amount of design problems that developers can deal with. For this reason, they proposed a prioritization approach based on previous modifications of a class, important modifiability scenarios for the considered system, and the relevance of the code smell type.…”

Section: Code Smell Evolutionmentioning

confidence: 99%

See 1 more Smart Citation

The Scent of a Smell: An Extensive Comparison Between Textual and Structural Smells

Palomba

Panichella

Zaidman

et al. 2018

IIEEE Trans. Software Eng.

View full text Add to dashboard Cite

Abstract-Code smells are symptoms of poor design or implementation choices that have a negative effect on several aspects of software maintenance and evolution, such as program comprehension or change-and fault-proneness. This is why researchers have spent a lot of effort on devising methods that help developers to automatically detect them in source code. Almost all the techniques presented in literature are based on the analysis of structural properties extracted from source code, although alternative sources of information (e.g., textual analysis) for code smell detection have also been recently investigated. Nevertheless, some studies have indicated that code smells detected by existing tools based on the analysis of structural properties are generally ignored (and thus not refactored) by the developers. In this paper, we aim at understanding whether code smells detected using textual analysis are perceived and refactored by developers in the same or different way than code smells detected through structural analysis. To this aim, we set up two different experiments. We have first carried out a software repository mining study to analyze how developers act on textually or structurally detected code smells. Subsequently, we have conducted a user study with industrial developers and quality experts in order to qualitatively analyze how they perceive code smells identified using the two different sources of information. Results indicate that textually detected code smells are easier to identify and for this reason they are considered easier to refactor with respect to code smells detected using structural properties. On the other hand, the latter are often perceived as more severe, but more difficult to exactly identify and remove.

show abstract

Section: Analysis Of the Resultssupporting

confidence: 90%

Section: Code Smell Evolutionmentioning

confidence: 99%

The Scent of a Smell: An Extensive Comparison Between Textual and Structural Smells

Palomba

Panichella

Zaidman

et al. 2018

IIEEE Trans. Software Eng.

View full text Add to dashboard Cite

show abstract

“…An other interesting aspect related to code smells for improving architecture quality, and also outlined by Vidal et al [12], is that if the developer is interested in improving, for example, the coupling of the system, he can focus on the analysis and then removal of particular smells as Intensive Coupling, Dispersed Coupling and Shotgun Surgery smells [6], because these smells impact on coupling aspects. While if he wants to improve cohesion, he has to consider first God Class, Brain Method or Intensive Coupling smells.…”

Section: Introductionmentioning

confidence: 99%

Towards Assessing Software Architecture Quality by Exploiting Code Smell Relations

Fontana¹,

Ferme²,

Zanoni³

2015

2015 IEEE/ACM 2nd International Workshop on Software Architecture and Metrics

View full text Add to dashboard Cite

We can evaluate software architecture quality using a plethora of metrics proposed in the literature, but interpreting and exploiting in the right way these metrics is not always a simple task. This is true for both fixing the right metric threshold values and determining the actions to be taken to improve the quality of the system. Instead of metrics, we can detect code or architectural anomalies that give us useful hints on the possible architecture degradation. In this paper, we focus our attention on the detection of code smells and in particular on their relations and co-occurrences, with the aim to evaluate tecnical debt in an architectural context. We start from the assumption that certain patterns of code anomalies tend to be better indicators of architectural degradation than simple metrics evaluation.

show abstract

“…The new method compared with other in terms of various performance matrixes in this research. Vidal et al (2016) prioritizing the smells are process according to their groups which might cause the problems in software system. The detection of bad smells is performed on JSpirit tool in this research.…”

Section: Literature Reviewmentioning

confidence: 99%

Automatic multiprogramming bad smell detection with refactoring

Verma¹

2017

Int. j. adv. appl. sci.

View full text Add to dashboard Cite

A code smell detection and refactor is one of the very hot concepts in these days. A Lot of researcher worked on it to create an automatic bad smell detection and refactoring system. Main purpose behind the development of these type of systems is to create automatic for enhance the development quality of software systems. In the previous research the smell detection system perform detection on specific areas or specific language. Due to this companies needs to use more than one detector for software testing for large projects. The system is combination of various modules which can be developed in various languages. Our proposed method which is helpful their users to test their code and detect bad smell on more than one language. It acts as a bridge with some optimization techniques which provide highly accurate working for smell detection along with refactoring. Proposed approach uses optimization along with fact and rule programming to detect and refactor the bad smell from input programs. Various bad smells like long methods, dead code, lazy class, long class, etc. are used to check the quality of the code. The proposed approach is also working for Java, c++ and c#.net codes for the test all these bad smell and refactor c++ and Java code. The performance of the proposed approach is also better than other existing algorithms in terms of accuracy for detection and refactoring of bad smells. Some other challenges that the proposed approach faced to find the smells in the code also affect the performance. One of the main challenges is the way of writing code is different for everyone. So it's difficult to detect and refactor the thing on smell detection tool. Proposed approach used fact and rule processing for detection and eliminates unwanted entries with the help of the optimization process. The performance in terms of accuracy and FAR, FRR are stable and better for all the test cases in the comparison of existing methods and proposed approach.

show abstract

An approach to prioritize code smells for refactoring

Cited by 108 publications

References 19 publications

The Scent of a Smell: An Extensive Comparison Between Textual and Structural Smells

The Scent of a Smell: An Extensive Comparison Between Textual and Structural Smells

Towards Assessing Software Architecture Quality by Exploiting Code Smell Relations

Automatic multiprogramming bad smell detection with refactoring

Contact Info

Product

Resources

About