@conference {SCAM:CG:COMPARE,
	title = {{Static JavaScript Call Graphs: a Comparative Study}},
	booktitle = {Proceedings of the 18th IEEE International Working Conference on Source Code Analysis and Manipulation},
	year = {2018},
	publisher = {IEEE},
	organization = {IEEE},
	author = {Antal, G{\'a}bor and Heged{\H u}s, P{\'e}ter and T{\'o}th, Zolt{\'a}n and Ferenc, Rudolf and Tibor Gyim{\'o}thy}
}
@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 {AHS16,
	title = {Transforming {C++11} Code to {C++03} to Support Legacy Compilation Environments},
	booktitle = {Proceedings of 16th IEEE International Working Conference on Source Code Analysis and Manipulation (SCAM{\textquoteright}16)},
	year = {2016},
	pages = {177-186},
	author = {Antal, G{\'a}bor and Havas, D{\'a}vid and Istv{\'a}n Siket and {\'A}rp{\'a}d Besz{\'e}des and Rudolf Ferenc and Mihalicza, J{\'o}zsef}
}
@conference {BAB15,
	title = {Identifying Wasted Effort in the Field via Developer Interaction Data},
	booktitle = {Proceedings of the 31th IEEE International Conference on Software Maintenance and Evolution (ICSME{\textquoteright}15), Industry Track},
	year = {2015},
	month = {sep},
	pages = {391-400},
	author = {Gerg{\H o} Balogh and Antal, G{\'a}bor and {\'A}rp{\'a}d Besz{\'e}des and L{\'a}szl{\'o} Vid{\'a}cs and Tibor Gyim{\'o}thy and V{\'e}gh, {\'A}d{\'a}m Zolt{\'a}n}
}
@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}
}
