The Influences of Edge Instability on Change Propagation and Connectivity in Call Graphs
 671 Downloads
Abstract
During the lifetime of any software there are numerous changes, which lead to a large number of versions over time. The amount of effort in programming and debugging for these updates and therefore the reliability of the software depends substantially on how far the change propagates. We introduced the concept of Propagation Scope (PS) to quantify change propagation and investigated several opensource software systems. We found that the propagation property varies even with systems of similar scales. According to the asymmetry between the indegree and outdegree distributions in call graphs of software, we defined Edge Instability (EI) to measure the change propagation of a call graph. Analyzing newly added nodes in six software, we found that the new nodes exhibited preferential attachment behaviors and were more likely to call new nodes. We proposed a model based on these observations to adjust EI and Clustering Coefficient (CC). CC has been believed to be the major factor determining the propagation scope in a network. Our experiments showed, however, that EI had a larger impact on the propagation of call graphs. In both real software and our model, we measured the connectivity of call graphs with EI and evaluated connectivity under three edgeremoval strategies. Our experiments showed that removing edges with high EIs hurt network connectivity the most.
Keywords
Complex networks Software evolution Change propagation Network model Call graph1 Introduction
It has been observed that ideas, information, viruses, and diseases often propagate in the form of complex networks [30] and a network’s topological structure has a significant impact on the dynamics of change propagation [28]. In the domain of computer science, it has been demonstrated that class diagrams [34, 35], collaboration graphs [29], package dependency networks [23], the object graphs [31], software component graphs [20], and call graphs in largescale software systems [37] are all complex networks. In this paper, we studied change propagation in call graphs, a critical aspect in software evolution. As developers code to introduce new features or fix bugs for one part of a software system, other parts need to be updated accordingly to stay consistent with the changes. For example, when a function’s prototype changes, its callers have to be modified to call through the new interface. To understand the evolution of software systems, we collected call graphs of a large number of software systems of multiple versions. A call graph describes the calling relationship between functions in a program. Specifically, functions in the program are represented as nodes in a call graph. If one function calls another, an edge from the node representing the caller to the node of the callee function is added to the graph. We generated a call graph for each version of a selected software system and, by comparing the graphs of different versions, investigated change propagation as software evolves.
We selected 35 stable Linux kernels from version 1.0 to version 2.2.26 (available at http://ftp.kernel.org) and generated their call graphs using a modified version of GCC 3.4.6 [2]. To compare update propagation characteristics among different software, we collected call graphs for five additional opensource projects, including 80 versions of Samba, 25 versions of BIND, 55 versions of Sendmail, 76 versions of OpenSSH, and 59 versions of vsftpd obtained from the code repository [7]. To identify updates between two adjacent versions of a software system, we use ctags [1] to get the start and end points of a function in one version. We then compared the functions of the same name in the two versions to decide if the function is updated. We also identified functions removed from the older version or added in the newer version. All these changes, including updates, additions, and removals of functions, can be identified in the call graphs when they are propagated to other functions in the software. In this paper, we name the versions with ordered sequence numbers starting from 0 following their chronological order.
We quantified network propagation with Propagation Scope (PS). The scope that a change propagation can reach is mostly determined by the topological structure of the corresponding call graph, which can be characterized by many factors, including the graph’s node count, edge count, average node degree, etc. Among the factors, the clustering coefficient (CC) measures how tightly nodes in a network are clustered and is believed to be the most powerful factor determining the propagation of networks [38, 41]. We found, however, that propagation in a call graph was not sensitive to CC changes. In fact, for the studied software, the asymmetry between the indegree and outdegree distributions were manifest [36] and have a significant influence on the change propagation of software [8]. Given the asymmetry, we introduce Edge Instability (EI) to measure the propagation. We found that the new nodes exhibit preferential attachment behaviors and are more likely to call new nodes. With these observations, we propose a model to adjust CC and EI based on Barabási and Albert (BA) model and it’s extension [6, 18]. Experiments showed that EI has a larger impact than CC on the propagation of call graph.
Inspired by the influences of EI on change propagation, we use EI to measure the connectivity of call graphs. In complex networks, researchers often study robustness by measuring connectivity after removing nodes or edges [10, 32]. We adopted the same methodology to evaluate the connectivity of call graphs and compare three strategies to attack generated graphs by our model: 1. Removing edges randomly. 2. Removing edges with higher EIs. 3. Removing edges with higher “edge degrees” [19]. Our experiments showed that removing edges with high EIs hurt network robustness more than removing edges with high “edge degrees” or randomly.
The rest of this paper is organized as follows. Section 2 introduces the concept of propagation scope, edge instability and statistics with various software systems. Connectivity of call graphs under three edgeremoval strategies are discussed in Sect. 3. Section 4 describes behaviors of new nodes and an innovative model of software evolution. The correlation among parameters of the proposed model, change propagation and connectivity are also discussed in Sect. 4. Section 5 introduces the related work briefly. The paper closes with our conclusions in Sect. 6.
2 Change Propagation
To quantify the change propagation in a network, we introduce the concept of propagation scope (PS), derived from the concepts of Change Cost [26] and Average Propagation Ratio [25], and edge instability. To reveal impact of the structure of a call graph on PS, we will measure the number of nodes and edges, the average node degree, the diameter, the clustering coefficient and the edge instability of the call graphs under investigation.
2.1 Propagation Scope
Statistics with Linux and Samba of similar scale.
software  Linux1  Samba1  Linux2  Samba2 

Avg. node  3993  3803  8099  7373 
Avg. edge  14996  13849  31400  30513 
Ave. degree  7.51  7.28  7.75  8.27 
\(PS_G\)  0.0135  0.0297  0.0112  0.0295 
2.2 Edge Instability
The asymmetry between the indegree and outdegree distributions of software appears obviously [9, 29, 34, 36]. The indegree distribution of software systems obviously obeys the powerlaw while the outdegree distribution are similar to the powerlaw distribution with a cutoff. Inspired by the asymmetry of degree distribution and direction of change propagation in software, we propose the Edge Instability of a call graph.
Figure 3 includes two examples to explain this observation.
 1.
In Fig. 3(a), \(S_i\) is 3/4 and \(S_j\) is 1/4. Accordingly, \(I_{ij}\) of Edge \(<i, j>\) is 1/2. A change at Nodes j, a, b or c will propagate to Nodes i, d, e, and f across Edge \(<i, j>\), as indicated by the dotted lines.
 2.
In Fig. 3(b), \(S_i\) is 0 and \(S_j\) is 1/4. Accordingly, \(I_{ij}\) of Edge \(<i, j>\) is 1/4. Changes at Nodes j, a, b, and c only spread to Node i but do not reach nodes d, e, and f.
Apparently, Edge \(<i, j>\) with higher EI in the first example has a higher impact on the propagation scope.
2.3 Statistics with Six Open Source Software
The correlation coefficient results between \(PS_G\) and other features.
Software  Node  Edge  Ave. deg  D  CC  EI 

Linux  \(\)0.99  \(\)0.99  \(\)0.96  \(\)0.96  0.42  0.41 
Samba  \(\)0.11  \(\)0.11  0.086  0.05  0.03  0.29 
BIND  0.29  0.58  0.94  0.85  \(\)0.75  0.48 
Sendmail  \(\)0.80  \(\)0.80  \(\)0.79  \(\)0.37  0.76  0.68 
OpenSSH  \(\)0.96  \(\)0.96  \(\)0.85  \(\)0.94  0.97  0.94 
vsftpd  \(\)0.93  \(\)0.92  \(\)0.91  \(\)0.26  \(\)0.21  0.90 
 1.
Table 2 summarizes the correlation coefficient results between \(PS_G\) and other features of six software. Compared with the number of nodes, the number of edges, the average node degree, the diameter (D) and the clustering coefficient, the edge instability is the only one that had a positive correlation with \(PS_G\) in all six software.
 2.
As the increase of node number, the corresponding \(PS_G\) decreases except for BIND. In fact, \(PS_G\) is the ratio of the number of nodes a propagation reaches to the number of all nodes. The propagation of changes in a system is hard to maintain the same rate as a software system becomes larger.
 3.
Per the definition of PS, as the increases of the average degree, PS of a software system would also increase. This phenomenon can be observed clearly in BIND system (Fig. 4(c)). It is easy to understand that the more edges a system has, the faster the propagation would be. The tendency, however, is not apparent in other software systems. It is difficult to tell the impact of the average degree on \(PS_G\) in two cases: 1. The average degree is very stable. 2. The average degree and node number change at the same time.
 4.
Previous works suggest that as CC increases the propagation scope in a network would decrease [38]. This can be clearly observed in BIND and vsftpd. It is not apparent, however in other systems as CC is very stable in different versions.
3 Connectivity
In complex networks, researchers often study robustness by measuring connectivity after removing nodes or edges [10, 32]. As many error conditions do not cause the crash of the whole software system, we assume that the other parts of the software keep working. For example, when the kernel panics in a loadable module of an Ethernet driver it can contain the failure and give out messages. The other parts of the system cannot use this driver but may be able to access the Ethernet device from other channels and certainly a user can continue to work in a text editor. Thus, we adopted the same methodology to evaluate the connectivity of call graphs in this paper.
We remove the edge to simulate the failure, and study how well the other nodes in the call graph stay connected. Connectivity among the nodes left represents a measure of robustness of the graph under edge removal. It is not a measure of how well the software handles crashes but how well its functions are designed and coded to minimize the impact on the rest of the system when one or more parts fail.
4 Features of Call Graphs and Evolution Model
To understand how software systems evolve into particular structures, we studied the ways new nodes were added into call graphs.
4.1 Preferential Attachment
Average connecting probability.
Software  Linux  Samba  BIND  Sendmail  OpenSSH  vsftpd 

Avg. Indegree  73.06 %  60.28 %  60.36 %  60.66 %  62.46 %  64.65 % 
Avg. Outdegree  4.43 %  12.35 %  5.79 %  6.99 %  10.91 %  34.32 % 
4.2 Callers of New Nodes
4.3 Evolution Model for Software
 1.
In the beginning, a network consists of \(m_0\) nodes and no edges. \(m_0\) is a small integer. In our experiments it is set to 3.
 2.
Add Node v ( \(v = m_0 + 1\) intially).
 3.
Repeat the following two steps for Node v until m edges are added.
 (a)Preferential attachment (PA): Each edge of Node v is then attached to an existing node with the probability proportional to its degree and age, i.e., the probability for Node w (w = 1, 2, ..., \(m_0\) + v  1) to be attached to v iswhere \(k_i = (age_i)^{\beta }*{k^{'}_i}\). \(age_i\), with the initial value of 1, represents the age of Node i. When a new node is added to the network, the age of each existing node is incremented by 1. \({k^{'}_i}\) is the degree of Node i. \(\beta \) controls the influence of a node’s age.$$\begin{aligned} P_w = \frac{k_w}{\sum _{i=1}^{m_0+v1}{k_i}} \end{aligned}$$(10)
 (b)
Triad formation (TF): If an edge between Nodes v and w was added in the previous PA step, then add one more edge from Node v to a randomly chosen neighbor of Node w. If all neighbors of Node w have been connected to Node v, go back to Step 3(a).
 (a)
 4.
If \(v < N  m_0 + 1\), increment v by 1 and go back to step 2. Otherwise, the network is generated.
In generating the network, the total number of the PA and TF steps that produces edges for each new node is m. After one PA, we perform a TF step with a probability of \(P_t\). \(P_t\) is a parameter that adjusts the CC of the generated network.
Equation (2) shows that the diameter of a graph has a major impact on \(PS_G\). When a new edge does not cause the current diameter to exceed a threshold, LD, the edge is added. Otherwise, the new edge is dropped and a new possible edge is selected to repeat the above step.
Following [34], we first generate undirected graphs and then transform them into directed graphs by making edges to start from the newly added nodes and end at the existing nodes.

\(P_t\) correlated positively with CC as shown in Fig. 7 (a) and (d).

\(\beta \) correlated positively with EI as shown in Fig. 7 (b) and (e).

\(\beta \), which determines \(PS_G\) of a network, has a larger impact on the propagation than \(P_t\), as shown in Fig. 7 (c) and (f). Thus, in our model, the propagation scope was highly correlated with \(\beta \) and therefore EI but less affected by the changes in CC.
To study the impact of EI on connectivity, we use the three strategies to attack graphs generated by different \(\beta \)s. Figure 8 summarized the results. Figure 8(a) showed that, under different \(\beta \)s (between 0 and 1), the effect of node age on network structure changed significantly. The effect of the node ages limited the preferential attachment and prevented a scalefree distribution of connectivities [4]. It seemed to be a critical point in a network and the network became scalefree when \(\beta \) was below a certain value. With large \(\beta \)s, the network showed no power law characteristics and the degree became exponentially distributed. As shown in Fig. 8(a), overall and for different \(\beta \)s, the networks had a good connectivity. This result was consistent with the experiments on network connectivity [3]. This suggested that the network was connected under the random attack due to the scalefree feature. When \(\beta \) fell between 0.4 and 0.8, however, the degree distribution of network transited from scalefree to exponential and the network more vulnerable to random attacks.
Figure 8(b) showed a fast decay for different values of \(\beta \) and f between 0.2 and 0.3. The network was less connected and therefore it became “harder” for the remaining nodes to communicate with each other when the unstable edges (the edges with the EI values close to 1) were removed.
Figure 8(b) with 8(c) showed that when \(\beta \) is small the HL and ED removals had a similar effect for network connectivity. When \(\beta \) is large, however, the HL removal hurt the connectivity more than ED. As \(\beta \) increased the distribution of degree morphs from scalefree to exponential. Under exponential degree distribution, each node in the network has approximately the same degree, and therefore the damage to network connectivity by ED removal was less obvious. In HL removal, however, the EI highly affected the propagation of networks when \(\beta \) increased (see Fig. 7) and the edges with high EI had a structure of “weak ties” (see Fig. 6). Thus, removing the edges with high EIs in HL removal broke the network into small pieces fast for all \(\beta \) values. HL instead of ED removal became a good indicator for attacks when the degree distribution of networks shifts from scalefree to exponential.
5 Related Work
Two main approaches to study change propagation in software are Impact Analysis (IA) and Mining Software Repositories (MSR). IA uses dependency or traceability information and MSR uses historical information [21]. An indepth review of impact analysis for software change can be found in [24]. Mirarab et al. [27] propose to use BBNs for impact analysis, and their approach achieves a precision of 63 % with a recall of 26 %. Formal Concept Analysis (FCA) [14], probabilistic approach [33], and Family Dependence Graph (FDG) [39] have been employed for change impact analysis. In the context of complex technical systems, Giffin et al. [13] analyze change propagation with design structure matrix (DSM) and categorize a number of typical change patterns. Recently, Zhang et al. [40] use requirement dependency as a tool to conduct change propagation analysis. They investigate whether existing dependency types are sufficient for change propagation analysis. In our work, we analyze the impact of software network structures on the change propagation without tracing the affected functions in software.
Hassan and Holt propose to determine how changes propagate with developer information, historical cochange information of entity, code structure, and code layout heuristic [16]. Hassan and Malik further improve the approach with an adaptive heuristic method [17]. Zimmermann et al. [42] apply data mining techniques to analyze version histories, and to uncover couplings between finegrained entities to guide programmers among related changes. Gall et al. [12] propose an approach to extract software evolution patterns and dependencies from the CVS data. Their proposed methodology, QCR, is to examine the historical development of classes by analyzing changes of classes and common change behavior obtained from CVS. They further [11] classify changes according to their significance levels (low, medium, high, or crucial). In our work, we explain why asymmetric structures inside the software are formed after analyzing call graphs of many software system versions, and propose an evolution model capturing the way new nodes are added during the process of software evolution. By varying the parameters of the proposed model, we study the relationship between the change propagation and software structure.
Asymmetric structures can increase the fragility of software [8]. Studies on the mechanism of asymmetric software structures can help optimization of software. Myers points out that the asymmetry typically is due to the common practice of software reuse [29]. Others [34] argue that the asymmetry is rooted right in the economization of development effort and related costs. Additionally [9] notes that the outdegree of the class in the object oriented software systems is limited by the size of the class. They have found that the limitation leads to the asymmetry of degree distributions. We found, however, that the manner in which new nodes are added into the call graphs during software evolution contributes to the asymmetric feature of software, and that the asymmetric structures have a significant impact on the change propagation of software.
Many network models have been proposed in the past decade. In BA model [5], each newly added node is connected to nodes selected with a probability proportional to their respective degrees. Although the degree distribution of the BA model follows the powerlaw distribution, the resulting clustering coefficient is much lower than those measured in software systems. In the Copying model [22], each newly added node randomly selects a target node and connects to it, as well as to all neighbor nodes of the target node. The Copying model has a large clustering coefficient. In the process of selecting the target node in the Copying model, however, older nodes have greater priority to be connected to the newly added nodes. This feature is different from actual new node behavior demonstrated in real software systems, in which new nodes are more likely to be connected among themselves.
6 Conclusions
Using propagation scope, we quantified change propagation in different versions of six opensource software systems. Inspired by the asymmetry of degree distribution and direction of change propagation in software, we proposed the edge instability to measure the change propagation of a call graph. We calculated the number of nodes, the number of edges, the average node degree, the diameter, CC, EI in the call graphs of the selected systems, and found that EI is the only one that had a positive correlation with propagation scope in all six studied software. To compare the impact of CC and EI on change propagation, we have proposed a novel model allowing us to adjust these properties. Although CC is traditionally considered one of the most important factors in the study of propagation, our experimental results indicated that EI had a much bigger impact in call graphs. Furthermore, we showed the correlation between the connectivity of call graphs and EI, i.e., eliminating the edges with high EI breaks a network into small pieces faster in real software and networks generated by our model. In summary, we demonstrated that EI could be a good indicator of the change propagation and connectivity of software networks.
Notes
Acknowledgments
This work was supported by National Natural Science Foundation of China (No. 61272167).
References
 1.ctags 5.8 release. http://ctags.sourceforge.net
 2.Gcc 3.4 release series. http://gcc.gnu.org/gcc3.4/
 3.Albert, R., Jeong, H., Barabósi, A.: Error and attack tolerance of complex networks. Nature 406(6794), 378–382 (2000)CrossRefGoogle Scholar
 4.Amaral, L., Scala, A., Barthélémy, M.: Classes of smallworld networks. Proc. Nat. Acad. Sci. 97, 11149–11152 (2000)CrossRefGoogle Scholar
 5.Barabási, A.L., Albert, R.: Emergence of scaling in random networks. Science 286, 509–512 (1999)MathSciNetCrossRefzbMATHGoogle Scholar
 6.Barabási, A.L., Albert, R.: Emergence of scaling in random networksscience. Science 286(5439), 509–512 (1999)MathSciNetCrossRefzbMATHGoogle Scholar
 7.Bhattacharya, P., Iliofotou, M., Neamtiu, I., Faloutsos, M.: Graphbased analysis and prediction for software evolution. In: ICSM, pp. 419–429 (2012)Google Scholar
 8.Challet, D., Lombardoni, A.: Bug propagation and debugging in asymmetric software structures. Phys. Rev. E 70, 046109 (2004)CrossRefGoogle Scholar
 9.Concas, G., Marchesi, S.P.M., Serra, N.: Powerlaws in a large objectoriented software system. IEEE Trans. Softw. Eng. 33(10), 687–708 (2007)CrossRefGoogle Scholar
 10.Crucittia, P., Latorab, V., Marchiori, M., Rapisarda, A.: Error and attacktolerance of complex networks. Phys. A 340, 388–394 (2004)MathSciNetCrossRefGoogle Scholar
 11.Fluri, B., Gall, H.C.: Classifying change types for qualifying change couplings. In: ICPC, pp. 35–45 (2006)Google Scholar
 12.Gall, H., Jazayeri, M., Krajewski, J.: Cvs release history data for detecting logical couplings. In: IWPSE (2003)Google Scholar
 13.Giffin, M., de Weck, O., Bounova, G., Keller, R., Eckert, C., Clakson, J.: Change propagation analysis in complex technical systems. J. Mech. Des. 131(8), 0810011–08100114 (2009)CrossRefGoogle Scholar
 14.Girba, T., Ducasse, S., Kuhn, A.: Using concept analysis to detect cochange patterns. In: Ninth International Workshop on Principles of Software Evolution: In conjunction with the 6th ESEC/FSE, pp. 83–89 (2007)Google Scholar
 15.Granovetter, M.: The strength of weak ties. Am. J. Socio. 78(6), 1360–1380 (1973)CrossRefGoogle Scholar
 16.Hassan, A.E., Holt, R.C.: Predicting change propagation in software systems. In: International Conference on Software Maintenance, pp. 284–293 (2004)Google Scholar
 17.Hassan, A.E., Malik, H.: Supporting software evolution using adaptive change propagation heuristics. In: ICSM, pp. 177–186 (2008)Google Scholar
 18.Holme, P., Kim, B.: Growing scalefree networks with tunable clustering. Phys. Rev. E 65(2), 026107 (2000)CrossRefGoogle Scholar
 19.Holme, P., Kim, B., Yoon, C.: Attack vulnerability of complex networks. Phys. Rev. E 65(2), 056109 (2002)CrossRefGoogle Scholar
 20.Ichii, M., Matsushita, M., Inoue, K.: An exploration of powerlaw in userelation of java software systems. In: 19th Australian Software Engineering Conference, pp. 422–4311 (2008)Google Scholar
 21.Kagdi, H., Maletic, J.: Softwarechange prediction: estimated+actual. In: Software Evolvability, pp. 38–43 (2006)Google Scholar
 22.Krapivsky, P.L., Redner, S.: Network growth by copying. Phys. Rev. E 71(3), 036118 (2005)MathSciNetCrossRefGoogle Scholar
 23.LaBelle, N., Wallingford, E.: Interpackage dependency networks in opensource software. CoRR, cs.SE/0411096 (2004)Google Scholar
 24.Lehnert, S.: A review of software change impact analysis. Technical University Ilmenau, pages Report ilm1200618 (2011)Google Scholar
 25.Liu, J., Lu, K.H.J., Li, B., Tse, C.: Characterizing the structural quality of general complex software networks. Int. J. Bifurcat. Chaos 18(02), 605–613 (2008)CrossRefGoogle Scholar
 26.MacCormack, A., Rusnak, J., Baldwin, C.: Exploring the structure of complex software designs: an empirical study of open source and proprietary code. Manag. Sci. 52(7), 1015–1030 (2006)CrossRefGoogle Scholar
 27.Mirarab, S., Hassouna, A., Tahvildari, L.: Using bayesian belief networks to predict change propagation in software systems. In: ICPC, pp. 177–188 (2007)Google Scholar
 28.Moore, C., Newman, M.E.J.: Epidemics and percolation in smallworld networks. Phys. Rev. E 61(5), 5678 (2000)CrossRefGoogle Scholar
 29.Myers, C.R.: Software systems as complex networks: structure, function, and evolvability of software collaboration graphs. Phys. Rev. E 68, 046116.1–046116.15 (2003)CrossRefGoogle Scholar
 30.Newman, M.E.J.: The structure and function of complex networks. SIAM Rev. 45, 167–256 (2003)MathSciNetCrossRefzbMATHGoogle Scholar
 31.Potanin, A., Noble, J., Frean, M., Biddle, R.: Scalefree geometry in oo programs. Commun. ACM 48(5), 99–103 (2005)CrossRefGoogle Scholar
 32.Albert, A.B.R., Jeong, H.: Error and attack tolerance of complex networks. Nature 406, 378–382 (2000)CrossRefGoogle Scholar
 33.Sharafat, A.R., Tahvildari, L.: Change prediction in objectoriented software systems: a probabilistic approac. J. Softw. 3(5), 26–39 (2008). (1796217X)CrossRefGoogle Scholar
 34.Valverde, S., Cancho, R.F., Solé, R.V.: Scalefree networks from optimal design. Europhys. Lett. 60, 512–517 (2002)CrossRefGoogle Scholar
 35.Valverde, S., Solé, R.V.: Hierarchical small worlds in software architecture. condmat/0307278 (2003)Google Scholar
 36.Wang, L., Wang, Y., Zhao, Y.: Mechanism of asymmetric software structures: a complex network perspective from behaviors of new nodes. Phys. A Stat. Mech. Appl. 413, 162–172 (2014)CrossRefGoogle Scholar
 37.Wang, L., Wang, Z., Yang, C., Zhang, L., Ye, Q.: Linux kernels as complex networks: a novel method to study evolution. In: ICSM, pp. 41–50 (2009)Google Scholar
 38.Wu, X., Liu, Z.: How community structure influences epidemic spread in social networks. Phys. A 387, 623–630 (2008)CrossRefGoogle Scholar
 39.Yazdanshenas, A.R., Moonen, L.: Finegrained change impact analysis for componentbased product families. In: ICSM, pp. 119–128 (2012)Google Scholar
 40.Zhang, H., Li, J., Zhu, L., Zhu, L., Jeffery, R., Liu, Y., Wang, Q., Li, M.: Investigating dependencies in software requirements for change propagation analysis. Inf. Softw. Technol. 56(1), 40–53 (2014)CrossRefGoogle Scholar
 41.Zhou, T., Yan, G., Wang, B.: Maximal planar networks with large clustering coefficient and powerlaw degree distribution. Phys. Rev. E 71(4), 046141 (2005)CrossRefGoogle Scholar
 42.Zimmermann, T., Zeller, A., Weissgerber, P., Diehl, S., Zeller, A.: Mining version histories to guide software changes. IEEE Trans. Softw. Eng. 31(6), 429–445 (2005)CrossRefGoogle Scholar