@conference {BaF14,
	title = {Recognizing Antipatterns and Analyzing Their Effects on Software Maintainability},
	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 = {337{\textendash}352},
	publisher = {Springer-Verlag},
	organization = {Springer-Verlag},
	address = {Guimar{\~a}es, Portugal},
	abstract = {Similarly to design patterns and their inherent extra information about the structure and design of a system, antipatterns - or bad code smells - can also greatly influence the quality of software. Although the belief that they negatively impact maintainability is widely accepted, there are still relatively few objective results that would support this theory. In this paper we show our approach of detecting antipatterns in source code by structural analysis and use the results to reveal connections among antipatterns, number of bugs, and maintainability. We studied 228 open-source Java based systems and extracted bug-related information for 34 of them from the PROMISE database. For estimating the maintainability, we used the ColumbusQM probabilistic quality model. We found that there is a statistically significant, 0.55 Spearman correlation between the number of bugs and the number of antipatterns. Moreover, there is an even stronger, -0.62 reverse Spearman correlation between the number of antipatterns and code maintainability. We also found that even these few implemented antipatterns could nearly match the machine learning based bug-predicting power of 50 class level source code metrics. Although the presented analysis is not conclusive by far, these first results suggest that antipatterns really do decrease code quality and can highlight spots that require closer attention.},
	keywords = {Antipatterns, Empirical validation, ISO/IEC 25010, OO design, Software maintainability, SQuaRE},
	doi = {10.1007/978-3-319-09156-3_25},
	url = {https://link.springer.com/chapter/10.1007\%2F978-3-319-09156-3_25},
	author = {D{\'e}nes B{\'a}n and Rudolf Ferenc}
}
@article {KHF14,
	title = {Runtime Exception Detection in {J}ava Programs Using Symbolic Execution},
	journal = {Acta Cybernetica},
	volume = {21},
	number = {3},
	year = {2014},
	pages = {331{\textendash}352},
	abstract = {Most of the runtime failures of a software system can be revealed during test execution only, which has a very high cost. In Java programs, runtime failures are manifested as unhandled runtime exceptions. In this paper we present an approach and tool for detecting runtime exceptions in Java programs without having to execute tests on the software. We use the symbolic execution technique to implement the approach. By executing the methods of the program symbolically we can determine those execution branches that throw exceptions. Our algorithm is able to generate concrete test inputs also that cause the program to fail in runtime. We used the Symbolic PathFinder extension of the Java PathFinder as the symbolic execution engine. Besides small example codes we evaluated our algorithm on three open source systems: jEdit, ArgoUML, and log4j. We found multiple errors in the log4j system that were also reported as real bugs in its bug tracking system.},
	keywords = {Java runtime exception, rule checking, symbolic execution},
	issn = {0324-721X},
	doi = {10.14232/actacyb.21.3.2014.4},
	url = {http://www.inf.u-szeged.hu/actacybernetica/edb/vol21n3/Kadar_2014_ActaCybernetica.xml},
	author = {K{\'a}d{\'a}r, Istv{\'a}n and P Heged{\H u}s and Rudolf Ferenc}
}
@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}
}
@article {16350,
	title = {A retrospective view of software maintenance and reengineering research {\textendash} a selection of papers from European Conference on Software Maintenance and Reengineering 2010},
	journal = {JOURNAL OF SOFTWARE MAINTENANCE AND EVOLUTION-RESEARCH AND PRACTICE},
	volume = {25},
	year = {2013},
	pages = {569{\textendash}574},
	issn = {1532-060X},
	author = {R. Capilla and J. C. Duenas and Rudolf Ferenc}
}
@conference {KHF13,
	title = {Runtime Exception Detection in {J}ava Programs Using Symbolic Execution},
	booktitle = {Proceedings of the 13th Symposium on Programming Languages and Software Tools (SPLST 2013)},
	year = {2013},
	month = {aug},
	pages = {215{\textendash}229},
	publisher = {University of Szeged},
	organization = {University of Szeged},
	address = {Szeged, Hungary},
	abstract = {Most of the runtime failures of a software system can be revealed during test execution only, which has a very high cost. In Java programs, runtime failures are manifested as unhandled runtime exceptions. In this paper we present an approach and tool for detecting runtime exceptions in Java programs without having to execute tests on the software. We use the symbolic execution technique to implement the approach. By executing the methods of the program symbolically we can determine those execution branches that throw exceptions. Our algorithm is able to generate concrete test inputs also that cause the program to fail in runtime. We used the Symbolic PathFinder extension of the Java PathFinder as the symbolic execution engine. Besides small example codes we evaluated our algorithm on three open source systems: jEdit, ArgoUML, and log4j. We found multiple errors in the log4j system that were also reported as real bugs in its bug tracking system.},
	keywords = {Java runtime exception, Java Virtual Machine, rule checking, symbolic execution},
	author = {K{\'a}d{\'a}r, Istv{\'a}n and P Heged{\H u}s and Rudolf Ferenc}
}
@conference {16368,
	title = {Runtime Exception Detection in Java Programs Using Symbolic Execution},
	booktitle = {Proceedings of the 13th Symposium on Programming Languages and Software Tools, SPLST{\textquoteright}13},
	year = {2013},
	pages = {215{\textendash}229},
	publisher = {University of Szeged},
	organization = {University of Szeged},
	address = {Szeged},
	author = {Istv{\'a}n K{\'a}d{\'a}r and P Heged{\H u}s and Rudolf Ferenc},
	editor = {{\'A}kos Kiss}
}
@article {SMR:SMR548,
	title = {A retrospective view of software maintenance and reengineering research a selection of papers from European Conference on Software Maintenance and Reengineering 2010},
	journal = {Journal of Software Maintenance and Evolution: Research and Practice},
	year = {2011},
	publisher = {John Wiley \& Sons, Ltd},
	keywords = {software evolution, software maintenance, technical debt},
	issn = {1532-0618},
	doi = {10.1002/smr.548},
	url = {http://dx.doi.org/10.1002/smr.548},
	author = {R. Capilla and J. C. Duenas and Rudolf Ferenc}
}
@article {FGM02,
	title = {{Recognizing Design Patterns in C++ programs with the integration of Columbus and Maisa}},
	journal = {Acta Cybernetica},
	volume = {15},
	year = {2002},
	pages = {669-682},
	author = {Rudolf Ferenc and J. Gustafsson and L. M{\"u}ller and J. Paakki}
}
@conference {FGM01,
	title = {{Recognizing Design Patterns in C++ programs with the integration of Columbus and Maisa}},
	booktitle = {Proceedings of the 7th Symposium on Programming Languages and Software Tools (SPLST 2001)},
	year = {2001},
	month = {jun},
	pages = {58-70},
	publisher = {University of Szeged},
	organization = {University of Szeged},
	author = {Rudolf Ferenc and J. Gustafsson and L. M{\"u}ller and J. Paakki}
}
