@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}
}
@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 {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 {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}
}
@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}
}
@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 {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}
}
@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 {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 {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 {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 {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 {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 {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 {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}
}
@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}
}
