Core developer identification method, device and equipment based on developer collaboration network

Abstract

The present application relates to a method, device and equipment for identifying core developers based on a developer collaboration network in the field of Internet technology. The method addresses the problem of difficulty in identifying core developers in open source projects with a large number of developers. Based on the collaborative relationship of developers' participation and contribution, an undirected and entitled collaborative network of developers is constructed. Based on the undirected and entitled collaborative network, a developer importance index for identifying core developers is proposed. Developers are ranked according to the developer importance index, and core developers are identified. Compared with previous evaluation methods, the method comprehensively considers the personal influence and collaborative influence of developers who participate in the contribution, and uses a complex network system to comprehensively explain the developer behavior, eliminating the tedious steps of collating and analyzing a large amount of contribution data, saving a lot of resources, improving the accuracy and efficiency of judging the importance of developers, and improving the efficiency of identifying core developers.

Description

Technical Field

[0001] The present application relates to the field of Internet technology, and in particular to a method, apparatus, and device for identifying core developers based on a developer collaboration network. Background Art

[0002] In recent years, with the continuous evolution of development models, open source has gradually entered the public eye. Open source communities, exemplified by GitHub, GitLink, and OSchina, have fostered a wealth of excellent open source software. However, open source project development is characterized by low barriers to entry and free participation. The spontaneity and uncertainty of participating developers have led to problems such as low development efficiency, poor sustainability, and difficulty ensuring project quality in some projects. Abandoned projects also waste significant resources. To prevent the loss of talented core developers, promote project development vitality, enhance developer collaboration, and improve the management quality of open source projects, some open source communities are developing profiling of developer capabilities to determine their importance. While assigning attribute labels to developers can, to some extent, alleviate the problem of low development efficiency in collaboration, due to the limitations of these labels, the resulting developer attributes tend to be flat, failing to fully consider developer behavior and collaborative relationships. They rely solely on historical contribution data to identify developers, making it particularly difficult to identify core developers with outstanding capabilities and contributions among peripheral developers. If a developer collaboration network can be built based on the contributions of developers in open source projects, the core developers at the "hub nodes" will be clearly visible, which can greatly improve the accuracy and efficiency of core developer positioning.

[0003] Currently, methods for identifying developer criticality are primarily constructed from two perspectives: based on historical contribution data and based on developer relationship attributes. The historical contribution data perspective assesses developer contributions based on factors such as the number of files and lines of code contributed, and the level of discussion involved. The developer relationship attribute perspective constructs developer types based on developer relationship networks, developer skill attributes, or the division of developer responsibilities. Using different evaluation criteria to determine developer importance, different types of developers are rated. Generally speaking, methods based on historical contribution data typically determine developer importance based on objective data, such as the amount of code submitted and the number of contributions made. While objective and direct, these methods often overlook the spontaneity and subjectivity of developer behavior and the collaborative relationships between developers. The developer relationship attribute perspective fully considers this aspect, but at the same time, simply considering developer relationships while downplaying historical contributions is undesirable. Summary of the Invention

[0004] Based on this, it is necessary to address the above technical issues, make full use of the historical data content provided by the open source community, and combine it with the research methods of complex system network science to provide a core developer identification method, device and equipment based on the developer collaboration network.

[0005] A method for identifying core developers based on a developer collaboration network, the method comprising:

[0006] The data of each event in each event set of a predetermined open source project is obtained, and the data of the event is processed into records in a specified format; and a local database is constructed based on all the records in the specified format.

[0007] The records in the local database are grouped according to the set time slices to obtain time slice groups, and secondary grouping is performed according to event sets within different time slice groups. The initiators of the events in the obtained different event set groups are matched in pairs to obtain developer data pairs.

[0008] An undirected collaboration network is constructed with the developers included in the developer data pairs as nodes and the developer data pairs as edges.

[0009] The edges of the undirected collaboration network are traversed, corresponding edge weights are determined according to the number of times the developer data pair corresponding to the edge appears repeatedly in different event set groups, and the edge weights of the undirected collaboration network are updated according to the edge weights.

[0010] Based on the obtained undirected authorized collaboration network, the developer's personal influence factor and collaboration influence factor are calculated.

[0011] A developer importance index of a developer in an undirected authorized collaboration network is determined according to the developer's personal influence factor and the collaboration influence factor.

[0012] A developer importance ranking is determined based on the developer importance index, and core developers are identified.

[0013] In one embodiment, data of each event in each event set of a predetermined open source project is obtained, the event data is processed into records in a specified format; and a local database is constructed based on all records in the specified format, including:

[0014] Use crawlers to crawl data for each event in each dataset of a predetermined open source project.

[0015] Process the data of each event into JSON format records.

[0016] The JSON format records of the events contained in the event set are stored in the local database as the smallest unit of storage data; the attributes of the JSON format records of the events include: an identification attribute corresponding to the corresponding event set identifier, the initiator of the event, and the time when the event occurred.

[0017] In one embodiment, the records in the local database are grouped according to a set time slice to obtain time slice groups, and then further grouped according to event sets within different time slice groups. The initiators of the events within the different event set groups are matched pairwise to obtain developer data pairs, including:

[0018] Each record in the local database is grouped according to a set time slice to obtain a time slice group.

[0019] The event data in the same time slice group are grouped again according to the event set identifier, and the event data with the same event set identifier are grouped as one to obtain the event set group.

[0020] Match the initiators of the events in the same event set group in pairs to obtain developer data pairs; the data format of the developer data pairs is:

[0021] {[(x0,y0),(x1,y1)...],[(z0,m0),(z1,m1)...],...}

[0022] Among them, x0, x1, ..., y0, y1, ..., z0, z1, ..., m0, m1, ... are all initiators of events, () is the developer data pair in the same event set in the same time slice, and [] is the grouping of different event sets in the same time slice.

[0023] In one embodiment, traversing the edges of the undirected collaboration network, determining corresponding edge weights based on the number of times the developer data pairs corresponding to the edges appear repeatedly in different event set groups, and updating the edge weights of the undirected collaboration network based on the edge weights includes:

[0024] Check whether the developer data pairs corresponding to the edges of the undirected collaborative network appear repeatedly in the corresponding time slice grouping and event set grouping. Each time they appear repeatedly, the edge weight is increased by 1 until all edges of the undirected collaborative network are traversed, thereby obtaining the edge weights of all edges in the undirected collaborative network.

[0025] The edge weights of the undirected collaboration network are updated according to the edge weights.

[0026] In one embodiment, calculating the developer's personal influence factor and collaboration influence factor based on the obtained undirected authorized collaboration network includes:

[0027] Based on the undirected authorized collaboration network, the developer's personal influence factor and collaboration influence factor are calculated; the expression of the developer's personal influence factor is:

[0028]

[0029] Where T(i) is the developer’s personal influence factor corresponding to node i, k(i) is the degree of node i, DG(i) is the maximum connected subgraph after deleting node i in the undirected weighted collaboration network, and G is the initial graph of the undirected weighted collaboration network.

[0030] The expression of the collaborative influence factor is:

[0031] I(i)=∑ i,j∈S W(i,j)·k(j)

[0032] Among them, I(i) is the collaborative influence factor of the developer corresponding to node i, W(i,j) is the weight ratio of node j to node i, k(j) is the degree of node j, and S is the connected graph where nodes i and j are located.

[0033] In one embodiment, when node j is a neighbor of node i, the weight between node j and node i is divided by the sum of the weights between all neighbors of node i and node i to obtain the weight ratio of node j to node i.

[0034] When node j is the secondary neighbor of node i, the weight ratio of node j to node i is calculated based on the weight of the shortest path and the longest path with the highest number of connections from node j to node i.

[0035] In one embodiment, the developer importance index of the developer in the undirected rightful collaboration network is determined based on the developer's personal influence factor and the collaboration influence factor. The expression of the developer importance index in the step is:

[0036] DIM=T(i)+I(i)

[0037] Among them, DIM=T(i)+I(i) is the developer importance index, T(i) is the personal influence factor of the developer corresponding to node i, and I(i) is the collaborative influence factor of the developer corresponding to node i.

[0038] A core developer identification device based on a developer collaboration network, the device comprising:

[0039] The local database construction module is used to obtain data of each event in each event set of a predetermined open source project, process the data of the event into records in a specified format; and construct a local database based on all the records in the specified format.

[0040] An undirected collaborative network construction module is used to group the records in the local database according to the set time slices to obtain time slice groups, perform secondary grouping according to event sets within different time slice groups, match the initiators of the events in the different event set groups obtained in pairs, and obtain developer data pairs; use the developers included in the developer data pairs as nodes and the developer data pairs as edges to construct an undirected collaborative network.

[0041] The undirected authorized collaboration network determination module is used to traverse the edges of the undirected collaboration network, determine the corresponding edge weights based on the number of times the developer data corresponding to the edge appears repeatedly in different event set groups; and update the edge weights of the undirected collaboration network based on the edge weights.

[0042] A developer importance index determination module is used to calculate the developer's personal influence factor and collaborative influence factor based on the obtained undirected authorized collaboration network; and determine the developer importance index of the developer in the undirected authorized collaboration network based on the developer's personal influence factor and the collaborative influence factor;

[0043] The core developer identification module is used to determine the developer importance ranking according to the developer importance index and identify the core developers.

[0044] In one embodiment, the local database construction module is further used to use a crawler program to crawl the data of each event under each data set of a predetermined open source project; process the data of each event into a JSON format record; store the JSON format record of the events contained in the event set as the smallest unit of storing data in the local database; the attributes of the JSON format record of the event include: an identification attribute corresponding to the corresponding event set identifier, the initiator of the event, and the time when the event occurred.

[0045] A computer device includes a memory and a processor, wherein the memory stores a computer program, and the processor implements the above method when executing the computer program.

[0046] The aforementioned method, apparatus, and device for identifying core developers based on a developer collaboration network address the difficulty of identifying core developers in open source projects with a large number of developers. By constructing an undirected, authoritative collaboration network of developers based on their collaborative relationships, the method proposes a developer importance index for identifying core developers based on the undirected, authoritative collaboration network. Developers are ranked and identified based on this developer importance index. Compared to previous evaluation methods, this method comprehensively considers the individual influence and collaborative influence of contributing developers and utilizes a complex network system to comprehensively explain developer behavior. This method eliminates the tedious steps of collating and analyzing large amounts of contribution data, conserves significant resources, improves the accuracy and efficiency of developer importance assessments, and enhances the efficiency of identifying core developers. BRIEF DESCRIPTION OF THE DRAWINGS

[0047] Figure 1 1 is a flow chart of a method for identifying core developers based on a developer collaboration network in one embodiment;

[0048] Figure 2 A partial schematic diagram of an undirected authorized collaboration relationship network in another embodiment;

[0049] Figure 3 1 is a flow chart of a method for identifying core developers based on a developer collaboration network in another embodiment;

[0050] Figure 4 A structural block diagram of a core developer identification device based on a developer collaboration network in one embodiment;

[0051] Figure 5 FIG. 1 is a diagram showing the internal structure of a computer device in one embodiment. DETAILED DESCRIPTION

[0052] In order to make the purpose, technical solutions and advantages of this application more clear, the following further describes this application in detail with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are only used to explain this application and are not intended to limit this application.

[0053] The purpose of this invention is to address the shortcomings of existing models, make full use of the historical data content provided by the open source community, combine the research methods of complex system network science, and propose a core developer identification method based on the developer collaboration network.

[0054] In one embodiment, Figure 1 As shown, a method for identifying core developers based on a developer collaboration network is provided, which includes the following steps:

[0055] Step 100: Obtain data of each event in each event set of a predetermined open source project, process the event data into records in a specified format; and construct a local database based on all records in the specified format.

[0056] Use crawler programs to obtain digital data of various events under the event set of predetermined open source projects in the open source community.

[0057] The events contained in the event set are used as the smallest unit for storing data. The corresponding event set identification attribute is added to each event to mark which event set the event belongs to. In addition, the event must at least contain information such as the initiator of the event and the time when the event occurred, and the data is stored in the database.

[0058] Preferably, the records in the specified format may be records in json format, and the data processing tool used to process the event data into records in the specified format is an API that conforms to the json format, such as GitHub's GraphQL query language.

[0059] GraphQL is a query language that is particularly advantageous for querying Graph (graph-like data).

[0060] Step 102: Group the records in the local database according to the set time slice to obtain time slice groups, perform secondary grouping according to event sets within different time slice groups, match the initiators of the events in the different event set groups in pairs, and obtain developer data pairs.

[0061] Specifically, the following operations are performed on each record in the local database: data in the same time slice are grouped according to a certain time slice (the event data in the same group are events that occurred in the same time slice); different groups are grouped according to event sets, and events in the same event set are grouped together; the initiators of the events in the group are matched pairwise to form a developer data pair (x, y). This data pair is undirected, and x and y are two different developers in the same event.

[0062] Step 104: Construct an undirected collaboration network with the developers included in the developer data pairs as nodes and the developer data pairs as edges.

[0063] Specifically, an undirected collaborative network is constructed under different time slices, with developers (the initiators of the event in step 102) as nodes of the network and developer data pairs (x, y) as edges. The meaning of the edges is that the developers have the same contribution (the same set of events) in the time slice.

[0064] Step 106: Traverse the edges of the undirected collaboration network, determine the corresponding edge weights based on the number of times the developer data corresponding to the edges appear repeatedly in different event set groups, and update the edge weights of the undirected collaboration network based on the edge weights.

[0065] Specifically, two developers may participate in different event sets (participating in more than one identical contribution), in which case the same developer data pair (x, y) will exist in different event sets. The number of occurrences of (x, y) is recorded as the weight of the edge between the two developers.

[0066] Step 108: Calculate the developer's personal influence factor and collaboration influence factor based on the obtained undirected authorized collaboration network.

[0067] The developer's personal influence factor refers to an indicator that measures the impact of a developer's personal contribution on project development. In the personal influence factor formula, DG(i) is the connected subgraph of the collaboration network after deleting developer i (node ​​i in the model), and G is the initial graph of the collaboration network. Because DG(i) / G<100%, the percentage of loss is the personal influence percentage of developer i, which is multiplied by the degree k(i) of node i to obtain the personal influence factor.

[0068] The collaboration influence factor is a metric that measures the impact of a developer's contributions on other developers in a collaborative network. The calculation for neighbor nodes is relatively simple: the weight percentage multiplied by the node's degree, which will not be explained in detail here. To calculate the impact for secondary neighbor nodes, because in a connected graph, there is no unique path to a secondary neighbor, we first need to determine the shortest number of connections to the secondary neighbor. Each additional connection multiplies the weight by a number less than 1, weakening the impact. Next, we need to identify the path with the highest edge weight within the shortest number of connections. In real-world scenarios, this also indicates closer developer collaboration along this path. Once the path is determined, the developer collaboration influence factor can be calculated using the formula.

[0069] Step 110: Determine the developer importance index of the developer in the undirected authorized collaboration network based on the developer's personal influence factor and the collaboration influence factor.

[0070] Developer Importance Metrics (DIM) are divided into two parts. For node i in an undirected authorized collaboration network, the first part is the developer's personal influence factor T(i), and the second part is the collaboration influence factor I(i).

[0071] When judging the importance of developers, we must consider both the developers' historical contribution data and the construction of a network structure that reflects the collaborative relationship between developers. It is extremely important to combine the properties of the developer collaboration network topology with the historical contribution data of each developer to comprehensively judge the criticality of the developer.

[0072] Step 112: Determine the developer importance ranking based on the developer importance index and identify the core developers.

[0073] The aforementioned method for identifying core developers based on developer collaboration networks addresses the difficulty of identifying core developers in open source projects with a large number of developers. By constructing an undirected, empowered collaboration network of developers based on their collaborative relationships, the method then proposes a developer importance metric for identifying core developers based on the undirected, empowered collaboration network. Developers are then ranked and identified based on this developer importance metric. Compared to previous evaluation methods, this method comprehensively considers the individual influence and collaborative influence of contributing developers and utilizes a complex network system to comprehensively explain developer behavior. This method eliminates the tedious steps of collating and analyzing large amounts of contribution data, conserves significant resources, improves the accuracy and efficiency of determining developer importance, and enhances the efficiency of identifying core developers.

[0074] In one embodiment, step 100 includes: using a crawler program to crawl data of each event under each data set of a predetermined open source project; processing the data of each event into a JSON format record; storing the JSON format record of the events contained in the event set as the minimum unit of storing data in a local database; the attributes of the JSON format record of the event include: an identification attribute corresponding to the corresponding event set identifier, the initiator of the event, and the time when the event occurred.

[0075] In one embodiment, step 102 includes: grouping each record in the local database according to a set time slice to obtain a time slice group; regrouping the event data within the same time slice group according to an event set identifier, and grouping the event data with the same event set identifier as a group to obtain an event set group; matching the initiators of the events within the same event set group to obtain developer data pairs; the data format of the developer data pairs is:

[0076] {[(x0,y0),(x1,y1)...],[(z0,m0),(z1,m1)...],...}(1)

[0077] Among them, x0, x1, ..., y0, y1, ..., z0, z1, ..., m0, m1, ... are all initiators of events, () is the developer data pair in the same event set in the same time slice, and [] is the grouping of different event sets in the same time slice.

[0078] In one embodiment, step 106 includes: checking whether the developer data pairs corresponding to the edges of the undirected collaborative network appear repeatedly in the corresponding time slice grouping and event set grouping, and adding 1 to the edge weight each time it appears repeatedly until all edges of the undirected collaborative network are traversed, thereby obtaining the edge weights of all edges in the undirected collaborative network; and updating the edge weights of the undirected collaborative network according to the edge weights.

[0079] In one embodiment, step 108 includes: calculating the developer's personal influence factor and the collaboration influence factor based on the undirected authorized collaboration network; the expression of the developer's personal influence factor is:

[0080]

[0081] Where T(i) is the developer’s personal influence factor corresponding to node i, k(i) is the degree of node i, DG(i) is the maximum connected subgraph after deleting node i in the undirected weighted collaboration network, and G is the initial graph of the undirected weighted collaboration network.

[0082] The expression of collaborative influence factor is:

[0083] I(i)=Σ i,j∈S W(i,j)·k(j) (3)

[0084] Among them, I(i) is the collaborative influence factor of the developer corresponding to node i, W(i,j) is the weight ratio of node j to node i, k(j) is the degree of node j, and S is the connected graph where nodes i and j are located.

[0085] The degree k(i) of node j is how many neighboring nodes it is connected to. Figure 2 The degree of node A is 4 and the degree of node B is 1.

[0086] In one embodiment, when node j is a neighbor of node i, the weight between node j and node i is divided by the sum of the weights between all neighbors of node i and node i to obtain the weight ratio of node j to node i; when node j is a secondary neighbor of node i, the weight ratio of node j to node i is calculated based on the weight of the shortest path from node j to node i and the longest path.

[0087] For example, refer to Figure 2 The figure shows a partial diagram of an undirected, authorized collaborative network. Figure 2 Here, A, B, C, D, E, F, G, H, and I are nodes in an undirected weighted network. The number on the edge between two nodes is the edge weight. Calculate the weight ratio between nodes A and B and the weight ratio between nodes A and G.

[0088]

[0089]

[0090] The weight ratio W(A,B) between node A and node B is 1 / 6, and the weight ratio W(A,G) between node A and node G is 1 / 10.

[0091] In one embodiment, the expression of the developer importance index in step 110 is:

[0092] DIM=T(i)+I(i) (4)

[0093] Among them, DIM is the developer importance index, T(i) is the individual influence factor of the developer corresponding to node i, and I(i) is the collaborative influence factor of the developer corresponding to node i.

[0094] In one embodiment, Figure 3 The flowchart shown provides a method for identifying core developers based on a developer collaboration network, which specifically performs the following steps:

[0095] Step 301: Use a crawler program to crawl digital data of open source projects, and use existing data processing tools (or select an API that conforms to the JSON format, such as GitHub GraphQL) to process the data into JSON format.

[0096] Step 302: Use the events contained in the event set as the smallest unit for storing data. Add the corresponding event set identification attribute to each event to mark which event set the event belongs to. In addition, the event must also contain at least information such as the initiator of the event and the time when the event occurred, and store the data in the database.

[0097] Step 303: Group the data in the local database according to the set time slices. The event data in the same group are events that occurred in the same time slice.

[0098] Step 304: The event data within the same group are regrouped according to the event set identifier. Events with the same event set number are grouped together. The initiators of the events within the same group are matched in pairs to form developer data pairs. The data format is {[(x0,y0),(x1,y1)...],[(z0,m0),(z1,m1)...],...}, where () represents the developer data pair within the same event set in the same time slice, and [] represents different event set groups in the same time slice.

[0099] Step 305: The event initiator (developer) is used as a node of the collaborative network. The developer data pairs participating in the same event set (with the same contribution) are used as edges of the collaborative network, and a basic undirected and unweighted network is preliminarily constructed.

[0100] Step 306: Traverse the edges of the undirected and unauthorized developer collaboration network to check whether the developer data pair corresponding to the edge appears repeatedly in the corresponding time slice and event set group. Each time it appears repeatedly, the weight of the edge is increased by 1.

[0101] Step 307: After the edge weights are updated, an undirected authorized developer collaboration network is constructed.

[0102] Step 308: Calculate the personal influence factor and collaborative influence factor of the developers in the developer network based on the developer network.

[0103] Step 309: Calculate the developer importance index of the developers in the network based on the developer's personal influence factor and collaborative influence factor, obtain the developer importance ranking based on the developer importance index, and identify the core developers.

[0104] Step 310: The process of identifying the core developer ends.

[0105] It should be understood that although Figure 1 The steps in the flowchart are shown in sequence as indicated by the arrows, but these steps are not necessarily executed in the order indicated by the arrows. Unless otherwise specified in this document, there is no strict order restriction for the execution of these steps, and these steps can be executed in other orders. In addition, Figure 1 At least part of the steps may include multiple sub-steps or multiple stages. These sub-steps or stages are not necessarily executed at the same time, but can be executed at different times. The execution order of these sub-steps or stages is not necessarily sequential, but can be executed in turn or alternately with other steps or at least part of the sub-steps or stages of other steps.

[0106] In one embodiment, Figure 4 As shown, a core developer identification device based on a developer collaboration network is provided, comprising: a local database construction module, an undirected collaboration network construction module, an undirected authorized collaboration network determination module, a developer importance index determination module, and a core developer identification module, wherein:

[0107] The local database construction module is used to obtain the data of each event under each event set of the predetermined open source project, process the event data into records in a specified format; and build a local database based on all records in the specified format.

[0108] The undirected collaborative network construction module is used to group the records in the local database according to the set time slices to obtain time slice groups, and then perform secondary grouping according to event sets within different time slice groups. The initiators of the events in the different event set groups are matched with each other to obtain developer data pairs; the undirected collaborative network is constructed with the developers included in the developer data pairs as nodes and the developer data pairs as edges.

[0109] The undirected authorized collaboration network determination module is used to traverse the edges of the undirected collaboration network, determine the corresponding edge weights based on the number of times the developer data corresponding to the edge appears repeatedly in different event set groups, and update the edge weights of the undirected collaboration network based on the edge weights.

[0110] The developer importance index determination module is used to calculate the developer's personal influence factor and collaboration influence factor based on the obtained undirected authorized collaboration network; and determine the developer importance index of the developer in the undirected authorized collaboration network based on the developer's personal influence factor and collaboration influence factor.

[0111] The core developer identification module is used to determine the developer importance ranking based on the developer importance index and identify the core developers.

[0112] In one embodiment, the local database construction module is further used to use a crawler program to crawl the data of each event under each data set of a predetermined open source project; process the data of each event into a JSON format record; store the JSON format record of the events contained in the event set as the smallest unit of storing data in the local database; the attributes of the JSON format record of the event include: an identification attribute corresponding to the corresponding event set identifier, the initiator of the event, and the time when the event occurred.

[0113] In one embodiment, the undirected collaborative network construction module is further used to group each record in the local database according to a set time slice to obtain a time slice group; to perform secondary grouping of event data within the same time slice group according to an event set identifier, and to group event data with the same event set identifier as a group to obtain an event set group; to match the initiators of events within the same event set group in pairs to obtain developer data pairs; the data format of the developer data pairs is shown in formula (1).

[0114] In one embodiment, the undirected authorized collaborative network determination module is further used to check whether the developer data pairs corresponding to the edges of the undirected collaborative network appear repeatedly in the corresponding time slice grouping and event set grouping. Each time it appears repeatedly, the edge weight is increased by 1 until all edges of the undirected collaborative network are traversed, thereby obtaining the edge weights of all edges in the undirected collaborative network; and the edge weights of the undirected collaborative network are updated according to the edge weights.

[0115] In one embodiment, the developer importance index determination module is used to calculate the developer's personal influence factor and the collaboration influence factor based on the undirected authorized collaboration network; the expression of the developer's personal influence factor is shown in formula (2).

[0116] The expression of collaborative influence factor is shown in formula (3).

[0117] In one embodiment, the developer importance index determination module is also used to, when node j is a neighbor of node i, divide the weight between node j and node i by the sum of the weights between all neighbors of node i and node i to obtain the weight ratio of node j to node i; when node j is a secondary neighbor of node i, calculate the weight ratio of node j to node i based on the weight of the shortest path and the longest path with the most connections from node j to node i.

[0118] In one embodiment, the expression of the developer importance index in the developer importance index determination module is shown in formula (4).

[0119] For the specific definition of the core developer identification device based on the developer collaboration network, please refer to the definition of the core developer identification method based on the developer collaboration network above, which will not be repeated here. The various modules in the above-mentioned core developer identification device based on the developer collaboration network can be implemented in whole or in part by software, hardware and their combination. The above-mentioned modules can be embedded in or independent of the processor in the computer device in the form of hardware, or can be stored in the memory of the computer device in the form of software, so that the processor can call and execute the operations corresponding to the above modules.

[0120] In one embodiment, a computer device is provided. The computer device may be a terminal, and its internal structure diagram may be as follows: Figure 5 As shown. The computer device includes a processor, a memory, a network interface, a display screen and an input device connected via a system bus. The processor of the computer device is used to provide computing and control capabilities. The memory of the computer device includes a non-volatile storage medium and an internal memory. The non-volatile storage medium stores an operating system and a computer program. The internal memory provides an environment for the operation of the operating system and the computer program in the non-volatile storage medium. The network interface of the computer device is used to communicate with an external terminal via a network connection. When the computer program is executed by the processor, a core developer identification method based on a developer collaboration network is implemented. The display screen of the computer device can be a liquid crystal display screen or an electronic ink display screen, and the input device of the computer device can be a touch layer covering the display screen, or a button, trackball or touchpad provided on the computer device housing, or an external keyboard, touchpad or mouse, etc.

[0121] Those skilled in the art will understand that Figure 5 The structure shown in the figure is only a block diagram of a part of the structure related to the solution of the present application, and does not constitute a limitation on the computer device to which the solution of the present application is applied. The specific computer device may include more or fewer components than shown in the figure, or combine certain components, or have a different component arrangement.

[0122] In one embodiment, a computer device is provided, including a memory and a processor. The memory stores a computer program, and the processor implements the steps in the above method embodiment when executing the computer program.

[0123] The technical features of the above embodiments can be combined arbitrarily. To make the description concise, not all possible combinations of the technical features in the above embodiments are described. However, as long as there is no contradiction in the combination of these technical features, they should be considered to be within the scope of this specification.

[0124] The above-described embodiments merely represent several implementation methods of the present application. While the descriptions are relatively specific and detailed, they should not be construed as limiting the scope of the present invention. It should be noted that a person skilled in the art could make various modifications and improvements without departing from the spirit of the present application, all of which fall within the scope of protection of the present application. Therefore, the scope of protection of the present patent application shall be determined by the appended claims.

Claims

1. A core developer identification method based on a developer collaboration network, characterized in that: The method comprises: Obtaining data of each event in each event set of a predetermined open source project, processing the data of the event into records in a specified format; and constructing a local database based on all records in the specified format; Grouping the records in the local database according to a set time slice to obtain time slice groups, performing secondary grouping according to event sets within different time slice groups, and matching the initiators of events within the different event set groups to obtain developer data pairs; Constructing an undirected collaboration network using the developers included in the developer data pairs as nodes and the developer data pairs as edges; Traversing the edges of the undirected collaboration network, determining corresponding edge weights according to the number of times the developer data pair corresponding to the edge appears repeatedly in different event set groups, and updating the edge weights of the undirected collaboration network according to the edge weights; Calculate the developer's personal influence factor and collaboration influence factor based on the obtained undirected authorized collaboration network; Determining a developer importance index of a developer in an undirected authorized collaboration network based on the developer's personal influence factor and the collaboration influence factor; Determining a developer importance ranking based on the developer importance index and identifying core developers; The expression of the developer's personal influence factor is: Where T(i) is the developer’s personal influence factor corresponding to node i, k(i) is the degree of node i, DG(i) is the maximum connected subgraph after deleting node i in the undirected weighted collaboration network, and G is the initial graph of the undirected weighted collaboration network. The expression of the collaborative influence factor is: I(i)=∑ i,j∈S W(i,j)·k(j) Where I(i) is the collaborative influence factor of the developer corresponding to node i, W(i, j) is the weight ratio of node j to node i, k(j) is the degree of node j, and S is the connectivity graph where nodes i and j are located; The calculation process of the weight ratio from node j to node i includes: When node j is a neighbor of node i, the weight ratio of node j to node i is obtained by dividing the weight between node j and node i by the sum of the weights between all neighbors of node i and node i. When node j is the secondary neighbor of node i, the weight ratio of node j to node i is calculated based on the weight of the shortest path and the longest path with the highest number of connections from node j to node i.

2. The method according to claim 1, characterized in that Obtaining data of each event in each event set of a predetermined open source project, and processing the data of the event into records in a specified format; Build a local database based on all records in the specified format, including: Use crawlers to crawl data for each event in each dataset of a predetermined open source project; Process the data of each event into JSON format records; The JSON format records of the events contained in the event set are stored in the local database as the smallest unit of storage data; the attributes of the JSON format records of the events include: an identification attribute corresponding to the corresponding event set identifier, the initiator of the event, and the time when the event occurred.

3. The method according to claim 1, characterized in that The records in the local database are grouped according to a set time slice to obtain time slice groups. Within different time slice groups, the records are further grouped according to event sets. The initiators of the events within the different event set groups are matched pairwise to obtain developer data pairs, including: Grouping each record in the local database according to a set time slice to obtain a time slice group; The event data in the same time slice group are grouped again according to the event set identifier, and the event data with the same event set identifier are grouped as a group to obtain the event set group; Match the initiators of the events in the same event set group in pairs to obtain developer data pairs; the data format of the developer data pairs is: {[(x0,y0),(x1,y1)...],[(z0,m0),(z1,m1)...],...} Among them, x0, x1, ..., y0, y1, ..., z0, z1, ..., m0, m1, ... are all initiators of events, () is the developer data pair in the same event set in the same time slice, and [] is the grouping of different event sets in the same time slice.

4. The method according to claim 1, wherein Traversing the edges of the undirected collaboration network, determining corresponding edge weights according to the number of times the developer data pair corresponding to the edge appears repeatedly in different event set groups, and updating the edge weights of the undirected collaboration network according to the edge weights, including: Check whether the developer data pair corresponding to the edge of the undirected collaborative network appears repeatedly in the corresponding time slice group and event set group, and increase the edge weight by 1 each time it appears repeatedly until all edges of the undirected collaborative network are traversed, thereby obtaining the edge weights of all edges in the undirected collaborative network; The edge weights of the undirected collaboration network are updated according to the edge weights.

5. The method according to claim 1, wherein According to the developer's personal influence factor and the collaboration influence factor, the developer importance index of the developer in the undirected authorized collaboration network is determined. The expression of the developer importance index in the step is: DIM=T(i)+I(i) Among them, DIM=T(i)+I(i) is the developer importance index, T(i) is the personal influence factor of the developer corresponding to node i, and I(i) is the collaborative influence factor of the developer corresponding to node i.

6. A core developer identification device based on a developer collaboration network, characterized in that: The device comprises: A local database construction module is used to obtain data of each event in each event set of a predetermined open source project, process the data of the event into records in a specified format; and construct a local database based on all records in the specified format; An undirected collaborative network construction module is configured to group records in the local database according to set time slices to obtain time slice groups, perform secondary grouping within different time slice groups according to event sets, match the initiators of events within the different event set groups to obtain developer data pairs, and construct an undirected collaborative network using the developers included in the developer data pairs as nodes and the developer data pairs as edges; an undirected authorized collaboration network determination module, configured to traverse the edges of the undirected collaboration network, determine the corresponding edge weights based on the number of times the developer data pairs corresponding to the edges appear repeatedly in different event set groups, and update the edge weights of the undirected collaboration network based on the edge weights; A developer importance index determination module is used to calculate the developer's personal influence factor and collaborative influence factor based on the obtained undirected authorized collaboration network; and determine the developer importance index of the developer in the undirected authorized collaboration network based on the developer's personal influence factor and the collaborative influence factor; A core developer identification module, configured to determine a developer importance ranking based on the developer importance index and identify core developers; Among them, the expression of the developer's personal influence factor in the developer importance index determination module is: Where T(i) is the developer’s personal influence factor corresponding to node i, k(i) is the degree of node i, DG(i) is the maximum connected subgraph after deleting node i in the undirected weighted collaboration network, and G is the initial graph of the undirected weighted collaboration network. The expression of the collaborative influence factor is: I(i)=∑ i,j∈S W(i,j)·k(j) Where I(i) is the collaborative influence factor of the developer corresponding to node i, W(i, j) is the weight ratio of node j to node i, k(j) is the degree of node j, and S is the connectivity graph where nodes i and j are located; The calculation process of the weight ratio from node j to node i includes: When node j is a neighbor of node i, the weight ratio of node j to node i is obtained by dividing the weight between node j and node i by the sum of the weights between all neighbors of node i and node i. When node j is the secondary neighbor of node i, the weight ratio of node j to node i is calculated based on the weight of the shortest path and the longest path with the highest number of connections from node j to node i.

7. The device according to claim 6, characterized in that The local database construction module is further used to crawl the data of each event under each data set of the predetermined open source project using a crawler program; process the data of each event into a JSON format record; and store the JSON format record of the event contained in the event set as the minimum unit of data storage in the local database; The attributes of the event record in JSON format include: the identification attribute corresponding to the corresponding event set identifier, the initiator of the event, and the time when the event occurred.

8. A computer device comprising a memory and a processor, wherein the memory stores a computer program, wherein: When the processor executes the computer program, the method according to any one of claims 1 to 5 is implemented.

Images