Object-oriented Software Metrics Research Articles

Maintainability Evaluation for Object Oriented Software Metrics Using Tool Cohesion Inheritance (COIN)

In modern era, maintainability is an important part for software development that covers approx. 70-75% of development cost of the software system. It can allow the customer to adapt the software quickly and easily in an agile manner. Object oriented software metrics plays an important role for the designing of software development. Its features can be categorized into the object oriented metrics and the hierarchies of the class. In this paper, a tool named as COIN can help for evaluating the maintainability factors of object oriented software system using metrics like cohesion, coupling, inheritance and other object oriented metrics as well as through which we can analyzed the all metrics for the software system for evaluating the maintainability factors and testability also.

Comparison of threshold identification techniques for object-oriented software metrics

Quality assurance is a continuous process throughout the project lifecycle from inception till post-delivery. Software metrics are tools to help developers in achieving software quality objectives. Software metrics are used to predict the fault-proneness of classes in software using machine-learning and statistical techniques. However, these methodologies are difficult for daily tasks. Simpler and on the fly methodologies such as threshold values are needed. Metric thresholds can be used to control software quality and to recommend improvements on software code. Thresholds detect the parts of software that need more verification and validation. Many threshold identification techniques were proposed in previous research. However, the techniques do not provide consistent thresholds. The authors compare eight threshold identification techniques to diagnose software fault-proneness. The eight techniques are derived from diagnosis measures such as specificity, sensitivity, recall and precision. Five threshold identification techniques have derived thresholds that are skewed and have large standard deviations. Only three techniques are selected for threshold identification based on consistency and variation in selecting thresholds of software metrics in the systems under study. These techniques find thresholds that have the least variation among the studied techniques. The median of the 11 systems is selected as a representative of all thresholds.

Application of machine learning algorithms for code smell prediction using object-oriented software metrics

Code smells are generally not considered as bugs; instead, they point out certain shortcomings in the software design or code. Identification of code smell is a necessary step for improving the software quality and reducing the maintenance effort. In this study, we introduce a bad smell prediction technique based on object-oriented software metrics that use Decision Tree (DT) and Random Forest (RF) machine learning algorithm. An open-source project, namely JHOTDRAW, was used as our dataset, for which values of object-oriented software metrics were calculated. Two feature selection methods-Random Forest Importance (RFI) and Information Gain (IG) were applied to extract the most relevant attributes for the prediction of code smells, namely, Feature envy, Dispersed coupling, refused parent bequest, and God class. The random-search algorithm was used to tune the parameters of Random Forest and Decision Tree. Results show that the best classification accuracy for Decision Tree was obtained at 99.13% for refused parent bequest code smells. Results also show that after using the Random Forest classifier, refused parent bequest smell was predicted with the best accuracy of 99.14%. Finally, in this research study, a set of code smell prediction rules were extracted using Decision Tree.

Comparing Static and Dynamic Weighted Software Coupling Metrics

Coupling metrics that count the number of inter-module connections in a software system are an established way to measure internal software quality with respect to modularity. In addition to static metrics, which are obtained from the source or compiled code of a program, dynamic metrics use runtime data gathered, e.g., by monitoring a system in production. Dynamic metrics have been used to improve the accuracy of static metrics for object-oriented software. We study weighted dynamic coupling that takes into account how often a connection (e.g., a method call) is executed during a system’s run. We investigate the correlation between dynamic weighted metrics and their static counterparts. To compare the different metrics, we use data collected from four different experiments, each monitoring production use of a commercial software system over a period of four weeks. We observe an unexpected level of correlation between the static and the weighted dynamic case as well as revealing differences between class- and package-level analyses.

Applying learning-based methods for recognizing design patterns

Recognizing design patterns in source code helps in improving the aspect of reusability and maintainability that play an essential role during analysis and design phases of software development process. Software patterns provide design-level documents, which are applied for the recurring design issues. Analysis of design patterns is often carried out by using forward engineering as well as reverse engineering. In this study, a reverse engineering approach has been applied for recognizing design patterns. The study is comprised of two phases such as preparation of requisite dataset based on object-oriented software metrics and recognition of design patterns. The first phase, i.e., dataset preparation, is carried out by various object-oriented metrics. Design pattern recognition is performed by using learning-based algorithms such as artificial neural network and logistic regression. The presented method is validated by using three case studies such as JRefactory, JUnit and Quaqua.

Cost-effective and fault-resilient reusability prediction model by using adaptive genetic algorithm based neural network for web-of-service applications

The exponential rise in software technologies and its significances has demanded academia-industries to ensure low cost software solution with assured service quality and reliability. A low cost and fault-resilient software design is must, where to achieve low cost design the developers or programmers prefer exploiting source or function reuse. However, excessive reusability makes software vulnerable to get faulty due to increased complexity and aging proneness. Non-deniably assessing reusability of a class of function in software can enable avoiding any unexpected fault or failure. To achieve it developing a robust and efficient reusability estimation or prediction model is of utmost significance. On the other hand, the aftermath consequences of excess reusability caused faults might lead significant losses. Hence assessing cost effectiveness and efficacy of a reusability prediction model is must for software design optimization. In this paper, we have examined different reusability prediction models for their cost effectiveness and prediction efficiency over object-oriented software design. At first to examine the reusability of a class, three key object oriented software metrics (OO-SM); cohesion, coupling and complexity of the software components are used. Furthermore, our proposed cost-efficient reusability prediction model incorporates Min–Max normalization, outlier detection, reusability threshold estimation; T test analysis based feature selection and various classification algorithms. Different classifiers including decision tree (DT), Naive Bayes (NB), artificial neural network (ANN) algorithms, extreme learning machine (ELM), regression algorithms, multivariate adaptive regression spline (MARS) and adaptive genetic algorithm (AGA) based ANN are used for reusability prediction. Additionally, the cost effectiveness of each reusability prediction model is estimated, where the overall results have revealed that AGA based ANN as classifier in conjunction with OO-SM, normalization, T test analysis based feature selection outperforms other state-of-art techniques in terms of both accuracy as well as cost-effectiveness.

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.

Towards an extended BPMS prototype: Open challenges of BPM to flexible and robust orchestrate of uncertain processes

Nowadays, uncertainty is widely discussed as serious a challenge against business decision-making. The current business process management systems (BPMSs) are only able to manage certain processes, where there is practically a huge gap between what is expected and what is realized due to uncertainty. This study developed an extended BPMS prototype to facilitate and improve any business process management subject to uncertainty. This prototype can model, design, control and optimize in uncertainty modes, in addition to classic BPMSs operations. For developing a new prototype, the authors first provided a meta-model for designing new engine functions. Thereafter, by defining the architecture style and abstract model, defining user interfaces and component interfaces, uncertain BPMS prototype with CORBA standards created. Furthermore, flexible components are implemented to deal with uncertainty during run-time. This paper has used three evaluation methods to validate the proposed uncertain BPMS prototype. Firstly, an executable prototype has been built and evaluated with a rating model, which obtains quantitative metrics. The comparison between the proposed uncertain BPMS prototype and other classic BPMSs has effectively demonstrated the ability of an extended BPMS prototype in BP management under uncertainty modes. Secondly, a case study in oil and gas industry was studied with a focus on the industry 4.0. The results have revealed the improvement in planning service time after using the proposed prototype. Thirdly, the efficiency of uncertain BPMS prototype has been investigated through different object-oriented software metrics. These results also show the ability of the extended BPMS prototype to flexibly and robustly orchestrate uncertain processes.

A Classification of Software Modules into Library and Application Components in the Open-Source Field

Software reuse significantly reduce the costs of software production in the field of open-source software (OSS) development and lead to produce more reliable software systems. Software metrics have been proposed as indicators of software quality factors such as reusability. However, few empirical research papers have validated the relationship between components reusability and software metrics. This research aims to validate Chidamber and Kemerer (CK) metrics as predictors of software reusability. In order to achieve this goal, an empirical study is conducted to validate metrics in classifying two groups of components: library (reuse-prone) and non-library (less reuseprone). A nearest neighbor’s technique is used to classify library and application components using object-oriented software metrics. The approach is applied to a number of library and application systems available online. The conducted nearest neighbors models have produced acceptable classification. The results provide evidence of using metrics as surrogates of software reusability when models are evaluated using Fmeasure. CK metrics can be used to measure component reuse-proneness and can be used to differentiate between library and application components. A nearest neighbor’s technique can be used to identify the reuse-prone components in open-source application.

Structural Code Clone Detection Methodology Using Software Metrics

Unnecessary repeated codes, also known as code clones, have not been well documented and are difficult to maintain. Code clones may become an important problem in the software development cycle, since any detected error must be fixed in all occurrences. This condition significantly increases software maintenance costs and requires effort/duration for understanding the code. This research introduces a novel methodology to minimize or prevent the code cloning problem in software projects. In particular, this manuscript is focused on the detection of structural code clones, which are defined as similarity in software structure such as design patterns. Our proposed methodology provides a solution to the class-level structural code clone detection problem. We introduce a novel software architecture that provides unification of different software quality analysis tools that take measurements for software metrics for structural code clone detection. We present an empirical evaluation of our approach and investigate its practical usefulness. We conduct a user study using human judges to detect structural code clones in three different open-source software projects. We apply our methodology to the same projects and compare results. The results show that our proposed solution is able to show high consistency compared with the results reached by the human judges. The outcome of this study also indicates that a uniform structural code clone detection system can be built on top of different software quality tools, where each tool takes measurements of different object-oriented software metrics.

Maintainability prediction of web service using support vector machine with various kernel methods

The present day software are mostly developed based on Service-Oriented Computing (SOC), which assembles loosely coupled pieces of software called services. With the increase in the number of development of these varieties of service oriented software, their effective maintenance plays an important role for the developers. The quality of SOC can be best assessed by the use of software metrics. In this paper, different object-oriented software metrics have been considered in order to design a model for predicting maintainability of SOC paradigm. Further support vector machine with different type of kernels have been considered for predicting maintainability of SOC paradigm. This paper also focuses on the effectiveness of feature selection techniques such as univariate logistic regression analysis, cross correlation analysis, rough set analysis, and principal component analysis. The results show that, maintainability of SOC paradigm can be predicted by application of various object-oriented metrics. The results further indicated that, it is possible to find a small subset of object-oriented metrics out of total available various object-oriented metrics, that enables prediction of maintainability with higher accuracy.

Validating the Effectiveness of Object-Oriented Metrics for Predicting Maintainability

Abstract In this study, empirically investigates the relationship of existing class level object-oriented metrics with a quality parameter i.e., maintainability. Here, different subset of Object-Oriented software metrics have been considered to provide requisite input data to design the models for predicting maintainability using Neuro-Genetic algorithm (hybrid approach of neural network and genetic algorithm). This technique is applied to estimate maintainability on two different case studies such as Quality Evaluation System (QUES) and User Interface System (UIMS). The performance parameters of this technique are evaluated based on the basis of Mean absolute error (MAE), Mean Absolute Relative Error (MARE), Root Mean Square Error (RMSE), and Standard Error of the Mean (SEM). The results reported that the identified subset metrics demonstrated an improved maintainability prediction with higher accuracy.

Synergy of Classical and Model-Based Object-Oriented (OO) Metrics in Reducing Test Costs

Software testing and maintenance being interleaved phases span more in software life cycle. The efforts to minimize this span rely obviously on testing when maintenance is natural. The features of Object-Oriented (OO) software systems, when compared to the classical systems, claim much reducing the maintenance costwithout necessarily thepossibility of maintenance itself. It is natural that even such systems evolve due to many reasons. Though the specific reasons leading to the maintenance differ, the general rationale behind maintenance is to enhance the life-cycleand possibly the value of the existing system. Hence testing effort is more natural and significant even then. Moreover, the salient features of OO software systems furtherance the testing span despite their claim on maintenance. However, the availability of classical OO software metrics aid better early quality testing of OO systems. They exploit the critical parts of OO software systems thereby offering timely, thorough, and effective assurance. However there is not yet a common metric model in this regard. On the other hand, it is expected that the evolved model-based OO software metrics help define the subjective features more objectively facilitating users to perform metrics activities. The conflation of both classical and model-based metrics mutually alleviates their limitations and brings more synergy in reducing the test costs of OO software systems.

Feedback for Programming Assignments Using Software-Metrics and Reference Code

Feedback for student programming assignments on quality is a tedious and laborious task for the instructor. In this paper, we make use of few object-oriented software metrics along with a reference code that is provided by the instructor to analyze student programs and provide feedback. The empirical study finds those software metrics that can be used on the considered programming assignments and the way reference code helps the instructor to assess them. This approach helps the instructor to easily find out quality issues in student programs. Feedback to such assignments can be provided using the guidelines which we will be discussing. We also perform an experimental study on programming assignments of sophomore students who were enrolled in an object-oriented programming course to validate our approach.

Application of Object Oriented Metrics to Java and C Sharp: Comparative Study

This research paper presents the comparative study of various object oriented software metrics and their application on C Sharp and Java language. A set of eleven well established object-oriented metrics are applied on twenty C Sharp and Java programs to measure and compare the important features such as complexity, testability and maintainability of both languages. This analysis shows that C# is a modern and powerful language which is fully object-oriented as compared to Java. The primary objective of this study is to investigate the applicability of Object–Oriented software metrics to measure the complexity of a Java and C Sharp software applications.

Review on software metrics thresholds for object-oriented software

Software metrics like any other measures have been advocated as the essential tool in Object-oriented systems. Controlling software metrics is an important for building quality software systems. Software metrics thresholds have been used in various disciplines in identifying the unsafe design by setting an alarm at a place where the value of the specific internal measure exceeds some predefined values. Although, the researchers and other practitioners tried to introduce a variety of software metrics, but the issue of thresholds has been given limited attention. A few meaningful software metric thresholds have been introduced in the literature. In this review paper, the authors went through different literatures to identify the existing object-oriented software metrics thresholds in order to gain an insight about the phenomena. By studying the validation process and the sensations of the metrics presented in the literature, the study found the thresholds for CK metrics have been validated more than any other metrics.

Improved CK Metrics for Object Oriented Design Measurement

In order to understand and control the software development process better, improve the quality of software. At the same time, traditional methods of measurement in the field of object-oriented is no longer fit for some of the unique features for object-oriented software, this makes us accelerate the speed of research of object-oriented software metrics, and considerable progress has been made. This paper describes object-oriented software measurement method proposed by Chidamber and Kemerer-- C&K , for its lack, we improved on method of C&K, combined with the features of the Java language, applied software measurement tools that you already have on software measurement indicators for implementation and help developers guide software development processes to meet the needs of users better.

Prediction of testability using the design metrics for object-oriented software

One of the cost effective methods to monitor the testing effort is to assess the testability of the software from the early phases of the software development. Software metrics based testability assessment can enable testers to focus more on the testing of the less testable classes. This paper presents a study based on the experimental analysis that uses fourteen design metrics as the independent variables and two JUnit based test metrics as the dependent variables. The results of the study indicate a number of promising effects of design metrics on testability of a class in object oriented software.

Validation of dynamic coupling metrics for object-oriented software

Dynamic coupling metrics for object-oriented software provide scope of coupling measurement up to the object level and take into account important and widely used object-oriented features such as inheritance, polymorphism and dynamic binding during measurement. The dynamic measures are computed at run-time, which take into consideration the actual interactions taking place among members of a class. In this paper, an attempt has been made to evaluate dynamic coupling metrics for object-oriented software using formal evaluation framework proposed by Briand et al. A practical and useful coupling measure must satisfy most of the properties given in this framework. The results of this study show that dynamic coupling metrics satisfy all properties and parameters required by the evaluation framework and thus dynamic coupling measures are robust and useful.

Identifying thresholds for object-oriented software metrics

Abstract Despite the importance of software metrics and the large number of proposed metrics, they have not been widely applied in industry yet. One reason might be that, for most metrics, the range of expected values, i.e., reference values are not known. This paper presents results of a study on the structure of a large collection of open-source programs developed in Java, of varying sizes and from different application domains. The aim of this work is the definition of thresholds for a set of object-oriented software metrics, namely: LCOM, DIT, coupling factor, afferent couplings, number of public methods, and number of public fields. We carried out an experiment to evaluate the practical use of the proposed thresholds. The results of this evaluation indicate that the proposed thresholds can support the identification of classes which violate design principles, as well as the identification of well-designed classes. The method used in this study to derive software metrics thresholds can be applied to other software metrics in order to find their reference values.