@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}
}
@conference {SCAM:CG:COMPARE,
	title = {{Static JavaScript Call Graphs: a Comparative Study}},
	booktitle = {Proceedings of the 18th IEEE International Working Conference on Source Code Analysis and Manipulation},
	year = {2018},
	publisher = {IEEE},
	organization = {IEEE},
	author = {Antal, G{\'a}bor and Heged{\H u}s, P{\'e}ter and T{\'o}th, Zolt{\'a}n and Ferenc, Rudolf and Tibor Gyim{\'o}thy}
}
@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 {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 {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}
}
@mastersthesis {Heg15,
	title = {Advances in Software Product Quality Measurement and its Applications in Software Evolution},
	year = {2015},
	note = {Supervisor: Rudolf Ferenc},
	school = {University of Szeged},
	type = {phdphdthesis},
	address = {Szeged, Hungary},
	url = {http://doktori.bibl.u-szeged.hu/2265/},
	author = {P Heged{\H u}s}
}
@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 {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 {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 {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 {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}
}
@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}
}
@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}
}
@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}
}
@article {16348,
	title = {A probabilistic quality model for c$\#$ - an industrial case study},
	journal = {ACTA CYBERNETICA - SZEGED},
	volume = {21},
	year = {2013},
	pages = {135{\textendash}147},
	issn = {0324-721X},
	author = {P Heged{\H u}s}
}
@conference {16365,
	title = {Relating clusterization measures and software quality},
	booktitle = {CSMR{\textquoteright}13},
	year = {2013},
	pages = {345{\textendash}348},
	publisher = {IEEE Computer Society},
	organization = {IEEE Computer Society},
	address = {Los Alamitos},
	author = {B. Csaba and Schrettner, L. and {\'A}rp{\'a}d Besz{\'e}des and Judit J{\'a}sz and P Heged{\H u}s and Tibor Gyim{\'o}thy},
	editor = {Anthony Cleve and Filippo Ricca and Maura Cerioli}
}
@conference {16367,
	title = {Revealing the Effect of Coding Practices on Software Maintainability},
	booktitle = {2013 IEEE International Conference on Software Maintenance},
	year = {2013},
	pages = {578{\textendash}581},
	publisher = {IEEE Computer Society Press},
	organization = {IEEE Computer Society Press},
	address = {Los Alamitos},
	author = {P Heged{\H u}s and Alexander Serebrenik and Tom Mens and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
	editor = {Lisa O{\textquoteright}Conner}
}
@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 {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 {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 {16332,
	title = {A Probabilistic Software Quality Model for C$\#$ {\textendash} an Industrial Case Study},
	year = {2012},
	publisher = {Department of Informatics, University of Szeged},
	organization = {Department of Informatics, University of Szeged},
	author = {P Heged{\H u}s}
}
@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 {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}
}
@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}
}
@conference {THJ10,
	title = {Comparison of Different Impact Analysis Methods and Programmer{\textquoteright}s Opinion {\textendash} an Empirical Study},
	booktitle = {Proceedings of the 8th International Conference on the Principles and Practice of Programming in Java (PPPJ{\textquoteright}10)},
	year = {2010},
	pages = {109-118},
	publisher = {ACM},
	organization = {ACM},
	author = {T{\'o}th, G. and P Heged{\H u}s and Judit J{\'a}sz and {\'A}rp{\'a}d Besz{\'e}des and Tibor Gyim{\'o}thy}
}
@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}
}
@conference {KBH10,
	title = {{DPDX} {\textendash} A Common Exchange Format for Design Pattern Detection Tools},
	booktitle = {14th European Conference on Software Maintenance and Reengineering (CSMR 2010)},
	year = {2010},
	month = {mar},
	pages = {232-235},
	author = {G. Kniesel and A. Binun and P Heged{\H u}s and F{\"u}l{\"o}p, L.J. and A. Chatzigeorgiou and Y.-G. Gueheneuc and N. Tsantalis}
}
@booklet {KBH09,
	title = {A common exchange format for design pattern detection tools},
	year = {2009},
	note = {IAI-TR-2009-03},
	author = {G. Kniesel and A. Binun and P Heged{\H u}s and F{\"u}l{\"o}p, L.J. and A. Chatzigeorgiou and Y.-G. Gueheneuc and N. Tsantalis}
}
@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}
}
@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 {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 {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}
}
