On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> Discussion around RQ1: <s> Since code revisions reflect the extent of human involvement in the software development process, revision histories reveal the interactions and interfaces between developers and modules.We therefore divide developers and modules into groups according to the revision histories of the open source software repository, for example, sourceforge.net. To describe the interactions in the open source development process, we use a representative model, Legitimate Peripheral Participation (LPP) [6], to divide developers into groups such as core and peripheral teams, based on the evolutionary process of learning behavior.With the conventional module relationship, we divide modules into kernel and non-kernel types (such as UI). In the past, groups of developers and modules have been partitioned naturally with informal criteria. In this work, however, we propose a developer-module relationship model to analyze the grouping structures between developers and modules. Our results show some process cases of relative importance on the constructed graph of project development. The graph reveals certain subtle relationships in the interactions between core and non-core team developers, and the interfaces between kernel and non-kernel modules. <s> BIB001 </s> On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> Discussion around RQ1: <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> BIB002 </s> On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> Discussion around RQ1: <s> Commercial software project managers design project organizational structure carefully, mindful of available skills, division of labour, geographical boundaries, etc. These organizational "cathedrals" are to be contrasted with the "bazaar-like" nature of Open Source Software (OSS) Projects, which have no pre-designed organizational structure. Any structure that exists is dynamic, self-organizing, latent, and usually not explicitly stated. Still, in large, complex, successful, OSS projects, we do expect that subcommunities will form spontaneously within the developer teams. Studying these subcommunities, and their behavior can shed light on how successful OSS projects self-organize. This phenomenon could well hold important lessons for how commercial software teams might be organized. Building on known well-established techniques for detecting community structure in complex networks, we extract and study latent subcommunities from the email social network of several projects: Apache HTTPD, Python, PostgresSQL, Perl, and Apache ANT. We then validate them with software development activity history. Our results show that subcommunities do indeed spontaneously arise within these projects as the projects evolve. These subcommunities manifest most strongly in technical discussions, and are significantly connected with collaboration behaviour. <s> BIB003 </s> On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> Discussion around RQ1: <s> Software fails and fixing it is expensive. Research in failure prediction has been highly successful at modeling software failures. Few models, however, consider the key cause of failures in software: people. Understanding the structure of developer collaboration could explain a lot about the reliability of the final product. We examine this collaboration structure with the developer network derived from code churn information that can predict failures at the file level. We conducted a case study involving a mature Nortel networking product of over three million lines of code. Failure prediction models were developed using test and post-release failure data from two releases, then validated against a subsequent release. One model's prioritization revealed 58% of the failures in 20% of the files compared with the optimal prioritization that would have found 61% in 20% of the files, indicating that a significant correlation exists between file-based developer network metrics and failures. <s> BIB004 </s> On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> Discussion around RQ1: <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> BIB005 </s> On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> Discussion around RQ1: <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> BIB006 </s> On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> Discussion around RQ1: <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> BIB007 </s> On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> Discussion around RQ1: <s> Members of software project teams have specific roles and responsibilities which are formally defined during project inception or at the start of a life cycle activity. Often, the team structure undergoes spontaneous changes as delivery deadlines draw near and critical tasks have to be completed. Some members -- depending on their skill or seniority -- need to take on more responsibilities, while others end up being peripheral to the project's execution. We posit that this kind of ad hoc reorganization of a team's structure can be discerned from the project's bug tracker. In this paper, we extract a social network from the bug log of a real life software system and apply ideas from social network analysis to understand how the positions of individual team members in the network relate to their organizational seniority, project roles, and geographic locations that define the formal team structure. In addition to providing insights on individual team members for the system studied, our approach can serve as a framework for analyzing team dynamics of software projects. <s> BIB008 </s> On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> Discussion around RQ1: <s> Correcting software defects accounts for a significant amount of resources such as time, money and personnel. To be able to focus testing efforts where needed the most, researchers have studied statistical models to predict in which parts of a software future defects are likely to occur. By studying the mathematical relations between predictor variables used in these models, researchers can form an increased understanding of the important connections between development activities and software quality. Predictor variables used in past top-performing models are largely based on file-oriented measures, such as source code and churn metrics. However, source code is the end product of numerous interlaced and collaborative activities carried out by developers. Traces of such activities can be found in the repositories used to manage development efforts. In this paper, we investigate statistical models, to study the impact of social structures between developers and end-users on software quality. These models use predictor variables based on social information mined from the issue tracking and version control repositories of a large open-source software project. The results of our case study are promising and indicate that statistical models based on social information have a similar degree of explanatory power as traditional models. Furthermore, our findings suggest that social information does not substitute, but rather augments traditional product and process-based metrics used in defect prediction models. <s> BIB009 </s> On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> Discussion around RQ1: <s> Social network analysis has many applications in software engineering and is often performed through the use of visualizations. Discovery of these networks, however, presents a challenge since the relationships are initially not known. We present an approach for mining and visualizing networks of software developers from version control systems. It computes similarities among developers based on common file changes, constructs the network of collaborating developers and applies filtering techniques to improve the modularity of the network. We validate the approach on two projects from industry and demonstrate its use in a case study of an open-source project. Results indicate that the approach performs well in revealing the structure of development teams and improving the modularity in visualizations of developer networks. <s> BIB010 </s> On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> Discussion around RQ1: <s> Software development teams must be properly structured to provide effectiv collaboration to produce quality software. Over the last several years, social network analysis (SNA) has emerged as a popular method for studying the collaboration and organization of people working in large software development teams. Researchers have been modeling networks of developers based on socio-technical connections found in software development artifacts. Using these developer networks, researchers have proposed several SNA metrics that can predict software quality factors and describe the team structure. But do SNA metrics measure what they purport to measure? The objective of this research is to investigate if SNA metrics represent socio-technical relationships by examining if developer networks can be corroborated with developer perceptions. To measure developer perceptions, we developed an online survey that is personalized to each developer of a development team based on that developer's SNA metrics. Developers answered questions about other members of the team, such as identifying their collaborators and the project experts. A total of 124 developers responded to our survey from three popular open source projects: the Linux kernel, the PHP programming language, and the Wireshark network protocol analyzer. Our results indicate that connections in the developer network are statistically associated with the collaborators whom the developers named. Our results substantiate that SNA metrics represent socio-technical relationships in open source development projects, while also clarifying how the developer network can be interpreted by researchers and practitioners. <s> BIB011 </s> On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> Discussion around RQ1: <s> A great variety of systems in nature, society and technology -- from the web of sexual contacts to the Internet, from the nervous system to power grids -- can be modeled as graphs of vertices coupled by edges. The network structure, describing how the graph is wired, helps us understand, predict and optimize the behavior of dynamical systems. In many cases, however, the edges are not continuously active. As an example, in networks of communication via email, text messages, or phone calls, edges represent sequences of instantaneous or practically instantaneous contacts. In some cases, edges are active for non-negligible periods of time: e.g., the proximity patterns of inpatients at hospitals can be represented by a graph where an edge between two individuals is on throughout the time they are at the same ward. Like network topology, the temporal structure of edge activations can affect dynamics of systems interacting through the network, from disease contagion on the network of patients to information diffusion over an e-mail network. In this review, we present the emergent field of temporal networks, and discuss methods for analyzing topological and temporal structure and models for elucidating their relation to the behavior of dynamical systems. In the light of traditional network theory, one can see this framework as moving the information of when things happen from the dynamical system on the network, to the network itself. Since fundamental properties, such as the transitivity of edges, do not necessarily hold in temporal networks, many of these methods need to be quite different from those for static networks. <s> BIB012 </s> On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> Discussion around RQ1: <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> BIB013 </s> On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> Discussion around RQ1: <s> We study the dynamics of the European Air Transport Network by using a multiplex network formalism. We will consider the set of flights of each airline as an interdependent network and we analyze the resilience of the system against random flight failures in the passenger's rescheduling problem. A comparison between the single-plex approach and the corresponding multiplex one is presented illustrating that the multiplexity strongly affects the robustness of the European Air Network. <s> BIB014 </s> On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> Discussion around RQ1: <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> Discussion around RQ1: <s> In most natural and engineered systems, a set of entities interact with each other in complicated patterns that can encompass multiple types of relationships, change in time, and include other types of complications. Such systems include multiple subsystems and layers of connectivity, and it is important to take such"multilayer"features into account to try to improve our understanding of complex systems. Consequently, it is necessary to generalize"traditional"network theory by developing (and validating) a framework and associated tools to study multilayer systems in a comprehensive fashion. The origins of such efforts date back several decades and arose in multiple disciplines, and now the study of multilayer networks has become one of the most important directions in network science. In this paper, we discuss the history of multilayer networks (and related concepts) and review the exploding body of work on such networks. To unify the disparate terminology in the large body of recent work, we discuss a general framework for multilayer networks, construct a dictionary of terminology to relate the numerous existing concepts to each other, and provide a thorough discussion that compares, contrasts, and translates between related notions such as multilayer networks, multiplex networks, interdependent networks, networks of networks, and many others. We also survey and discuss existing data sets that can be represented as multilayer networks. We review attempts to generalize single-layer-network diagnostics to multilayer networks. We also discuss the rapidly expanding research on multilayer-network models and notions like community structure, connected components, tensor decompositions, and various types of dynamical processes on multilayer networks. We conclude with a summary and an outlook. <s> BIB016 </s> On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> Discussion around RQ1: <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> BIB017 </s> On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> Discussion around RQ1: <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> BIB018 </s> On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> Discussion around RQ1: <s> In the past years, network theory has successfully characterized the interaction among the constituents of a variety of complex systems, ranging from biological to technological, and social systems. However, up until recently, attention was almost exclusively given to networks in which all components were treated on equivalent footing, while neglecting all the extra information about the temporal- or context-related properties of the interactions under study. Only in the last years, taking advantage of the enhanced resolution in real data sets, network scientists have directed their interest to the multiplex character of real-world systems, and explicitly considered the time-varying and multilayer nature of networks. We offer here a comprehensive review on both structural and dynamical organization of graphs made of diverse relationships (layers) between its constituents, and cover several relevant issues, from a full redefinition of the basic structural measures, to understanding how the multilayer nature of the network affects processes and dynamics. <s> BIB019 </s> On Using Network Science in Mining Developers Collaboration in Software Engineering: A Systematic Literature Review <s> Discussion around RQ1: <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> BIB020
To answer this question, we need to test the quality of the constructed network. To that end, we will use the results of features "B1" to "B10" to answer this question. The quality of the network stems from the quality of its components (i.e., the nodes and the edges) and on the other aspects we mentioned in the definition section like being weighted, multiplex, or bipartite. Based on the results, we found that 60% of the PSs used a proxy edge. A proxy edge is obtained by doing one (or more) of the following: -Classical OMP: which was described in the Section 2. The PSs BIB013  BIB002 BIB017  BIB007 did classical OMP, which does not respect the edge weights. That means, the links between any two developers, for example, in the network who collaborated 1 time or 1000 times are treated equally. The resulted network is not informative and a lot of measure, like the degree centrality, do not provide meaningful results for the projected networks if the weights are ignored. -Multiplex(space) aggregation: In this type of aggregation, like PSs BIB017 BIB003 BIB007 BIB006 BIB018 BIB002 , the edges are aggregated from different types of relationships(interactions). This results in a dense disguised network, in which the link do not reflect any special interaction that can be meaningfully quantified. Edge aggregation from different types of interactions is an oversimplification of reality, which yields wrong conclusions as shown by Cardillo et al. BIB014 . -Temporal(time) aggregation: In this type of aggregation, like the PSs  BIB004 BIB010 BIB001 BIB008 BIB003 BIB005 BIB015 BIB011 BIB020  BIB017 BIB009 BIB007  BIB002  BIB013 , the edges are aggregated over time into a single network. The problem of the previous classical OMP and the aggregations is that it generates a very dense graphs, where every node is almost connected to every other node in the network. This renders many measures, like the degree centrality, not of much benefit. Some researchers were aware of this problem and included this as a threat to validity in their work, like the PS BIB010 . Additionally, the bipartite networks, the dynamic networks, and the multiplex networks have their special characteristic that differs from the unipartite static network. Thus, converting any non-unipartite, non-static, or multiplex network into a unipartite static network should be done with extreme care if required, and generally we recommend keeping the network in its nature. Additionally, the collaboration intensity (or frequency) was not considered when it should be. To address the problems found in the PSs for this research question, we provide here some pointers to extend the space of the used methods. For example, the work by Zweig  provides a systematic method to do a proper one mode projection, the works by Kivelä et al. BIB016 and by Boccaletti et al. BIB019 provide a good resource for the methods, the models, and the measures that can be used to analyze the multiplex networks, and the seminal work by Holme and Saramäki BIB012 provide frameworks, measures, and methods for the temporal networks (dynamic networks).