@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}
}
@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}
}
@article {DJN14,
	title = {Designing and Implementing Control Flow Graph for {M}agic 4th Generation Language},
	journal = {Acta Cybernetica},
	volume = {21},
	number = {3},
	year = {2014},
	pages = {419{\textendash}437},
	abstract = {A good compiler which implements many optimizations during its compilation phases must be able to perform several static analysis techniques such as control flow or data flow analysis. Besides compilers, these techniques are common for static analyzers as well to retrieve information from source code, for example for code auditing, quality assurance or testing purposes. Implementing control flow analysis requires handling many special structures of the target language. In our paper we present our experiences in implementing control flow graph (CFG) construction for a special 4th generation language called Magic. While we were designing and implementing the CFG for this language, we identified differences compared to 3rd generation languages mostly because of the unique programming technique of Magic (e.g. data access, parallel task execution, events). Our work was motivated by our industrial partner who needed precise static analysis tools (e.g. for quality assurance or testing purposes) for this language. We believe that our experiences for Magic, as a representative of 4GLs, might be generalized for other languages too.},
	issn = {0324-721X},
	url = {http://publicatio.bibl.u-szeged.hu/8995/},
	author = {D{\'e}vai, Rich{\'a}rd and Judit J{\'a}sz and Csaba Nagy and Rudolf Ferenc}
}
@conference {DJN13,
	title = {Designing and Implementing Control Flow Graph for {M}agic 4th Generation Language},
	booktitle = {Proceedings of the 13th Symposium on Programming Languages and Software Tools (SPLST 2013)},
	year = {2013},
	month = {aug},
	pages = {200{\textendash}214},
	publisher = {University of Szeged},
	organization = {University of Szeged},
	address = {Szeged, Hungary},
	abstract = {A good compiler which implements many optimizations during its compilation phases must be able to perform several static analysis techniques such as control ow or data ow analysis. Besides compilers, these techniques are common for static analyzers to retrieve information from the code for example code auditing, quality assurance, or testing purposes. Implementing control ow analysis requires handling many special structures of the target language. In our paper we present our experiences in implementing control ow graph (CFG) construction for a special 4th generation language called Magic. During designing and implementing the CFG for this language we identied dierences compared to 3rd generation languages because the special programming technique of this language (e.g. data access, parallel task execution, events). Our work was motivated by our industrial partner who needed precise static analysis tools (e.g. for quality assurance or testing purposes) for this language. We believe that our experiences for Magic, as a representative of 4GLs might be generalized for other languages too.},
	author = {D{\'e}vai, Rich{\'a}rd and Judit J{\'a}sz and Csaba Nagy and Rudolf Ferenc}
}
@conference {FNF13,
	title = {A Methodology and Framework for Automatic Layout Independent {GUI} Testing of Applications Developed in {M}agic xpa},
	booktitle = {Proceedings of the 13th International Conference on Computational Science and Its Applications (ICCSA 2013)},
	series = {Lecture Notes in Computer Science (LNCS)},
	volume = {7972},
	year = {2013},
	pages = {513{\textendash}528},
	publisher = {Springer-Verlag},
	organization = {Springer-Verlag},
	address = {Ho Chi Minh City, Vietnam},
	abstract = {Testing an application via its Graphical User Interface (GUI) requires lots of manual work, even if some steps of GUI testing can be automated. Test automation tools are great help for testers, particularly for regression testing. However these tools still lack some important features and still require manual work to maintain the test cases. For instance, if the layout of a window is changed without affecting the main functionality of the application, all test cases testing the window must be re-recorded again. This hard maintenance work is one of the greatest problems with the regression tests of GUI applications. In our paper we propose an approach to use the GUI information stored in the source code during automatic testing processes to create layout independent test scripts. The idea was motivated by testing an application developed in a fourth generation language, Magic. In this language the layout of the GUI elements (e.g. position and size of controls) are stored in the code and can be gathered via static code analysis. We implemented the presented approach for Magic xpa in a tool called Magic Test Automation, which is used by our industrial partner who has developed applications in Magic for more than a decade.},
	doi = {10.1007/978-3-642-39643-4_37},
	url = {https://link.springer.com/chapter/10.1007\%2F978-3-642-39643-4_37},
	author = {Fritsi, D{\'a}niel and Csaba Nagy and Rudolf Ferenc and Tibor Gyim{\'o}thy}
}
@conference {16347,
	title = {A Methodology and Framework for Automatic Layout Independent {GUI} Testing of Applications Developed in Magic xpa},
	booktitle = {Computational Science and Its Applications {\textendash} ICCSA 2013},
	year = {2013},
	pages = {513{\textendash}528},
	publisher = {"Springer-Verlag"address},
	organization = {"Springer-Verlag"address},
	address = {Berlin; Heidelberg},
	author = {D. Fritsi and Csaba Nagy and Rudolf Ferenc and Tibor Gyim{\'o}thy},
	editor = {Beniamino Murgante and Sanjay Misra and Maurizio Carlini and Carmelo M Torre and Hong-Quang Nguyen and David Taniar and Bernady O Apduhan and Osvaldo Gervasi}
}
@conference {NNF13,
	title = {A Regression Test Selection Technique for {M}agic Systems},
	booktitle = {Proceedings of the 13th Symposium on Programming Languages and Software Tools (SPLST 2013)},
	year = {2013},
	month = {aug},
	pages = {76{\textendash}89},
	publisher = {University of Szeged},
	organization = {University of Szeged},
	address = {Szeged, Hungary},
	abstract = {Regression testing is an important step to make sure that after committing a change to our software we do not make unwanted changes to other, untouched features. For larger and faster evolving software, however, executing all the test cases of a regression test can easily become a tremendous process which takes too much time to thoroughly test each changes separately. In our paper, we present a method to support regression testing with impact analysis based test selection. As a result, we can show a limited set of test cases that must be re-executed after a change, to test the changed part of the code and its related code elements. Our technique is implemented for a special 4th generation language, the Magic xpa development environment. The technique was implemented in cooperation with our industrial partner, SZEGED Software Inc, who has been developing Magic applications for more than a decade.},
	author = {G{\'a}bor Nov{\'a}k and Csaba Nagy and Rudolf Ferenc}
}
@conference {16370,
	title = {Static Analysis of Data-Intensive Applications},
	year = {2013},
	publisher = {IEEE Computer Society},
	organization = {IEEE Computer Society},
	author = {Csaba Nagy}
}
@booklet {TR2013001,
	title = {Survey on Testing Embedded Systems},
	year = {2013},
	publisher = {University of Szeged, Department of Software Engineering \& University of Novi Sad, Faculty of Technical Sciences},
	type = {Technical Report},
	url = {http://cirene.sed.hu/sites/cirene.sed.hu/files/page_files/3.2-Survey-on-Testing-Embedded-Systems.pdf},
	author = {{\'A}rp{\'a}d Besz{\'e}des and Tam{\'a}s Gergely and Papp, Istv{\'a}n and Marinkovi{\'c}, Vladimir and Zlokolica, Vladimir and Gerg{\H o} Balogh and Bogn{\'a}r, Szabolcs and Kastelan, Ivan and Kova{\v c}evi{\'c}, Jelena and Muhi, Korn{\'e}l and Csaba Nagy and Popovi{\'c}, Miroslav and R{\'a}cz, R{\'o}bert and Istv{\'a}n Siket and Varga, P{\'e}ter}
}
@conference {Nagy2011SQ,
	title = {Complexity Measures in {4GL} Environment},
	booktitle = {Computational Science and Its Applications - ICCSA 2011, Lecture Notes in Computer Science},
	series = {Lecture Notes in Computer Science},
	volume = {6786},
	year = {2011},
	pages = {293-309},
	publisher = {Springer Berlin / Heidelberg},
	organization = {Springer Berlin / Heidelberg},
	author = {Csaba Nagy and L{\'a}szl{\'o} Vid{\'a}cs and Rudolf Ferenc and Tibor Gyim{\'o}thy and Kocsis, F. and I. Kov{\'a}cs}
}
@conference {FNF11,
	title = {A Layout Independent GUI Test Automation Tool for Applications Developed in Magic/uniPaaS},
	booktitle = {Proceedings of the 12th Symposium on Programming Languages and Software Tools},
	year = {2011},
	pages = {248-259},
	author = {D. Fritsi and Csaba Nagy and Rudolf Ferenc and Tibor Gyim{\'o}thy}
}
@conference {Nagy2011CSMR,
	title = {Solutions for Reverse Engineering 4GL Applications, Recovering the Design of a Logistical Wholesale System},
	booktitle = {Proceedings of CSMR 2011 (15th European Conference on Software Maintenance and Reengineering)},
	year = {2011},
	pages = {343-346},
	publisher = {IEEE Computer Society},
	organization = {IEEE Computer Society},
	doi = {10.1109/CSMR.2011.66},
	author = {Csaba Nagy and L{\'a}szl{\'o} Vid{\'a}cs and Rudolf Ferenc and Tibor Gyim{\'o}thy and Kocsis, F. and I. Kov{\'a}cs}
}
@conference {TNJ10,
	title = {{CIASYS} {\textendash} Change Impact Analysis at System Level},
	booktitle = {Proceedings of the 14th European Conference on Software Maintenance and Reengineering (CSMR{\textquoteright}10)},
	year = {2010},
	pages = {203-206},
	author = {T{\'o}th, G. and Csaba Nagy and Judit J{\'a}sz and {\'A}rp{\'a}d Besz{\'e}des and F{\"u}l{\"o}p, L.J.}
}
@conference {conf/icsm/NagyVFGKK10,
	title = {{MAGISTER}: Quality assurance of Magic applications for software developers and end users.},
	booktitle = {ICSM},
	year = {2010},
	pages = {1-6},
	publisher = {IEEE Computer Society},
	organization = {IEEE Computer Society},
	keywords = {dblp},
	isbn = {978-1-4244-8630-4},
	url = {http://dblp.uni-trier.de/db/conf/icsm/icsm2010.html$\#$NagyVFGKK10},
	author = {Csaba Nagy and L{\'a}szl{\'o} Vid{\'a}cs and Rudolf Ferenc and Tibor Gyim{\'o}thy and Kocsis, F. and I. Kov{\'a}cs}
}
@conference {NPG10,
	title = {Towards a Safe Method for Computing Dependencies in Database-Intensive Systems},
	booktitle = {Proceedings of the 14th European Conference on Software Maintenance and Reengineering (CSMR{\textquoteright}10)},
	year = {2010},
	month = {mar},
	pages = {166-175},
	author = {Csaba Nagy and J. P{\'a}ntos and Tam{\'a}s Gergely and {\'A}rp{\'a}d Besz{\'e}des}
}
@conference {Nagy09,
	title = {Extension of {GCC} with a fully manageable reverse engineering front end},
	booktitle = {Proceedings of the 7th international conference on applied informatics (ICAI 2007)},
	year = {2009},
	pages = {145-152},
	author = {Csaba Nagy}
}
@conference {NaSp09,
	title = {Static security analysis based on input-related software faults},
	booktitle = {Proceedings of the 13th European Conference on Software Maintenance and Reengineering (CSMR{\textquoteright}09)},
	year = {2009},
	pages = {37-46},
	author = {Csaba Nagy and M. Spiros}
}
@conference {NLB07,
	title = {Code factoring in {GCC} on different intermediate languages},
	booktitle = {Proceedings of the 10th Symposium on Programming Languages and Software Tools (SPLST{\textquoteright}07)},
	year = {2007},
	month = {jun},
	pages = {79-95},
	author = {Csaba Nagy and G. L{\'o}ki and {\'A}rp{\'a}d Besz{\'e}des and Tibor Gyim{\'o}thy}
}
