Software Metrics Research Articles

Mobile response system: a novel approach to interactive and hands-on activity in the classroom

Mobile devices are being used profusely in the classrooms to improve passive learning environments and to enhance student comprehension. However, with respect to students’ active involvement in problem solving activities, the typical usage of the mobile devices in answering multiple choice and true/false questions is not adequate and the use of mobile devices need to be expanded to include dynamic and interactive problem-solving activities to better satisfy students’ learning needs. To facilitate such interactive problem solving using mobile devices, a comprehensive software environment is necessary. This paper details the design, deployment and evaluation of Mobile Response System (MRS) software that facilitates execution and assessment of multi-step in-class interactive problem-solving activities using mobile devices. MRS is an active learning tool, which engages students with the visual representation of a problem that spans on multiple screens, allows them to interact with that, and makes them realize the consequences of their actions instantly and visually. The immediate and automated grading feature of MRS enables a feedback-driven and evidence-based teaching methodology, which is important to improve the quality of classroom learning. MRS is designed to be independent of any interactive problem or its domain. Therefore, it allows easier integration of interactive activity Apps developed by others and can be used in any discipline. The results obtained from software metrics and runtime performance data verified the quality of the software. Additionally, the in-class assessment data verified that the MRS software is a helpful intervention for improving student comprehension and satisfaction.

Three-dimensional Simulation System based Intelligent Object-oriented Paradigm for Conducting Physics Experiments

Despite the large number of studies conducted in the area of simulation, yet there are no generic paradigms or even architectures for developing three-dimensional (3D) simulation applications with autonomous intelligent objects. This paper introduces a novel intelligent 3D simulation system to support conducting experiments in Physics. First of all, an intelligent object-oriented paradigm is proposed with the aim of system development. Accordingly, the physical work-cell entities of each experiment are modeled through defining their attributes and methods inside objects or classes of an application hierarchy. Then, we construct a knowledge base (KB) documents the rules/algorithms which work on the data entities and 3D objects using two kinds of object rules, namely: property, and action rules. The student’s simulation layer allows him/her using the system to walk through the virtual Physics lab based on a pre-defined walking model. S/he can access the simulation area to conduct experiments based on mathematical collision detection. In terms of software engineering, the system makes the Physics experiments easier by making more modular and reusable their applicable parts. Furthermore, a major pedagogical goal is achieved through allowing the learner tuning parameters, fix a part of a device and visualize output. This gives him/her a good explanation by visualizing how different parameters influence the experiment results. The Weighted Methods per Class (WMC), and the Reusability rank (RR) are the software metrics used to validate the proposed system. Furthermore, the experimental scenario is executed by applying the proposed system to students to estimate its caliber and efficiency. For measuring students’ performance, we used one exploratory group depending on pre/ and post-tests. The results reveal the contribution of the system to learners’ performance regarding Physics experimentation.

Actionable Analytics for Strategic Maintenance of Critical Software: An Industry Experience Report

NASA has been successfully sustaining the continuous operation of its critical navigation software systems for over 12 years. To accomplish this, NASA scientists must continuously monitor their process, report on current system quality, forecast maintenance effort, and sustain required staffing levels. This report presents some examples of the use of a robust software metrics and analytics program that enables actionable strategic maintenance management of a critical system (Monte) in a timely, economical, and risk-controlled fashion. This article is part of a special issue on Actionable Analytics for Software Engineering.

Hybrid K-means with neural network based Binary Cuckoo Search technique: a classifier for fault prediction in acceptance testing

We propose a meta heuristic method using Binary Cuckoo Search to classify the generated test cases that helps to improve the test suite quality. In our proposed method, test cases for acceptance testing of our case study Hospital Management System are generated automatically through the existing tool, Code Pro, and then clustered by using K-means clustering algorithm. Then, the clustered test cases are classified according to their fault detection capability. We propose a novel classifier, hybrid K-means with neural network based Binary Cuckoo Search technique, for classification of generated test cases into two classes, faulty and faultless. The classified result is experimentally evaluated against the existing software metrics, average percentage of faults detected (APFD), problem tracking reports (PTR), and time and memory usage. From the experimental results, we observe that the average percentage of fault detected in our approach is higher than the existing method.

Hybrid K-means with neural network based Binary Cuckoo Search technique: a classifier for fault prediction in acceptance testing

We propose a meta heuristic method using Binary Cuckoo Search to classify the generated test cases that helps to improve the test suite quality. In our proposed method, test cases for acceptance testing of our case study Hospital Management System are generated automatically through the existing tool, Code Pro, and then clustered by using K-means clustering algorithm. Then, the clustered test cases are classified according to their fault detection capability. We propose a novel classifier, hybrid K-means with neural network based Binary Cuckoo Search technique, for classification of generated test cases into two classes, faulty and faultless. The classified result is experimentally evaluated against the existing software metrics, average percentage of faults detected (APFD), problem tracking reports (PTR), and time and memory usage. From the experimental results, we observe that the average percentage of fault detected in our approach is higher than the existing method.

A Framework for Software Defect Prediction and Metric Selection

Automated software defect prediction is an important and fundamental activity in the domain of software development. However, modern software systems are inherently large and complex with numerous correlated metrics that capture different aspects of the software components. This large number of correlated metrics makes building a software defect prediction model very complex. Thus, identifying and selecting a subset of metrics that enhance the software defect prediction method’s performance are an important but challenging problem that has received little attention in the literature. The main objective of this paper is to identify significant software metrics, to build and evaluate an automated software defect prediction model. We propose two novel hybrid software defect prediction models to identify the significant attributes (metrics) using a combination of wrapper and filter techniques. The novelty of our approach is that it embeds the metric selection and training processes of software defect prediction as a single process while reducing the measurement overhead significantly. Different wrapper approaches were combined, including SVM and ANN, with a maximum relevance filter approach to find the significant metrics. A filter score was injected into the wrapper selection process in the proposed approaches to direct the search process efficiently to identify significant metrics. Experimental results with real defect-prone software data sets show that the proposed hybrid approaches achieve significantly compact metrics (i.e., selecting the most significant metrics) with high prediction accuracy compared with conventional wrapper or filter approaches. The performance of the proposed framework has also been verified using a statistical multivariate quality control process using multivariate exponentially weighted moving average. The proposed framework demonstrates that the hybrid heuristic can guide the metric selection process in a computationally efficient way by integrating the intrinsic characteristics from the filters into the wrapper and using the advantages of both the filter and wrapper approaches.

A Suite of Object Oriented Cognitive Complexity Metrics

Object orientation has gained a wide adoption in the software development community. To this end, different metrics that can be utilized in measuring and improving the quality of object-oriented (OO) software have been proposed, by providing insight into the maintainability and reliability of the system. Some of these software metrics are based on cognitive weight and are referred to as cognitive complexity metrics. It is our objective in this paper to present a suite of cognitive complexity metrics that can be used to evaluate OO software projects. The present suite of metrics includes method complexity, message complexity, attribute complexity, weighted class complexity, and code complexity. The metrics suite was evaluated theoretically using measurement theory and Weyuker’s properties, practically using Kaner’s framework and empirically using thirty projects.

SPMDL

Software metrics are becoming more acceptable measures for software quality assessment. However, there is no standard form to represent metric definitions, which would be useful for metrics exchange and customization. In this article, we propose the Software Product Metrics Definition Language (SPMDL). We develop an XML-based description language to define software metrics in a precise and reusable form. Metric definitions in SPMDL are based on meta-models extracted from either source code or design artifacts, such as the Dagstuhl Middle Meta-model, with support for various abstraction levels. The language defines several flexible computation mechanisms, such as extended Object Constraint Language queries and predefined graph operations on the meta-model. SPMDL provides an unambiguous description of the metric definition; it is also easy to use and is extensible.

Determining the Tested Classes with Software Metrics

Early detection and correction of errors appearing in software projects reduces the risk of exceeding the estimated time and cost. An efficient and effective test plan should be implemented to detect potential errors as early as possible. In the earlier phases, codes can be analyzed by efficiently employing software metric and insight can be gained about error susceptibility and measures can be taken if necessary. It is possible to classify software metric according to the time of collecting data, information used in the measurement, type and interval of the data generated. Considering software metric depending on the type and interval of the data generated, object-oriented software metric is widely used in the literature. There are three main metric sets used for software projects that are developed as object-oriented. These are Chidamber & Kemerer, MOOD and QMOOD metric sets. In this study, an approach for identifying the classes that should primarily be tested has been developed by using the object-oriented software metric. Then, this approach is applied for selected versions of the project developed. According to the results obtained, the correct determination rate of sum of the metrics method, which was developed to identify the classes that should primarily be tested, is ranged between 55% and 68%. In the random selection method, which was used to make comparisons, the correct determination rate for identifying the classes that should primarily be tested is ranged between 9.23% and 11.05%. In the results obtained using sum of the metrics method, a significant rate of improvement is observed compared to the random selection method.

Esophagogastric junction and esophageal body contraction metrics on high-resolution manometry predict esophageal acid burden.

Distal contractile integral (DCI) and esophagogastric junction contractile integral (EGJ-CI) are high-resolution manometry (HRM) software metrics assessing esophageal motor function in gastroesophageal reflux disease (GERD). Patients undergoing HRM and ambulatory pH monitoring off antisecretory therapy prospectively completed symptom questionnaires assessing symptom burden and a global symptom score (GSS) at baseline and after GERD therapy. DCI<450mmHg/cm/s in ≥5 swallows diagnosed ineffective esophageal motility (IEM); proportions of failed (DCI<100mmHg/cm/s) and weak (DCI 100-450mmHg/cm/s) sequences were separately assessed. EGJ-CI assessed vigor of the EGJ barrier. Univariate and multivariate analyses addressed performance of esophageal body and EGJ metrics in predicting abnormal esophageal reflux burden, and symptom outcome from antireflux therapy. Of 188 patients (55.2±0.9year, 64% F), 42.6% had low EGJ-CI, and 25.0% had IEM. While low EGJ-CI was associated with abnormal reflux burden (P=0.003), IEM alone was not (P=0.2). Increasing proportions of failed swallows predicted abnormal AET better than the current IEM definition. Combined low EGJ-CI and IEM segregated abnormal total and supine acid burden compared to patients with normal EGJ-CI and no IEM (P≤0.007 for each comparison). Medical therapy and surgical antireflux therapy were similarly effective in improving symptom burden; surgery resulted in better outcomes with low EGJ-CI (P≤0.04), especially with intact esophageal body motor function (P=0.02). While abnormal EGJ and esophageal body metrics are collectively associated with elevated esophageal reflux burden, increasing proportions of failed swallows are better predictors of reflux burden and outcome compared to the current IEM definition.

A novel Bayes defect predictor based on information diffusion function

Software defect prediction plays a significant part in identifying the most defect-prone modules before software testing. Quite a number of researchers have made great efforts to improve prediction accuracy. However, the problem of insufficient historical data available for within- or cross- project still remains unresolved. Further, it is common practice to use the probability density function for a normal distribution in Naïve Bayes (NB) classifier. Nevertheless, after performing a Kolmogorov–Smirnov test, we find that the 21 main software metrics are not normally distributed at the 5% significance level. Therefore, this paper proposes a new Bayes classifier, which evolves NB classifier with non-normal information diffusion function, to help solve the problem of lacking appropriate training data for new projects. We conduct three experiments on 34 data sets obtained from 10 open source projects, using only 10%, 6.67%, 5%, 3.33% and 2% of the total data for training, respectively. Four well-known classification algorithms are also included for comparison, namely Logistic Regression, Naïve Bayes, Random Tree and Support Vector Machine. All experimental results demonstrate the efficiency and practicability of the new classifier.

Cloned and non-cloned Java methods: a comparative study

Reusing code via copy-and-paste, with or without modification is a common behavior observed in software engineering. Traditionally, cloning has been considered as a bad smell suggesting flaws in design decisions. Many studies exist targeting clone discovery, removal, and refactoring. However there are not many studies which empirically investigate and compare the quality of cloned code to that of the code which has not been cloned. To this end, we present a statistical study that shows whether qualitative differences exist between cloned methods and non-cloned methods in Java projects. The dataset consists of 3562 open source Java projects containing 412,705 cloned and 616,604 non-cloned methods. The study uses 27 software metrics as a proxy for quality, spanning across complexity, modularity, and documentation (code-comments) categories. When controlling for size, no statistically significant differences were found between cloned and non-cloned methods for most of the metrics, except for three of them. The main statistically significant difference found was that cloned methods are on an average 18% smaller than non-cloned methods. After doing a mixed method analysis, we provide some insight for why cloned methods are smaller.

A User Interface Design Method based on Quantitative Evaluation of Consistency in Device Operation

SUMMARYDigitized electrical products have many functions, and these user interface specifications have become large scale. Therefore, in short development period, it is a problem that time for usability evaluation is insufficient. In this paper, we propose a user interface design method that can evaluate consistency in device operation, by simple processes. Features of the proposed method are to use similarity of functions or interactions, as software metrics. The similarities are calculated from the design information, and are analyzed by using an agglomerative hierarchical clustering (AHC). As a result of the AHC, functions or interactions are classified into several groups, and their consistencies are able to be judged. This is an automatic evaluation method that does not require manpower. Thus, unlike conventional usability evaluation, efficiency of the design work can be expected. As a result of evaluating user interfaces for digital camera by using the method, this technique was able to identify the points to be corrected in the interactions.

Software defect prediction using stacked denoising autoencoders and two-stage ensemble learning

ContextSoftware defect prediction (SDP) plays an important role in allocating testing resources reasonably, reducing testing costs, and ensuring software quality. However, software metrics used for SDP are almost entirely traditional features compared with deep representations (DPs) from deep learning. Although stacked denoising autoencoders (SDAEs) are powerful for feature learning and have been successfully applied in other fields, to the best of our knowledge, it has not been investigated in the field of SDP. Meanwhile, class-imbalance is still a pressing problem needing to be addressed. ObjectiveIn this paper, we propose a novel SDP approach, SDAEsTSE, which takes advantages of SDAEs and ensemble learning, namely the proposed two-stage ensemble (TSE). MethodOur method mainly includes two phases: the deep learning phase and two-stage ensemble (TSE) phase. We first use SDAEs to extract the DPs from the traditional software metrics, and then a novel ensemble learning approach, TSE, is proposed to address the class-imbalance problem. ResultsExperiments are performed on 12 NASA datasets to demonstrate the effectiveness of DPs, the proposed TSE, and SDAEsTSE, respectively. The performance is evaluated in terms of F-measure, the area under the curve (AUC), and Matthews correlation coefficient (MCC). Generally, DPs, TSE, and SDAEsTSE contribute to significantly higher performance compared with corresponding traditional metrics, classic ensemble methods, and benchmark SDP models. ConclusionsIt can be concluded that (1) deep representations are promising for SDP compared with traditional software metrics, (2) TSE is more effective for addressing the class-imbalance problem in SDP compared with classic ensemble learning methods, and (3) the proposed SDAEsTSE is significantly effective for SDP.

A Metrics Suite for code annotation assessment

Code annotation is a language feature that enables the introduction of custom metadata on programming elements. In Java, this feature was introduced on version 5, and today it is widely used by main enterprise application frameworks and APIs. Although this language feature potentially simplifies metadata configuration, its abuse and misuse can reduce source code readability and complicate its maintenance. The goal of this paper is to propose software metrics regarding annotations in the source code and analyze their distribution in real-world projects. We have defined a suite of metrics to assess characteristics of the usage of source code annotations in a code base. Our study collected data from 24947 classes extracted from open source projects to analyze the distribution of the proposed metrics. We developed a tool to automatically extract the metrics and provide a full report on annotations usage. Based on the analysis of the distribution, we defined an appropriate approach for the calculation of thresholds to interpret the metric values. The results allow the assessment of annotated code characteristics. Using the thresholds values, we proposed a way to interpret the use of annotations, which can reveal potential problems in the source code.

Software reusability metrics estimation: Algorithms, models and optimization techniques

ObjectiveIn this paper, the proposed model is intended to employ a novel evolutionary computing-based artificial intelligence or machine learning scheme for regression tests to be used for reusability estimation. Such enhancement can lead to accurate reusability pattern estimation, which can be effective for optimal software design purposes. This model is popularly called an aging-resilient software reusability forecast representation. The proposed system employs predominant object-oriented software metrics, such as Chidamber and Kemerer's metrics to examine reusability. Here, cumulative metrics, object-oriented metrics, McCabe's metrics, cohesion and a coupling-based reusability assessment model have been proposed which could be of paramount significance in software design optimization. In this paper, software metrics algorithms and their primary constructions have been developed for estimating the metrics from the UML/class diagrams. It is feasible to derive an efficient and robust reusability prediction model for web-service products using object-oriented metrics. Here, it was also found that OO-CK metrics, particularly complexity, cohesion and coupling-related metrics can be helpful in predicting reusability in web-service software products. Considering the above-mentioned key contributions, it can be stated that the proposed research could be of paramount significance in next-generation software computation systems, primarily for software component reusability, reliability, survivability, aging prediction and stability, and for software excellence assurance purposes.

Investigation of various data analysis techniques to identify change prone parts of an open source software

Identifying and examining the change-prone parts of the software is gaining wide importance in the field of software engineering. This would help software practitioners to cautiously assign the resources for testing and maintenance. Software metrics can be used for constructing various classification models which allow timely identification of change prone classes. There have been various machine learning classification models proposed in the literature. However, due to varying results across studies, more research needs to be done to increase the confidence in the results and provide a valuable conclusion. In this paper, we have used a number of data analysis techniques (14 machine learning techniques and a statistical technique) to construct change prediction models and performed statistical testing to compare the performance of these models. The application of a large number of techniques will allow for fair evaluation and will thus, increase the conclusion validity of the study. The results are validated on five releases of an open source, widely used operating system in mobile phone and tablet computers, ‘Android’. To make the results more generalizable, we have also conducted inter-release and cross-project predictions. The results conclude that the machine learning techniques are effective in predicting change prone classes and thus, should be widely used by researchers and practitioners to reduce maintenance effort and thus efficient and better development of software.

Scalable code clone detection and search based on adaptive prefix filtering

Code clone detection is a well-known software engineering problem that aims to detect all the groups of code blocks or code fragments that are functionally equivalent in a code base. It has numerous and wide ranging important uses in areas such as software metrics, plagiarism detection, aspect mining, copyright infringement investigation, code compaction, virus detection, and detecting bugs. A scalable code clone detection technique, able to process large source code repositories, is crucial in the context of multi-project or Internet-scale code clone detection scenarios. In this paper, we focus on improving the scalability of code clone detection, relative to current state of the art techniques. Our adaptive prefix filtering technique improves the performance of code clone detection for many common execution parameters, when tested on common benchmarks. The experimental results exhibit improvements for commonly used similarity thresholds of between 40% and 80%, in the best case decreasing the execution time up to 11% and increasing the number of filtered candidates up to 63%.

Database engines: Evolution of greenness

AbstractInformation technology consumes up to 10% of the world's electricity generation, contributing to CO2 emissions and high energy costs. Data centers, particularly databases, use up to 23% of this energy. Therefore, building an energy‐efficient (green) database engine could reduce energy consumption and CO2 emissions. The goal of this study is to understand the factors driving databases' energy consumption and execution time throughout their evolution. We conducted an empirical case study of energy consumption by 2 MySQL database engines, InnoDB and MyISAM, across 40 releases. We examined the relationships of 4 software metrics to energy consumption and execution time to determine which metrics reflect the greenness and performance of a database. Our analysis shows that database engines' energy consumption and execution time increase as databases evolve. Moreover, the lines of code (LOC) metric is correlated moderately to strongly with energy consumption and execution time in 88% of cases. Our findings provide insights to practitioners and researchers. Database administrators may use them to select a fast, green release of the MySQL database engine. MySQL developers may use LOC to assess products' greenness and performance. Researchers may use our findings to further develop new hypotheses or build models predicting greenness and performance of databases.

Software metrics thresholds calculation techniques to predict fault-proneness: An empirical comparison

Context: Nowadays, fault-proneness prediction is an important field of software engineering. It can be used by developers and testers to prioritize tests. This would allow a better allocation of resources, reducing testing time and costs, and improving the effectiveness of software testing. Non-supervised fault-proneness prediction models, especially thresholds-based models, can easily be automated and give valuable insights to developers and testers on the classification performed.Objective: In this paper, we investigated three thresholds calculation techniques that can be used for fault-proneness prediction: ROC Curves, VARL (Value of an Acceptable Risk Level) and Alves rankings. We compared the performance of these techniques with the performance of four machine learning and two clustering based models.Method: Threshold values were calculated on a total of twelve different public datasets: eleven from the PROMISE Repository and another based on the Eclipse project. Thresholds-based models were then constructed using each thresholds calculation technique investigated. For comparison, results were also computed for supervised machine learning and clustering based models. Inter-dataset experimentation between different systems and versions of a same system was performed.Results: Results show that ROC Curves is the best performing method among the three thresholds calculation methods investigated, closely followed by Alves Rankings. VARL method didn’t give valuable results for most of the datasets investigated and was easily outperformed by the two other methods. Results also show that thresholds-based models using ROC Curves outperformed machine learning and clustering based models.Conclusion: The best of the three thresholds calculation techniques for fault-proneness prediction is ROC Curves, but Alves Rankings is a good choice too. In fact, the advantage of Alves Rankings over ROC Curves technique is that it is completely unsupervised and can therefore give pertinent threshold values when fault data is not available.