Software Structure Metrics Based on Information Flow

Structured design methodologies provide a disciplined and organized guide to the construction of software systems. However, while the methodology structures and documents the points at which design decisions are made, it does not provide a specific, quantitative basis for making these decisions. Typically, the designers' only guidelines are qualitative, perhaps even vague, principles such as "functionality," "data transparency," or "clarity." This paper, like several recent publications, defines and validates a set of software metrics which are appropriate for evaluating the structure of large-scale systems. These metrics are based on the measurement of information flow between system components. Specific metrics are defined for procedure complexity, module complexity, and module coupling. The validation, using the source code for the UNIX operating system, shows that the complexity measures are strongly correlated with the occurrence of changes. Further, the metrics for procedures and modules can be interpreted to reveal various types of structural flaws in the design and implementation.     

Using multiple metrics for analysis of improvement

To make global decisions about a project or group of projects, it is necessary to analyse several metrics in concert, as well as changes in individual metrics. This paper discusses several approaches to collective metrics analysis. First, classification tree analysis is described as a technique for evaluating both process and metrics characteristics. Next, the notion of a multiple metrics graph is introduced. Developed initially as a way to evaluate software switch quality, a multiple metrics graph allows collections of metrics to be viewed in terms of overall product or process improvement.This work was done while the authors were affiliated with Contel Technology Center, Chantilly, Virginia, USA.     

Empirical Research on the Application of a Structure-Based Software Reliability Model

Reliability engineering implemented early in the development process has a significant impact on improving software quality. It can assist in the design of architecture and guide later testing, which is beyond the scope of traditional reliability analysis methods. Structural reliability models work for this, but most of them remain tested in only simulation case studies due to lack of actual data. Here we use software metrics for reliability modeling which are collected from source codes of post versions. Through the proposed strategy, redundant metric elements are filtered out and the rest are aggregated to represent the module reliability. We further propose a framework to automatically apply the module value and calculate overall reliability by introducing formal methods. The experimental results from an actual project show that reliability analysis at the design and development stage can be close to the validity of analysis at the test stage through reasonable application of metric data. The study also demonstrates that the proposed methods have good applicability.      

Techniques of Successful Application of Factor Analysis in Software Measurement

Metrics in a software sense can be roughly divided into two groups, internal metrics and external metrics. Internal metrics can be measured directly, while external metrics are predicted using internal metrics. Factor analysis is a statistical technique which can be applied to analyze the structure of internal metrics and form a prediction model for external metrics A prediction model generated by using factor analysis needs further validation since factor analysis has a non-unique solution for the factor-loading matrix. The computational methodology to establish a model is presented as well as the validation process. This is illustrated by an empirical study of design metrics and a prediction model for design quality.     

A set of complexity metrics for guiding the software test process

Software verification and validation is a domain which is covered by many dynamic test, static analysis, and formal verification techniques. This presents a problem to practitioners with respect to selecting those suitable techniques which can be used successfully. The basic idea of the methodology presented here is to select test techniques which fit the software under test. A dynamic test technique requires that certain program elements are covered, will be sensitive to errors associated with these elements, because executing an error location is a precondition for revealing the error. Furthermore, it is likely that the probability of errors increases with complexity. Complexity can be characterized in terms of several properties which can be used to suggest various testing strategies. The complexity of the various software properties can be measured using appropriate complexity metrics. Properties with unusual high complexity measures should be tested very throughly. The approach described in this paper permits the selection of test techniques based on the values of the metrics with respect to a particular software product.     

基于继承图的面向对象软件复杂性度量研究

面向对象软件开发是一种新的可以减少成本、提高可用性和灵活性的高效的软件系统开发方法。复杂性度量在软件开发中起着非常重要的作用,它可减少整个开发周期的费用,但目前还没有成熟的用于面向对象软件复杂性的度量方法。文章首先通过继承图描述面向对象软件复杂性度量方法,然后讨论了单元重复继承算法,最后给出了具体实例。     

构件软件的回归测试复杂性度量

基于构件的软件构建方法目前被广泛使用在软件开发中,用于减少软件开发的工程成本和加快软件开发进度.在软件维护过程中,由于构件更新或者新版本的发布,基于构件的系统会受到影响,需要进行回归测试.对于指定的软件修改需求,维护者可以实施不同的修改手段.不同的修改手段会导致不同的回归测试复杂性,这种复杂性是软件维护成本和有效性的重要因素.目前的研究没有强调构件软件的回归测试复杂性问题.基于修改影响复杂性模型和度量,提出一种回归测试的复杂性度量框架.该度量框架包括两个部分:基于图的模型和形式化度量计算.该度量可以有效表示构件软件分别在构件和系统层面的回归测试复杂性因素,可视化地体现复杂性变化.然后根据模型,提出具体的度量计算方式.最后,通过实验研究,针对同一个构件软件的相同修改需求,利用若干个实验组进行独立修改实施,然后比较回归测试的复杂性.实验结果表明,所提出的度量方式是可行和有效的.     

完善验证的凝聚力测量方法以提升软件品质

无适当使用软件测量将可能引起软件低品质且高成本的窘态.凝聚力是软件品质重要因子之一如同维护度,可靠度和再利用度.软件模组品质的优劣必影响整体系统之品质的优劣.为了设计和维护高品质软件,软件专案经理人和软件工程师无可避免需引用软件凝聚力测量以衡量和产生高品质软件.提出以活路跃变量及视觉化变量纵距为分析基础之功能导向凝聚力测量方法.进而,以一系列实际案例来作实验验证,并以一组性质来作理论辩证所提的测量方法.因此一经完善定义,完善实验和完善辩证之凝聚力测量方法被提出用于当软件凝聚力强度的指标和因此增进软件品质.这凝聚力测量方法能容易嵌入CASE以帮助软件工程师确保软件品质.     

Measurement and Validation of Module Coupling Attributes

Module coupling is an important criterion for evaluating the quality of a software design. While the benefits of reduced module coupling are widely agreed upon, it has been difficult to measure coupling and thus understand it empirically. This study argues the definition of coupling, defines a set of coupling metrics based on the measurement of connections of a module within its running environment, and validates the set using principal component analysis. In an empirical study, the results indicate that these coupling metrics capture three distinct attributes of module coupling. These three attributes represent sources of variation not accounted for in the set of metric primitives and are appropriate for evaluating the coupling complexity of software. This study provides a set of validated measurements of the coupling complexity of software and a new way to evaluate module coupling measurements.Gregory A. Hall is an Assistant Professor of Computer Science at Texas State University. He is actively engaged in research and publication in the areas of software engineering, software measurement, software testing, and digital forensics. He is a member of the Association for Computing Machinery, the IEEE, and the IEEE Computer Society.Wenyou Tao received the MS degree in Computer Science and MS degree in Mining Engineering from the University of Idaho, and the MS and BS degrees from Chongqing University, China. He is currently a Quality Controller at LiveBridge Corporate, Canada. Previously, he worked as a QA engineer at Aventail Corporation and a software engineer at NET Information Systems, U.S.A.John C. Munson is a Professor of Computer Science at the University of Idaho. He has worked with a number of different commercial and governmental organizations in the development of software static and dynamic measurement techniques for software test evaluation. He has been actively engaged in research and publication in the areas of software reliability engineering, software measurement, and computer security. He is a member of the Association for Computing Machinery, the IEEE, the IEEE Computer Society and the IEEE Reliability Society. He has been closely associated with the IEEE International Symposium on Software. He has also been associated with the IEEE International Conference on Software Maintenance and IEEE International Software Metrics Symposium serving as a member of the program committee and also as program chair for these conferences.     

软件开发过程持续改进的方法研究

随着软件的规模和复杂度的不断增大，软件开发过程越来越难以度量和保持持续改进。通过对软件开发过程中软件度量计划、度量实施、度量分析的研究，提出了一种软件开发过程持续改进的螺旋式模型，用于促使软件开发过程的持续改进和软件组织能力的有效提升。     

Applying and evaluating concern-sensitive design heuristics

Manifestation of crosscutting concerns in software systems is often an indicative of design modularity flaws and further design instabilities as those systems evolve. Without proper design evaluation mechanisms, the identification of harmful crosscutting concerns can become counter-productive and impractical. Nowadays, metrics and heuristics are the basic mechanisms to support their identification and classification either in object-oriented or aspect-oriented programs. However, conventional mechanisms have a number of limitations to support an effective identification and classification of crosscutting concerns in a software system. In this paper, we claim that those limitations are mostly caused by the fact that existing metrics and heuristics are not sensitive to primitive concern properties, such as either their degree of tangling and scattering or their specific structural shapes. This means that modularity assessment is rooted only at conventional attributes of modules, such as module cohesion, coupling and size. This paper proposes a representative suite of concern-sensitive heuristic rules. The proposed heuristics are supported by a prototype tool. The paper also reports an exploratory study to evaluate the accuracy of the proposed heuristics by applying them to seven systems. The results of this exploratory analysis give evidences that the heuristics offer support for: (i) addressing the shortcomings of conventional metrics-based assessments, (ii) reducing the manifestation of false positives and false negatives in modularity assessment, (iii) detecting sources of design instability, and (iv) finding the presence of design modularity flaws in both object-oriented and aspect-oriented programs. Although our results are limited to a number of decisions we made in this study, they indicate a promising research direction. Further analyses are required to confirm or refute our preliminary findings and, so, this study should be seen as a stepping stone on understanding how concerns can be useful assessment abstractions. We conclude this paper by discussing the limitations of this exploratory study focusing on some situations which hinder the accuracy of concern-sensitive heuristics.     

Yield-driven, false-path-aware clock skew scheduling

Semiconductor technology advances have enabled designers to integrate more functionality in a single chip. As design complexity increases, many new design techniques are developed to optimize chip area and power consumption, as well as performance. Traditionally, yield improvement has been achieved through process improvement. However, in deep-submicron technologies, process variations are difficult to control. As a result, many design decisions significantly affect yield. Therefore, designers should consider yield-related issues during the design phase. This article proposes clock skew scheduling as a tool to address causes of performance-related circuit yield loss. It is an interesting example of how managing circuit-level parameters can have a direct impact on yield metrics and therefore a clear example of the direction of DFM research.     

The measurement of a design structural and functional complexity

When evaluation of terms such as “design complexity” and its “quality”, it is often performed in an ad hoc manner. This paper attempts to remedy this situation by articulating two definitions of design complexity (structural complexity versus functional complexity), their associated value measures, and the relationships between them. The structural definition states that a design complexity is a function of its representation. Defining design complexity in the structural way provides quantitative techniques for evaluating vague terms. The functional definition states that a design complexity is a function of its probability of successfully achieving the required specifications (functional requirements and constraints). The proposed measurable metrics provide a proper basis for evaluating each step of the design process, and accordingly recommends the direction to follow for design modification and enhancement. It also provides a framework for comparing competing artifacts     

Avoiding metric monsters: A design metrics approach

Metric monsters are stumbling blocks that prevent software metrics-guided methodologies from attaining product and process improvement. Metric monsters can occur during the identification, collection or application of software metrics. In our research, we have developed and tested our design metrics over a five-year period and have found them to be excellent predictors of error-prone modules. Based on this research, we will identify some of the monsters that occur in the quantitative analyses of software and its development processes, and present our approach in formulating a design metrics model that avoids these monsters. This model consists of software tools, guidelines and actions for the application of software design metrics.     

Complexity metrics for Workflow nets

Process modeling languages such as EPCs, BPMN, flow charts, UML activity diagrams, Petri nets, etc., are used to model business processes and to configure process-aware information systems. It is known that users have problems understanding these diagrams. In fact, even process engineers and system analysts have difficulties in grasping the dynamics implied by a process model. Recent empirical studies show that people make numerous errors when modeling complex business processes, e.g., about 20% of the EPCs in the SAP reference model have design flaws resulting in potential deadlocks, livelocks, etc. It seems obvious that the complexity of the model contributes to design errors and a lack of understanding. It is not easy to measure complexity, however. This paper presents three complexity metrics that have been implemented in the process analysis tool ProM. The metrics are defined for a subclass of Petri nets named Workflow nets, but the results can easily be applied to other languages. To demonstrate the applicability of these metrics, we have applied our approach and tool to 262 relatively complex Protos models made in the context of various student projects. This allows us to validate and compare the different metrics. It turns out that our new metric focusing on the structuredness outperforms existing metrics.     

Empirical evaluation of reuse sensitiveness of complexity metrics

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.     

Measuring complexity in C++ application software

This paper concerns the use of design/source-code complexity metrics in analysing C++ software. It describes the use of one suite of object-oriented metrics published by Chidamber and Kemerer¹ to evaluate a commercial C++ application. It provides an interpretation and critique of these metrics, including the use of two traditional metrics (Cyclomatic Complexity² and Software Science³) in association with these object-oriented metrics. The evolution, over a two and a half year period, of one commercial grade C++ application comprising 114 classes with 25,000 lines of code is studied. The efforts consumed in bug fixes and enhancements are correlated with the complexity measures on a per class basis, and results are presented. These results are compared to those from other workers. The paper provides a detailed analysis of the practical strengths and weaknesses of the metrics suite in the light of experiences with its use. © 1998 John Wiley & Sons, Ltd.