More Web Proxy on the site http://driver.im/

research-article

Why Developers Refactor Source Code: A Mining-based Study

Authors:

Jevgenija Pantiuchina,

Fiorella Zampetti,

Simone Scalabrino,

Valentina Piantadosi,

Gabriele Bavota,

Massimiliano Di PentaAuthors Info & Claims

ACM Transactions on Software Engineering and Methodology (TOSEM), Volume 29, Issue 4

Article No.: 29, Pages 1 - 30

https://doi.org/10.1145/3408302

Published: 26 September 2020 Publication History

Abstract

Refactoring aims at improving code non-functional attributes without modifying its external behavior. Previous studies investigated the motivations behind refactoring by surveying developers. With the aim of generalizing and complementing their findings, we present a large-scale study quantitatively and qualitatively investigating why developers perform refactoring in open source projects. First, we mine 287,813 refactoring operations performed in the history of 150 systems. Using this dataset, we investigate the interplay between refactoring operations and process (e.g., previous changes/fixes) and product (e.g., quality metrics) metrics. Then, we manually analyze 551 merged pull requests implementing refactoring operations and classify the motivations behind the implemented refactorings (e.g., removal of code duplication). Our results led to (i) quantitative evidence of the relationship existing between certain process/product metrics and refactoring operations and (ii) a detailed taxonomy, generalizing and complementing the ones existing in the literature, of motivations pushing developers to refactor source code.

References

[1]

[n.d.]. 52North/WPS Pull Request #73. Retrieved from https://github.com/52North/WPS/pull/73.

[2]

[n.d.]. apache/fineract Pull Request #366. Retrieved from https://github.com/apache/fineract/pull/366.

[3]

[n.d.]. cbeust/testng Pull Request #1481. Retrieved from https://github.com/cbeust/testng/pull/1481.

[4]

[n.d.]. Code metrics for Java code by means of static analysis. Retrieved from https://github.com/mauricioaniche/ck.

[5]

[n.d.]. confluentinc/kafka-connect-elasticsearch Pull Request #251. Retrieved from https://github.com/confluentinc/kafka-connect-elasticsearch/pull/251.

[6]

[n.d.]. dropwizard/dropwizard Pull Request #488. Retrieved from https://github.com/dropwizard/dropwizard/pull/488.

[7]

[n.d.]. DSpace/DSpace Pull Request #1083. Retrieved from https://github.com/DSpace/DSpace/pull/1083.

[8]

[n.d.]. DSpace/DSpace Pull Request #324. Retrieved from https://github.com/DSpace/DSpace/pull/324.

[9]

[n.d.]. eclipse/microprofile-fault-tolerance Pull Request #363. Retrieved from https://github.com/eclipse/microprofile-fault-tolerance/pull/363.

[10]

[n.d.]. google/error-prone Pull Request #1071. Retrieved from https://github.com/google/error-prone/pull/1071.

[11]

[n.d.]. kiegroup/optaplanner Pull Request #150. Retrieved from https://github.com/kiegroup/optaplanner/pull/150.

[12]

[n.d.]. minio/minio-java Pull Request #238. Retrieved from https://github.com/minio/minio-java/pull/238.

[13]

[n.d.]. PMD Source Code Analyzer. Retrieved from http://pmd.sourceforge.net.

[14]

[n.d.]. samtools/htsjdk Pull Request #1067. Retrieved from https://github.com/samtools/htsjdk/pull/1067.

[15]

[n.d.]. samtools/htsjdk Pull Request #599. Retrieved from https://github.com/samtools/htsjdk/pull/599.

[16]

[n.d.]. spring-io/sagan Pull Request #179. Retrieved from https://github.com/spring-io/sagan/issues/179.

[17]

[n.d.]. spring-io/sagan Pull Request #317. Retrieved from https://github.com/spring-io/sagan/pull/317.

[18]

[n.d.]. spring-projects/spring-amqp Pull Request #346. Retrieved from https://github.com/spring-projects/spring-amqp/pull/346.

[19]

[n.d.]. TeamAmaze/AmazeFileManager Pull Request #1577. Retrieved from https://github.com/TeamAmaze/AmazeFileManager/pull/1577.

[20]

[n.d.]. zalando/nakadi Pull Request #626. Retrieved from https://github.com/zalando/nakadi/pull/626.

[21]

[n.d.]. zalando/nakadi/ Pull Request #933. Retrieved from https://github.com/zalando/nakadi/pull/933.

[22]

[n.d.]. zhcet-amu/zhcet-web Pull Request #136. Retrieved from https://github.com/zhcet-amu/zhcet-web/pull/136.

[23]

H. Akaike. 1973. Information theory and an extension of the maximum likelihood principle. In Proceedings of the 2nd International Symposium on Information Theory.

[24]

Miltiadis Allamanis, Earl T. Barr, Christian Bird, and Charles Sutton. 2014. Learning natural coding conventions. In Proceedings of the 22nd ACM SIGSOFT International Symposium on Foundations of Software Engineering (FSE’14). 281--293.

Digital Library

[25]

Uri Alon, Meital Zilberstein, Omer Levy, and Eran Yahav. 2019. Code2Vec: Learning distributed representations of code. Proc. ACM Program. Lang. 3 (January 2019), 40:1–40:29.

Digital Library

[26]

Mohammad Alshayeb. 2009. Empirical investigation of refactoring effect on software quality. Inf. Softw. Technol. 51, 9 (2009), 1319--1326.

Digital Library

[27]

Anonymous. 2018. Replication Package. Retrieved from https://github.com/replication-package/why-refactoring.

[28]

Nicolas Anquetil and Timothy Lethbridge. 1999. Experiments with clustering as a software remodularization method. In Proceedings of the Working Conference on Reverse Engineering (WCRE’99). 235--255.

[29]

Giuliano Antoniol, Kamel Ayari, Massimiliano Di Penta, Foutse Khomh, and Yann-Gaël Guéhéneuc. 2008. Is it a bug or an enhancement?: A text-based approach to classify change requests. In Proceedings of the 2008 Conference of the Centre for Advanced Studies on Collaborative Research. IBM, 23.

Digital Library

[30]

Davide Arcelli, Vittorio Cortellessa, and Catia Trubiani. 2012. Antipattern-based model refactoring for software performance improvement. In Proceedings of the 8th International ACM SIGSOFT Conference on Quality of Software Architectures (QoSA’12). 33--42.

Digital Library

[31]

Venera Arnaoudova, Massimiliano Di Penta, Giuliano Antoniol, and Yann-Gaël Guéhéneuc. 2013. A new family of software anti-patterns: Linguistic anti-patterns. In Proceedings of the 17th European Conference on Software Maintenance and Reengineering (CSMR’13). 187--196.

Digital Library

[32]

Douglas Bates, Martin Mächler, Ben Bolker, and Steve Walker. 2015. Fitting linear mixed-effects models using lme4. J. Stat. Softw. 67, 1 (2015), 1--48.

[33]

Gabriele Bavota. 2012. Using structural and semantic information to support software refactoring. In Proceedings of the 34th International Conference on Software Engineering (ICSE’12). IEEE Computer Society, 1479--1482.

Digital Library

[34]

Gabriele Bavota, Bernardino De Carluccio, Andrea De Lucia, Massimiliano Di Penta, Rocco Oliveto, and Orazio Strollo. 2012. When does a refactoring induce bugs? an empirical study. In Proceedings of the IEEE International Working Conference on Source Code Analysis and Manipulation. 104--113.

Digital Library

[35]

Gabriele Bavota, Andrea De Lucia, Andrian Marcus, and Rocco Oliveto. 2013. Automating extract class refactoring: An improved method and its evaluation. Empirical Software Engineering 19, 6 (2013), 1--48.

[36]

Gabriele Bavota, Andrea De Lucia, Andrian Marcus, and Rocco Oliveto. 2014. Recommending refactoring operations in large software systems. In Recommendation Systems in Software Engineering. Springer, Berlin, 387--419.

[37]

Gabriele Bavota, Bogdan Dit, Rocco Oliveto, Massimiliano Di Penta, Denys Poshyvanyk, and Andrea De Lucia. 2013. An empirical study on the developers’ perception of software coupling. In Proceedings of the 35th International Conference on Software Engineering (ICSE’13). IEEE Computer Society, 692--701.

[38]

Gabriele Bavota, Andrea De Lucia, Andrian Marcus, and Rocco Oliveto. 2013. Using structural and semantic measures to improve software modularization. Empir. Softw. Eng. 18, 5 (2013), 901--932.

[39]

Gabriele Bavota, Andrea De Lucia, Massimiliano Di Penta, Rocco Oliveto, and Fabio Palomba. 2015. An experimental investigation on the innate relationship between quality and refactoring. J. Syst. Softw. 107 (2015), 1--14.

Digital Library

[40]

William J. Brown, Raphael C. Malveau, William H. Brown, Hays W. McCormick III, and Thomas J. Mowbray. 1998. Anti Patterns: Refactoring Software, Architectures, and Projects in Crisis (1st ed.). John Wiley 8 Sons.

Digital Library

[41]

Raymond P. L. Buse and Westley Weimer. 2010. Learning a metric for code readability. IEEE Trans. Softw. Eng. 36, 4 (2010), 546--558.

Digital Library

[42]

Gerardo Canfora, Luigi Cerulo, Marta Cimitile, and Massimiliano Di Penta. 2014. How changes affect software entropy: An empirical study. Emp. Softw. Eng. 19, 1 (2014), 1--38.

Digital Library

[43]

Diego Cedrim, Alessandro Garcia, Melina Mongiovi, Rohit Gheyi, Leonardo Sousa, Rafael de Mello, Baldoino Fonseca, Márcio Ribeiro, and Alexander Chávez. 2017. Understanding the impact of refactoring on smells: A longitudinal study of 23 software projects. In Proceedings of the 2017 11th Joint Meeting on Foundations of Software Engineering (ESEC/FSE’17). 465--475.

Digital Library

[44]

Alexander Chávez, Isabella Ferreira, Eduardo Fernandes, Diego Cedrim, and Alessandro Garcia. 2017. How does refactoring affect internal quality attributes?: A multi-project study. In Proceedings of the 31st Brazilian Symposium on Software Engineering (SBES’17). 74--83.

Digital Library

[45]

Chien-Tsun Chen, Yu Chin Cheng, Chin-Yun Hsieh, and I-Lang Wu. 2009. Exception handling refactorings: Directed by goals and driven by bug fixing. J. Syst. Softw. 82, 2 (2009), 333--345.

Digital Library

[46]

Shyam R. Chidamber and Chris F. Kemerer. 1994. A metrics suite for object oriented design. IEEE Trans. Softw. Eng. 20, 6 (June 1994), 476--493.

Digital Library

[47]

Cesar Couto, João Eduardo Montandon, Christofer Silva, and Marco Tulio Valente. 2011. Static correspondence and correlation between field defects and warnings reported by a bug finding tool. Softw. Qual. J. 21, 2 (2011), 241--257.

Digital Library

[48]

Florian Deissenbock and Markus Pizka. 2005. Concise and consistent naming. In Proceedings of the 13th International Workshop on Program Comprehension (IWPC’05). 97–106.

Digital Library

[49]

Danny Dig. 2011. A refactoring approach to parallelism. IEEE Softw. 28, 1 (2011), 17--22.

Digital Library

[50]

Paul Duvall, Stephen M. Matyas, and Andrew Glover. 2007. Continuous Integration: Improving Software Quality and Reducing Risk. Addison-Wesley Professional.

Digital Library

[51]

Sarah Fakhoury, Yuzhan Ma, Venera Arnaoudova, and Olusola O. Adesope. 2018. The effect of poor source code lexicon and readability on developers’ cognitive load. In Proceedings of the 26th Conference on Program Comprehension (ICPC’18). 286--296.

[52]

Michael Fischer, Martin Pinzger, and Harald C. Gall. 2003. Populating a release history database from version control and bug tracking systems. In Proceedings of the 19th International Conference on Software Maintenance (ICSM’03). 23.

[53]

Marios Fokaefs, Nikolaos Tsantalis, Eleni Stroulia, and Alexander Chatzigeorgiou. 2011. JDeodorant: Identification and application of extract class refactorings. In Proceedings of the 33rd International Conference on Software Engineering (ICSE’11). ACM, 1037--1039.

Digital Library

[54]

Martin Fowler. 1999. Refactoring: Improving the Design of Existing Code. Addison-Wesley, Boston, MA.

Digital Library

[55]

M. Fowler, K. Beck, J. Brant, W. Opdyke, and D. Roberts. 1999. Refactoring: Improving the Design of Existing Code. Addison-Wesley.

Digital Library

[56]

Mathew Hall, Neil Walkinshaw, and Phil McMinn. 2012. Supervised software modularisation. In Proceedings of the 28th IEEE International Conference on Software Maintenance (ICSM’12). 472--481.

Digital Library

[57]

Frank E. Harrell Jr, with contributions from Charles Dupont, et al. 2017. Hmisc: Harrell Miscellaneous. R package version 4.0-3. Retrieved from https://CRAN.R-project.org/package=Hmisc.

[58]

Brian Henderson-Sellers, Larry L. Constantine, and Ian M. Graham. 1996. Coupling and cohesion (towards a valid metrics suite for object-oriented analysis and design). Obj. Orient. Syst. 3 (1996), 143--158.

[59]

David Kawrykow and Martin P. Robillard. 2009. Improving API usage through automatic detection of redundant code. In Proceedings of the 2009 IEEE/ACM International Conference on Automated Software Engineering (ASE’09). 111--122.

[60]

Miryung Kim, Thomas Zimmermann, and Nachiappan Nagappan. 2012. A field study of refactoring challenges and benefits. In Proceedings of the 20th International Symposium on Foundations of Software Engineering.

Digital Library

[61]

Miryung Kim, T. Zimmermann, and N. Nagappan. 2014. An empirical study of refactoring challenges and benefits at microsoft. IEEE Trans. Softw. Eng. 40, 7 (July 2014), 633--649.

Digital Library

[62]

Sunghun Kim and Michael D. Ernst. 2007. Which warnings should I fix first? In Proceedings of the Joint Meeting of the European Software Engineering Conference and the ACM SIGSOFT International Symposium on Foundations of Software Engineering (ESEC/FSE’07). 45--54.

[63]

Sunghun Kim, Thomas Zimmermann, E. James Whitehead Jr., and Andreas Zeller. 2007. Predicting faults from cached history. In Proceedings of the 29th International Conference on Software Engineering (ICSE’07). 489--498.

[64]

Giri P. Krishnan and Nikolaos Tsantalis. 2014. Unification and refactoring of clones. In Proceedings of the IEEE Conference on Software Maintenance, Reengineering and Reverse Engineering. 104--113.

[65]

A. Kuhn, S. Ducasse, and T. Gîrba. 2007. Semantic clustering: Identifying topics in source code. Inf. Softw. Technol. 49, 3 (2007), 230--243.

Digital Library

[66]

D. Lawrie and D. Binkley. 2011. Expanding identifiers to normalize source code vocabulary. In Proceedings of the 2011 27th IEEE International Conference on Software Maintenance (ICSM’11). 113--122.

[67]

Dawn Lawrie, Henry Feild, and David Binkley. 2006. Syntactic identifier conciseness and consistency. In Proceedings of the Source Code Analysis and Manipulation Working Conference (SCAM’06). 139--148.

Digital Library

[68]

Dawn Lawrie, Christopher Morrell, Henry Feild, and David Binkley. 2006. What’s in a name? a study of identifiers. In Proceedings of the International Conference on Program Comprehension (ICPC’06).

Digital Library

[69]

Dawn Lawrie, Christopher Morrell, Henry Feild, and David Binkley. 2007. Effective identifier names for comprehension and memory. Innov. Syst. Softw. Eng. 3, 4 (2007), 303--318.

[70]

António Menezes Leitão. 2004. Detection of redundant code using R2D2. Softw. Qual. J. 12, 4 (1 December 2004), 361--382.

Digital Library

[71]

Bin Lin, Simone Scalabrino, Andrea Mocci, Rocco Oliveto, Gabriele Bavota, and Michele Lanza. 2017. Investigating the use of code analysis and nlp to promote a consistent usage of identifiers. In Proceedings of the 2017 IEEE 17th International Working Conference on Source Code Analysis and Manipulation (SCAM’17). IEEE, 81--90.

[72]

Mehran Mahmoudi, Sarah Nadi, and Nikolaos Tsantalis. 2019. Are refactorings to blame? An empirical study of refactorings in merge conflicts. In Proceedings of the 26th IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER19). 151--162.

[73]

Onaiza Maqbool and Haroon A. Babri. 2007. Hierarchical clustering for software architecture recovery. IEEE Trans. Softw. Eng. 33, 11 (2007), 759--780.

Digital Library

[74]

A. Marcus and D. Poshyvanyk. 2005. The conceptual cohesion of classes. In Proceedings of the 21st IEEE International Conference on Software Maintenance (ICSM’05). IEEE, 133--142.

[75]

Andrian Marcus, Denys Poshyvanyk, and Rudolf Ferenc. 2008. Using the conceptual cohesion of classes for fault prediction in object-oriented systems. IEEE Trans. Softw. Eng. 34, 2 (2008), 287--300.

Digital Library

[76]

John Micco. 2016. Flaky tests at google and how we mitigate them. Retrieved from https://testing.googleblog.com/2016/05/flaky-tests-at-google-and-how-we.html.

[77]

Naouel Moha, Yann-Gaël Guéhéneuc, Laurence Duchien, and Anne-Françoise Le Meur. 2010. DECOR: A method for the specification and detection of code and design smells. IEEE Trans. Softw. Eng. 36, 1 (2010), 20--36.

Digital Library

[78]

Raimund Moser, Pekka Abrahamsson, Witold Pedrycz, Alberto Sillitti, and Giancarlo Succi. 2007. A case study on the impact of refactoring on quality and productivity in an Agile team. In Balancing Agility and Formalism in Software Engineering, Second IFIP TC 2 Central and East European Conference on Software Engineering Techniques (CEE-SET'07), Poznan, Poland, October 10-12, 2007, Revised Selected Papers. 252--266.

[79]

Raimund Moser, Witold Pedrycz, and Giancarlo Succi. 2008. A comparative analysis of the efficiency of change metrics and static code attributes for defect prediction. In Proceedings of the 30th International Conference on Software Engineering (ICSE’08). 181--190.

Digital Library

[80]

Emerson Murphy-Hill, Chris Parnin, and Andreaw P. Black. 2011. How we refactor, and how we know it. Trans. Softw. Eng. 38, 1 (2011), 5--18.

Digital Library

[81]

Matheus Paixão, Mark Harman, Yuanyuan Zhang, and Yijun Yu. 2018. An empirical study of cohesion and coupling: Balancing optimization and disruption. IEEE Trans. Evol. Comput. 22, 3 (2018), 394--414.

[82]

Fabio Palomba, Gabriele Bavota, Massimiliano Di Penta, Fausto Fasano, Rocco Oliveto, and Andrea De Lucia. 2018. On the diffuseness and the impact on maintainability of code smells: A large scale empirical investigation. Emp. Softw. Eng. 23, 3 (2018), 1188--1221.

Digital Library

[83]

Fabio Palomba, Andrea De Lucia, Gabriele Bavota, and Rocco Oliveto. 2015. Anti-pattern detection: Methods, challenges, and open issues. Adv. Comput. 95 (2015), 201--238.

[84]

Jevgenija Pantiuchina, Gabriele Bavota, Michele Tufano, and Denys Poshyvanyk. 2018. Towards just-in-time refactoring recommenders. In Proceedings of the 26th Conference on Program Comprehension (ICPC’18). 312--315.

Digital Library

[85]

Anthony Peruma, Mohamed Wiem Mkaouer, Michael J. Decker, and Christian D. Newman. 2018. An empirical investigation of how and why developers rename identifiers. In Proceedings of the 2nd International Workshop on Refactoring (IWoR’18). 26--33.

[86]

Kata Praditwong, Mark Harman, and Xin Yao. 2011. Software module clustering as a multi-objective search problem. IEEE Trans. Softw. Eng. 37, 2 (2011), 264--282.

Digital Library

[87]

Baishakhi Ray, Daryl Posnett, Vladimir Filkov, and Premkumar T. Devanbu. 2014. A large scale study of programming languages and code quality in github. In Proceedings of the 22nd ACM SIGSOFT International Symposium on Foundations of Software Engineering. 155--165.

[88]

B. Rosner. 2011. Fundamentals of Biostatistics (7th ed.). Brooks/Cole, Boston, MA.

[89]

Chanchal K. Roy. [n.d.]. Large scale clone detection, analysis, and benchmarking: An evolutionary perspective. In Proceedings of the 12th IEEE International Workshop on Software Clones (IWSC’18).

[90]

Simone Scalabrino, Mario Linares-Vásquez, Rocco Oliveto, and Denys Poshyvanyk. 2018. A comprehensive model for code readability. J. Softw.: Evol. Process 30, 6, e1958.

Digital Library

[91]

Danilo Silva, Nikolaos Tsantalis, and Marco Tulio Valente. 2016. Why we refactor? confessions of GitHub contributors. In Proceedings of the 24th ACM SIGSOFT International Symposium on Foundations of Software Engineering (FSE’16). 858--870.

Digital Library

[92]

Jaime Spacco, David Hovemeyer, and William Pugh. 2006. Tracking defect warnings across versions. In Proceedings of the 2006 International Workshop on Mining Software Repositories. ACM, 133--136.

Digital Library

[93]

Davide Spadini, Fabio Palomba, Tobias Baum, Stefan Hanenberg, Magiel Bruntink, and Alberto Bacchelli. 2019. Test-driven code review: An empirical study. In Proceedings of the 41st International Conference on Software Engineering (ICSE’19). 1061--1072.

Digital Library

[94]

Donna Spencer. 2009. Card Sorting: Designing Usable Categories. Rosenfeld Media.

[95]

Konstantinos Stroggylos and Diomidis Spinellis. 2007. Refactoring–does it improve software quality? In Proceedings of the 5th International Workshop on Software Quality (WoSQ’07). IEEE Computer Society, Los Alamitos, CA. http://dx.doi.org/10.1109/WOSQ.2007.11

Digital Library

[96]

Gábor Szoke, Gábor Antal, Csaba Nagy, Rudolf Ferenc, and Tibor Gyimóthy. 2014. Bulk fixing coding issues and its effects on software quality: Is it worth refactoring? In Proceedings of the IEEE 14th International Working Conference on Source Code Analysis and Manipulation (SCAM’14). IEEE, 95--104.

Digital Library

[97]

Armstrong Takang, Penny Grubb, and Robert Macredie. 1996. The effects of comments and identifier names on program comprehensibility: An experiential study. J. Program. Lang. 4, 3 (1996), 143--167.

[98]

Nikolaos Tsantalis and Alexander Chatzigeorgiou. 2009. Identification of move method refactoring opportunities. IEEE Trans. Softw. Eng. 35, 3 (2009), 347--367.

Digital Library

[99]

Nikolaos Tsantalis, Matin Mansouri, Laleh M. Eshkevari, Davood Mazinanian, and Danny Dig. 2018. Accurate and efficient refactoring detection in commit history. In Proceedings of the 40th International Conference on Software Engineering (ICSE’18). 483--494.

Digital Library

[100]

Nikolaos Tsantalis, Davood Mazinanian, and Shahriar Rostami. 2017. Clone refactoring with lambda expressions. In Proceedings of the 39th International Conference on Software Engineering (ICSE’17). 60--70.

Digital Library

[101]

Michele Tufano, Fabio Palomba, Gabriele Bavota, Rocco Oliveto, Massimiliano Di Penta, Andrea De Lucia, and Denys Poshyvanyk. 2017. When and why your code starts to smell bad (and whether the smells go away). IEEE Trans. Softw. Eng. 43, 11 (2017), 1063--1088.

Digital Library

[102]

Michele Tufano, Jevgenija Pantiuchina, Cody Watson, Gabriele Bavota, and Denys Poshyvanyk. 2019. On learning meaningful code changes via neural machine translation. In Proceedings of the 41st International Conference on Software Engineering (ICSE’19). 25--36.

Digital Library

[103]

Arie Van Deursen, Leon Moonen, Alex Van Den Bergh, and Gerard Kok. 2001. Refactoring test code. In Proceedings of the 2nd International Conference on Extreme Programming and Flexible Processes in Software Engineering (XP’01). 92--95.

[104]

Carmine Vassallo, Giovanni Grano, Fabio Palomba, Harald Gall, and Alberto Bacchelli. 2019. A large-scale empirical exploration on refactoring activities in open source software projects. Sci’ Comput’ Program’ 180, 1 (2019), 1--15.

[105]

Yi Wang. 2009. What motivate software engineers to refactor source code? evidences from professional developers. In Proceedings of the IEEE International Conference on Software Maintenance (ICSM’09). 413 –416.

[106]

Ying Zhang, Gang Huang, Xuanzhe Liu, Wei Zhang, Hong Mei, and Shunxiang Yang. 2012. Refactoring android java code for on-demand computation offloading. In Proceedings of the ACM International Conference on Object Oriented Programming Systems Languages and Applications (OOPSLA’12). 233--248.

Digital Library

Cited By

Coelho FTsantalis NMassoni TAlves E(2025)A qualitative study on refactorings induced by code reviewEmpirical Software Engineering10.1007/s10664-024-10560-730:1Online publication date: 1-Feb-2025
https://dl.acm.org/doi/10.1007/s10664-024-10560-7
Aman HAmasaki SYokogawa TKawahara M(2024)A Quantitative Investigation of Trends in Confusing Variable Pairs Through Commits: Do Confusing Variable Pairs Survive?Proceedings of the 28th International Conference on Evaluation and Assessment in Software Engineering10.1145/3661167.3661228(90-99)Online publication date: 18-Jun-2024
https://dl.acm.org/doi/10.1145/3661167.3661228
Shahoor AYi JKim DChristakis MPradel M(2024)Preserving Reactiveness: Understanding and Improving the Debugging Practice of Blocking-Call BugsProceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis10.1145/3650212.3680319(768-780)Online publication date: 11-Sep-2024
https://dl.acm.org/doi/10.1145/3650212.3680319
Show More Cited By

Index Terms

Why Developers Refactor Source Code: A Mining-based Study
1. Software and its engineering
  1. Software creation and management
    1. Software post-development issues
      1. Maintaining software

Recommendations

Why we refactor? confessions of GitHub contributors
FSE 2016: Proceedings of the 2016 24th ACM SIGSOFT International Symposium on Foundations of Software Engineering

Refactoring is a widespread practice that helps developers to improve the maintainability and readability of their code. However, there is a limited number of studies empirically investigating the actual motivations behind specific refactoring ...
Using developers' feedback to improve code smell detection
SAC '15: Proceedings of the 30th Annual ACM Symposium on Applied Computing

Several studies are focused on the study of code smells and many detection techniques have been proposed. In this scenario, the use of rules involving software-metrics has been widely used in refactoring tools as a mechanism to detect code smells ...
How Do Developers Refactor Code to Improve Code Reusability?
Reuse in Emerging Software Engineering Practices
Abstract
Refactoring is the de-facto practice to optimize software health. While there has been several studies proposing refactoring strategies to optimize software design through applying design patterns and removing design defects, little is known about ...

Comments

Please enable JavaScript to view thecomments powered by Disqus.

Information & Contributors

Information

Published In

cover image ACM Transactions on Software Engineering and Methodology

ACM Transactions on Software Engineering and Methodology Volume 29, Issue 4

Continuous Special Section: AI and SE

October 2020

307 pages

ISSN:1049-331X

EISSN:1557-7392

DOI:10.1145/3409663

Editor:
Mauro Pezzè
Università della Svizzera italiana and Università di Milano-Bicocca, Switzerland

Issue’s Table of Contents

Copyright © 2020 ACM.

Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. Copyrights for components of this work owned by others than ACM must be honored. Abstracting with credit is permitted. To copy otherwise, or republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. Request permissions from [email protected]

Publisher

Association for Computing Machinery

New York, NY, United States

Publication History

Published: 26 September 2020

Accepted: 01 June 2020

Revised: 01 May 2020

Received: 01 December 2019

Published in TOSEM Volume 29, Issue 4

Permissions

Request permissions for this article.

Request Permissions

Check for updates

Author Tags

Qualifiers

Research-article
Research
Refereed

Funding Sources

SNF Project JITRA

Contributors

Other Metrics

View Article Metrics

Bibliometrics & Citations

Bibliometrics

Article Metrics

38
Total Citations
View Citations
823
Total Downloads

Downloads (Last 12 months)199
Downloads (Last 6 weeks)15

Reflects downloads up to 12 Dec 2024

Other Metrics

View Author Metrics

Citations

Cited By

Coelho FTsantalis NMassoni TAlves E(2025)A qualitative study on refactorings induced by code reviewEmpirical Software Engineering10.1007/s10664-024-10560-730:1Online publication date: 1-Feb-2025
https://dl.acm.org/doi/10.1007/s10664-024-10560-7
Aman HAmasaki SYokogawa TKawahara M(2024)A Quantitative Investigation of Trends in Confusing Variable Pairs Through Commits: Do Confusing Variable Pairs Survive?Proceedings of the 28th International Conference on Evaluation and Assessment in Software Engineering10.1145/3661167.3661228(90-99)Online publication date: 18-Jun-2024
https://dl.acm.org/doi/10.1145/3661167.3661228
Shahoor AYi JKim DChristakis MPradel M(2024)Preserving Reactiveness: Understanding and Improving the Debugging Practice of Blocking-Call BugsProceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis10.1145/3650212.3680319(768-780)Online publication date: 11-Sep-2024
https://dl.acm.org/doi/10.1145/3650212.3680319
Swain VPanigrahi RSahu KPadhy N(2024)Revealing MOVE METHOD: Machine Learning-driven Real-time Refactoring Identification for Enhanced Software Quality2024 International Conference on Emerging Systems and Intelligent Computing (ESIC)10.1109/ESIC60604.2024.10481609(572-578)Online publication date: 9-Feb-2024
https://doi.org/10.1109/ESIC60604.2024.10481609
Prokić SLuburić NSlivka JKovačević A(2024)Prescriptive procedure for manual code smell annotationScience of Computer Programming10.1016/j.scico.2024.103168238:COnline publication date: 1-Dec-2024
https://dl.acm.org/doi/10.1016/j.scico.2024.103168
AlOmar E(2024)Deciphering refactoring branch dynamics: An empirical study on QtInformation and Software Technology10.1016/j.infsof.2024.107596(107596)Online publication date: Oct-2024
https://doi.org/10.1016/j.infsof.2024.107596
Venigalla AChimalakonda S(2024)An exploratory study of software artifacts on GitHub from the lens of documentationInformation and Software Technology10.1016/j.infsof.2024.107425(107425)Online publication date: Feb-2024
https://doi.org/10.1016/j.infsof.2024.107425
DePalma KMiminoshvili IHenselder CMoss KAlOmar E(2024)Exploring ChatGPT’s code refactoring capabilities: An empirical studyExpert Systems with Applications10.1016/j.eswa.2024.123602249(123602)Online publication date: Sep-2024
https://doi.org/10.1016/j.eswa.2024.123602
Martins LGhaleb TCosta HMachado I(2024)A comprehensive catalog of refactoring strategies to handle test smells in Java-based systemsSoftware Quality Journal10.1007/s11219-024-09663-732:2(641-679)Online publication date: 1-Jun-2024
https://dl.acm.org/doi/10.1007/s11219-024-09663-7
Prokić SLuburić NSlivka JKovačević A(2023)Identification of Code Properties that Support Code Smell Analysis2023 46th MIPRO ICT and Electronics Convention (MIPRO)10.23919/MIPRO57284.2023.10159875(1664-1669)Online publication date: 22-May-2023
https://doi.org/10.23919/MIPRO57284.2023.10159875
Show More Cited By

View Options

Login options

Check if you have access through your login credentials or your institution to get full access on this article.

Full Access

Get this Article

View options

PDF

View or Download as a PDF file.

eReader

View online with eReader.

HTML Format

View this article in HTML Format.

Media

Figures

Other

Tables

View Issue’s Table of Contents