Exploring community structure of software Call Graph and its applications in class cohesion measurement

Highlights

• We show that software static Call Graphs exhibit significant community structures.

• We propose two new class cohesion metrics based on community structures.

• The new metrics provide new and useful measurement of software class cohesion.

• The new metrics perform better than existing metrics in software fault prediction.

Abstract

Many complex networked systems exhibit natural divisions of network nodes. Each division, or community, is a densely connected subgroup. Such community structure not only helps comprehension but also finds wide applications in complex systems. Software networks, e.g., Class Dependency Networks, are such networks with community structures, but their characteristics at the function or method call granularity have not been investigated, which are useful for evaluating and improving software intra-class structure. Moreover, existing proposed applications of software community structure have not been directly compared or combined with existing software engineering practices. Comparison with baseline practices is needed to convince practitioners to adopt the proposed approaches. In this paper, we show that networks formed by software methods and their calls exhibit relatively significant community structures. Based on our findings we propose two new class cohesion metrics to measure the cohesiveness of object-oriented programs. Our experiment on 10 large open-source Java programs validate the existence of community structures and the derived metrics give additional and useful measurement of class cohesion. As an application we show that the new metrics are able to predict software faults more effectively than existing metrics.

Introduction

Many natural and man-made complex networked systems, including metabolic networks, computer networks and social networks, exhibit divisions or clusters of network nodes (Flake, Lawrence, Giles, 2000, Fortunato, 2010, Girvan, Newman, 2002, Mucha, Richardson, Macon, Porter, Onnela, 2010, Palla, Derényi, Farkas, Vicsek, 2005). Each division, or community (Girvan and Newman, 2002), is a densely connected and highly correlated subgroup. Such community structure not only helps comprehension but also finds wide applications in complex systems. For example, researchers in Biology and Bioinformatics have applied community detection algorithms to identifying functional groups of proteins in Protein–Protein Interaction networks (Dunn, Dudbridge, Sanderson, 2005, Jonsson, Cavanna, Zicha, Bates, 2006). For online auction sites such as ebay.com, community structure is used to improve the effectiveness of the recommendation systems (Jin, Parkes, Wolfe, 2007, Reichardt, Bornholdt, 2007). A survey on the applications of community detection algorithms can be found in Fortunato (2010).

There are also research efforts to investigate community structures in software, a very complex system (Concas, Monni, Orru, Tonelli, 2013, Pan, Li, Ma, Liu, 2011, Šubelj, Bajec, 2011, Šubelj, Bajec, 2012, Šubelj, Žitnik, Blagus, Bajec, 2014). Most of them reported a significant community structure of a certain type of software network such as Class Dependency Networks (Šubelj and Bajec, 2011). Some pioneering applications of software community structure are proposed (for more details, please refer to Section 2). However, there are still some unsolved problems.

Firstly, most of the measurements are performed on the network of classes. Little results are reported on the granularity of software method or function call, i.e., method/function Call Graphs (Graham et al., 1982). Such investigation is necessary from both theoretical and practical perspectives. In addition, measurements of the network of classes cannot be used in intra-class structure, which limits their applications in software quality evaluation and improvement.

Secondly, these pioneering applications have not been directly compared or combined with existing software engineering metrics and practices. Comparison with baseline practices is needed to convince people to adopt the proposed approaches. Only when the proposed approaches outperform or complement the existing method, there can be a possibility that the approaches are adopted by software engineering practitioners.

Do software networks at other granularities also present significant community structures? If so how can we make use of it in software engineering practices? To answer these open questions and solve the existing problems, we construct static Call Graphs, in which nodes represent methods in an OO (Object-Oriented) program and edges represent methods invocation relations. We then apply existing community detection algorithms to such graphs. Fig. 1 depicts the community structure of jEdit, an open-source text editor. There are 5979 nodes that are divided into 34 communities shown in different colors. The community structure is detected by Louvain algorithm (Blondel et al., 2008) that is implemented in a network analysis and visualization tool called Pajek.¹ In Section 3, we show that such result presents typical community characteristics similar to those previously observed in other complex systems.

It is well known that high-quality software should exhibit “high cohesion and low coupling” nature. Software with such nature is believed to be easy to understand, modify, and maintain (Briand, Bunse, Daly, 2001, Pressman, 2010). Object-oriented design strives to incorporate data and related functionality into modules, which usually reduces coupling between modules. However, employing object-oriented mechanism itself does not necessarily guarantee minimal coupling and maximal cohesion. Therefore, a quantitative measurement is valuable in both a posteriori analysis of a finished product to control software quality, and a priori analysis to guide coding in order to avoid undesirable results in the first place.

The existence of community structures, as confirmed by our experiments on 10 large open-source Java programs using four widely-used community detection algorithms, sheds light on the cohesiveness measurements of OO programs. Intuitively, community structures are able to indicate cohesion as nodes within a community are highly cohesive, and nodes in different communities are loosely coupled. In this paper, we propose two new class cohesion metrics—MCC (Method Community Cohesion) and MCEC (Method Community Entropy Cohesion) based on community structures. The basic idea of MCC is to quantify how many methods of a certain class reside in the same community. As for MCEC, it uses the standard notion of Information Entropy (Shannon, 2001) to quantify the distribution of all the methods of a class among communities. Comparing with existing metrics, these two metrics provide a new and more systematic point of view for class cohesion measurement.

Fig. 2 gives the overview of our approach. Once a Call Graph is constructed, we apply widely-used community detection algorithms. Fig. 2 shows the static Call Graph of JHotDraw, a Java GUI framework for technical and structured graphics. There are 5125 nodes divided into 35 communities, as reported by Louvain algorithm (Blondel et al., 2008). Based on the community structures, the metrics of MCC and MCEC are computed.

We validate the proposed metrics using the following processes. Firstly, we show that MCC and MCEC theoretically satisfy expected properties of class cohesion metrics (Briand et al., 1998). Secondly, we empirically compare MCC and MCEC with five widely-used class cohesion metrics and our experiments indicate that the new metrics are more reasonable than existing ones. Thirdly, Principle Component Analysis (PCA; Pearson, 1901) is conducted to show that MCC and MCEC provide additional and useful information of class cohesion that is not reflected by existing metrics. Finally, experiments are carried out to show that MCC and MCEC usually perform equally or better than existing class cohesion metrics when they are used in software fault prediction.

In summary we make the following contributions in this paper:

• We show through experiments on 10 large open-source Java programs that the static Call Graphs constructed from OO programs usually exhibit relatively significant community structures as other networked complex systems (e.g., social networks). Such results are helpful in intra-class structure and quality evaluation.

• Based on community structures of Call Graphs, we propose two new class cohesion metrics. We conduct study to confirm the proposed metrics satisfy the theoretical requirements of cohesion metrics. The comparison with five existing metrics shows that the class cohesion metrics based on community structures can provide new insight of OO programs.

• We conduct empirical study and illustrate the effectiveness of the new metrics through software fault prediction experiments on four open-source programs with 1500 classes, among which there are 702 faulty ones. Results show that the new metrics usually perform equally or better than existing ones.

The rest of this paper is organized as follows. Section 2 reviews related work. In Section 3, community structures of 10 large open-source programs are investigated using four community detection algorithms. Two class cohesion metrics based on community structure are proposed in Section 4. Section 5 conducts empirical evaluations of the class cohesion metrics, followed by discussions on community detection algorithms and potential applications of the proposed metrics in Section 6. Finally Section 7 concludes the paper with future work.