@article {SAN17, title = {Empirical Study on Refactoring Large-scale Industrial Systems and Its Effects on Maintainability}, journal = {Journal of Systems and Software}, volume = {129}, number = {C}, year = {2017}, month = {jul}, pages = {107{\textendash}126}, abstract = {We examine hundreds of manual refactoring commits from large-scale industrial systems.We study the effects of these commits on source code using a maintainability model.Developers preferred to fix concrete coding issues rather than fix code smells.A single refactoring had only a small impact (sometimes even negative effect).Whole refactoring process has significant beneficial effect on the maintainability. Software evolves continuously, it gets modified, enhanced, and new requirements always arise. If we do not spend time occasionally on improving our source code, its maintainability will inevitably decrease. The literature tells us that we can improve the maintainability of a software system by regularly refactoring it. But does refactoring really increase software maintainability? Can it happen that refactoring decreases the maintainability? Empirical studies show contradicting answers to these questions and there have been only a few studies which were performed in a large-scale, industrial context. In our paper, we assess these questions in an in vivo context, where we analyzed the source code and measured the maintainability of 6 large-scale, proprietary software systems in their manual refactoring phase. We analyzed 2.5 million lines of code and studied the effects on maintainability of 315 refactoring commits which fixed 1273 coding issues. We found that single refactorings only make a very little difference (sometimes even decrease maintainability), but a whole refactoring period, in general, can significantly increase maintainability, which can result not only in the local, but also in the global improvement of the code.}, keywords = {Antipatterns, coding issues, ISO/IEC 25010, maintainability, refactoring, select:quality, software quality}, issn = {0164-1212}, doi = {10.1016/j.jss.2016.08.071}, url = {http://www.sciencedirect.com/science/article/pii/S0164121216301558?via\%3Dihub}, author = {Sz{\H o}ke, G{\'a}bor and Antal, G{\'a}bor and Csaba Nagy and Rudolf Ferenc and Tibor Gyim{\'o}thy} } @conference {SNF16, title = {Designing and Developing Automated Refactoring Transformations: An Experience Report}, booktitle = {Proceedings of the 23rd IEEE International Conference on Software Analysis, Evolution, and Reengineering (SANER 2016)}, year = {2016}, month = {mar}, pages = {693{\textendash}697}, publisher = {IEEE Computer Society}, organization = {IEEE Computer Society}, address = {Suita, Osaka, Japan}, abstract = {There are several challenges which should be kept in mind during the design and development phases of a refactoring tool, and one is that developers have several expectations that are quite hard to satisfy. In this report, we present our experiences of a two-year project where we attempted to create an automatic refactoring tool. In this project, we worked with five software development companies that wanted to improve the maintainability of their products. The project was designed to take into account the expectations of the developers of these companies and consisted of three main stages: a manual refactoring phase, a tool building phase, and an automatic refactoring phase. Throughout these stages we collected the opinions of the developers and faced several challenges on how to automate refactoring transformations, which we present and summarize.}, keywords = {Automated Refactoring, code smells, coding issues, software maintenance}, doi = {10.1109/SANER.2016.17}, url = {http://ieeexplore.ieee.org/document/7476700/}, author = {Sz{\H o}ke, G{\'a}bor and Csaba Nagy and Rudolf Ferenc and Tibor Gyim{\'o}thy} } @conference {SNH15, title = {Do Automatic Refactorings Improve Maintainability? An Industrial Case Study}, booktitle = {Proceedings of the 31st International Conference on Software Maintenance and Evolution (ICSME 2015)}, year = {2015}, pages = {429{\textendash}438}, publisher = {IEEE Computer Society}, organization = {IEEE Computer Society}, address = {Bremen, Germany}, abstract = {Refactoring is often treated as the main remedy against the unavoidable code erosion happening during software evolution. Studies show that refactoring is indeed an elemental part of the developers{\textquoteright} arsenal. However, empirical studies about the impact of refactorings on software maintainability still did not reach a consensus. Moreover, most of these empirical investigations are carried out on open-source projects where distinguishing refactoring operations from other development activities is a challenge in itself. We had a chance to work together with several software development companies in a project where they got extra budget to improve their source code by performing refactoring operations. Taking advantage of this controlled environment, we collected a large amount of data during a refactoring phase where the developers used a (semi)automatic refactoring tool. By measuring the maintainability of the involved subject systems before and after the refactorings, we got valuable insights into the effect of these refactorings on large-scale industrial projects. All but one company, who applied a special refactoring strategy, achieved a maintainability improvement at the end of the refactoring phase, but even that one company suffered from the negative impact of only one type of refactoring.}, keywords = {automatic refactoring, coding issues, ISO/IEC 25010, Software maintainability}, doi = {10.1109/ICSM.2015.7332494}, url = {http://ieeexplore.ieee.org/document/7332494/}, author = {Sz{\H o}ke, G{\'a}bor and Csaba Nagy and P Heged{\H u}s and Rudolf Ferenc and Tibor Gyim{\'o}thy} } @conference {SNF15, title = {{FaultBuster}: An Automatic Code Smell Refactoring Toolset}, booktitle = {Proceedings of the 15th International Working Conference on Source Code Analysis and Manipulation (SCAM 2015)}, year = {2015}, month = {sep}, pages = {253{\textendash}258}, publisher = {IEEE Computer Society}, organization = {IEEE Computer Society}, address = {Bremen, Germany}, abstract = {One solution to prevent the quality erosion of a software product is to maintain its quality by continuous refac-toring. However, refactoring is not always easy. Developers need to identify the piece of code that should be improved and decide how to rewrite it. Furthermore, refactoring can also be risky; that is, the modified code needs to be re-tested, so developers can see if they broke something. Many IDEs offer a range of refactorings to support so-called automatic refactoring, but tools which are really able to automatically refactor code smells are still under research. In this paper we introduce FaultBuster, a refactoring toolset which is able to support automatic refactoring: identifying the problematic code parts via static code analysis, running automatic algorithms to fix selected code smells, and executing integrated testing tools. In the heart of the toolset lies a refactoring framework to control the analysis and the execution of automatic algorithms. FaultBuster provides IDE plugins to interact with developers via popular IDEs (Eclipse, Netbeans and IntelliJ IDEA). All the tools were developed and tested in a 2-year project with 6 software development companies where thousands of code smells were identified and fixed in 5 systems having altogether over 5 million lines of code.}, keywords = {Antipatterns, automatic refactoring, code smells, coding issues, Columbus, SourceMeter}, doi = {10.1109/SCAM.2015.7335422}, url = {http://ieeexplore.ieee.org/document/7335422/}, author = {Sz{\H o}ke, G{\'a}bor and Csaba Nagy and F{\"u}l{\"o}p, Lajos Jen{\H o} and Rudolf Ferenc and Tibor Gyim{\'o}thy} } @article {USH15, title = {Performance Comparison of Query-based Techniques for Anti-pattern Detection}, journal = {Information and Software Technology}, volume = {65}, number = {C}, year = {2015}, month = {sep}, pages = {147{\textendash}165}, abstract = {Context Program queries play an important role in several software evolution tasks like program comprehension, impact analysis, or the automated identification of anti-patterns for complex refactoring operations. A central artifact of these tasks is the reverse engineered program model built up from the source code (usually an Abstract Semantic Graph, ASG), which is traditionally post-processed by dedicated, hand-coded queries. Objective Our paper investigates the costs and benefits of using the popular industrial Eclipse Modeling Framework (EMF) as an underlying representation of program models processed by four different general-purpose model query techniques based on native Java code, OCL evaluation and (incremental) graph pattern matching. Method We provide in-depth comparison of these techniques on the source code of 28 Java projects using anti-pattern queries taken from refactoring operations in different usage profiles. Results Our results show that general purpose model queries can outperform hand-coded queries by 2{\textendash}3 orders of magnitude, with the trade-off of an increased in memory consumption and model load time of up to an order of magnitude. Conclusion The measurement results of usage profiles can be used as guidelines for selecting the appropriate query technologies in concrete scenarios.}, keywords = {Anti-patterns, Columbus, EMF-IncQuery, OCL, Performance measurements, refactoring}, issn = {0950-5849}, doi = {10.1016/j.infsof.2015.01.003}, url = {http://www.sciencedirect.com/science/article/pii/S0950584915000051?via\%3Dihub}, author = {Ujhelyi, Zolt{\'a}n and Sz{\H o}ke, G{\'a}bor and Horv{\'a}th, {\'A}kos and Csisz{\'a}r, Norbert Istv{\'a}n and L{\'a}szl{\'o} Vid{\'a}cs and Varr{\'o}, D{\'a}niel and Rudolf Ferenc} } @conference {UHV14, title = {Anti-pattern Detection with Model Queries: A Comparison of Approaches}, booktitle = {Proceedings of the 2014 Software Evolution Week (Merger of the 18th IEEE European Conference on Software Maintenance and Reengineering \& 21st IEEE Working Conference on Reverse Engineering {\textendash} CSMR-WCRE 2014)}, year = {2014}, note = {Best paper of the conference}, pages = {293{\textendash}302}, publisher = {IEEE Computer Society}, organization = {IEEE Computer Society}, address = {Antwerp, Belgium}, abstract = {Program queries play an important role in several software evolution tasks like program comprehension, impact analysis, or the automated identification of anti-patterns for complex refactoring operations. A central artifact of these tasks is the reverse engineered program model built up from the source code (usually an Semantic Graph, ASG), which is traditionally post-processed by dedicated, hand-coded queries. Our paper investigates the use of the popular industrial Eclipse Modeling Framework (EMF) as an underlying representation of program models processed by three general-purpose model query techniques based on native Java code, local-search and incremental evaluation. We provide in-depth comparison of these techniques on the source code of 17 Java projects using queries taken from refactoring operations in different usage profiles. Our results show that general purpose model queries outperform hand-coded queries by 2-3 orders of magnitude, while there is a 5-10 times increase in memory consumption and model load time. In addition, measurement results of usage profiles can be used as guidelines for selecting the appropriate query technologies in concrete scenarios.}, keywords = {antipattern detection, program queries, query technologies, select:quality}, doi = {10.1109/CSMR-WCRE.2014.6747181}, url = {http://ieeexplore.ieee.org/document/6747181/}, author = {Ujhelyi, Zolt{\'a}n and Horv{\'a}th, {\'A}kos and Varr{\'o}, D{\'a}niel and Csisz{\'a}r, Norbert Istv{\'a}n and Sz{\H o}ke, G{\'a}bor and L{\'a}szl{\'o} Vid{\'a}cs and Rudolf Ferenc} } @conference {SAN14, title = {Bulk Fixing Coding Issues and Its Effects on Software Quality: Is It Worth Refactoring?}, booktitle = {Proceedings of the 14th IEEE International Working Conference on Source Code Analysis and Manipulation (SCAM 2014)}, year = {2014}, month = {sep}, pages = {95{\textendash}104}, publisher = {IEEE Computer Society}, organization = {IEEE Computer Society}, address = {Victoria, British Columbia, Canada}, abstract = {The quality of a software system is mostly defined by its source code. Software evolves continuously, it gets modified, enhanced, and new requirements always arise. If we do not spend time periodically on improving our source code, it becomes messy and its quality will decrease inevitably. Literature tells us that we can improve the quality of our software product by regularly refactoring it. But does refactoring really increase software quality? Can it happen that a refactoring decreases the quality? Is it possible to recognize the change in quality caused by a single refactoring operation? In our paper, we seek answers to these questions in a case study of refactoring large-scale proprietary software systems. We analyzed the source code of 5 systems, and measured the quality of several revisions for a period of time. We analyzed 2 million lines of code and identified nearly 200 refactoring commits which fixed over 500 coding issues. We found that one single refactoring only makes a small change (sometimes even decreases quality), but when we do them in blocks, we can significantly increase quality, which can result not only in the local, but also in the global improvement of the code.}, keywords = {Antipatterns, coding issues, ISO/IEC 25010, maintainability, software quality}, doi = {10.1109/SCAM.2014.18}, url = {http://ieeexplore.ieee.org/document/6975643/}, author = {Sz{\H o}ke, G{\'a}bor and Antal, G{\'a}bor and Csaba Nagy and Rudolf Ferenc and Tibor Gyim{\'o}thy} } @conference {SNF14, title = {A Case Study of Refactoring Large-Scale Industrial Systems to Efficiently Improve Source Code Quality}, booktitle = {Proceedings of the 14th International Conference on Computational Science and Its Applications (ICCSA 2014)}, series = {Lecture Notes in Computer Science (LNCS)}, volume = {8583}, year = {2014}, month = {jun}, pages = {524{\textendash}540}, publisher = {Springer-Verlag}, organization = {Springer-Verlag}, address = {Guimar{\~a}es, Portugal}, abstract = {Refactoring source code has many benefits (e.g. improving maintainability, robustness and source code quality), but it takes time away from other implementation tasks, resulting in developers neglecting refactoring steps during the development process. But what happens when they know that the quality of their source code needs to be improved and they can get the extra time and money to refactor the code? What will they do? What will they consider the most important for improving source code quality? What sort of issues will they address first or last and how will they solve them? In our paper, we look for answers to these questions in a case study of refactoring large-scale industrial systems where developers participated in a project to improve the quality of their software systems. We collected empirical data of over a thousand refactoring patches for 5 systems with over 5 million lines of code in total, and we found that developers really optimized the refactoring process to significantly improve the quality of these systems.}, keywords = {refactoring, Software engineering, software quality}, doi = {10.1007/978-3-319-09156-3_37}, url = {https://link.springer.com/chapter/10.1007\%2F978-3-319-09156-3_37}, author = {Sz{\H o}ke, G{\'a}bor and Csaba Nagy and Rudolf Ferenc and Tibor Gyim{\'o}thy} } @conference {MSF13, title = {A Semi-automatic Usability Evaluation Framework}, booktitle = {Proceedings of the 13th International Conference on Computational Science and Its Applications (ICCSA 2013)}, series = {Lecture Notes in Computer Science (LNCS)}, volume = {7973}, year = {2013}, month = {jun}, pages = {529{\textendash}542}, publisher = {Springer-Verlag}, organization = {Springer-Verlag}, address = {Ho Chi Minh City, Vietnam}, abstract = {Most of the software maintenance costs come from usability bugs reported after the release and deployment. A usability bug is really subjective, hence there is a large communication overhead between the end user and the developer. Moreover, the reputation of the software development company could be decreased as well. Therefore, proactively testing and maintaining software systems from a usability point of view is unambiguously beneficial. In this paper we propose a research prototype, the Usability Evaluation Framework. The development of the framework is driven by welldefined requirements. It is built upon a usability model, it calculates usability metrics, it integrates questionnaires and it also ensures several meaningful reports. We have successfully applied the framework to evaluate and to improve the usability of two industrial software systems.}, doi = {10.1007/978-3-642-39643-4_38}, url = {https://link.springer.com/chapter/10.1007\%2F978-3-642-39643-4_38}, author = {Muhi, Korn{\'e}l and Sz{\H o}ke, G{\'a}bor and F{\"u}l{\"o}p, Lajos Jen{\H o} and Rudolf Ferenc and Berger, {\'A}goston} }