Software Complexity Metrics: A Survey

2001

ABSTRACT: A review of the existing work on software complexity metrics shows the use of McCabe's cyclomatic number, Halstead's software science, the number of program statements, the Oviedo's dataflow complexity graph. None of these metrics satisfied all the nine desirable properties of a complexity metric. The conclusion is that the choice of the complexity metric is dependent on the choice of the software development methodology and the programming language.

Software measurement is very important and complex issue, especially when dealing applications into the practice. This paper discusses the comparison of various procedural oriented metrics which are used for the measurement of several properties of source code such as size, complexity, and error. It is widely accepted that sizing or predicting the volume of software process is one of the most dominant aspects of cost estimating. Generally cost estimation model are based upon the strong assumption that size and complexity influences development effort and still there is no unique metric which can work during all of the development phases. In order to improve the software quality and the maintainability, it is necessary to control the software complexity by measuring the related aspects.

approved:

People demand for software quality is growing increasingly, thus different scales for the software are growing fast to handle the quality of software. The software complexity metric is one of the measurements that use some of the internal attributes or characteristics of software to know how they effect on the software quality. In this paper, we cover some of more efficient software complexity metrics such as Cyclomatic complexity, line of code and Hallstead complexity metric. This paper presents their impacts on the software quality. It also discusses and analyzes the correlation between them. It finally reveals their relation with the number of errors using a real dataset as a case study.

Over the last several years, software engineers have devoted a great effort to measuring the complexity of computer programs and many software metrics have been introduced. These metrics have been invented for the purpose of identifying and evaluating the characteristics of computer programs. But, most of them have been defined and then tested only in a limited environment. Scientists proposed a set of complexity metrics that address many principles of object oriented software production to enhance and improve software development and maintenance. The aim of this paper is to present taxonomy of complexity metrics that, separately, evaluate structural and dynamic characteristics of size, control flow, and data. While most invented metrics applied to only the method and class levels of complexity, our approach uses metrics on each of the three levels: class, method, and statement.

It is considerably recognized that in software engineering, the utilization of metrics at the initial stages of the object oriented software can encourage designers to bring about a noticeable improvement decisions. In this paper, a literature review and classification scheme for software complexity measurement researches is presented. The study shows that an expanding volume of complexity measurement has been conducted in diverse range of areas. As software complexity is an important factor that ought to be recognized at different levels of software development and it requires in profundity study with comprehension. Examinations of the chosen scrutinizes are completed and holes in the exploration are recognized. Analyses of the selected researches are completed and crevices in the research are identified. A complete record of references is explored. This review is planned to furnish driving force in exploration and help simulate further interest.

There are different sources of software complexity. A large set of complexity metrics can measure distinct program attributes to show different program size indicators. Nevertheless, the size of a program must be obtained from the overall program complexity based on the values of all program factors. Based on the concept that software complexity is a measurement of the resources expended through the software life cycle, and the fact that a program may be approached from three distinct perspectives, the complexity factors are classified into three complexity domains: syntactical, functional, and computational. Each domain represents the magnitudes of the factors in one of the three dimensions: length, time, and level or depth. Using these ideas, in this article we define ordinal measures of the complexity factors based on discrete mathematical structures of programs and the information content or entropy. transform the different domains of software complexity in linear metric spaces in order to represent a program by a set of vectors whose magnitudes and distances represent metrics of the program components, and define a "unified complexity metric" of the program size and the effort needed to produce it over the multilinear complexity space conformed by the three complexity spaces. These metrics may be used to define a statistical method that estimates the size of a program and the effort needed to produce it from the external system design, the productivity in software projects, and the quality and value of software products.

Communications of the ACM, 1986

System research and information technologies

The use of code metrics allows software developers and project managers to evaluate various features of the software (to be built or already in existence), predict workload, determine software complexity and reliability, and quantify the quality of software systems being developed. Articles written in recent years have proposed various methods for solving this problem. However, there is still no very effective approach to measuring software complexity. This article provides a brief overview of existing software complexity metrics and proposes a new hybrid method for computing software complexity. The proposed hybrid method for evaluating software complexity combines the key features of the Halsted, Maccabe, and SLOC metrics and also allows for a more efficient assessment of complexity.

2011

Software quality depends on several factors such as on time delivery; within budget and fulfilling user's needs. Complexity is one of the most important factors that may affect the quality. Therefore, measuring and controlling the complexity result in improving the quality. So far, most of the researches have tried to identify and measure the complexity in design and code phase. However, when we have the code or design for software, it is too late to control complexity. In this article, with emphasis on Requirement Engineering process, we analyze the causes of software complexity, particularly in the first phase of software development, and propose a requirement based metric. This metric enables a software engineer to measure the complexity before actual design and implementation and choose strategies that are appropriate to the software complexity degree, thus saving on cost and human resource wastage and, more importantly, leading to lower maintenance costs.