On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> From SE to a network (Fields A) <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> From SE to a network (Fields A) <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> BIB002 </s> On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> From SE to a network (Fields A) <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> BIB003 </s> On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> From SE to a network (Fields A) <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> BIB004 </s> On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> From SE to a network (Fields A) <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> BIB005 </s> On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> From SE to a network (Fields A) <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> BIB006 </s> On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> From SE to a network (Fields A) <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> BIB007
In this section, we provide the results for the extraction features "A1" to "A3". As per the inclusion and exclusion criteria described in Section 3.2, all of the included PSs were handling Human Aspects of software engineering. Thus, the Figure 7 shows the used networks in the PSs. The most used network, in 15 PS, was the Collaboration Network where the nodes were developers and an edge appeared between any two developers if they worked together on the same file, line of code, module, or project. If the collaboration network was based on more than one type of interaction between the developers, then this was a one-mode projection from a multiplex bipartite network. The Communication network was constructed by modeling the developers as nodes and the edges were communication messages between developers. The Developer-project network was a bipartite network where the two sets V L and V R were the developers and the projects, respectively, and the edges represented developers taking part in a project. Similarly, the Developer-module network was a bipartite network between developers and the modules. Those two networks were found in 7 primary studies, BIB002  BIB004 BIB003 BIB001  BIB005 . The Follow network was the social network of the Github platform where a developer could explicitly follow another one, like Twitter. The other two networks, the Hierarchical and Repository networks were devised and contributed networks of the works in BIB006 BIB007 , respectively. 