Papers
Topics
Authors
Recent
Gemini 2.5 Flash
Gemini 2.5 Flash
194 tokens/sec
GPT-4o
7 tokens/sec
Gemini 2.5 Pro Pro
46 tokens/sec
o3 Pro
4 tokens/sec
GPT-4.1 Pro
38 tokens/sec
DeepSeek R1 via Azure Pro
28 tokens/sec
2000 character limit reached

Predicting the Impact of Batch Refactoring Code Smells on Application Resource Consumption (2306.15763v1)

Published 27 Jun 2023 in cs.SE and cs.LG

Abstract: Automated batch refactoring has become a de-facto mechanism to restructure software that may have significant design flaws negatively impacting the code quality and maintainability. Although automated batch refactoring techniques are known to significantly improve overall software quality and maintainability, their impact on resource utilization is not well studied. This paper aims to bridge the gap between batch refactoring code smells and consumption of resources. It determines the relationship between software code smell batch refactoring, and resource consumption. Next, it aims to design algorithms to predict the impact of code smell refactoring on resource consumption. This paper investigates 16 code smell types and their joint effect on resource utilization for 31 open source applications. It provides a detailed empirical analysis of the change in application CPU and memory utilization after refactoring specific code smells in isolation and in batches. This analysis is then used to train regression algorithms to predict the impact of batch refactoring on CPU and memory utilization before making any refactoring decisions. Experimental results also show that our ANN-based regression model provides highly accurate predictions for the impact of batch refactoring on resource consumption. It allows the software developers to intelligently decide which code smells they should refactor jointly to achieve high code quality and maintainability without increasing the application resource utilization. This paper responds to the important and urgent need of software engineers across a broad range of software applications, who are looking to refactor code smells and at the same time improve resource consumption. Finally, it brings forward the concept of resource aware code smell refactoring to the most crucial software applications.

Definition Search Book Streamline Icon: https://streamlinehq.com
References (51)
  1. Jari Aarniala. 2005. Instrumenting java bytecode. In Seminar work for the Compilerscourse, Department of Computer Science, University of Helsinki, Finland.
  2. An empirical study of the impact of two antipatterns, blob and spaghetti code, on program comprehension. In 2011 15th European Conference on Software Maintenance and Reengineering. IEEE, 181–190.
  3. Exploratory study of the impact of project domain and size category on the detection of the God class design smell. Software Quality Journal (2021), 1–41.
  4. Coping with an open bug repository. In Proceedings of the 2005 OOPSLA workshop on Eclipse technology eXchange. 35–39.
  5. Evaluating the impact of code smell refactoring on the energy consumption of Android applications. In 2019 45th Euromicro Conference on Software Engineering and Advanced Applications (SEAA). IEEE, 82–86.
  6. A Berkeley view of cloud computing. UC Berkeley EECS Technical Report EECS-2009-28 (2009).
  7. Above the clouds: A berkeley view of cloud computing. Technical Report. Technical Report UCB/EECS-2009-28, EECS Department, University of California, Berkeley.
  8. Using findbugs on production software. In Companion to the 22nd ACM SIGPLAN conference on Object-oriented programming systems and applications companion. 805–806.
  9. A Quantitative Study on Characteristics and Effect of Batch Refactoring on Code Smells. In 2019 ACM/IEEE International Symposium on Empirical Software Engineering and Measurement (ESEM). 1–11. https://doi.org/10.1109/ESEM.2019.8870183
  10. Miroslav D Ćirić and Svetozar R Rančić. 2005. Parsing in different languages. Facta universitatis-series: Electronics and Energetics 18, 2 (2005), 299–307.
  11. Scott Cromar. 2013. GanttProject. In From Techie to Boss. Springer, 225–229.
  12. Frederick. Dietz and Timo Stitch. 2017. Columba Email Client Project. URL: http://columba.sourceforge.net/testing/index.php(visited on 2/11/2021) (2017).
  13. Anthony J Dos Reis. 2012. Compiler Construction Using Java, JavaCC, and Yacc. John Wiley & Sons.
  14. Multilingual semantic parsing and code-switching. In Proceedings of the 21st Conference on Computational Natural Language Learning (CoNLL 2017). 379–389.
  15. Eduardo Fernandes. 2019. Stuck in the middle: Removing obstacles to new program features through batch refactoring. In 2019 IEEE/ACM 41st International Conference on Software Engineering: Companion Proceedings (ICSE-Companion). IEEE, 206–209.
  16. JDeodorant: identification and application of extract class refactorings. In 2011 33rd International Conference on Software Engineering (ICSE). IEEE, 1037–1039.
  17. Martin Fowler. 2018. Refactoring: improving the design of existing code. Addison-Wesley Professional.
  18. Erich Gamma. 1995. Design patterns: elements of reusable object-oriented software. Pearson Education India.
  19. Hristina Gulabovska and Zoltán Porkoláb. 2019. Survey on Static Analysis Tools of Python Programs.. In SQAMIA.
  20. Emily H Halili. 2008. Apache JMeter. Packt Publishing Birmingham.
  21. Towards resource consumption-aware programming. In 2009 Fourth International Conference on Software Engineering Advances. IEEE, 490–493.
  22. Splendid IT-Consulting. 2020. JSparrow.
  23. Actively comparing clones inside the code editor. In Proceedings of the 4th International Workshop on Software Clones. 9–16.
  24. J James. [n.d.]. JParse: A Java Parser. Retrieved (11 September 2004) from http://www. ittc. ku. edu/JParse ([n. d.]).
  25. Theodore W Leung. 2004. Professional XML Development with Apache Tools: Xerces, Xalan, FOP, Cocoon, Axis, Xindice. John Wiley & Sons.
  26. Application of Log4j in E-Commerce Services. In Applied Mechanics and Materials, Vol. 635. Trans Tech Publ, 1517–1521.
  27. Java Code Coverage Test Technology Based on EMMA. In Advanced Materials Research, Vol. 1049. Trans Tech Publ, 2069–2072.
  28. Emerson Murphy-Hill. 2008. Scalable, expressive, and context-sensitive code smell display. In Companion to the 23rd ACM SIGPLAN conference on Object-oriented programming systems languages and applications. 771–772.
  29. Glenford J Myers. 1978. A controlled experiment in program testing and code walkthroughs/inspections. Commun. ACM 21, 9 (1978), 760–768.
  30. JRuby. URL: http://jruby. org/(visited on 12/11/2013) (2014).
  31. An Empirical Study on the Impact of Android Code Smells on Resource Usage.. In SEKE. 314–313.
  32. Kelly O’Hair. 2004. HPROF: a Heap/CPU profiling tool in J2SE 5.0. Sun Developer Network, Developer Technical Articles & Tips 28 (2004).
  33. Behind the intents: An in-depth empirical study on software refactoring in modern code review. In Proceedings of the 17th International Conference on Mining Software Repositories. 125–136.
  34. On the impact of code smells on the energy consumption of mobile applications. Information and Software Technology 105 (2019), 43–55.
  35. Investigation for Software Power Consumption of Code Refactoring Techniques.. In SEKE. 717–722.
  36. Terence J. Parr and Russell W. Quong. 1995. ANTLR: A predicated-LL (k) parser generator. Software: Practice and Experience 25, 7 (1995), 789–810.
  37. Ricardo Pérez-Castillo and Mario Piattini. 2014. Analyzing the harmful effect of god class refactoring on power consumption. IEEE software 31, 3 (2014), 48–54.
  38. Testing in the cloud: Exploring the practice. IEEE software 29, 2 (2011), 46–51.
  39. A comparison of bug finding tools for java. In 15th International symposium on software reliability engineering. IEEE, 245–256.
  40. Refactoring for software architecture smells. In Proceedings of the 1st International Workshop on Software Refactoring. 1–4.
  41. Self-Admitted Technical Debt classification using LSTM neural network. In 17th International Conference on Information Technology–New Generations (ITNG 2020). Springer, 679–685.
  42. Measuring quality of software modularization. US Patent 8,146,058.
  43. Jolita Savolskyte. 2004. Review of the JHotDraw framework. Harlow, Information and Media Technologies (2004).
  44. OpenStack: toward an open-source solution for cloud computing. International Journal of Computer Applications 55, 3 (2012), 38–42.
  45. Alexander Shvets. [n.d.]. Java Code Smells, https://refactoring.guru/, 2021.
  46. Qualitas Corpus: A Curated Collection of Java Code for Empirical Studies. In 2010 Asia Pacific Software Engineering Conference (APSEC2010). 336–345. https://doi.org/10.1109/APSEC.2010.46
  47. Use, disuse, and misuse of automated refactorings. In 2012 34th International Conference on Software Engineering (ICSE). IEEE, 233–243.
  48. Empirical Evaluation of the Energy Impact of Refactoring Code Smells.. In ICT4S. 365–383.
  49. A platform-specific code smell alert system for high performance computing applications. In 2014 IEEE International Parallel & Distributed Processing Symposium Workshops. IEEE, 652–661.
  50. Makarius Wenzel. 2012. Isabelle/jEdit–a Prover IDE within the PIDE framework. In International Conference on Intelligent Computer Mathematics. Springer, 468–471.
  51. Predicting defects for eclipse. In Third International Workshop on Predictor Models in Software Engineering (PROMISE’07: ICSE Workshops 2007). IEEE, 9–9.
Citations (1)
View on Semantic Scholar

Summary

We haven't generated a summary for this paper yet.

Ai Sparkles Streamline Icon: https://streamlinehq.com Summarize Now