On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> The constructed networks, their validity, and measures validation (Features B) <s> Publisher Summary This chapter constructs four social networks for the Open Source Software (OSS) development community at Source Forge. Social network analysis has been used in many research areas to discover the intrinsic mechanisms of social communities by examining the topological properties of the social network formed by relationships between the actors and the groups in those communities. For each social network, number of people are expanded in the network by including the next set of peripheral users as defined by their role in the community, moving from the core project leaders, to the core developers, to the co-developers, and finally out to active users. All the social networks have scale-free properties, and the inclusion of the co-developers and active users triggers the emergence of the small world phenomenon for the social network. The chapter examines how these topological network properties potentially explain the success and efficiency of OSS development practices. <s> BIB001 </s> On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> The constructed networks, their validity, and measures validation (Features B) <s> Communication & Co-ordination activities are central to large software projects, but are difficult to observe and study in traditional (closed-source, commercial) settings because of the prevalence of informal, direct communication modes. OSS projects, on the other hand, use the internet as the communication medium,and typically conduct discussions in an open, public manner. As a result, the email archives of OSS projects provide a useful trace of the communication and co-ordination activities of the participants. However, there are various challenges that must be addressed before this data can be effectively mined. Once this is done, we can construct social networks of email correspondents, and begin to address some interesting questions. These include questions relating to participation in the email; the social status of different types of OSS participants; the relationship of email activity and commit activity (in the CVS repositories) and the relationship of social status with commit activity. In this paper, we begin with a discussion of our infrastructure (including a novel use of Scientific Workflow software) and then discuss our approach to mining the email archives; and finally we present some preliminary results from our data analysis. <s> BIB002 </s> On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> The constructed networks, their validity, and measures validation (Features B) <s> Software development is heavily dependent on the participants of the process and their roles within the process. Each developer has his specific skills and interests and hence contributes to the project in a different way. While some programmers work on separate modules, others developers integrate these modules towards the final product. To identify such different groups of people one approach is to work with methods taken from social network analysis. To this end, a social network has to be defined in a suitable way, and appropriate analysis strategies have to be chosen. This paper shows how a network of software developers could be defined based on information in a software repository, and what it can possibly tell about roles of developers (and what not) in the process of the application server Tomcat. <s> BIB003 </s> On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> The constructed networks, their validity, and measures validation (Features B) <s> We investigate the structures of collaboration in software development groups by analyzing the data derived from the versioning system SVN (subversion) for several open source projects of different types and sizes. The goal of the work presented here is to investigate specific properties of the network topology in the collaboration groups of open source developer communities. For this purpose we developed a software called 'SVN Network Analysis Tool' (SVNNAT) which helps us to analyze the update data in subversion systems (SVN) with respect to the changes committed to the software code. In order to construct the network topology from the SVN data, we defined a collaboration coefficient that is able to express the strength of the developers' relationship in terms of their collaboration during the software production process. We present initial results deriving from the application of SVNNAT to several open source projects including up to 871 software developers. After constructing weighted networks from the matrix representation of the collaboration coefficients, we characterize the resulting networks using typical indicators of topology properties like betweenness, closeness, and degree centralization. <s> BIB004 </s> On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> The constructed networks, their validity, and measures validation (Features B) <s> Software teams should follow a well defined goal and keep their work focused. Work fragmentation is bad for efficiency and quality. In this paper we empirically investigate the relationship between the fragmentation of developer contributions and the number of post-release failures. Our approach is to represent developer contributions with a developer-module network that we call contribution network. We use network centrality measures to measure the degree of fragmentation of developer contributions. Fragmentation is determined by the centrality of software modules in the contribution network. Our claim is that central software modules are more likely to be failure-prone than modules located in surrounding areas of the network. We analyze this hypothesis by exploring the network centrality of Microsoft Windows Vista binaries using several network centrality measures as well as linear and logistic regression analysis. In particular, we investigate which centrality measures are significant to predict the probability and number of post-release failures. Results of our experiments show that central modules are more failure-prone than modules located in surrounding areas of the network. Results further confirm that number of authors and number of commits are significant predictors for the probability of post-release failures. For predicting the number of post-release failures the closeness centrality measure is most significant. <s> BIB005 </s> On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> The constructed networks, their validity, and measures validation (Features B) <s> Studies have shown that social factors in development organizations have adramatic effect on software quality. Separately, program dependencyinformation has also been used successfully to predict which software componentsare more fault prone. Interestingly, the influence of these two phenomena haveonly been studied separately. Intuition and practical experience suggests,however, that task assignment (i.e. who worked on which components and howmuch) and dependency structure (which components have dependencies on others)together interact to influence the quality of the resulting software. Westudy the influence of combined socio-technical software networks onthe fault-proneness of individual software components within a system. Thenetwork properties of a software component in this combined network are ableto predict if an entity is failure prone with greater accuracy than priormethods which use dependency or contribution information in isolation. Weevaluate our approach in different settings by using it on Windows Vista andacross six releases of the Eclipse development environment including usingmodels built from one release to predict failure prone components in the nextrelease. We compare this to previous work. In every case, our method performsas well or better and is able to more accurately identify those softwarecomponents that have more post-release failures, with precision and recallrates as high as 85%. <s> BIB006 </s> On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> The constructed networks, their validity, and measures validation (Features B) <s> A critical factor in work group coordination, communication has been studied extensively. Yet, we are missing objective evidence of the relationship between successful coordination outcome and communication structures. Using data from IBM's Jazz™ project, we study communication structures of development teams with high coordination needs. We conceptualize coordination outcome by the result of their code integration build processes (successful or failed) and study team communication structures with social network measures. Our results indicate that developer communication plays an important role in the quality of software integrations. Although we found that no individual measure could indicate whether a build will fail or succeed, we leveraged the combination of communication structure measures into a predictive model that indicates whether an integration will fail. When used for five project teams, our predictive model yielded recall values between 55% and 75%, and precision values between 50% to 76%. <s> BIB007 </s> On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> The constructed networks, their validity, and measures validation (Features B) <s> This paper analyses the behaviour of virtual communities for Open Source Software (OSS) projects. The development of OSS projects relies on virtual communities, which are built on relationships among members, being their final objective sharing knowledge and improving the underlying project. This study addresses the interactive collaboration in these kinds of communities applying social network analysis (SNA). In particular, SNA techniques will be used to identify those members playing a middle-man role among other community members. Results will illustrate the importance of this role to achieve successful virtual communities. <s> BIB008 </s> On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> The constructed networks, their validity, and measures validation (Features B) <s> In this study, we extract patterns from a large developer collaborations network extracted from Source Forge. Net at high and low level of details. At the high level of details, we extract various network-level statistics from the network. At the low level of details, we extract topological sub-graph patterns that are frequently seen among collaborating developers. Extracting sub graph patterns from large graphs is a hard NP-complete problem. To address this challenge, we employ a novel combination of graph mining and graph matching by leveraging network-level properties of a developer network. With the approach, we successfully analyze a snapshot of Source Forge. Net data taken on September 2009. We present mined patterns and describe interesting observations. <s> BIB009 </s> On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> The constructed networks, their validity, and measures validation (Features B) <s> Ownership is a key aspect of large-scale software development. We examine the relationship between different ownership measures and software failures in two large software projects: Windows Vista and Windows 7. We find that in all cases, measures of ownership such as the number of low-expertise developers, and the proportion of ownership for the top owner have a relationship with both pre-release faults and post-release failures. We also empirically identify reasons that low-expertise developers make changes to components and show that the removal of low-expertise contributions dramatically decreases the performance of contribution based defect prediction. Finally we provide recommendations for source code change policies and utilization of resources such as code inspections based on our results. <s> BIB010 </s> On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> The constructed networks, their validity, and measures validation (Features B) <s> Cross-system bug fixing propagation is frequent among systems having similar characteristics, using a common framework, or, in general, systems with cloned source code fragments. While previous studies showed that clones tend to be properly maintained within a single system, very little is known about cross-system bug management. This paper describes an approach to mine explicitly documented cross-system bug fixings, and to relate their occurrences to social characteristics of contributors discussing through the project mailing lists--e.g., degree, betweenness, and brokerage--as well as to the contributors' activity on source code. The paper reports results of an empirical study carried out on FreeBSD and OpenBSD kernels. The study shows that the phenomenon of cross-system bug fixing between these two projects occurs often, despite the limited overlap of contributors. The study also shows that cross-system bug fixings mainly involve contributors with the highest degree, betweenness and brokerage level, as well as contributors that change the source code more than others. <s> BIB011 </s> On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> The constructed networks, their validity, and measures validation (Features B) <s> A software developer joining a large software project faces a steep learning curve before they are able to make real contributions. One challenge is finding the subject matter experts who can answer questions about a specific area of the software or to review changes. This is especially true of large projects with many modules and a large number of authors. In this paper, we describe a method to model a software project as a network using information mined from the project’s version control repository, and demonstrate how network analysis techniques can be used to identify the key authors and subject matter experts. We investigate metrics that can be gathered using network analysis, such as which groups of authors typically work together, and how closely knit the developers are on a project. We analyze several specific projects to demonstrate the applicability of these techniques and several hundred projects to show general trends. <s> BIB012 </s> On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> The constructed networks, their validity, and measures validation (Features B) <s> In this paper, we firstly create developer networks by affiliation between projects and developers, and then, with respect to social network analysis, take an approach to empirically study the new developers' behavior and the relationship with the centrality measures. We find that most of new developers choose to cooperate with each other initially, but more collaboration are established between new developers and existing developers, and more new collaboration are developed between existing developers who have never collaborated with each other than those have collaborated before. In addition we suggest that new developers prior to cooperate with high between ness centrality or degree centrality and then closeness centrality, discuss that centrality measures can use to guide the preferential collaboration of OSS community. <s> BIB013 </s> On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> The constructed networks, their validity, and measures validation (Features B) <s> Developers build all the software artifacts in development. Existing work has studied the social behavior in software repositories. In one of the most important software repositories, a bug repository, developers create and update bug reports to support software development and maintenance. However, no prior work has considered the priorities of developers in bug repositories. In this paper, we address the problem of the developer prioritization, which aims to rank the contributions of developers. We mainly explore two aspects, namely modeling the developer prioritization in a bug repository and assisting predictive tasks with our model. First, we model how to assign the priorities of developers based on a social network technique. Three problems are investigated, including the developer rankings in products, the evolution over time, and the tolerance of noisy comments. Second, we consider leveraging the developer prioritization to improve three predicted tasks in bug repositories, i.e., bug triage, severity identification, and reopened bug prediction. We empirically investigate the performance of our model and its applications in bug repositories of Eclipse and Mozilla. The results indicate that the developer prioritization can provide the knowledge of developer priorities to assist software tasks, especially the task of bug triage. <s> BIB014 </s> On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> The constructed networks, their validity, and measures validation (Features B) <s> Code authorship information is important for analyzing software quality, performing software forensics, and improving software maintenance. However, current tools assume that the last developer to change a line of code is its author regardless of all earlier changes. This approximation loses important information. We present two new line-level authorship models to overcome this limitation. We first define the repository graph as a graph abstraction for a code repository, in which nodes are the commits and edges represent the development dependencies. Then for each line of code, structural authorship is defined as a sub graph of the repository graph recording all commits that changed the line and the development dependencies between the commits, weighted authorship is defined as a vector of author contribution weights derived from the structural authorship of the line and based on a code change measure between commits, for example, best edit distance. We have implemented our two authorship models as a new git built-in tool git-author. We evaluated git-author in an empirical study and a comparison study. In the empirical study, we ran git-author on five open source projects and found that git-author can recover more information than a current tool (git-blame) for about 10% of lines. In the comparison study, we used git-author to build a line-level model for bug prediction. We compared our line-level model with an existing file-level model. The results show that our line-level model performs consistently better than the file-level model when evaluated on our data sets produced from the Apache HTTP server project. <s> BIB015 </s> On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> The constructed networks, their validity, and measures validation (Features B) <s> Using a bug repository, developers contribute to improve the quality of software incrementally by creating and updating bug reports. All the software artifacts in bug repositories are derived from developer contribution. Most prior studies on developer contribution in bug repositories bias on one particular form, e.g., commenting bug reports. However, in real practice of bug repositories, developers participate in and contribute to software projects via multiple ways, e.g., reporting new bugs, reopening incorrectly fixed bugs, commenting unfixed bug reports, and fixing unsolved bugs. In this paper, we exploit recent advances in analysis of heterogeneous network to avoid biased aspects in measuring developer contribution and explore multiple types of developer contribution in bug repositories. Further, we consider leveraging such multiple types of developer contribution to assist a typical prediction problem in bug repositories, i.e., bug triage. Empirical studies on bug repositories of Eclipse and Mozilla show that our approach can provide enriched knowledge of developer contribution to improve the resolution of bug triage. This study strongly suggests using the promising aspects of heterogeneous network can open many actionable insights in analyzing software repositories. <s> BIB016 </s> On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> The constructed networks, their validity, and measures validation (Features B) <s> Universally accessible and publically archived nature of Bug Tracking System (BTS) of Open Source Software enables developers to follow the work of each other and contribute in bug fixing. The interaction of developers through comments on BTS of project leads to form a social network. The developers and their relationships change over the time resulting in evolution of Developers' social network (DSN). Prior studies (Hong et.al) have compared the evolution of DSN with evolution of general social networks like facebook, twitter etc., showing their resemblance and some differences with them. However these studies don't provide any insight how the evolution of DSN correlate with the effectiveness of bug fixing process over the time. Such insight is helpful as managers can reorganize the teams and issue the guidelines to the developers, accordingly, forcing the communication structure which results in to more effective bug fixing process. In this paper, we first study the evolution of DSN of Eclipse a java based IDE, partially replicating and enhancing the study done by Hong et. al. Then we show how the global social network properties of the DSN e.g. Average Path Length, Clustering Coefficient, modularity etc. has an impact on attributes characterizing effectiveness of bug fixing process like average fix time of the bugs, percentage of bugs fixed etc. We found good correlation between global social network properties and attributes characterizing the bug fixing process. <s> BIB017 </s> On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> The constructed networks, their validity, and measures validation (Features B) <s> We conduct a statistical analysis on the social networks of contributors in Open Source Software (OSS) communities using datasets collected from two most fast-growing OSS social interaction sites, Github.com and Ohloh.net. Our goal is to analyze the connectivity structure of the social networks of contributors and to investigate the effect of the different social tie structures on developers' overall productivity to OSS projects. We first analyze the general structure of the social networks, e.g., graph distances and the degree distribution of the social networks. Our analysis confirms that the social networks of OSS communities follow power-law degree distributions and exhibit small-world characteristics. However, the degree mixing pattern shows that high degree nodes tend to connect more with low degree nodes, suggesting collaborations between experts and newbie developers. Second, we study the correlation between graph degrees and the productivity of the contributors in terms of the amount of contribution and commitment to OSS projects. The analysis demonstrates evident influence of the social ties on the developers' overall productivity. <s> BIB018 </s> On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> The constructed networks, their validity, and measures validation (Features B) <s> Developer teams may naturally emerge independent of managerial decisions, organizational structure, or work locations in large software. Such self organized collaboration teams of developers can be traced from the source code repositories. In this paper, we identify the developer teams in the collaboration network in order to present the work team evolution and the factors that affect team stability for a large, globally developed, commercial software. Our findings indicate that: a) Number of collaboration teams do not change over time, b) Size of the collaboration teams increases over time, c) Team activity is not related with team size, d) Factors related to team size, location and activity affect the stability of teams over time. <s> BIB019 </s> On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> The constructed networks, their validity, and measures validation (Features B) <s> Determining contributors' expertise, role, and individual importance are fundamental for assessing their impact on a software project. Currently-used expertise metrics are agnostic to contributor roles and can lead to incorrect characterizations. To address these issues, we operationalize contributor expertise and role. First, we revisit current expertise metrics and show that their use bundles many different aspects, creating ambiguity. Second, we introduce clearly-defined contributor roles, which capture multiple project facets. Third, we propose a graph model, based on contributor collaborations, that captures the hierarchical structure of the contributor community in a concise yet informative way. We demonstrate the model's usefulness in two ways: (a) for identifying the structure and evolution of contributor interactions, (b) for predicting contributor roles. We substantiate our study using two large open-source projects, Fire fox and Eclipse. Our systematic approach clarifies and isolates contributor role and expertise, and sheds light onto the dynamics of contributors within software projects. <s> BIB020 </s> On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> The constructed networks, their validity, and measures validation (Features B) <s> Developers contributing to open source projects spontaneously group into "emerging'' teams, reflected by messages exchanged over mailing lists, issue trackers and other communication means. Previous studies suggested that such teams somewhat mirror the software modularity. This paper empirically investigates how, when a project evolves, emerging teams re-organize themselves-e.g., by splitting or merging. We relate the evolution of teams to the files they change, to investigate whether teams split to work on cohesive groups of files. Results of this study-conducted on the evolution history of four open source projects, namely Apache httpd, Eclipse JDT, Netbeans, and Samba-provide indications of what happens in the project when teams reorganize. Specifically, we found that emerging team splits imply working on more cohesive groups of files and emerging team merges imply working on groups of files that are cohesive from structural perspective. Such indications serve to better understand the evolution of software projects. More important, the observation of how emerging teams change can serve to suggest software remodularization actions. <s> BIB021 </s> On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> The constructed networks, their validity, and measures validation (Features B) <s> Effective software engineering demands a coordinated effort. Unfortunately, a comprehensive view on developer coordination is rarely available to support software-engineering decisions, despite the significant implications on software quality, software architecture, and developer productivity. We present a fine-grained, verifiable, and fully automated approach to capture a view on developer coordination, based on commit information and source-code structure, mined from version-control systems. We apply methodology from network analysis and machine learning to identify developer communities automatically. Compared to previous work, our approach is fine-grained, and identifies statistically significant communities using order-statistics and a community-verification technique based on graph conductance. To demonstrate the scalability and generality of our approach, we analyze ten open-source projects with complex and active histories, written in various programming languages. By surveying 53 open-source developers from the ten projects, we validate the authenticity of inferred community structure with respect to reality. Our results indicate that developers of open-source projects form statistically significant community structures and this particular view on collaboration largely coincides with developers' perceptions of real-world collaboration. <s> BIB022
Not surprisingly, the nodes in the majority of the networks of the PSs were Contributors, which means any human who contributed to a software repository, like a developer, a tester, an architect, etc. An exception to this was the work in BIB015 BIB006 BIB001  BIB012 where the nodes were two sets of a bipartite network and the analysis was done on the constructed bipartite network, not on a one-mode projected network. For feature "B3", there were 3 PSs, BIB010 BIB016 BIB020 , where the constructed network was a multiplex network. Additionally, only 5 PSs, BIB003 BIB017  BIB013 BIB008 , considered the temporality of a network and provided a dynamic network. The rest of the primary studies considered a static network. The PSs that considered directed networks were 13 PSs, BIB007 BIB011 BIB002 BIB016 BIB014 BIB004 BIB015 BIB022 BIB006 BIB020 BIB018 BIB008  and the rest PSs considered an undirected network. We found that 60% of the PSs, 21 PSs, used a proxy edge. Only 5 PSs, BIB007 BIB003 BIB021 BIB020 BIB001 , used a multiplex representation of the network. The rest used a unipelx network. Nearly 89% of the PSs aggregated the networks over time and used a single static network, only 4 primary studies, BIB003 BIB017  BIB013 considered different networks of the same nodes over time and performed analysis based on this situation. For feature "B10", only 13 PSs considered the weights of the edges, while the other 22 PSs did not consider the edge weights. The used measures in the PSs are shown in Figure 8 . The figure shows that the Degree and the Betweenness centrality measures were dominant among the used measures with 21 and 17 times used in the PSs, respectively. Motif analysis was used only once in the work BIB009 . The measures in "Others" are measures that were used only one time across the PSs. For the feature "B12", we found that 11 PSs did not provide sufficient definition and explanation for the used measures, and only 9 PSs, BIB005 BIB021 BIB010 BIB016  BIB015 BIB022 BIB019 BIB020 , contributed (devised) new measures and(or) models for the constructed networks. Surprisingly, we found only 14%, 5 PSs out of the 35, that used a Null model to validate the results. The rest of the PSs did not use any statistical validation of the results.