Peter Hegedus

A cost model based on software maintainability

In this paper we present a maintainability based model for estimating the costs of developing source code in its evolution phase. Our model adopts the concept of entropy in thermodynamics, which is used to measure the disorder of a system. In our model, we use maintainability for measuring disorder (i.e. entropy) of the source code of a software system. We evaluated our model on three proprietary and two open source real world software systems implemented in Java, and found that the maintainability of these evolving software is decreasing over time. Furthermore, maintainability and development costs are in exponential relationship with each other. We also found that our model is able to predict future development costs with high accuracy in these systems.

Qualitygate SourceAudit: A tool for assessing the technical quality of software

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.

Towards a Benchmark for Evaluating Reverse Engineering Tools

In this paper we present work in progress towards implementing a benchmark called BEFRIEND (benchmark for reverse engineering tools working on source code), with which the outputs of reverse engineering tools can be evaluated and compared easily and efficiently. Such tools are e.g. design pattern miners, duplicated code detectors and coding rule violation checkers. BEFRIEND supports different kinds of tool families, programming languages and software systems, and it enables the users to define their own evaluation criteria.

A Probabilistic Quality Model for C# - an Industrial Case Study

Both for software developers and managers it is crucial to have clues about different aspects of the quality of their systems. Maintainability is probably the most attractive, observed and evaluated quality characteristic of all. The importance of maintainability lies in its very obvious and direct connection with the costs of altering the behavior of the software. In this paper we present an existing approach and its adaptation to the C# language for estimating the maintainability of the source code. We used our model to assess the maintainability of the C# components of a large international company. We analyzed almost a million lines of code and evaluated the results with the help of IT professionals of our industrial partner. The application of our method and model was successful as the opinions of the developers showed a 0.92 correlation with the maintainability values produced by our C# maintainability model.

Connection between version control operations and quality change of the source code

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.

DPDX--Towards a Common Result Exchange Format for Design Pattern Detection Tools

Tools for design pattern detection (DPD) can ease program comprehension, helping programmers understand the design and intention of certain parts of a system’s implementation. Many tools have been proposed in the past. However, the many different output formats used by the tools make it difficult to compare their results and to improve their accuracy and performance through data fusion. In addition, all the output formats have been shown to have several limitations in both their forms and contents. Consequently, we develop DPDX, a rich common exchange format for DPD tools, to overcome previous limitations. DPDX provides the basis for an open federation of tools that perform comparison, fusion, visualisation, and–or validation of DPD results.

A Code Refactoring Dataset and Its Assessment Regarding Software Maintainability

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.

Cumulative code churn: Impact on maintainability

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.

Impact of Version History Metrics on Maintainability

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.

Development of a Methodology, Software -- Suite and Service for Supporting Software Architecture Reconstruction

Having an up-to-date knowledge of the architecture of a software system is of primary importance, since it affects every aspect of software development. It aids under-standing the system, helps defining high level conditions and constraints for making decisions, supports dependency analysis, logical grouping of components, evaluation of high level design, etc. During the evolution of a software, the documentation of its architecture may not be maintained because of the strict deadlines, resulting in an increasing gap between the architectural design and implementation. The national grant project named GOP-1.1.1-07/1-2008-0077 sponsored by the New Hungarian Development Plan, supports the development of appropriate tools for automatic architecture reconstruction and reverse engineering of software systems. The project will result in a complex solution for automatic architecture reconstruction of software systems by offering both a flexible and highly customizable set of services and a state-of-the-art boxed product. On one hand, architecture reconstruction in the scope of the project deals with visualization of the components and their relations. On the other hand, tracking the changes of the architectural elements during software evolution will also be supported. The tools of the project are being developed by FrontEndART Ltd. while the theoretical and technological background is provided by the Department of Software Engineering at University of Szeged.