Explore the vast range of titles available.

Empirical validation of software metrics suites to predict fault proneness in object-oriented (OO) components is essential to ensure their practical use in industrial settings. In this paper, we empirically validate three OO metrics suites for their ability to predict software quality in terms of fault-proneness: the Chidamber and Kemerer (CK) metrics, Abreu's Metrics for Object-Oriented Design (MOOD), and Bansiya and Davis' Quality Metrics for Object-Oriented Design (QMOOD). Some CK class metrics have previously been shown to be good predictors of initial OO software quality. However, the other two suites have not been heavily validated except by their original proposers. Here, we explore the ability of these three metrics suites to predict fault-prone classes using defect data for six versions of Rhino, an open-source implementation of JavaScript written in Java. We conclude that the CK and QMOOD suites contain similar components and produce statistical models that are effective in detecting error-prone classes. We also conclude that the class components in the MOOD metrics suite are not good class fault-proneness predictors. Analyzing multivariate binary logistic regression models across six Rhino versions indicates these models may be useful in assessing quality in OO classes produced using modern highly iterative or agile software development processes.

Over the years, various software quality measurement models have been proposed and used in academia and the software industry to assess the quality of produced code and to obtain guidelines for its improvement. In this article, we describe the design and functionality of SQMetrics, a tool for calculating object-oriented quality metrics for projects written in Java. SQMetrics provides the convenience of measuring small code, mainly covering academic or research needs. In this context, the application can be used by students of software engineering courses to make measurements and comparisons in their projects and gradually increase their quality by improving the calculated metrics. Teachers, on the other hand, can use SQMetrics to evaluate students’ Java projects and grade them in proportion to their quality. The contribution of the proposed tool is three-fold, as it has been: (a) tested for its completeness and functionality by comparing it with widely known similar tools, (b) evaluated for its usability and value as a learning aid by students, and (c) statistically tested for its value as a teachers’ aid assisting in the evaluation of student projects. Our findings verify SQMetrics’ effectiveness in helping software engineering students learn critical concepts and improve the quality of their code, as well as in helping teachers assess the quality of students’ Java projects and make more informed grading decisions.

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), Naïve 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.

This study aims to develop a methodology in which alternative Six Sigma projects are prioritized and selected using appropriate multi-criteria decision-making (MCDM) methods in the software development industry. The methodology developed in this paper proposes an MCDM-based approach for researchers to prioritize and select Six Sigma projects for software development projects. The study reveals that by prioritizing software projects with CRITIC, Entropy, and ARAS methods, software companies will be able to achieve their goals such as quality, process improvement, resource allocation, and customer satisfaction. CRiteria Importance Through Intercriteria Correlation (CRITIC) and Entropy methods were used to determine criterion weights and a new Additive Ratio ASsessment (ARAS) method was used to rank alternatives in ordering software development projects. According to the results obtained, one of 7 software development projects (Project 6) was considered the highest priority project for Chidamber and Kemerer's (C&K) software quality metrics. To the best of our knowledge, this is the first study that implements CRITIC and ARAS methods in the Six Sigma project prioritization and selection process for software development projects.

This chapter discusses the integration of modern features in C++ with object‐oriented design techniques. The goal is to design robust and flexible classes in C++. The chapter first explores two modelling techniques; the Liskov substitution principle (LSP); and the single responsibility principle (SRP). It then discusses how to design classes. In doing so, the chapter introduces a number of language features that improve the robustness and reliability of C++ classes and member functions. It also focuses on the different ways to construct objects and to initialise data. The features are tactical in the sense that they help to improve code quality at class level. Then, the chapter discusses different ways to achieve polymorphic behaviour in classes and class hierarchies. It finally gives an overview of object‐oriented software metrics that measure code quality by providing metrics for classes, their members as well as class hierarchies.

We present a comprehensive study of an implementation of the Smalltalk object oriented system, one of the first and purest object-oriented programming environment, searching for scaling laws in its properties. We study ten system properties, including the distributions of variable and method names, inheritance hierarchies, class and method sizes, system architecture graph. We systematically found Pareto - or sometimes log-normal - distributions in these properties. This denotes that the programming activity, even when modeled from a statistical perspective, can in no way be simply modeled as a random addition of independent increments with finite variance, but exhibits strong organic dependencies on what has been already developed. We compare our results with similar ones obtained for large Java systems, reported in the literature or computed by ourselves for those properties never studied before, showing that the behavior found is similar in all studied object oriented systems. We show how the Yule process is able to stochastically model the generation of several of the power-laws found, identifying the process parameters and comparing theoretical and empirical tail indexes. Lastly, we discuss how the distributions found are related to existing object-oriented metrics, like Chidamber and Kemerer's, and how they could provide a starting point for measuring the quality of a whole system, versus that of single classes. In fact, the usual evaluation of systems based on mean and standard deviation of metrics can be misleading. It is more interesting to measure differences in the shape and coefficients of the data?s statistical distributions.

The paper describes an improved hierarchical model for the assessment of high-level design quality attributes in object-oriented designs. In this model, structural and behavioral design properties of classes, objects, and their relationships are evaluated using a suite of object-oriented design metrics. This model relates design properties such as encapsulation, modularity, coupling, and cohesion to high-level quality attributes such as reusability, flexibility, and complexity using empirical and anecdotal information. The relationship or links from design properties to quality attributes are weighted in accordance with their influence and importance. The model is validated by using empirical and expert opinion to compare with the model results on several large commercial object-oriented systems. A key attribute of the model is that it can be easily modified to include different relationships and weights, thus providing a practical quality assessment tool adaptable to a variety of demands.

Object-oriented metrics have been validated empirically as measures of design complexity. These metrics can be used to mitigate potential problems in the software complexity. However, there are few studies that were conducted to formulate the guidelines, represented as threshold values, to interpret the complexity of the software design using metrics. Classes can be clustered into low and high risk levels using threshold values. In this paper, we use a statistical model, derived from the logistic regression, to identify threshold values for the Chidamber and Kemerer (CK) metrics. The methodology is validated empirically on a large open-source system-the Eclipse project. The empirical results indicate that the CK metrics have threshold effects at various risk levels. We have validated the use of these thresholds on the next release of the Eclipse project-Version 2.1-using decision trees. In addition, the selected threshold values were more accurate than those were selected based on either intuitive perspectives or on data distribution parameters. Furthermore, the proposed model can be exploited to find the risk level for an arbitrary threshold value. These findings suggest that there is a relationship between risk levels and object-oriented metrics and that risk levels can be used to identify threshold effects.

Open source software systems are becoming increasingly important these days. Many companies are investing in open source projects and lots of them are also using such software in their own work. But, because open source software is often developed with a different management style than the industrial ones, the quality and reliability of the code needs to be studied. Hence, the characteristics of the source code of these projects need to be measured to obtain more information about it. This paper describes how we calculated the object-oriented metrics given by Chidamber and Kemerer to illustrate how fault-proneness detection of the source code of the open source Web and e-mail suite called Mozilla can be carried out. We checked the values obtained against the number of bugs found in its bug database - called Bugzilla - using regression and machine learning methods to validate the usefulness of these metrics for fault-proneness prediction. We also compared the metrics of several versions of Mozilla to see how the predicted fault-proneness of the software system changed during its development cycle.

To produce high quality object-oriented (OO) applications, a strong emphasis on design aspects, especially during the early phases of software development, is necessary. Design metrics play an important role in helping developers understand design aspects of software and, hence, improve software quality and developer productivity. In this paper, we provide empirical evidence supporting the role of OO design complexity metrics, specifically a subset of the Chidamber and Kemerer (1991, 1994) suite (CK metrics), in determining software defects. Our results, based on industry data from software developed in two popular programming languages used in OO development, indicate that, even after controlling for the size of the software, these metrics are significantly associated with defects. In addition, we find that the effects of these metrics on defects vary across the samples from two programming languages-C++ and Java. We believe that these results have significant implications for designing high-quality software products using the OO approach.