Showing papers on "Halstead complexity measures published in 1999"

Prediction of fault-proneness at early phase in object-oriented development

Abstract: To analyse the complexity of object-oriented software, several metrics have been proposed. Among them, Chidamber and Kemerer's (1994) metrics are well-known object-oriented metrics. Also, their effectiveness has been empirically evaluated from the viewpoint of estimating the fault-proneness of object-oriented software. In the evaluations, these metrics were applied, not to the design specification but to the source code, because some of them measure the inner complexity of a class, and such information cannot be obtained until the algorithm and the class structure are determined at the end of the design phase. However, the estimation of the fault-proneness should be done in the early phase so as to effectively allocate effort for fixing the faults. This paper proposes a new method to estimate the fault-proneness of an object class in the early phase, using several complexity metrics for object-oriented software. In the proposed method, we introduce four checkpoints into the analysis/design/implementation phase, and we estimate the fault-prone classes using applicable metrics at each checkpoint.

Empirical evaluation of reuse sensitiveness of complexity metrics

Abstract: Measuring software products and processes is essential for improving software productivity and quality. In order to evaluate the complexity of object-oriented software, several complexity metrics have been proposed. Among them, Chidamber and Kemerer’s metrics are the most well-known for object-oriented software. Their metrics evaluate the complexity of the classes in terms of internal, inheritance, and coupling complexity. Though the reused classes of the class library usually have better quality than the newly-developed ones, their metrics deal with inheritance and coupling complexity in the same way. This article first proposes a revision of the Chidamber and Kemerer’s metrics which can be applied to software which had been constructed by reusing software components. Then, we give an analysis of data collected from the development of an object-oriented software using a GUI framework. We compare the original metrics with the revised ones by evaluating the accuracy of estimating the effort to fix faults and show the validity and usefulness of the revised metrics.

Empirical analysis of the correlation between amount-of-reuse metrics in the C programming language

Abstract: In recent years, there have been several proposals for amount-ofreuse metrics. However, it is not often clear if these metrics measure anything different than already used software metrics, or what the relations between these metrics really are. Without this, the true added value provided by each metric is unknown. In this paper, an analysis of the existing amount-of-reuse metrics is presented and a portion of them are selected on the basis of their industrial applicability. These metrics are then applied to a collection of public domain 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. Through this process we find that a subset of the selected amount-of-reuse metrics provide a relatively independent view of the analyzed code.

A multi-layered system of metrics for the measurement of reuse by inheritance

Abstract: In spite of the intense efforts of metrics research, the impact of object-oriented software metrics is, for the moment, still quite reduced. The cause of this fact lies not in an intrinsic incapacity of metrics to help in assessing and improving the quality of object-oriented systems, but in the unsystematic, dispersed and ambiguous manner of defining and using the metrics. In this paper, we define a multi-layered system of metrics that measures inheritance-based reuse, and we propose a number of metric definitions for the layers of this system. By defining and using such systems of metrics, we obtain a unitary approach of related measures and a systematic, yet flexible manner of defining new measures as part of a particular metrics system. Organising metric definitions in systems of metrics contributes to (a strongly needed) order among object-oriented metrics, thus increasing their reliability and usability.

Static Analyser for Java-Based Object-Oriented Software Metrics

Abstract: Software metrics play a major role In the software development. Not only software metrics help in understanding the size and complexity of software systems, but they are also helpful in improving the quality of software systems. For object-oriented systems, a large number of metrics have been established. These metrics should be supported by automated collection tools. Automated tools are useful for measuring and improving the quality of software systems. One such tool is a static analyser. A static analyser has been developed for a subset of Java language. A number of object-oriented software metrics has been evaluated using attribute grammar approach. Attribute grammar approach is considered as a well-defined approach to the software metrics evaluation since it is based on the measurement of the source code itself. New definitions for a number of object-oriented metrics have been specified using attribute grammars. This tool has been built using C language. Lexical analyser and syntax analyser have been generated using lex and yacc tools under linux operating system. Four object-oriented metrics have been evaluated. These metrics are Depth of Inheritance Tree metric, Number of Children metric, Response For a Class metric, and Coupling Between Object Classes metric. The software metrics will be produced in the common metrics format that is used in SCOPE project.

A Fractal Software Complexity Metric Analyser

Abstract: As we try to fulfill the requirements upon quality of the software products we cannot avoid the use of the complexity metrics. There is a lot of different metrics and also there are hundreds of tools for analyzing the software with some of those metrics. However, since all tools available are concentrated only on some specific programming metrics, for a comprehensive analysis one has to use a lot of different tools. We wanted to derive an environment that would include all of the mostly used metrics, and since we are also developing new metrics ourselves, we developed a tool called Software Complexity Analyzer, that beside classical metrics incorporates also more universal fractal metrics.