A Survey of Dynamic Software Metrics <s> Introduction <s> A relative complexity technique that combines the features of many complexity metrics to predict performance and reliability of a computer program is presented. Relative complexity aggregates many similar metrics into a linear compound metric that describes a program. Since relative complexity is a static measure, it is expanded by measuring relative complexity over time to find a program's functional complexity. It is shown that relative complexity gives feedback on the same complexity domains that many other metrics do. Thus, developers can save time by choosing one metric to do the work of many. > <s> BIB001 </s> A Survey of Dynamic Software Metrics <s> Introduction <s> Software metrics have been studied in the procedural paradigm as a quantitative means of assessing the software development process as well as the quality of software products. Several studies have validated that various metrics are useful indicators of maintenance effort in the procedural paradigm. However, software metrics have rarely been studied in the object oriented paradigm. Very few metrics have been proposed to measure object oriented systems, and the proposed ones have not been validated. This research concentrates on several object oriented software metrics and the validation of these metrics with maintenance effort in two commercial systems. > <s> BIB002 </s> A Survey of Dynamic Software Metrics <s> Introduction <s> Both operational environment and source code complexity influence the reliability of software systems. The complex modules of software systems often contain a disproportionate number of faults. However, if in a given environment, the complex modules are rarely exercised, then few of these faults are likely to become expressed as failures. Different environments will exercise a system's modules differently. A system's dynamic complexity is high in an environment that exercises the system's complex modules with high probability. It is likely that one or more potential scenarios induce inordinately large dynamic complexity. Identifying these scenarios is the first step in assuring that they receive the testing time that they warrant. The paper presents two metrics which evaluate the dynamic complexity of systems and of subsystems in the intended operational environment. The authors' analyze two software systems using both dynamic metrics. > <s> BIB003 </s> A Survey of Dynamic Software Metrics <s> Introduction <s> I. INTRODUCTION. II. OO SOFTWARE METRICS. Project Metrics. Average number of support classes per key class.Average man-days per application class.Average number of classes per developer.Number of major iterations.Number of subsystems.Number of contracts completed.Design Metrics. Average method size.Average number of methods per class.Average number of instance variables per class.Class hierarchy nesting level.Method complexity.Number of methods overridden, inherited, and added by a subclass.Global usage.Instance variable usage.Average number of comment lines per class/method.Number of problem reports per class or contract.Number of times a class is reused.Number of classes/methods thrown away. III. APPENDICES. Project Experience Database. SmallTalk Projects.C++ Projects.Metrics Form. Metrics Tools. <s> BIB004 </s> A Survey of Dynamic Software Metrics <s> Introduction <s> Transparent impact-, heat- and fire-resistant polymeric materials for making windows, windshields and plane canopies are provided wherein the polymeric materials comprise an exposy resin cured with an alkoxy boroxine catalyst and a polycarbonate resin, preferably a polyphenolphthalein carbonate resin. Laminates including the advantages of both resins comprise a transparent layer of epoxy resin and a transparent layer of a polycarbonate resin joined together with a transparent adhesive interlayer. <s> BIB005 </s> A Survey of Dynamic Software Metrics <s> Introduction <s> Cohesion was first developed to predict properties of implementations created from a given design. Unfortunately, cohesion, as originally defined, could not be objectively assessed, while more recently developed objective cohesion measures depend on code level information. We show that association based and slice based approaches can be used to measure cohesion using only design level information. Our design level cohesion measures are formally defined, can be readily implemented, and can support software design, maintenance, and restructuring. <s> BIB006 </s> A Survey of Dynamic Software Metrics <s> Introduction <s> The increasing importance being placed on software measurement has led to an increased amount of research in developing new software measures. Given the importance of object oriented development techniques, one specific area where this has occurred is cohesion measurement in object oriented systems. However despite an interesting body of work, there is little understanding of the motivations and empirical hypotheses behind many of these new measures. It is often difficult to determine how such measures relate to one another and for which application they can be used. As a consequence, it is very difficult for practitioners and researchers to obtain a clear picture of the state of the art in order to select or define cohesion measures for object oriented systems. To help remedy this situation a unified framework, based on the issues discovered in a review of object oriented cohesion measures, is presented. The unified framework contributes to an increased understanding of the state of the art as it is a mechanism for: (i) comparing measures and their potential use, (ii) integrating existing measures which examine the same concepts in different ways, and (iii) facilitating more rigorous decision making regarding the definition of new measures and the selection of existing measures for a specific goal of measurement. <s> BIB007 </s> A Survey of Dynamic Software Metrics <s> Introduction <s> Abstract The basis for measuring many attributes in the physical world, such as size and mass, is fairly obvious when compared to the measurement of software attributes. Software has a very complex structure, and this makes it difficult to define meaningful measures that actually quantify attributes of interest. Program slices provide an abstraction that can be used to define important software attributes that can serve as a basis for measurement. We have successfully used program slices to define objective, meaningful, and valid measures of cohesion. Previously, cohesion was viewed as an attribute that could not be objectively measured; cohesion assessment relied on subjective evaluations. In this paper we review the original slice-based cohesion measures defined to measure functional cohesion in the procedural paradigm as well as the derivative work aimed at measuring cohesion in other paradigms and situations. By viewing software products at differing levels of abstraction or granularity, it is possible to define measures which are available at different points in the software life cycle and/or suitable for varying purposes. <s> BIB008 </s> A Survey of Dynamic Software Metrics <s> Introduction <s> Classes are the fundamental concepts in the object-oriented paradigm. They are the basic units of object-oriented programs, and serve as the units of encapsulation, which promotes the modifiability and the reusability of them. In order to take full advantage of the desirable features provided by classes, such as data abstraction and encapsulation, classes should be designed to have good quality. Because object-oriented systems are developed by heavily reusing the existing classes, the classes of poor quality can be a serious obstacle to the development of systems. We define a new cohesion measure for assessing the quality of classes. Our approach is based on the observations on the salient natures of classes which have not been considered in the previous approaches. A Most Cohesive Component (MCC) is introduced as the most cohesive form of a class. We believe that the cohesion of a class depends on the connectivity of itself and its constituent components. We propose the connectivity factor to indicate the degree of the connectivity among the members of a class, and the structure factor to take into account the cohesiveness of its constituent components. Consequently, the cohesion of a class is defined as the product of the connectivity factor and the structure factor. This cohesion measure indicates how closely a class approaches MCC; the closely a class approaches MCC, the greater cohesion the class has. <s> BIB009 </s> A Survey of Dynamic Software Metrics <s> Introduction <s> The history of software metrics is almost as old as the history of software engineering. Yet, the extensive research and literature on the subject has had little impact on industrial practice. This is worrying given that the major rationale for using metrics is to improve the software engineering decision making process from a managerial and technical perspective. Industrial metrics activity is invariably based around metrics that have been around for nearly 30 years (notably Lines of Code or similar size counts, and defects counts). While such metrics can be considered as massively successful given their popularity, their limitations are well known, and mis-applications are still common. The major problem is in using such metrics in isolation. We argue that it is possible to provide genuinely improved management decision support systems based on such simplistic metrics, but only by adopting a less isolationist approach. Specifically, we feel it is important to explicitly model: (a) cause and eAect relationships and (b) uncertainty and combination of evidence. Our approach uses Bayesian Belief nets, which are increasingly seen as the best means of handling decisionmaking under uncertainty. The approach is already having an impact in Europe. ” 1999 Elsevier Science Inc. All rights reserved. <s> BIB010 </s> A Survey of Dynamic Software Metrics <s> Introduction <s> The increasing importance being placed on software measurement has led to an increased amount of research developing new software measures. Given the importance of object-oriented development techniques, one specific area where this has occurred is coupling measurement in object-oriented systems. However, despite a very interesting and rich body of work, there is little understanding of the motivation and empirical hypotheses behind many of these new measures. It is often difficult to determine how such measures relate to one another and for which application they can be used. As a consequence, it is very difficult for practitioners and researchers to obtain a clear picture of the state of the art in order to select or define measures for object-oriented systems. This situation is addressed and clarified through several different activities. First, a standardized terminology and formalism for expressing measures is provided which ensures that all measures using it are expressed in a fully consistent and operational manner. Second, to provide a structured synthesis, a review of the existing frameworks and measures for coupling measurement in object-oriented systems takes place. Third, a unified framework, based on the issues discovered in the review, is provided and all existing measures are then classified according to this framework. This paper contributes to an increased understanding of the state-of-the-art. <s> BIB011 </s> A Survey of Dynamic Software Metrics <s> Introduction <s> The design of software is often depicted by graphs that show components and their relationships. For example, a structure chart shows the calling relationships among components. Object oriented design is based on various graphs as well. Such graphs are abstractions of the software, devised to depict certain design decisions. Coupling and cohesion are attributes that summarize the degree of interdependence or connectivity among subsystems and within subsystems, respectively. When used in conjunction with measures of other attributes, coupling and cohesion can contribute to an assessment or prediction of software quality. Let a graph be an abstraction of a software system and let a subgraph represent a module (subsystem). The paper proposes information theory based measures of coupling and cohesion of a modular system. These measures have the properties of system level coupling and cohesion defined by L.C. Briand et al. (1996; 1997). Coupling is based on relationships between modules. We also propose a similar measure for intramodule coupling based on an intramodule abstraction of the software, rather than intermodule, but intramodule coupling is calculated in the same way as intermodule coupling. We define cohesion in terms of intramodule coupling, normalized to between zero and one. We illustrate the measures with example graphs. Preliminary analysis showed that the information theory approach has finer discrimination than counting. <s> BIB012 </s> A Survey of Dynamic Software Metrics <s> Introduction <s> As object-oriented (OO) analysis and design techniques become more widely used, the demand on assessing the quality of OO designs increases substantially. Recently, there has been much research effort devoted to developing and empirically validating metrics for OO design quality. Complexity, coupling, and cohesion have received a considerable interest in the field. Despite the rich body of research and practice in developing design quality metrics, there has been less emphasis on dynamic metrics for OO designs. The complex dynamic behavior of many real-time applications motivates a shift in interest from traditional static metrics to dynamic metrics. This paper addresses the problem of measuring the quality of OO designs using dynamic metrics. We present a metrics suite to measure the quality of designs at an early development phase. The suite consists of metrics for dynamic complexity and object coupling based on execution scenarios. The proposed measures are obtained from executable design models. We apply the dynamic metrics to assess the quality of a pacemaker application. Results from the case study are used to compare static metrics to the proposed dynamic metrics and hence identify the need for empirical studies to explore the dependency of design quality on each. <s> BIB013 </s> A Survey of Dynamic Software Metrics <s> Introduction <s> Module cohesion describes the degree to which different actions performed by a module contribute towards a unified function. High module cohesion is a desirable property of a program. The program modifications during successive maintenance interventions can have negative effect on the structure of the program resulting in less cohesive modules. Therefore, metrics that measure module cohesion are important for software restructuring during maintenance. The existing static slice based module cohesion metrics significantly overestimate cohesion due to the limitations of static slicing. In this paper, we present a novel program execution based approach to measure module cohesion of legacy software. We define cohesion metrics based on definition-use pairs in the dynamic slices of the outputs. Our approach significantly improves the accuracy of cohesion measurement. We implemented our technique and measured module cohesion for several programs. Cohesion measurements using our technique were found to be more insightful than static slice based measurements. <s> BIB014 </s> A Survey of Dynamic Software Metrics <s> Introduction <s> Classes are the basic modules in object-oriented (OO) software, which consist of attributes and methods. Thus, in an OO environment, cohesion mainly concerns how tight the attributes and methods of classes are. This paper discusses the relationships between attributes and attributes, attributes and methods, and methods and methods of a class based on dependence analysis. Then we discuss the properties of these relationships. According to these properties, this paper proposes a novel approach to measuring class cohesion. Our approach overcomes the limitations of previous class cohesion measures, which consider only one or two of the three relationships in a class. We also prove that this measure satisfies the properties that a good measurement should have. <s> BIB015 </s> A Survey of Dynamic Software Metrics <s> Introduction <s> The relationships between coupling and external quality factors of object-oriented software have been studied extensively for the past few years. For example, several studies have identified clear empirical relationships between class-level coupling and the fault-proneness of the classes. A common way to quantify the coupling is through static code analysis. However, the resulting static coupling measures only capture certain underlying dimensions of coupling. Other dependencies regarding the dynamic behavior of software can only be inferred from run-time information. For example, due to inheritance and polymorphism, it is not always possible to determine the actual receiver and sender classes (i.e., the objects) from static code analysis. This paper describes how several dimensions of dynamic coupling can be calculated by tracing the flow of messages between objects at run-time. As a first evaluation of the proposed dynamic coupling measures, fairly accurate prediction models of the change proneness of classes have been developed using change data from nine maintenance releases of a large SmallTalk system. Preliminary results suggest that dynamic coupling may also be useful for developing prediction models and tools supporting change impact analysis. At present, work on developing a dynamic coupling tracer and ripple-effect prediction models for Java programs is underway. <s> BIB016 </s> A Survey of Dynamic Software Metrics <s> Introduction <s> A large number of cohesion measures based on method-attribute references have been proposed. However, virtually no attention has been paid to the abstract representation that objectively depicts the relationships among the members of a class. Specially, the flow dependence relationship among attributes, the indirect and potential dependence relationships among class members, and the direction of method-attribute references are ignored. To address this problem, we first identifies four types of basic dependence relationships and uses a class member dependence graph to represent all dependences among the members of a class. Then, a dependence relationships based measure for measuring the class cohesiveness is proposed. Finally, we compare our class cohesion measure with typical cohesion measures. <s> BIB017 </s> A Survey of Dynamic Software Metrics <s> Introduction <s> As we move from developing procedure-oriented to O-O programs, the complexity traditionally found in functions and procedures is moving to the connections among components. More faults occur as components are integrated to form higher level aggregates. Consequently, we need to place more effort on testing the connections among components. Although O-O tech- nology provides abstraction mechanisms to build components to integrate, it also adds new com- positional relations that can contain faults, which must be found during integration testing. This paper describes new techniques for analyzing and testing the polymorphic relationships that oc- cur in O-O software. The application of these techniques can result in an increased ability to find faults and overall higher quality software. <s> BIB018 </s> A Survey of Dynamic Software Metrics <s> Introduction <s> Cohesion refers to the degree of the relatedness of the elements in a module, and it is widely accepted that the module of higher cohesion is easier to understand, maintain, and reuse. Recently, several cohesion metrics have been proposed to measure the cohesiveness of classes in an object-oriented program. However, the existing cohesion metrics do not consider the characteristics of dependent instance variables that are commonly used in a class and, thus, do not properly reflect the cohesiveness of the class. This paper presents an approach for improving the cohesion metrics by considering the characteristics of the dependent instance variables in an object-oriented program. To demonstrate the importance of the dependent instance variables, a case study has been conducted on a class library. <s> BIB019 </s> A Survey of Dynamic Software Metrics <s> Introduction <s> Software quality is an important external software attribute that is difficult to measure objectively. Several studies have identified a clear empirical relationship between static coupling metrics and software quality. However due to the nature of object-oriented programs, static metrics fail to quantify all the underlying dimensions of coupling, as program behaviour is a function of its operational environment as well as the complexity of the source code. In this paper a set of run-time object-oriented coupling metrics are described. A method of collecting such metrics which utilises the Java Platform Debug Architecture is described and a collection of Java programs from the SPECjvm98 benchmark suite are evaluated. A number of statistical techniques including descriptive statistics, a correlation study and principal component analysis are used to assess the fundamental properties of the measures and investigate whether they are redundant with respect to the Chidamber and Kemerer static CBO metric. Results to date indicate that run-time coupling metrics can provide an interesting and informative qualitative analysis of a program and complement existing static coupling metrics. <s> BIB020 </s> A Survey of Dynamic Software Metrics <s> Introduction <s> The extent of coupling in an object-oriented system has implications for its quality in terms of software maintenance. In turn, the extent of reuse in a software system also has implications for the maintainability of that system. One important feature of reflective systems is their dynamic behaviour. In such systems, objects exchange coupling interactions to a larger degree than corresponding static systems providing the same functionality. In this paper, we look at object coupling as it evolves during program execution and propose a measure which takes object interactions into account. The measure can be used to compare systems built on meta-level architectures with systems having no reflective features yet, at the same time, exhibiting the same interface. <s> BIB021 </s> A Survey of Dynamic Software Metrics <s> Introduction <s> Most object-oriented coupling measures proposed in the literature deal with coupling at the static class level. Measuring dynamic object coupling on the other hand gives us the potential for greater insight into system structure and a comparison of the architectural aspects of different systems. In previous work, we theoretically validated a Dynamic Coupling Metric (DCM) and showed, with the aid of a small example, how a system with meta-level characteristics contained less coupling than a corresponding system without these features. In this paper, we build on the theoretical foundations of our DCM and investigate, in more detail, an empirical validation of the metric. A profiler was developed to collect dynamic coupling data represented by message exchanges between objects at runtime; two system models with different architectural characteristics providing the same functionality were then considered. Empirical validation of the metric showed it to be a useful vehicle for comparing the runtime coupling characteristics of software systems. Results also showed that for examples covering various types of couplings, reflective systems separating the base level from the meta-level exhibited significantly less coupling when compared with corresponding systems with a single-level architecture. <s> BIB022 </s> A Survey of Dynamic Software Metrics <s> Introduction <s> Cohesion is one of the fundamental measures of the 'goodness' of a software design. The most accepted and widely studied object-oriented cohesion metric is Chi- damber and Kemerer's Lack of Cohesion in Methods mea- sure. However due to the nature of object-oriented pro- grams, static design metrics fail to quantify all the under- lying dimensions of cohesion, as program behaviour is a function of it operational environment as well as the com- plexity of the source code. For these reasons two run-time object-oriented cohesion metrics are described in this pa- per, and applied to Java programs from the SPECjvm98 benchmark suite. A statistical analysis is conducted to as- sess the fundamental properties of the measures and inves- tigate whether they are redundant with respect to the static cohesion metric. Results to date indicate that run-time co- hesion metrics can provide an interesting and informative qualitative analysis of a program and complement existing static cohesion metrics. <s> BIB023 </s> A Survey of Dynamic Software Metrics <s> Introduction <s> In this paper we present an investigation into the run-time behaviour of objects in Java programs, using specially adapted coupling metrics. We identify objects from the same class that exhibit non-uniform coupling behaviour when measured dynamically.We define a number of object level run-time metrics, based on the static Chidamber and Kemerer coupling between objects (CBO) measure. These new metrics seek to quantify coupling at different layers of granularity, that is at class-class and object-class level. We outline our method of collecting such metrics and present a study of the programs from the JOlden benchmark suite as an example of their use.A number of statistical techniques, principally agglomerative hierarchical clustering analysis, are used to facilitate the identification of such objects. <s> BIB024 </s> A Survey of Dynamic Software Metrics <s> Introduction <s> This paper examines the relationship between the static coupling between objects (CBO) metric and some of its dynamic counterparts. The dimensions of the relationship for Java programs are investigated, and the influence of instruction coverage on this relationship is measured. An empirical evaluation of 14 Java programs taken from the SPEC JVM98 and the JOlden benchmark suites is conducted using the static CBO metric, six dynamic metrics and instruction coverage data.The results presented here confirm preliminary studies indicating the independence of static and dynamic coupling metrics, but point to a strong influence of coverage on the relationship. Based on this, this paper suggests that dynamic coupling metrics might be better interpreted in the context of coverage measures, rather than as stand-alone software metrics. <s> BIB025 </s> A Survey of Dynamic Software Metrics <s> Introduction <s> During initial program comprehension, software engineers could benefit from knowing the most need-to-be-understood classes in the system under study in order to kick-start their software reconnaissance. Previously we have used Webmining techniques on runtime trace data to identify these important classes. Here, we reprise this Webmining technique and make a thorough comparison of its effectiveness when collecting static information of the software system under study. Apache Ant and Jakarta JMeter, two medium-scale open source Java software systems, serve as case studies. From publicly available developers notes we conclude that the Webmining technique in combination with dynamic analysis provides the best results with a level of recall of 90% when comparing with the developers' opinion <s> BIB026 </s> A Survey of Dynamic Software Metrics <s> Introduction <s> Dynamic analysis has long been a subject of study in the context of (compiler) optimization, program comprehension, test coverage, etc. Ever-since, the scale of the event trace has been an important issue. This scalability issue finds its limits on the computational front, where time and/or space complexity of algorithms become too large to be handled by a computer, but also on the cognitive front, where the results presented to the user become too large to be easily understood. This research focuses on delivering a number of program comprehension solutions that help software engineers to focus on the software system during their initial program exploration and comprehension phases. The key concepts we use in our techniques are "frequency of execution" and runtime "coupling". To validate our techniques we used a number of open-source software systems, as well as an industrial legacy application. <s> BIB027
Software metrics are the units of measurement that are used to characterize software engineering products (design, source code etc.), software engineering processes (analysis, design, coding, testing etc.) and software engineering professionals (the efficiency of an individual tester, or the productivity of an individual designer). If used properly, software engineering metrics allow us to quantitatively define the degree of success or failure, for a product, a process, or a person, make meaningful and useful managerial and technical decisions, and make quantified and meaningful estimates [1] . Thus, incorporating metrics into development plans is a simple step towards creating better systems. The most popular and time-honoured software metrics have been LOC (lines of code) and Cyclomatic Complexity  . These measures were originally defined for procedural programs and later incorporated for object-oriented systems. The LOC metric is a measure of a size of a module and Cyclomatic Complexity measures logical complexity of a module. Software metrics proposed and used for procedural paradigm have been found inadequate for object-oriented software products BIB010 mainly because of the distinguishing features of the object-oriented paradigm such as classes, encapsulation, inheritance and polymorphism. Chidamber and Kemerer  addressed the need for new and modified metrics for object-oriented systems by introducing a set of metrics. Their metrics suite has been a subject of discussion for many years and the authors themselves and other researchers have continued to improve or add to the "CK" metric suite. Other major metrics suites proposed for object-oriented systems are MOOD metrics BIB005 , Lorenz and Kidd metrics BIB004 , Briand et al. metrics  , Harrison et al. metrics  and Bansiya et al. metrics  . Static metrics focus on static properties of the software and a number of static metrics have been proposed in literature for the measurement of coupling   BIB011  BIB012  BIB002  BIB018 , cohesion   BIB012 BIB007  BIB008 BIB006 BIB009  BIB019 BIB015 BIB017   and other attributes of object-oriented software using design or source code of the software, which are static in nature. The static metrics are able to quantify various aspects of the complexity of design or source code of a software system, but their ability to accurately predict the dynamic behaviour of an application is as yet unproven. Traditional static metrics alone may be insufficient in evaluating the dynamic behaviour of an application at runtime, as its behaviour will be influenced by the execution environment as well as the complexity of the source code. Object-oriented features such as polymorphism, dynamic binding, inheritance and common presence of unused ("dead") code in commercial software, render the static metrics imprecise, as they do not precisely reflect the runtime situation of the software BIB020 . For instance, target method of a polymorphic call depends on the run time type of the object receiving the call. In programs that employ inheritance, this target may change BIB016 . Moreover, the complex dynamic behaviour of many real-time applications motivates us to focus on dynamic metrics in place of traditional static metrics. Dynamic metrics are the class of software metrics that capture the dynamic behaviour of the software system and are usually obtained from the execution traces of the code or from the executable models. Major dynamic metrics proposed have been for the measurement of coupling BIB020 BIB016  BIB016 BIB024 BIB025 BIB013 BIB021 BIB022   BIB026 BIB027 , cohesion BIB014  BIB023 , and complexity BIB013 BIB001 BIB003  . In this paper, need and benefits of having dynamic metrics for software systems are discussed and major contributions of the paper are briefly described as follows: • a comparison between static and dynamic metrics is done; • study of existing dynamic metrics categorized into different classes is carried out; • different dynamic metrics belonging to same class are compared and their relationships with external quality attributes are examined; • research challenges and opportunities available in the field of dynamic metrics are highlighted; The remainder of this paper is organized as follows. In Section 2 advantages of dynamic metrics over static metrics are discussed and in Section 3 various dynamic coupling metrics proposed in literature are studied and compared on the basis of their relations with quality attributes. Section 4 examines and compares the existing metrics for the measurement of dynamic cohesion and Section 5 describes the dynamic complexity metrics and their relations with quality attributes. Section 6 discusses miscellaneous dynamic metrics and Section 7 discusses the relatively new concept of pseudo dynamic metrics. Section 8 identifies the potential research directions and challenges in the area of dynamic metrics and Section 9 concludes the paper.