The relationship between traceable code patterns and code smells

Zadia Codabux, Kazi Zakia Sultana, Byron J. Williams

Research output: Chapter in Book/Report/Conference proceedingConference contribution

3 Citations (Scopus)

Abstract

Context: It is important to maintain software quality as a software system evolves. Managing code smells in source code contributes towards quality software. While metrics have been used to pinpoint code smells in source code, we present an empirical study on the correlation of code smells with class-level (micro pattern) and methodlevel (nano-pattern) traceable patterns of code. Objective: This study explores the relationship between code smells and class-level and method-level structural code constructs. Method: We extracted micro patterns at the class level and nano-patterns at the method level from three versions of Apache Tomcat and PersonalBlog and Roller from Standford SecuriBench and compared their distributions in code smell versus non-code smell classes and methods.Result: We found that DataManager, Record and Outline micro patterns are more frequent in classes having code smell compared to non-code smell classes in the applications we analyzed. localReader, localWriter, Switcher, and ArrReader nano-patterns are more frequent in code smell methods compared to the non-code smell methods. Conclusion: We conclude that code smells are correlated with both micro and nano-patterns.

Original languageEnglish
Title of host publicationProceedings - SEKE 2017
Subtitle of host publication29th International Conference on Software Engineering and Knowledge Engineering
PublisherKnowledge Systems Institute Graduate School
Pages444-449
Number of pages6
ISBN (Electronic)1891706411
DOIs
StatePublished - 1 Jan 2017
Event29th International Conference on Software Engineering and Knowledge Engineering, SEKE 2017 - Pittsburgh, United States
Duration: 5 Jul 20177 Jul 2017

Publication series

NameProceedings of the International Conference on Software Engineering and Knowledge Engineering, SEKE
ISSN (Print)2325-9000
ISSN (Electronic)2325-9086

Conference

Conference29th International Conference on Software Engineering and Knowledge Engineering, SEKE 2017
CountryUnited States
CityPittsburgh
Period5/07/177/07/17

Cite this

Codabux, Z., Sultana, K. Z., & Williams, B. J. (2017). The relationship between traceable code patterns and code smells. In Proceedings - SEKE 2017: 29th International Conference on Software Engineering and Knowledge Engineering (pp. 444-449). (Proceedings of the International Conference on Software Engineering and Knowledge Engineering, SEKE). Knowledge Systems Institute Graduate School. https://doi.org/10.18293/SEKE2017-121
Codabux, Zadia ; Sultana, Kazi Zakia ; Williams, Byron J. / The relationship between traceable code patterns and code smells. Proceedings - SEKE 2017: 29th International Conference on Software Engineering and Knowledge Engineering. Knowledge Systems Institute Graduate School, 2017. pp. 444-449 (Proceedings of the International Conference on Software Engineering and Knowledge Engineering, SEKE).
@inproceedings{46361cc874b3496ea2dfe75741b42aaa,
title = "The relationship between traceable code patterns and code smells",
abstract = "Context: It is important to maintain software quality as a software system evolves. Managing code smells in source code contributes towards quality software. While metrics have been used to pinpoint code smells in source code, we present an empirical study on the correlation of code smells with class-level (micro pattern) and methodlevel (nano-pattern) traceable patterns of code. Objective: This study explores the relationship between code smells and class-level and method-level structural code constructs. Method: We extracted micro patterns at the class level and nano-patterns at the method level from three versions of Apache Tomcat and PersonalBlog and Roller from Standford SecuriBench and compared their distributions in code smell versus non-code smell classes and methods.Result: We found that DataManager, Record and Outline micro patterns are more frequent in classes having code smell compared to non-code smell classes in the applications we analyzed. localReader, localWriter, Switcher, and ArrReader nano-patterns are more frequent in code smell methods compared to the non-code smell methods. Conclusion: We conclude that code smells are correlated with both micro and nano-patterns.",
author = "Zadia Codabux and Sultana, {Kazi Zakia} and Williams, {Byron J.}",
year = "2017",
month = "1",
day = "1",
doi = "10.18293/SEKE2017-121",
language = "English",
series = "Proceedings of the International Conference on Software Engineering and Knowledge Engineering, SEKE",
publisher = "Knowledge Systems Institute Graduate School",
pages = "444--449",
booktitle = "Proceedings - SEKE 2017",

}

Codabux, Z, Sultana, KZ & Williams, BJ 2017, The relationship between traceable code patterns and code smells. in Proceedings - SEKE 2017: 29th International Conference on Software Engineering and Knowledge Engineering. Proceedings of the International Conference on Software Engineering and Knowledge Engineering, SEKE, Knowledge Systems Institute Graduate School, pp. 444-449, 29th International Conference on Software Engineering and Knowledge Engineering, SEKE 2017, Pittsburgh, United States, 5/07/17. https://doi.org/10.18293/SEKE2017-121

The relationship between traceable code patterns and code smells. / Codabux, Zadia; Sultana, Kazi Zakia; Williams, Byron J.

Proceedings - SEKE 2017: 29th International Conference on Software Engineering and Knowledge Engineering. Knowledge Systems Institute Graduate School, 2017. p. 444-449 (Proceedings of the International Conference on Software Engineering and Knowledge Engineering, SEKE).

Research output: Chapter in Book/Report/Conference proceedingConference contribution

TY - GEN

T1 - The relationship between traceable code patterns and code smells

AU - Codabux, Zadia

AU - Sultana, Kazi Zakia

AU - Williams, Byron J.

PY - 2017/1/1

Y1 - 2017/1/1

N2 - Context: It is important to maintain software quality as a software system evolves. Managing code smells in source code contributes towards quality software. While metrics have been used to pinpoint code smells in source code, we present an empirical study on the correlation of code smells with class-level (micro pattern) and methodlevel (nano-pattern) traceable patterns of code. Objective: This study explores the relationship between code smells and class-level and method-level structural code constructs. Method: We extracted micro patterns at the class level and nano-patterns at the method level from three versions of Apache Tomcat and PersonalBlog and Roller from Standford SecuriBench and compared their distributions in code smell versus non-code smell classes and methods.Result: We found that DataManager, Record and Outline micro patterns are more frequent in classes having code smell compared to non-code smell classes in the applications we analyzed. localReader, localWriter, Switcher, and ArrReader nano-patterns are more frequent in code smell methods compared to the non-code smell methods. Conclusion: We conclude that code smells are correlated with both micro and nano-patterns.

AB - Context: It is important to maintain software quality as a software system evolves. Managing code smells in source code contributes towards quality software. While metrics have been used to pinpoint code smells in source code, we present an empirical study on the correlation of code smells with class-level (micro pattern) and methodlevel (nano-pattern) traceable patterns of code. Objective: This study explores the relationship between code smells and class-level and method-level structural code constructs. Method: We extracted micro patterns at the class level and nano-patterns at the method level from three versions of Apache Tomcat and PersonalBlog and Roller from Standford SecuriBench and compared their distributions in code smell versus non-code smell classes and methods.Result: We found that DataManager, Record and Outline micro patterns are more frequent in classes having code smell compared to non-code smell classes in the applications we analyzed. localReader, localWriter, Switcher, and ArrReader nano-patterns are more frequent in code smell methods compared to the non-code smell methods. Conclusion: We conclude that code smells are correlated with both micro and nano-patterns.

UR - http://www.scopus.com/inward/record.url?scp=85029495730&partnerID=8YFLogxK

U2 - 10.18293/SEKE2017-121

DO - 10.18293/SEKE2017-121

M3 - Conference contribution

AN - SCOPUS:85029495730

T3 - Proceedings of the International Conference on Software Engineering and Knowledge Engineering, SEKE

SP - 444

EP - 449

BT - Proceedings - SEKE 2017

PB - Knowledge Systems Institute Graduate School

ER -

Codabux Z, Sultana KZ, Williams BJ. The relationship between traceable code patterns and code smells. In Proceedings - SEKE 2017: 29th International Conference on Software Engineering and Knowledge Engineering. Knowledge Systems Institute Graduate School. 2017. p. 444-449. (Proceedings of the International Conference on Software Engineering and Knowledge Engineering, SEKE). https://doi.org/10.18293/SEKE2017-121