Object-oriented software quality through data scope complexity measurement

Object-oriented software metrics are important in software engineering field for measurement of the software quality, size estimation, complexity and effort. Object oriented software development is the most popular and best practice in software development. Object oriented software metrics can be used for measuring extend of object orientedness of a program. These quantities are important information indicators, that can be helpful for a software developer in take decisions for designing good software. It is proven that the software metrics provide quantitative information about the structure of the code, which can be used to determine the reliability of software. The design of the software is highly recommended to be object oriented in the software development environment. Software metrics specific to programs that have object oriented design can be used to measure the quality of the software like inheritance, assessing the effects of coupling, the complexity of the code, size aspects, etc, of the software developed in such an environment. Software measurement is a way for assessing the quality of software. Many attributes can define quality of a software, internal (size, complexity) as well as external (reliability)[14]. Often internal attributes are contributing factors to external attributes. Reliability as a term means the degree to which a component, product or system executes specified functions for a specific period of time under specified conditions. Software reliability is the software being trustworthy of the specifications. The aim of the work is to model the relationship between reliability of object oriented software to the object oriented design metrics and predict reliability of software.

There is no software metrics based on object-oriented programming languages (OOPLs) developed to help object-oriented software development. A graph-theoretical complexity metric to measure object-oriented software complexity is described. It shows that inheritance has a close relation with the object-oriented software complexity, and reveals that misuse of repeated (multiple) inheritance will increase software complexity and be prone to implicit software errors. An algorithm to support this software metric is presented. Its time complexity is O(n/sup 3/). >

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.

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.

An alternative approach for measuring object-oriented (OO) software quality has been proposed by applying the Analytic Hierarchy Process (AHP) scheme. This approach is effective in defining the rank of software quality over a number of Java applications based on two sets of metric values representing main OO structural properties. The Metrics for Object-Oriented Software Engineering (MOOSE) and Metrics for Object-Oriented Design (MOOD) that have been describing individual characteristic of OO property now are integrated by means of AHPs pairwise comparison to deliver an estimate quantitative value of OO software design quality. A series of experiments were conducted by applying the approach to students works in Fundamental of Programming class. The results of applying AHP scheme were compared to experts judgments for verification. The result demonstrates the solidity of AHP mechanism for the intended purpose of measuring OO design quality.

An acceptable measure of software quality must quantify software complexity. Traditional software metrics such as lines of code, software science and cyclomatic complexity are investigated as possible indicators of complexity of object-oriented systems. This research reports the effects of polymorphism and inheritance on the complexity of object-oriented systems are measured by the traditional metrics. The results of this research indicate that traditional metrics are applicable to the measurement of the complexity of object-oriented systems.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Software patterns are often considered as an important methodology in the process of analysis and design of a software, when the proposed architecture of the software is a complex one. During the process of reverse engineering, design patterns become helpful to analyze the source code. A pattern-based analysis often improves maintainability of the source code. The proposed reverse engineering approach considers software metrics for the development of the datasets. The study is comprises of two phases such as preparation of requisite dataset based on object-oriented software metrics and identification of design patterns. Preparation of dataset is carried out using pattern instances from source code, mapped with software metrics. Analysis of design patterns is accomplished by considering a learning-based method i.e., Artificial Neural Network. In this study, two open source software such as JRefactory and Quaqua have been considered to exploit the idea of reverse engineering.

Organizations are becoming increasingly concerned about software quality. In object-oriented (OO) systems, quality is characterized by measurements of internal quality attributes. An efficient and proper method to analyze software quality in the absence of fault-prone or defective data labels is cluster analysis. The aim of this paper is to find similarities among project structures by measuring characteristics of internal software quality. In a sample of 150 open-source software systems, we evaluated software using macro and micro categories. Results obtained using cluster analysis indicated that some domains such as Graphics, Games, and Development tend to have similarities in specialization, abstraction, stability, and complexity. These results exploit the ability of OO software metrics to find similar behavior across domains. The results provide an immediate view of the trends and characteristics of internal software quality of Java systems that need to be addressed so that software systems can continue to be maintainable.

Android, being the most widely used mobile operating system of choice, also poses a security risk of mass privacy intrusion and sensitive data theft. Hence, as a mitigation effort, it is imperative to identify robust methods in identifying android malwares. In this paper, we extend our previous research work titled “Anatomizing Android Malwares” [20] and bring forward a novel method of identifying malicious android apps using object-oriented software metrics and supervised machine learning techniques. Initially, we retrieve object-oriented software metrics from the decompiled android app, and then this metrics tuple is tagged either as benign or malware using VirusTotal service. Finally, the set of metrics tuple acts as input features in machine learning algorithms. We evaluated the performance and stability of our forty-eight different machine-learned models against 5774 android apps collected from AndroZoo [1]. The discriminatory power of every machine-learned model is measured using its area under ROC curve (AUC), accuracy and F-measure values. Our method yields AUC, accuracy and F-measure of 1.0, 100% and 1.0, respectively.

This paper shows that existing software metric tools interpret and implement the definitions of object-oriented software metrics differently. This delivers tool-dependent metrics results and has even implications on the results of analyses based on these metrics results. In short, the metrics-based assessment of a software system and measures taken to improve its design differ considerably from tool to tool. To support our case, we conducted an experiment with a number of commercial and free metrics tools. We calculated metrics values using the same set of standard metrics for three software systems of different sizes. Measurements show that, for the same software system and metrics, the metrics values are tool depended. We also defined a (simple) software quality model for maintainability based on the metrics selected. It defines a ranking of the classes that are most critical wrt. maintainability. Measurements show that even the ranking of classes in a software system is metrics tool dependent.

Software metrics serve as a significant issue to improve software quality. It is an important research of software engineering. In line with the methodologies of object-oriented analysis and design widely developed, many software metrics techniques have been proposed. However, not many focus on the metrics evaluation of an inheritance hierarchy. In this paper, we propose a novel concept named unit repeated inheritance (URI) in Z notation to realize object-oriented software metrics. The approach describes an inheritance level technique (ILT) method as a guide to measure the software complexity of an inheritance hierarchy. The measures of inheritance metrics are formed based on the proposed mechanism. Also, we use Lex and Yacc to construct a windowing tool which is used in conjunction with a conventional C++ programming environment to assist a programmer to analyze and measure his/her C++ programs.

Software development costs can be greatly reduced by creating well-designed software. Object-oriented software metrics can assist in designing high-quality systems. Package cohesion metric is found to be highly related to software testability. We have developed a package cohesion metric that has proved its ability in software maintainability and testability predictions as early as the design phase of software development. In this paper, we expand our previous works by proposing a logistic regression model that can predict software testability regarding its costs and efforts. The proposed model can predict the package testability during the design phase, which can save many resources of software development life. This early prediction helps developers to discover the poorly designed packages and take decisions to reduce any further costs and efforts that might happen in the future. The experiments showed that the proposed package cohesion metric could assess the design cohesiveness of software packages.

Traditional software metrics, such as code coverage, McCabe complexity, etc. address the needs of a software engineer. In contrast, managers of software development organizations face a broader set of issues. For example, an executive responsible for multiple products and releases has to understand the customer views of those products and put in place, appropriate actions across the products that will be of high business value. We present examples of data and metrics associated with service (i.e. product support) for field reported problems and customer critical situations, and customer satisfaction ratings across a comprehensive range of software product attributes. Issues arising in the data integration, analysis, and correlation of these metrics are highlighted. A systematic methodology for statistical analysis of the data that enables management to derive key, actionable drivers of change through the metrics is presented. We also present an outline of a decision support system developed at IBM for tracking and using software metrics to enable executives to make better informed decisions in supporting their products.

Automated maintenance of object-oriented software system designs via refactoring is a performance demanding combinatorial optimization problem. In this study, we made an empirical comparative study to see the performances of alternative search algorithms under a quality model defined by an aggregated software fitness metric. We handled 20 different refactoring actions that realize searches on design landscape defined by combination of 24 object-oriented software metrics. The investigated algorithms include random, steepest descent, multiple first descent, multiple steepest descent, simulated annealing and artificial bee colony searches. The study is realized by using a tool called A-CMA developed in Java that accepts bytecode compiled Java codes as its input. The empiricial study showed that multiple steepest descent and population-based artificial bee colony algorithms are two most suitable approaches for the efficient solution of the search based refactoring problem.

This chapter describes the foundation and properties of object-oriented software measures. Many software measures for object-oriented applications have been developed and tested in the development environment. However, the process of defining new measures is still alive. The reason for such development lies in difficulties associated with understanding and maintaining object-oriented applications. It is still difficult to relate the measures to the phenomena we want to improve. Do our measurements indicate problems in reliability, maintenance, or too much complexity of some portions of the application? In order to reduce the complexity of software, new development methodologies and tools are being introduced. An example of the new approach to development is separation of concern. The tools, such as Aspect/J (Kiezales et al., 1997) or Hyper/J (Ossher & Tarr, 1998), facilitate the development process. There does not seem to be a sound metrics suite to measure complexity and efficiency of applications developed and coded with Aspect/J or Hyper/J. In this chapter, we attempt to review the current research into object-oriented software metrics and suggest theoretical framework for complexity estimation and ranking of compositional units in object-oriented applications developed with Hyper/J.