Showing papers on "Halstead complexity measures published in 2003"

Empirical analysis of CK metrics for object-oriented design complexity: implications for software defects

Abstract: 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.

Predicting maintenance performance using object-oriented design complexity metrics

Abstract: The Object-Oriented (OO) paradigm has become increasingly popular in recent years. Researchers agree that, although maintenance may turn out to be easier for OO systems, it is unlikely that the maintenance burden will completely disappear. One approach to controlling software maintenance costs is the utilization of software metrics during the development phase, to help identify potential problem areas. Many new metrics have been proposed for OO systems, but only a few of them have been validated. The purpose of this research is to empirically explore the validation of three existing OO design complexity metrics and, specifically, to assess their ability to predict maintenance time. This research reports the results of validating three metrics, Interaction Level (IL), Interface Size (IS), and Operation Argument Complexity (OAC). A controlled experiment was conducted to investigate the effect of design complexity (as measured by the above metrics) on maintenance time. Each of the three metrics by itself was found to be useful in the experiment in predicting maintenance performance.

Product metrics for object-oriented systems

Abstract: We survey metrics proposed for object-oriented systems, focusing on product metrics. The survey is intended for the purposes of understanding, classifying, and analyzing ongoing research in object-oriented metrics. The survey applies fundamental measurement theory to artifacts created by development activities. We develop a mathematical formalism that captures this perspective clearly, giving appropriate attention to the peculiarities of the object-oriented system developmenr process. Consistent representation of the available metrics, following this mathematical formalism, shows that current research in this area contains varying coverage of different products and their properties at different development stages. The consistent representation also facilitates several analyses including aggregation across metrics, usage across metrics, equivalent formulation of metrics by multiple researchers, and exploitation of traditional metrics for object-oriented metrics. We also trace the chronological development of research in this area, and uncover gaps that suggest opportunities for future research.

Design and Code Complexity Metrics for OO Classes

Abstract: classes consisting solely of virtual functions classes with a number of member functions, where one particular member function was much more complex than the other member functions. In the case of a class consisting solely of virtual functions, the following problems were identified for each metric: The code complexity WMC metric, since it calculates the McCabe’s cyclomatic complexity for each member function, calculates an empty virtual function as cyclomatic complexity = 1. Thus empty virtual functions add to the complexity measure of a class. The AMC metric has a similar problem, although due to the averaging nature of the metric the problem is not as bad as with

Complexity of Algorithms and Software Metrics.

Abstract: The aim of this paper is to introduce a system structure in the diversity of algorithmic complexity measures for a study of computer software. We consider basic concepts and constructions from the theory of algorithmic complexity and develop a system structure in this theory, especially, for the axiomatic complexity theory. An important class of dual complexity measures is studied. We demonstrate how software metrics fit in the lattice of algorithmic complexity measures. Relations between software metrics and algorithmic complexity are analyzed.

Identifying effective software metrics using genetic algorithms

Abstract: Various software metrics may be used to quantify object-oriented source code characteristics in order to assess the quality of the software. This type of software quality assessment may be viewed as a problem of classification: given a set of objects with known features (software metrics) and group labels (quality rankings), design a classifier that can predict the quality rankings of new objects using only the software metrics. We have obtained a variety of software measures for a Java application used for biomedical data analysis. A system architect has ranked the quality of the objects as low, medium-low, medium or high with respect to maintainability. A commercial program was used to parse the source code identifying 16 metrics. A genetic algorithm (GA) was implemented to determine which subset of the various software metrics gave the best match to the quality ranking specified by the expert. By selecting the optimum metrics for determining object quality, GA-based feature selection offers an insight into which software characteristics developers should try to optimize.

Statische Analyse von Java-Anwendungen: Eignen sich Lines-of-Code-Metrik und Halstead-Länge?

Abstract: Many of the recently developed software systems are implemented in Java. For these systems, activities presently are mainly related to software development tasks rather than to dedicated software maintenance tasks. For these Java systems, therefore, experimental confirmation of established metrics for measuring code quantities that are related to software maintenance is not available. This also includes very basic size measures such as the LOC metric and the Halstead length. In this article, the application of these metrics for Java systems as well as some of the associated difficulties are outlined. The presented results are based on experimental data and include empirical correlations between the basic size metrics as well as newly derived scaling laws which are suitable for maintenance related software measurement.

Correlation between Amount-of-Reuse Metrics and Other Software Measures with Respect to Programming Code in C++

Abstract: In recent years, there have been several proposals for amount-of-reuse metrics. However, it is not clear if these metrics measure anything different from other software metrics that are often generally used. Besides, the relationship between these metrics is also unclear. Without a clear understanding, the true added value provided by these metrics remains unknown. In this paper, an analysis of the existing amount-of-reuse metrics is presented and a subset of these is selected, on the basis of their industrial applicability, for further investigation. These metrics are then applied to a collection of different software products to obtain an understanding of the level of correlation that exists between them and other well-known software metrics such as cyclomatic complexity, volume and lines of code. Our analysis suggests that the selected subset of amount-of-reuse metrics provides a relatively independent view of the analyzed code.