Syntactic Complexity Metrics and the Readability of Programs in a Functional Computer Language

Nowadays, software is expected to have an extended lifespan, which makes the evaluation of its complexity at the early stages critical in upcoming maintenance. Indeed, complexity is proportional to the evolution of software. Software metrics were introduced as tools that allow us to obtain an objective measurement of the complexity of software. Hence, enabling software engineering to assess and manage software complexity. Reducing software costs is one of the major concerns of software engineering which creates an increasing need for new methodologies and techniques to control those costs. Software complexity metrics can help us to do so. In this paper, we would investigate how those metrics can be used to reduce software costs. We would first analyze the most popular complexity metrics and distinguish their properties. Then, we will show how each of those metrics fit within the software life cycle. Finally, we will provide a detailed approach to use the complexity metrics to reduce software costs.

A methodology for generating an optimum software quality classification tree using software complexity metrics to discriminate between high-quality modules and low-quality modules is proposed. The process of tree generation is an application of the AIC (Akaike Information Criterion) procedures to the binomial distribution. AIC procedures are based on maximum likelihood estimation and the least number of complexity metrics. It is an improvement of the software quality classification tree generation method proposed by Porter and Selby (1990) from the viewpoint that the complexity metrics are minimized. The problems of their method are that the software quality prediction model is unstable because it reflects observational errors in real data too much and there is no objective criterion for determining whether the discrimination is appropriate or not at a deep nesting level of the classification tree when the number of sample modules gets smaller. To solve these problems a new metric is introduced and its validity is theoretically and experimentally verified. In our examples, complexity metrics written in C language, such as lines of source code, Halstead's (1977) software science, McCabe's (976) cyclomatic number, Henry and Kafura's (1981) fan-in/out and Howatt and Baker's (1989) scope number, are investigated. Our experiments with a medium-sized piece of software (85 thousand lines of source code; 562 samples) show that the software quality classification tree generated by our new metric identifies the target class of the observed modules more efficiently using the minimum number of complexity metrics without any significant decrease of the correct classification ratio (76%->72%) than the conventional classification tree.

Predicting aging-related bugs using software complexity metrics

Regression modelling of software quality: empirical investigation

Software complexity metrics have been shown to be very closely related to the distribution of faults in software. This paper focuses on identification of fault-prone software modules based on discriminant analysis and classification for software that are developed by CHILL language. We define software complexity metrics for CHILL language. The technique is successful in classifying software modules with relatively low error rare. This procedure shows very useful method in the detection of software modules in the fault of programs with high potential.

Modern software systems increasingly rely on numerical algorithms that require high or arbitrary precision, especially in scientific computing, numerical modeling, optimization, and data analysis. The use of high-precision arithmetic significantly affects the computational behavior of programs, since the cost of arithmetic and transcendental operations depends on the precision level of numerical data representation. In such conditions, predicting program execution time and estimating computational complexity become non-trivial tasks, particularly in distributed computing environments. This paper presents an analysis of existing software complexity metrics with respect to their applicability to programs performing high-precision computations in distributed systems. Classical software metrics, including size metrics, control flow complexity metrics, and data flow complexity metrics, are considered and systematized. Their main limitations are identified in the context of high-precision arithmetic, where the assumption of constant-time arithmetic operations is no longer valid. It is shown that classical complexity metrics do not account for the dependence of computational cost on the mantissa length of numerical variables and the actual cost of arithmetic operations. As a result, programs with relatively simple control structures but intensive high-precision computations may require significantly more computational resources than programs with complex control logic implemented using standard floating-point arithmetic. The study substantiates the necessity of extending existing complexity evaluation approaches by incorporating parameters related to numerical precision and operation cost. The computational complexity of a program is proposed to be considered as a function of the types of arithmetic operations, their execution frequency, and the mantissa length of numerical data. Such an approach allows for a more accurate estimation of execution time and resource consumption, which is especially important for programs executed in distributed computing systems where communication overhead and data transfer costs play a significant role. The obtained results can be used for preliminary performance estimation, rational resource allocation, and the selection of appropriate parallelization strategies for high-precision numerical software in distributed environments.

This paper is the reply to the paper "Erhard Konrad: Software Metrics, Measurement Theory, and Viewpoints - Critical Remarks on a New Approach", which was published in SIGPLAN Notices in March 1991. Konrad imputes that the authors of /ZUSE89/ misapply measurement theory, and confuse reality with mathematics. The statements of Konrad are wrong. It will be shown that Konrad misunderstood important concepts of measurement theory. Konrad's critical statements to our approach deny theoretical investigations of software complexity metrics. That has fatal consequences for the use of software complexity metrics in practice, to make statistics, and to calculate correlations.

This paper is the reply to the paper "Erhard Konrad: Application of Measurement Theory to Software Metrics - Comments on the Bollmann-Zuse Approach" which is also published in this issue (November 92) of SlGPLAN Notices. Konrad is criticizing our approach: "Horst Zuse; Peter Bollmann: Using Measurement Theory to Describe the Properties and Scales of Software Complexity Metrics", which was published in SlGPLAN Notices (8)89. Konrad criticized the first time our paper in SIGPLAN Notices in March 1991. We replied in SlGPLAN Notices May 1991 to this criticism. In this issue (November 1992) Konrad imputes again that we have failed to achieve our goals of refuting his criticism. We will show that Konrad has a totally different view of established concepts of measurement theory as treated by Roberts, Krantz, Luce, Suppes and Tversky.

With the evolution of the software development, the scale of the software is increasingly growing to the extent that we cannot hand it easily. Some metrics are proposed to measure the complexity of software in last a few years. This article aims at a comprehensive survey of the metric of software complexity. Some classic and efficient software complexity metrics, such as Lines of Codes (LOC), Halstead Complexity Metric (HCM) and Cyclomatic Complexity Metric (CCM), are discussed and analyzed first. Then, some other approaches driven from above classic metrics are also discussed. The comparison and the relationship of these metrics of software complexity are also presented.

Applications of a relative complexity metric for software project management

For the past two years the Software Management Research Unit at General Electric has been investigating several areas of human factors in software engineering with support from Engineering Psychology Programs of the Office of Naval Research. There have been two major thrusts in this research. The first thrust investigated the effects of several modern programming practices on programmer efficiency. The second thrust investigated the prediction of programmer performance from software complexity metrics such as those proposed by Halstead and McCabe. This research program consisted of separate experiments on the understanding, modification, debugging, and construction of software, each using professional programmers. Each experiment investigated both the effects of experimentally manipulated programming practices, and the values of complexity metrics computed from the programs employed.

The concept of complexity is used in many areas of computer science and software engineering. Software complexity metrics can be used to evaluate and compare quality of software development and maintenance processes and their products. Complexity management and measurement is especially important in novel programming technologies and paradigms, such as aspect-oriented programming, generative programming, and metaprogramming, where complex multilanguage and multi-aspect program specifications are developed and used. This paper analyzes complexity management and measurement techniques, and proposes five complexity metrics (Relative Kolmogorov Complexity, Metalanguage Richness, Cyclomatic Complexity, Normalized Difficulty, Cognitive Difficulty) for measuring complexity of metaprograms at information, metalanguage, graph, algorithm, and cognitive dimensions.

In this paper we propose the quantitative analysis of the complexity of a simple reference game implemented on a particular gaming platform as means for characterizing how the platform succeeds in easing the development of networked multiplayer games. We first present our own open source tool based on Sneed's Object-Point (OP) method for the automatic quantitative assessment of the complexity of a software API by analyzing a source code using the API. We then apply our tool, together with the recently released JSComplexity tool based on classical software complexity metrics, to compare two platforms for networked multiplayer games, the open source realXtend Tundra SDK and the proprietary Union. As the reference games we use existing implementations of the simple Pong game atop the two platforms. Our data shows that these complexity metrics reveal API design tradeoffs, resulting in complexity differences in the reference games.

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.

There are several software complexity metrics in use today. Halstead's software science, McCabe cyclomatic number and lines of code (LOC) are most popular of them. A great weakness of these metrics is that they measure different complexities for a given program. Thus, it will be very clever to join them. We have developed a model which combines above three metrics and present it in this paper.