CN119784096A

CN119784096A - Method, apparatus, device and product for allocating code tasks

Info

Publication number: CN119784096A
Application number: CN202510271973.7A
Authority: CN
Inventors: 王浩; 唐子航; 何涛; 刘兴; 孙宇佳; 金鑫
Original assignee: Beijing Volcano Engine Technology Co Ltd
Current assignee: Beijing Volcano Engine Technology Co Ltd
Priority date: 2025-03-07
Filing date: 2025-03-07
Publication date: 2025-04-08
Anticipated expiration: 2045-03-07
Also published as: CN119784096B

Abstract

Embodiments of the present disclosure relate to methods, devices, equipment and products for assigning code tasks. The method includes determining a data basis for submission history information based on submission history information of the code task, and the submission history information includes task information, personnel information and personnel skill information. The method includes determining a knowledge graph associated with personnel, skills and code tasks by a target model based on the determined data basis, and the target model is configured with a time decay model and an attention mechanism. The method includes determining a set of personnel matching each code task based on each code task and the knowledge graph by the target model. 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.

Description

Method, apparatus, device and product for distributing code tasks

Technical Field

The present application relates to the field of computer technology, and in particular, to a method, an apparatus, an electronic device, and a computer program product for distributing code tasks.

Background

Large software development generally refers to software development projects that are large in scale, high in complexity, and involve multiple functional modules and subsystems. These projects may require tens or even hundreds of development teams to complete over months or years. With the development of internet technology, the field of software development has also advanced and innovated. Today, the mode of software development is no longer limited to traditional centralized collaboration, i.e., the way in which all people must co-develop at the same place. Instead, it has crossed geographic boundaries, enabling widespread practice of off-site development.

Disclosure of Invention

Embodiments of the present disclosure provide a method, apparatus, electronic device, and computer program product for distributing code tasks.

According to a first aspect of the present disclosure, a method for distributing code tasks is provided. The method includes determining, based on the submission history information of the code tasks, a data base for the submission history information, the submission history information including task information, personnel information, and personnel skill information, the data base including at least one of an ownership portrayal for each code task and a modified behavior pattern for each code task. The method includes determining, by a target model, a knowledge graph associated with the person, skill, and code task based on the determined data basis, the target model configured with a time decay model and an attention mechanism, the knowledge graph including skill, workload, collaboration relationship, and current state of the person. The method includes determining, by the object model, a set of people matching each code task based on each code task and the knowledge-graph. In addition, the method includes assigning, by the object model, the code task to persons matching the code task based on a composite score for each person in the set of persons in response to the code task being in error, the composite score being determined based on the knowledge graph and a time decay factor for each person.

According to a second aspect of the present disclosure, an apparatus for distributing code tasks is provided. The apparatus includes a data base determination module configured to determine a data base for the submission history information, including task information, personnel information, and personnel skill information, based on the submission history information of the code tasks, the data base including at least one of an ownership portrayal for each code task and a modified behavior pattern for each code task. The apparatus includes a knowledge-graph determination module configured to determine, by a target model, a knowledge graph associated with a person, skill, and code task based on the determined data basis, the target model configured with a time-decay model and an attention mechanism, the knowledge graph including skill, workload, collaboration relationship, and current state of the person. The apparatus includes a person set determination module configured to determine, by the object model, a person set that matches each code task based on each code task and a knowledge graph. The apparatus further includes a person assignment module configured to assign, by the object model, the code task to persons matching the code task based on a composite score for each person in the set of persons in response to the code task being in error, the composite score being determined based on the knowledge graph and a time decay factor for each person.

According to a third aspect of the present disclosure, an electronic device is provided. The electronic device comprises a processor and a memory coupled to the processor, the memory having instructions stored therein that, when executed by the processor, cause the electronic device to perform the method according to the first aspect.

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 includes computer-executable instructions that, when executed, cause a computer to perform the steps of the method of the first aspect of the present disclosure.

The summary is provided to introduce a selection of concepts in a simplified form that are further described below in the detailed description. This summary is not intended to identify key features or essential features of the claimed subject matter, nor is it intended to be used to limit the scope of the claimed subject matter.

Drawings

The above and other features, advantages and aspects of embodiments of the present disclosure will become more apparent by reference to the following detailed description when taken in conjunction with the accompanying drawings. In the drawings, wherein like or similar reference numerals denote like or similar elements, in which:

FIG. 1 illustrates a schematic diagram of an example environment in which devices and/or methods may be implemented, according to embodiments of the present disclosure;

FIG. 2 illustrates a flow chart of a method for distributing code tasks according to an embodiment of the disclosure;

FIG. 3 shows a schematic diagram of example steps for distributing code tasks, according to an embodiment of the disclosure;

FIG. 4A illustrates a schematic diagram of an example data infrastructure for distributing code tasks, according to an embodiment of the disclosure;

FIG. 4B illustrates a schematic diagram of collaboration intensity for distributing code tasks, according to an embodiment of the disclosure;

FIG. 5A shows a schematic diagram of a large model-based developer skill knowledge graph, in accordance with an embodiment of the disclosure;

FIG. 5B shows a schematic diagram of an example of a developer skill knowledge graph, in accordance with an embodiment of the disclosure;

FIG. 6 illustrates a schematic diagram of large model-based dynamic state awareness in accordance with an embodiment of the present disclosure;

FIG. 7 illustrates a schematic diagram of a time-sequential attention mechanism of a goal model, according to an embodiment of the present disclosure;

FIG. 8 illustrates a schematic diagram of intelligent allocation and dynamic adjustment of model-based code tasks, according to an embodiment of the present disclosure;

FIG. 9 illustrates a block diagram of an apparatus for distributing code tasks in accordance with some embodiments of the present disclosure, and

Fig. 10 shows a block diagram of an electronic device according to an embodiment of the disclosure.

The same or similar reference numbers will be used throughout the drawings to refer to the same or like elements.

Detailed Description

It will be appreciated that prior to using the technical solutions disclosed in the embodiments of the present disclosure, the user should be informed and authorized of the type, usage range, usage scenario, etc. of the personal information (such as voice) related to the present disclosure in an appropriate manner according to the relevant legal regulations.

Embodiments of the present disclosure will be described in more detail below with reference to the accompanying drawings. While certain embodiments of the present disclosure have been shown in the accompanying drawings, it is to be understood that the present disclosure may be embodied in various forms and should not be construed as limited to the embodiments set forth herein, but are provided to provide a more thorough and complete understanding of the present disclosure. It should be understood that the drawings and embodiments of the present disclosure are for illustration purposes only and are not intended to limit the scope of the present disclosure.

In describing embodiments of the present disclosure, the term "comprising" and its like should be understood to be open-ended, i.e., 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," and the like, may refer to different or the same object unless explicitly stated otherwise. Other explicit and implicit definitions are also possible below.

As mentioned above, large software development projects are large in scale and many problems are naturally encountered during development. One of them is code error alarm and processing work after code error alarm, including the situation of which developers to distribute to process, how to distribute, etc. In the related art, a method for distributing alarming code tasks based on a specified rule is adopted, and cannot adapt to dynamic changes of teams, and meanwhile, professional particulars and real-time states of developers are ignored. Another technique is to assign the code task of an alarm based on the last modifier of the code task of the alarm, and this scheme does not consider the collaboration history of the code task developer and the current state of the developer, and easily causes maldistribution of the code task of the alarm. In practice, a mode of manually distributing tasks according to personal experience by relying on team responsible persons is adopted, and the mode is low in efficiency and difficult to apply in large scale in a large team development environment.

To this end, embodiments of the present disclosure propose a solution for automatically assigning code tasks to users. First, a data base for the submission history information is determined based on the submission history information of the code tasks, wherein the submission history information includes task information, personnel information, and personnel skill information, and the determined data base includes at least one of an ownership portrayal of each code task, and a modified behavior pattern for each code task. And then, constructing a knowledge graph associated with the personnel, skills and code tasks based on the determined data basis by using the target model. The target model is configured with a time decay model and an attention mechanism, and the constructed knowledge graph comprises information on the skill, workload, collaboration relationship, current state and the like of the personnel. Then, the target model determines a person set matched with each code task according to the specific condition of each code task and the constructed knowledge graph. Finally, when the code task is in error, the target model can distribute the code task to the personnel matched with the code task according to the comprehensive score of each personnel in the personnel set. Wherein the composite score is determined based on the knowledge-graph and the time-decay factor of each person.

According to the scheme of the embodiment of the disclosure, by means of the model capacity of the target model, deep technical understanding and real-time accurate capacity portraits can be achieved, so that when a code task is wrong, the wrong code task can be distributed to related personnel efficiently according to the current state of the related personnel to achieve maintenance of the code task, the reliability and timeliness of the wrong code task being processed are ensured, and user experience is improved.

Embodiments of the present disclosure will be described in further detail below with reference to the accompanying drawings. FIG. 1 illustrates a schematic diagram of an example environment 100 in which devices and/or methods may be implemented, according to embodiments of the present disclosure.

In order to dynamically process the alarm or error condition of the code task, personnel for carrying out error alarm processing can be allocated to the error code task in a targeted manner according to the submitting history information of the code task. In some embodiments, a data basis for the submission history information may be determined from the submission history information of the code task, and then a knowledge graph 130 associated with the person, skill, and code task is determined based on the data basis. As shown in fig. 1, in some embodiments, a knowledge graph 130 may be constructed from the personnel information 110 and the task information 120. Wherein the person information 110 includes skill information of the person. Herein, a person is also referred to as a developer or developer.

In some embodiments, the submission history information includes task information, personnel information, and personnel skill information. The task information refers to information related to code tasks, such as code change, submission frequency, and the like. Information such as participation degree of developers in different types of code tasks indicated by personnel information. The skill information of the person refers to information such as the expertise field of the developer.

In some embodiments, the constructed data base includes at least one of an ownership portrait for each code task and a modified behavior pattern for each code task. In some embodiments, an accurate ownership portrait may be established for each code task by scanning all historical commit records of the versioning system (e.g., git). By creation of the ownership portraits, primary responsible persons and secondary responsible persons can be represented for each code task.

In some embodiments, after the ownership portrayal of the code task is established, the developer's modified behavior patterns can be further analyzed on this basis. By means of analysis of the modification behavior patterns, skill feature images of developers can be established, and accordingly decision basis can be provided for subsequent intelligent distribution of code tasks.

In some embodiments, the constructed data base may further include integrating the ownership portraits and the modified behavior model, so as to obtain a complete collaboration network, i.e. a collaboration relationship graph, so as to identify the core developer and the professional domain expert of the team from the collaboration relationship graph. By constructing the data foundation in a layer-by-layer progressive manner, a dynamically updated knowledge base can be formed, so that reliable data support can be provided for the distribution decision of the code tasks of subsequent alarms, the code tasks of the alarms can be ensured to be distributed to the most suitable processing personnel, the development efficiency of the whole development team can be improved, and the user experience is improved.

And after the data base supporting the subsequent task decision distribution is constructed, the model capability of the target model 140 can be introduced to construct a developer skill knowledge graph based on model perception on the basis, so that the distribution of code tasks with finer granularity and better adaptation with the target developer or errors can be conveniently realized in the decision process of the subsequent task distribution.

Referring to FIG. 1, in some embodiments, an indication map 130 associated with personnel, skills, and code tasks may be constructed based on a previously determined data basis by means of a goal model 140, which enables a deeper technical understanding and a more accurate representation of capabilities. The target model 140 may be a large-scale pre-trained model, which is an artificial intelligence model based on deep learning techniques. In some embodiments, the goal model 140 may be a model configured with a time-sequential attention mechanism, i.e., may be configured with a time-decay model and an attention mechanism. By means of a time sequence attention mechanism, the decision of the distribution of the code tasks of the subsequent alarm can be ensured to adapt to the dynamic change of the cooperative relationship.

In some embodiments, the constructed knowledge graph 130 includes skills, workload, collaboration relationships, and current status of the person. In some embodiments, the constructed knowledge-graph 130 may also be continuously analyzed by means of the target model 140 to enable dynamic updating of the constructed knowledge-graph 130.

As shown in FIG. 1, in some embodiments, depth mining of the submitted history information and dynamic perception of the real-time status of personnel may be accomplished based on knowledge graph 130 and model-based distribution system 140 to obtain distribution results 150, i.e., code tasks are distributed to relevant personnel, and particularly in the case of code task error alarms, code tasks of relevant alarms may be distributed to relevant personnel for subsequent processing.

In some embodiments, a matching set of people may be determined for each code task by the object model via a knowledge graph and based on the code task. For example, the code task 1 is cooperatively developed by the person a and the person B, and then the person a and the person B may be persons in the person set matched with the code task 1.

In some embodiments, when a code task is in error, the person most suitable for perfecting the code task in error can be determined by the target model according to the composite score of each person in the matched set of persons. In some embodiments, the composite score may be determined from a knowledge-graph and a time decay factor for each person. For example, when the code task 1 is in error, the person a is in an unresponsive state at present, and the attenuation coefficient of the person a relative to the person B is small, so that the overall score of the person B is high, and the error code task 1 can be allocated to the person B without the influence of other factors.

According to the scheme of the embodiment of the disclosure, by means of the capability of the target model, deep technical understanding and real-time accurate capability portrait drawing can be realized, so that when a code alarms, an alarm code task can be distributed to related personnel efficiently according to the current state of the related personnel, the reliability and timeliness of the alarm code task being processed are ensured, and user experience is improved.

It should be understood that the architecture and functionality in the example environment 100 are described for illustrative purposes only and are not meant to suggest any limitation as to the scope of the disclosure. Embodiments of the present disclosure may also be applied to other environments having different structures and/or functions.

A process according to an embodiment of the present disclosure will be described in detail below in conjunction with fig. 2 to 10. For ease of understanding, specific data set forth in the following description are intended to be exemplary and are not intended to limit the scope of the disclosure. It will be appreciated that the embodiments described below may also include additional actions not shown and/or may omit shown actions, the scope of the present disclosure being not limited in this respect.

Fig. 2 illustrates a flow chart of a method 200 for distributing code tasks according to an embodiment of the disclosure. The method 200 is schematically described below taking as an example an apparatus for distributing code tasks. The method 200 includes block 202, block 204, block 206, and block 208.

At block 202, a data basis for the submission history information, including task information, personnel information, and personnel skill information, may be determined based on the submission history information of the code tasks, the data basis including at least one of an ownership portrayal of each code task and a modified behavior pattern for each code task. In order to dynamically process the alarm condition of the code task, personnel for alarm processing can be allocated to the code task with pertinence according to the submitting history information of the code task. In some embodiments, a data basis for the submission history information may be determined from the submission history information of the code task, and then a knowledge graph 130 associated with the person, skill, and code task is determined based on the data basis. As shown in fig. 1, in some embodiments, a knowledge graph 130 may be constructed from the personnel information 110 and the task information 120. Wherein the person information 110 includes skill information of the person. In some embodiments, the submission history information includes task information, personnel information, and personnel skill information. The task information refers to information related to code tasks, such as code change, submission frequency, and the like. Information such as participation degree of developers in different types of code tasks indicated by personnel information. The skill information of the person refers to information such as the expertise field of the developer. In some embodiments, the constructed data base includes at least one of an ownership portrait for each code task and a modified behavior pattern for each code task. By creation of the ownership portraits, primary responsible persons and secondary responsible persons can be represented for each code task. In some embodiments, after the ownership portrayal of the code task is established, the developer's modified behavior patterns can be further analyzed on this basis. By means of analysis of the modification behavior patterns, skill feature images of developers can be established, and accordingly decision basis can be provided for subsequent intelligent distribution of code tasks.

At block 204, a knowledge graph associated with the person, skill, and code task may be determined by a target model based on the determined data basis, the target model configured with a time decay model and an attention mechanism, the knowledge graph including the person's skill, workload, collaboration relationship, and current state. And after the data base supporting the subsequent task decision distribution is constructed, the model capability of the target model 140 can be introduced to construct a developer skill knowledge graph based on model perception on the basis, so that the distribution of the code tasks with finer granularity and alarm more suitable for the target developer can be conveniently realized in the decision process of the subsequent task distribution. Referring to FIG. 1, in some embodiments, an indication map 130 associated with personnel, skills, and code tasks may be constructed based on a previously determined data basis by means of a goal model 140, which enables a deeper technical understanding and a more accurate representation of capabilities. The target model 140 may be a large-scale pre-trained model, which is an artificial intelligence model based on deep learning techniques. In some embodiments, the goal model 140 may be a model configured with a time-sequential attention mechanism, i.e., may be configured with a time-decay model and an attention mechanism. By means of a time sequence attention mechanism, the decision of the distribution of the code tasks of the subsequent alarm can be ensured to adapt to the dynamic change of the cooperative relationship. In some embodiments, the constructed knowledge graph 130 includes skills, workload, collaboration relationships, and current status of the person. In some embodiments, the constructed knowledge-graph 130 may also be continuously analyzed by means of the target model 140 to enable dynamic updating of the constructed knowledge-graph 130.

At block 206, a set of people matching each code task may be determined by the goal model based on each code task and the knowledge-graph. As shown in FIG. 1, in some embodiments, depth mining of the submission history information and dynamic awareness of the person's real-time status may be implemented based on knowledge-graph 130 and model-based distribution system 140 to obtain distribution results 150, i.e., code tasks, to related persons. For example, the code task 1 is cooperatively developed by the person a and the person B, and then the person a and the person B may be persons in the person set matched with the code task 1.

At block 208, the code task may be assigned by the object model to persons matching the code task based on the composite score for each person in the set of persons, based on the knowledge graph and the time decay coefficients for each person, in response to the code task being in error. In some embodiments, when a code task is in error, the person most suitable for perfecting the code task in error can be determined by the target model according to the composite score of each person in the matched set of persons. For example, when code task 1 is in error, person a is currently in an unresponsive state, and the attenuation coefficient of person a relative to person B is small, so that the overall score of person B is high, and then the error code task 1 can be assigned to person B.

According to the scheme of the embodiment of the disclosure, by means of the capability of the target model, deep technical understanding and real-time accurate capability portrait drawing can be realized, so that when a code makes an error alarm, the code task of the error alarm can be distributed to the related personnel efficiently according to the current state of the related personnel, the reliability and timeliness of the code task of the error alarm being processed are ensured, and the user experience is improved.

FIG. 3 shows a schematic diagram of example steps 300 for distributing code tasks, according to an embodiment of the disclosure. In order to dynamically process the alarm condition of the code task, personnel for performing error alarm processing can be allocated to the code task with the error alarm in a targeted manner according to the submitting history information of the code task. In order to facilitate the use of data in the subsequent allocation decision process, a foundation stone for code task allocation of alarm can be laid first, namely, a basic data structure is constructed. As shown in fig. 3, an underlying data structure may be constructed at 310. In some embodiments, building the underlying data structure may be further divided into three incremental layers to enable building a comprehensive developer-code association network.

As will be described below in connection with fig. 4A. FIG. 4A illustrates a schematic diagram of an example data infrastructure 400A for distributing code tasks, according to an embodiment of the disclosure. Referring to FIG. 4A, data base build 310 includes code ownership definition 410, modification behavior analysis 420, and collaboration relationship build 430, which are progressive. In some embodiments, the attribution relationship of code tasks or code modules may be analyzed by scanning all historical commit records of a version control system (e.g., git).

In some embodiments, code ownership definition 410 in turn includes analyzing the commit record, introducing a time decay model, and identifying responsible persons. In some embodiments, at 411, the commit record is analyzed. That is, the contribution of each developer or developer to the code task or code module may be calculated by analyzing the change amount equalization index of the code line of each code task or code module by analyzing the frequency of the submitted records of the code task or code module. By 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 referenced for task allocation in the subsequent decision-making process.

In some embodiments, a time decay model is introduced at 412 to ensure that recently modified code tasks are able to get higher weights. In some embodiments, at 413, the responsible person is identified. The primary responsible person and the secondary responsible person are identified for each code task or code module, so that a foundation can be laid for the subsequent determination of the matched personnel set. By the operations at 411, 412 and 413, an accurate ownership portrait can be established for each code task or code module.

The calculation formula for the contribution in some embodiments is as follows:

N is the number of all submitted records of the developer in the code task or the code module; for modifying type weights; modifying the number of lines for the code submitted for the ith time; Is a time decay weight; Is a collaborative weight.

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

Wherein, Is the time difference (in days) between the current time and the i-th commit time,Is a decay time coefficient for adjusting the rate of time decay.

In some embodiments, the collaborative weights are calculated as follows:

Wherein, Is a collaboration weight coefficient used for adjusting the influence degree of collaboration frequency on the collaboration weight.

After completion of code ownership definition in the data base, the next level of the data base is to modify behavior analysis 420. In some embodiments, modifying behavior analysis 420 includes semantically analyzing the submitted information and creating a skill feature image.

Referring to FIG. 4A, in some embodiments, the commit information, i.e., the commit history information of the code task or code module, is semantically analyzed to identify different types of code changes, such as types of functional development, defect repair, and code reconstruction, at 421. In some embodiments, the type of code change may be initially determined by analyzing the code add, delete, change, etc. operations with the aid of differential (diff) information provided by the version control system. For example, when a row marked with "+" is detected, it can be determined that the type of change corresponding to the row code may be a newly added function, class, module, or the like, corresponding to a function development or new feature addition. For another example, when a row marked with "-" is detected, it may be determined that the type of change in the row of code plays may be the removal of outdated codes, obsolete functions, corresponding to code cleaning or technical debt repayment. For another example, when a row is detected where both "+" and "-" are present, it may be determined that the type of change to which the code corresponds may be optimized performance, tuning logic, corresponding to defect repair or code reconstruction.

In some embodiments, the scope of change of a code task or code module may also be analyzed. For example, at the file level, it may be determined whether the change type is a front-end, back-end, or configuration file change, depending on the type of file. For another example, at the module or task level, the directory structure of code modules or code tasks may be combined to determine the attribute attribution of the changed module or task. As another example, at the function or class level, the function or class of the change design may be extracted by means of a static code analysis tool (e.g., an AST parser) to further refine the scope of the change.

In some embodiments, for database-related code, the type of code change may be determined by analyzing the corresponding SQL statement or API call of the add-drop-modify operation. For example, a code task or an API call added or deleted in a code module may be detected to determine whether an external dependent change is involved. For another example, modifications to the configuration file (e.g., yaml,. Json) may also be detected to determine whether environmental configuration or parameter adjustment, etc., is involved.

In some embodiments, the altered semantic information may be further extracted by Natural Language Processing (NLP) techniques. For example, a word segmentation tool may be used to segment submitted history information to extract key verbs and nouns and combine context to determine the type of change. For example, fix corresponds to defect repair, add corresponds to function development, refactor corresponds to code reconstruction. In some embodiments, pre-trained language models (e.g., BERT, GPT) may also be used to semantically classify submitted historical information. In some embodiments, the commit history information and code change content may also be combined for contextual semantic analysis. For example, based on submitted information "Add user authentication" in combination with an auth module newly added in the code change, it can be determined to be a functional development. Based on "Refactor database connection logic" of the commit information, in combination with modifications to the database connection code in the code change, a determination can be made as to the code reconstruction. Alternatively, the semantics of the code changes and the commit information can also be analyzed directly by means of the large model and hints to quickly identify the change type.

In some embodiments, the structured information of the code change and the unstructured semantic information of the submitted information may be combined to form a multi-modal analysis framework, and the added and deleted features of the code change and the semantic features of the submitted information may be fused to construct a multi-dimensional feature vector. For example, a function is newly added in the code change, and the submitted information contains an "Add" keyword, so that the function development can be further confirmed. In some embodiments, the fused feature vectors may be classified using a machine learning or deep learning model (e.g., random forest, LSTM, transformer). For example, the input of the model may be a code change feature and a commit information feature, such that the output of the model may be derived as a change type (e.g., functional development, defect repair, reconstruction, etc.). In some embodiments, the change patterns of the developer may also be analyzed in conjunction with the historical commit record. For example, some developer recently submitted fix-type changes frequently, indicating that the current stage is dominated by defect repair.

Referring to fig. 4A, a skill feature image is created at 422. In some embodiments, the degree of participation and expertise of each developer or person in different types of task weight may be determined and skill profiles established for each developer or person to provide decision basis for subsequent intelligent allocation.

In some embodiments, the language processing capabilities of the large model may be used to parse the resume of each person or developer and extract information such as skill keywords, project experience, technical stack, etc. from the resume to construct a preliminary skill representation of each person or developer and mark the programming language, framework, tools, and fields (e.g., front-end, back-end, AI, etc.) that are good at.

In some embodiments, technical documents, design documents, code annotations, etc. written by the developers may also be analyzed through a large model to understand the technical expressive power and depth into a specific field of each developer or developer, to identify the expertise of the developer in the specific technical field (e.g., algorithm optimization, system architecture design, etc.), and to evaluate the technical depth thereof.

In some embodiments, task allocation, completion records, comments, and collaboration data may also be extracted from project management tools (e.g., jira, trello, asana) and analyzed in conjunction with large models for task types (e.g., functional development, defect repair, reconstruction, etc.) and participation frequencies of each developer or person to quantify the degree of participation of the developer in different task types and to annotate their empirical values on a particular task type.

In some embodiments, the submission records (such as Git) of the code repository may also be analyzed by the large model, and the types (functional development, bug fixes, performance optimizations, etc.) and complexities of the code changes may be identified to build technical behavior patterns of the developer, so that their contribution and expertise in different task types may be annotated.

In some embodiments, project management platform and code collaboration records may also be combined, and a collaboration network of developers may be built using a large model to analyze their roles in the team (e.g., core developer, technical expert, supporting roles, etc.) to identify the technical impact and collaboration capabilities of the developers in the team, thereby enabling further improvement of their skill portraits.

In some embodiments, the above information may be integrated into a developer skill knowledge graph, and the skill labels and weights may be dynamically updated to reflect the real-time status and capability changes of the developer, so as to form a multidimensional association graph of "developer-skill-task type", so as to provide accurate basis for task allocation and team management.

As shown in FIG. 4A, after the first two steps of the data base construction are completed, on the basis of the first two steps, the next level of the data base, namely, the collaboration relationship construction 430. At 431, a collaboration history, i.e., a collaboration history between developers, is recorded, including collectively modifying the frequency and scope of the same module. The collaboration history may be as shown in table 1 below:

Referring to FIG. 4A, at 432, a collaboration relationship graph is constructed. That is, a weighted collaboration relationship graph is constructed, wherein nodes represent developers or developers, and edges represent collaboration relationships between the developers or developers. In some embodiments, at 433, the strength of collaboration between each developer may also be quantified. In connection with fig. 4B, fig. 4B illustrates a schematic diagram of a collaboration intensity 400B for distributing code tasks, according to an embodiment of the disclosure. As shown in fig. 4B, a weighted collaboration relationship diagram is constructed among person a, person B, person C, and person D, with weights representing the strength of collaboration relationship between person a and person B. Wherein, the cooperative weight of the person A to the person B is 0.85, and the cooperative weight of the person B to the person A is 0.65. Core developers and professional domain experts in a team can be identified by nodes representing personnel and edges representing collaboration relationships and weight values between edges.

In some embodiments, a rotation Index (Rolling Index) may be employed to construct the data base. The rotation index is mainly used for ensuring that stable service can be provided in the updating process in a scene requiring frequent updating of the index. It achieves seamless switching and high availability by maintaining two or more copies of the index (e.g., index a and index B), with different copies being used alternately when updating the index. For example, in an initial state, served by index a, index B is in a standby state, and all query requests are routed to index a. When the system needs to update the index, the update operation is performed on the spare index B.

In some embodiments, the updating of index B includes rescanning the commit record from the code repository, recalculating the association of the developer with the code module, and updating the developer skill knowledge graph, among other things. After the update of the index B is completed, necessary verification can be performed to ensure that the data of the index B is correct and complete. After verification passes, the system will switch the service provider from index A to index B. Then, the index B starts to provide service to the outside, the index a enters a standby state, and all query requests of the system are routed to the index B. When the next index update request comes, the update operation will be performed on the spare index a. After the update is completed, the system switches the service provider again, switching from index B back to index a.

By means of the rotation type index switching method, the association relation between a developer or a developer and a code module can be updated regularly, stability, integrity and consistency of a constructed data base are guaranteed, and accordingly accuracy of a subsequent allocation decision is guaranteed.

Fig. 4A-4B depict a three-layer progressive data construction process, so that a dynamically updated knowledge base can be formed to provide reliable data support for subsequent alarm allocation decisions, ensuring that each problem can find the most appropriate handler, thereby improving the problem resolution efficiency of the whole team and improving user experience.

Returning to FIG. 3, when building the underlying data structure is complete at 310, a large model-based developer skill knowledge graph may be built at 320. The core goal of knowledge graph management is to accurately map the association relationship of developer-skill-code module. By introducing large model capabilities, deeper technical understanding and more accurate representation of capabilities can be achieved.

As will be described below in connection with fig. 5A. Fig. 5A shows a schematic diagram of a large model-based developer skill knowledge graph 500A, according to an embodiment of the disclosure. Referring to fig. 5A, a large model based developer skill knowledge graph 320 includes a code capability understanding 510, a submit information interpretation 520, and a skill graph update 530. I.e., by deep understanding of the submission history and related prompts, a developer skill knowledge graph is generated. In some embodiments, the relevant information of the commit history may be in the form of the previously constructed base data having three incremental layers.

As shown in FIG. 5A, code capability understanding 510 includes analyzing technical features, identifying programming patterns, and evaluating code quality. In some embodiments, at 511, analytical technique features are performed. I.e., the submission history information of the code task may be analyzed by means of a large model to enable a deep technical understanding of the submission history information. For example, a large model may understand the technical features and complexity of code in the commit history information. In some embodiments, at 512, programming patterns are identified, and programming patterns and technical preferences for each developer or developer can also be identified by way of a large model. In some embodiments, the quality of the code is evaluated, and the quality and technical depth of the code in the commit history may be evaluated by means of a large model, 513.

Referring to fig. 5A, submitting an information interpretation 520 includes extracting technical keywords, understanding technical paths, and identifying areas of expertise. In some embodiments, extracting technical keywords, i.e., analyzing technical keywords in the submission history information by means of a large model, is performed 521. At 522, an understanding technology path, i.e., a technology path that understands problem resolution by means of a large model, is performed. At 523, the area of expertise is identified, i.e., the quality of the developer's area of expertise and solutions is identified by means of large models.

With continued reference to fig. 5A, skill profile updating 530 includes implementing updating skill tags, adjusting skill weights, and optimizing picture structure. In some embodiments, at 531, the implementation updates the skill-tags, i.e., updates the developer's skill-tags in real-time via a large model, is performed. In some embodiments, at 532, skill weights are adjusted, i.e., adjusting skill weights and expertise scores is performed. In some embodiments, at 533, the picture structure is optimized, i.e., the structural relationship of the knowledge-graph is optimized.

In some embodiments, the inputs for the large model may be code submission records, contextual hints, and external knowledge bases (optional). The code commit record may include code content (code fragments, change content) of the commit, commit information (commit message), including descriptive text, commit time, commit information, and code module path (e.g., file name, directory structure), among others. The contextual hints can include project context information (e.g., technical stacks of projects, target functions), functional descriptions of code modules, historical collaboration relationships (e.g., collaboration frequency between developers), and task types (e.g., functional development, defect repair, performance optimization, etc.). While the external knowledge base (optional) may include grammatical rules of programming languages, documents of common technical frameworks and libraries, and industry standards and best practices.

In some embodiments, the output of the large model may be a knowledge graph including a skills feature portraits, code module associations, and collaboration relationships. Wherein the skill profile includes a developer's skill tags (e.g., "Java back-end development," "front-end reaction," "database optimization"), skill weights (e.g., a developer's skill score in a field), expertise fields (e.g., "Performance optimization expert," "security hole repair"). The association of the code modules can include association relation between the developer and the code modules (such as contribution degree of the developer to a certain module), and technical characteristics of the modules (such as a high concurrency processing module and a data analysis module). In addition, collaboration relationships may include strength of collaboration between developers (e.g., frequency of co-modifying the same module or task), role distribution within a team (e.g., "core developer", "code reviewer"). In conjunction with fig. 5B, fig. 5B shows a schematic diagram of an example 500B of a developer skill knowledge-graph, according to an embodiment of the disclosure. The knowledge Graph is presented in the form of Graph structure (Graph), the nodes (Node) represent entities, and the edges (Edge) represent the relationships between the entities. For example, developer a is adept at JAVA backend development.

By means of the large model, the system can better understand and manage the technical capability distribution of the team, and a more reliable decision basis is provided for alarm distribution.

Returning to FIG. 3, upon completion of building the underlying data structure at 310, and building of the large model-based developer skill knowledge graph at 320, large model-based dynamic state awareness may be implemented at 330. The dynamic state sensing module can accurately evaluate and predict the states of each person or developer by means of the intelligent analysis capability of the large model, and real-time decision support is provided for alarm distribution.

As will be described below in connection with fig. 6. Fig. 6 illustrates a schematic diagram of large model-based dynamic state awareness 600, according to an embodiment of the present disclosure. Referring to fig. 6, the large model-based dynamic state awareness 330 includes intelligent load assessment 610, time zone and state analysis 620, and dynamic skill matching 630. That is, the real-time evaluation of the development status of each developer or each person is realized mainly by the above three core functions.

In some embodiments, intelligent load assessment 610 includes understanding task complexity, assessing cognitive load, and predicting task risk, so that a developer can analyze current workload and determine if it has enough time and effort to handle new alarm tasks. In some embodiments, understanding task complexity, i.e., analyzing the tasks currently assigned to the developer by means of a large model, evaluating its technical difficulty and predicted completion time, is performed at 611. In some embodiments, the developer's current task description (e.g., code change content, task type) may be input to the large model, which may then output a task's complexity score (e.g., "high," "medium," "low"). For example, the input of the large model may be that the current task of developer A is "optimize concurrency performance of order management module" and the output of the large model may be that the task complexity score is "high".

In some embodiments, at 612, evaluating the cognitive burden, i.e., evaluating the cognitive burden of different types of tasks with the aid of a large model, is performed. For example, the cognitive burden of a task on a developer can be assessed by means of a large model in combination with the task type (e.g., functional development, defect repair) and skill profile of the developer. In some embodiments, at 613, a predicted task risk, i.e., a predicted task's potential risk and completion time, is performed. For example, the priority of the developer's current task may be identified by means of a large model and a determination may be made as to whether a new alarm task may be inserted.

In some embodiments, time zone and status analysis 620 includes analyzing calendar and records, understanding status information, and predicting contact time, which enables judgment of availability of a developer, ensuring that the developer is in a working time or responsive status at the time of alert assignment. In some embodiments, at 621, an analysis of the calendar and notes is performed, i.e., by integrating calendar, meeting notes, etc., information to identify whether the developer has an idle time to process the alarm. In some embodiments, understanding status information is performed at 622, i.e., by analyzing status information (e.g., "online", "busy") of instant messaging tools (e.g., slack, teams) to determine the developer's real-time status. In some embodiments, at 623, a predicted contact time, i.e., a predicted best contact time window, is performed. In some embodiments, the large model may also output a developer's availability score (e.g., 1 for full availability, 0 for unavailable). For example, the input may be that developer C is in UTC+8 time zone, the current time is 10 pm, the status is "offline" and the output may be that the availability score is 0.

In some embodiments, dynamic skill matching 630 includes understanding the nature of the alert technology, evaluating the current state of technology, and predicting the best person, which enables a large model to dynamically match the most appropriate developer or person based on the technical characteristics of the alert and the current state of skill of the developer. In some embodiments, at 631, understanding the nature of the alarm technique is performed. The technical characteristics of the problems are extracted by means of semantic analysis of alarm contents (such as logs and error information) by means of a large model. In some embodiments, error logs, stack information, and related code segments of the code task of the error alarm may be entered into a large model, which may then output technical characteristics of the code task of the error alarm (e.g., the module involved, possible root cause), etc. For example, the input for the large model may be that the alarm log displays "database connection timeout" and the output of the large model may be that the technical characteristic is "database optimization problem, involving the data storage module".

In some embodiments, the current state of the art is evaluated at 632. The large model is combined with the skill knowledge graph of the developer to judge whether the current skill is matched with the alarm problem. In some embodiments, at 633, the best choice is predicted. Namely, according to the recent task completion condition of the developer, the skill weight of the developer is dynamically adjusted. For example, if a developer is recently frequently dealing with database problems, his "database optimization" skill weight will be increased) and rank the heavier ones first. In some embodiments, a skill match score for the developer may be output through dynamic skill match 630. For example, 0.9 indicates a high degree of matching, and 0.3 indicates a low degree of matching.

In some embodiments, upon receiving alarm information (e.g., service anomalies, code errors), the large model may extract technical characteristics of the alarm (e.g., code module or code task involved, error type). Meanwhile, the large model can develop developer state evaluation, including load evaluation, availability evaluation and skill matching, so as to obtain a matching personnel set, wherein the matching personnel set can comprise developers with lower loads, currently available developers and developers with higher skill matching degree. After the matched set of people is obtained, a composite score for each developer may be calculated according to the following formula in some embodiments:

wherein, alpha, beta and gamma are weight parameters which can be adjusted as required.

In some embodiments, the highest scoring developer may be selected as the handler for the alert based on the composite score. In some embodiments, if the highest scoring developer fails to respond in time, a dynamic adjustment mechanism may be triggered to assign an alert to the next best candidate.

By means of the large model, working states, task loads, time zone differences and task complexity of developers are analyzed in real time, and intelligent decision support can be provided for alarm distribution.

Fig. 7 shows a schematic diagram of a time sequential attention mechanism 700 of a goal model according to an embodiment of the disclosure. Whereas in large software development teams, the code task's collaboration relationship and code responsibility are not constant, but rather dynamically adjusted over time and task variation. Thus, to dynamically evaluate collaboration relationships between developers and priorities of alarm assignments, a large model may be configured with a time-sequential attention mechanism. Referring to fig. 7, a time series attention mechanism 701 includes a time decay model 710 and an attention weight calculation 720.

In some embodiments, an exponential decay function 711 may be employed to weight the historical collaboration relationship to achieve a near term collaboration high weight 712. In some embodiments, the formula for the exponential decay function is shown as formula (5):

Where Δt is a time interval (i.e., a difference between a time at which the cooperation occurs and a current time), and λ is a decay coefficient for controlling a speed of time decay. By giving a higher weight to recent collaboration, it can be ensured that the allocation result reflects the current collaboration state. For example, the last collaboration may be significantly weighted over the collaboration record one year ago, thereby improving the timeliness of the assignment result. If developers A and B collaborate frequently within the last 1 week, their collaboration weight will be significantly higher than the collaboration record 1 year ago, then the ranking will be top. In some embodiments, if a certain code task is modified in the near future, then the ordering of that code task will also be forward.

In some embodiments, the attention weights 720 may include extracting alarm feature vectors, feature fusion calculating weights, and dynamically adjusting weight distribution, which is a method of calculating attention weights based on multidimensional features (such as importance of code modules, skill matching of developers, historical collaboration intensity, etc.), and is capable of dynamically adjusting priority of code task allocation for error alarms.

In some embodiments, at 721, alarm feature vector extraction, i.e., extracting feature vectors associated with alarms, is performed. For example, the alert feature vector is extracted based on the frequency of modification of the code module, the complexity, importance, or level of the code module or code task, and the skill tags, historical contributions, and current workload of the developer.

In some embodiments, feature fusion calculation weights are performed at 722, i.e., the composite weights are calculated using a feature fusion function (e.g., a weighted average or neural network model). For example, a weighted average or neural network model may be used to calculate the composite weights. In some embodiments, the input features may be weighted using an attention mechanism (Attention Mechanism) to calculate the composite weight. The calculation formula is as follows:

Wherein, Is a Query vector (Query) representing a feature vector of an alarm; is a Key vector (Key), representing feature vectors of the developer and the code module; Is the dimension of the feature vector for normalization.

In some embodiments, at 723, dynamically adjusting the weight distribution, i.e., dynamically adjusting the weight distribution, is performed such that the key features have a greater impact on the distribution results. For example, when the importance of a code module or code task is high, the collaboration weight associated with that module may be automatically increased.

In some embodiments, the time decay model and the attention weight may be combined to dynamically calculate the collaboration relationship and assign priorities. The calculation formula of the time sequence attention fusion is as follows:

Wherein, As a base collaboration intensity (e.g., historical collaboration frequency); As a time attenuation factor, reflecting the timeliness of the cooperation; the influence of the multidimensional features can be integrated for the attention weighting.

By the method for comprehensively considering the historical data and the real-time state, the weight of the cooperative relationship can be dynamically adjusted, and the allocation strategy is ensured to adapt to the real-time change of the team state so as to output the optimal allocation decision.

Assume that the code for the error alert relates to "order management module" and that the alert type is "high priority defect repair". The developer information comprises that the contribution degree of the developer A to the order management module is 0.8, 3 collaboration records exist in the last 1 week, and the contribution degree of the developer B to the order management module is 0.6, and no collaboration record exists in the last 1 week. The time decay coefficient λ=0.1. The matching degree of the alarm feature and the developer A is 0.9, and the matching degree of the alarm feature and the developer B is 0.7.

Then, in the time decay calculation, TIMEDECAY _a=0.74 for developer a and TIMEDECAY _b=0.05 for developer B.

Meanwhile, attentionWeight _A =0.55 for developer a and AttentionWeight _B =0.45 for developer B can be obtained according to the following formula (8).

Meanwhile, according to formula (7), finalScore _A =0.326 of developer a and FinalScore _B =0.0135 of developer B can be obtained. Thus, developer a may be assigned a significantly higher priority than developer B, and then an alarm task may be assigned to developer a, ignoring other possible factors (e.g., whether the developer is idle at the current time).

The method comprises the steps of assuming that a certain code task has a database connection timeout error, the current task load of a developer A is lower, the score is 0.2, the load of a developer B is higher, the score is 0.8, the developer A is in working time, the score is 1, the developer B is in non-working time, the score is 0, the "database optimization" skill weight of the developer A is 0.9, and the developer B is 0.7.

Then it can be derived that developer a's composite score =Developer B, composite score =. The code task for which the database connection times out may be assigned to developer a at this time.

If on this basis developer a fails to respond to the code task of the alarm within a prescribed time. Then the status of the other developers can be re-evaluated, the next highest composite score developer (e.g., developer C) can be selected, and the code tasks for the alarm upgrades can be re-assigned to developer C.

As can be seen from the above description with respect to fig. 7, the time-series attention mechanism can dynamically adjust the collaboration relationship and assign priorities by introducing a time decay model and attention weight calculation.

FIG. 8 illustrates a schematic diagram of intelligent allocation and dynamic adjustment 800 of model-based code tasks, according to an embodiment of the present disclosure. After the data foundation construction, dynamic state sensing and time sequence attention calculation are completed, intelligent distribution can be realized by means of a comprehensive scoring model, and adjustment of a dynamic mechanism is supported. As shown in fig. 8, intelligent allocation and dynamic adjustment 801 may be implemented by a composite scoring model 810 and a dynamic adjustment mechanism 820.

Referring to fig. 8, the functionality of the composite scoring model 810 may be implemented in conjunction with collaborative network scoring 811, skill matching 812, and time-decay factors 813. In some embodiments, the calculation of the composite score may be as shown in equation (9) below:

Wherein BaseScore is the base collaboration intensity, TIMEDECAY is the time decay factor, attentionWeight is the attention weight, expertiseLevel is the specialty score.

By the multi-dimensional comprehensive score calculation method, the accuracy and fairness of code tasks of error alarm assigned can be ensured.

With continued reference to FIG. 8, dynamic adjustment mechanism 820 may be implemented with task upgrade procedure 821 and reassignment mechanism 822. In some embodiments, the task upgrade procedure 821 and the reassignment mechanism 822 may be automatically triggered when a developer who is supposed to be assigned cannot respond in time. For example, if developer a does not process the code task of the error alarm within a specified time, the code task of the error alarm may be assigned to the next best candidate. By the method, the influence on the overall efficiency caused by delayed response of individual developers can be avoided, and the reliability of processing the code tasks of error alarm is improved.

Fig. 9 illustrates a block diagram of an apparatus 900 for distributing code tasks, according to some embodiments of the disclosure. As shown in fig. 9, the apparatus 900 includes a data base determination module 902 configured to determine a data base for the submission history information, including task information, personnel information, and personnel skill information, based on the submission history information of the code tasks, the data base including at least one of an ownership portrayal of each code task and a modification behavior pattern for each code task. The apparatus 900 further comprises a knowledge-graph determination module 904 configured to determine a knowledge graph associated with the person, skill, and code task based on the determined data basis by a target model configured with a time-decay model and an attention mechanism, the knowledge graph comprising skill, workload, collaborative relationship, and current state of the person. The apparatus 900 further comprises a person set determination module 906 configured to determine a person set matching each code task based on each code task and the knowledge-graph by the object model. In addition, the apparatus 900 further includes a person assignment module 908 configured to assign, by the object model, the code task to persons matching the code task based on a composite score of each person in the set of persons, the composite score being determined based on the knowledge graph and the time decay factor of each person, in response to the code task error.

Fig. 10 illustrates a block diagram of an electronic device 1000, in accordance with certain embodiments of the present disclosure. Fig. 10 illustrates a block diagram of an electronic device 1000, which device 1000 may be a device or apparatus described in embodiments of the disclosure, in accordance with certain embodiments of the disclosure. As shown in fig. 10, the device 1000 includes a Central Processing Unit (CPU) and/or a Graphics Processing Unit (GPU) 1001 that can perform various suitable actions and processes in accordance with computer program instructions stored in a read-only memory (ROM) 1002 or loaded from a storage unit 1008 into 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, ROM 1002, and RAM 1003 are connected to each other by a bus 1004. An input/output (I/O) interface 1005 is also connected to bus 1004. Although not shown in fig. 10, the device 1000 may also include a coprocessor.

The various components in device 1000 are connected to I/O interfaces 1005, including an input unit 1006, e.g., keyboard, mouse, etc., an output unit 1007, e.g., various types of displays, speakers, etc., a storage unit 1008, e.g., magnetic disk, optical disk, etc., and a communication unit 1009, e.g., network card, modem, wireless communication transceiver, etc. Communication unit 1009 allows device 1000 to exchange information/data with other devices via a computer network, such as the internet, and/or various telecommunications networks.

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

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 having computer readable program instructions embodied thereon for performing aspects of the present disclosure.

The computer readable storage medium may be a tangible device that can hold and store instructions for use by an instruction execution device. The computer readable storage medium may be, for example, but not limited to, an electronic storage device, a magnetic storage device, an optical storage device, an electromagnetic storage device, a semiconductor storage device, or any suitable combination of the foregoing. More specific examples (a non-exhaustive list) of the computer-readable storage medium include a portable computer diskette, 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 disc read-only memory (CD-ROM), a Digital Versatile Disc (DVD), a memory stick, a floppy disk, a mechanical encoding device, punch cards or intra-groove protrusion structures such as those having instructions stored thereon, and any suitable combination of the foregoing. Computer-readable storage media, as used herein, are not to be construed as transitory signals per se, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through waveguides or other transmission media (e.g., optical pulses through fiber optic cables), or electrical signals transmitted through wires.

The computer readable program instructions described herein may be downloaded from a computer readable storage medium to a respective computing/processing device or to an external computer or external storage device over a network, such as the internet, a local area network, a wide area network, and/or a wireless network. The network may include copper transmission cables, fiber optic transmissions, wireless transmissions, routers, firewalls, switches, gateway computers and/or edge servers. The network interface card or network interface in each computing/processing device receives computer readable program instructions from the network and forwards the computer readable program instructions for storage in a computer readable storage medium in the respective computing/processing device.

The computer program instructions for performing the operations of the present disclosure can be assembly instructions, instruction Set Architecture (ISA) instructions, machine-related instructions, microcode, firmware instructions, state setting data, or source or object code written in any combination of one or more programming languages, including an object-oriented programming language and conventional procedural programming languages. The computer readable program instructions may be executed entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the remote computer or server. In the case of remote computers, the remote computer may be connected to the user's computer through any kind of network, including a Local Area Network (LAN) or a Wide Area Network (WAN), or may be connected to an external computer (for example, through the Internet using an Internet service provider). In some embodiments, aspects of the present disclosure are implemented by personalizing electronic circuitry, such as programmable logic circuitry, field Programmable Gate Arrays (FPGAs), or Programmable Logic Arrays (PLAs), with state information of computer readable program instructions, which can execute the computer readable program instructions.

These computer readable program instructions may be provided to a processing unit of a general purpose computer, special purpose computer, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processing unit of the computer or other programmable data processing apparatus, create means for implementing the functions/acts specified in the flowchart and/or block diagram block or blocks. These computer readable program instructions may also be stored in a computer readable storage medium that can direct a computer, programmable data processing apparatus, and/or other devices to function in a particular manner, such that the computer readable medium having the instructions stored therein includes an article of manufacture including instructions which implement the function/act specified in the flowchart and/or block diagram block or blocks.

The computer readable program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other devices to cause a series of operational steps to be performed on the computer, other programmable apparatus or other devices to produce a computer implemented process such that the instructions which execute on the computer, other programmable apparatus or other devices implement the functions/acts specified in the flowchart and/or block diagram block or blocks.

The flowcharts and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of devices, methods and computer program products according to various embodiments of the present disclosure. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of instructions, which comprises one or more executable instructions for implementing the specified logical function(s). In some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two consecutive blocks may in fact be performed substantially in parallel, and they may sometimes be performed in the reverse order, depending on the functionality involved. It will also be noted that each block of the block diagrams and/or flowchart illustration, and combinations of blocks in the block diagrams and/or flowchart illustration, can be implemented by special purpose hardware-based systems which perform the specified functions or acts, or combinations of special purpose hardware and computer instructions.

The foregoing description of the embodiments of the present disclosure has been presented for purposes of illustration and description, and is not intended to be exhaustive or limited to the embodiments disclosed. Many modifications and variations will be apparent to those of ordinary skill in the art without departing from the scope and spirit of the various embodiments described. The terminology used herein was chosen in order to best explain the principles of the embodiments, the practical application, or the technical improvement of the technology in the marketplace, or to enable others of ordinary skill in the art to understand the embodiments disclosed herein.

Some example implementations of the present disclosure are listed below.

Example 1. A method for distributing code tasks, comprising:

Determining a data basis for the submission history information based on the submission history information of the code tasks, the submission history information including task information, personnel information, and personnel skill information, the data basis including at least one of an ownership portrayal of each code task and a modified behavior pattern for each code task;

Determining, by a target model, a knowledge graph associated with the person, skill, and code task based on the determined data basis, the target model configured with a time decay model and an attention mechanism, the knowledge graph including skill, workload, collaboration relationship, and current state of the person;

Determining a set of people matching each code task based on each code task and the knowledge graph by the object model, and

In response to code task errors, assigning, by the object model, the code tasks to persons matching the code tasks based on a composite score for each person in the set of persons, the composite score determined based on the knowledge graph and a time decay factor for each person.

Example 2. The method of example 1, wherein determining the data basis for the commit history information based on commit history information of the code task comprises:

in response to each code task being incorporated into a production branch, the data base for the commit history information is determined based on a rotation index.

Example 3 the method of any of examples 1-2, wherein responsive to each code task being merged into a production branch, determining the data base for the commit history information based on a rotation index comprises:

Determining ownership portraits for each code task based on said submission history information, and

Determining a modified behavior pattern for each code task based on the submission history information, and

Based on the ownership portrayal and the modified behavior pattern, a collaboration network is determined, the collaboration network indicating a strength of collaboration relationship between each person.

Example 4 the method of any of examples 1-3, wherein determining an ownership portrait for each code task based on the submission history information comprises:

Determining a contribution degree of each person to each code task based on the submission history information;

Ordering for each code task based on a time decay model, and

Based on the contribution, for each code task ordered, a first responsible person and a second responsible person for each code task are identified.

Example 5. The method of any of examples 1-4, wherein determining a modified behavior pattern for each code task based on the submission history information comprises:

determining a task change type for each code task based on the submission history information, the task change type including at least one of functional development, defect repair, and task reconstruction;

Determining skill characteristics of each person and engagement of each person with respect to each code task based on the submission history information, and

And determining a skill feature image for each person based on the task change type for each code task, the skill feature of each person and the participation degree of each person for each code task.

Example 6 the method of any of examples 1-5, wherein determining a collaboration network based on the ownership portraits and the modified behavior patterns comprises:

determining a collaboration history of each person with another person, the collaboration history including a collaboration frequency and a collaboration scope, and

Determining a collaboration relationship graph based on the collaboration history, nodes of the collaboration relationship graph indicating persons, edges of the collaboration relationship graph indicating collaboration relationship weights, and

And determining core personnel and professionals based on the collaboration relation graph.

Example 7. The method of any of examples 1-6, wherein determining, by the objective model, a knowledge-graph associated with the person, skill, and code task based on the determined data basis comprises:

determining at least one of a technical understanding, a developing intent for each code task based on the determined data basis by a language model, and

The knowledge graph is updated by a language model based on the technical understanding for each code task, the development intent.

Example 8 the method of any of examples 1-7, wherein determining, by the object model, a set of people matching each code task based on each code task and the knowledge-graph comprises:

Determining a current workload of each person for each person in the set of persons associated with each code task, and

Determining, for each person in the set of persons associated with each code task, whether each person is in a responsive state, and

Determining a current skill state of each person for each person in the set of persons associated with each code task, and

A set of people matching each code task is determined based on the current workload, the respondable status, and the composite score for the current skill status for each person associated with each code task.

Example 9. The method of any of examples 1-8, wherein assigning, by the goal model, the code task to a person matching the code task based on the composite score of each person in the set of persons in response to a code task error comprises:

determining, by the object model, a weight for each of the following based on the priority of the code tasks:

a weight of a current workload for each person in the set of persons that matches the code task;

A weight of a current responsive status of each person in the set of persons matching the code task, and

A weight for the current skill state of each person in the set of persons that matches the code task;

Determining a composite score for each person in the set of persons matching the code task based on the composite weight of the weight of each item and the time decay factor of each person in the set of persons matching the code task, and

And distributing the code task to personnel matched with the code task based on the comprehensive score.

Example 10. The method of any of examples 1-9, the integrated weight is determined by the target model configured with a temporal decay model and an attention mechanism, the temporal decay coefficient is determined based on an exponential decay function and a collaborative relationship weight.

Example 11. The method of any one of examples 1-10, further comprising:

re-determining a composite score for each person in the set of persons matching the code task in response to the person matching the code task not responding to the allocation within a predetermined time, and

And reassigning the code task to a person who matches the code task based on the determined composite score.

Example 12. An apparatus for assigning code tasks, comprising:

A data base determination module configured to determine a data base for code tasks based on the submission history information of the code tasks, the submission history information including task information, personnel information, and personnel skill information, the data base including at least one of an ownership portrait for each code task and a modified behavioral pattern for each code task;

A knowledge-graph determination module configured to determine a knowledge graph associated with the person, skill, and code task based on the determined data basis by a target model configured with a time-decay model and an attention mechanism, the knowledge graph including skill, workload, collaboration relationship, and current state of the person;

a person set determination module configured to determine a person set matching each code task based on each code task and the knowledge graph by the object model, and

A composite score determination module configured to assign, by the goal model, the code task to persons matching the code task based on a composite score of each person in the set of persons, the composite score determined based on the knowledge graph and a time decay factor of each person, in response to a code task error.

Example 13 the apparatus of example 12, wherein the data base determination module comprises:

A first determination module configured to determine the data basis for the commit history information based on a rotation index in response to each code task being merged into a production branch.

Example 14 the apparatus of any one of examples 12-13, wherein the first determination module comprises:

A second determination module configured to determine ownership portraits of each code task based on the commit history information, and

A third determination module configured to determine a modified behavior pattern for each code task based on the submission history information, and

A fourth determination module configured to determine a collaboration network based on the ownership portraits and the modified behavior patterns, the collaboration network indicating a strength of collaboration relationship between each person.

Example 15 the apparatus of any one of examples 12-14, wherein the second determination module comprises:

a fifth determination module configured to determine a contribution of each person to each code task based on the submission history information;

A ranking module configured to rank for each code task based on a time decay model, and

A representation module configured to identify, for each code task ordered, a first responsible person and a second responsible person for each code task based on the contribution.

Example 16 the apparatus of any one of examples 12-15, wherein the third determination module includes:

A sixth determination module configured to determine a task change type for each code task based on the submission history information, the task change type including at least one of function development, defect repair, and task reconstruction;

A seventh determination module configured to determine skill characteristics of each person and participation degree of each person for each code task based on the submission history information, and

And an eighth determining module configured to determine a skill feature image for each person based on the task change type for each code task, the skill feature of each person, and the participation degree of each person for each code task.

Example 17 the apparatus of any one of examples 12-16, wherein the fourth determination module comprises:

A ninth determination module configured to determine a collaboration history of each person with another person, the collaboration history including a collaboration frequency and a collaboration range, and

A tenth determination module configured to determine a collaboration relationship graph, nodes of the collaboration relationship graph indicating persons, edges of the collaboration relationship graph indicating collaboration relationship weights, based on the collaboration history, and

An eleventh determination module configured to determine a core person and a professional person based on the collaboration relationship diagram.

Example 18 the apparatus of 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, a development intent for each code task based on the determined data basis by a language model, and

An updating module configured to update the knowledge graph by a language model based on the technical understanding for each code task, the development intent.

Example 19 the apparatus of any one of examples 12-18, wherein the person set determination module includes:

A thirteenth determination module configured to determine, for each person in the set of persons associated with each code task, a current workload of each person, and

A fourteenth determination module configured to determine, for each person in the set of persons associated with each code task, whether each person is in a responsive state, and

A fifteenth determination module configured to determine, for each person in the set of persons associated with each code task, a current skill state of each person, and

A sixteenth determination module is configured to determine a set of people matching each code task based on the current workload, the respondable status, and the composite score of the current skill status for each person associated with each code task.

Example 20 the apparatus of any of examples 12-19, wherein the personnel allocation module comprises:

a seventeenth determination module configured to determine, by the target model, a weight for each of the following based on the priority of the code task:

An eighteenth determination module configured to determine a composite score for each person in the set of persons matching the code task based on the composite weight of the weight of each item and the time decay factor of each person in the set of persons matching the code task, and

An assignment module configured to assign the code task to a person who matches the code task based on the composite score.

Example 21 the apparatus of any one of examples 12-20, the synthetic weight determined by the target model configured with a temporal decay model and an attention mechanism, the temporal decay coefficient determined based on an exponential decay function and a collaborative relationship weight.

Example 22 the apparatus of any one of examples 12-21, further comprising:

A redetermining module configured to redetermine a composite score for each person in the set of persons matching the code task in response to the person matching the code task not responding to the allocation within a predetermined time, and

A reassignment module configured to reassign the code task to a person matching the code task based on the redetermined composite score.

Example 23 an electronic device, comprising:

processor, and

A memory coupled with the processor, the memory having instructions stored therein, which when executed by the processor, cause the electronic device to perform actions comprising:

Example 24 the electronic device of example 23, wherein determining the data basis for the submission history information based on the submission history information of the code task includes:

Example 25 the electronic device of any of examples 23-24, wherein responsive to each code task being incorporated into a production branch, determining the data base for the submission history information based on a rotation index includes:

Example 26 the electronic device of any of examples 23-25, wherein determining an ownership portrait for each code task based on the submission history information includes:

Ordering for each code task based on a time decay model, and

Example 27 the electronic device of any of examples 23-26, wherein determining a modified behavior pattern for each code task based on the submission history information includes:

Example 28 the electronic device of any of examples 23-27, wherein determining a collaboration network based on the ownership portraits and the modified behavior patterns comprises:

Example 29 the electronic device of any of examples 23-28, wherein determining, by the target model, a knowledge-graph associated with the person, skill, and code task based on the determined data basis includes:

Example 30 the electronic device of any of examples 23-29, wherein determining, by the object model, a set of people matching each code task based on each code task and the knowledge-graph includes:

Example 31. The electronic device of any of examples 23-30, wherein assigning, by the goal model, the code task to a person matching the code task based on the composite score of each person in the set of persons in response to a code task error comprises:

Example 32 the electronic device of any of examples 23-31, the integrated weight determined by the target model configured with a temporal decay model and an attention mechanism, the temporal decay coefficient determined based on an exponential decay function and a collaborative relationship weight.

Example 33 the electronic device of any of examples 23-32, further comprising:

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

Example 35. A computer program product tangibly stored on a computer-readable medium and comprising computer-executable instructions that, when executed by an apparatus, cause the apparatus to perform the method of any one of examples 1 to 11.

Although the disclosure has been described in language specific to structural features and/or methodological acts, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or acts described above. Rather, the specific features and acts described above are 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; 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.

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 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.

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; 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.

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; 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.

6. The method according to claim 3, wherein determining a collaborative 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.

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; and

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 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.

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 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.

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; and

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; and

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; 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 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.