A Survey of Dynamic Software Metrics <s> Zaidman et al.'s Work <s> The network structure of a hyperlinked environment can be a rich source of information about the content of the environment, provided we have effective means for understanding it. We develop a set of algorithmic tools for extracting information from the link structures of such environments, and report on experiments that demonstrate their effectiveness in a variety of context on the World Wide Web. The central issue we address within our framework is the distillation of broad search topics, through the discovery of “authorative” information sources on such topics. We propose and test an algorithmic formulation of the notion of authority, based on the relationship between a set of relevant authoritative pages and the set of “hub pages” that join them together in the link structure. Our formulation has connections to the eigenvectors of certain matrices associated with the link graph; these connections in turn motivate additional heuristrics for link-based analysis. <s> BIB001 </s> A Survey of Dynamic Software Metrics <s> Zaidman et al.'s Work <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> BIB002 </s> A Survey of Dynamic Software Metrics <s> Zaidman et al.'s Work <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> BIB003 </s> A Survey of Dynamic Software Metrics <s> Zaidman et al.'s Work <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> BIB004
Zaidman et al.  BIB003 BIB004 propose a variation of import coupling and use the same for the purpose of program comprehension. Authors consider the following properties of a coupling metric in order to be useful for the purpose of program comprehension: • Since, software engineers try to comprehend the software at the class-level only. While selecting dynamic coupling measures, only those metrics which are defined at class-level need to be considered. • All classes external to the actual project (e.g., library classes), have no direct influence on the program comprehension process. • Only those classes that have a prominent role within the system's architecture need to be considered and such classes are expected to give orders to other classes, i.e., tell them what to do and what to give in return. As such, these classes are expected to request the services of other classes. This suggests that direction of coupling needs to be taken into consideration is the "import coupling" for the purpose of program comprehension. Out of twelve metrics proposed by Arisholm BIB002 , two metrics IC CM and IC CC adhere to the criteria set out as above, namely: working at the class-level and measuring import coupling. Authors also use a variation of IC CC metric and refer it as IC CC ′ . This metric differs from IC CC metric in the sense that IC CC metric is targeted more towards finding the number of classcollaborations, while IC CC ′ retrieves the number of method-collaborations. Consider the following example: A class having one method calls two distinct methods of second class and one method of third class. IC CC is calculated as two (number of distinct classes called) and is calculated as three (number of distinct methods called). These dynamic coupling measures allow us to identify the most need-to-be-understood classes in a system. Detecting these classes very early in the program comprehension process allows the end user to pay attention towards these classes and start exploring the software system directly from there. Authors experiment with various dynamic coupling metrics and also compare direct and indirect coupling solutions. To simulate the indirect coupling, they use the HITS web-mining algorithm BIB001 . Their experiments show that taking indirect coupling into account delivers better results for program comprehension.