@proceedings {16563,
	title = {BugsJS: a Benchmark of JavaScript Bugs},
	year = {2019},
	pages = {90-101},
	address = {Xi{\textquoteright}an, China},
	abstract = {JavaScript is a popular programming language that is also error-prone due to its asynchronous, dynamic, and loosely-typed nature. In recent years, numerous techniques have been proposed for analyzing and testing JavaScript applications. However, our survey of the literature in this area revealed that the proposed techniques are often evaluated on different datasets of programs and bugs. The lack of a commonly used benchmark limits the ability to perform fair and unbiased comparisons for assessing the efficacy of new techniques. To fill this gap, we propose BugsJS, a benchmark of 453 real, manually validated JavaScript bugs from 10 popular JavaScript server-side programs, comprising 444k LOC in total. Each bug is accompanied by its bug report, the test cases that detect it, as well as the patch that fixes it. BugsJS features a rich interface for accessing the faulty and fixed versions of the programs and executing the corresponding test cases, which facilitates conducting highly-reproducible empirical studies and comparisons of JavaScript analysis and testing tools.},
	keywords = {benchmark, Bug database, BugsJS, JavaScript, literature survey, real bugs, reproducibility, select:quality},
	doi = {10.1109/ICST.2019.00019},
	url = {https://ieeexplore.ieee.org/document/8730197/authors$\#$authors},
	author = {P{\'e}ter Gyimesi and B{\'e}la Vancsics and Andrea Stocco and Davood Mazinanian and {\'A}rp{\'a}d Besz{\'e}des and Rudolf Ferenc and Ali Mesbah}
}
@proceedings {16554,
	title = {Challenging Machine Learning Algorithms in Predicting Vulnerable JavaScript Functions},
	year = {2019},
	pages = {8-14},
	publisher = {IEEE Press},
	keywords = {select:itsec},
	author = {Rudolf Ferenc and P{\'e}ter Heged{\H u}s and P{\'e}ter Gyimesi and G{\'a}bor Antal and D{\'e}nes B{\'a}n and Tibor Gyimothy}
}
@article {HKF17,
	title = {Empirical Evaluation of Software Maintainability Based on a Manually Validated Refactoring Dataset},
	journal = {Information and Software Technology},
	volume = {95},
	year = {2018},
	note = {Accepted, to appear.},
	month = {nov},
	chapter = {313},
	abstract = {Context: Refactoring is a technique for improving the internal structure of software systems. It has a solid theoretical background while being used in development practice also. However, we lack empirical research results on the real effect of code refactoring and its application. Objective: This paper presents a manually validated subset of a previously published dataset containing the refactorings extracted by the RefFinder tool, code metrics, and maintainability of 7 open-source systems. We found that RefFinder had around 27\% overall average precision on the subject systems, thus our manually validated subset has substantial added value. Using the dataset, we studied several aspects of the refactored and non-refactored source code elements (classes and methods), like the differences in their maintainability and source code metrics. Method: We divided the source code elements into a group containing the refactored elements and a group with non-refactored elements. We analyzed the elements{\textquoteright} characteristics in these groups using correlation analysis, Mann-Whitney U test and effect size measures. Results: Source code elements subjected to refactorings had significantly lower maintainability than elements not affected by refactorings. Moreover, refactored elements had significantly higher size related metrics, complexity, and coupling. Also these metrics changed more significantly in the refactored elements. The results are mostly in line with our previous findings on the not validated dataset, with the difference that clone metrics had no strong connection with refactoring. Conclusions: Compared to the preliminary analysis using a not validated dataset, the manually validated dataset led to more significant results, which suggests that developers find targets for refactorings based on some internal quality properties of the source code, like their size, complexity or coupling, but not clone related metrics as reported in our previous studies. They do not just use these properties for identifying targets, but also control them with refactorings.},
	keywords = {Code refactoring, Empirical study, Manually validated empirical dataset, Software maintainability, Source code metrics},
	issn = {0950-5849},
	doi = {10.1016/j.infsof.2017.11.012},
	url = {http://www.sciencedirect.com/science/article/pii/S0950584916303561},
	author = {P Heged{\H u}s and K{\'a}d{\'a}r, Istv{\'a}n and Rudolf Ferenc and Tibor Gyim{\'o}thy}
}
@article {ban2018prediction,
	title = {Prediction Models for Performance, Power, and Energy Efficiency of Software Executed on Heterogeneous Hardware},
	journal = {Journal of Supercomputing},
	year = {2018},
	note = {(Accepted for publication.)},
	pages = {25},
	publisher = {springer},
	author = {B{\'a}n, D{\'e}nes and Rudolf Ferenc and Siket, Istv{\'a}n and {\'A}kos Kiss 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}
}
@proceedings {FBG16,
	title = {10th Jubilee Conference of PhD Students in Computer Science (CSCS 2016)},
	year = {2016},
	note = {Volume of Extended Abstracts},
	month = {jun},
	publisher = {University of Szeged},
	address = {Szeged, Hungary},
	url = {http://www.inf.u-szeged.hu/~cscs/},
	editor = {Rudolf Ferenc and B{\'a}nhelyi, Bal{\'a}zs and Tam{\'a}s Gergely and Attila Kert{\'e}sz and Kincses, Zolt{\'a}n}
}
@conference {KHF16c,
	title = {Assessment of the Code Refactoring Dataset Regarding the Maintainability of Methods},
	booktitle = {Proceedings of the 16th International Conference on Computational Science and Its Applications (ICCSA 2016)},
	year = {2016},
	month = {jul},
	pages = {610{\textendash}624},
	publisher = {Springer International Publishing},
	organization = {Springer International Publishing},
	address = {Beijing, China},
	abstract = {Code refactoring has a solid theoretical background while being used in development practice at the same time. However, previous works found controversial results on the nature of code refactoring activities in practice. Both their application context and impact on code quality needs further examination. Our paper encourages the investigation of code refactorings in practice by providing an excessive open dataset of source code metrics and applied refactorings through several releases of 7 open-source systems. We already demonstrated the practical value of the dataset by analyzing the quality attributes of the refactored source code classes and the values of source code metrics improved by those refactorings. In this paper, we have gone one step deeper and explored the effect of code refactorings at the level of methods. We found that similarly to class level, lower maintainability indeed triggers more code refactorings in practice at the level of methods and these refactorings significantly decrease size, coupling and clone metrics.},
	keywords = {Code refactoring, Empirical study, Refactoring dataset, Software maintainability},
	doi = {10.1007/978-3-319-42089-9_43},
	url = {https://link.springer.com/chapter/10.1007\%2F978-3-319-42089-9_43},
	author = {K{\'a}d{\'a}r, Istv{\'a}n and P Heged{\H u}s and Rudolf Ferenc and Tibor Gyim{\'o}thy}
}
@conference {KHF16,
	title = {A Code Refactoring Dataset and Its Assessment Regarding Software Maintainability},
	booktitle = {Proceedings of the 23rd IEEE International Conference on Software Analysis, Evolution, and Reengineering (SANER 2016)},
	year = {2016},
	pages = {599{\textendash}603},
	publisher = {IEEE Computer Society},
	organization = {IEEE Computer Society},
	address = {Suita, Osaka, Japan},
	abstract = {It is very common in various fields that there is a gap between theoretical results and their practical applications. This is true for code refactoring as well, which has a solid theoretical background while being used in development practice at the same time. However, more and more studies suggest that developers perform code refactoring entirely differently than the theory would suggest. Our paper encourages the further investigation of code refactorings in practice by providing an excessive open dataset of source code metrics and applied refactorings through several releases of 7 open-source systems. As a first step of processing this dataset, we examined the quality attributes of the refactored source code classes and the values of source code metrics improved by those refactorings. Our early results show that lower maintainability indeed triggers more code refactorings in practice and these refactorings significantly decrease complexity, code lines, coupling and clone metrics. However, we observed a decrease in comment related metrics in the refactored code.},
	keywords = {Code refactoring, Empirical study, Software maintainability},
	doi = {10.1109/SANER.2016.42},
	url = {http://ieeexplore.ieee.org/document/7476680/},
	author = {K{\'a}d{\'a}r, Istv{\'a}n and P Heged{\H u}s 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 {GBS16,
	title = {Enforcing Techniques and Transformation of {C/C++} Source Code to Heterogeneous Hardware},
	booktitle = {Proceedings of the 16th IEEE International Conference on Scalable Computing and Communication (ScalCom 2016)},
	year = {2016},
	month = {jul},
	pages = {1173{\textendash}1180},
	publisher = {IEEE Computer Society},
	organization = {IEEE Computer Society},
	address = {Toulouse, France},
	abstract = {Besides well-known CPU based architectures, the so-called accelerators (GPU, DSP, FPGA) are about to gain ground in everyday programming, computing tasks. However, programming such computation units is quite different from traditional programming for CPUs, and special skills are required from the developers. In this paper we present techniques, tooling support for the developers in the first step of re-engineering for parallelism in heterogeneous parallel platforms, namely to assure that the code to be offloaded to an accelerator conforms to its specific requirements by identifying the possible violations in the source code, and also by providing automatic code transformations for their elimination.},
	keywords = {C/C++, Cevelop, code transformation, Eclipse CDT, heterogeneous hardware, REPARA, Static Analysis},
	doi = {10.1109/UIC-ATC-ScalCom-CBDCom-IoP-SmartWorld.2016.0180},
	url = {http://ieeexplore.ieee.org/document/7816976/},
	author = {Gyimesi, G{\'a}bor and D{\'e}nes B{\'a}n and Istv{\'a}n Siket and Rudolf Ferenc and Brugnoni, Silvano and Corbat, Thomas and Sommerlad, Peter and Suter, Toni}
}
@conference {KHF16b,
	title = {A Manually Validated Code Refactoring Dataset and Its Assessment Regarding Software Maintainability},
	booktitle = {Proceedings of the 12th ACM International Conference on Predictive Models and Data Analytics in Software Engineering (PROMISE 2016)},
	year = {2016},
	month = {sep},
	pages = {10:1{\textendash}10:4},
	publisher = {ACM},
	organization = {ACM},
	address = {Ciudad Real, Spain},
	abstract = {Refactoring is a popular technique for improving the internal structure of software systems. It has a solid theoretical background while being used in development practice at the same time. However, we lack empirical research results on the real effect of code refactoring and its ways of application. This paper presents a manually validated dataset of applied refactorings and source code metrics and maintainability of 7 open-source systems. It is a subset of our previously published dataset containing the refactoring instances automatically extracted by the RefFinder tool. We found that RefFinder had around 27\% overall average precision on the subject systems, thus our new {\textendash} manually validated {\textendash} subset has substantial added value allowing researchers to perform more accurate empirical investigations. Using this data, we were able to study whether refactorings were really triggered by poor maintainability of the code, or by other aspects. The results show that source code elements subject to refactorings had significantly lower maintainability values (approximated by source code metric aggregation) than elements not affected by refactorings between two releases.},
	keywords = {Code refactoring, Empirical study, Manually validated empirical dataset, Software maintainability},
	doi = {10.1145/2972958.2972962},
	url = {https://dl.acm.org/citation.cfm?doid=2972958.2972962},
	author = {K{\'a}d{\'a}r, Istv{\'a}n and P Heged{\H u}s and Rudolf Ferenc and Tibor Gyim{\'o}thy}
}
@conference {TGF16,
	title = {A Public Bug Database of {GitHub} Projects and Its Application in Bug Prediction},
	booktitle = {Proceedings of the 16th International Conference on Computational Science and Its Applications (ICCSA 2016)},
	year = {2016},
	pages = {625{\textendash}638},
	publisher = {Springer International Publishing},
	organization = {Springer International Publishing},
	address = {Beijing, China},
	abstract = {Detecting defects in software systems is an evergreen topic, since there is no real world software without bugs. Many different bug locating algorithms have been presented recently that can help to detect hidden and newly occurred bugs in software. Papers trying to predict the faulty source code elements or code segments in the system always use experience from the past. In most of the cases these studies construct a database for their own purposes and do not make the gathered data publicly available. Public datasets are rare; however, a well constructed dataset could serve as a benchmark test input. Furthermore, open-source software development is rapidly increasing that also gives an opportunity to work with public data. In this study we selected 15 Java projects from GitHub to construct a public bug database from. We matched the already known and fixed bugs with the corresponding source code elements (classes and files) and calculated a wide set of product metrics on these elements. After creating the desired bug database, we investigated whether the built database is usable for bug prediction. We used 13 machine learning algorithms to address this research question and finally we achieved F-measure values between 0.7 and 0.8. Beside the F-measure values we calculated the bug coverage ratio on every project for every machine learning algorithm. We obtained very high and promising bug coverage values (up to 100\%).},
	keywords = {Bug database, Bug prediction},
	doi = {10.1007/978-3-319-42089-9_44},
	url = {https://link.springer.com/chapter/10.1007\%2F978-3-319-42089-9_44},
	author = {T{\'o}th, Zolt{\'a}n and Gyimesi, P{\'e}ter and Rudolf Ferenc}
}
@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 {KHF15,
	title = {Adding Constraint Building Mechanisms to a Symbolic Execution Engine Developed for Detecting Runtime Errors},
	booktitle = {Proceedings of the 15th International Conference on Computational Science and Its Applications (ICCSA 2015)},
	series = {Lecture Notes in Computer Science (LNCS)},
	volume = {9159},
	year = {2015},
	month = {jun},
	pages = {20{\textendash}35},
	publisher = {Springer-Verlag},
	organization = {Springer-Verlag},
	address = {Banff, Alberta, Canada},
	abstract = {Most of the runtime failures of a software system can be revealed during test execution only, which has a very high cost. The symbolic execution engine developed at the Software Engineering Department of University of Szeged is able to detect runtime errors (such as null pointer dereference, bad array indexing, division by zero) in Java programs without running the program in real-life environment. In this paper we present a constraint system building mechanism which improves the accuracy of the runtime errors found by the symbolic execution engine mentioned above. We extend the original principles of symbolic execution by tracking the dependencies of the symbolic variables and substituting them with concrete values if the built constraint system unambiguously determines their value. The extended symbolic execution checker was tested on real-life open-source systems as well.},
	keywords = {Constraint system building, Java runtime errors, Software engineering, symbolic execution},
	doi = {10.1007/978-3-319-21413-9_2},
	url = {https://link.springer.com/chapter/10.1007\%2F978-3-319-21413-9_2},
	author = {K{\'a}d{\'a}r, Istv{\'a}n and P Heged{\H u}s and Rudolf Ferenc}
}
@conference {GGT15,
	title = {Characterization of Source Code Defects by Data Mining Conducted on {GitHub}},
	booktitle = {Proceedings of the 15th International Conference on Computational Science and Its Applications (ICCSA 2015)},
	series = {Lecture Notes in Computer Science (LNCS)},
	volume = {9159},
	year = {2015},
	month = {jun},
	pages = {47{\textendash}62},
	publisher = {Springer-Verlag},
	organization = {Springer-Verlag},
	address = {Banff, Alberta, Canada},
	abstract = {In software systems the coding errors are unavoidable due to the frequent source changes, the tight deadlines and the inaccurate specifications. Therefore, it is important to have tools that help us in finding these errors. One way of supporting bug prediction is to analyze the characteristics of the previous errors and identify the unknown ones based on these characteristics. This paper aims to characterize the known coding errors. Nowadays, the popularity of the source code hosting services like GitHub are increasing rapidly. They provide a variety of services, among which the most important ones are the version and bug tracking systems. Version control systems store all versions of the source code, and bug tracking systems provide a unified interface for reporting errors. Bug reports can be used to identify the wrong and the previously fixed source code parts, thus the bugs can be characterized by static source code metrics or by other quantitatively measured properties using the gathered data. We chose GitHub for the base of data collection and we selected 13 Java projects for analysis. As a result, a database was constructed, which characterizes the bugs of the examined projects, thus can be used, inter alia, to improve the automatic detection of software defects.},
	keywords = {Bug database, Data mining, GitHub},
	doi = {10.1007/978-3-319-21413-9_4},
	url = {https://link.springer.com/chapter/10.1007\%2F978-3-319-21413-9_4},
	author = {Gyimesi, P{\'e}ter and Gyimesi, G{\'a}bor and T{\'o}th, Zolt{\'a}n and Rudolf Ferenc}
}
@conference {FHF15,
	title = {Code Ownership: Impact on Maintainability},
	booktitle = {Proceedings of the 15th International Conference on Computational Science and Its Applications (ICCSA 2015)},
	series = {Lecture Notes in Computer Science (LNCS)},
	volume = {9159},
	year = {2015},
	month = {jun},
	pages = {3{\textendash}19},
	publisher = {Springer-Verlag},
	organization = {Springer-Verlag},
	address = {Banff, Alberta, Canada},
	abstract = {Software systems erode during development, which results in high maintenance costs in the long term. Is it possible to narrow down where exactly this erosion happens? Can we infer the future erosion based on past code changes? In this paper we investigate code ownership and show that a further step of code quality decrease is more likely to happen due to the changes in source files modified by several developers in the past, compared to files with clear ownership. We estimate the level of code ownership and maintainability changes for every commit of three open-source and one proprietary software systems. With the help of Wilcoxon rank test we compare the ownership values of the files in commits resulting maintainability increase with those of decreasing the maintainability. Three tests out of the four gave strong results and the fourth one did not contradict them either. The conclusion of this study is a generalization of the already known fact that common code is more error-prone than those of developed by fewer developers. This result could be utilized in identifying the {\textquotedblleft}hot spots{\textquotedblright} of the source code from maintainability point of view. A possible IDE plug-in, which indicates the risk of decreasing the maintainability of the source code, could help the architect and warn the developers.},
	keywords = {Code ownership, ISO/IEC 25010, Source code maintainability, Wilcoxon test},
	doi = {10.1007/978-3-319-21413-9_1},
	url = {https://link.springer.com/chapter/10.1007\%2F978-3-319-21413-9_1},
	author = {Farag{\'o}, Csaba and P Heged{\H u}s and Rudolf Ferenc}
}
@conference {TVF15,
	title = {Comparison of Static Analysis Tools for Quality Measurement of {RPG} Programs},
	booktitle = {Proceedings of the 15th International Conference on Computational Science and Its Applications (ICCSA 2015)},
	series = {Lecture Notes in Computer Science (LNCS)},
	volume = {9159},
	year = {2015},
	month = {jun},
	pages = {177{\textendash}192},
	publisher = {Springer-Verlag},
	organization = {Springer-Verlag},
	address = {Banff, Alberta, Canada},
	abstract = {The RPG programming language is a popular language employed widely in IBM i mainframes nowadays. Legacy mainframe systems that evolved and survived the past decades usually data intensive and even business critical applications. Recent, state of the art quality assurance tools are mostly focused on popular languages like Java, C++ or Python. In this work we compare two source code based quality management tools for the RPG language. The study is focused on the data obtained using static analysis, which is then aggregated to higher level quality attributes. SourceMeter is a command line tool-chain capable to measure various source attributes like metrics and coding rule violations. SonarQube is a quality management platform with RPG language support. To facilitate the objective comparison, we used the SourceMeter for RPG plugin for SonarQube, which seamlessly integrates into the framework extending its capabilities. The evaluation is built on analysis success and depth, source code metrics, coding rules and code duplications. We found that SourceMeter is more advanced in analysis depth, product metrics and finding duplications, while their performance of coding rules and analysis success is rather balanced. Since both tools were presented recently on the market of quality assurance tools, we expect additional releases in the future with more mature analyzers.},
	keywords = {Coding rules, IBM RPG, metrics, software quality, SonarQube, SourceMeter, Static Analysis},
	doi = {10.1007/978-3-319-21413-9_13},
	url = {https://link.springer.com/chapter/10.1007\%2F978-3-319-21413-9_13},
	author = {T{\'o}th, Zolt{\'a}n and L{\'a}szl{\'o} Vid{\'a}cs and Rudolf Ferenc}
}
@book {Fer15,
	title = {Conference of PhD Students in Computer Science},
	series = {Acta Cybernetica},
	volume = {22},
	number = {1},
	year = {2015},
	publisher = {University of Szeged},
	organization = {University of Szeged},
	edition = {Special Issue},
	address = {Szeged, Hungary},
	doi = {10.14232/actacyb.22.1.2015.1},
	url = {http://www.inf.u-szeged.hu/actacybernetica/edb/vol22n1/CSCSPreface_2015_ActaCybernetica.xml},
	editor = {Rudolf Ferenc}
}
@conference {FHF15b,
	title = {Cumulative Code Churn: Impact on Maintainability},
	booktitle = {Proceedings of the 15th IEEE International Working Conference on Source Code Analysis and Manipulation (SCAM 2015)},
	year = {2015},
	month = {sep},
	pages = {141{\textendash}150},
	publisher = {IEEE Computer Society},
	organization = {IEEE Computer Society},
	address = {Bremen, Germany},
	abstract = {It is a well-known phenomena that the source code of software systems erodes during development, which results in higher maintenance costs in the long term. But can we somehow narrow down where exactly this erosion happens? Is it possible to infer the future erosion based on past code changes? Do modifications performed on frequently changing code have worse effect on software maintainability than those affecting less frequently modified code? In this study we investigated these questions and the results indicate that code churn indeed increases the pace of code erosion. We calculated cumulative code churn values and maintainability changes for every version control commit operation of three open-source and one proprietary software system. With the help of Wilcoxon rank test we compared the cumulative code churn values of the files in commits resulting maintainability increase with those of decreasing the maintainability. In the case of three systems the test showed very strong significance and in one case it resulted in strong significance (p-values 0.00235, 0.00436, 0.00018 and 0.03616). These results support our preliminary assumption that modifying high-churn code is more likely to decrease the overall maintainability of a software system, which can be thought of as the generalization of the already known phenomena that code churn results in higher number of defects.},
	keywords = {code churn, ISO/IEC 25010, Source code maintainability, Wilcoxon test},
	doi = {10.1109/SCAM.2015.7335410},
	url = {http://ieeexplore.ieee.org/document/7335410/},
	author = {Farag{\'o}, Csaba and P Heged{\H u}s and Rudolf Ferenc}
}
@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 {FHL15,
	title = {Impact of Version History Metrics on Maintainability},
	booktitle = {Proceedings of the 8th International Conference on Advanced Software Engineering \& Its Applications (ASEA 2015)},
	year = {2015},
	pages = {30{\textendash}35},
	publisher = {IEEE Computer Society},
	organization = {IEEE Computer Society},
	address = {Jeju Island, Korea},
	abstract = {In this study we present how some version control history based metrics affect maintainability of the source code. These metrics cover intensity of modifications, code ownership and code aging. We determine the order of source files based on each analyzed metrics, and compare it with their maintainability based order. As a cross-check we perform a comparison test with post-release defects as well. We performed the analysis on 14 versions of 4 well-known open source software systems. The results show high correlation between the version control metrics and relative maintainability indexes, in each case. The comparison with post-release defects also support the results in most of the cases.},
	keywords = {code aging, code churn, Code ownership, Source code maintainability, version control history metrics},
	doi = {10.1109/ASEA.2015.14},
	url = {http://ieeexplore.ieee.org/document/7433065/},
	author = {Farag{\'o}, Csaba and P Heged{\H u}s and Lad{\'a}nyi, Gergely and Rudolf Ferenc}
}
@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 {BFS15,
	title = {Prediction Models for Performance, Power, and Energy Efficiency of Software Executed on Heterogeneous Hardware},
	booktitle = {Proceedings of the 13th IEEE International Symposium on Parallel and Distributed Processing with Applications (ISPA 2015)},
	year = {2015},
	month = {aug},
	pages = {178{\textendash}183},
	publisher = {IEEE Computer Society},
	organization = {IEEE Computer Society},
	address = {Helsinki, Finland},
	abstract = {Heterogeneous environments are becoming commonplace so it is increasingly important to understand how and where we could execute a given algorithm the most efficiently. In this paper we propose a methodology that uses both static source code metrics and dynamic execution time, power and energy measurements to build configuration prediction models. These models are trained on special benchmarks that have both sequential and parallel implementations and can be executed on various computing elements, e.g., on CPUs or GPUs. After they are built, however, they can be applied to a new system using only the system{\textquoteright}s static metrics which are much more easily computable than any dynamic measurement. We found that we could predict the optimal execution configuration fairly accurately using static information alone.},
	keywords = {configuration selection, Green computing, heterogeneous architecture, performance optimization, power-aware execution},
	doi = {10.1109/Trustcom.2015.629},
	url = {http://ieeexplore.ieee.org/document/7345645/},
	author = {D{\'e}nes B{\'a}n and Rudolf Ferenc and Istv{\'a}n Siket and {\'A}kos Kiss}
}
@conference {LTF15,
	title = {A Software Quality Model for {RPG}},
	booktitle = {Proceedings of the 22nd IEEE International Conference on Software Analysis, Evolution, and Reengineering (SANER 2015)},
	year = {2015},
	month = {mar},
	pages = {91{\textendash}100},
	publisher = {IEEE Computer Society},
	organization = {IEEE Computer Society},
	address = {Montr{\'e}al, Canada},
	abstract = {The IBM i mainframe was designed to manage business applications for which the reliability and quality is a matter of national security. The RPG programming language is the most frequently used one on this platform. The maintainability of the source code has big influence on the development costs, probably this is the reason why it is one of the most attractive, observed and evaluated quality characteristic of all. For improving or at least preserving the maintainability level of software it is necessary to evaluate it regularly. In this study we present a quality model based on the ISO/IEC 25010 international standard for evaluating the maintainability of software systems written in RPG. As an evaluation step of the quality model we show a case study in which we explain how we integrated the quality model as a continuous quality monitoring tool into the business processes of a mid-size software company which has more than twenty years of experience in developing RPG applications.},
	keywords = {Case Study, IBM i mainframe, ISO/IEC 25010, RPG quality model, Software maintainability},
	doi = {10.1109/SANER.2015.7081819},
	url = {http://ieeexplore.ieee.org/document/7081819/},
	author = {Lad{\'a}nyi, Gergely and T{\'o}th, Zolt{\'a}n and Rudolf Ferenc and Keresztesi, Tibor}
}
@proceedings {FBG14,
	title = {9th Conference of PhD Students in Computer Science (CSCS 2014)},
	year = {2014},
	note = {Volume of Extended Abstracts},
	month = {jun},
	publisher = {University of Szeged},
	address = {Szeged, Hungary},
	url = {http://www.inf.u-szeged.hu/~cscs/cscs2014/},
	editor = {Rudolf Ferenc and B{\'a}nhelyi, Bal{\'a}zs and Tam{\'a}s Gergely and Kincses, Zolt{\'a}n}
}
@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}
}
@article {FHV14,
	title = {Connection Between Version Control Operations and Quality Change of the Source Code},
	journal = {Acta Cybernetica},
	volume = {21},
	number = {4},
	year = {2014},
	pages = {585{\textendash}607},
	abstract = {Software erosion is a well-known phenomena, meaning that software quality is continuously decreasing due to the ever-ongoing modifications in the source code. In this research work we investigated this phenomena by studying the impact of version control commit operations (add, update, delete) on the quality of the code. We calculated the ISO/IEC 9126 quality attributes for thousands of revisions of an industrial and three open-source software systems with the help of the Columbus Quality Model. We also collected the cardinality of each version control operation type for every investigated revision. We performed Chisquared tests on contingency tables with rows of quality change and columns of version control operation commit types. We compared the results with random data as well. We identified that the relationship between the version control operations and quality change is quite strong. Great maintainability improvements are mostly caused by commits containing Add operation. Commits containing file updates only tend to have a negative impact on the quality. Deletions have a weak connection with quality, and we could not formulate a general statement.},
	keywords = {Case Study, ISO/IEC 9126, Software Erosion, Software maintainability, Source Code Version Control},
	issn = {0324-721X},
	url = {http://publicatio.bibl.u-szeged.hu/8394/},
	author = {Farag{\'o}, Csaba and P Heged{\H u}s and V{\'e}gh, {\'A}d{\'a}m Zolt{\'a}n and Rudolf Ferenc}
}
@conference {LHF14,
	title = {The Connection of the Bug Density and Maintainability of Classes},
	booktitle = {8th International Workshop on Software Quality and Maintainability},
	series = {SQM},
	year = {2014},
	note = {Presentation only},
	month = {feb},
	address = {Antwerp, Belgium},
	abstract = {Measuring software product maintainability is a central issue in software engineering which led to a number of different practical quality models. Besides system level assessments it is also desirable that these models provide technical quality information at source code element level (e.g. classes, methods) to aid the improvement of the software. Although many existing models give an ordered list of source code elements that should be improved, it is unclear how these improvements affect other important quality indicators of the system, e.g. bug density. In this paper we empirically investigate the connection of bug numbers in the classes of different open-source systems and the class level maintainability measures of our ColumbusQM probabilistic quality model using open-access bug datasets. We show that classes with lower maintainability score contain significantly more bugs than more maintainable classes. Moreover, in terms of correctness and completeness, ColumbusQM competes with statistical and machine learning prediction models especially trained on the bug data using product metrics as predictors. This is a great achievement in the light of that our model needs no training and its purpose is different (e.g. to estimate testability, or development costs) than those of the bug prediction models. In summary, we show that improving the maintainability of a software according to the suggestions of our quality model will expectedly also reduce its bug density.},
	keywords = {Bug density, Bug prediction, Class level maintainability, ColumbusQM, ISO/IEC 25010, Software maintainability},
	author = {Lad{\'a}nyi, Gergely and P Heged{\H u}s and Rudolf Ferenc and Istv{\'a}n Siket 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 {FHF14,
	title = {The Impact of Version Control Operations on the Quality Change of the Source Code},
	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 = {353{\textendash}369},
	publisher = {Springer-Verlag},
	organization = {Springer-Verlag},
	address = {Guimar{\~a}es, Portugal},
	abstract = {The number of software systems under development and maintenance is rapidly increasing. The quality of a system{\textquoteright}s source code tends to decrease during its lifetime which is a problem because maintaining low quality code consumes a big portion of the available efforts. In this research we investigated one aspect of code change, the version control commit operations (add, update, delete). We studied the impact of these operations on the maintainability of the code. We calculated the ISO/IEC 9126 quality attributes for thousands of revisions of an industrial and three open-source software systems. We also collected the cardinality of each version control operation type for every investigated revision. Based on these data, we identified that operation Add has a rather positive, while operation Update has a rather negative effect on the quality. On the other hand, for operation Delete we could not find a clear connection to quality change.},
	keywords = {Case Study, ISO/IEC 9126, Software Erosion, Software maintainability, Source Code Version Control},
	doi = {10.1007/978-3-319-09156-3_26},
	url = {https://link.springer.com/chapter/10.1007\%2F978-3-319-09156-3_26},
	author = {Farag{\'o}, Csaba and P Heged{\H u}s and Rudolf Ferenc}
}
@conference {BHS14,
	title = {{QualityGate SourceAudit}: a Tool for Assessing the Technical Quality of Software},
	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},
	month = {feb},
	pages = {440{\textendash}445},
	publisher = {IEEE Computer Society},
	organization = {IEEE Computer Society},
	address = {Antwerp, Belgium},
	abstract = {Software systems are evolving continuously in order to fulfill the ever-changing business needs. This endless modification, however, decreases the internal quality of the system over time. This phenomena is called software erosion, which results in higher development, testing, and operational costs. The SourceAudit tool presented in this paper helps managing the technical risks of software deterioration by allowing imme-diate, automatic, and objective assessment of software quality. By monitoring the high-level technical quality of systems it is possible to immediately perform the necessary steps needed to reduce the effects of software erosion, thus reaching higher maintainability and lower costs in the mid and long-term. The tool measures source code maintainability according to the ISO/IEC 25010 based probabilistic software maintainability model called ColumbusQM. It gives a holistic view on software quality and warns on source code maintainability decline.},
	keywords = {ColumbusQM, development costs, internal system quality, ISO-IEC 25010 based probabilistic software maintainability, operational costs, QualityGate SourceAudit, software deterioration, Software Erosion, Source code maintainability, technical software quality, testing costs},
	doi = {10.1109/CSMR-WCRE.2014.6747214},
	url = {http://ieeexplore.ieee.org/document/6747214/},
	author = {Tibor Bakota and P Heged{\H u}s and Istv{\'a}n Siket and Lad{\'a}nyi, Gergely and Rudolf Ferenc}
}
@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 {DVF14,
	title = {Service Layer for {IDE} Integration of {C/C++} Preprocessor Related Analysis},
	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},
	publisher = {Springer-Verlag},
	organization = {Springer-Verlag},
	address = {Guimar{\~a}es, Portugal},
	abstract = {Software development in C/C++ languages is tightly coupled with preprocessor directives. While the use of preprocessor constructs cannot be avoided, current IDE support for developers can still be improved. Early feedback from IDEs about misused macros or conditional compilation has positive effects on developer productivity and code quality as well. In this paper we introduce a service layer for the Visual Studio to make detailed preprocessor information accessible for any type of IDE extensions. The service layer is built upon our previous work on the analysis of directives. We wrap the analyzer tool and provide its functionality through an API. We present the public interface of the service and demonstrate the provided services through small plug-ins implemented using various extension mechanisms. These plug-ins work together to aid the daily work of developers in several ways. We provide (1) an editor extension through the Managed Extensibility Framework which provides macro highlighting within the source code editor; (2) detailed information about actual macro substitutions and an alternative code view to show the results of macro calls; (3) a managed package for discovering the intermediate steps of macro replacements through a macro explorer. The purpose of this work is twofold: we present an additional layer designed to aid the work of tool developers; second, we provide directly usable IDE components to express its potentials.},
	doi = {10.1007/978-3-319-09156-3_29},
	url = {https://link.springer.com/chapter/10.1007\%2F978-3-319-09156-3_29},
	author = {D{\'e}vai, Rich{\'a}rd and L{\'a}szl{\'o} Vid{\'a}cs and Rudolf Ferenc and Tibor Gyim{\'o}thy}
}
@inbook {FHG14,
	title = {Software Product Quality Models},
	booktitle = {Evolving Software Systems},
	year = {2014},
	pages = {65{\textendash}100},
	publisher = {Springer Berlin Heidelberg},
	organization = {Springer Berlin Heidelberg},
	chapter = {3},
	abstract = {Both for software developers and managers it is crucial to have information about different aspects of the quality of their systems. This chapter gives a brief overview about the history of software product quality measurement, focusing on software maintainability, and the existing approaches and high-level models for characterizing software product quality. The most widely accepted and used practical maintainability models and the state-of-the-art works in the subject are introduced. These models play a very important role in software evolution by allowing to estimate future development costs, assess risks, or support management decisions. Based on objective aspects, the implementations of the most popular software maintainability models are compared and evaluated. The evaluation includes the Quality Index, SQALE, SQUALE, SIG, QUAMOCO, and Columbus Quality Model. The chapter presents the result of comparing the features and stability of the tools and the different models on a large number of open-source Java projects.},
	isbn = {978-3-642-45397-7},
	doi = {10.1007/978-3-642-45398-4_3},
	url = {https://link.springer.com/chapter/10.1007/978-3-642-45398-4_3},
	author = {Rudolf Ferenc and P Heged{\H u}s and Tibor Gyim{\'o}thy}
}
@conference {FLS14,
	title = {{SourceMeter} {SonarQube} plug-in},
	booktitle = {Proceedings of the 14th IEEE International Working Conference on Source Code Analysis and Manipulation (SCAM 2014)},
	year = {2014},
	month = {sep},
	pages = {77{\textendash}82},
	publisher = {IEEE Computer Society},
	organization = {IEEE Computer Society},
	address = {Victoria, British Columbia, Canada},
	abstract = {The SourceMeter Sonar Qube plug-in is an extension of Sonar Qube, an open-source platform for managing code quality made by Sonar Source S.A, Switzerland. The plug-in extends the built-in Java code analysis engine of Sonar Qube with Front End ART{\textquoteright}s high-end Java code analysis engine. Most of Sonar Qubes original analysis results are replaced (including the detected source code duplications), while the range of available analyses is extended with a number of additional metrics and issue detectors. Additionally, the plug-in offers new GUI features on the Sonar Qube dashboard and drilldown views, making the Sonar Qube user experience more comfortable and the work with the tool more productive.},
	keywords = {clone detection, coding issues, metrics, plug-in, software quality, Sonar Qube, Source Meter},
	doi = {10.1109/SCAM.2014.31},
	url = {http://ieeexplore.ieee.org/document/6975640/},
	author = {Rudolf Ferenc and Lang{\'o}, L{\'a}szl{\'o} and Istv{\'a}n Siket and Tibor Gyim{\'o}thy and Tibor Bakota}
}
@inbook {16356,
	title = {Configuring Software for Reuse with {VCL}},
	booktitle = {Proceedings of the 13th Symposium on Programming Languages and Software Tools, SPLST{\textquoteright}13},
	year = {2013},
	pages = {16{\textendash}30},
	publisher = {University of Szeged},
	organization = {University of Szeged},
	address = {Szeged},
	author = {Daniel Dan and Stan Jarzabek and Rudolf Ferenc},
	editor = {{\'A}kos Kiss}
}
@conference {DJF13,
	title = {Configuring Software for Reuse with {VCL}},
	booktitle = {Proceedings of the 13th Symposium on Programming Languages and Software Tools (SPLST 2013)},
	year = {2013},
	pages = {16{\textendash}30},
	publisher = {University of Szeged},
	organization = {University of Szeged},
	address = {Szeged, Hungary},
	abstract = {Preprocessors such as cpp are often used to manage families of programs from a common code base. The approach is simple, but code instrumented with preprocessing commands may become unreadable and dificult to work with. We describe a system called VCL (variant configuration language) that enhances cpp to provide a better solution to the same problem. The main extensions have to do with propagation of parameters across source files during VCL processing, the ability to adapt source files for reuse depending on the reuse context, and the ability to form general templates to represent any group of similar program structures (methods, functions, classes, files, directories) in generic, adaptable form. In the paper, we describe salient features of VCL, explain how they alleviate some of the problems of cpp, and illustrate reuse capabilities of VCL with an example.},
	author = {Daniel, Dan and Jarzabek, Stan 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}
}
@article {HBL13,
	title = {A Drill-Down Approach for Measuring Maintainability at Source Code Element Level},
	journal = {Electronic Communications of the {EASST}},
	volume = {60},
	year = {2013},
	pages = {1{\textendash}21},
	abstract = {Measuring source code maintainability has always been a challenge for software engineers. To address this problem, a number of metrics-based quality models have been proposed by researchers. Besides expressing source code maintainability in terms of numerical values, these models are also expected to provide explicable results, i.e. to give a detailed list of source code fragments that should be improved in order to reach higher overall quality. In this paper, we propose a general method for drilling down to the root causes of a quality rating. According to our approach, a relative maintainability index can be calculated for each source code element for which metrics are calculated (e.g. methods, classes). The index value expresses the source code element{\textquoteright}s contribution to the overall quality rating. We empirically validated the method on the jEdit open source tool, by comparing the results with the opinions of software engineering students. The case study shows that there is a high, 0.68 Spearman{\textquoteright}s correlation, which suggests that relative maintainability indices assigned by our method express the subjective feelings of humans fairly well.},
	keywords = {ISO/IEC 9126, Method level maintainability, Metrics-based quality model, Relative maintainability index},
	issn = {1863-2122},
	doi = {10.14279/tuj.eceasst.60.852},
	url = {https://journal.ub.tu-berlin.de/eceasst/article/view/852},
	author = {P Heged{\H u}s and Tibor Bakota and Lad{\'a}nyi, Gergely and Farag{\'o}, Csaba and Rudolf Ferenc}
}
@conference {HBL13b,
	title = {A Drill-Down Approach for Measuring Maintainability at Source Code Element Level},
	booktitle = {Proceedings of the 7th International Workshop on Software Quality and Maintainability (SQM 2013)},
	year = {2013},
	month = {mar},
	pages = {20{\textendash}29},
	address = {Genova, Italy},
	abstract = {Measuring source code maintainability has always been a challenge for software engineers. To address this problem, a number of metrics-based quality models have been proposed by researchers. Besides expressing source code maintainability in terms of numerical values, these models are also expected to provide explicable results, i.e. to give a detailed list of source code fragments that should be improved in order to reach higher overall quality. In this paper, we propose a general method for drilling down to the root causes of a quality rating. According to our approach, a relative maintainability index can be calculated for each source code element for which metrics are calculated (e.g. methods, classes). The index value expresses the source code element{\textquoteright}s contribution to the overall quality rating. We empirically validated the method on the jEdit open source tool, by comparing the results with the opinions of software engineering students. The case study shows that there is a high, 0.68 Spearman{\textquoteright}s correlation, which suggests that relative maintainability indices assigned by our method express the subjective feelings of humans fairly well.},
	keywords = {ISO/IEC 9126, Method level maintainability, Metrics-based quality model, Relative maintainability index},
	author = {P Heged{\H u}s and Tibor Bakota and Lad{\'a}nyi, Gergely and Farag{\'o}, Csaba and Rudolf Ferenc}
}
@article {16345,
	title = {A Drill-Down Approach for Measuring Maintainability at Source Code Element Level},
	journal = {ELECTRONIC COMMUNICATIONS OF THE EASST},
	volume = {60},
	year = {2013},
	pages = {20{\textendash}29},
	issn = {1863-2122},
	url = {http://www.inf.u-szeged.hu/ ferenc/papers/SQM2013_pre_proceedings.pdf},
	author = {P Heged{\H u}s and Tibor Bakota and G. Lad{\'a}nyi and Csaba Farag{\'o} 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}
}
@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}
}
@conference {16351,
	title = {A Semi-automatic Usability Evaluation Framework},
	booktitle = {Computational Science and Its Applications {\textendash} ICCSA 2013},
	year = {2013},
	pages = {529{\textendash}542},
	publisher = {"Springer-Verlag"address},
	organization = {"Springer-Verlag"address},
	address = {Berlin; Heidelberg},
	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.},
	author = {Korn{\'e}l Muhi and G{\'a}bor Sz{\H o}ke and F{\"u}l{\"o}p, L.J. and Rudolf Ferenc and {\'A}goston Berger},
	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 {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}
}
@conference {TNF13,
	title = {Using Version Control History to Follow the Changes of Source Code Elements},
	booktitle = {Proceedings of the 17th European Conference on Software Maintenance and Reengineering (CSMR 2013)},
	year = {2013},
	month = {mar},
	pages = {319{\textendash}322},
	publisher = {IEEE Computer Society},
	organization = {IEEE Computer Society},
	address = {Genova, Italy},
	abstract = {Version control systems store the whole history of the source code. Since the source code of a system is organized into files and folders, the history tells us the concerned files and their changed lines only but software engineers are also interested in which source code elements (e.g. classes or methods) are affected by a change. Unfortunately, in most programming languages source code elements do not follow the file system hierarchy, which means that a file can contain more classes and methods and a class can be stored in more files, which makes it difficult to determine the changes of classes by using the changes of files. To solve this problem we developed an algorithm, which is able to follow the changes of the source code elements by using the changes of files and we successfully applied it on the Web Kit open source system.},
	keywords = {Repository Mining, Static Analysis, Version Control System},
	doi = {10.1109/CSMR.2013.40},
	url = {http://ieeexplore.ieee.org/document/6498479/},
	author = {T{\'o}th, Zolt{\'a}n and Nov{\'a}k, G{\'a}bor and Rudolf Ferenc and Istv{\'a}n Siket}
}
@conference {16373,
	title = {Using Version Control History to Follow the Changes of Source Code Elements},
	booktitle = {Proceedings of the 17th European Conference on Software Maintenance and Reengineering},
	year = {2013},
	pages = {319{\textendash}322},
	publisher = {IEEE Computer Society Press},
	organization = {IEEE Computer Society Press},
	address = {Los Alamitos},
	author = {Zolt{\'a}n T{\'o}th and G{\'a}bor Nov{\'a}k and Rudolf Ferenc and Istv{\'a}n Siket},
	editor = {Anthony Cleve and Filippo Ricca and Maura Cerioli}
}
@conference {16342,
	title = {Abstract Runtime Monitoring with USE},
	booktitle = {Proceedings of the16th European Conference on Software Maintenance and Reengineering (CSMR{\textquoteright}12)},
	year = {2012},
	pages = {549{\textendash}552},
	publisher = {IEEE Computer Society},
	organization = {IEEE Computer Society},
	address = {Los Alamitos},
	author = {Lars Hamann and L{\'a}szl{\'o} Vid{\'a}cs and M. Gogolla and Mirco Kuhlmann},
	editor = {T. Mens and A. Cleve and Rudolf Ferenc}
}
@conference {16329,
	title = {A Cost Model Based on Software Maintainability},
	booktitle = {Proceedings of the 28th IEEE International Conference on Software Maintenance (ICSM)},
	year = {2012},
	pages = {316{\textendash}325},
	publisher = {IEEE Comput. Soc. Press},
	organization = {IEEE Comput. Soc. Press},
	address = {Los Alamitos},
	author = {Tibor Bakota and P Heged{\H u}s and G. Lad{\'a}nyi and K{\"o}rtv{\'e}lyesi, P and Rudolf Ferenc and Tibor Gyim{\'o}thy},
	editor = {Paolo Tonella and Massimiliano Di Penta and Jonathan I Maletic}
}
@article {16327,
	title = {Developer Support for Understanding Preprocessor Macro Expansions},
	journal = {Communications in Computer and Information Science},
	volume = {340},
	year = {2012},
	pages = {121{\textendash}130},
	issn = {1865-0929},
	author = {L{\'a}szl{\'o} Vid{\'a}cs and D{\'e}vai, R. and Rudolf Ferenc and Tibor Gyim{\'o}thy}
}
@conference {16304,
	title = {Development of a Unified Software Quality Platform in the Szeged {InfoP{\'o}lus} Cluster},
	booktitle = {Proceedings of the16th European Conference on Software Maintenance and Reengineering (CSMR{\textquoteright}12)},
	year = {2012},
	pages = {495{\textendash}498},
	publisher = {IEEE Computer Society},
	organization = {IEEE Computer Society},
	address = {Los Alamitos},
	author = {{\'A}rp{\'a}d Besz{\'e}des and Schrettner, L. and Tibor Gyim{\'o}thy},
	editor = {T. Mens and A. Cleve and Rudolf Ferenc}
}
@conference {16306,
	title = {Impact Analysis Using Static Execute After in {WebKit}},
	booktitle = {Proceedings of the16th European Conference on Software Maintenance and Reengineering (CSMR{\textquoteright}12)},
	year = {2012},
	pages = {95{\textendash}104},
	publisher = {IEEE Computer Society},
	organization = {IEEE Computer Society},
	address = {Los Alamitos},
	author = {Judit J{\'a}sz and Schrettner, L. and {\'A}rp{\'a}d Besz{\'e}des and Cs Osztrogon{\'a}c and Tibor Gyim{\'o}thy},
	editor = {T. Mens and A. Cleve and Rudolf Ferenc}
}
@article {16330,
	title = {Introduction to the Software Quality and Maintainability special issue},
	journal = {Software Quality Journal},
	volume = {20},
	year = {2012},
	pages = {263{\textendash}264},
	issn = {0963-9314},
	author = {Yiannis Kanellopoulos and Rudolf Ferenc}
}
@article {16326,
	title = {Myth or Reality? Analyzing the Effect of Design Patterns on Software Maintainability},
	journal = {Communications in Computer and Information Science},
	volume = {340},
	year = {2012},
	pages = {138{\textendash}145},
	issn = {1865-0929},
	author = {P Heged{\H u}s and D{\'e}nes B{\'a}n and Rudolf Ferenc and Tibor Gyim{\'o}thy}
}
@conference {16331,
	title = {Software Quality Model and Framework with Applications in Industrial Context},
	booktitle = {Proceedings of the16th European Conference on Software Maintenance and Reengineering (CSMR{\textquoteright}12)},
	year = {2012},
	pages = {453{\textendash}456},
	publisher = {IEEE Computer Society},
	organization = {IEEE Computer Society},
	address = {Los Alamitos},
	author = {Schrettner, L. and F{\"u}l{\"o}p, L.J. and {\'A}rp{\'a}d Besz{\'e}des and {\'A}kos Kiss and Tibor Gyim{\'o}thy},
	editor = {T. Mens and A. Cleve and Rudolf Ferenc}
}
@article {16328,
	title = {Towards Building Method Level Maintainability Models Based on Expert Evaluations},
	journal = {Communications in Computer and Information Science},
	volume = {340},
	year = {2012},
	pages = {146{\textendash}154},
	issn = {1865-0929},
	author = {P Heged{\H u}s and G. Lad{\'a}nyi and Istv{\'a}n Siket and Rudolf Ferenc}
}
@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 {6080791,
	title = {A probabilistic software quality model},
	booktitle = {Software Maintenance (ICSM), 2011 27th IEEE International Conference on},
	year = {2011},
	month = {sept.},
	pages = {243 -252},
	keywords = {cost estimation, costing, development cost, IEC standards, ISO standards, ISO/IEC 9126 standard, maintainability, probabilistic software quality model, probability, risk estimation, select:quality, software change, software maintenance, software quality, software quality selected},
	issn = {1063-6773},
	doi = {10.1109/ICSM.2011.6080791},
	author = {Tibor Bakota and P Heged{\H u}s and K{\"o}rtv{\'e}lyesi, P and Rudolf Ferenc and Tibor Gyim{\'o}thy}
}
@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}
}
@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 {conf/fgit/HegedusBILFG11,
	title = {Source Code Metrics and Maintainability: A Case Study.},
	booktitle = {FGIT-ASEA/DRBC/EL},
	series = {Communications in Computer and Information Science},
	volume = {257},
	year = {2011},
	pages = {272-284},
	publisher = {Springer},
	organization = {Springer},
	keywords = {dblp},
	isbn = {978-3-642-27206-6},
	url = {http://dblp.uni-trier.de/db/conf/fgit/asea2011.html$\#$HegedusBILFG11},
	author = {P Heged{\H u}s and Tibor Bakota and L. Ill{\'e}s and G. Lad{\'a}nyi and Rudolf Ferenc and Tibor Gyim{\'o}thy},
	editor = {Kim, Tai-Hoon and Adeli, Hojjat and Kim, Haeng-Kon and Kang, Heau-Jo and Kim, Kyung Jung and Kiumi, Akingbehin and Kang, Byeong Ho}
}
@inbook {springerlink:10.1007/978-3-642-17578-7_28,
	title = {Bug Forecast: A Method for Automatic Bug Prediction},
	booktitle = {Advances in Software Engineering},
	series = {Communications in Computer and Information Science},
	volume = {117},
	year = {2010},
	pages = {283-295},
	publisher = {Springer Berlin Heidelberg},
	organization = {Springer Berlin Heidelberg},
	isbn = {978-3-642-17578-7},
	url = {http://dx.doi.org/10.1007/978-3-642-17578-7_28},
	author = {Rudolf Ferenc},
	editor = {Kim, Tai-Hoon and Kim, Haeng-Kon and Khan, Muhammad Khurram and Kiumi, Akingbehin and Fang, Wai-chi and �l�zak, Dominik}
}
@conference {Schrettner:2010:DMS:1955601.1955983,
	title = {Development of a Methodology, Software {\textendash} Suite and Service for Supporting Software Architecture Reconstruction},
	booktitle = {Proceedings of the 2010 14th European Conference on Software Maintenance and Reengineering},
	series = {CSMR {\textquoteright}10},
	year = {2010},
	pages = {190{\textendash}193},
	publisher = {IEEE Computer Society},
	organization = {IEEE Computer Society},
	address = {Washington, DC, USA},
	keywords = {architecture evolution, architecture management, architecture reconstruction, architecture visualization},
	isbn = {978-0-7695-4321-5},
	doi = {http://dx.doi.org/10.1109/CSMR.2010.32},
	url = {http://dx.doi.org/10.1109/CSMR.2010.32},
	author = {Schrettner, L. and P Heged{\H u}s and Rudolf Ferenc and F{\"u}l{\"o}p, L.J. and Tibor Bakota}
}
@article {SMR:SMR522,
	title = {Introduction to the Special Issue of the 13th European Conference on Software Maintenance and Reengineering (CSMR 2009)},
	journal = {Journal of Software Maintenance and Evolution: Research and Practice},
	year = {2010},
	publisher = {John Wiley \& Sons, Ltd.},
	issn = {1532-0618},
	doi = {10.1002/smr.522},
	url = {http://dx.doi.org/10.1002/smr.522},
	author = {Rudolf Ferenc and J. Knodel and A. Winter}
}
@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 { ujhazi:new,
	title = {New Conceptual Coupling and Cohesion Metrics for Object-Oriented Systems.},
	booktitle = {SCAM{\textquoteright}10},
	year = {2010},
	pages = {33-42},
	keywords = {relate:quality, software quality selected},
	author = {B. {\'U}jh{\'a}zi and Rudolf Ferenc and D. Poshyvanyk and Tibor Gyim{\'o}thy}
}
@conference {Schrettner:2010:VSA:1852761.1852783,
	title = {Visualization of software architecture graphs of Java systems: managing propagated low level dependencies},
	booktitle = {Proceedings of the 8th International Conference on the Principles and Practice of Programming in Java},
	series = {PPPJ {\textquoteright}10},
	year = {2010},
	pages = {148{\textendash}157},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	keywords = {architecture reconstruction, architecture visualization, lifting, nested set model, software architecture},
	isbn = {978-1-4503-0269-2},
	doi = {http://doi.acm.org/10.1145/1852761.1852783},
	url = {http://doi.acm.org/10.1145/1852761.1852783},
	author = {Schrettner, L. and F{\"u}l{\"o}p, L.J. and Rudolf Ferenc and Tibor Gyim{\'o}thy}
}
@conference {FIVHF08,
	title = {Comparing and Evaluating Design Pattern Miner Tools},
	booktitle = {Annales Universitatis Scientiarum Budapestinensis de Rolando Eotvos Nominatae Sectio Computarotica},
	volume = {31},
	year = {2009},
	pages = {167-184},
	publisher = {Department of Computer Algebra, E{\"o}tv{\"o}s Lor{\'a}nd University},
	organization = {Department of Computer Algebra, E{\"o}tv{\"o}s Lor{\'a}nd University},
	author = {F{\"u}l{\"o}p, L.J. and {\'A}. Ilia and {\'A}. Z. V{\'e}gh and P Heged{\H u}s and Rudolf Ferenc}
}
@conference {conf/icsm/LiuPFGC09,
	title = {Modeling class cohesion as mixtures of latent topics.},
	booktitle = {ICSM},
	year = {2009},
	pages = {233-242},
	publisher = {IEEE},
	organization = {IEEE},
	keywords = {dblp},
	url = {http://dblp.uni-trier.de/db/conf/icsm/icsm2009.html$\#$LiuPFGC09},
	author = {Y. Liu and D. Poshyvanyk and Rudolf Ferenc and Tibor Gyim{\'o}thy and N. Chrisochoides}
}
@conference {HFF09,
	title = {Script2Ant - a tool for cross-platform scripting between different operating systems},
	booktitle = {Proceedings of the 11th Symposium on Programming Languages and Software Tools and 7th Nordic Workshop on Model Driven Software Engineering (SPLST{\textquoteright}09)},
	year = {2009},
	month = {aug},
	pages = {45-48},
	author = {Gy. Heged{\H u}s and F{\"u}l{\"o}p, L.J. and Rudolf Ferenc}
}
@article {Poshyvanyk:2009:UIR:1487421.1487439,
	title = {Using information retrieval based coupling measures for impact analysis},
	journal = {Empirical Softw. Engg.},
	volume = {14},
	year = {2009},
	month = {February},
	pages = {5{\textendash}32},
	publisher = {Kluwer Academic Publishers},
	address = {Hingham, MA, USA},
	keywords = {Change prediction, Coupling measurement, Impact analysis, Information retrieval, Latent semantic indexing, relate:quality, software quality selected},
	issn = {1382-3256},
	doi = {10.1007/s10664-008-9088-2},
	url = {http://dl.acm.org/citation.cfm?id=1487421.1487439},
	author = {D. Poshyvanyk and A. Marcus and Rudolf Ferenc and Tibor Gyim{\'o}thy}
}
@article {FHF08a,
	title = {Befriend - a Benchmark for Evaluating Reverse Engineering Tools},
	journal = {Periodica Polytechnica - Electrical Engineering},
	volume = {52},
	number = {3-4},
	year = {2008},
	pages = {153-162},
	author = {F{\"u}l{\"o}p, L.J. and P Heged{\H u}s and Rudolf Ferenc}
}
@conference {BBF08,
	title = {Continuous Software Quality Supervision Using {SourceInventory} and {Columbus}},
	booktitle = {Research Demonstrations of 30th International Conference on Software Engineering (ICSE{\textquoteright}08)},
	year = {2008},
	pages = {931-932},
	author = {Tibor Bakota and {\'A}rp{\'a}d Besz{\'e}des and Rudolf Ferenc and Tibor Gyim{\'o}thy}
}
@conference {FHF08,
	title = {Introducing a Benchmark for Evaluating Reverse Engineering Tools},
	booktitle = {Proceedings of the Sixth Conference of PhD Students in Computer Science},
	year = {2008},
	month = {jul},
	pages = {25},
	author = {F{\"u}l{\"o}p, L.J. and P Heged{\H u}s and Rudolf Ferenc}
}
@conference {FFG08,
	title = {{Towards a Benchmark for Evaluating Design Pattern Miner Tools}},
	booktitle = {Proceedings of the 12th European Conference on Software Maintenance and Reengineering (CSMR 2008)},
	year = {2008},
	month = {apr},
	pages = {143-152},
	publisher = {IEEE Computer Society},
	organization = {IEEE Computer Society},
	doi = {http://dx.doi.org/10.1109/CSMR.2008.4493309},
	author = {F{\"u}l{\"o}p, L.J. and Rudolf Ferenc and Tibor Gyim{\'o}thy}
}
@conference {FHFG08,
	title = {{Towards a Benchmark for Evaluating Reverse Engineering Tools}},
	booktitle = {Tool Demonstrations of the 15th Working Conference on Reverse Engineering (WCRE 2008)},
	year = {2008},
	month = {oct},
	pages = {335-336},
	doi = {http://dx.doi.org/10.1109/WCRE.2008.18},
	author = {F{\"u}l{\"o}p, L.J. and P Heged{\H u}s and Rudolf Ferenc and Tibor Gyim{\'o}thy}
}
@article {Marcus:2008:UCC:1399105.1399457,
	title = {Using the Conceptual Cohesion of Classes for Fault Prediction in Object-Oriented Systems},
	journal = {IEEE Trans. Softw. Eng.},
	volume = {34},
	year = {2008},
	month = {March},
	pages = {287{\textendash}300},
	publisher = {IEEE Press},
	address = {Piscataway, NJ, USA},
	keywords = {and reengineering, Code documentation, Document analysis, Document indexing, maintainability, Metrics/Measurement, Quality analysis and evaluation, relate:quality, Restructuring, reverse engineering, software quality selected},
	issn = {0098-5589},
	doi = {10.1109/TSE.2007.70768},
	url = {http://dl.acm.org/citation.cfm?id=1399105.1399457},
	author = {A. Marcus and D. Poshyvanyk and Rudolf Ferenc}
}
@conference {DBLP:conf/icsm/BakotaFG07,
	title = {Clone Smells in Software Evolution},
	booktitle = {ICSM},
	year = {2007},
	pages = {24-33},
	author = {Tibor Bakota and Rudolf Ferenc and Tibor Gyim{\'o}thy}
}
@conference {FIV07,
	title = {Comparing and Evaluating Design Pattern Miner Tools},
	booktitle = {Proceedings of the 10th Symposium on Programming Languages and Software Tools (SPLST{\textquoteright}07)},
	year = {2007},
	month = {jun},
	pages = {372-386},
	author = {F{\"u}l{\"o}p, L.J. and {\'A}. Ilia and {\'A}. Z. V{\'e}gh and Rudolf Ferenc}
}
@booklet {bicsak:cfg,
	title = {Constructing control flows graphs of binary executable programs at post-link time},
	year = {2007},
	author = {A. Bics{\'a}k and {\'A}kos Kiss and Rudolf Ferenc and Tibor Gyim{\'o}thy}
}
@conference {VBF07,
	title = {Macro Impact Analysis Using Macro Slicing},
	booktitle = {Proceedings of the Second International Conference on Software and Data Technologies (ICSOFT{\textquoteright}07)},
	year = {2007},
	month = {jul},
	pages = {230-235},
	author = {L{\'a}szl{\'o} Vid{\'a}cs and {\'A}rp{\'a}d Besz{\'e}des and Rudolf Ferenc}
}
@booklet {bicsak:abstracting,
	title = {Method and a device for abstracting instruction sequences with tail merging},
	year = {2007},
	author = {A. Bics{\'a}k and {\'A}kos Kiss and G. Lehotai and Rudolf Ferenc and Tibor Gyim{\'o}thy}
}
@conference {FGF06,
	title = {{Evaluating C++ Design Pattern Miner Tools}},
	booktitle = {Proceedings of the 6th International Workshop on Source Code Analysis and Manipulation (SCAM 2006)},
	year = {2006},
	month = {sep},
	pages = {127-138},
	publisher = {IEEE Computer Society},
	organization = {IEEE Computer Society},
	author = {F{\"u}l{\"o}p, L.J. and T. Gyovai and Rudolf Ferenc}
}
@conference {VGF06,
	title = {{From C++ Refactorings to Graph Transformations}},
	booktitle = {Electronic Communications of the EASST and Proceedings of the 3rd Workshop on Software Evolution through Transformations (Setra 2006)},
	year = {2006},
	month = {sep},
	pages = {127-141},
	publisher = {ECEASST},
	organization = {ECEASST},
	author = {L{\'a}szl{\'o} Vid{\'a}cs and M. Gogolla and Rudolf Ferenc}
}
@conference {BFG06,
	title = {{Towards Portable Metrics-based Models for Software Maintenance Problems}},
	booktitle = {Proceedings of the 22nd International Conference on Software Maintenance (ICSM 2006)},
	year = {2006},
	month = {sep},
	pages = {483-486},
	publisher = {IEEE Computer Society},
	organization = {IEEE Computer Society},
	author = {Tibor Bakota and Rudolf Ferenc and Tibor Gyim{\'o}thy and C. Riva and J. Xu}
}
@conference {BFG05,
	title = {{Columbus: A Reverse Engineering Approach}},
	booktitle = {Proceedings of the 13th IEEE Workshop on Software Technology and Engineering Practice (STEP 2005)},
	year = {2005},
	month = {sep},
	pages = {93-96},
	publisher = {IEEE Computer Society},
	organization = {IEEE Computer Society},
	author = {{\'A}rp{\'a}d Besz{\'e}des and Rudolf Ferenc and Tibor Gyim{\'o}thy}
}
@conference {FBF05,
	title = {{Design Pattern Mining Enhanced by Machine Learning}},
	booktitle = {Proceedings of the 21th International Conference on Software Maintenance (ICSM 2005)},
	year = {2005},
	month = {sep},
	pages = {295-304},
	publisher = {IEEE Computer Society},
	organization = {IEEE Computer Society},
	author = {Rudolf Ferenc and {\'A}rp{\'a}d Besz{\'e}des and F{\"u}l{\"o}p, L.J. and J. Lele}
}
@conference {GFS05,
	title = {{Empirical Validation of Object-Oriented Metrics on Open Source Software for Fault Prediction}},
	booktitle = {IEEE Transactions on Software Engineering},
	volume = {31},
	number = {10},
	year = {2005},
	month = {oct},
	pages = {897-910},
	publisher = {IEEE Computer Society},
	organization = {IEEE Computer Society},
	keywords = {relate:quality, software quality selected},
	author = {Tibor Gyim{\'o}thy and Rudolf Ferenc and Istv{\'a}n Siket}
}
@inbook {FBG04b,
	title = {{Tools for Software Maintenance and Reengineering}},
	year = {2005},
	pages = {16-31},
	publisher = {Franco Angeli Milano},
	organization = {Franco Angeli Milano},
	chapter = {{Extracting Facts with Columbus from C++ Code}},
	author = {Rudolf Ferenc and {\'A}rp{\'a}d Besz{\'e}des and Tibor Gyim{\'o}thy},
	editor = {Di Penta, Massimiliano and Harsu, Maarit}
}
@conference {SiF04,
	title = {Calculating Metrics from Large {C++} Programs},
	booktitle = {Proceedings of the 6th International Conference on Applied Informatics (ICAI2004)},
	year = {2004},
	month = {jan},
	pages = {319-328},
	author = {Istv{\'a}n Siket and Rudolf Ferenc}
}
@conference {VBF04,
	title = {{Columbus Schema for C/C++ Preprocessing}},
	booktitle = {Proceedings of the 8th European Conference on Software Maintenance and Reengineering (CSMR 2004)},
	year = {2004},
	month = {mar},
	pages = {75-84},
	publisher = {IEEE Computer Society},
	organization = {IEEE Computer Society},
	author = {L{\'a}szl{\'o} Vid{\'a}cs and {\'A}rp{\'a}d Besz{\'e}des and Rudolf Ferenc}
}
@conference {BFG04,
	title = {{CSiBE Benchmark: One Year Perspective and Plans}},
	booktitle = {Proceedings of the 2004 GCC Developers{\textquoteright} Summit},
	year = {2004},
	month = {jun},
	pages = {7-15},
	author = {{\'A}rp{\'a}d Besz{\'e}des and Rudolf Ferenc and Tam{\'a}s Gergely and Tibor Gyim{\'o}thy and G. L{\'o}ki and L{\'a}szl{\'o} Vid{\'a}cs}
}
@conference {FSG04,
	title = {{Extracting Facts from Open Source Software}},
	booktitle = {Proceedings of the 20th International Conference on Software Maintenance (ICSM 2004)},
	year = {2004},
	month = {sep},
	pages = {60-69},
	publisher = {IEEE Computer Society},
	organization = {IEEE Computer Society},
	author = {Rudolf Ferenc and Istv{\'a}n Siket and Tibor Gyim{\'o}thy}
}
@conference {FBG04,
	title = {{Extracting Facts with Columbus from C++ Code}},
	booktitle = {Tool Demonstrations of the 8th European Conference on Software Maintenance and Reengineering (CSMR 2004)},
	year = {2004},
	month = {mar},
	pages = {4-8},
	author = {Rudolf Ferenc and {\'A}rp{\'a}d Besz{\'e}des and Tibor Gyim{\'o}thy}
}
@conference {FBG04a,
	title = {{Fact Extraction and Code Auditing with Columbus and SourceAudit}},
	booktitle = {Proceedings of the 20th International Conference on Software Maintenance (ICSM 2004)},
	year = {2004},
	month = {sep},
	pages = {513},
	publisher = {IEEE Computer Society},
	organization = {IEEE Computer Society},
	author = {Rudolf Ferenc and {\'A}rp{\'a}d Besz{\'e}des and Tibor Gyim{\'o}thy}
}
@conference {FeB03,
	title = {{Az Objektumvez{\'e}relt Szoftverek Elemz{\'e}se.}},
	booktitle = {VIII. Orsz{\'a}gos (Centen{\'a}riumi) Neumann Kongresszus El{\~o}ad{\'a}sok {\'e}s {\"O}sszefoglal{\'o}k},
	year = {2003},
	month = {oct},
	pages = {463-474},
	publisher = {Neumann J{\'a}nos Sz{\'a}m{\'\i}t{\'o}g{\'e}p-tudom{\'a}nyi T{\'a}rsas{\'a}g},
	organization = {Neumann J{\'a}nos Sz{\'a}m{\'\i}t{\'o}g{\'e}p-tudom{\'a}nyi T{\'a}rsas{\'a}g},
	author = {Rudolf Ferenc and {\'A}rp{\'a}d Besz{\'e}des}
}
@conference {BaF03,
	title = {{Mining Design Patterns from C++ Source Code}},
	booktitle = {Proceedings of the 19th International Conference on Software Maintenance (ICSM 2003)},
	year = {2003},
	month = {sep},
	pages = {305-314},
	publisher = {IEEE Computer Society},
	organization = {IEEE Computer Society},
	doi = {http://dx.doi.org/10.1109/ICSM.2003.1235436},
	author = {Zs. Balanyi and Rudolf Ferenc}
}
@article {BFG03,
	title = {{Survey of Code-Size Reduction Methods}},
	journal = {ACM Computing Surveys},
	volume = {35},
	number = {3},
	year = {2003},
	month = {sep},
	pages = {223-267},
	keywords = {software quality selected},
	author = {{\'A}rp{\'a}d Besz{\'e}des and Rudolf Ferenc and Tibor Gyim{\'o}thy and A. Dolenc and K. Karsisto}
}
@conference {FBT02,
	title = {{Columbus {\textendash} Reverse Engineering Tool and Schema for C++}},
	booktitle = {Proceedings of the 18th International Conference on Software Maintenance (ICSM{\textquoteright}02)},
	year = {2002},
	month = {oct},
	pages = {172-181},
	publisher = {IEEE Computer Society},
	organization = {IEEE Computer Society},
	keywords = {relate:quality},
	author = {Rudolf Ferenc and {\'A}rp{\'a}d Besz{\'e}des and M. Tarkiainen and Tibor Gyim{\'o}thy}
}
@conference {FeB02,
	title = {{Data Exchange with the Columbus Schema for C++}},
	booktitle = {Proceedings of the 6th European Conference on Software Maintenance and Reengineering (CSMR 2002)},
	year = {2002},
	month = {mar},
	pages = {59-66},
	publisher = {IEEE Computer Society},
	organization = {IEEE Computer Society},
	author = {Rudolf Ferenc and {\'A}rp{\'a}d Besz{\'e}des}
}
@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 {FMB01,
	title = {{C}olumbus {\textendash} Tool for Reverse Engineering Large Object Oriented Software Systems},
	booktitle = {Proceedings of the Seventh Symposium on Programming Languages and Software Tools (SPLST 2001)},
	year = {2001},
	month = {jun},
	pages = {16-27},
	publisher = {University of Szeged},
	organization = {University of Szeged},
	author = {Rudolf Ferenc and F. Magyar and {\'A}rp{\'a}d Besz{\'e}des and {\'A}kos Kiss and M. Tarkiainen}
}
@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}
}
@booklet {Ferenc01ashort,
	title = {A short introduction to {Columbus/CAN}},
	year = {2001},
	author = {Rudolf Ferenc and {\'A}rp{\'a}d Besz{\'e}des and F. Magyar and Tibor Gyim{\'o}thy}
}
@conference {FSH01,
	title = {{Towards a Standard Schema for C/C++}},
	booktitle = {Proceedings of the 8th Working Conference on Reverse Engineering (WCRE 2001)},
	year = {2001},
	month = {oct},
	pages = {49-58},
	publisher = {IEEE Computer Society},
	organization = {IEEE Computer Society},
	author = {Rudolf Ferenc and S. E. Sim and R. C. Holt and R. Koschke and Tibor Gyim{\'o}thy}
}
@booklet {FMBe00,
	title = {Columbus 2.0 - Tool for Reverse Engineering Large Object Oriented Software Systems},
	year = {2000},
	publisher = {Research Group on Artificial Intelligence, Hungarian Academy of Sciences and University of Szeged},
	author = {Rudolf Ferenc and F. Magyar and {\'A}rp{\'a}d Besz{\'e}des and G. M{\'a}rton and M. Tarkiainen and Tibor Gyim{\'o}thy}
}
@booklet {Beszedes_anevaluation,
	title = {An Evaluation of Reverse Engineering Capabilities of the {TDE/Columbus} system},
	year = {1999},
	author = {{\'A}rp{\'a}d Besz{\'e}des and Rudolf Ferenc and Tibor Gyim{\'o}thy and F. Magyar and G. M{\'a}rton and M. Tarkianen}
}
@mastersthesis {Fer97,
	title = {Adatfolyam-diagramok glob{\'a}lis elemz{\'e}se. Inform{\'a}ci{\'o}s rendszer tervez{\'e}se SSADM-mel},
	year = {1997},
	type = {masters},
	author = {Rudolf Ferenc}
}
@booklet {AFR95,
	title = {V{\'a}llalati inform{\'a}ci{\'o}s rendszer elemz{\'e}se {\'e}s tervez{\'e}se {SSADM}-mel {\'e}s a DFD-k glob{\'a}lis anal{\'\i}zise},
	year = {1995},
	note = {TDK dolgozat},
	author = {P. Alb and Rudolf Ferenc and V. Rajda}
}
