Method, device, equipment and product for allocating code task

Abstract

The embodiment of the invention relates to a method, a device, equipment and a product for allocating code tasks. The method comprises the steps that based on submission historical information of a code task, a data basis for the submission historical information is determined, and the submission historical information comprises task information, personnel information and personnel skill information; the method includes determining, by a target model based on the determined data basis, a knowledge graph associated with personnel, skills, and code tasks, the target model configured with a time decay model and an attention mechanism. The method includes determining, by a target model, a set of persons matching each code task based on each code task and a knowledge graph. The method further includes, in response to a code task error, assigning, by the target model, the code task to a person matching the code task based on a comprehensive score for each person in the set of persons, the comprehensive score being determined based on the knowledge graph and a time decay coefficient for each person.

Description

Technical Field

[0001] The present application relates to the field of computer technology, and more particularly to a method, device, electronic device, and computer program product for allocating code tasks. Background Art

[0002] Large-scale software development usually refers to software development projects that are large in scale, highly complex, and involve multiple functional modules and subsystems. These projects may require a development team of dozens or even hundreds of people, and take months or years to complete. With the development of Internet technology, the field of software development has also ushered in progress and innovation. Today, the model of software development is no longer limited to the traditional centralized collaboration, that is, everyone must develop together in the same location. On the contrary, it has crossed geographical boundaries and realized the widespread practice of remote development. Summary of the invention

[0003] Embodiments of the present disclosure provide a method, an apparatus, an electronic device, and a computer program product for allocating code tasks.

[0004] According to a first aspect of the present disclosure, a method for assigning code tasks is provided. The method includes determining a data basis for the submission history information based on the submission history information of the code task, the submission history information includes task information, personnel information and personnel skill information, and the data basis includes at least one of the ownership portrait of each code task and the modification behavior pattern for each code task. The method includes determining a knowledge graph associated with personnel, skills and code tasks by a target model based on the determined data basis, the target model is configured with a time decay model and an attention mechanism, and the knowledge graph includes the skills, workload, collaborative relationship and current status of the personnel. The method includes determining a set of personnel matching each code task by the target model based on each code task and the knowledge graph. In addition, the method also includes, in response to an error in the code task, assigning the code task to a person matching the code task by the target model based on the comprehensive score of each person in the personnel set, and the comprehensive score is determined based on the knowledge graph and the time decay coefficient of each person.

[0005] According to a second aspect of the present disclosure, a device for allocating code tasks is provided. The device includes a data basis determination module, which is configured to determine the data basis for the submission history information based on the submission history information of the code task, the submission history information includes task information, personnel information and personnel skill information, and the data basis includes at least one of the ownership portrait of each code task and the modification behavior mode for each code task. The device includes a knowledge graph determination module, which is configured to determine the knowledge graph associated with personnel, skills and code tasks based on the determined data basis by the target model, the target model is configured with a time decay model and an attention mechanism, and the knowledge graph includes the skills, workload, collaboration relationship and current status of the personnel. The device includes a personnel set determination module, which is configured to determine the personnel set matching each code task based on each code task and the knowledge graph by the target model. In addition, the device also includes a personnel allocation module, which is configured to allocate the code task to the personnel matching the code task by the target model based on the comprehensive score of each personnel in the personnel set in response to an error in the code task, and the comprehensive score is determined based on the knowledge graph and the time decay coefficient of each personnel.

[0006] According to a third aspect of the present disclosure, an electronic device is provided, comprising a processor and a memory coupled to the processor, wherein the memory has instructions stored therein, and when the instructions are executed by the processor, the electronic device executes the method according to the first aspect.

[0007] In a fourth aspect of the present disclosure, a computer program product is provided. The computer program product is tangibly stored on a non-transitory computer readable medium and comprises computer executable instructions, which when executed cause a computer to perform the steps of the method of the first aspect of the present disclosure.

[0008] The purpose of this Summary is to introduce a selection of concepts in a simplified form that are further described in the Detailed Description below. This Summary is not intended to identify key features or essential features of the claimed subject matter, nor is it intended to limit the scope of the claimed subject matter. BRIEF DESCRIPTION OF THE DRAWINGS

[0009] The above and other features, advantages and aspects of the embodiments of the present disclosure will become more apparent with reference to the following detailed description in conjunction with the accompanying drawings. In the accompanying drawings, the same or similar reference numerals represent the same or similar elements, wherein:

[0010] Figure 1 A schematic diagram showing an example environment in which devices and / or methods according to embodiments of the present disclosure may be implemented;

[0011] Figure 2A flowchart of a method for allocating code tasks according to an embodiment of the present disclosure is shown;

[0012] Figure 3 A schematic diagram showing example steps for assigning code tasks according to an embodiment of the present disclosure;

[0013] Figure 4A A schematic diagram showing an example data infrastructure for distributing code tasks according to an embodiment of the present disclosure is shown;

[0014] Figure 4B A schematic diagram showing the collaboration intensity for allocating code tasks according to an embodiment of the present disclosure is shown;

[0015] Figure 5A A schematic diagram of a developer skill knowledge graph based on a large model according to an embodiment of the present disclosure is shown;

[0016] Figure 5B A schematic diagram showing an example of a developer skill knowledge graph according to an embodiment of the present disclosure;

[0017] Figure 6 A schematic diagram of dynamic state perception based on a large model according to an embodiment of the present disclosure is shown;

[0018] Figure 7 A schematic diagram of a temporal attention mechanism of a target model according to an embodiment of the present disclosure is shown;

[0019] Figure 8 A schematic diagram showing intelligent allocation and dynamic adjustment of code tasks based on a model according to an embodiment of the present disclosure is shown;

[0020] Fig. 9 A block diagram showing an apparatus for allocating code tasks according to some embodiments of the present disclosure; and

[0021] Fig.10 A block diagram of an electronic device according to an embodiment of the present disclosure is shown.

[0022] Throughout the drawings, the same or similar reference numbers denote the same or similar elements. DETAILED DESCRIPTION

[0023] It is understandable that before using the technical solutions disclosed in the embodiments of the present disclosure, the type, scope of use, usage scenarios, etc. of the personal information (such as voice) involved in the present disclosure should be informed to the user and the user's authorization should be obtained in an appropriate manner in accordance with relevant laws and regulations.

[0024] Embodiments of the present disclosure will be described in more detail below with reference to the accompanying drawings. Although certain embodiments of the present disclosure are shown in the accompanying drawings, it should be understood that the present disclosure can be implemented in various forms and should not be construed as being limited to the embodiments described herein, which are instead provided for a more thorough and complete understanding of the present disclosure. It should be understood that the drawings and embodiments of the present disclosure are only for exemplary purposes and are not intended to limit the scope of protection of the present disclosure.

[0025] In the description of the embodiments of the present disclosure, the term "including" and similar terms should be understood as open inclusion, that is, "including but not limited to". The term "based on" should be understood as "based at least in part on". The term "one embodiment" or "the embodiment" should be understood as "at least one embodiment". The terms "first", "second", etc. may refer to different or the same objects, unless explicitly stated. Other explicit and implicit definitions may also be included below.

[0026] As mentioned above, large-scale software development projects are large in scale, and naturally many difficulties will be encountered during the development process. One of them is the code error alarm and the processing work after the code error alarm, including which developers are assigned to handle it and how to assign it. In the related technology, a method of allocating alarm code tasks based on prescribed rules is adopted. This method cannot adapt to the dynamic changes of the team and also ignores the professional expertise and real-time status of the developers. There is another technology that allocates alarm code tasks based on the last modifier of the alarm code task. This solution does not take into account the collaboration history of the code task developers and the current status of the developers, which easily causes uneven distribution of alarm code tasks. In practice, a model that relies on the team leader to manually allocate tasks based on personal experience is also adopted. This model is inefficient and difficult to apply on a large scale, especially in the development environment of a large team.

[0027] To this end, an embodiment of the present disclosure proposes a scheme for automatically assigning code tasks to users. First, based on the submission history information of the code task, the data basis for the submission history information is determined, wherein the submission history information includes task information, personnel information and personnel skill information, and the determined data basis includes the ownership portrait of each code task, and at least one of the modification behavior patterns for each code task. Afterwards, a knowledge graph associated with personnel, skills and code tasks is constructed based on the above-determined data basis using a target model. The target model is configured with a time decay model and an attention mechanism, and the constructed knowledge graph includes information on personnel skills, workload, collaborative relationships and current status. Then, the target model determines the set of personnel matching each code task based on the specific circumstances of each code task and the constructed knowledge graph. Finally, when a code task goes wrong, the target model can assign the code task to the personnel matching the code task based on the comprehensive score of each person in the personnel set. Among them, the comprehensive score is determined based on the knowledge graph and the time decay coefficient of each person.

[0028] Therefore, according to the scheme of the embodiment of the present disclosure, with the help of the model capabilities of the target model, it is possible to achieve in-depth technical understanding and real-time and accurate drawing of capability portraits, so that when a code task fails, the erroneous code task can be dynamically and efficiently allocated to relevant personnel according to the current status of the relevant personnel to achieve maintenance of the code task, ensuring the reliability and timeliness of the processing of the erroneous code task, thereby improving the user experience.

[0029] The embodiments of the present disclosure will be described in detail below in conjunction with the accompanying drawings. Figure 1 A schematic diagram of an example environment 100 is shown in which devices and / or methods according to embodiments of the present disclosure may be implemented.

[0030] In order to dynamically handle the alarm or error of the code task, the personnel responsible for error alarm processing can be assigned to the erroneous code task in a targeted manner according to the submission history information of the code task. In some embodiments, the data basis for the submission history information can be determined according to the submission history information of the code task, and then the knowledge graph 130 associated with the personnel, skills and code task can be determined based on the data basis. Figure 1 As shown, in some embodiments, a knowledge graph 130 can be constructed based on personnel information 110 and task information 120. The personnel information 110 includes personnel skill information. In this article, personnel are also referred to as developers or developers.

[0031] In some embodiments, the submission history information includes task information, personnel information, and personnel skill information. Task information refers to information related to code tasks, such as code changes, submission frequency, and other information. Personnel information indicates information such as the degree of participation of developers in different types of code tasks. Personnel skill information refers to information such as the areas of expertise of developers.

[0032] In some embodiments, the constructed data foundation includes at least one of the ownership portrait of each code task and the modification behavior pattern for each code task. In some embodiments, an accurate ownership portrait can be established for each code task by scanning all historical commit records of a version control system (such as Git). By establishing the ownership portrait, the main responsible person and the secondary responsible person can be indicated for each code task.

[0033] In some embodiments, after the ownership profile of the code task is established, the modification behavior pattern of the developer can be further analyzed on this basis. With the analysis of the modification behavior pattern, the skill feature profile of the developer can be established, thereby providing a decision basis for the intelligent allocation of subsequent code tasks.

[0034] In some embodiments, the constructed data foundation may also include the integration of the aforementioned ownership portrait and modification behavior model, and the resulting complete collaboration network, i.e., collaboration relationship diagram, so that the core developers and professional experts of the team can be identified from the collaboration relationship diagram. Through the construction of this layer-by-layer data foundation, a dynamically updated knowledge base can be formed, thereby providing reliable data support for the allocation decision of subsequent alarm code tasks, thereby ensuring that the alarm code task can be assigned to the most appropriate processing personnel, thereby improving the development efficiency of the entire development team and enhancing the user experience.

[0035] After the data foundation supporting the subsequent task decision allocation is constructed, the model capability of the target model 140 can be introduced to build a model-aware developer skill knowledge graph on this basis. This will facilitate the allocation of more fine-grained alarm or error code tasks that are more suitable for the target developers in the subsequent task allocation decision-making process.

[0036] refer to Figure 1In some embodiments, the target model 140 can be used to construct an indication map 130 associated with personnel, skills, and code tasks based on previously determined data, so as to achieve a deeper technical understanding and a more accurate capability portrait. The target model 140 can be a large-scale pre-trained model, which is an artificial intelligence model based on deep learning technology. In some embodiments, the target model 140 can be a model configured with a temporal attention mechanism, that is, it can be configured with a time decay model and an attention mechanism. With the help of the temporal attention mechanism, it can ensure that the decision on the allocation of subsequent alarm code tasks adapts to the dynamic changes of the collaborative relationship.

[0037] In some embodiments, the constructed knowledge graph 130 includes the skills, workload, collaboration relationship and current status of the personnel. In some embodiments, the constructed knowledge graph 130 can also be continuously analyzed with the aid of the target model 140 to achieve dynamic update of the constructed knowledge graph 130.

[0038] like Figure 1 As shown, in some embodiments, based on the knowledge graph 130 and the model-based allocation system 140, deep mining of submission history information and dynamic perception of the real-time status of personnel can be achieved to obtain an allocation result 150, that is, to allocate code tasks to relevant personnel, especially in the case of code task error alarms, the relevant alarmed code tasks can be allocated to relevant personnel for subsequent processing.

[0039] In some embodiments, the target model can determine a matching set of personnel for each code task based on the code task by using the knowledge graph. For example, if code task 1 is developed by personnel A and personnel B, then personnel A and personnel B can be personnel in the set of personnel matching code task 1.

[0040] In some embodiments, when a code task goes wrong, the target model can determine the person who is most suitable to complete the wrong code task based on the comprehensive score of each person in the matched personnel set. In some embodiments, the comprehensive score can be determined based on the knowledge graph and the time decay coefficient of each person. For example, when code task 1 goes wrong, person A is currently in an unresponsive state, and the decay coefficient of person A is still small relative to person B. Therefore, person B has a higher comprehensive score. In the absence of other factors, the wrong code task 1 can be assigned to person B.

[0041] Therefore, according to the scheme of the embodiment of the present disclosure, with the help of the capabilities of the target model, it is possible to achieve in-depth technical understanding and real-time and accurate drawing of capability portraits, so that when a code alarm occurs, the alarm code tasks can be dynamically and efficiently allocated to relevant personnel based on their current status, ensuring the reliability and timeliness of the processing of the alarm code tasks, thereby improving the user experience.

[0042] It should be understood that the architecture and functions in the example environment 100 are described for exemplary purposes only and do not imply any limitation on the scope of the present disclosure. Embodiments of the present disclosure may also be applied to other environments with different structures and / or functions.

[0043] The following will combine Figures 2 to 10 The process according to the embodiment of the present disclosure is described in detail. For ease of understanding, the specific data mentioned in the following description are exemplary and are not intended to limit the scope of protection of the present disclosure. It is understood that the embodiments described below may also include additional actions not shown and / or the actions shown may be omitted, and the scope of the present disclosure is not limited in this respect.

[0044] Figure 2 The flowchart of the method 200 for allocating code tasks according to an embodiment of the present disclosure is shown. Next, the method 200 is schematically described by taking the apparatus for allocating code tasks as the execution subject as an example. The method 200 includes a block 202, a block 204, a block 206 and a block 208.

[0045] At box 202, the data basis for the submission history information can be determined based on the submission history information of the code task, the submission history information includes task information, personnel information and personnel skill information, and the data basis includes at least one of the ownership portrait of each code task and the modification behavior pattern for each code task. In order to dynamically handle the alarm situation of the code task, the personnel responsible for alarm handling can be targeted for the erroneous code task based on the submission history information of the code task. In some embodiments, the data basis for the submission history information can be determined based on the submission history information of the code task, and then the knowledge graph 130 associated with the personnel, skills and code tasks can be determined based on the data basis. Figure 1As shown, in some embodiments, a knowledge graph 130 can be constructed based on personnel information 110 and task information 120. Among them, the personnel information 110 includes the skill information of the personnel. In some embodiments, the submission history information includes task information, personnel information and the skill information of the personnel. Task information refers to information related to code tasks, such as code changes, submission frequency and other information. Personnel information indicates the degree of participation of developers in different types of code tasks and other information. Personnel skill information refers to information such as the areas of expertise of developers. In some embodiments, the constructed data foundation includes at least one of the ownership portrait of each code task and the modification behavior pattern for each code task. By establishing the ownership portrait, the main responsible person and the secondary responsible person can be indicated for each code task. In some embodiments, after the ownership portrait of the code task is established, the modification behavior pattern of the developer can be further analyzed on this basis. With the analysis of the modification behavior pattern, the skill feature portrait of the developer can be established, so as to provide a decision basis for the intelligent allocation of subsequent code tasks.

[0046] At box 204, the target model can determine the knowledge graph associated with personnel, skills, and code tasks based on the determined data foundation. The target model is configured with a time decay model and an attention mechanism. The knowledge graph includes personnel skills, workload, collaborative relationships, and current status. When the data foundation supporting the subsequent task decision allocation is constructed, the model capabilities of the target model 140 can be introduced to build a model-aware developer skill knowledge graph on this basis. This can facilitate the allocation of more fine-grained and more targeted alarm code tasks in the decision-making process of subsequent task allocation. Reference Figure 1 In some embodiments, the target model 140 can be used to construct an indication map 130 associated with personnel, skills, and code tasks based on previously determined data, so as to achieve a deeper technical understanding and a more accurate capability portrait. The target model 140 can be a large-scale pre-trained model, which is an artificial intelligence model based on deep learning technology. In some embodiments, the target model 140 can be a model configured with a temporal attention mechanism, that is, it can be configured with a time decay model and an attention mechanism. With the help of the temporal attention mechanism, it can ensure that the decision on the allocation of subsequent alarm code tasks adapts to the dynamic changes of the collaborative relationship. In some embodiments, the constructed knowledge map 130 includes the skills, workload, collaborative relationship, and current status of the personnel. In some embodiments, the constructed knowledge map 130 can also be continuously analyzed with the help of the target model 140 to achieve dynamic updating of the constructed knowledge map 130.

[0047] At block 206, the target model may determine a set of personnel matching each code task based on each code task and the knowledge graph. Figure 1 As shown, in some embodiments, deep mining of submission history information and dynamic perception of the real-time status of personnel can be achieved based on the knowledge graph 130 and the model-based allocation system 140 to obtain an allocation result 150, that is, to allocate code tasks to relevant personnel. For example, if code task 1 is developed collaboratively by personnel A and personnel B, then personnel A and personnel B can be personnel in the personnel set that matches code task 1.

[0048] At box 208, in response to a code task error, the target model can assign the code task to a person who matches the code task based on the comprehensive score of each person in the personnel set, and the comprehensive score is determined based on the knowledge graph and the time decay coefficient of each person. In some embodiments, when a code task error occurs, the target model can determine the person who is most suitable for completing the error code task based on the comprehensive score of each person in the matching personnel set. For example, when code task 1 fails, person A is currently in an unresponsive state, and the decay coefficient of person A is still small relative to person B. Therefore, person B has a higher comprehensive score, so the error code task 1 can be assigned to person B.

[0049] Therefore, according to the scheme of the embodiment of the present disclosure, with the help of the capabilities of the target model, it is possible to achieve in-depth technical understanding and the drawing of real-time and accurate capability portraits, so that when a code error alarm occurs, the code tasks of the error alarm can be dynamically and efficiently allocated to the relevant personnel according to the current status of the relevant personnel, ensuring the reliability and timeliness of the processing of the code tasks of the error alarm, thereby improving the user experience.

[0050] Figure 3 A schematic diagram of an example step 300 for assigning code tasks according to an embodiment of the present disclosure is shown. In order to dynamically handle the alarm situation of code tasks, personnel for error alarm processing can be targeted for code tasks with error alarms based on the submission history information of the code tasks. In order to facilitate the use of data in the subsequent allocation decision-making process, the foundation of the alarm code task allocation can be laid first, that is, the basic data structure can be constructed. Figure 3 As shown, a basic data structure may be constructed at 310. In some embodiments, the construction of the basic data structure may be divided into three progressive levels to realize the construction of a comprehensive developer-code association network.

[0051] The following will be combined Figure 4A to describe. Figure 4A FIG. 4 is a schematic diagram of an example data infrastructure 400A for distributing code tasks according to an embodiment of the present disclosure. Figure 4A ,Data infrastructure construction 310 includes code ownership definition 410, modification behavior analysis 420 and collaboration relationship construction 430, and these three steps are progressive. In some embodiments, the ownership relationship of code tasks or code modules can be analyzed by scanning all historical submission records of a version control system (such as Git).

[0052] In some embodiments, code ownership definition 410 further includes analyzing submission records, introducing a time decay model, and identifying responsible persons. In some embodiments, at 411, submission records are analyzed. That is, the contribution of each developer or developer to a code task or code module can be calculated by analyzing the frequency of submission records of a code task or code module, the amount of change in the lines of code of each code task or code module, and other quantitative indicators. Through such contribution calculation, the contribution of each developer or person in each code task or code module can be quantified, so that the contribution can be referred to in the subsequent decision-making process to allocate tasks.

[0053] In some embodiments, at 412, a time decay model is introduced to ensure that recently modified code tasks can obtain higher weights. In some embodiments, at 413, the responsible person is identified. That is, the main responsible person and the secondary responsible person are identified for each code task or code module, which can lay the foundation for the subsequent determination of the matching personnel set. Through the operations at 411, 412 and 413, an accurate ownership portrait can be established for each code task or code module.

[0054] In some embodiments, the contribution is calculated as follows:

[0055] Where N is the number of all submission records of the developer in the code task or code module; To modify the type weight; The number of lines modified for the i-th submitted code; is the time decay weight; is the collaboration weight.

[0056] In some embodiments, the time decay weight is calculated as follows:

[0057] in, is the time difference between the current time and the time of the ith submission (in days), is the decay time coefficient, which is used to adjust the speed of time decay.

[0058] In some embodiments, the calculation formula of the collaboration weight is as follows:

[0059] in, is the collaboration weight coefficient, which is used to adjust the influence of collaboration frequency on collaboration weight.

[0060] After the code ownership is defined in the data foundation, the next level of the data foundation is modification behavior analysis 420. In some embodiments, modification behavior analysis 420 includes semantic analysis of submission information and building a skill profile.

[0061] refer to Figure 4A In some embodiments, at 421, semantic analysis is performed on the submission information, that is, semantic analysis is performed on the submission history information of the code task or code module to identify different types of code changes, such as functional development, defect repair, and code refactoring. In some embodiments, the type of code change can be preliminarily determined by using the difference (diff) information provided by the version control system and analyzing the operations of adding, deleting, and modifying the code. For example, when a line marked with "+" is detected, it can be determined that the change type corresponding to the line of code may be a newly added function, class, or module, corresponding to functional development or new feature addition. For another example, when a line marked with "-" is detected, it can be determined that the change type of the line of code may be the removal of obsolete code and abandoned functions, corresponding to code cleanup or technical debt repayment. For another example, when a line with both "+" and "-" is detected, it can be determined that the change type corresponding to the code may be performance optimization, logic adjustment, corresponding to defect repair or code refactoring.

[0062] In some embodiments, the scope of changes to code tasks or code modules can also be analyzed. For example, at the file level, the type of change can be determined based on the type of file to determine whether the change type is a change to the front-end, back-end, or configuration file. For another example, at the module or task level, the directory structure of the code module or code task can be combined to determine the attribute attribution of the changed module or task. For another example, at the function or class level, static code analysis tools (such as AST parsers) can be used to extract the functions or classes of the changed design to further refine the scope of the change.

[0063] In some embodiments, for database-related codes, the type of code change can be determined by analyzing the corresponding SQL statements or API calls of the add, delete, query, and modify operations. For example, the API calls added or deleted in the code task or code module can be detected to determine whether changes to external dependencies are involved. For another example, modifications to configuration files (such as .yaml, .json) can also be detected to determine whether environment configuration or parameter adjustment is involved.

[0064] In some embodiments, the semantic information of the change can be further extracted by natural language processing (NLP) technology. For example, a word segmentation tool can be used to segment the submitted historical information to extract key verbs and nouns, and combined with the context to determine the type of change. For example, fix corresponds to defect repair, add corresponds to function development, and refactor corresponds to code refactoring. In some embodiments, pre-trained language models (such as BERT and GPT) can also be used to semantically classify the submitted historical information. In some embodiments, the submitted historical information and the code change content can also be combined to perform contextual semantic analysis. For example, according to the submitted information "Add user authentication" combined with the newly added auth module in the code change, it can be determined as function development. According to the "Refactor database connectionlogic" of the submitted information, combined with the modification of the database connection code in the code change, it can be determined as code refactoring. Alternatively, the semantics of the code change and the submitted information can be directly analyzed with the help of a large model and prompts to quickly identify the type of change.

[0065] In some embodiments, the structured information of code changes and the unstructured semantic information of submission information can also be combined to form a multimodal analysis framework, and the addition, deletion and modification features of code changes and the semantic features of submission information can be fused to construct a multidimensional feature vector. For example, a new function is added in the code change, and the "Add" keyword is included in the submission information, which can further confirm that it is a functional development. In some embodiments, machine learning or deep learning models (such as random forests, LSTM, Transformer) can be used to classify the fused feature vectors. For example, the input of the model can be code change features and submission information features, so that the output of the model can be the change type (such as functional development, defect repair, refactoring, etc.). In some embodiments, the developer's change pattern can also be analyzed in combination with historical submission records. For example, a developer has recently frequently submitted fix-type changes, which indicates that the current stage is mainly defect repair.

[0066] refer to Figure 4A At 422, a skill profile is created. In some embodiments, the participation level and expertise of each developer or person in different types of tasks can be determined, and a skill profile is created for each developer or person to provide a decision basis for subsequent intelligent allocation.

[0067] In some embodiments, the language processing capabilities of the large model can be used to parse the resume of each person or developer, and extract skill keywords, project experience, technology stack and other information from the resume to build a preliminary skill profile of each person or developer, and mark the programming languages, frameworks, tools and fields (such as front-end, back-end, AI, etc.) that they are good at.

[0068] In some embodiments, the big model can also be used to analyze technical documents, design documents, code comments, etc. written by developers to understand the technical expression ability and in-depth understanding of specific fields of each developer or developer, to identify the developer's expertise in specific technical fields (such as algorithm optimization, system architecture design, etc.) and evaluate their technical depth.

[0069] In some embodiments, task assignments, completion records, comments, and collaboration data can also be extracted from project management tools (such as Jira, Trello, and Asana), and combined with a large model to analyze task types (such as feature development, bug fixing, refactoring, etc.) and the frequency of participation of each developer or person, so as to quantify the developer's level of participation in different task types and annotate their experience values ​​on specific task types.

[0070] In some embodiments, the large model can also be used to analyze the submission records of the code repository (such as Git) and identify the type (function development, bug fixes, performance optimization, etc.) and complexity of code changes to build the developer's technical behavior pattern, so as to mark their contribution and expertise in different task types.

[0071] In some embodiments, it is also possible to combine the project management platform and code collaboration records, and use the big model to build a collaborative network of developers to analyze their roles in the team (such as core developers, technical experts, support roles, etc.) to identify the developer's technical influence and collaboration capabilities in the team, so as to further improve their skill profile.

[0072] In some embodiments, the above information can also be integrated into the developer skill knowledge graph, and the skill labels and weights can be dynamically updated to reflect the real-time status and ability changes of the developer, thereby forming a multi-dimensional correlation graph of "developer-skill-task type", which can provide accurate basis for task allocation and team management.

[0073] like Figure 4A As shown, after completing the first two steps of building the data foundation, based on the first two steps, the next level of the data foundation, namely, the collaborative relationship, is built 430. At 431, the collaborative history is recorded, that is, the collaborative history between developers is recorded, including the frequency and scope of jointly modifying the same module. The collaborative history record can be shown in the following Table 1:

[0074] refer to Figure 4A At 432, a collaboration relationship graph is constructed. That is, a weighted collaboration relationship graph is constructed, in which nodes represent developers or developers, and edges represent collaboration relationships between developers or developers. In some embodiments, at 433, the collaboration intensity between each developer can also be quantified. Figure 4B , Figure 4B FIG. 4 is a schematic diagram of a collaborative intensity 400B for allocating code tasks according to an embodiment of the present disclosure. Figure 4B As shown in the figure, a weighted collaboration relationship graph is constructed between personnel A, personnel B, personnel C, and personnel D, and the weight represents the collaboration strength between personnel A and personnel B. Among them, the collaboration weight of personnel A to personnel B is 0.85, and the collaboration weight of personnel B to personnel A is 0.65. The core developers and professional experts in the team can be identified through the nodes representing personnel, the edges representing collaboration relationships, and the weight values ​​between the edges.

[0075] In some embodiments, a rolling index can be used to build a data foundation. Rolling indexes are mainly used in scenarios where frequent index updates are required to ensure that stable services can still be provided during the update process. It achieves seamless switching and high availability by maintaining two or more index copies (such as index A and index B) and alternating between different copies when updating the index. For example, in the initial state, index A provides services and index B is in a standby state, then all query requests will be routed to index A. When the system needs to update the index, the update operation will be performed on the standby index B.

[0076] In some embodiments, the update process of index B includes rescanning submission records from the code repository, recalculating the association between developers and code modules, and updating the developer skill knowledge graph. After the update of index B is completed, necessary verification can be performed to ensure that the data of index B is correct and complete. After the verification is passed, the system will switch the service provider from index A to index B. After that, index B begins to provide services to the outside world, and index A enters the standby state. At this time, all query requests of the system will now be routed to index B. When the next index update request arrives, the update operation will be performed on the standby index A. After the update is completed, the system will switch the service provider again, switching from index B back to index A.

[0077] With this rotating index switching method, it is possible to ensure that the relationship between developers or developers and code modules is updated regularly, ensuring the stability, integrity and consistency of the constructed data foundation, thereby ensuring the accuracy of subsequent allocation decisions.

[0078] Figure 4A-4BIt describes a three-layer progressive data construction process, which can form a dynamically updated knowledge base to provide reliable data support for subsequent alarm allocation decisions, ensuring that the most appropriate person to handle each problem can be found, thereby improving the problem-solving efficiency of the entire team and enhancing the user experience.

[0079] Back to Figure 3 After the basic data structure is built at 310, a developer skill knowledge graph based on the big model can be built at 320. The core goal of knowledge graph management is to accurately map the relationship between "developer-skill-code module". By introducing the big model capability, a deeper technical understanding and a more accurate capability portrait can be achieved.

[0080] The following will be combined Figure 5A to describe. Figure 5A FIG. 5 is a schematic diagram of a developer skill knowledge graph 500A based on a large model according to an embodiment of the present disclosure. Figure 5A The developer skill knowledge graph 320 based on the big model includes code ability understanding 510, submission information interpretation 520, and skill graph update 530. That is, the developer skill knowledge graph is generated through a deep understanding of the submission history and related prompts. In some embodiments, the relevant information of the submission history can be in the form of the aforementioned basic data with three progressive levels.

[0081] like Figure 5A As shown, code capability understanding 510 includes analyzing technical features, identifying programming patterns, and evaluating code quality. In some embodiments, at 511, the analysis of technical features is performed. That is, the submission history information of the code task can be analyzed with the help of a large model to achieve a deep technical understanding of the submission history information. For example, the large model can understand the technical features and complexity of the code in the submission history information. In some embodiments, at 512, the programming pattern is identified, and the programming pattern and technical preferences of each developer or developer can also be identified with the help of the large model. In some embodiments, at 513, the code quality is evaluated, and the quality and technical depth of the code in the submission history can be evaluated with the help of a large model.

[0082] refer to Figure 5A , the submission information interpretation 520 includes extracting technical keywords, understanding technical paths, and identifying professional fields. In some embodiments, at 521, extracting technical keywords is performed, that is, using a large model to analyze technical keywords in the submission history information. At 522, understanding the technical path is performed, that is, using a large model to understand the technical path to solve the problem. At 523, identifying professional fields, that is, using a large model to identify the professional fields of developers and the quality of solutions.

[0083] Continue to refer Figure 5A , the skill graph update 530 includes updating skill labels, adjusting skill weights, and optimizing picture structures. In some embodiments, at 531, the skill labels are updated, that is, the developer's skill labels are updated in real time with the help of a large model. In some embodiments, at 532, the skill weights are adjusted, that is, the skill weights and professional ratings are adjusted. In some embodiments, at 533, the picture structure is optimized, that is, the structural relationship of the knowledge graph is optimized.

[0084] In some embodiments, the input for the large model can be code submission records, contextual prompts, and external knowledge bases (optional). Among them, the code submission record may include the submitted code content (code snippets, changes), submission information (commit message), including descriptive text, submission time, submitter information, and code module path (such as file name, directory structure). Contextual prompts may include project background information (such as the project's technology stack, target function), functional description of code modules, historical collaboration relationships (such as the frequency of collaboration between developers), and task types (such as function development, bug fixing, performance optimization, etc.). The external knowledge base (optional) may include the syntax rules of programming languages, documents of common technical frameworks and libraries, and industry standards and best practices.

[0085] In some embodiments, the output of the large model can be a knowledge graph that includes skill feature portraits, code module associations, and collaborative relationships. The skill feature portraits include the developer's skill labels (such as "Java backend development", "front-end React", "database optimization"), skill weights (such as the developer's proficiency score in a certain field), and areas of expertise (such as "performance optimization expert", "security vulnerability repair"). The code module association can include the relationship between the developer and the code module (such as the developer's contribution to a certain module), and the technical characteristics of the module (such as "high concurrency processing module", "data analysis module"). In addition, the collaborative relationship can include the intensity of collaboration between developers (such as the frequency of jointly modifying the same module or task), and the distribution of roles within the team (such as "core developer", "code reviewer"). Combined Figure 5B , Figure 5B A schematic diagram of an example 500B of a developer skill knowledge graph according to an embodiment of the present disclosure is shown. The knowledge graph is presented in the form of a graph structure, where nodes represent entities and edges represent the relationship between entities. For example, developer A is good at JAVA backend development.

[0086] With the support of large models, the system can better understand and manage the team's technical capability distribution, providing a more reliable decision-making basis for alarm allocation.

[0087] Back to Figure 3 After the basic data structure is built at 310 and the developer skill knowledge graph based on the big model is built at 320, dynamic state perception based on the big model can be realized at 330. The dynamic state perception module can realize accurate evaluation and prediction of the state of each person or developer by means of the intelligent analysis capability of the big model, and provide real-time decision support for alarm allocation.

[0088] The following will be combined Figure 6 to describe. Figure 6 FIG. 6 is a schematic diagram of a large model-based dynamic state perception 600 according to an embodiment of the present disclosure. Figure 6 The dynamic state perception 330 based on the big model includes intelligent load evaluation 610, time zone and state analysis 620 and dynamic skill matching 630. That is, the real-time evaluation of the development state of each developer or each person is mainly achieved through the above three core functions.

[0089] In some embodiments, intelligent load assessment 610 includes understanding task complexity, assessing cognitive burden, and predicting task risk, so that the current workload of the developer can be analyzed and whether the developer has enough time and energy to handle new alarm tasks. In some embodiments, at 611, understanding task complexity is performed, that is, the tasks currently assigned to the developer are analyzed with the help of a large model to assess their technical difficulty and estimated completion time. In some embodiments, the developer's current task description (such as code change content, task type) can be input into the large model, and then the large model can output the complexity score of the task (such as "high", "medium", "low"). For example, the input of the large model can be: the current task of developer A is "optimizing the concurrent performance of the order management module", and the output of the large model can be: the task complexity score is "high".

[0090] In some embodiments, at 612, cognitive burden assessment is performed, that is, the cognitive burden of different types of tasks is assessed with the help of a large model. For example, the cognitive burden of a task on a developer can be assessed with the help of a large model and in combination with the type of task (such as function development, bug fix) and the developer's skills. In some embodiments, at 613, task risk prediction is performed, that is, the potential risk and completion time of a task are predicted. For example, the priority of the developer's current task can be identified with the help of a large model, and it can be determined whether a new alarm task can be inserted.

[0091] In some embodiments, the time zone and status analysis 620 includes analyzing calendars and records, understanding status information, and predicting contact time, so that the developer's availability can be determined to ensure that the developer is in working hours or responsive when the alarm is assigned. In some embodiments, at 621, the calendar and record analysis is performed, that is, by integrating information such as calendars and meeting records, to identify whether the developer has free time to handle the alarm. In some embodiments, at 622, the status information is understood, that is, by analyzing the status information (such as "online" and "busy") of instant messaging tools (such as Slack and Teams) to determine the real-time status of the developer. In some embodiments, at 623, the contact time is predicted, that is, the best contact time window is predicted. In some embodiments, the large model can also output the developer's availability score (such as 1 for fully available and 0 for unavailable). For example, the input can be: Developer C is located in the UTC+8 time zone, the current time is 10 pm, and the status is "offline", and the output can be an availability score of 0.

[0092] In some embodiments, dynamic skill matching 630 includes understanding the nature of alarm technology, evaluating the current technical status, and predicting the best personnel, so that the big model can dynamically match the most suitable developer or personnel according to the technical characteristics of the alarm and the current skill status of the developer. In some embodiments, at 631, the understanding of the nature of alarm technology is performed. That is, the alarm content (such as logs, error messages) is semantically analyzed with the help of the big model to extract the technical characteristics of the problem. In some embodiments, the error log, stack information, and related code snippets of the code task of the error alarm can be input into the big model, and then the big model can output the technical characteristics of the code task of the error alarm (such as the modules involved, possible root causes), etc. For example, the input to the big model can be: the alarm log shows "database connection timeout", and the output of the big model can be: the technical characteristics are "database optimization problems, involving data storage modules".

[0093] In some embodiments, at 632, the current technical status is evaluated. That is, the large model is combined with the developer's skill knowledge graph to determine whether their current skills match the alarm problem. In some embodiments, at 633, the best candidate is predicted. That is, according to the developer's recent task completion, the skill weight is dynamically adjusted. For example, if a developer frequently handles database problems recently, the weight of his "database optimization" skill will be increased), and the skill with a larger weight will be ranked first. In some embodiments, through dynamic skill matching 630, the developer's skill matching score can be output. For example, 0.9 indicates a high match, and 0.3 indicates a low match.

[0094] In some embodiments, upon receiving an alarm message (such as a service anomaly or a code error), the big model can extract the technical characteristics of the alarm (such as the code module or code task involved, the error type). At the same time, the big model can conduct a developer status assessment, including load assessment, availability assessment, and skill matching, to obtain a set of matching personnel, which may include developers with lower loads, currently available developers, and developers with higher skill matching. After obtaining the set of matching personnel, the comprehensive score of each developer can be calculated. In some embodiments, the calculation formula for the comprehensive score is as follows:

[0095] Among them, α, β, and γ are weight parameters and can be adjusted as needed.

[0096] In some embodiments, the developer with the highest score can be selected as the handler of the alarm based on the comprehensive score. In some embodiments, if the developer with the highest score fails to respond in time, a dynamic adjustment mechanism can be triggered to assign the alarm to the next best candidate.

[0097] Using big models to analyze developers' work status, task load, time zone differences, and task complexity in real time can provide intelligent decision support for alarm allocation.

[0098] Figure 7 A schematic diagram of a temporal attention mechanism 700 of a target model according to an embodiment of the present disclosure is shown. Given that in a large software development team, the collaborative relationship and code responsibility of code tasks are not static, but are dynamically adjusted with the change of time and tasks. Therefore, in order to dynamically evaluate the collaborative relationship between developers and the priority of alarm allocation, a large model can be configured with a temporal attention mechanism. Figure 7 , the temporal attention mechanism 701 includes a time decay model 710 and an attention weight calculation 720.

[0099] In some embodiments, an exponential decay function 711 may be used to weight the historical collaboration relationship to achieve a high weight for recent collaboration 712. In some embodiments, the formula of the exponential decay function is shown in formula (5):

[0100] Among them, Δt is the time interval (i.e. the difference between the time when the collaboration occurred and the current time), and λ is the decay coefficient, which is used to control the speed of time decay. By giving higher weights to recent collaborations, it can be ensured that the allocation results reflect the current state of collaboration. For example, the weight of the most recent collaboration will be significantly higher than the collaboration record from a year ago, thereby improving the timeliness of the allocation results. If developers A and B have collaborated frequently in the past week, their collaboration weight will be significantly higher than the collaboration record from a year ago, and the ranking will be higher. In some embodiments, if a code task has been modified recently, the ranking of this code task will also be higher.

[0101] In some embodiments, the attention weight 720 may include extracting alarm feature vectors, calculating weights through feature fusion, and dynamically adjusting weight distribution. This method of calculating attention weights based on multi-dimensional features (such as the importance of code modules, the skill matching of developers, historical collaboration intensity, etc.) can dynamically adjust the priority of code task assignment for error alarms.

[0102] In some embodiments, at 721, alarm feature vector extraction is performed, that is, feature vectors related to alarms are extracted. For example, alarm feature vectors are extracted based on the modification frequency of code modules, the complexity, importance or level of code modules or code tasks, and the skill tags, historical contributions and current workload of developers.

[0103] In some embodiments, at 722, feature fusion is performed to calculate weights, that is, a feature fusion function (such as weighted average or neural network model) is used to calculate the comprehensive weight. For example, a weighted average or a neural network model can be used to calculate the comprehensive weight. In some embodiments, an attention mechanism can be used to weight the input features to calculate the comprehensive weight. The calculation formula is as follows:

[0104] in, is the query vector (Query), which represents the feature vector of the alarm; is the key vector (Key), which represents the feature vector of developers and code modules; is the dimension of the feature vector, used for normalization.

[0105] In some embodiments, at 723, dynamic weight distribution adjustment is performed, that is, dynamic weight distribution adjustment is performed so that the key features have a greater impact on the allocation result. For example, when a code module or code task is more important, the system can automatically increase the collaboration weight associated with the module.

[0106] In some embodiments, the time decay model and attention weight can be combined to dynamically calculate the collaboration relationship and assign priorities. The calculation formula for temporal attention fusion is as follows:

[0107] in, is the basic collaboration intensity (e.g., historical collaboration frequency); is the time decay factor, reflecting the timeliness of collaboration; is the attention weight, which can integrate the influence of multi-dimensional features.

[0108] Through this method of comprehensive consideration of historical data and real-time status, the weight of the collaborative relationship can be dynamically adjusted to ensure that the allocation strategy adapts to the real-time changes in the team status and output the optimal allocation decision.

[0109] Assume that the code of the error alarm involves the "order management module" and the alarm type is "high priority defect repair". The developer information is: Developer A's contribution to the order management module is 0.8, and there are 3 collaboration records in the last week; Developer B: The contribution to the order management module is 0.6, and there is no collaboration record in the last week. The time decay coefficient λ = 0.1. The matching degree of the alarm feature with developer A is 0.9; the matching degree of the alarm feature with developer B is 0.7.

[0110] Then, in the time decay calculation, developer A's TimeDecay_A=0.74; developer B's TimeDecay_B=0.05.

[0111] At the same time, according to the following formula (8), we can get the AttentionWeight of developer A: A =0.55; Developer B’s AttentionWeight B =0.45.

[0112]

[0113] At the same time, according to formula (7), the FinalScore of developer A can be obtained: A =0.326; FinalScore of Developer B B =0.0135. Therefore, the allocation priority of developer A is significantly higher than that of developer B. Therefore, ignoring the influence of other possible factors (such as whether the developer is free at the current time), the alarm task can be assigned to developer A.

[0114] Assume that a database connection timeout error occurs in a code task; Developer A's current task load is low, with a score of 0.2; Developer B's load is high, with a score of 0.8; Developer A is in working hours, with a score of 1; Developer B is in non-working hours, with a score of 0; Developer A's "Database Optimization" skill weight is 0.9, and Developer B's is 0.7.

[0115] Then we can get: Developer A's comprehensive score = ; Developer B: Overall score = At this time, the code task for the database connection timeout can be assigned to developer A.

[0116] If, based on this, developer A fails to respond to the code task of the alarm within the specified time, then the status of other developers can be re-evaluated, the next developer with the highest comprehensive score (such as developer C) can be selected, and the code task of the alarm upgrade can be reallocated to developer C.

[0117] By the above Figure 7 From the description, we can see that the temporal attention mechanism can dynamically adjust the collaborative relationship and assign priorities by introducing the time decay model and attention weight calculation.

[0118] Figure 8 A schematic diagram of model-based intelligent allocation and dynamic adjustment of code tasks 800 according to an embodiment of the present disclosure is shown. After completing the data foundation construction, dynamic state perception and time series attention calculation, the comprehensive scoring model can be used to achieve intelligent allocation and support the adjustment of dynamic mechanisms. Figure 8 As shown, intelligent allocation and dynamic adjustment 801 can be implemented through a comprehensive scoring model 810 and a dynamic adjustment mechanism 820 .

[0119] refer to Figure 8 , the function of the comprehensive scoring model 810 can be realized by combining the collaborative network score 811, the skill matching degree 812 and the time decay factor 813. In some embodiments, the calculation formula of the comprehensive score can be shown as the following formula (9):

[0120] Among them, BaseScore is the basic collaboration strength, TimeDecay is the time decay factor, AttentionWeight is the attention weight, and ExpertiseLevel is the professionalism score.

[0121] This multi-dimensional comprehensive scoring calculation method can ensure the accuracy and fairness of the allocation of error alarm code tasks.

[0122] Continue to refer Figure 8, the dynamic adjustment mechanism 820 can be implemented with the help of the task upgrade process 821 and the reallocation mechanism 822. In some embodiments, when the originally assigned developer fails to respond in time, the task upgrade process 821 and the reallocation mechanism 822 can be automatically triggered. For example, if developer A does not handle the error alarm code task within the specified time, the error alarm code task can be assigned to the next best candidate. In this way, the overall efficiency can be avoided from being affected by the delayed response of individual developers, and the reliability of the error alarm code task being processed can be improved.

[0123] Therefore, according to the scheme of the embodiment of the present disclosure, with the help of the model capabilities of the target model, it is possible to achieve in-depth technical understanding and real-time and accurate drawing of capability portraits, so that when a code task fails, the erroneous code task can be dynamically and efficiently allocated to relevant personnel according to the current status of the relevant personnel to achieve maintenance of the code task, ensuring the reliability and timeliness of the processing of the erroneous code task, thereby improving the user experience.

[0124] Fig. 9 900 is a block diagram of an apparatus for allocating code tasks according to some embodiments of the present disclosure. Fig. 9 As shown, the device 900 includes a data basis determination module 902, which is configured to determine the data basis for the submission history information based on the submission history information of the code task, the submission history information includes task information, personnel information and personnel skill information, and the data basis includes at least one of the ownership portrait of each code task and the modification behavior mode for each code task. The device 900 also includes a knowledge graph determination module 904, which is configured to determine the knowledge graph associated with personnel, skills and code tasks based on the determined data basis by the target model, the target model is configured with a time decay model and an attention mechanism, and the knowledge graph includes the skills, workload, collaborative relationship and current status of the personnel. The device 900 also includes a personnel set determination module 906, which is configured to determine the personnel set matching each code task based on each code task and the knowledge graph by the target model. In addition, the device 900 also includes a personnel allocation module 908, which is configured to allocate the code task to the personnel matching the code task by the target model based on the comprehensive score of each person in the personnel set in response to an error in the code task, and the comprehensive score is determined based on the knowledge graph and the time decay coefficient of each person.

[0125] Fig.10 A block diagram of an electronic device 1000 is shown in accordance with some embodiments of the present disclosure. Fig.10 1 shows a block diagram of an electronic device 1000 according to some embodiments of the present disclosure. The device 1000 may be a device or apparatus described in an embodiment of the present disclosure. Fig.10As shown, the device 1000 includes a central processing unit (CPU) and / or a graphics processing unit (GPU) 1001, which can perform various appropriate actions and processes according to computer program instructions stored in a read-only memory (ROM) 1002 or loaded from a storage unit 1008 to a random access memory (RAM) 1003. In the RAM 1003, various programs and data required for the operation of the device 1000 can also be stored. The CPU / GPU 1001, the ROM 1002, and the RAM 1003 are connected to each other via a bus 1004. An input / output (I / O) interface 1005 is also connected to the bus 1004. Although not shown in FIG. Fig.10 As shown in FIG. 1 , device 1000 may further include a coprocessor.

[0126] A number of components in the device 1000 are connected to the I / O interface 1005, including: an input unit 1006, such as a keyboard, a mouse, etc.; an output unit 1007, such as various types of displays, speakers, etc.; a storage unit 1008, such as a disk, an optical disk, etc.; and a communication unit 1009, such as a network card, a modem, a wireless communication transceiver, etc. The communication unit 1009 allows the device 1000 to exchange information / data with other devices through a computer network such as the Internet and / or various telecommunication networks.

[0127] The various methods or processes described above may be executed by the CPU / GPU 1001. For example, in some embodiments, the methods may be implemented as a computer software program, which is tangibly contained in a machine-readable medium, such as a storage unit 1008. In some embodiments, part or all of the computer program may be loaded and / or installed on the device 1000 via the ROM 1002 and / or the communication unit 1009. When the computer program is loaded into the RAM 1003 and executed by the CPU / GPU 1001, one or more steps or actions in the methods or processes described above may be performed.

[0128] In some embodiments, the methods and processes described above may be implemented as a computer program product. The computer program product may include a computer-readable storage medium carrying computer-readable program instructions for executing various aspects of the present disclosure.

[0129] Computer readable storage medium can be a tangible device that can hold and store instructions used by an instruction execution device. Computer readable storage medium can be, for example, but not limited to, an electrical storage device, a magnetic storage device, an optical storage device, an electromagnetic storage device, a semiconductor storage device, or any suitable combination thereof. More specific examples (non-exhaustive list) of computer readable storage medium include: a portable computer disk, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), a static random access memory (SRAM), a portable compact disk read-only memory (CD-ROM), a digital versatile disk (DVD), a memory stick, a floppy disk, a mechanical encoding device, for example, a punch card or a convex structure in a groove on which instructions are stored, and any suitable combination thereof. The computer readable storage medium used here is not interpreted as a transient signal itself, such as a radio wave or other freely propagating electromagnetic wave, an electromagnetic wave propagated by a waveguide or other transmission medium (for example, a light pulse by an optical fiber cable), or an electrical signal transmitted by a wire.

[0130] The computer-readable program instructions described herein can be downloaded from a computer-readable storage medium to each computing / processing device, or downloaded to an external computer or external storage device via a network, such as the Internet, a local area network, a wide area network, and / or a wireless network. The network can include copper transmission cables, optical fiber transmissions, wireless transmissions, routers, firewalls, switches, gateway computers, and / or edge servers. The network adapter card or network interface in each computing / processing device receives the computer-readable program instructions from the network and forwards the computer-readable program instructions for storage in the computer-readable storage medium in each computing / processing device.

[0131] The computer program instructions for performing the operations of the present disclosure may be assembly instructions, instruction set architecture (ISA) instructions, machine instructions, machine-dependent instructions, microcode, firmware instructions, state setting data, or source code or object code written in any combination of one or more programming languages, including object-oriented programming languages, and conventional procedural programming languages. Computer-readable program instructions may be executed entirely on a user's computer, partially on a user's computer, as a separate software package, partially on a user's computer, partially on a remote computer, or entirely on a remote computer or server. In the case of a remote computer, the remote computer may be connected to the user's computer via any type of network, including a local area network (LAN) or a wide area network (WAN), or may be connected to an external computer (e.g., using an Internet service provider to connect via the Internet). In some embodiments, an electronic circuit, such as a programmable logic circuit, a field programmable gate array (FPGA), or a programmable logic array (PLA), may be customized by utilizing the state information of the computer-readable program instructions, and the electronic circuit may execute the computer-readable program instructions, thereby implementing various aspects of the present disclosure.

[0132] These computer-readable program instructions can be provided to a processing unit of a general-purpose computer, a special-purpose computer, or other programmable data processing device, thereby producing a machine, so that when these instructions are executed by the processing unit of the computer or other programmable data processing device, a device that implements the functions / actions specified in one or more boxes in the flowchart and / or block diagram is generated. These computer-readable program instructions can also be stored in a computer-readable storage medium, and these instructions cause the computer, programmable data processing device, and / or other equipment to work in a specific manner, so that the computer-readable medium storing the instructions includes a manufactured product, which includes instructions for implementing various aspects of the functions / actions specified in one or more boxes in the flowchart and / or block diagram.

[0133] Computer-readable program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other device so that a series of operating steps are performed on the computer, other programmable data processing apparatus, or other device to produce a computer-implemented process, thereby causing the instructions executed on the computer, other programmable data processing apparatus, or other device to implement the functions / actions specified in one or more boxes in the flowchart and / or block diagram.

[0134] The flow chart and block diagram in the accompanying drawings show the possible architecture, function and operation of the equipment, method and computer program product according to multiple embodiments of the present disclosure. In this regard, each frame in the flow chart or block diagram can represent a part of a module, program segment or instruction, and a part of the module, program segment or instruction includes one or more executable instructions for realizing the specified logical function. In some alternative implementations, the function marked in the frame can also occur in a sequence different from that marked in the accompanying drawings. For example, two continuous frames can actually be executed substantially in parallel, and they can also be executed in the opposite order sometimes, depending on the functions involved. It should also be noted that each frame in the block diagram and / or flow chart, and the combination of frames in the block diagram and / or flow chart can be implemented with a dedicated hardware-based system that performs a specified function or action, or can be implemented with a combination of dedicated hardware and computer instructions.

[0135] The embodiments of the present disclosure have been described above, and the above description is exemplary, not exhaustive, and is not limited to the disclosed embodiments. Many modifications and changes will be apparent to those of ordinary skill in the art without departing from the scope and spirit of the described embodiments. The choice of terms used herein is intended to best explain the principles of the embodiments, practical applications, or technical improvements to the technology in the market, or to enable other persons of ordinary skill in the art to understand the embodiments disclosed herein.

[0136] Some example implementations of the present disclosure are listed below.

[0137] Example 1. A method for allocating code tasks, comprising: Based on submission history information of the code task, determining a data basis for the submission history information, the submission history information including task information, personnel information, and personnel skill information, the data basis including at least one of an ownership profile of each code task and a modification behavior pattern for each code task; Determining, by a target model based on the determined data foundation, a knowledge graph associated with personnel, skills, and code tasks, wherein the target model is configured with a time decay model and an attention mechanism, and the knowledge graph includes personnel's skills, workload, collaborative relationship, and current status; The target model determines a set of personnel matching each code task based on each code task and the knowledge graph; and In response to an error in a code task, the target model assigns the code task to a person matching the code task based on a comprehensive score of each person in the person set, wherein the comprehensive score is determined based on the knowledge graph and a time decay coefficient of each person.

[0138] Example 2. The method according to Example 1, wherein based on the submission history information of the code task, determining the data basis for the submission history information comprises: In response to each code task being merged into a production branch, the data basis for the commit history information is determined based on a rotating index.

[0139] Example 3. The method according to any one of Examples 1-2, wherein in response to each code task being merged into a production branch, determining the data basis for the commit history information based on a rotating index comprises: Determine an ownership profile of each code task based on the submission history information; and Determine a modification behavior pattern for each code task based on the submission history information; and Based on the ownership portrait and the modification behavior pattern, a collaboration network is determined, where the collaboration network indicates the strength of the collaboration relationship between each person.

[0140] Example 4. The method according to any one of Examples 1-3, wherein determining the ownership profile of each code task based on the submission history information comprises: Based on the submission history information, determine the contribution of each person to each code task; Based on the time decay model, sort each code task; and Based on the contribution, for each sorted code task, a first responsible person and a second responsible person for each code task are identified.

[0141] Example 5. The method according to any one of Examples 1-4, wherein based on the submission history information, determining the modification behavior pattern for each code task comprises: Based on the submission history information, determine a task change type for each code task, where the task change type includes at least one of function development, defect repair, and task refactoring; Based on the submission history information, determine the skill characteristics of each person and the degree of participation of each person in each code task; and Based on the task change type for each code task, the skill characteristics of each person, and the degree of participation of each person in each code task, a skill characteristic profile for each person is determined.

[0142] Example 6. The method according to any one of Examples 1-5, wherein determining the collaboration network based on the ownership profile and the modification behavior pattern comprises: determining each person's collaboration history with another person, the collaboration history including collaboration frequency and collaboration scope; and Based on the collaboration history, determining a collaboration relationship graph, wherein nodes of the collaboration relationship graph indicate personnel, and edges of the collaboration relationship graph indicate collaboration relationship weights; and Based on the collaboration diagram, core personnel and professionals are determined.

[0143] Example 7. According to any one of Examples 1-6, the method of determining, by the target model based on the determined data foundation, a knowledge graph associated with personnel, skills, and code tasks comprises: Determining, by the language model, at least one of a technical understanding and a development intention for each code task based on the determined data foundation; and The knowledge graph is updated by the language model based on the technical understanding of each code task and the development intention.

[0144] Example 8. According to any one of Examples 1-7, the method wherein the target model determines a set of people matching each code task based on each code task and the knowledge graph, comprising: For each person in the set of people associated with each code task, determine a current workload of each person; and For each person in the set of people associated with each code task, determine whether each person is in a responsive state; and For each person in the set of people associated with each code task, determine a current skill state of each person; and A set of personnel matching each code task is determined based on a comprehensive score of the current workload, the responsiveness status, and the current skill status of each personnel associated with each code task.

[0145] Example 9. The method according to any one of Examples 1-8, wherein in response to an error in a code task, the target model assigns the code task to a person matching the code task based on a comprehensive score of each person in the person set, comprising: The target model determines the weight of each of the following based on the priority of the code task: The weight of the current workload of each person in the personnel set matching the code task; The weight of the current responsiveness status of each person in the person set matching the code task; and The weight of the current skill status of each person in the set of people matching the code task; Determine a comprehensive score for each person in the set of personnel matching the code task based on the comprehensive weight of the weight of each item and the time decay coefficient of each person in the set of personnel matching the code task; and Based on the comprehensive score, the code task is assigned to a person who matches the code task.

[0146] Example 10. According to the method described in any one of Examples 1-9, the comprehensive weight is determined by the target model configured with a time decay model and an attention mechanism, and the time decay coefficient is determined based on an exponential decay function and a collaborative relationship weight.

[0147] Example 11. The method according to any one of Examples 1-10, further comprising: In response to the person matched with the code task not responding to the assignment within a predetermined time, re-determining a comprehensive score for each person in the set of people matched with the code task; and Based on the re-determined comprehensive score, the coding task is re-assigned to a person who matches the coding task.

[0148] Example 12. An apparatus for allocating code tasks, comprising: A data basis determination module is configured to determine a data basis for the submission history information of the code task based on the submission history information, wherein the submission history information includes task information, personnel information, and personnel skill information, and the data basis includes at least one of an ownership profile of each code task and a modification behavior pattern for each code task; A knowledge graph determination module is configured to determine a knowledge graph associated with personnel, skills, and code tasks based on the determined data foundation by a target model, wherein the target model is configured with a time decay model and an attention mechanism, and the knowledge graph includes personnel's skills, workload, collaborative relationship, and current status; A personnel set determination module is configured to determine a personnel set matching each code task based on each code task and the knowledge graph by the target model; and The comprehensive score determination module is configured to, in response to an error in a code task, assign the code task to a person matching the code task based on the comprehensive score of each person in the personnel set by the target model, wherein the comprehensive score is determined based on the knowledge graph and the time decay coefficient of each person.

[0149] Example 13. The apparatus of Example 12, wherein the data basis determination module comprises: The first determining module is configured to determine the data basis for the submission history information based on a rotating index in response to each code task being merged into a production branch.

[0150] Example 14. The apparatus of any one of Examples 12-13, wherein the first determining module comprises: A second determination module is configured to determine the ownership portrait of each code task based on the submission history information; and A third determination module is configured to determine a modification behavior pattern for each code task based on the submission history information; and The fourth determination module is configured to determine a collaboration network based on the ownership portrait and the modification behavior pattern, wherein the collaboration network indicates the strength of the collaboration relationship between each person.

[0151] Example 15. The apparatus of any one of Examples 12-14, wherein the second determining module comprises: A fifth determination module is configured to determine the contribution of each person to each code task based on the submission history information; A sorting module is configured to sort each code task based on a time decay model; and The representation module is configured to identify a first responsible person and a second responsible person for each of the sorted code tasks based on the contribution degree.

[0152] Example 16. The apparatus of any one of Examples 12-15, wherein the third determining module comprises: a sixth determination module, configured to determine a task change type for each code task based on the submission history information, wherein the task change type includes at least one of function development, defect repair, and task refactoring; a seventh determination module, configured to determine the skill characteristics of each person and the degree of participation of each person in each code task based on the submission history information; and The eighth determination module is configured to determine a skill characteristic profile for each person based on the task change type for each code task, the skill characteristics of each person, and the degree of participation of each person in each code task.

[0153] Example 17. The apparatus of any one of Examples 12-16, wherein the fourth determining module comprises: a ninth determination module configured to determine a collaboration history between each person and another person, wherein the collaboration history includes a collaboration frequency and a collaboration scope; and a tenth determining module, configured to determine a collaboration relationship graph based on the collaboration history, wherein nodes of the collaboration relationship graph indicate personnel, and edges of the collaboration relationship graph indicate collaboration relationship weights; and The eleventh determination module is configured to determine core personnel and professionals based on the collaboration relationship diagram.

[0154] Example 18. The apparatus according to any one of Examples 12-17, wherein the knowledge graph determination module comprises: a twelfth determination module, configured to determine at least one of a technical understanding and a development intention for each code task based on the determined data basis by a language model; and An updating module is configured to update the knowledge graph based on the technical understanding of each code task and the development intention by a language model.

[0155] Example 19. The apparatus according to any one of Examples 12-18, wherein the personnel set determination module comprises: A thirteenth determination module is configured to determine the current workload of each person in the personnel set associated with each code task; and A fourteenth determination module is configured to determine, for each person in the personnel set associated with each code task, whether each person is in a responsive state; and A fifteenth determination module is configured to determine, for each person in the person set associated with each code task, a current skill status of each person; and The sixteenth determination module is configured to determine a set of personnel that matches each code task based on a comprehensive score of the current workload, the responsiveness status, and the current skill status of each personnel associated with each code task.

[0156] Example 20. The apparatus according to any one of Examples 12-19, wherein the personnel allocation module comprises: A seventeenth determination module is configured to determine, by the target model, a weight of each of the following items based on the priority of the code task: The weight of the current workload of each person in the personnel set matching the code task; The weight of the current responsiveness status of each person in the person set matching the code task; and The weight of the current skill status of each person in the set of people matching the code task; An eighteenth determination module is configured to determine a comprehensive score for each person in the personnel set matching the code task based on a comprehensive weight of the weights of each item and a time decay coefficient of each person in the personnel set matching the code task; and An assignment module is configured to assign the code task to a person matching the code task based on the comprehensive score.

[0157] Example 21. According to the device described in any one of Examples 12-20, the comprehensive weight is determined by the target model configured with the time decay model and the attention mechanism, and the time decay coefficient is determined based on an exponential decay function and a collaborative relationship weight.

[0158] Example 22. The apparatus of any one of Examples 12-21, further comprising: a redetermining module configured to redetermine a comprehensive score of each person in a set of persons matching the code task in response to the person matching the code task not responding to the assignment within a predetermined time; and A reallocation module is configured to reallocate the code task to a person matching the code task based on the re-determined comprehensive score.

[0159] Example 23. An electronic device comprising: Processor; and A memory coupled to the processor, the memory having instructions stored therein, wherein when the instructions are executed by the processor, the electronic device performs actions, the actions comprising: Based on submission history information of the code task, determining a data basis for the submission history information, the submission history information including task information, personnel information, and personnel skill information, the data basis including at least one of an ownership profile of each code task and a modification behavior pattern for each code task; Determining, by a target model based on the determined data foundation, a knowledge graph associated with personnel, skills, and code tasks, wherein the target model is configured with a time decay model and an attention mechanism, and the knowledge graph includes personnel's skills, workload, collaborative relationship, and current status; The target model determines a set of personnel matching each code task based on each code task and the knowledge graph; and In response to an error in a code task, the target model assigns the code task to a person matching the code task based on a comprehensive score of each person in the person set, wherein the comprehensive score is determined based on the knowledge graph and a time decay coefficient of each person.

[0160] Example 24. The electronic device according to Example 23, wherein based on the submission history information of the code task, determining the data basis for the submission history information comprises: In response to each code task being merged into a production branch, the data basis for the commit history information is determined based on a rotating index.

[0161] Example 25. The electronic device of any one of Examples 23-24, wherein in response to each code task being merged into a production branch, determining the data basis for the commit history information based on a rotating index comprises: Determine an ownership profile of each code task based on the submission history information; and Determine a modification behavior pattern for each code task based on the submission history information; and Based on the ownership portrait and the modification behavior pattern, a collaboration network is determined, where the collaboration network indicates the strength of the collaboration relationship between each person.

[0162] Example 26. The electronic device according to any one of Examples 23-25, wherein determining the ownership portrait of each code task based on the submission history information comprises: Based on the submission history information, determine the contribution of each person to each code task; Based on the time decay model, sort each code task; and Based on the contribution, for each sorted code task, a first responsible person and a second responsible person for each code task are identified.

[0163] Example 27. The electronic device according to any one of Examples 23-26, wherein based on the submission history information, determining the modification behavior pattern for each code task comprises: Based on the submission history information, determine a task change type for each code task, where the task change type includes at least one of function development, defect repair, and task refactoring; Based on the submission history information, determine the skill characteristics of each person and the degree of participation of each person in each code task; and Based on the task change type for each code task, the skill characteristics of each person, and the degree of participation of each person in each code task, a skill characteristic profile for each person is determined.

[0164] Example 28. The electronic device of any one of Examples 23-27, wherein based on the ownership portrait and the modification behavior pattern, determining a collaborative network comprises: determining each person's collaboration history with another person, the collaboration history including collaboration frequency and collaboration scope; and Based on the collaboration history, determining a collaboration relationship graph, wherein nodes of the collaboration relationship graph indicate personnel, and edges of the collaboration relationship graph indicate collaboration relationship weights; and Based on the collaboration diagram, core personnel and professionals are determined.

[0165] Example 29. The electronic device according to any one of Examples 23-28, wherein determining, by the target model based on the determined data foundation, a knowledge graph associated with personnel, skills, and code tasks comprises: Determining, by the language model, at least one of a technical understanding and a development intention for each code task based on the determined data foundation; and The knowledge graph is updated by the language model based on the technical understanding of each code task and the development intention.

[0166] Example 30. The electronic device according to any one of Examples 23-29, wherein the target model determines a set of people matching each code task based on each code task and the knowledge graph, including: For each person in the set of people associated with each code task, determine a current workload of each person; and For each person in the set of people associated with each code task, determine whether each person is in a responsive state; and For each person in the set of people associated with each code task, determine a current skill state of each person; and A personnel set matching each code task is determined based on a comprehensive score of the current workload, the responsiveness status, and the current skill status of each person associated with each code task.

[0167] Example 31. The electronic device according to any one of Examples 23-30, wherein in response to an error in a code task, the target model assigns the code task to a person matching the code task based on a comprehensive score of each person in the person set, comprising: The target model determines the weight of each of the following based on the priority of the code task: The weight of the current workload of each person in the personnel set matching the code task; The weight of the current responsiveness status of each person in the person set matching the code task; and The weight of the current skill status of each person in the set of people matching the code task; Determine a comprehensive score for each person in the set of personnel matching the code task based on the comprehensive weight of the weight of each item and the time decay coefficient of each person in the set of personnel matching the code task; and Based on the comprehensive score, the code task is assigned to a person who matches the code task.

[0168] Example 32. According to the electronic device described in any one of Examples 23-31, the comprehensive weight is determined by the target model configured with the time decay model and the attention mechanism, and the time decay coefficient is determined based on an exponential decay function and a collaborative relationship weight.

[0169] Example 33. The electronic device of any one of Examples 23-32 further includes: In response to the person matched with the code task not responding to the assignment within a predetermined time, re-determining a comprehensive score for each person in the set of people matched with the code task; and Based on the re-determined comprehensive score, the coding task is re-assigned to a person who matches the coding task.

[0170] Example 34. A computer-readable storage medium having one or more computer instructions stored thereon, wherein the one or more computer instructions are executed by a processor to implement the method according to any one of Examples 1 to 11.

[0171] Example 35. A computer program product tangibly stored on a computer-readable medium and comprising computer-executable instructions that, when executed by a device, cause the device to perform the method according to any one of Examples 1 to 11.

[0172] Although the disclosure has been described in language specific to structural features and / or methodological logical actions, it should be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or actions described above. Instead, the specific features and actions described above are merely example forms of implementing the claims.

Claims

1. A method for allocating code tasks, comprising: Based on submission history information of the code task, determining a data basis for the submission history information, the submission history information including task information, personnel information, and personnel skill information, the data basis including at least one of an ownership profile of each code task and a modification behavior pattern for each code task; Determining, by a target model based on the determined data foundation, a knowledge graph associated with personnel, skills, and code tasks, wherein the target model is configured with a time decay model and an attention mechanism, and the knowledge graph includes personnel's skills, workload, collaborative relationship, and current status; The target model determines a set of personnel matching each code task based on each code task and the knowledge graph; as well as In response to an error in a code task, the target model assigns the code task to a person matching the code task based on a comprehensive score of each person in the person set, wherein the comprehensive score is determined based on the knowledge graph and a time decay coefficient of each person.

2. The method according to claim 1, wherein based on the submission history information of the code task, determining the data basis for the submission history information comprises: In response to each code task being merged into a production branch, the data basis for the commit history information is determined based on a rotating index.

3. The method according to claim 2, wherein in response to each code task being merged into a production branch, determining the data basis for the commit history information based on a rotating index comprises: Determine the ownership profile of each code task based on the submission history information; and Based on the submission history information, determining a modification behavior pattern for each code task; as well as Based on the ownership portrait and the modification behavior pattern, a collaboration network is determined, where the collaboration network indicates the strength of the collaboration relationship between each person.

4. The method according to claim 3, wherein determining the ownership profile of each code task based on the submission history information comprises: Based on the submission history information, determine the contribution of each person to each code task; Based on the time decay model, sort each code task; as well as Based on the contribution, for each sorted code task, a first responsible person and a second responsible person for each code task are identified.

5. The method according to claim 3, wherein determining the modification behavior pattern for each code task based on the submission history information comprises: Based on the submission history information, determine a task change type for each code task, where the task change type includes at least one of function development, defect repair, and task refactoring; Based on the submission history information, determine the skill characteristics of each person and the degree of participation of each person in each code task; as well as Based on the task change type for each code task, the skill characteristics of each person, and the degree of participation of each person in each code task, a skill characteristic profile for each person is determined.

6. The method according to claim 3, wherein determining a collaborative network based on the ownership profile and the modification behavior pattern comprises: Determining a collaboration history between each person and another person, the collaboration history including a collaboration frequency and a collaboration scope; as well as Based on the collaboration history, determining a collaboration relationship graph, wherein nodes of the collaboration relationship graph indicate personnel, and edges of the collaboration relationship graph indicate collaboration relationship weights; as well as Based on the collaboration diagram, core personnel and professionals are determined.

7. The method according to claim 1, wherein determining, by the target model based on the determined data foundation, a knowledge graph associated with personnel, skills, and code tasks comprises: Determining, by the language model, at least one of a technical understanding and a development intention for each code task based on the determined data foundation; as well as The knowledge graph is updated by the language model based on the technical understanding of each code task and the development intention.

8. The method according to claim 7, wherein the target model determines a set of personnel matching each code task based on each code task and the knowledge graph, comprising: For each person in the set of people associated with each code task, determine a current workload of each person; and For each person in the set of people associated with each code task, determine whether each person is in a responsive state; and For each person in the set of people associated with each code task, determine a current skill status of each person; as well as A set of personnel matching each code task is determined based on a comprehensive score of the current workload, the responsiveness status, and the current skill status of each personnel associated with each code task.

9. The method according to claim 8, wherein in response to an error in a code task, the target model assigning the code task to a person matching the code task based on a comprehensive score of each person in the person set comprises: The target model determines the weight of each of the following based on the priority of the code task: The weight of the current workload of each person in the personnel set matching the code task; The weight of the current responsiveness status of each person in the personnel set matching the code task; as well as The weight of the current skill status of each person in the set of people matching the code task; Determine a comprehensive score for each person in the set of personnel matching the code task based on the comprehensive weight of the weight of each item and the time decay coefficient of each person in the set of personnel matching the code task; as well as Based on the comprehensive score, the code task is assigned to a person who matches the code task.

10. According to the method according to claim 9, the comprehensive weight is determined by the target model configured with a time decay model and an attention mechanism, and the time decay coefficient is determined based on an exponential decay function and a collaborative relationship weight.

11. The method according to claim 10, further comprising: In response to the person matched with the code task not responding to the assignment within a predetermined time, re-determining a comprehensive score for each person in the set of people matched with the code task; as well as Based on the re-determined comprehensive score, the coding task is re-assigned to a person who matches the coding task.

12. A device for allocating code tasks, comprising: A data basis determination module is configured to determine a data basis for the submission history information of the code task based on the submission history information, wherein the submission history information includes task information, personnel information, and personnel skill information, and the data basis includes at least one of an ownership profile of each code task and a modification behavior pattern for each code task; A knowledge graph determination module is configured to determine a knowledge graph associated with personnel, skills, and code tasks based on the determined data foundation by a target model, wherein the target model is configured with a time decay model and an attention mechanism, and the knowledge graph includes personnel's skills, workload, collaborative relationship, and current status; A personnel set determination module is configured to determine a personnel set matching each code task based on each code task and the knowledge graph by the target model; as well as A personnel assignment module is configured to, in response to an error in a code task, assign the code task to a person matching the code task based on a comprehensive score of each person in the personnel set by the target model, wherein the comprehensive score is determined based on the knowledge graph and a time decay coefficient of each person.

13. An electronic device, comprising: processor; as well as A memory coupled to the processor, the memory having instructions stored therein, wherein when the instructions are executed by the processor, the electronic device executes the method according to any one of claims 1 to 11.

14. A computer program product tangibly stored on a non-transitory computer readable medium and comprising computer executable instructions for performing the method according to any one of claims 1 to 11.

Images