Object-oriented Design Metrics Research Articles

Software Reliability Prediction using Correlation Constrained Multi-Objective Evolutionary Optimization Algorithm

Software reliability frameworks are extremely effective for estimating the probability of software failure over time. Numerous approaches for predicting software dependability were presented, but neither of those has shown to be effective. Predicting the number of software faults throughout the research and testing phases is a serious problem. As there are several software metrics such as object-oriented design metrics, public and private attributes, methods, previous bug metrics, and software change metrics. Many researchers have identified and performed predictions of software reliability on these metrics. But none of them contributed to identifying relations among these metrics and exploring the most optimal metrics. Therefore, this paper proposed a correlation- constrained multi-objective evolutionary optimization algorithm (CCMOEO) for software reliability prediction. CCMOEO is an effective optimization approach for estimating the variables of popular growth models which consists of reliability. To obtain the highest classification effectiveness, the suggested CCMOEO approach overcomes modeling uncertainties by integrating various metrics with multiple objective functions. The hypothesized models were formulated using evaluation results on five distinct datasets in this research. The prediction was evaluated on seven different machine learning algorithms i.e., linear support vector machine (LSVM), radial support vector machine (RSVM), decision tree, random forest, gradient boosting, k-nearest neighbor, and linear regression. The result analysis shows that random forest achieved better performance.

Measure extendibility/extensibility quality attribute using object oriented design metric

Software design is one of the very important phases of the software engineering. The costs of software can be minimized if improvements or corrections made during this stage. Several of the current computer aided software engineering (CASE) tools like enterprise architect (EA) v12 do not have the capability to improve the design. This work aims to develop an algorithm that helps the software engineers evaluating the design quality utilizing one of the object-oriented (OO) design models namely quality metrics for object-oriented design (QMOOD) which represents as hierarchical model that describes the relationship between quality attributes such as reusability, extendibility and properties of the design of OO design. This algorithm describesed how the assessment of the extendibility/ extensibility using the software metrics has been done and the impact of the involved metrics in the extendibility value. Results obtained demonstrate the effect of OO design metrics such as inheritance, polymorphism, abstraction and coupling in quality characteristics like extensibility. The results show that lower values of abstraction and coupling, obtain higher value of extendibility which means the class diagram is ready to accept additional improvements. The proposed algorithm has been tested on two different systems (test cases) that vary in their class diagrams, functionalities, and complexities.

Towards a Formal Approach for Assessing the Design Quality of Object-Oriented Systems

The cost of software maintenance is always increasing. The companies are often confronted to failures and software errors. The quality of software to use is so required. In this paper, the authors propose a new formal approach for assessing the quality of object-oriented system design according to the quality assessment model. This approach consists in modeling the input software system by an automaton based on object-oriented design metrics and their relationship with the quality attributes. The model exhibits the importance of metrics through their links with the attributes of software quality. In addition, it is very practical and flexible for all changes. It allows the quality estimation and its validation. For the verification of proposed probabilistic model (automaton), they use the model-checking and the prism tool. The model-checking is very interesting for the evaluation and validation of the probabilistic automaton. They use it to approve the software quality of the three experimental projects. The obtained results are very interesting and of great importance.

Machine Learning based Test Case Prioritization in Object Oriented Testing

Software maintenance is one of the most expensive activities in software life cycle. It costs nearly 70% of the total cost of the software. Either to adopt the new requirement or to correct the functionality, software undergoes maintenance. As a consequent of maintenance activities, software undergoes many reforms. Newly added software components may affect the working of existing components and also may introduce faults in existing components. The regression testing tries to reveal the faults that might have been introduced due to these reformations. Running all the prior existing test cases may not be feasible due to constraints like time, cost and resources. Test case prioritization may help in ordered execution of test cases. Running a faulty or fault prone component early in testing process may help in revealing more faults per unit of time. And hence may reduce the testing time. There have been many different criteria for assigning the priority to test cases. But none of the approaches so far have considered the object oriented design metrics for determining the priority of test cases. Object oriented design metrics have been empirically studied for their impact of software maintainability, reliability, testability and quality but usage of these metrics in test case prioritization is still an open area of research. The research reported in this paper evaluates subset of CK metrics. Metrics considered from CK suite include Coupling between objects (CBO), Depth of Inheritance tree (DIT), weighted methods per class (WMC), Number of children (NOC), and Response for a class (RFC). Study also considers four other metrics namely publically inherited methods (PIM), weighted attributes per class (WAC), number of methods inherited (NMI) and number of methods overridden. A model is built based on these metrics for the prediction of software quality and based on the quality measures software modules are classified with the help of Support Vector Machine (SVM) algorithm. The proposed approach is implemented in WEKA tool and analysed on experimental data extracted from open source software. Proposed work would firstly help the tester in identifying the low quality modules and then prioritize the test cases based on quality centric approach. The work also attempts to automate test case prioritization in object oriented testing. The results obtained are encouraging.

An Analytical Evolution of Usability for Object Oriented Metrics

Object oriented design metrics are most essential part of software development environment and being more popular day by day. This study focus on a set of object oriented metrics that can be used to measure the quality of an object oriented design. The object oriented design metrics focus on the measurements of class and design characteristics. These measurements permit designers to access the software in the early stage of the process and changes accordingly to reduce complexity and improve the continuing capability of the design. This paper summarizes the existing metrics those guide the designers to support their design. We categorized and discussed metrics in such a way that novice designers can apply metrics in their design as needed.

Utility of an object-oriented metrics component: examining the feasibility of .Net and C# object-oriented program from the perspective of mobile learning

In the 21st century, mobile applications could be built using different object-oriented languages like C#, Java and object-oriented framework. Increasing and maintaining the software product for multiple applications remains to be a challenging task. Object-oriented metrics play a crucial role in development of a software product. The estimation of object-oriented metrics is essential in the software engineering domain, including measuring the software code complexity, and estimating the size and quality of the products. Developers generally implements applications on different platforms, such as the Android in Java and Windows in C#, by having the metrics estimation conducted automatically since manual calculation is difficult. The metrics are generated in different ways owing to the change of mobile technologies and other marketing factors. This research not only reviews both manual and automated design tools for the estimation of object-oriented metrics for mobile applications, but also proposes a novel approach for estimating the metrics by recognising individual metrics and estimating the re-usability factors in a dynamic manner. The Chidamber and Kemerer metrics suite is best suited for measuring the object-oriented design metrics. This paper reviews the object-oriented metrics and analyses the difference through a comparison table; following that, several suggestions are provided to researchers and system developers.

An empirical study to improve software security through the application of code refactoring

ContextCode bad smells indicate design flaws that can degrade the quality of software and can potentially lead to the introduction of faults. They can be eradicated by applying refactoring techniques. Code bad smells that impact the security perspective of software should be detected and removed from their code base. However, the existing literature is insufficient to support this claim and there are few studies that empirically investigate bad smells and refactoring opportunities from a security perspective. ObjectiveIn this paper, we investigate how refactoring can improve the security of an application by removing code bad smell. MethodWe analyzed three different code bad smells in five software systems. First, the identified code bad smells are filtered against security attributes. Next, the object-oriented design and security metrics are calculated for the five investigated systems. Later, refactoring is applied to remove security-related code bad smells. The correctness of detection and refactoring of investigated code smells are then validated. Finally, both traditional object-oriented and security metrics are again calculated after removing bad smells to assess its impact on the design and security attributes of systems. ResultsWe found ‘feature envy’ to be the most abundant security bad smell in investigated projects. The ‘move method’ and ‘move field’ are commonly applied refactoring techniques because of the abundance of feature envy. ConclusionThe results of security metrics indicate that refactoring helps improve the security of an application without compromising the overall quality of software systems.

Early Stage Software Reliability Modeling using Requirements and Object-Oriented Design Metrics: Fuzzy Logic Perspective

Early Stage Software Reliability Modeling using Requirements and Object-Oriented Design Metrics: Fuzzy Logic Perspective

An Efficient Object Oriented Design Model: By Measuring and Prioritizing the Design Metrics of UML Class Diagram with Preeminent Quality Attributes

In Software Engineering, non-functional quality attributes plays a major part in the design phase. The conflicts among quality attributes will smash up the overall software quality. Due to many changes in the requirements, may affect the overall design quality. It is very important to maintain the quality in the former stages of SDLC. In order to overcome the conflicts among attributes and to design quality software, a work is proposed to create an Efficient Object Oriented Design Model (EOODM), by Measuring and Prioritizing the Quality Metrics of UML Class Diagram. The above model works in three steps as, 1) The conflicts quality attributes are managed by creating generic rules, 2) The measurement is done by quantify the Object Oriented Design metrics of a class diagram. 3) The priority will be given to the attributes by equivalence partitioning of the quality metrics. However, all the design is done by using UML diagrams, especially the Class Diagram, where they are the ruler for the developers. We are in a position to measure and estimate the software quality attributes along with the quality metrics. By measuring the Design Metrics of Class Diagram leads to Preeminent Quality Software. This model will help the designers to evaluate a better software system.The main aim is to enhance the software design by improving the design metrics of UML class diagram.

Proposing and assessing a software visualization approach based on polymetric views

In this paper, we present an approach for the visualization of object-oriented software. This approach has been implemented in MetricAttitude, a visualization tool based on static analysis that provides a mental picture of a software implemented in Java by means of polymetric views. The approach graphically represents a suite of object-oriented design metrics (e.g., Weighted Methods per Class) and “traditional” code-size metrics (e.g., Lines Of Code). To assess the validity of our proposal, we have conducted two users' studies with students in Computer Science and professional software developers. The used empirical method is qualitative. To assess MetricAttitude and its underlying approach, we conducted questionnaire-based surveys. Results suggest that MetricAttitude is a viable means to deal with existing objects-oriented software and to comprehend their source code, in particular.

IJARCCE - Computer and Communication Engineering

The quality of any object oriented design is critical because it has a great influence on overall quality of finally delivered software product. Testability quantification early in the software development process is a criterion of crucial important to software development team. Testability has always been an indefinable concept its correct measurement, quantification or evaluation is a difficult task because of its potential factors. Testability analysis of object oriented software at an initial stage of software development process has been identified as a key factor for high quality product. A best suited object oriented design (OOD) properties and its associated metrics are helpful if applied in the early stage of development process .This paper describes an improved testability quantification framework using the identified set of potential factors, OOD properties and OOD metrics for software products at early phase, exclusively at design time. The proposed framework relates OOD properties to high level quality attributes/constructs using appropriate information to develop quality product and it may used to benchmark software products according to their key attribute. The objective of this research work to encourage researchers and developers to provide a framework to access and quantify software testability at early stage of development life cycle.

IJARCCE - Computer and Communication Engineering

3 Abstract: Measuring testability early in the development life cycle considerably reduces the overall development cost, effort and rework. It is very expensive and error prone decision to correct the design to get better testability after the coding has started. This paper proposes a testability measurement framework for object oriented software concerning at design phase. This framework correlates the testability factor with object oriented design properties and also correlates design properties with object oriented design metrics. No such framework has been presented in the literature that accurately measure testability of object oriented software taking design phase into consideration. The proposed framework reduces the gap between object oriented design properties, metrics and testability. This framework measures effort in measuring testability of object oriented software early at design phase and makes it possible to produce reliable end product within time and budget.

Theoretical Validation of Inheritance Metrics for Object-Oriented Design against Briand's Property

Many inheritance metrics can be found in the literature, but most of those are validated theoretically by using Weyuker's property. Theoretical validation of inheritance metrics using Briand's property is rare in the literature. This paper considers the metrics proposed by Rajnish and Sandip and presents a theoretical validation of the inheritance metrics using the Briand's size and length properties of an inheritance hierarchy. This paper also gives the projection and viewpoint of the inheritance metrics.

An approach to automatically enforce object-oriented constraints

This paper presents an approach to automatically enforce object-oriented constraints during incremental C++ code changes. The approach is realised as a tool to keep track on code changes and to notify developers with violations of predefined OO constraints. The OO constraints under consideration are taken from object-oriented design metrics. The object-oriented metrics mainly cover class size, coupling between classes, number of subclasses and inheritance tree. The goal of this work is to help designers to monitor design during incremental code changes. Object-oriented design metrics are automatically extracted from source code. The extracted metrics are used by designers to define the constraints. The tool supports defining and managing these OO constraints. After a code change is committed, design changes are identified and predefined constraints are checked for possible violations. The evaluation of the tool shows that it helps in detecting violations of design constraints, and it saves time and efforts of developers.

New Quality Inheritance Metrics for Object-Oriented Design

Metrics are used to help a software engineer in quantitative analysis to assess the quality of the design before a system is built. Object-Oriented (OO) design is becoming more popular in software development environment and OO design metrics are essential parts of software environment. The primary purpose of this paper is to analytically evaluate against the Weyuker’s property and empirically validate, a proposed inheritance metrics (against a three versions of the same project) that can be used to measure the quality (especially focus on the quality factors “Reuse” and “Design Complexity”) of an OO systems in terms of the using class inheritance tree.

Investigating of high and low impact faults in object-oriented projects

For optimum utilization of resources and reducing the cost of software, the fault detection and elimination process must be properly planned and for this type of planning prediction of fault-prone module is gaining importance among researchers. It would be valuable to know how object-oriented design metrics and class fault-proneness are related when fault impact is taken into account. In this paper, we use the logistic regression method to empirically investigate the usefulness of object-oriented design metrics in predicting fault-proneness when taking fault impact into account. Our results, based on a public domain NASA Promise data set, indicate that most of these design metrics are statistically related to fault-proneness of classes across fault impact, and the prediction capabilities of the investigated metrics greatly depend on the impact of faults. More specifically, these design metrics are able to predict high/low impact faults in fault-prone classes.

Existing Object Oriented Design Metrics a Study and Comparison

Existing Object Oriented Design Metrics a Study and Comparison

Analyzing Software Quality Evolution using Metrics: An Empirical Study on Open Source Software

The study presented in this paper aims at analyzing empirically the quality of evolving software systems using metrics. We used a synthetic metric (Quality Assurance Indicator - Qi), which captures in an integrated way different object-oriented software attributes. We wanted to investigate if the Qi metric can be used to observe how quality evolves along the evolution of software systems. We consider software quality from an internal (structural) perspective. We used various object-oriented design metrics for measuring the structural quality of a release. We performed an empirical analysis using historical data collected from successive released versions of three open source (Java) software systems. The collected data cover, for each system, a period of several years (4 years for two systems and 7 years for the third one). We focused on three issues: (1) the evolution of the Qi metric along the evolution of the subject systems, (2) the class growth of the subject systems, and (3) the quality of added classes versus the quality of removed ones. Empirical results provide evidence that the Qi metric reflects properly the quality evolution of the studied software systems.

Integrity quantification model for object oriented design

Various surveys indicate that over the past several years software security has risen in priority for many software organizations. Security quantification in early stage of software development life cycle assists security experts to address security related problems well in advance. Security assessment using model is proved to be one of the established methods. Keeping in view of the same, an Integrity Quantification Model (IQM) is proposed in this paper. An effort is made by authors to correlate design integrity with complexity factors. Object oriented design metrics are used to quantify complexity factors. The developed model has been validated with realistic (small set of) data to prove the significance.

Empirical Analysis of Object-Oriented Design Metrics for Predicting Unit Testing Effort of Classes

In this paper, we investigate empirically the relationship between object-oriented design metrics and testability of classes. We address testability from the point of view of unit testing effort. We collected data from three open source Java software systems for which JUnit test cases exist. To capture the testing effort of classes, we used metrics to quantify the corresponding JUnit test cases. Classes were classified, according to the required unit testing effort, in two categories: high and low. In order to evaluate the relationship between object-oriented design metrics and unit testing effort of classes, we used logistic regression methods. We used the univariate logistic regression analysis to evaluate the individual effect of each metric on the unit testing effort of classes. The multivariate logistic regression analysis was used to explore the combined effect of the metrics. The performance of the prediction models was evaluated using Receiver Operating Characteristic analysis. The results indicate that: 1) complexity, size, cohesion and (to some extent) coupling were found significant predictors of the unit testing effort of classes and 2) multivariate regression models based on object-oriented design metrics are able to accurately predict the unit testing effort of classes.