Software Maintainability Research Articles

A fuzzy genetic automatic refactoring approach to improve software maintainability and flexibility

The creation of high-quality software is of great importance in the current state of the enterprise systems. High-quality software should contain certain features including flexibility, maintainability, and a well-designed structure. Correctly adhering to the object-oriented principles is a primary approach to make the code more flexible. Developers usually try to leverage these principles, but many times neglecting them due to the lack of time and the extra costs involved. Therefore, sometimes they create confusing, complex, and problematic structures in code known as code smells. Code smells have specific and well-known anti-patterns that can be corrected after their identification with the help of the refactoring techniques. This process can be performed either manually by the developers or automatically. In this paper, an automated method for identifying and refactoring a series of code smells in the Java programs is introduced. The primary mechanism used for performing such automated refactoring is by leveraging a fuzzy genetic method. Besides, a graph model is used as the core representation scheme along with the corresponding measures such as betweenness, load, in-degree, out-degree, and closeness centrality, to identify the code smells in the programs. Then, the applied fuzzy approach is combined with the genetic algorithm to refactor the code using the graph-related features. The proposed method is evaluated using the Freemind, Jag, JGraph, and JUnit as sample projects and compared the results against the Fontana dataset which contains results from IPlasma, FluidTool, Anti-patternScanner, PMD, and Maeinescu. It is shown that the proposed approach can identify on average 68.92% of the bad classes similar to the Fontana dataset and also refactor 77% of the classes correctly with respect to the coupling measures. This is a noteworthy result among the currently existing refactoring mechanisms and also among the studies that consider both the identification and the refactoring of the bad smells.

Analysis of COVID‐19 Mathematical and Software Models: Or How NOT to Set Up a Softward Project

This report discusses the open-source software that implements the COVID-19 model in [1] (announced March 16, 2020), led by Dr. Neil Ferguson of Imperial College London (ICL). My personal interest was to investigate how the model was implemented after having seen it described as a system of ordinary differential equations (ODEs) on BBC News on March 17, 2020. Anecdotal evidence suggests that the original program (written in C) is at least 20 years old and it is undocumented (nothing new in the software world; the programmers in this case probably thought it was not necessary to write readable and maintainable software). Furthermore, all the 15,000 lines of code were in a single file (sometimes called balls of mud). On April 22, 2020 a modified version (called 0.7.0, seemingly produced by Microsoft) appeared consisting of approximately 12 separate source files. This is the version of the program that we review in this article. We do not investigate the fixes that have been made between April 22 and the time of writing of this report. Finally, we note that version 0.7.0 is not an implementation of the ODEs that were announced on BBC News with great aplomb on the evening of Saint Patrick's Day 2020. For a discussion of ODEs in epidemiology, see [2]. Before I discovered that the ICL model was not ODE-based (seemingly contradicting the BBC announcement) I solved the MSEIR (iMmune, Susceptible, Exposed, Infective, Recovered) ODE model numerically in C++. The system of equations is relatively benign and we used the C++ Boost odeint library to solve them. (A word of advice: it is tempting to use the Euler method but don't use it, not even for producing cute S-curves in your blogs.) Summarizing, this report is a critique of the quality of 0.7.0 code based on my experience, background, and how I view software. I was unable to analyze the underlying mathematical model because it is not documented and the code is unreadable. However, I do have something to say about the (lack of) quality of code, random number generation (RNG), and (univariate) statistical distributions as these are of central importance in computational finance, an area in which I am involved (see [3], [4], [5], [6]). This critique is based on incomplete information, namely the bespoke open-source C code. I was unable to find further relevant documentation. Nonetheless, a robust review is still possible. Finally, this report has wider applicability than just the current software system. It pinpoints some of the things that can (and do) go badly wrong in software projects. I will distribute this report to my clients and students. I have been preaching the same “doctrine” for more than 30 years and now is a special opportunity to use it to shine a light to expose the shortcomings of such a high-profile project. It will be interesting to follow developments in the coming years. One reason for writing this report was to counter some of the technically superficial and somewhat partisan blogs written by what we flippantly call nameless internet warriors (see [17]). It is never clear to me if there are ulterior or political motives behind these blogs. They are irrelevant here. On the other hand, these kinds of blogs may provide more information on some structural problems in software projects (see [18] for some horror stories).

Predicting Code Smells and Analysis of Predictions: Using Machine Learning Techniques and Software Metrics

Code smell detection is essential to improve software quality, enhancing software maintainability, and decrease the risk of faults and failures in the software system. In this paper, we proposed a code smell prediction approach based on machine learning techniques and software metrics. The local interpretable model-agnostic explanations (LIME) algorithm was further used to explain the machine learning model’s predictions and interpretability. The datasets obtained from Fontana et al. were reformed and used to build binary-label and multi-label datasets. The results of 10-fold cross-validation show that the performance of tree-based algorithms (mainly Random Forest) is higher compared with kernel-based and network-based algorithms. The genetic algorithm based feature selection methods enhance the accuracy of these machine learning algorithms by selecting the most relevant features in each dataset. Moreover, the parameter optimization techniques based on the grid search algorithm significantly enhance the accuracy of all these algorithms. Finally, machine learning techniques have high potential in predicting the code smells, which contribute to detect these smells and enhance the software’s quality.

Multi‐view city‐based approach for code‐smell evolution visualisation

Code smells are indicators of inappropriate and possibly harmful design decisions that could lead to issues in the comprehensibility and maintainability of software systems. To avoid such quality complications, understanding the presence and prioritising the removal of code smells are required. This study presents a visualisation approach to help better understanding the evolutional characteristics of code smells presented in the different versions of the software system. The core of the visualisation approach is the metaphor of buildings and building blocks. An overall framework for detecting, categorising and visualising code smells is proposed. Three types of code smells were considered in this study. The considered code smells are God Class, Long Method and Type Checking. The applicability of the proposed approach is demonstrated by evaluating several versions of an open-source java software and visualising the detected code smells. Additionally, a pilot experimental study is conducted to empirically assure the usefulness of the proposed visualisations.

Code smell detection and identification in imbalanced environments

Context:Code smells are sub-optimal design choices that could lower software maintainability. Objective:Previous literature did not consider an important characteristic of the smell detection problem, namely data imbalance. When considering a high number of code smell types, the number of smelly classes is likely to largely exceed the number of non-smelly ones, and vice versa. Moreover, most studies did address the smell identification problem, which is more likely to present a higher imbalance as the number of smelly classes is relatively much less than the number of non-smelly ones. Furthermore, an additional research gap in the literature consists in the fact that the number of smell type identification methods is very small compared to the detection ones. Research gap:The main challenges in smell detection and identification in an imbalanced environment are: (1) the structuring of the smell detector that should be able to deal with complex splitting boundaries and small disjuncts, (2) the design of the detector quality evaluation function that should take into account data imbalance, and (3) the efficient search for effective software metrics’ thresholds that should well characterize the different smells. Furthermore, the number of smell type identification methods is very small compared to the detection ones. Method:We propose ADIODE, an effective search-based engine that is able to deal with all the above-described challenges not only for the smell detection case but also for the identification one. Indeed, ADIODE is an EA (Evolutionary Algorithm) that evolves a population of detectors encoded as ODTs (Oblique Decision Trees) using the F-measure as a fitness function. This allows ADIODE to efficiently approximate globally-optimal detectors with effective oblique splitting hyper-planes and metrics’ thresholds. We note that to build the BE, each software class is parsed using a particular tool with the aim to extract its metrics’ values, based on which the considered class is labeled by means of a set of existing advisors; which could be seen as a two-step construction process. Results:A comparative experimental study on six open-source software systems demonstrates the merits and the outperformance of our approach compared to four of the most representative and prominent baseline techniques available in literature. The detection results show that the F-measure of ADIODE ranges between 91.23 % and 95.24 %, and its AUC lies between 0.9273 and 0.9573. Similarly, the identification results indicate that the F-measure of ADIODE varies between 86.26 % and 94.5 %, and its AUC is between 0.8653 and 0.9531.

Machine Learning Techniques for Software Maintainability Prediction: Accuracy Analysis

Maintaining software once implemented on the end-user side is laborious and, over its lifetime, is most often considerably more expensive than the initial software development. The prediction of software maintainability has emerged as an important research topic to address industry expectations for reducing costs, in particular, maintenance costs. Researchers and practitioners have been working on proposing and identifying a variety of techniques ranging from statistical to machine learning (ML) for better prediction of software maintainability. This review has been carried out to analyze the empirical evidence on the accuracy of software product maintainability prediction (SPMP) using ML techniques. This paper analyzes and discusses the findings of 77 selected studies published from 2000 to 2018 according to the following criteria: maintainability prediction techniques, validation methods, accuracy criteria, overall accuracy of ML techniques, and the techniques offering the best performance. The review process followed the well-known systematic review process. The results show that ML techniques are frequently used in predicting maintainability. In particular, artificial neural network (ANN), support vector machine/regression (SVM/R), regression & decision trees (DT), and fuzzy & neuro fuzzy (FNF) techniques are more accurate in terms of PRED and MMRE. The N-fold and leave-one-out cross-validation methods, and the MMRE and PRED accuracy criteria are frequently used in empirical studies. In general, ML techniques outperformed non-machine learning techniques, e.g., regression analysis (RA) techniques, while FNF outperformed SVM/R, DT, and ANN in most experiments. However, while many techniques were reported superior, no specific one can be identified as the best.

A New Metaheuristic-Based Hierarchical Clustering Algorithm for Software Modularization

Software refactoring is a software maintenance action to improve the software internal quality without changing its external behavior. During the maintenance process, structural refactoring is performed by remodularizing the source code. Software clustering is a modularization technique to remodularize artifacts of source code aiming to improve readability and reusability. Due to the NP hardness of the clustering problem, evolutionary approaches such as the genetic algorithm have been used to solve this problem. In the structural refactoring literature, there exists no search-based algorithm that employs a hierarchical approach for modularization. Utilizing global and local search strategies, in this paper, a new search-based top-down hierarchical clustering approach, named TDHC, is proposed that can be used to modularize the system. The output of the algorithm is a tree in which each node is an artifact composed of all artifacts in its subtrees and is a candidate to be a software module (i.e., cluster). This tree helps a software maintainer to have better vision on source code structure to decide appropriate composition points of artifacts aiming to create modules (i.e., files, packages, and components). Experimental results on seven folders of Mozilla Firefox with different functionalities and five other software systems show that the TDHC produces modularization closer to the human expert’s decomposition (i.e., directory structure) than the other existing algorithms. The proposed algorithm is expected to help a software maintainer for better remodularization of a source code. The source codes and dataset related to this paper can be accessed at https://github.com/SoftwareMaintenanceLab.

An empirical investigation on the relationship between design and architecture smells

Architecture of a software system represents the key design decisions and therefore its quality plays an important role to keep the software maintainable. Code smells are indicators of quality issues in a software system and are classified based on their granularity, scope, and impact. Despite a plethora of existing work on smells, a detailed exploration of architecture smells, their characteristics, and their relationships with smells in other granularities is missing. The paper aims to study architecture smells characteristics, investigate correlation, collocation, and causation relationships between architecture and design smells. We implement smell detection support for seven architecture smells. We mine 3 073 open-source repositories containing more than 118 million lines of C# code and empirically investigate the relationships between seven architecture and 19 design smells. We find that smell density does not depend on repository size. Cumulatively, architecture smells are highly correlated with design smells. Our collocation analysis finds that the majority of design and architecture smell pairs do not exhibit collocation. Finally, our causality analysis reveals that design smells cause architecture smells.

Measuring Maintainability of Object Oriented Design: A Revisit

Maintainability has always been an elusive concept. Software maintainability is an external software quality attributes that estimate the complexity and effort required for maintaining software. The key concern of this review paper will be organized study on maintainability considering in view by its sub factors and metrics implementation of software maintainability keeping in mind to supports the maintenance process and facilitates the formation of improved quality software. In this paper studies accomplish a systematic literature review to have widespread facts of maintainability research and its feature factors and related measurements. Finally, study does a comparative analysis on software maintainability models developed by various researchers/area experts including their contribution and limitation. In last our effort is to find the known wide-ranging and complete model or framework for quantifying the maintainability of object-oriented software at an initial stage of the development life cycle.

An empirical study on predictability of software maintainability using imbalanced data

In software engineering predictive modeling, early prediction of software modules or classes that possess high maintainability effort is a challenging task. Many prediction models are constructed to predict the maintainability of software classes or modules by applying various machine learning (ML) techniques. If the software modules or classes need high maintainability, effort would be reduced in a dataset, and there would be imbalanced data to train the model. The imbalanced datasets make ML techniques bias their predictions towards low maintainability effort or majority classes, and minority class instances get discarded as noise by the machine learning (ML) techniques. In this direction, this paper presents empirical work to improve the performance of software maintainability prediction (SMP) models developed with ML techniques using imbalanced data. For developing the models, the imbalanced data is pre-processed by applying data resampling methods. Fourteen data resampling methods, including oversampling, undersampling, and hybrid resampling, are used in the study. The study results recommend that the safe-level synthetic minority oversampling technique (Safe-Level-SMOTE) is a useful method to deal with the imbalanced datasets and to develop competent prediction models to forecast software maintainability.

A Tool-Based Perspective on Software Code Maintainability Metrics: A Systematic Literature Review

Software maintainability is a crucial property of software projects. It can be defined as the ease with which a software system or component can be modified to be corrected, improved, or adapted to its environment. The software engineering literature proposes many models and metrics to predict the maintainability of a software project statically. However, there is no common accordance with the most dependable metrics or metric suites to evaluate such nonfunctional property. The goals of the present manuscript are as follows: (i) providing an overview of the most popular maintainability metrics according to the related literature; (ii) finding what tools are available to evaluate software maintainability; and (iii) linking the most popular metrics with the available tools and the most common programming languages. To this end, we performed a systematic literature review, following Kitchenham’s SLR guidelines, on the most relevant scientific digital libraries. The SLR outcome provided us with 174 software metrics, among which we identified a set of 15 most commonly mentioned ones, and 19 metric computation tools available to practitioners. We found optimal sets of at most five tools to cover all the most commonly mentioned metrics. The results also highlight missing tool coverage for some metrics on commonly used programming languages and minimal coverage of metrics for newer or less popular programming languages. We consider these results valuable for researchers and practitioners who want to find the best selection of tools to evaluate the maintainability of their projects or to bridge the discussed coverage gaps for newer programming languages.

Software maintainability prediction of open source datasets using least squares support vector machines

Software Maintainability (SM), being one of the priciest and tedious phases of any software development life cycle, has drawn the attention of various researchers over the years. SM measures the ease of carrying out maintenance activities such as repair and improvement of software code as per the changing needs of the customer and should be predicted well in advance. The current study implements the Least Squares Support Vector Machines (LS-SVM) algorithm for SM Prediction (SMP) on six open source datasets, namely Abdera, Ivy, jEdit, Log4j, Poi, and Rave. MAE, RMSE, and MMRE are considered as the prediction accuracy measures to evaluate the performance. Results indicate that LS-SVM is a potentially viable tool for predicting maintainability. Best results are obtained with jEdit dataset having minimum values for MAE, RMSE, and MMRE, i.e. 20.38, 46.97, and 1.02, respectively; jEdit having high component stability with lesser number of changes.

Impact of Historical Software Metric Changes in Predicting Future Maintainability Trends in Open-Source Software Development

Software maintenance is one of the key stages in the software lifecycle and it includes a variety of activities that consume the significant portion of the costs of a software project. Previous research suggest that future software maintainability can be predicted, based on various source code aspects, but most of the research focuses on the prediction based on the present state of the code and ignores its history. While taking the history into account in software maintainability prediction seems intuitive, the research empirically testing this has not been done, and is the main goal of this paper. This paper empirically evaluates the contribution of historical measurements of the Chidamber & Kemerer (C&K) software metrics to software maintainability prediction models. The main contribution of the paper is the building of the prediction models with classification and regression trees and random forest learners in iterations by adding historical measurement data extracted from previous releases gradually. The maintainability prediction models were built based on software metric measurements obtained from real-world open-source software projects. The analysis of the results show that an additional amount of historical metric measurements contributes to the maintainability prediction. Additionally, the study evaluates the contribution of individual C&K software metrics on the performance of maintainability prediction models.

A systematic literature review on empirical studies towards prediction of software maintainability

Software maintainability prediction in the earlier stages of software development involves the construction of models for the accurate estimation of maintenance effort. This guides the software practitioners to manage the resources optimally. This study aims at systematically reviewing the prediction models from January 1990 to October 2019 for predicting software maintainability. We analyze the effectiveness of these models according to various aspects. To meet the goal of the research, we have identified 36 research papers. On investigating these papers, we found that various machine learning (ML), statistical (ST), and hybridized (HB) techniques have been applied to develop prediction models to predict software maintainability. The significant finding of this review is that the overall performance of ML-based models is better than that of ST models. The use of HB techniques for prediction of software maintainability is limited. The results of this review revealed that software maintainability prediction (SMP) models developed using ML techniques outperformed models developed using ST techniques. Also, the prediction performance of few models developed using HB techniques is encouraging, yet no conclusive results about the performance of HB techniques could be reported because different HB techniques are applied in a few studies.

Pre-exascale accelerated application development: The ORNL Summit experience

High-performance computing (HPC) increasingly relies on heterogeneous architectures to achieve higher performance. In the Oak Ridge Leadership Facility (OLCF), Oak Ridge, TN, USA, this trend continues as its latest supercomputer, Summit, entered production in early 2019. The combination of IBM POWER9 CPU and NVIDIA V100 GPU, along with a fast NVLink2 interconnect and other latest technologies, pushes system performance to a new height and breaks the exascale barrier by certain measures. Due to Summit's powerful GPUs and much higher GPU–CPU ratio, offloading to accelerators becomes a requirement for any application, which intends to effectively use the system. To facilitate navigating a complex landscape of competing heterogeneous architectures, a collection of applications from a wide spectrum of scientific domains is selected for early adoption on Summit. In this article, the experience and lessons learned are summarized, in the hope of providing useful guidance to address new programming challenges, such as scalability, performance portability, and software maintainability, for future application development efforts on heterogeneous HPC systems.

Using Ensembles for Class-Imbalance Problem to Predict Maintainability of Open Source Software

To facilitate software maintenance and save the maintenance cost, numerous machine learning (ML) techniques have been studied to predict the maintainability of software modules or classes. An abundant amount of effort has been put by the research community to develop software maintainability prediction (SMP) models by relating software metrics to the maintainability of modules or classes. When software classes demanding the high maintainability effort (HME) are less as compared to the low maintainability effort (LME) classes, the situation leads to imbalanced datasets for training the SMP models. The imbalanced class distribution in SMP datasets could be a dilemma for various ML techniques because, in the case of an imbalanced dataset, minority class instances are either misclassified by the ML techniques or get discarded as noise. The recent development in predictive modeling has ascertained that ensemble techniques can boost the performance of ML techniques by collating their predictions. Ensembles themselves do not solve the class-imbalance problem much. However, aggregation of ensemble techniques with the certain techniques to handle class-imbalance problem (e.g., data resampling) has led to several proposals in research. This paper evaluates the performance of ensembles for the class-imbalance in the domain of SMP. The ensembles for class-imbalance problem (ECIP) are the modification of ensembles which pre-process the imbalanced data using data resampling before the learning process. This study experimentally compares the performance of several ECIP using performance metrics Balance and g-Mean over eight Apache software datasets. The results of the study advocate that for imbalanced datasets, ECIP improves the performance of SMP models as compared to classic ensembles.

Software maintainability prediction using an enhanced random forest algorithm

Now-a-days, software maintainability has become one of the significant quality-assessing attributes for any software system. Current study presents an enhanced-RFA (Random Forest Algorithm) approach for Software Maintainability Prediction. The proposed approach combines Random Forest (RF) algorithm with three prevalent feature selection techniques namely Chi-Squared, RF and Linear Correlation Filter along with a re-sampling technique intended to improve the prediction accuracy of basic RF algorithm. Enhanced- RFA is applied on two commercially available datasets, QUES and UIMS and performance is evaluated on the basis of R2. Results indicate that the proposed approach performs significantly better than RFA for both the datasets with an improvement in R2 values equal to 69.50%, 65.57% & 69.40% for QUES and 31.90%, 44.94% & 51.81% for UIMS using chisquared, RF and linear correlation filter techniques respectively.

Assessing Cross-Project Technique for Software Maintainability Prediction

Software Maintainability refers to the ease with which software maintenance activities like correction of faults, deletion of obsolete code, addition of new code etc. can be carried out to adapt to the modified environment. Predicting maintainability in early stages of development helps in reducing the cost of maintenance and ensures optimum utilization of resources. Sometimes, it becomes difficult to train prediction models using historical data of the same dataset for which the model is being developed because of the unavailability of sufficient amount of training data, in turn making a way for Cross-Project technique for Software Maintainability Prediction (CPSMP). In order to evaluate the proposed CPSMP technique, QUES dataset is used as training set and UIMS dataset is used as test set in this study with 19 different regression modelling methods. Performance of CPSMP model is evaluated using Root Mean Square Error (RMSE) as an accuracy measure. Results show that cross-project technique can successfully be applied for maintainability prediction. The average RMSE value calculated for all the modelling methods is found to be 82.310 without CPSMP whereas an average RMSE value of 71.532 is obtained with CPSMP resulting in an overall improvement in prediction performance by 13.09%. Also, 84.21% of the total techniques used in this study performed better with CPSMP.

Code Refactoring Strategies for DevOps: Improving Software Maintainability and Scalability

This article, investigates how strategic code refactoring can enhance software quality in a DevOps environment. The objective is to explore and analyze refactoring techniques that improve both software maintainability and scalability. The study finds that effective refactoring practices, such as decomposing monolithic architectures into microservices, optimizing database interactions, and leveraging asynchronous processing, significantly enhance software scalability. Concurrently, refactoring techniques that address code smells, simplify complex structures, and promote modularity are crucial for improving maintainability. Automation of these strategies through tools and Infrastructure as Code (IaC) further supports scalable and efficient software management. The significance of these findings lies in their potential to improve software performance and adaptability in dynamic DevOps environments. Policy implications include the need for organizations to integrate these refactoring practices into their development and deployment processes to sustain high-quality software and effectively manage scaling challenges. Adopting these strategies will support robust, agile development and competitive advantage in the evolving software landscape.

Automated Regression Testing for Web Services

Web services represent class of applications developed through open internet standards. They help to develop dynamic applications and thus are used to deliver business components or functionalities on the web. Business functionalities as per changing market scenarios are frequently changing and so are these web services. It is therefore the need to properly ensure quality of these web services as they are essential to deliver functions which are required for organizations in their strategic business. To maintain desired level of quality, software maintainability of such applications is important. Regression Testing is required for proper maintaining any software and it becomes very costly in terms of cost and labor for constantly changing applications. Thus to reduce maintenance cost we need to reduce effort required in such testing. This paper presents an efficient regression testing strategy which is also automated to reduce the regression costs of web services. The strategy is implemented through an extensive framework supported by automation and also integrates data testing with regression. The proposed work is particularly useful for those applications which are delivered over web.