Software Design Smell Detection: a systematic mapping study

Abstract

Design Smells are indicators of situations that negatively affect software quality attributes such as understandability, testability, extensibility, reusability, and maintainability in general. Improving maintainability is one of the cornerstones of making software evolution easier. Hence, Design Smell Detection is important in helping developers when making decisions that can improve software evolution processes. After a long period of research, it is important to organize the knowledge produced so far and to identify current challenges and future trends. In this paper, we analyze 18 years of research into Design Smell Detection. There is a wide variety of terms that have been used in the literature to describe concepts which are similar to what we have defined as “Design Smells,” such as design defect, design flaw, anomaly, pitfall, antipattern, and disharmony. The aim of this paper is to analyze all these terms and include them in the study. We have used the standard systematic literature review method based on a comprehensive set of 395 articles published in different proceedings, journals, and book chapters. We present the results in different dimensions of Design Smell Detection, such as the type or scope of smell, detection approaches, tools, applied techniques, validation evidence, type of artifact in which the smell is detected, resources used in evaluation, supported languages, and relation between detected smells and software quality attributes according to a quality model. The main contributions of this paper are, on the one hand, the application of domain modeling techniques to obtain a conceptual model that allows the organization of the knowledge on Design Smell Detection and a collaborative web application built on that knowledge and, on the other, finding how tendencies have moved across different kinds of smell detection, as well as different approaches and techniques. Key findings for future trends include the fact that all automatic detection tools described in the literature identify Design Smells as a binary decision (having the smell or not), which is an opportunity to evolve to fuzzy and prioritized decisions. We also find that there is a lack of human experts and benchmark validation processes, as well as demonstrating that Design Smell Detection positively influences quality attributes.

Appendix. Relevant work included in the systematic mapping

[S1] Abílio, R., Padilha, J., Figueiredo, E., & Costa, H. (2015, April). Detecting code smells in software product lines—an exploratory study. In Information Technology-New Generations (ITNG), 2015 12th International Conference on(pp. 433–438). IEEE.

[S2] Ahmed, I., Mannan, U. A., Gopinath, R., & Jensen, C. (2015, October). An empirical study of design degradation: how software projects get worse over time. In Empirical Software Engineering and Measurement (ESEM), 2015 ACM/IEEE International Symposium on (pp. 1–10). IEEE.

[S3] Almeida, D., Campos, J. C., Saraiva, J., & Silva, J. C. (2015, April). Towards a catalog of usability smells. In Proceedings of the 30th Annual ACM Symposium on Applied Computing (pp. 175–181). ACM.

[S4] Alves, P., Santana, D., & Figueiredo, E. (2012, June). ConcernReCS: finding code smells in software aspectization. In Software Engineering (ICSE), 2012 34th International Conference on (pp. 1463–1464). IEEE.

[S5] Amorim, L., Costa, E., Antunes, N., Fonseca, B., & Ribeiro, M. (2015, November). Experience report: evaluating the effectiveness of decision trees for detecting code smells. In Software Reliability Engineering (ISSRE), 2015 IEEE 26th International Symposium on (pp. 261–269). IEEE.

[S6] Arnaoudova, V. (2010, October). Improving source code quality through the definition of linguistic antipatterns. In 17th Working Conference on Reverse Engineering (pp. 285–288).

[S7] Bavota, G., De Lucia, A., Di Penta, M., Oliveto, R., & Palomba, F. (2015). An experimental investigation on the innate relationship between quality and refactoring. Journal of Systems and Software, 107, 1–14.

[S8] Bertran, I. M. (2011, May). Detecting architecturally-relevant code smells in evolving software systems. In Proceedings of the 33rd International Conference on Software Engineering(pp. 1090–1093). ACM.

[S9] Macia, I., Garcia, A., & von Staa, A. (2010, September). Defining and applying detection strategies for aspect-oriented code smells. In Software Engineering (SBES), 2010 Brazilian Symposium on (pp. 60–69). IEEE.

[S10] Bhattacharrya, A., & Fuhrer, R. (2004, October). Smell detection for Eclipse. In Companion to the 19th annual ACM SIGPLAN conference on Object-oriented programming systems, languages, and applications (pp. 22–22). ACM.

[S11] Boussaa, M., Kessentini, W., Kessentini, M., Bechikh, S., & Chikha, S. B. (2013, August). Competitive coevolutionary code-smells detection. In International Symposium on Search Based Software Engineering (pp. 50–65). Springer, Berlin, Heidelberg.

[S12] Bryton, S., e Abreu, F. B., & Monteiro, M. (2010, September). Reducing subjectivity in code smells detection: experimenting with the Long Method. In Quality of Information and Communications Technology (QUATIC), 2010 Seventh International Conference on the (pp. 337–342). IEEE.

[S13] Silva, J. C., Campos, J. C., Saraiva, J., & Silva, J. L. (2014). An approach for graphical user interface external bad smells detection. In New Perspectives in Information Systems and Technologies, Volume 2 (pp. 199–205). Springer, Cham.

[S14] Cardoso, B., & Figueiredo, E. (2015, May). Co-occurrence of design patterns and bad smells in software systems: an exploratory study. In Proceedings of the annual conference on Brazilian symposium on information systems: information systems: a computer socio-technical perspective (pp. 347–354).

[S15] Charalampidou, S., Ampatzoglou, A., & Avgeriou, P. (2015, October). Size and cohesion metrics as indicators of the Long Method bad smell: an empirical study. In Proceedings of the 11th International Conference on Predictive Models and Data Analytics in Software Engineering (p. 8). ACM.

[S16] Chatzigeorgiou, A., & Manakos, A. (2014). Investigating the evolution of code smells in object-oriented systems. Innovations in Systems and Software Engineering, 10(1), 3–18.

[S17] Chaudron, M. R., Katumba, B., & Ran, X. (2014, August). Automated prioritization of metrics-based design flaws in UML class diagrams. In Software Engineering and Advanced Applications (SEAA), 2014 40th EUROMICRO Conference on(pp. 369–376). IEEE.

[S18] Chis, A. E. (2008, October). Automatic detection of memory anti-patterns. In Companion to the 23rd ACM SIGPLAN conference on Object-oriented programming systems languages and applications (pp. 925–926). ACM.

[S19] Chivers, H., & Fletcher, M. (2005). Applying security design analysis to a service-based system. Software: Practice and Experience, 35(9), 873–897.

[S20] Choinzon, M., & Ueda, Y. (2006, May). Detecting defects in object oriented designs using design metrics. In Proceedings of the 2006 conference on Knowledge-Based Software Engineering: Proceedings of the Seventh Joint Conference on Knowledge-Based Software Engineering (pp. 61–72). IOS Press.

[S21] Christopoulou, A., Giakoumakis, E. A., Zafeiris, V. E., & Soukara, V. (2012). Automated refactoring to the Strategy design pattern. Information and Software Technology, 54(11), 1202–1214.

[S22] Conceicao, C. F. R., de Figueiredo Carneiro, G., & e Abreu, F. B. (2014, September). Streamlining code smells: using collective intelligence and visualization. In Quality of Information and Communications Technology (QUATIC), 2014 9th International Conference on the (pp. 306–311). IEEE.

[S23] Cortellessa, V., Di Marco, A., & Trubiani, C. (2014). An approach for modeling and detecting software performance antipatterns based on first-order logics. Software & Systems Modeling, 13(1), 391–432.

[S24] Cortellessa, V., Martens, A., Reussner, R., & Trubiani, C. (2010, March). A process to effectively identify “guilty” performance antipatterns. In International Conference on Fundamental Approaches to Software Engineering (pp. 368–382). Springer, Berlin, Heidelberg.

[S25] Counsell, S., & Mendes, E. (2007, October). Size and frequency of class change from a refactoring perspective. In Software Evolvability, 2007 Third International IEEE Workshop on (pp. 23–28). IEEE.

[S26] Crespo, Y., López, C., & Marticorena, R. (1996). Relative thresholds: case study to incorporate metrics in the detection of bad smells. In Proceedings of 10th ECOOP Workshop on Quantitative Approaches in Object-Oriented Software Engineering.–Lugano: Universita della Svizzera italiana Press(pp. 109–118).

[S27] Czibula, G., Marian, Z., & Czibula, I. G. (2015). Detecting software design defects using relational association rule mining. Knowledge and Information Systems, 42(3), 545–577.

[S28] Dąbrowski, R., Stencel, K., & Timoszuk, G. (2011, September). Software is a directed multigraph. In European Conference on Software Architecture (pp. 360–369). Springer, Berlin, Heidelberg.

[S29] Danphitsanuphan, P., & Suwantada, T. (2012, May). Code smell detecting tool and code smell-structure bug relationship. In Engineering and Technology (S-CET), 2012 Spring Congress on (pp. 1–5). IEEE.

[S30] von Detten, M., & Becker, S. (2011, June). Combining clustering and pattern detection for the reengineering of component-based software systems. In Proceedings of the joint ACM SIGSOFT conference--QoSA and ACM SIGSOFT symposium--ISARCS on Quality of software architectures--QoSA and architecting critical systems--ISARCS (pp. 23–32). ACM.

[S31] Dexun, J., Peijun, M., Xiaohong, S., & Tiantian, W. (2012, December). Detecting bad smells with weight based distance metrics theory. In Instrumentation, Measurement, Computer, Communication and Control (IMCCC), 2012 Second International Conference on (pp. 299–304). IEEE.

[S32] Dexun, J., Peijun, M., Xiaohong, S., Tiantian, W. (2013). Distribution rule based bad smell detection and refactoring scheme. International Journal of Software Engineering & Applications (IJSEA) 4(5), 1677–1684.

[S33] Dietrich, J. (2012, October). Upload your program, share your model. In Proceedings of the 3rd annual conference on Systems, programming, and applications: software for humanity (pp. 21–22). ACM.

[S34] Dijkman, R., Gfeller, B., Küster, J., & Völzer, H. (2011). Identifying refactoring opportunities in process model repositories. Information and Software Technology, 53(9), 937–948.

[S35] Din, J., Al-Badareen, A. B., & Jusoh, Y. Y. (2012, December). Antipatterns detection approaches in object-oriented design: a literature review. In Computing and Convergence Technology (ICCCT), 2012 7th International Conference on (pp. 926–931). IEEE.

[S36] Do Vale, G. A., & Figueiredo, E. M. L. (2015, September). A method to derive metric thresholds for software product lines. In Software Engineering (SBES), 2015 29th Brazilian Symposium on (pp. 110–119). IEEE.

[S37] Dobrzański, Ł., & Kuźniarz, L. (2006, April). An approach to refactoring of executable UML models. In Proceedings of the 2006 ACM symposium on Applied computing (pp. 1273–1279). ACM.

[S38] Drozdz, M., Kourie, D. G., Watson, B. W., & Boake, A. (2006). Refactoring tools and complementary techniques. AICCSA, 6, 685–688.

[S39] Ebert, C., Dumke, R., Bundschuh, M., & Schmietendorf, A. (2005). Best practices in software measurement: how to use metrics to improve project and process performance. Springer Science & Business Media.

[S40] Van Emden, E., & Moonen, L. (2012, October). Assuring software quality by code smell detection. In Reverse Engineering (WCRE), 2012 19th Working Conference on. IEEE.

[S41] Fard, A. M., & Mesbah, A. (2013, September). Jsnose: detecting JavaScript code smells. In Source Code Analysis and Manipulation (SCAM), 2013 IEEE 13th International Working Conference on (pp. 116–125). IEEE.

[S42] Feng, T., Zhang, J., Wang, H., & Wang, X. (2004, September). Software design improvement through anti-patterns identification. In Software Maintenance, 2004. Proceedings. 20th IEEE International Conference on (p. 524). IEEE.

[S43] Fenske, W. (2015, September). Code smells in highly configurable software. In Software Maintenance and Evolution (ICSME), 2015 IEEE International Conference on (pp. 602–605). IEEE.

[S44] Fenske, W., & Schulze, S. (2015, January). Code smells revisited: a variability perspective. In Proceedings of the Ninth International Workshop on Variability Modelling of Software-intensive Systems (p. 3). ACM.

[S45] Fenske, W., Schulze, S., Meyer, D., & Saake, G. (2015, September). When code smells twice as much: metric-based detection of variability-aware code smells. In Source Code Analysis and Manipulation (SCAM), 2015 IEEE 15th International Working Conference on (pp. 171–180). IEEE.

[S46] Fernandes, E., Oliveira, J., Vale, G., Paiva, T., & Figueiredo, E. (2016, June). A review-based comparative study of bad smell detection tools. In Proceedings of the 20th International Conference on Evaluation and Assessment in Software Engineering (p. 18). ACM.

[S47] de Figueiredo Carneiro, G., & de Mendonça Neto, M. G. (2013, July). Sourceminer—a multi-perspective software visualization environment. In International Conference on Enterprise Information Systems pp. 25–36). Springer, Cham.

[S48] Carneiro, G. D. F., Silva, M., Mara, L., Figueiredo, E., Sant’Anna, C., Garcia, A., & Mendonca, M. (2010, September). Identifying code smells with multiple concern views. In Software Engineering (SBES), 2010 Brazilian Symposium on (pp. 128–137). IEEE.

[S49] Fokaefs, M., Tsantalis, N., & Chatzigeorgiou, A. (2007, October). Jdeodorant: identification and removal of feature envy bad smells. In Software Maintenance, 2007. ICSM 2007. IEEE International Conference on (pp. 519–520). IEEE.

[S50] Fontana, F. A., Braione, P., & Zanoni, M. (2012). Automatic detection of bad smells in code: an experimental assessment. Journal of Object Technology, 11(2), 5–1.

[S51] Fontana, F. A., Dietrich, J., Walter, B., Yamashita, A., & Zanoni, M. (2016, March). Antipattern and code smell false positives: preliminary conceptualization and classification. In Software Analysis, Evolution, and Reengineering (SANER), 2016 IEEE 23rd International Conference on (Vol. 1, pp. 609–613). IEEE.

[S52] Fontana, F. A., Ferme, V., Marino, A., Walter, B., & Martenka, P. (2013, September). Investigating the impact of code smells on system’s quality: an empirical study on systems of different application domains. In Software Maintenance (ICSM), 2013 29th IEEE International Conference on (pp. 260–269). IEEE.

[S53] Fontana, F. A., Ferme, V., & Zanoni, M. (2015, May). Filtering code smells detection results. In Proceedings of the 37th International Conference on Software Engineering-Volume 2(pp. 803–804). IEEE Press.

[S54] Fontana, F. A., Ferme, V., & Zanoni, M. (2015, May). Towards assessing software architecture quality by exploiting code smell relations. In Proceedings of the Second International Workshop on Software Architecture and Metrics (pp. 1–7). IEEE Press.

[S55] Fontana, F. A., Ferme, V., Zanoni, M., & Yamashita, A. (2015, May). Automatic metric thresholds derivation for code smell detection. In Emerging Trends in Software Metrics (WETSoM), 2015 IEEE/ACM 6th International Workshop on (pp. 44–53). IEEE.

[S56] Fontana, F. A., Mangiacavalli, M., Pochiero, D., & Zanoni, M. (2015, May). On experimenting refactoring tools to remove code smells. In Scientific Workshop Proceedings of the XP2015 (p. 7). ACM.

[S57] Fontana, F. A., Mäntylä, M. V., Zanoni, M., & Marino, A. (2016). Comparing and experimenting machine learning techniques for code smell detection. Empirical Software Engineering, 21(3), 1143–1191.

[S58] Fontana, F. A., Mariani, E., Mornioli, A., Sormani, R., & Tonello, A. (2011, March). An experience report on using code smells detection tools. In Software Testing, Verification and Validation Workshops (ICSTW), 2011 IEEE Fourth International Conference on (pp. 450–457). IEEE.

[S59] Fontana, F. A., & Spinelli, S. (2011, May). Impact of refactoring on quality code evaluation. In Proceedings of the 4th Workshop on Refactoring Tools (pp. 37–40). ACM.

[S60] Fontana, F. A., Zanoni, M., Marino, A., & Mantyla, M. V. (2013, September). Code smell detection: towards a machine learning-based approach. In Software Maintenance (ICSM), 2013 29th IEEE International Conference on (pp. 396–399). IEEE.

[S61] Fourati, R., Bouassida, N., & Abdallah, H. B. (2011). A metric-based approach for anti-pattern detection in UML designs. In Computer and Information Science 2011 (pp. 17–33). Springer, Berlin, Heidelberg.

[S62] Fowler, M., Beck, K., Brant, J., Opdyke, W., & Roberts, D. (2000). Refactoring: improving the design of existing code. Addison-Wesley Professional.

[S63] Fu, S., & Shen, B. (2015, October). Code Bad Smell Detection through evolutionary data mining. In Empirical Software Engineering and Measurement (ESEM), 2015 ACM/IEEE International Symposium on (pp. 1–9). IEEE.

[S64] Gabel, M., & Su, Z. (2010, May). Online inference and enforcement of temporal properties. In Proceedings of the 32nd ACM/IEEE International Conference on Software Engineering-Volume 1 (pp. 15–24). ACM.

[S65] Ganea, G., & Marinescu, R. (2015, September). Modeling design flaw evolution using complex systems. In Symbolic and Numeric Algorithms for Scientific Computing (SYNASC), 2015 17th International Symposium on (pp. 433–436). IEEE.

[S66] Garcia, J., Popescu, D., Edwards, G., & Medvidovic, N. (2009, March). Identifying architectural bad smells. In Software Maintenance and Reengineering, 2009. CSMR’09. 13th European Conference on (pp. 255–258). IEEE.

[S67] Gauthier, F., & Merlo, E. (2013, May). Semantic smells and errors in access control models: a case study in PHP. In Software Engineering (ICSE), 2013 35th International Conference on (pp. 1169–1172). IEEE.

[S68] Ge, X., Taneja, K., Xie, T., & Tillmann, N. (2011, May). DyTa: dynamic symbolic execution guided with static verification results. In Software Engineering (ICSE), 2011 33rd International Conference on (pp. 992–994). IEEE.

[S69] Ghannem, A., El Boussaidi, G., & Kessentini, M. (2016). On the use of design defect examples to detect model refactoring opportunities. Software Quality Journal, 24(4), 947–965.

[S70] Ghannem, A., Kessentini, M., & El Boussaidi, G. (2011, November). Detecting model refactoring opportunities using heuristic search. In Proceedings of the 2011 Conference of the Center for Advanced Studies on Collaborative Research (pp. 175–187). IBM Corp..

[S71] Gîrba, T., Ducasse, S., Kuhn, A., Marinescu, R., & Daniel, R. (2007, September). Using concept analysis to detect co-change patterns. In Ninth international workshop on Principles of software evolution: in conjunction with the 6th ESEC/FSE joint meeting (pp. 83–89). ACM.

[S72] Guéhéneuc, Y. G., & Albin-Amiot, H. (2001). Using design patterns and constraints to automate the detection and correction of inter-class design defects. In Technology of Object-Oriented Languages and Systems, 2001. TOOLS 39. 39th International Conference and Exhibition on (pp. 296–305). IEEE.

[S73] Guerra, E., Alves, F., Kulesza, U., & Fernandes, C. (2013). A reference architecture for organizing the internal structure of metadata-based frameworks. Journal of Systems and Software, 86(5), 1239–1256.

[S74] Guerrouj, L., Kermansaravi, Z., Arnaoudova, V., Fung, B. C., Khomh, F., Antoniol, G., & Guéhéneuc, Y. G. (2017). Investigating the relation between lexical smells and change-and fault-proneness: an empirical study. Software Quality Journal, 25(3), 641–670.

[S75] Guo, L. Q., Hsu, K. H., & Tsai, C. Y. (2015, October). A study of the definition and identification of bad smells in aspect oriented programming. In e-Business Engineering (ICEBE), 2015 IEEE 12th International Conference on (pp. 303–310). IEEE.

[S76] Gupta, V., Kapur, P. K., & Kumar, D. (2016). Modelling and measuring code smells in enterprise applications using TISM and two-way assessment. International Journal of System Assurance Engineering and Management, 7(3), 332–340.

[S77] Hallal, H. H., Alikacem, E., Tunney, W. P., Boroday, S., & Petrenko, A. (2004, September). Antipattern-based detection of deficiencies in Java multithreaded software. In Quality Software, 2004. QSIC 2004. Proceedings. Fourth International Conference on (pp. 258–267). IEEE.

[S78] Han, Z., Gong, P., Zhang, L., Ling, J., & Huang, W. (2013, July). Definition and detection of control-flow anti-patterns in process models. In Computer Software and Applications Conference Workshops (COMPSACW), 2013 IEEE 37th Annual (pp. 433–438). IEEE.

[S79] Hassaine, S., Khomh, F., Guéhéneuc, Y. G., & Hamel, S. (2010, September). IDS: an immune-inspired approach for the detection of software Design Smells. In Quality of Information and Communications Technology (QUATIC), 2010 Seventh International Conference on the (pp. 343–348). IEEE.

[S80] Hecht, G. (2015, May). An approach to detect Android antipatterns. In Proceedings of the 37th International Conference on Software Engineering-Volume 2 (pp. 766–768). IEEE Press.

[S81] Hecht, G., Benomar, O., Rouvoy, R., Moha, N., & Duchien, L. (2015, November). Tracking the software quality of android applications along their evolution (t). In Automated Software Engineering (ASE), 2015 30th IEEE/ACM International Conference on (pp. 236–247). IEEE.

[S82] Hecht, G., Rouvoy, R., Moha, N., & Duchien, L. (2015, May). Detecting antipatterns in android apps. In Mobile Software Engineering and Systems (MOBILESoft), 2015 2nd ACM International Conference on (pp. 148–149). IEEE.

[S83] Holzmann, G. J., & Joshi, R. (2008). Reliable software systems design: defect prevention, detection, and containment. In Verified Software: Theories, Tools, Experiments (pp. 237–244). Springer, Berlin, Heidelberg.

[S84] Hozano, M., Ferreira, H., Silva, I., Fonseca, B., & Costa, E. (2015, April). Using developers’ feedback to improve code smell detection. In Proceedings of the 30th Annual ACM Symposium on Applied Computing (pp. 1661–1661). ACM.

[S85] Huang, J., Carminati, F., Betev, L., Zhu, J., & Luzzi, C. (2011, October). EXTRACTOR: an extensible framework for identifying Aspect-oriented refactoring opportunities. In System Science, Engineering Design and Manufacturing Informatization (ICSEM), 2011 International Conference on(Vol. 2, pp. 222–226). IEEE.

[S86] Hussain, S. (2016, April). Threshold analysis of design metrics to detect design flaws: student research abstract. In Proceedings of the 31st Annual ACM Symposium on Applied Computing (pp. 1584–1585). ACM.

[S87] Irwanto, D. (2010, December). Visual indicator component software to show component design quality and characteristic. In Advances in Computing, Control and Telecommunication Technologies (ACT), 2010 Second International Conference on (pp. 50–54). IEEE.

[S88] Ito, Y., Hazeyama, A., Morimoto, Y., Kaminaga, H., Nakamura, S., & Miyadera, Y. (2015). A method for detecting bad smells and its application to software engineering education. International Journal of Software Innovation (IJSI), 3(2), 13–23.

[S89] Jaafar, F., Guéhéneuc, Y. G., Hamel, S., Khomh, F., & Zulkernine, M. (2016). Evaluating the impact of design pattern and anti-pattern dependencies on changes and faults. Empirical Software Engineering, 21(3), 896–931.

[S90] Jalbani, A. A., Grabowski, J., Neukirchen, H., & Zeiss, B. (2009, September). Towards an integrated quality assessment and improvement approach for UML models. In International SDL Forum (pp. 63–81). Springer, Berlin, Heidelberg.

[S91] Jiang, D., Ma, P., Su, X., & Wang, T. (2014). Distance metric based divergent change bad smell detection and refactoring scheme analysis. Proc. of the 26th Int. Journal of Innovative Computing, Information and Control (ICIC’2014), 10(4).

[S92] Kaur, H., & Kaur, P. J. (2014, September). A GUI based unit testing technique for antipattern identification. In Confluence The Next Generation Information Technology Summit (Confluence), 2014 5th International Conference- (pp. 779–782). IEEE.

[S93] Kaur, M., & Kumar, P. (2014, August). Spotting the phenomenon of bad smells in MobileMedia product line architecture. In Contemporary Computing (IC3), 2014 Seventh International Conference on (pp. 357–363). IEEE.

[S94] Kessentini, M., Kessentini, W., Sahraoui, H., Boukadoum, M., & Ouni, A. (2011, June). Design defects detection and correction by example. In Program Comprehension (ICPC), 2011 IEEE 19th International Conference on (pp. 81–90). IEEE.

[S95] Kessentini, M., Sahraoui, H., Boukadoum, M., & Wimmer, M. (2011, March). Design defect detection rules generation: a music metaphor. In Software Maintenance and Reengineering (CSMR), 2011 15th European Conference on (pp. 241–248). IEEE.

[S96] Kessentini, M., Sahraoui, H., Boukadoum, M., & Wimmer, M. (2011, March). Search-based design defects detection by example. In International Conference on Fundamental Approaches to Software Engineering (pp. 401–415). Springer, Berlin, Heidelberg.

[S97] Kessentini, M., Vaucher, S., & Sahraoui, H. (2010, September). Deviance from perfection is a better criterion than closeness to evil when identifying risky code. In Proceedings of the IEEE/ACM international conference on Automated software engineering (pp. 113–122). ACM.

[S98] Kessentini, W., Kessentini, M., Sahraoui, H., Bechikh, S., & Ouni, A. (2014). A cooperative parallel search-based software engineering approach for code-smells detection. IEEE Transactions on Software Engineering, 40(9), 841–861.

[S99] Khomh, F., Vaucher, S., Guéhéneuc, Y. G., & Sahraoui, H. (2009, August). A Bayesian approach for the detection of code and Design Smells. In Quality Software, 2009. QSIC’09. 9th International Conference on (pp. 305–314). IEEE.

[S100] Khomh, F., Vaucher, S., Guéhéneuc, Y. G., & Sahraoui, H. (2011). BDTEX: a GQM-based Bayesian approach for the detection of antipatterns. Journal of Systems and Software, 84(4), 559–572.

[S101] Kiefer, C., Bernstein, A., & Tappolet, J. (2007, May). Mining software repositories with isparol and a software evolution ontology. In Proceedings of the Fourth International Workshop on Mining Software Repositories (p. 10). IEEE Computer Society.

[S102] Kim, T. W., Kim, T. G., & Seu, J. H. (2013). Specification and automated detection of code smells using OCL. International Journal of Software Engineering and Its Applications, 7(4), 35–44.

[S103] Kreimer, J. (2005). Adaptive detection of design flaws. Electronic Notes in Theoretical Computer Science, 141(4), 117–136.

[S104] Kumar, S., & Chhabra, J. K. (2014, September). Two level dynamic approach for Feature Envy detection. In Computer and Communication Technology (ICCCT), 2014 International Conference on (pp. 41–46). IEEE.

[S105] Lanza, M., & Marinescu, R. (2007). Object-oriented metrics in practice: using software metrics to characterize, evaluate, and improve the design of object-oriented systems. Springer Science & Business Media.

[S106] Lee, S. J., Lo, L. H., Chen, Y. C., & Shen, S. M. (2016). Co-changing code volume prediction through association rule mining and linear regression model. Expert Systems with Applications, 45, 185–194.

[S107] Lelli, V., Blouin, A., Baudry, B., Coulon, F., & Beaudoux, O. (2016, June). Automatic detection of GUI Design Smells: the case of blob listener. In Proceedings of the 8th ACM SIGCHI Symposium on Engineering Interactive Computing Systems(pp. 263–274). ACM.

[S108] Ligu, E., Chatzigeorgiou, A., Chaikalis, T., & Ygeionomakis, N. (2013, September). Identification of refused bequest code smells. In Software Maintenance (ICSM), 2013 29th IEEE International Conference on (pp. 392–395). IEEE.

[S109] Liska, P., & Polasek, I. (2011, September). Design Smell detection with similarity scoring and fingerprinting: preliminary study. In Engineering of Computer Based Systems (ECBS-EERC), 2011 2nd Eastern European Regional Conference on the (pp. 163–164). IEEE.

[S110] Liu, H., Guo, X., & Shao, W. (2013). Monitor-based instant software refactoring. IEEE Transactions on Software Engineering, 39(8), 1112–1126.

[S111] Liu, H., Liu, Q., Niu, Z., & Liu, Y. (2016). Dynamic and automatic feedback-based threshold adaptation for code smell detection. IEEE Transactions on Software Engineering, 42(6), 544–558.

[S112] Liu, H., Ma, Z., Shao, W., & Niu, Z. (2012). Schedule of bad smell detection and resolution: a new way to save effort. IEEE Transactions on Software Engineering, 38(1), 220–235.

[S113] Lozano, A., Mens, K., & Portugal, J. (2015, March). Analyzing code evolution to uncover relations. In Patterns Promotion and Anti-patterns Prevention (PPAP), 2015 IEEE 2nd Workshop on (pp. 1–4). IEEE.

[S114] Ma, H., Ji, Z., Shao, W., & Zhang, L. (2005, September). Towards the uml evaluation using taxonomic patterns on meta-classes. In Quality Software, 2005.(QSIC 2005). Fifth International Conference on (pp. 37–44). IEEE.

[S115] Macia, I., Garcia, A., Chavez, C., & von Staa, A. (2013, March). Enhancing the detection of code anomalies with architecture-sensitive strategies. In Software Maintenance and Reengineering (CSMR), 2013 17th European Conference on(pp. 177–186). IEEE.

[S116] Macia, I., Garcia, J., Popescu, D., Garcia, A., Medvidovic, N., & von Staa, A. (2012, March). Are automatically-detected code anomalies relevant to architectural modularity?: an exploratory analysis of evolving systems. In Proceedings of the 11th annual international conference on Aspect-oriented Software Development (pp. 167–178). ACM.

[S117] Maddeh, M., & Ayouni, S. (2015, May). Extracting and modeling design defects using gradual rules and UML profile. In IFIP International Conference on Computer Science and its Applications_x000D_ (pp. 574–583). Springer, Cham.

[S118] Mahouachi, R., Kessentini, M., & Ghedira, K. (2012, March). A new design defects classification: marrying detection and correction. In International Conference on Fundamental Approaches to Software Engineering (pp. 455–470). Springer, Berlin, Heidelberg.

[S119] Maiga, A., Ali, N., Bhattacharya, N., Sabane, A., Gueheneuc, Y. G., & Aimeur, E. (2012, October). SMURF: a SVM-based incremental anti-pattern detection approach. In Reverse engineering (WCRE), 2012 19th working conference on (pp. 466–475). IEEE.

[S120] Maiga, A., Ali, N., Bhattacharya, N., Sabané, A., Guéhéneuc, Y. G., Antoniol, G., & Aïmeur, E. (2012, September). Support vector machines for anti-pattern detection. In Proceedings of the 27th IEEE/ACM International Conference on Automated Software Engineering (pp. 278–281). ACM.

[S121] Mannan, U. A., Ahmed, I., Almurshed, R. A. M., Dig, D., & Jensen, C. (2016, May). Understanding code smells in android applications. In Proceedings of the International Workshop on Mobile Software Engineering and Systems (pp. 225–234). ACM.

[S122] Mansoor, U., Kessentini, M., Maxim, B. R., & Deb, K. (2017). Multi-objective code-smells detection using good and bad design examples. Software Quality Journal, 25(2), 529–552.

[S123] Mäntylä, M. V., & Lassenius, C. (2006). Subjective evaluation of software evolvability using code smells: an empirical study. Empirical Software Engineering, 11(3), 395–431.

[S124] Mara, L., Honorato, G., Medeiros, F. D., Garcia, A., & Lucena, C. (2011, March). Hist-Inspect: a tool for history-sensitive detection of code smells. In Proceedings of the tenth international conference on Aspect-oriented software development companion (pp. 65–66). ACM.

[S125] Marinescu, C., Marinescu, R., Mihancea, P.F., Ratiu, D., Wettel, R. (2005). iplasma: an integrated platform for quality assessment of object-oriented design. In International Conference Software Maintenance ICSM (pp. 77–80). IEEE.

[S126] Marinescu, R. (2004, September). Detection strategies: metrics-based rules for detecting design flaws. In Software Maintenance, 2004. Proceedings. 20th IEEE International Conference on (pp. 350–359). IEEE.

[S127] Mathur, N., & Reddy, Y. R. (2015). Correctness of semantic code smell detection tools. In QuASoQ/WAWSE/CMCE@ APSEC (pp. 17–22).

[S128] Mekruksavanich, S., Yupapin, P. P., & Muenchaisri, P. (2012). Analytical learning based on a meta-programming approach for the detection of object-oriented design defects. Information Technology Journal, 11(12), 1677.

[S129] Mihancea, P. F., & Marinescu, R. (2005, March). Towards the optimization of automatic detection of design flaws in object-oriented software systems. In Software Maintenance and Reengineering, 2005. CSMR 2005. Ninth European Conference on (pp. 92–101). IEEE.

[S130] Moha, N. (2007, October). Detection and correction of design defects in object-oriented designs. In Companion to the 22nd ACM SIGPLAN conference on Object-oriented programming systems and applications companion (pp. 949–950). ACM.

[S131] Moha, N., & Guéhéneuc, Y. G. (2007, November). Decor: a tool for the detection of design defects. In Proceedings of the twenty-second IEEE/ACM international conference on Automated software engineering (pp. 527–528). ACM.

[S132] Moha, N., & Guéhéneuc, Y. G. (2007, October). P TIDEJ and DÉCOR: identification of design patterns and design defects. In Companion to the 22nd ACM SIGPLAN conference on Object-oriented programming systems and applications companion (pp. 868–869). ACM.

[S133] Moha, N., Gueheneuc, Y. G., & Leduc, P. (2006, September). Automatic generation of detection algorithms for design defects. In Automated Software Engineering, 2006. ASE’06. 21st IEEE/ACM International Conference on (pp. 297–300). IEEE.

[S134] Moha, N., Guéhéneuc, Y. G., Le Meur, A. F., & Duchien, L. (2008, March). A domain analysis to specify design defects and generate detection algorithms. In international conference on fundamental approaches to software engineering (pp. 276–291). Springer, Berlin, Heidelberg.

[S135] Moha, N., Guéhéneuc, Y. G., Le Meur, A. F., Duchien, L., & Tiberghien, A. (2010). From a domain analysis to the specification and detection of code and Design Smells. Formal Aspects of Computing, 22(3–4), 345–361.

[S136] Moha, N., Gueheneuc, Y. G., Duchien, L., & Le Meur, A. F. (2010). Decor: A method for the specification and detection of code and Design Smells. IEEE Transactions on Software Engineering, 36(1), 20–36.

[S137] Moha, N., Palma, F., Nayrolles, M., Conseil, B. J., Guéhéneuc, Y. G., Baudry, B., & Jézéquel, J. M. (2012, November). Specification and detection of SOA antipatterns. In International Conference on Service-Oriented Computing (pp. 1–16). Springer, Berlin, Heidelberg.

[S138] Müller, S., Würsch, M., Fritz, T., & Gall, H. C. (2012, June). An approach for collaborative code reviews using multi-touch technology. In Cooperative and Human Aspects of Software Engineering (CHASE), 2012 5th International Workshop on(pp. 93–99). IEEE.

[S139] Munro, M. J. (2005, September). Product metrics for automatic identification of “ bad smell” design problems in java source-code. In Software Metrics, 2005. 11th IEEE International Symposium (pp. 15–15). IEEE.

[S140] Murphy-Hill, E., & Black, A. P. (2008, November). Seven habits of a highly effective smell detector. In Proceedings of the 2008 international workshop on Recommendation systems for software engineering (pp. 36–40). ACM.

[S141] Nayrolles, M., Palma, F., Moha, N., & Guéhéneuc, Y. G. (2012, November). Soda: a tool support for the detection of SOA antipatterns. In International Conference on Service-Oriented Computing (pp. 451–455). Springer, Berlin, Heidelberg.

[S142] Neukirchen, H., & Bisanz, M. (2007). Utilising code smells to detect quality problems in TTCN-3 test suites. In Testing of Software and Communicating Systems (pp. 228–243). Springer, Berlin, Heidelberg.

[S143] Neukirchen, H., Zeiss, B., & Grabowski, J. (2008). An approach to quality engineering of TTCN-3 test specifications. International Journal on Software Tools for Technology Transfer, 10(4), 309.

[S144] Nguyen, A. C., & Khoo, S. C. (2011, October). Extracting significant specifications from mining through mutation testing. In International Conference on Formal Engineering Methods(pp. 472–488). Springer, Berlin, Heidelberg.

[S145] Nguyen, H. V., Nguyen, H. A., Nguyen, T. T., Nguyen, A. T., & Nguyen, T. N. (2012, September). Detection of embedded code smells in dynamic web applications. In Proceedings of the 27th IEEE/ACM International Conference on Automated Software Engineering (pp. 282–285). ACM.

[S146] Nguyen, T., & Pooley, R. (2009, September). Effective recognition of patterns in object-oriented designs. In Software Engineering Advances, 2009. ICSEA’09. Fourth International Conference on (pp. 320–325). IEEE.

[S147] Nguyen, T. T., Nguyen, H. A., Pham, N. H., Al-Kofahi, J. M., & Nguyen, T. N. (2009, August). Graph-based mining of multiple object usage patterns. In Proceedings of the the 7th joint meeting of the European software engineering conference and the ACM SIGSOFT symposium on The foundations of software engineering (pp. 383–392). ACM.

[S148] Nödler, J., Neukirchen, H., & Grabowski, J. (2009, April). A flexible framework for quality assurance of software artefacts with applications to java, uml, and ttcn-3 test specifications. In Software Testing Verification and Validation, 2009. ICST’09. International Conference on (pp. 101–110). IEEE.

[S149] Nongpong, K. (2015, January). Feature envy factor: a metric for automatic feature envy detection. In Knowledge and Smart Technology (KST), 2015 7th International Conference on (pp. 7–12). IEEE.

[S150] Oliveira, R. (2016, May). When more heads are better than one? Understanding and improving collaborative identification of code smells. In Software Engineering Companion (ICSE-C), IEEE/ACM International Conference on(pp. 879–882). IEEE.

[S151] Oliveto, R., Gethers, M., Bavota, G., Poshyvanyk, D., & De Lucia, A. (2011, May). Identifying method friendships to remove the feature envy bad smell (NIER track). In Proceedings of the 33rd International Conference on Software Engineering (pp. 820–823). ACM.

[S152] Ouni, A., Kessentini, M., Bechikh, S., & Sahraoui, H. (2015). Prioritizing code-smells correction tasks using chemical reaction optimization. Software Quality Journal, 23(2), 323–361.

[S153] Ouni, A., Kessentini, M., Sahraoui, H., & Boukadoum, M. (2013). Maintainability defects detection and correction: a multi-objective approach. Automated Software Engineering, 20(1), 47–79.

[S154] Ouni, A., Kessentini, M., Sahraoui, H., Inoue, K., & Deb, K. (2016). Multi-criteria code refactoring using search-based software engineering: an industrial case study. ACM Transactions on Software Engineering and Methodology (TOSEM), 25(3), 23.

[S155] Ouni, A., Kessentini, M., Sahraoui, H., Inoue, K., & Hamdi, M. S. (2015). Improving multi-objective code-smells correction using development history. Journal of Systems and Software, 105, 18–39.

[S156] Palma, F. (2012, November). Detection of SOA antipatterns. In International Conference on Service-Oriented Computing(pp. 412–418). Springer, Berlin, Heidelberg.

[S157] Palomba, F. (2015, May). Textual analysis for code smell detection. In Proceedings of the 37th International Conference on Software Engineering-Volume 2 (pp. 769–771). IEEE Press.

[S158] Palomba, F., Bavota, G., Di Penta, M., Oliveto, R., & De Lucia, A. (2014, September). Do they really smell bad? a study on developers’ perception of bad code smells. In Software maintenance and evolution (ICSME), 2014 IEEE international conference on (pp. 101–110). IEEE.

[S159] Palomba, F., Bavota, G., Di Penta, M., Oliveto, R., De Lucia, A., & Poshyvanyk, D. (2013, November). Detecting bad smells in source code using change history information. In Proceedings of the 28th IEEE/ACM International Conference on Automated Software Engineering (pp. 268–278). IEEE Press.

[S160] Palomba, F., Bavota, G., Di Penta, M., Oliveto, R., Poshyvanyk, D., & De Lucia, A. (2015). Mining version histories for detecting code smells. IEEE Transactions on Software Engineering, 41(5), 462–489.

[S161] Palomba, F., Di Nucci, D., Tufano, M., Bavota, G., Oliveto, R., Poshyvanyk, D., & De Lucia, A. (2015, May). Landfill: an open dataset of code smells with public evaluation. In Mining Software Repositories (MSR), 2015 IEEE/ACM 12th Working Conference on (pp. 482–485). IEEE.

[S162] Palomba, F., De Lucia, A., Bavota, G., & Oliveto, R. (2014). Anti-pattern detection: methods, challenges, and open issues. In Advances in computers (Vol. 95, pp. 201–238). Elsevier.

[S163] Palomba, F., Panichella, A., De Lucia, A., Oliveto, R., & Zaidman, A. (2016, May). A textual-based technique for smell detection. In Program Comprehension (ICPC), 2016 IEEE 24th International Conference on (pp. 1–10). IEEE.

[S164] Parsons, T. (2004, October). A framework for detecting, assessing and visualizing performance antipatterns in component based systems. In Companion to the 19th annual ACM SIGPLAN conference on Object-oriented programming systems, languages, and applications (pp. 316–317). ACM.

[S165] Parsons, T., Murphy, J. (2008). Detecting performance antipatterns in component based enterprise systems. Journal of Object Technology, 7(3), 55–90.

[S166] Peiris, M., & Hill, J. H. (2014). Towards detecting software performance anti-patterns using classification techniques. ACM SIGSOFT Software Engineering Notes, 39(1), 1–4.

[S167] Pietrzak, B., & Walter, B. (2006, June). Leveraging code smell detection with inter-smell relations. In International Conference on Extreme Programming and Agile Processes in Software Engineering (pp. 75–84). Springer, Berlin, Heidelberg.

[S168] Piveta, E. K., Hecht, M., Pimenta, M. S., & Price, R. T. (2006). Detecting Bad Smells in AspectJ. Journal of Universal Computer Science, 12(7), 811–827.

[S169] Polášek, I., Snopko, S., & Kapustík, I. (2012, September). Automatic identification of the anti-patterns using the rule-based approach. In Intelligent Systems and Informatics (SISY), 2012 IEEE 10th Jubilee International Symposium on(pp. 283–286). IEEE.

[S170] Polášek, I., Líška, P., Kelemen, J., & Lang, J. (2012, June). On extended similarity scoring and bit-vector algorithms for Design Smell detection. In Intelligent Engineering Systems (INES), 2012 IEEE 16th International Conference on (pp. 115–120). IEEE.

[S171] Pradel, M., Jaspan, C., Aldrich, J., & Gross, T. R. (2012, June). Statically checking API protocol conformance with mined multi-object specifications. In Proceedings of the 34th International Conference on Software Engineering (pp. 925–935). IEEE Press.

[S172] Putro, H. P., & Liem, I. (2011, July). Xml representations of program code. In Electrical Engineering and Informatics (ICEEI), 2011 International Conference on (pp. 1–6). IEEE.

[S173] Qingji, X. (2010). Study on the detection and correction of software based on UML. In International Conference on E-Health Networking, Digital Ecosystems and Technologies (pp. 268–271). IEEE.

[S174] Rao, A.A., Reddy, K.N. (2008). Detecting bad smells in object-oriented design using design change propagation probability matrix. In Proceedings of the International Multi-Conference of Engineers and Computer Scientists, Hong Kong, vol. I..

[S175] Rasool, G., & Arshad, Z. (2015). A review of code smell mining techniques. Journal of Software: Evolution and Process, 27(11), 867–895.

[S176] Rasool, G., & Arshad, Z. (2017). A lightweight approach for detection of code smells. Arabian Journal for Science and Engineering, 42(2), 483–506.

[S177] Rapu, D., Ducasse, S., Gîrba, T., & Marinescu, R. (2004, March). Using history information to improve design flaws detection. In Software Maintenance and Reengineering, 2004. CSMR 2004. Proceedings. Eighth European Conference on(pp. 223–232). IEEE.

[S178] Ratzinger, J., Fischer, M., Gall, H.C (2005, May). Improving evolvability through refactoring. In Proceedings of the 2005 International Workshop on Mining Software Repositories, MSR 2005.

[S179] Reddy, K. R., & Rao, A. A. (2009). Dependency oriented complexity metrics to detect rippling related design defects. ACM SIGSOFT Software Engineering Notes, 34(4), 1–7.

[S180] Rodriguez, J. M., Crasso, M., & Zunino, A. (2013). An approach for web service discoverability anti-pattern detection for journal of web engineering. Journal of Web Engineering, 12(1–2), 131–158.

[S181] Rodriguez, J. M., Crasso, M., Zunino, A., & Campo, M. (2010). Improving web service descriptions for effective service discovery. Science of Computer Programming, 75(11), 1001–1021.

[S182] Rongviriyapanish, S., Karunlanchakorn, N., & Meananeatra, P. (2015, June). Automatic code locations identification for replacing temporary variable with query method. In Electrical Engineering/Electronics, Computer, Telecommunications and Information Technology (ECTI-CON), 2015 12th International Conference on (pp. 1–6). IEEE.

[S183] Rosenfeld, M., Fernández, A., & Díaz, A. (2010, June). Semantic wiki refactoring. a strategy to assist semantic wiki evolution. In Fifth Workshop on Semantic Wikis Linking Data and People 7th Extended Semantic Web Conference Hersonissos, Crete, Greece (p. 132).

[S184] Roussey, C., Corcho, O., & Vilches-Blázquez, L. M. (2009, September). A catalogue of OWL ontology antipatterns. In Proceedings of the fifth international conference on Knowledge capture (pp. 205–206). ACM.

[S185] Roussey, C., Corcho, Ó., Sváb-Zamazal, O., Schar e, F., Bernard, S (2012). Antipattern detection in web ontologies: an experiment using SPARQL queries. In Extraction et gestion des connaissances (pp. 321–326).

[S186] Sae-Lim, N., Hayashi, S., & Saeki, M. (2016, May). Context-based code smells prioritization for prefactoring. In Program Comprehension (ICPC), 2016 IEEE 24th International Conference on (pp. 1–10). IEEE.

[S187] Sahin, D., Kessentini, M., Bechikh, S., & Deb, K. (2014). Code-smell detection as a bilevel problem. ACM Transactions on Software Engineering and Methodology (TOSEM), 24(1), 6.

[S188] Santos, J. A. M., & de Mendonça, M. G. (2015, April). Exploring decision drivers on god class detection in three controlled experiments. In Proceedings of the 30th Annual ACM Symposium on Applied Computing (pp. 1472–1479). ACM.

[S189] Santos, J. A. M., de Mendonça, M. G., Dos Santos, C. P., & Novais, R. L. (2014). The problem of conceptualization in god class detection: agreement, strategies and decision drivers. Journal of Software Engineering Research and Development, 2(1), 11.

[S190] Santos, J. A., de Mendonça, M. G., & Silva, C. V. (2013, April). An exploratory study to investigate the impact of conceptualization in god class detection. In Proceedings of the 17th International Conference on Evaluation and Assessment in Software Engineering (pp. 48–59). ACM.

[S191] dos Santos Neto, B. F., Ribeiro, M., Da Silva, V. T., Braga, C., De Lucena, C. J. P., & de Barros Costa, E. (2015). AutoRefactoring: a platform to build refactoring agents. Expert Systems with Applications, 42(3), 1652–1664.

[S192] AyshwaryaLakshmi, S., Mary, S. S. A., & Vadivu, S. S. (2013, July). Agent based tool for topologically sorting badsmells and refactoring by analyzing complexities in source code. In Computing, Communications and Networking Technologies (ICCCNT), 2013 Fourth International Conference on (pp. 1–7). IEEE.

[S193] Schumacher, J., Zazworka, N., Shull, F., Seaman, C., & Shaw, M. (2010, September). Building empirical support for automated code smell detection. In Proceedings of the 2010 ACM-IEEE International Symposium on Empirical Software Engineering and Measurement (p. 8). ACM.

[S194] Settas, D., Cerone, A., & Fenz, S. (2012). Enhancing ontology-based antipattern detection using Bayesian networks. Expert Systems with Applications, 39(10), 9041–9053.

[S195] Settas, D., Meditskos, G., Bassiliades, N., & Stamelos, I. G. (2011, June). Detecting antipatterns using a web-based collaborative antipattern ontology knowledge base. In International Conference on Advanced Information Systems Engineering (pp. 478–488). Springer, Berlin, Heidelberg.

[S196] Settas, D. L., Sowe, S. K., & Stamelos, I. G. (2009). Detecting similarities in antipattern ontologies using semantic social networks: implications for software project management. The Knowledge Engineering Review, 24(3), 287–307.

[S197] Sfayhi, A., & Sahraoui, H. (2011, September). What you see is what you asked for: an effort-based transformation of code analysis tasks into interactive visualization scenarios. In Source Code Analysis and Manipulation (SCAM), 2011 11th IEEE International Working Conference on (pp. 195–203). IEEE.

[S198] Shaikh, M., & Lee, C. G. (2016). Aspect oriented re-engineering of legacy software using cross-cutting concern characterization and significant code smells detection. International Journal of Software Engineering and Knowledge Engineering, 26(03), 513–536.

[S199] Singh, S., & Kahlon, K. S. (2011). Effectiveness of encapsulation and object-oriented metrics to refactor code and identify error prone classes using bad smells. ACM SIGSOFT Software Engineering Notes, 36(5), 1–10.

[S200] Singh, S., & Kahlon, K. S. (2012). Effectiveness of refactoring metrics model to identify smelly and error prone classes in open source software. ACM SIGSOFT Software Engineering Notes, 37(2), 1–11.

[S201] Smith, C. U., & Williams, L. G. (2001, December). Software performance antipatterns; common performance problems and their solutions. In Int. CMG Conference (pp. 797–806).

[S202] Speicher, D., Jancke, S. (2010). Smell detection in context. Softwaretechnik-Trends, 30(2).

[S203] Srivisut, K., & Muenchaisri, P. (2007, July). Defining and detecting bad smells of aspect-oriented software. In Computer Software and Applications Conference, 2007. COMPSAC 2007. 31st Annual International (Vol. 1, pp. 65–70). IEEE.

[S204] Stoianov, A., & Şora, I. (2010, May). Detecting patterns and antipatterns in software using Prolog rules. In Computational Cybernetics and Technical Informatics (ICCC-CONTI), 2010 International Joint Conference on (pp. 253–258). IEEE.

[S205] Stolee, K. T., & Elbaum, S. (2011, May). Refactoring pipe-like mashups for end-user programmers. In Proceedings of the 33rd International Conference on Software Engineering (pp. 81–90). ACM.

[S206] Tahmid, A., Nahar, N., & Sakib, K. (2016, March). Understanding the evolution of code smells by observing code smell clusters. In Software Analysis, Evolution, and Reengineering (SANER), 2016 IEEE 23rd International Conference on (Vol. 4, pp. 8–11). IEEE.

[S207] Tahvildari, L., & Kontogiannis, K. (2003, March). A metric-based approach to enhance design quality through meta-pattern transformations. In Software Maintenance and Reengineering, 2003. Proceedings. Seventh European Conference on (pp. 183–192). IEEE.

[S208] Tahvildar, L., & Kontogiannis, K. (2004). Improving design quality using meta-pattern transformations: a metric-based approach. Journal of Software: Evolution and Process, 16(4–5), 331–361.

[S209] Tamrawi, A., Nguyen, H. A., Nguyen, H. V., & Nguyen, T. N. (2012, June). Build code analysis with symbolic evaluation. In Proceedings of the 34th International Conference on Software Engineering (pp. 650–660). IEEE Press.

[S210] Tamrawi, A., Nguyen, H. A., Nguyen, H. V., & Nguyen, T. N. (2012, September). SYMake: a build code analysis and refactoring tool for makefiles. In Proceedings of the 27th IEEE/ACM International Conference on Automated Software Engineering (pp. 366–369). ACM.

[S211] Tekin, U., & Buzluca, F. (2014). A graph mining approach for detecting identical design structures in object-oriented design models. Science of Computer Programming, 95, 406–425.

[S212] Tourwé, T., & Mens, T. (2003, March). Identifying refactoring opportunities using logic meta programming. In Software Maintenance and Reengineering, 2003. Proceedings. Seventh European Conference on (pp. 91–100). IEEE.

[S213] Trifu, A., & Marinescu, R. (2005, November). Diagnosing design problems in object oriented systems. In Reverse Engineering, 12th Working Conference on (pp. 10-pp). IEEE.

[S214] Trubiani, C., & Koziolek, A. (2011, March). Detection and solution of software performance antipatterns in palladio architectural models. In ACM SIGSOFT Software Engineering Notes (Vol. 36, No. 5, pp. 19–30). ACM.

[S215] Trucchia, F., & Romei, J. (2010). Finding “Bad Smells” in code. In Pro PHP Refactoring (pp. 5–24). Apress.

[S216] Tsantalis, N., Chaikalis, T., & Chatzigeorgiou, A. (2008, April). JDeodorant: identification and removal of type-checking bad smells. In Software Maintenance and Reengineering, 2008. CSMR 2008. 12th European Conference on (pp. 329–331). IEEE.

[S217] Tsantalis, N., & Chatzigeorgiou, A. (2011, March). Ranking refactoring suggestions based on historical volatility. In Software Maintenance and Reengineering (CSMR), 2011 15th European Conference on (pp. 25–34). IEEE.

[S218] Tufano, M., Palomba, F., Bavota, G., Oliveto, R., Di Penta, M., De Lucia, A., & Poshyvanyk, D. (2015, May). When and why your code starts to smell bad. In Software Engineering (ICSE), 2015 IEEE/ACM 37th IEEE International Conference on (Vol. 1, pp. 403–414). IEEE.

[S219] Vale, G., Figueiredo, E., Abílio, R., & Costa, H. (2014, September). Bad smells in software product lines: a systematic review. In Software Components, Architectures and Reuse (SBCARS), 2014 Eighth Brazilian Symposium on(pp. 84–94). IEEE.

[S220] Van Emden, E., & Moonen, L. (2002). Java quality assurance by detecting code smells. In Reverse Engineering, 2002. Proceedings. Ninth Working Conference on (pp. 97–106). IEEE.

[S221] Verebi, I. (2015, September). A model-based approach to software refactoring. In Software Maintenance and Evolution (ICSME), 2015 IEEE International Conference on (pp. 606–609). IEEE.

[S222] Vidal, S., Vazquez, H., Diaz-Pace, J. A., Marcos, C., Garcia, A., & Oizumi, W. (2015, November). JSpIRIT: a flexible tool for the analysis of code smells. In Chilean Computer Science Society (SCCC), 2015 34th International Conference of the(pp. 1–6). IEEE.

[S223] Vidal, S. A., Marcos, C., & Díaz-Pace, J. A. (2016). An approach to prioritize code smells for refactoring. Automated Software Engineering, 23(3), 501–532.

[S224] Štolc, M., & Polášek, I. (2010, January). A visual based framework for the model refactoring techniques. In Applied Machine Intelligence and Informatics (SAMI), 2010 IEEE 8th International Symposium on (pp. 72–82). IEEE.

[S225] Walter, B., & Alkhaeir, T. (2016). The relationship between design patterns and code smells: an exploratory study. Information and Software Technology, 74, 127–142.

[S226] Walter, B., Matuszyk, B., & Fontana, F. A. (2015, May). Including structural factors into the metrics-based code smells detection. In Scientific Workshop Proceedings of the XP2015(p. 11). ACM.

[S227] Walter, B., & Pietrzak, B. (2005, June). Multi-criteria detection of bad smells in code with UTA method. In International Conference on Extreme Programming and Agile Processes in Software Engineering (pp. 154–161). Springer, Berlin, Heidelberg.

[S228] Wang, C., Hirasawa, S., Takizawa, H., & Kobayashi, H. (2014, May). A platform-specific code smell alert system for high performance computing applications. In Parallel & Distributed Processing Symposium Workshops (IPDPSW), 2014 IEEE International (pp. 652–661). IEEE.

[S229] Wasylkowski, A., Zeller, A., & Lindig, C. (2007, September). Detecting object usage anomalies. In Proceedings of the the 6th joint meeting of the European software engineering conference and the ACM SIGSOFT symposium on The foundations of software engineering (pp. 35–44). ACM.

[S230] Winkler, D., & Biffl, S. (2006, June). An empirical study on design quality improvement from best-practice inspection and pair programming. In International Conference on Product Focused Software Process Improvement (pp. 319–333). Springer, Berlin, Heidelberg.

[S231] Yamashita, A. (2014). Assessing the capability of code smells to explain maintenance problems: an empirical study combining quantitative and qualitative data. Empirical Software Engineering, 19(4), 1111–1143.

[S232] Yamashita, A., & Counsell, S. (2013). Code smells as system-level indicators of maintainability: an empirical study. Journal of Systems and Software, 86(10), 2639–2653.

[S233] Yamashita, A., & Moonen, L. (2013). To what extent can maintenance problems be predicted by code smell detection?—an empirical study. Information and Software Technology, 55(12), 2223–2242.

[S234] Yamashita, A., Zanoni, M., Fontana, F. A., & Walter, B. (2015, September). Inter-smell relations in industrial and open source systems: A replication and comparative analysis. In Software Maintenance and Evolution (ICSME), 2015 IEEE International Conference on (pp. 121–130). IEEE.

[S235] Yamashita, A., & Moonen, L. (2013, October). Do developers care about code smells? an exploratory survey. In Reverse Engineering (WCRE), 2013 20th Working Conference on (pp. 242–251). IEEE.

[S236] Yamashita, A., & Moonen, L. (2013, May). Exploring the impact of inter-smell relations on software maintainability: an empirical study. In Software Engineering (ICSE), 2013 35th International Conference on (pp. 682–691). IEEE.

[S237] Yoshida, N., Saika, T., Choi, E., Ouni, A., & Inoue, K. (2016, May). Revisiting the relationship between code smells and refactoring. In Program Comprehension (ICPC), 2016 IEEE 24th International Conference on (pp. 1–4). IEEE.

[S238] Zamani, B., Butler, G. (2009). Smell detection in UML designs which utilize pattern languages. Iranian Journal of Electrical and Computer Engineer-ing (IJECE), 8(1), 47–52.

[S239] Zazworka, N., Seaman, C., & Shull, F. (2011, May). Prioritizing design debt investment opportunities. In Proceedings of the 2nd Workshop on Managing Technical Debt (pp. 39–42). ACM.

[S240] Zazworka, N., Shaw, M. A., Shull, F., & Seaman, C. (2011, May). Investigating the impact of design debt on software quality. In Proceedings of the 2nd Workshop on Managing Technical Debt (pp. 17–23). ACM.

[S241] Zhang, L., Sun, Y., Song, H., Wang, W., & Huang, G. (2012, October). Detecting anti-patterns in java ee runtime system model. In Proceedings of the Fourth Asia-Pacific Symposium on Internetware (p. 21). ACM.

[S242] Zhang, M., Baddoo, N., Wernick, P., & Hall, T. (2008, October). Improving the precision of fowler’s definitions of bad smells. In Software Engineering Workshop, 2008. SEW’08. 32nd Annual IEEE (pp. 161–166). IEEE.

[S243] Abdelmoez, W., Kosba, E., & Iesa, A. F. (2014, January). Risk-based code smells detection tool. In The International Conference on Computing Technology and Information Management (ICCTIM) (p. 148). Society of Digital Information and Wireless Communication.

[S244] Abilio, R., Vale, G., Oliveira, J., Figueiredo, E., & Costa, H. (2014). Code Smell Detection Tool for Compositional-based Software Product Lines. In Proceedings of 21th Brazilian Conference on Software, Tools Session (pp. 109–116).

[S245] Linares-Vásquez, M., Klock, S., McMillan, C., Sabané, A., Poshyvanyk, D., & Guéhéneuc, Y. G. (2014, June). Domain matters: bringing further evidence of the relationships among anti-patterns, application domains, and quality-related metrics in Java mobile apps. In Proceedings of the 22nd International Conference on Program Comprehension (pp. 232–243). ACM.

[S246] Adnan, M., & Afzal, M. (2016, October). A novel approach to super quality software development using workflows. In Ubiquitous Computing, Electronics & Mobile Communication Conference (UEMCON), IEEE Annual (pp. 1–3). IEEE.

[S247] Ahmed, I., Brindescu, C., Mannan, U. A., Jensen, C., & Sarma, A. (2017, November). An empirical examination of the relationship between code smells and merge conflicts. In Empirical Software Engineering and Measurement (ESEM), 2017 ACM/IEEE International Symposium on (pp. 58–67). IEEE.

[S248] Aivaloglou, E., & Hermans, F. (2016, August). How kids code and how we know: an exploratory study on the Scratch repository. In Proceedings of the 2016 ACM Conference on International Computing Education Research (pp. 53–61). ACM.

[S249] Aniche, M., Bavota, G., Treude, C., Gerosa, M. A., & van Deursen, A. (2017). Code smells for model-view-controller architectures. Empirical Software Engineering, 1–37.

[S250] Aniche, M., Bavota, G., Treude, C., Van Deursen, A., & Gerosa, M. A. (2016, October). A validated set of smells in model-view-controller architectures. In Software Maintenance and Evolution (ICSME), 2016 IEEE International Conference on (pp. 233–243). IEEE.

[S251] Aras, M. T., & Selçuk, Y. E. (2016, July). Metric and rule based automated detection of antipatterns in object-oriented software systems. In Computer Science and Information Technology (CSIT), 2016 7th International Conference on (pp. 1–6). IEEE.

[S252] Fontana, F. A., & Zanoni, M. (2017). Code smell severity classification using machine learning techniques. Knowledge-Based Systems, 128, 43–58.

[S253] Beena, R. (2015). A study of code smells in software versioning system using data mining techniques. 3, 37–39.

[S254] Bowes, D., Randall, D., & Hall, T. (2013, May). The inconsistent measurement of message chains. In Emerging Trends in Software Metrics (WETSoM), 2013 4th International Workshop on (pp. 62–68). IEEE.

[S255] Brabra, H., Mtibaa, A., Sliman, L., Gaaloul, W., Benatallah, B., & Gargouri, F. (2016, October). Detecting cloud (anti) patterns: OCCI perspective. In International Conference on Service-Oriented Computing (pp. 202–218). Springer, Cham.

[S256] Carette, A., Younes, M. A. A., Hecht, G., Moha, N., & Rouvoy, R. (2017, February). Investigating the energy impact of android smells. In Software Analysis, Evolution and Reengineering (SANER), 2017 IEEE 24th International Conference on (pp. 115–126). IEEE.

[S257] Charalampidou, S., Ampatzoglou, A., Chatzigeorgiou, A., & Avgeriou, P. (2017, May). Assessing code smell interest probability: a case study. In Proceedings of the XP2017 Scientific Workshops (p. 5). ACM.

[S258] Chen, W. K., & Wang, J. C. (2012, August). Bad smells and refactoring methods for gui test scripts. In Software Engineering, Artificial Intelligence, Networking and Parallel & Distributed Computing (SNPD), 2012 13th ACIS International Conference on (pp. 289–294). IEEE.

[S259] Chen, Z., Chen, L., Ma, W., & Xu, B. (2016, November). Detecting code smells in Paython programs. In Software Analysis, Testing and Evolution (SATE), International Conference on (pp. 18–23). IEEE.

[S260] Choudhary, A. & Singh, P. (2016). Minimizing refactoring effort through prioritization of classes based on historical, architectural and code smell information. CEUR Workshop Proc. 1771, (pp.76–79).

[S261] Codabux, Z., Sultana, K. Z., & Williams, B. J. (2017). The relationship between traceable code patterns and code smells. In Proc. 29th Int. Conf. Software Engineering and Knowledge Engineering.

[S262] Counsell, S., Hierons, R. M., Hamza, H., Black, S., & Durrand, M. (2010, May). Is a strategy for code smell assessment long overdue?. In Proceedings of the 2010 ICSE Workshop on Emerging Trends in Software Metrics (pp. 32–38). ACM.

[S263] da Silva Carvalho, L. P., Novais, R., do Nascimento Salvador, L., & de Mendonça Neto, M. G. (2017). An ontology-based approach to analyzing the occurrence of code smells in software.

[S264] da Silva Sousa, L. (2016, May). Spotting design problems with smell agglomerations. In Software Engineering Companion (ICSE-C), IEEE/ACM International Conference on (pp. 863–866). IEEE.

[S265] D’Ambros, M., Bacchelli, A., & Lanza, M. (2010, July). On the impact of design flaws on software defects. In Quality Software (QSIC), 2010 10th International Conference on (pp. 23–31). IEEE.

[S266] de Andrade, H. S., Almeida, E., & Crnkovic, I. (2014, April). Architectural bad smells in software product lines: an exploratory study. In Proceedings of the WICSA 2014 Companion Volume (p. 12). ACM.

[S267] de Mello, R., Oliveira, R., Sousa, L., & Garcia, A. (2017, May). Towards effective teams for the identification of code smells. In Cooperative and Human Aspects of Software Engineering (CHASE), 2017 IEEE/ACM 10th International Workshop on(pp. 62–65). IEEE.

[S268] Delchev, M., & Harun, M. F. (2015). Investigation of code smells in different software domains. Full-scale Software Engineering, 31.

[S269] Dhaka, G., & Singh, P. (2016, December). An empirical investigation into code smell elimination sequences for energy efficient software. In Software Engineering Conference (APSEC), 2016 23rd Asia-Pacific (pp. 349–352). IEEE.

[S270] Dhillon, P. K., & Sidhu, G. (2012). Can software faults be analyzed using bad code smells?: an empirical study. International Journal of Scientific and Research Publications, 2(10), 1–7.

[S271] dos Reis, J. P., e Abreu, F. B., & Carneiro, G. D. F. (2016, September). Code smells incidence: does it depend on the application domain?. In Quality of Information and Communications Technology (QUATIC), 2016 10th International Conference on the (pp. 172–177). IEEE.

[S272] Ferme, V., Marino, A., & Fontana, F. A. (2013). Is it a Real Code Smell to be Removed or not?. In International Workshop on Refactoring & Testing (RefTest), co-located event with XP 2013 Conference.

[S273] Ferreira, M., Barbosa, E., Macia, I., Arcoverde, R., & Garcia, A. (2014, March). Detecting architecturally-relevant code anomalies: a case study of effectiveness and effort. In Proceedings of the 29th Annual ACM Symposium on Applied Computing (pp. 1158–1163). ACM.

[S274] Fontana, F. A., Ferme, V., & Spinelli, S. (2012, June). Investigating the impact of code smells debt on quality code evaluation. In Proceedings of the Third International Workshop on Managing Technical Debt (pp. 15–22). IEEE Press.

[S275] Fontana, F. A., Ferme, V., Zanoni, M., & Roveda, R. (2015, October). Towards a prioritization of code debt: a code smell intensity index. In Managing Technical Debt (MTD), 2015 IEEE 7th International Workshop on (pp. 16–24). IEEE.

[S276] Fontana, F. A., & Maggioni, S. (2011, June). Metrics and antipatterns for software quality evaluation. In Software Engineering Workshop (SEW), 2011 34th IEEE (pp. 48–56). IEEE.

[S277] Fontana, F. A., Pigazzini, I., Roveda, R., Tamburri, D., Zanoni, M., & Di Nitto, E. (2017, April). Arcan: a tool for architectural smells detection. In Software Architecture Workshops (ICSAW), 2017 IEEE International Conference on (pp. 282–285). IEEE.

[S278] Fontana, F. A., Pigazzini, I., Roveda, R., Tamburri, D., Zanoni, M., & Di Nitto, E. (2017, April). Arcan: a tool for architectural smells detection. In Software Architecture Workshops (ICSAW), 2017 IEEE International Conference on (pp. 282–285). IEEE.

[S279] Fontana, F. A., Roveda, R., & Zanoni, M. (2016, April). Tool support for evaluating architectural debt of an existing system: an experience report. In Proceedings of the 31st Annual ACM Symposium on Applied Computing (pp. 1347–1349). ACM.

[S280] Suryanarayana, G., Samarthyam, G., & Sharma, T. (2014). Refactoring for software Design Smells: managing technical debt. Morgan Kaufmann.

[S281] Grigera, J., Garrido, A., & Rivero, J. M. (2014, July). A tool for detecting bad usability smells in an automatic way. In International Conference on Web Engineering (pp. 490–493). Springer, Cham.

[S282] Guimaraes, E., Garcia, A., Figueiredo, E., & Cai, Y. (2013, May). Prioritizing software anomalies with software metrics and architecture blueprints. In Modeling in Software Engineering (MiSE), 2013 5th International Workshop on (pp. 82–88). IEEE.

[S283] Gull, M., Zia, T., & Ilyas, M. (2017). Source code author attribution using author’s programming style and code smells. International Journal of Intelligent Systems and Applications, 9(5), 27.

[S284] Guo, Y., Seaman, C., Zazworka, N., & Shull, F. (2010, May). Domain-specific tailoring of code smells: an empirical study. In Proceedings of the 32nd ACM/IEEE International Conference on Software Engineering-Volume 2 (pp. 167–170). ACM.

[S285] Habchi, S., Hecht, G., Rouvoy, R., & Moha, N. (2017, May). Code smells in iOS apps: how do they compare to Android?. In Proceedings of the 4th International Conference on Mobile Software Engineering and Systems (pp. 110–121). IEEE Press.

[S286] Haendler, T., Sobernig, S., & Strembeck, M. (2017, May). Towards triaging code-smell candidates via runtime scenarios and method-call dependencies. In Proceedings of the XP2017 Scientific Workshops (p. 8). ACM.

[S287] Hall, T., Zhang, M., Bowes, D., & Sun, Y. (2014). Some code smells have a significant but small effect on faults. ACM Transactions on Software Engineering and Methodology (TOSEM), 23(4), 33.

[S288] Hecht, G., Moha, N., & Rouvoy, R. (2016, May). An empirical study of the performance impacts of android code smells. In Proceedings of the International Conference on Mobile Software Engineering and Systems (pp. 59–69). ACM.

[S289] Hermans, F., & Aivaloglou, E. (2016, May). Do code smells hamper novice programming? A controlled experiment on Scratch programs. In Program Comprehension (ICPC), 2016 IEEE 24th International Conference on (pp. 1–10). IEEE.

[S290] Hozano, M., Antunes, N., Fonseca, B. & Costa, E. (2017). Evaluating the accuracy of machine learning algorithms on detecting code smells for different developers. Proc. 19th Int. Conf. Enterp. Inf. Syst. (pp. 474–482).

[S291] Hozano, M., Garcia, A., Antunes, N., Fonseca, B., & Costa, E. (2017, May). Smells are sensitive to developers!: on the efficiency of (un) guided customized detection. In Proceedings of the 25th International Conference on Program Comprehension (pp. 110–120). IEEE Press.

[S292] Husien, H. K., Harun, M. F., & Lichter, H. (2017). Towards a severity and activity based assessment of code smells. Procedia Computer Science, 116, 460–467.

[S293] Jaafar, F., Guéhéneuc, Y. G., Hamel, S., & Khomh, F. (2013, October). Mining the relationship between anti-patterns dependencies and fault-proneness. In Reverse Engineering (WCRE), 2013 20th Working Conference on (pp. 351–360). IEEE.

[S294] Jiang, Y., Li, M., & Zhou, Z. H. (2011). Software defect detection with Rocus. Journal of Computer Science and Technology, 26(2), 328–342.

[S295] Kaur, A., Kaur, K., & Jain, S. (2016, September). Predicting software change-proneness with code smells and class imbalance learning. In Advances in Computing, Communications and Informatics (ICACCI), 2016 International Conference on (pp. 746–754). IEEE.

[S296] Keck, P., Van Hoorn, A., Okanović, D., Pitakrat, T., & Düllmann, T. F. (2016, October). Antipattern-based problem injection for assessing performance and reliability evaluation techniques. In Software Reliability Engineering Workshops (ISSREW), 2016 IEEE International Symposium on (pp. 64–70). IEEE.

[S297] Kessentini, M., & Ouni, A. (2017, May). Detecting Android smells using multi-objective genetic programming. In Proceedings of the 4th International Conference on Mobile Software Engineering and Systems (pp. 122–132). IEEE Press.

[S298] Khomh, F., Penta, M. D., Gueheneuc, Y. G., & Antoniol, G. (2009). An exploratory study of the impact of antipatterns on software changeability. École Polytechnique de Montréal, Tech. Rep. EPM-RT-2009-02.

[S299] Khomh, F., Di Penta, M., & Gueheneuc, Y. G. (2009, October). An exploratory study of the impact of code smells on software change-proneness. In Reverse Engineering, 2009. WCRE’09. 16th Working Conference on (pp. 75–84). IEEE.

[S300] Khumnin, P., & Senivongse, T. (2017, June). SQL antipatterns detection and database refactoring process. In Software Engineering, Artificial Intelligence, Networking and Parallel/Distributed Computing (SNPD), 2017 18th IEEE/ACIS International Conference on (pp. 199–205). IEEE.

[S301] Kim, D. K. (2017). Finding bad code smells with neural network models. International Journal of Electrical and Computer Engineering (IJECE), 7(6), 3613–3621

[S302] Krishna, R., Menzies, T., & Layman, L. (2017). Less is more: minimizing code reorganization using XTREE. Information and Software Technology, 88, 53–66.

[S303] AyshwaryaLakshmi, S., Shanmuga Vadivu, S., & Ramachandran, A. (2013). Detecting and scheduling bad smells using Java Agent Development (JADE). International Journal of Computer Applications, 67(10), 29–37.

[S304] Lenhard, J., Hassan, M. M., Blom, M., & Herold, S. (2017, September). Are code smell detection tools suitable for detecting architecture degradation?. In Proceedings of the 11th European Conference on Software Architecture: Companion Proceedings (pp. 138–144). ACM.

[S305] Li, W., & Shatnawi, R. (2007). An empirical study of the bad smells and class error probability in the post-release object-oriented system evolution. Journal of Systems and Software, 80(7), 1120–1128.

[S306] Llano, M. T., & Pooley, R. (2009, September). UML specification and correction of object-oriented anti-patterns. In Software Engineering Advances, 2009. ICSEA’09. Fourth International Conference on (pp. 39–44). IEEE.

[S307] Lozano, A., Wermelinger, M., & Nuseibeh, B. (2007, September). Assessing the impact of bad smells using historical information. In Ninth international workshop on Principles of software evolution: in conjunction with the 6th ESEC/FSE joint meeting (pp. 31–34). ACM.

[S308] Ma, W., Chen, L., Zhou, Y., & Xu, B. (2016, November). Do we have a chance to fix bugs when refactoring code smells?. In Software Analysis, Testing and Evolution (SATE), International Conference on (pp. 24–29). IEEE.

[S309] Macia Bertran, I., Garcia, A., & von Staa, A. (2011, March). An exploratory study of code smells in evolving aspect-oriented systems. In Proceedings of the tenth international conference on Aspect-oriented software development (pp. 203–214). ACM.

[S310] Macia, I., Garcia, J., Popescu, D., Garcia, A., Medvidovic, N., & von Staa, A. (2012, March). Are automatically-detected code anomalies relevant to architectural sustainability? In Proceedings of the 11th annual international conference on Aspect-oriented Software Development (pp. 167–178). ACM.

[S311] Malhotra, R., Chug, A., & Khosla, P. (2015, August). Prioritization of classes for refactoring: a step towards improvement in software quality. In Proceedings of the Third International Symposium on Women in Computing and Informatics (pp. 228–234). ACM.

[S312] Maneerat, N., & Muenchaisri, P. (2011, May). Bad-smell prediction from software design model using machine learning techniques. In Computer Science and Software Engineering (JCSSE), 2011 Eighth International Joint Conference on (pp. 331–336). IEEE.

[S313] Mäntylä, M. V., Vanhanen, J. & Lassenius, C. (2004). Bad smells—humans as code critics. In Proceedings 20th IEEE Int. Conf. Softw. Maintenance (pp. 399–408).

[S314] Marinescu, R. (2001). Detecting design flaws via metrics in object-oriented systems. In Technology of Object-Oriented Languages and Systems, 2001. TOOLS 39. 39th International Conference and Exhibition on (pp. 173–182). IEEE.

[S315] Marinescu, R. (2012). Assessing technical debt by identifying design flaws in software systems. IBM Journal of Research and Development, 56(5), 9–1.

[S316] Mekruksavanich, S. (2017, March). An adaptive approach for automatic design defects detection in object-oriented systems. In Digital Arts, Media and Technology (ICDAMT), International Conference on (pp. 342–346). IEEE.

[S317] Santos, J. A. M., & Mendonça, M. G. (2014). Identifying strategies on god class detection in two controlled experiments. In SEKE (pp. 244–249).

[S318] Mkaouer, M. W. (2016, October). Interactive code smells detection: an initial investigation. In International Symposium on Search Based Software Engineering (pp. 281–287). Springer, Cham.

[S319] Mo, R., Cai, Y., Kazman, R., & Xiao, L. (2015, May). Hotspot patterns: the formal definition and automatic detection of architecture smells. In Software Architecture (WICSA), 2015 12th Working IEEE/IFIP Conference on (pp. 51–60). IEEE.

[S320] Alkharabsheh, K., Almobydeen, S., Taboada, J. A., & Crespo, Y. (2016). Influence of nominal project knowledge in the detection of design smells: an exploratory study with God Class. International Journal of Advanced Studies in Computers, Science and Engineering, 5(11), 120.

[S321] Moha, N., & Guéhéneuc, Y. G. (2005, July). On the automatic detection and correction of software architectural defects in object-oriented designs. In Proceedings of the 4th ECOOP Workshop on Object-Oriented Reengineering.

[S322] Murphy-Hill, E., & Black, A. P. (2010, October). An interactive ambient visualization for code smells. In Proceedings of the 5th international symposium on Software visualization (pp. 5–14). ACM.

[S323] Nahar, N., & Sakib, K. (2016, March). ACDPR: a recommendation system for the creational design patterns using anti-patterns. In Software Analysis, Evolution, and Reengineering (SANER), 2016 IEEE 23rd International Conference on (Vol. 4, pp. 4–7). IEEE.

[S324] Nanthaamornphong, A., & Chaisutanon, A. (2016, September). Empirical evaluation of code smells in open source projects: preliminary results. In Proceedings of the 1st International Workshop on Software Refactoring (pp. 5–8). ACM.

[S325] Asano, K., Hayashi, S., & Saeki, M. (2017, November). Detecting bad smells of refinement in goal-oriented requirements analysis. In International Conference on Conceptual Modeling (pp. 122–132). Springer, Cham.

[S326] Dhambri, K., Sahraoui, H., & Poulin, P. (2008, April). Visual detection of design anomalies. In Software maintenance and reengineering, 2008. CSMR 2008. 12th European Conference on (pp. 279–283). IEEE.

[S327] Oizumi, W. N., Garcia, A. F., Colanzi, T. E., Ferreira, M., & Staa, A. V. (2015). On the relationship of code-anomaly agglomerations and architectural problems. Journal of Software Engineering Research and Development, 3(1), 11.

[S328] Oizumi, W., Sousa, L., Garcia, A., Oliveira, R., Oliveira, A., Agbachi, O. I., & Lucena, C. (2017). Revealing design problems in stinky code. In Proceedings of the 11th Brazilian Symposium on Software Components, Architectures, and Reuse (pp. 1–10).

[S329] Olbrich, S. M., Cruzes, D. S., & Sjøberg, D. I. (2010, September). Are all code smells harmful? A study of God Classes and Brain Classes in the evolution of three open source systems. In Software Maintenance (ICSM), 2010 IEEE International Conference on (pp. 1–10). IEEE.

[S330] Olbrich, S., Cruzes, D. S., Basili, V., & Zazworka, N. (2009, October). The evolution and impact of code smells: a case study of two open source systems. In Proceedings of the 2009 3rd international symposium on empirical software engineering and measurement (pp. 390–400). IEEE Computer Society.

[S331] de Oliveira, J. A., Fernandes, E. M., & Figueiredo, E. (2015). Evaluation of duplicated code detection tools in cross-project context. In Proceedings of the 3rd Workshop on Software Visualization, Evolution, and Maintenance (pp. 49–56).

[S332] Oliveira, R., Estácio, B., Garcia, A., Marczak, S., Prikladnicki, R., Kalinowski, M., & Lucena, C. (2016, September). Identifying code smells with collaborative practices: a controlled experiment. In Software Components, Architectures and Reuse (SBCARS), 2016 X Brazilian Symposium on (pp. 61–70). IEEE.

[S333] Oliveira, R., Sousa, L., de Mello, R., Valentim, N., Lopes, A., Conte, T., ... & Lucena, C. (2017, May). Collaborative identification of code smells: a multi-case study. In Software Engineering: Software Engineering in Practice Track (ICSE-SEIP), 2017 IEEE/ACM 39th International Conference on (pp. 33–42). IEEE.

[S334] Oliveto, R., Khomh, F., Antoniol, G., & Guéhéneuc, Y. G. (2011, March). Numerical signatures of antipatterns: an approach based on b-splines. In Software maintenance and reengineering (CSMR), 2012 14th European Conference on(pp. 248–251). IEEE.

[S335] Ouni, A., Kessentini, M., Inoue, K., & Cinnéide, M. O. (2017). Search-based web service antipatterns detection. IEEE Transactions on Services Computing, 10(4), 603–617.

[S336] Padilha, J., Pereira, J., Figueiredo, E., Almeida, J., Garcia, A., & Sant’Anna, C. (2014, June). On the effectiveness of concern metrics to detect code smells: an empirical study. In International Conference on Advanced Information Systems Engineering (pp. 656–671). Springer, Cham.

[S337] Paiva, T., Damasceno, A., Figueiredo, E., & Sant’Anna, C. (2017). On the evaluation of code smells and detection tools. Journal of Software Engineering Research and Development, 5(1), 7.

[S338] Paiva, T., Damasceno, A., Padilha, J., Figueiredo, E. & Sant’Anna, C. (2015). Experimental evaluation of code smell detection tools. 3th Work. Softw. Vis. Evol. Maint.

[S339] Palomba, F. (2016, October). Alternative sources of information for code smell detection: postcards from far away. In Software Maintenance and Evolution (ICSME), 2016 IEEE International Conference on (pp. 636–640). IEEE.

[S340] Palomba, F., Bavota, G., Di Penta, M., Fasano, F., Oliveto, R., & De Lucia, A. (2017). On the diffuseness and the impact on maintainability of code smells: a large scale empirical investigation. Empirical Software Engineering, 1–34.

[S341] Palomba, F., Di Nucci, D., Panichella, A., Zaidman, A., & De Lucia, A. (2017, February). Lightweight detection of Android-specific code smells: the aDoctor project. In Software Analysis, Evolution and Reengineering (SANER), 2017 IEEE 24th International Conference on (pp. 487–491). IEEE.

[S342] Palomba, F., Oliveto, R., & De Lucia, A. (2017, February). Investigating code smell co-occurrences using association rule learning: a replicated study. In Machine Learning Techniques for Software Quality Evaluation (MaLTeSQuE), IEEE Workshop on (pp. 8–13). IEEE.

[S343] Palomba, F., Panichella, A., Zaidman, A., Oliveto, R., & De Lucia, A. (2017). The scent of a smell: an extensive comparison between textual and structural smells. IEEE Transactions on Software Engineering.

[S344] Palomba, F., Zanoni, M., Fontana, F. A., De Lucia, A., & Oliveto, R. (2017). Toward a smell-aware bug prediction model. IEEE Transactions on Software Engineering.

[S345] Palomba, F., Zanoni, M., Fontana, F. A., De Lucia, A., & Oliveto, R. (2016, October). Smells like teen spirit: improving bug prediction performance using the intensity of code smells. In Software Maintenance and Evolution (ICSME), 2016 IEEE International Conference on (pp. 244–255). IEEE.

[S346] Parnin, C., Görg, C., & Nnadi, O. (2008, September). A catalogue of lightweight visualizations to support code smell inspection. In Proceedings of the 4th ACM symposium on Software visualization (pp. 77–86). ACM.

[S347] Peiris, M., & Hill, J. H. (2016, March). Automatically detecting excessive dynamic memory allocations software performance anti-pattern. In Proceedings of the 7th ACM/SPEC on International Conference on Performance Engineering (pp. 237–248). ACM.

[S348] Peldszus, S., Kulcsár, G., Lochau, M., & Schulze, S. (2016, September). Continuous detection of design flaws in evolving object-oriented programs using incremental multi-pattern matching. In Automated Software Engineering (ASE), 2016 31st IEEE/ACM International Conference on (pp. 578–589). IEEE.

[S349] Dos Reis, J. P., e Abreu, F. B., & Carneiro, G. D. F. (2017, June). Code smells detection 2.0: crowdsmelling and visualization. In Information Systems and Technologies (CISTI), 2017 12th Iberian Conference on (pp. 1–4). IEEE.

[S350] Pessoa, T., Abreu, F. B. E., Monteiro, M. P. & Bryton, S. (2011). An Eclipse plugin to support code smells detection. INFORUM 2011- Simpósio de Informática 12.

[S351] Peters, R., & Zaidman, A. (2012, March). Evaluating the lifespan of code smells using software repository mining. In Software Maintenance and Reengineering (CSMR), 2012 16th European Conference on (pp. 411–416). IEEE.

[S352] Rani, A., & Chhabra, J. K. (2017, February). Prioritization of smelly classes: a two phase approach (Reducing refactoring efforts). In Computational Intelligence & Communication Technology (CICT), 2017 3rd International Conference on (pp. 1–6). IEEE.

[S353] Ratiu, D., Marinescu, R., Ducasse, S., & Gırba, T. (2004). Evolution-enriched detection of God Classes. Proc. of the 2nd CAVIS, 3–7.

[S354] Verma, A., Kumar, A., & Kaur, I. (2017). Automatic multiprogramming bad smell detection with refactoring. International Journal of Advanced and Applied Sciences, 4(9), 80–85.

[S355] Rio, A. & e Abreu, F. (2016). Web systems quality evolution. 10th Int. Conf. Qual. Inf. Commun. Technol. 1, (pp. 248–253).

[S356] Rio, A., & e Abreu, F. B. (2017, June). Analyzing web applications quality evolution. In Information Systems and Technologies (CISTI), 2017 12th Iberian Conference on (pp. 1–4). IEEE.

[S357] Romano, D., Raila, P., Pinzger, M., & Khomh, F. (2012, October). Analyzing the impact of antipatterns on change-proneness using fine-grained source code changes. In Reverse Engineering (WCRE), 2012 19th Working Conference on (pp. 437–446). IEEE.

[S358] Sabane, A., Di Penta, M., Antoniol, G., & Guéhéneuc, Y. G. (2013, March). A study on the relation between antipatterns and the cost of class unit testing. In Software Maintenance and Reengineering (CSMR), 2013 17th European Conference on (pp. 167–176). IEEE.

[S359] Saboury, A., Musavi, P., Khomh, F., & Antoniol, G. (2017, February). An empirical study of code smells in JavaScript projects. In Software Analysis, Evolution and Reengineering (SANER), 2017 IEEE 24th International Conference on (pp. 294–305). IEEE.

[S360] Sae-Lim, N., Hayashi, S., & Saeki, M. (2017, May). Revisiting context-based code smells prioritization: on supporting referred context. In Proceedings of the XP2017 Scientific Workshops (p. 3). ACM.

[S361] Sae-Lim, N., Hayashi, S., & Saeki, M. (2017, September). How do developers select and prioritize code smells? A preliminary study. In Software Maintenance and Evolution (ICSME), 2017 IEEE International Conference on (pp. 484–488). IEEE.

[S362] Salehie, M., Li, S., & Tahvildari, L. (2006, June). A metric-based heuristic framework to detect object-oriented design flaws. In Program Comprehension, 2006. ICPC 2006. 14th IEEE International Conference on (pp. 159–168). IEEE.

[S363] Sangeetha, M., & Sengottuvelan, P. (2017, January). Systematic exhortation of code smell detection using JSmell for Java source code. In Inventive Systems and Control (ICISC), 2017 International Conference on (pp. 1–5). IEEE.

[S364] Santos, J. A. M., Rocha-Junior, J. B., & de Mendonça, M. G. (2017). Investigating factors that affect the human perception on god class detection: an analysis based on a family of four controlled experiments. Journal of Software Engineering Research and Development, 5(1), 8.

[S365] Kaur, K., & Jain, S. (2017). Evaluation of machine learning approaches for change-proneness prediction using code smells. In Proceedings of the 5th International Conference on Frontiers in Intelligent Computing: Theory and Applications(pp. 561–572). Springer, Singapore.

[S366] Serikawa, M. A., Landi, A. D. S., Siqueira, B. R., Costa, R. S., Ferrari, F. C., Menotti, R., & de Camargo, V. V. (2016, September). Towards the characterization of monitor smells in adaptive systems. In Software Components, Architectures and Reuse (SBCARS), 2016 X Brazilian Symposium on (pp. 51–60). IEEE.

[S367] Sharma, T., Fragkoulis, M., & Spinellis, D. (2016, May). Does your configuration code smell?. In Mining Software Repositories (MSR), 2016 IEEE/ACM 13th Working Conference on (pp. 189–200). IEEE.

[S368] Taibi, D., Janes, A., & Lenarduzzi, V. (2016, May). Towards a lean approach to reduce code smells injection: an empirical study. In International Conference on Agile Software Development (pp. 300–304). Springer, Cham.

[S369] Shatnawi, R., & Li, W. (2006, April). An investigation of bad smells in object-oriented design. In Information Technology: New Generations, 2006. ITNG 2006. Third International Conference on (pp. 161–165). IEEE.

[S370] Shoenberger, I., Mkaouer, M. W., & Kessentini, M. (2017, April). On the use of smelly examples to detect code smells in JavaScript. In European Conference on the Applications of Evolutionary Computation (pp. 20–34). Springer, Cham.

[S371] Singh, S., & Kaur, S. (2017). A systematic literature review: refactoring for disclosing code smells in object oriented software. Ain Shams Engineering Journal.

[S372] Sirikul, K., & Soomlek, C. (2016, July). Automated detection of code smells caused by null checking conditions in Java programs. In Computer Science and Software Engineering (JCSSE), 2016 13th International Joint Conference on (pp. 1–7). IEEE.

[S373] Sjøberg, D. I., Yamashita, A., Anda, B. C., Mockus, A., & Dybå, T. (2013). Quantifying the effect of code smells on maintenance effort. IEEE Transactions on Software Engineering, 39(8), 1144–1156.

[S374] Soh, Z., Yamashita, A., Khomh, F., & Guéhéneuc, Y. G. (2016, March). Do code smells impact the effort of different maintenance programming activities?. In Software Analysis, Evolution, and Reengineering (SANER), 2016 IEEE 23rd International Conference on (Vol. 1, pp. 393–402). IEEE.

[S375] Soltanifar, B., Akbarinasaji, S., Caglayan, B., Bener, A. B., Filiz, A., & Kramer, B. M. (2016, July). Software analytics in practice: a defect prediction model using code smells. In Proceedings of the 20th International Database Engineering & Applications Symposium (pp. 148–155). ACM.

[S376] Sousa, B. L., Souza, P. P., Fernandes, E. M., Ferreira, K. A., & Bigonha, M. A. (2017, May). FindSmells: flexible composition of bad smell detection strategies. In Program Comprehension (ICPC), 2017 IEEE/ACM 25th International Conference on(pp. 360–363). IEEE.

[S377] Srivisut, K., & Muenchaisri, P. (2007, July). Bad-smell metrics for aspect-oriented software. In Computer and Information Science, 2007. ICIS 2007. 6th IEEE/ACIS International Conference on (pp. 1060–1065). IEEE.

[S378] Steinbeck, M. (2017, February). An arc-based approach for visualization of code smells. In Software Analysis, Evolution and Reengineering (SANER), 2017 IEEE 24th International Conference on (pp. 397–401). IEEE.

[S379] Padilha, J., Figueiredo, E., Sant’Anna, C., & Garcia, A. (2013). Detecting god methods with concern metrics: an exploratory study. In Latin-American Workshop on Aspect-Oriented Software Development.

[S380] Taibi, D., Janes, A., & Lenarduzzi, V. (2017). How developers perceive smells in source code: a replicated study. Information and Software Technology, 92, 223–235.

[S381] Techapalokul, P. (2017, March). Sniffing through millions of blocks for bad smells. In Proceedings of the 2017 ACM SIGCSE Technical Symposium on Computer Science Education (pp. 781–782). ACM.

[S382] Vaucher, S., Khomh, F., Moha, N., & Guéhéneuc, Y. G. (2009, October). Tracking design smells: lessons from a study of God Classes. In Reverse Engineering, 2009. WCRE’09. 16th Working Conference on (pp. 145–154). IEEE.

[S383] Velioğlu, S., & Selçuk, Y. E. (2017, June). An automated code smell and anti-pattern detection approach. In Software Engineering Research, Management and Applications (SERA), 2017 IEEE 15th International Conference on (pp. 271–275). IEEE.

[S384] Vidal, S., Guimaraes, E., Oizumi, W., Garcia, A., Pace, A. D., & Marcos, C. (2016, September). Identifying architectural problems through prioritization of code smells. In Software Components, Architectures and Reuse (SBCARS), 2016 X Brazilian Symposium on (pp. 41–50). IEEE.

[S385] Vidal, S., Guimaraes, E., Oizumi, W., Garcia, A., Pace, A. D., & Marcos, C. (2016, April). On the criteria for prioritizing code anomalies to identify architectural problems. In Proceedings of the 31st Annual ACM Symposium on Applied Computing (pp. 1812–1814). ACM.

[S386] Wettel, R., & Lanza, M. (2008, September). Visually localizing design problems with disharmony maps. In Proceedings of the 4th ACM symposium on Software visualization (pp. 155–164). ACM.

[S387] Wong, S., Cai, Y., & Dalton, M. (2010). Detecting design defects caused by design rule violations. Proc of 18th ESEC/FSE.

[S388] Yamashita, A., Abtahizadeh, S. A., Khomh, F., & Guéhéneuc, Y. G. (2017, May). Software evolution and quality data from controlled, multiple, industrial case studies. In Mining Software Repositories (MSR), 2017 IEEE/ACM 14th International Conference on (pp. 507–510). IEEE.

[S389] Yamashita, A., & Moonen, L. (2012, September). Do code smells reflect important maintainability aspects?. In Software Maintenance (ICSM), 2012 28th IEEE International Conference on (pp. 306–315). IEEE.

[S390] Gupta, A., Suri, B., & Misra, S. (2017, July). A systematic literature review: code bad smells in Java source code. In International Conference on Computational Science and Its Applications (pp. 665–682). Springer, Cham.

[S391] Zazworka, N., & Ackermann, C. (2010, September). CodeVizard: a tool to aid the analysis of software evolution. In Proceedings of the 2010 ACM-IEEE International Symposium on Empirical Software Engineering and Measurement (p. 63). ACM.

[S392] Zhang, M., Baddoo, N., Wernick, P., & Hall, T. (2011, March). Prioritising refactoring using code bad smells. In Software Testing, Verification and Validation Workshops (ICSTW), 2011 IEEE Fourth International Conference on (pp. 458–464). IEEE.

[S393] Zhang, X., Zhou, Y., & Zhu, C. (2017, November). An empirical study of the impact of bad designs on defect proneness. In Software Analysis, Testing and Evolution (SATE), 2017 International Conference on (pp. 1–9). IEEE.

[S394] Zhao, X., Xuan, X., & Li, S. (2015, November). An empirical study of Long Method and God Method in industrial projects. In Automated Software Engineering Workshop (ASEW), 2015 30th IEEE/ACM International Conference on (pp. 109–114). IEEE.

[S395] Frącz, W., & Dajda, J. (2017, July). Experimental validation of source code reviews on mobile devices. In International Conference on Computational Science and Its Applications(pp. 533–547). Springer, Cham.