Using Z to specify object-oriented software complexity measures

There is no software metrics based on object-oriented programming languages (OOPLs) developed to help object-oriented software development. A graph-theoretical complexity metric to measure object-oriented software complexity is described. It shows that inheritance has a close relation with the object-oriented software complexity, and reveals that misuse of repeated (multiple) inheritance will increase software complexity and be prone to implicit software errors. An algorithm to support this software metric is presented. Its time complexity is O(n/sup 3/). >

Software metrics serve as a significant issue to improve software quality. It is an important research of software engineering. In line with the methodologies of object-oriented analysis and design widely developed, many software metrics techniques have been proposed. However, not many focus on the metrics evaluation of an inheritance hierarchy. In this paper, we propose a novel concept named unit repeated inheritance (URI) in Z notation to realize object-oriented software metrics. The approach describes an inheritance level technique (ILT) method as a guide to measure the software complexity of an inheritance hierarchy. The measures of inheritance metrics are formed based on the proposed mechanism. Also, we use Lex and Yacc to construct a windowing tool which is used in conjunction with a conventional C++ programming environment to assist a programmer to analyze and measure his/her C++ programs.

Object-oriented technology, including object-oriented analysis (OOA), object-oriented design (OOD), and object-oriented programming (OOP), is a new promising approach to developing software systems to reduce software costs and to increase software extensibility, flexibility, and reusability. Software metrics are widely used to measure software complexity and assure software correctness. This paper proposes a metric to measure object-oriented software. Also, an important factor called URIs, is conducted to build the metric. This approach describes a graph-theoretical method for measuring the complexity of the class hierarchy. The proposed metric shows that inheritance has a close relation with object-oriented software complexity and reveals that misuse of repeated (multiple) inheritance will increase software complexity and be prone to implicit software errors. >

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.

Object-oriented software metrics are important in software engineering field for measurement of the software quality, size estimation, complexity and effort. Object oriented software development is the most popular and best practice in software development. Object oriented software metrics can be used for measuring extend of object orientedness of a program. These quantities are important information indicators, that can be helpful for a software developer in take decisions for designing good software. It is proven that the software metrics provide quantitative information about the structure of the code, which can be used to determine the reliability of software. The design of the software is highly recommended to be object oriented in the software development environment. Software metrics specific to programs that have object oriented design can be used to measure the quality of the software like inheritance, assessing the effects of coupling, the complexity of the code, size aspects, etc, of the software developed in such an environment. Software measurement is a way for assessing the quality of software. Many attributes can define quality of a software, internal (size, complexity) as well as external (reliability)[14]. Often internal attributes are contributing factors to external attributes. Reliability as a term means the degree to which a component, product or system executes specified functions for a specific period of time under specified conditions. Software reliability is the software being trustworthy of the specifications. The aim of the work is to model the relationship between reliability of object oriented software to the object oriented design metrics and predict reliability of software.

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.

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.

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.

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

As a first step towards an integration of Object-Oriented Programming and Declarative Programming we present a purely algebraic framework for the specification of inheritance and object hierarchies, based on the known idea of representing records as order-sorted feature terms. Specifications in our formalism have an intended semantics which can be formally characterized as an initial algebra. We argue that the new formalism improves over some shortcomings of related approaches. In particular, we can express a novel mechanism called genetic inheritance, which allows to deal with multiple inheritance in a very flexible way.

The current study presents an HPSG analysis for verbal reduplication in Mandarin Chinese. After discussing its interaction with Aktionsarten and aspect markers, we argue that it is a morphological rather than syntactic process. We put forward a lexical rule for verbal reduplication in Mandarin Chinese and the different forms of reduplication are captured in an inheritance hierarchy. The interaction between verbal reduplication and aspect marking is handled by multiple inheritance. This analysis covers all forms of verbal reduplication in Mandarin Chinese and has none of the shortcomings of the previous analyses.

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.

This paper shows that existing software metric tools interpret and implement the definitions of object-oriented software metrics differently. This delivers tool-dependent metrics results and has even implications on the results of analyses based on these metrics results. In short, the metrics-based assessment of a software system and measures taken to improve its design differ considerably from tool to tool. To support our case, we conducted an experiment with a number of commercial and free metrics tools. We calculated metrics values using the same set of standard metrics for three software systems of different sizes. Measurements show that, for the same software system and metrics, the metrics values are tool depended. We also defined a (simple) software quality model for maintainability based on the metrics selected. It defines a ranking of the classes that are most critical wrt. maintainability. Measurements show that even the ranking of classes in a software system is metrics tool dependent.

Software metrics: fault content estimation and software process control