The program dependence graph in a software development environment

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.

The ULowell Data Flow Project combines dataflow hardware, dataflow software, and a data flow development environment. The hardware component, a data flow coprocessor card, utilizes seven NEC 7281 Image Pipelined Processors. Each chip models a static dataflow computation and is programmable. The coprocessor was designed and implemented by ULowell personnel and uses an AMIGA 2000 as a host. The software component currently consists of a library of data flow image processing algorithms and an evolving software development environment. Currently the image processing library includes typical imaging operations such as: edge enhancement, filtering, histogramming, and affine transformation. The software development environment (SDE) is depicted in Figure 1. The SDE contains a Data Flow Graph Editor which programmers use to design their data flow code. The data flow algorithm can then be converted directly into NEC data flow assembly code which is then assembled using the ULowell Data Flow Assembler. The assembler differs from NEC's assembler in that it can produce relocatable code. The object code output of the assembler is given to the Data Flow Resource Manager. The resource manager monitors the available resources within the chips. Thus, if a single process does not totally utilize a chip's table space or memory, then a second process may be concurrently loaded onto the same chip. The ability to have multiple data flow processes coexisting within a single chip is unique to the ULowell environment. The data flow resource manager can download and monitor code to either the hardware or to a software simulator/debugger. The simulator/debugger can monitor and trace data flow tokens as they proceed through the chip. Output of the simulator/debugger can be fed back into the data flow graph editior to visually trace token flow through the original program design. The last component of our SDE is a High Level Language translator which can compile programs written in SISAL, a high level language for parallel computation, down to NEC 7281 assembly language. We have already implemented the relocatable assembler, and the data flow resource manager. Prototype versions of the high level translator, simulator/debugger and graph/editor are currently being implemented.

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.

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.

Predicting aging-related bugs using software complexity metrics

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.

Regression modelling of software quality: empirical investigation

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.

A dependence model for reverse engineering should treat procedures in a modular fashion and should be fine-grained, distinguishing dependences that are due to different variables. The program dependence graph (PDG) satisfies neither of these criteria. We present a new form of dependence graph that satisfies both, while retaining the advantages of the PDG: it is easy to construct and allows program slicing to be implemented as a simple graph traversal. We define 'chopping', a generalization of slicing that can express most of its variants, and show that, using our dependence graph, it produces more accurate results than algorithms based directly on the PDG.

A dependence model for reverse engineering should treat procedures in a modular fashion and should be fine-grained, distinguishing dependences that are due to different variables. The program dependence graph (PDG) satisfies neither of these criteria. We present a new form of dependence graph that satisfies both, while retaining the advantages of the PDG: it is easy to construct and allows program slicing to be implemented as a simple graph traversal. We define 'chopping', a generalization of slicing that can express most of its variants, and show that, using our dependence graph, it produces more accurate results than algorithms based directly on the PDG.

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

This article reports on the defintion and the measutement of the software complexity metrics of Halstead and McCabe for programs written in the functional programming language Miranda. An automated measurement of these metrics is described. In a case study, the correlation is established between the complexity metrics and the expert assessment of the readability of programs in Miranda, and compared with those for programs in Pascal.

We present an approach to identifying similar code in programs based on finding similar subgraphs in attributed directed graphs. This approach is used on program dependence graphs and therefore considers not only the syntactic structure of programs but also the data flow within (as an abstraction of the semantics). As a result, there is no tradeoff between precision and recall; our approach is very good in both. An evaluation of our prototype implementation shows that the approach is feasible and gives very good results despite the non polynomial complexity of the problem.