Man-machine mixed programming software development method

Abstract

The invention provides a man-machine hybrid software development method, which comprises the following steps of: dividing a software development activity into a plurality of tasks, establishing task messages for the tasks, configuring message formats for the task messages, and pulling task attributes of the corresponding tasks for the task messages; the human or the robot issues the task message to a task pool; the robot performs task screening in the task pool to identify and get a target task; and the robot obtains the content of the target task and runs the target task. The robot part is enabled to undertake tasks in the aspects of architecture design, software development, testing and the like, and the labor burden of software engineering personnel in project development is reduced. The tasks are screened when the robot receives the tasks in the task pool, on one hand, it can be guaranteed that the task execution process of the robot is conducted smoothly, and on the other hand, the task execution efficiency of the robot can be effectively improved.

Description

Technical Field

[0001] The present invention relates to the technical field of software development, and in particular to a human-machine mixed software development method. Background Art

[0002] Driven by big data, various LLM (Large Language Model) software development scenarios, especially GPT models, have demonstrated powerful natural language processing capabilities, including code writing capabilities.

[0003] Complex logic problems are a major challenge for existing LLMs. The mainstream approach is to use Prompt+Thought to decompose complex logic problems, where CoT (Chain of Thought) gradually outputs the intermediate state of reasoning to increase the probability of obtaining correct reasoning results. SCoT (Struct Chain of Thought) is a special version of CoT, which uses structured intermediate states such as sequence, branch, and loop to enhance the code generation function. CoT-SC (Chain of Thought–Self Consistency) uses a method of parallel calculation of multiple CoTs and then voting to improve the stability of the generated results. Using multiple unrelated parallel calculations, CoT-SC consumes a lot of resources, so ToT (Tree of Thought) adopts a tree-like backtracking reasoning state transition method, and applies algorithms such as DFS and BFS for search optimization. GoT uses graph reasoning, interacts with LLM through prompter, parser, and uses LLM or human judgment to score the intermediate reasoning state. In addition to the above multi-step reasoning method, there is also AoT that attempts to reason through single-step IO, which displays the algorithm search and backtracking process in one shot or few shots, and can give the answer with only one LLM input and output.

[0004] Another major challenge of LLM is long context input. Model extrapolation ability is the ability to use longer lengths than samples during training for reasoning. Extrapolating longer token sequences leads to a more uniform distribution of attention, which is different from the training process and will affect the generation effect. ALIBI proposed a smooth attention method, which introduced relative position parameters when calculating the attention score, weakening the impact of attention generalization. In addition to directly optimizing local attention, another way to optimize extrapolation ability is to improve position encoding. RoPE (Rotary of Position Embedding) uses rotated position encoding to obtain a small amount of model extrapolation ability, which can extrapolate 10% of the length without deteriorating the effect. Position interpolation converts the integer position encoding m to mL / L' based on RoPE, where L' represents a longer context window. This method prevents the position encoding from exceeding the range used during training. Similar to position interpolation, CodeLlama increases the cycle period θ from 10,000 to 1,000,000 and applies this strategy in the fine-tuning stage. NTK-aware Scaled RoPE combines direct extrapolation with position interpolation to construct a scaling formula for high-frequency extrapolation and low-frequency interpolation, achieving capabilities similar to other methods that require fine-tuning without fine-tuning.

[0005] In order to improve the code generation capability of LLM, in addition to improving the ability to solve complex logic problems and long text input, it is also necessary to optimize for code scenarios and engineering scenarios. For example, through PSM and SPM training, the model can acquire the ability to fill in code. StarCoder introduces <|endoftext|>,<fim_suffix> ,<jupyter_start> Special tokens such as , etc. are used to train various code structures and optimize the model's ability to process code modules. MetaGPT builds a multi-agent LLM from an engineering perspective, allowing GPT4 to serve as product manager, architect, project manager, engineer, QA and other roles in engineering projects, covering demand analysis, architecture design, system design, code writing, functional testing and other aspects of engineering projects, and can automatically generate a series of project files from the original project description.

[0006] Despite the above-mentioned progress of LLM in the field of code generation, it is still difficult to apply LLM to actual engineering projects. On the one hand, the amount of code in actual engineering projects is too large to be able to be extrapolated by existing models. On the other hand, due to the complexity of human-computer interaction in actual engineering projects, human engineers cannot provide complex prerequisites in a single input when using LLM. In addition, most of the existing code robots are code generation robots that can only increase the coding speed of programmers. In software development projects, the code must also go through testing, verification and other processes before delivery. Existing code robots have obvious shortcomings in assisting people in testing and quality control. Summary of the invention

[0007] In order to overcome the above technical defects, the purpose of the present invention is to provide a task publishing, receiving and scheduling method for a human-machine hybrid programming team that uses robots to improve efficiency under the convenient control of humans.

[0008] The present invention discloses a human-machine hybrid software development method, comprising the following steps: dividing software development activities into a plurality of tasks, establishing task messages for the tasks, configuring message formats for the task messages, and extracting task attributes of the corresponding tasks for the task messages; a human or a robot issues the task messages to a task pool; a robot screens tasks in the task pool to identify target tasks and collects them; and the robot obtains the content of the target tasks and runs the target tasks.

[0009] Preferably, the robot screens tasks in the task pool to identify and claim target tasks, including: the robot screens tasks in the task pool according to the robot's role label, attribute label, resource measurement value and task priority to identify and claim target tasks.

[0010] Preferably, the robot screens tasks in the task pool according to the attribute labels to identify target tasks and receive them, including: the attribute labels include a large language model and an operation method of the large language model, the robot obtains the fitness with all tasks in the task pool based on its own attribute labels, eliminates tasks with fitness less than a preset threshold, and obtains a set of tasks that can be received.

[0011] Preferably, the robot screens tasks in the task pool according to the attribute labels to identify the target task and claim it, including: sorting the receivable task set from high to low according to the fitness degree, and claiming the tasks in the receivable task set in turn as the target task.

[0012] Preferably, before sorting the receivable task sets from high to low according to the degree of fitness, it also includes: the robot screening tasks in the task pool according to the priority of the tasks, wherein: sorting the receivable task sets from high to low according to the priority of the tasks, the priority includes several urgency levels, so as to obtain the task sets of several different urgency levels; picking up the task sets of several different urgency levels in turn; wherein, in the task set of the same urgency level, sorting is performed from high to low according to the degree of fitness, and the robot picks up the tasks in the task set of the same urgency level as the target tasks in turn.

[0013] Preferably, before the robot performs task screening in the task pool according to the priority of the attribute tag tasks, the robot also includes: the robot performs task screening in the task pool according to the role tag and the resource measurement value to match and obtain tasks that correspond to the role tag and the resource measurement value meets the running requirements.

[0014] Preferably, the robot screens tasks in the task pool to identify and claim the target task, including: the robot detects the task status in the task pool in real time; if a new task is added to the task pool, the robot actively screens tasks in the task pool to identify and claim the target task; when the robot has processed the target task and is in an idle state, the robot actively screens tasks in the task pool to identify and claim the target task.

[0015] Preferably, the task attributes of the task corresponding to the task message pulling include: the task attributes of the task corresponding to the task message pulling according to the context environment; the context environment includes a software development and testing environment and a software development environment; wherein: when it is a software development and testing environment, the requirements are written in the form of a dialog box in the code editing window and the test class tasks are published, or the test class tasks are published for the selected code through shortcut keys; when it is a software development environment, the tasks are published by writing files or functions.

[0016] Preferably, the priority level of the test-type task in which the requirements are written and published in the form of a dialog box is the highest priority; when the task pool receives the task, it will interrupt other priority tasks being executed by the robot.

[0017] Preferably, the publishing of the task by writing a file or a function includes: pulling the function of the task according to the functional module requirement document, and pulling the function interface of the task according to the class and interface design diagram.

[0018] Compared with the prior art, the above technical solution has the following beneficial effects:

[0019] 1. The present invention sets a robot to undertake part of the software development activities, so that the robot partially undertakes tasks such as architecture design, software development, and testing, thereby reducing the labor burden of software engineers in project development (including individual repetitive labor and collective repetitive labor, such as a sorting algorithm that a programmer has not written but has been written by many other programmers), so that humans can focus on innovation and management;

[0020] 2. By setting the robot to screen tasks when it receives tasks in the task pool, on the one hand, it can ensure the smooth progress of the robot's task execution process, and on the other hand, it can effectively improve the efficiency of the robot's task execution. BRIEF DESCRIPTION OF THE DRAWINGS

[0021] Figure 1 A schematic diagram of the process flow of the human-machine hybrid software development method provided by the present invention;

[0022] Figure 2 A transition diagram of the task status at each stage of the human-machine hybrid software development method provided by the present invention;

[0023] Figure 3 This is an example of the message format in the first embodiment of the human-machine hybrid software development method provided by the present invention. DETAILED DESCRIPTION

[0024] The advantages of the present invention are further described below in conjunction with the accompanying drawings and specific embodiments.

[0025] Exemplary embodiments will be described in detail herein, examples of which are shown in the accompanying drawings. When the following description refers to the drawings, the same numbers in different drawings represent the same or similar elements unless otherwise indicated. The embodiments described in the following exemplary embodiments do not represent all embodiments consistent with the present disclosure. Instead, they are merely examples of devices and methods consistent with some aspects of the present disclosure as detailed in the appended claims.

[0026] The terms used in this disclosure are for the purpose of describing specific embodiments only and are not intended to limit the disclosure. The singular forms of "a", "said" and "the" used in this disclosure and the appended claims are also intended to include plural forms unless the context clearly indicates otherwise. It should also be understood that the term "and / or" used herein refers to and includes any or all possible combinations of one or more associated listed items.

[0027] It should be understood that although the terms first, second, third, etc. may be used in the present disclosure to describe various information, such information should not be limited to these terms. These terms are only used to distinguish the same type of information from each other. For example, without departing from the scope of the present disclosure, the first information may also be referred to as the second information, and similarly, the second information may also be referred to as the first information. Depending on the context, the word "if" as used herein may be interpreted as "at the time of" or "when" or "in response to determining".

[0028] In the description of the present invention, it is necessary to understand that the terms "longitudinal", "lateral", "up", "down", "front", "back", "left", "right", "vertical", "horizontal", "top", "bottom", "inside", "outside", etc., indicating the orientation or position relationship, are based on the orientation or position relationship shown in the accompanying drawings, and are only for the convenience of describing the present invention and simplifying the description, rather than indicating or implying that the device or element referred to must have a specific orientation, be constructed and operated in a specific orientation, and therefore cannot be understood as a limitation on the present invention.

[0029] In the description of the present invention, unless otherwise specified and limited, it should be noted that the terms "installed", "connected" and "connected" should be understood in a broad sense. For example, it can be a mechanical connection or an electrical connection, or it can be the internal connection between two components. It can be a direct connection or an indirect connection through an intermediate medium. For ordinary technicians in this field, the specific meanings of the above terms can be understood according to the specific circumstances.

[0030] In the following description, the suffixes such as "module", "component" or "unit" used to represent elements are only used to facilitate the description of the present invention, and have no specific meanings. Therefore, "module" and "component" can be used interchangeably.

[0031] The present invention can be applied to generative artificial intelligence, human-computer interaction, software engineering process control, natural language processing, computer-aided design and other fields, and aims to improve the production efficiency of software development by building a hybrid development team composed of humans and numerous robots with clear division of labor to collaboratively develop software projects. It includes methods for task release, task collection and task scheduling of human-computer hybrid programming.

[0032] Specifically, the present invention discloses a human-machine hybrid software development method, see attached Figure 1 , including generating tasks, publishing tasks, and receiving tasks:

[0033] - Generate tasks, divide software development activities into several tasks, create task messages for tasks, configure message formats for task messages, and pull task attributes of corresponding tasks for task messages;

[0034] -Publish tasks. Humans or robots send task messages to the task pool;

[0035] - Receive tasks. The robot screens tasks in the task pool to identify the target task and receive it. The robot obtains the content of the target task and runs the target task.

[0036] In the first part, the entire software development activity is first switched to various tasks according to the specification requirements of the third level (explicit level, including 20 processes) of the Capability Maturity Model Integration (CMMI) in order to better organize and manage software projects. The classification of the present invention is the classification of tasks that can be completed by robots, for example, including: 1) system design: architecture design, class and interface design; 2) coding: code completion, code optimization; 3) testing: unit testing, functional testing, performance testing, regression testing, and automated testing. The various tasks that are divided have states, including at least the following states: to be received, to be processed, in processing, processing failed, processing successfully, human judgment processing failed, feedback cannot be processed, and human judgment processing successfully. Among them, feedback cannot be processed and human judgment processing successfully is the termination state of the task, and the task object will be released after reaching the termination state.

[0037] The transition diagram of task status at each stage is shown in the attached figure. Figure 2 As shown. In a preferred embodiment, a human can interrupt a task being processed by a robot, thereby changing the task status from being processed to pending, and the pending task will not be returned to the task pool. A human can withdraw the pending task that the robot has received, returning it to the task pool and changing it to the pending status.

[0038] Next, in the task release phase, a unified message format needs to be designed for the task. In a preferred embodiment, the task message format is set to the following parts: 1) Task type: tasks can be divided into different types, such as the classification above; 2) Task priority: the urgency or priority of the task to determine the order of executing the task; 3) Task publisher: information about the person or entity that publishes the task to determine the result return channel; 4) Task deadline: by when the task needs to be completed to ensure timely delivery; 5) Task instructions: describe the task objectives and generally explain the nature and objectives of the task; 6) Task file: can be a requirement document or a code file to be completed; 7) Task constraints: tasks may have special conditions or requirements, such as a specific context environment, a specific interface, a specific variable, a sample, a specific API, or a functional requirement; 6) Task deadline: by when the task needs to be completed to ensure timely delivery. In a preferred embodiment, the task message format can be transmitted in the form of a json string, and task messages with a unified format are added to the same task pool.

[0039] During the task release phase, you also need to configure various attributes of the task based on the context. For example: 1) When a task is required to have specific functions, you can get the corresponding instructions from the instruction template; 2) When a function is required, you can get the available function interface from the class and interface design diagram to get the function; 3) When a sample is required, you can get the sample from the sample library or search for the code snippet in the context; 4) When a description is required, it can be extracted from the architecture design and function design documents.

[0040] The context environment here includes, for example, a software development and testing environment and a software development environment. Different release forms can be selected according to different context environments.

[0041] For example, when developing a test environment for software, you can write requirements and publish test tasks in the form of a dialog box in the code editing window. Specifically, call up a dialog box in the code editing window, enter the task instruction (one of the message formats), and the system will automatically build a task message json string and publish the task. In addition, in the dialog box, you can also use the @operation and @robot identity tags to specify the robot to execute the task published through the dialog box. The task published through the dialog box can be a test or optimization requirement for a function in the file. The task type will be marked as unit test or optimization. If a robot with inappropriate capabilities is specified, the system will prompt that the robot is not suitable for performing such tasks and recommend a robot suitable for the task.

[0042] In addition, when developing a test environment for software, you can also use shortcut keys (such as the right mouse button) to publish test tasks for the selected code. That is, select a section of code with the mouse, and then submit the test requirements to the selected code by right clicking or using shortcut keys. The task message will be automatically constructed by the system and submitted to the task pool.

[0043] When it is a software development environment, tasks can be published by writing files or functions. Specifically, the functions of the task can be pulled out according to the functional module requirement document, and the function interface of the task can be pulled out according to the class and interface design diagram. Among them, the function description of the file can be written in the form of a comment at the top of the file; the function description of the function can be written in the form of a comment above the function, or below the function name, at the top of the function, in the form of a comment; the function description of the folder can be written in the folder as a description file with a specific name.

[0044] Furthermore, the priority level of the test task that is written and published in the form of a dialog box is the highest priority and needs to be processed in real time. When the task pool receives the task, it will interrupt other priority tasks that the robot is executing. Furthermore, if the robot is executing a real-time task, the user is asked whether to force interruption or termination of other real-time tasks, that is, the output of the robot's execution task is displayed in the code editing window, and humans can decide whether to accept it.

[0045] In the second part, both humans and robots can publish tasks, and the publisher attribute tag of the task can be used to record the source of the task. Preferably, the priority of tasks published by humans is higher than that of tasks published by robots. Another preferred embodiment is that tasks published by robots can reach a termination state without human confirmation, thereby improving development efficiency.

[0046] The robot here has its own role label, attribute label, and resource measurement value. The role label refers to the identity label set for the robot for easy identification, which can be a name, number, or virtual image. The attribute label includes the LLM model used by its robot and the method of operating the LLM model (also known as the Thoughts method). Examples of LLM models in software development are: 1) GPT4, 2) CodeL l ama, 3) WizardCoder, 4) Starcoder, 5) CodeT5, 6) Stab leCode, 7) CodeGen, etc. Examples of Thoughts methods for operating LLM models are: 1) CoT: natural language reasoning that guides several intermediate reasoning states. 2) CoT-SC: multiple CoTs vote. 3) ToT: tree-like (backtrackable) reasoning + search algorithm. 4) GoT: graph reasoning interacts with LLM through prompt and parse, using LLM or manual scoring. 5) SCoT: Generate structured intermediate reasoning states. 6) AoT: Display the algorithm search and backtracking process in one shot / few shot, and give the answer with one LLM input and output. The above models and Thoughts methods are not one-to-one correspondence, but are matched according to the model training process and the robot's execution capability. Resource metrics refer to the measurement of the robot's hardware and software resources, which are used to evaluate the robot's performance, capabilities, and resource utilization.

[0047] Therefore, preferably, when a task is released, constraints on the robot that receives the task can be set, for example: limiting the task to test robots, limiting the task to robots with executable LLM models with an executable size of more than 10B, limiting the task to robots "Xiao Ming", and other constraints.

[0048] The task pool is responsible for unified management and scheduling of tasks, and can be used in multi-threaded, concurrent programming or asynchronous programming environments to improve the execution efficiency and management of tasks. The task pool, for example, includes the following main components: 1) Task queue: The task pool usually maintains a task queue to store tasks to be executed. 2) Thread pool and process pool: used to manage threads or processes that execute tasks. Thread pools are usually used in multi-threaded environments, while process pools are used in multi-process environments. 3) Task scheduler: used to select suitable tasks and assign them to available threads or processes for execution. Task schedulers usually use scheduling algorithms such as first-in-first-out (FIFO) or priority scheduling. 4) Task completion notification mechanism: used to notify the main program or other tasks after the task is completed. It can be an event, callback function or message queue, etc.

[0049] In the third part, the robot can autonomously pick up tasks from the task pool, and when picking up tasks, the robot will search and filter the tasks in the task pool to obtain tasks that can actually be executed, also known as target tasks. In the task pool, the robot can filter tasks based on the robot's role label, attribute label, resource measurement value, and task priority to identify and pick up target tasks.

[0050] Based on different LLM and Thought methods, the adaptability of robots to various tasks will be different, and the robots will sort the suitability of various tasks accordingly. When accepting tasks, the robot first excludes the task types that are beyond its capability range, and then accepts tasks from high to low according to the task priority and task type suitability.

[0051] In a preferred embodiment, the robot first screens tasks in the task pool according to the role tag and resource measurement value to match and obtain tasks corresponding to the role tag and with resource measurement values ​​that meet the running requirements. For example, if the task attributes in the release phase are set to be claimed by a designated robot "Xiao Ming", robots other than "Xiao Ming" cannot claim the task. If the size of the LLM required to execute the task exceeds the robot's capacity (resource measurement value), the robot cannot claim the task.

[0052] Next, the robot obtains the compatibility with all tasks in the task pool based on its own attribute labels (large language model and the operation method of the large language model), eliminates tasks with a compatibility less than a preset threshold, and obtains a set of available tasks.

[0053] Then the robot screens the tasks in the available task set according to the priority of the tasks, and sorts the available task set from high to low according to the priority of the tasks. The priority includes several urgency levels, so as to obtain several task sets with different urgency levels, and collect several task sets with different urgency levels in turn.

[0054] Among them, in the task set of the same urgency level, the tasks are sorted from high to low according to the adaptability, and the robot takes the tasks in the task set of the same urgency level as the target tasks in turn.

[0055] Furthermore, the "automatic" in the robot's automatic task collection can be understood as: 1) If there is a new task in the task pool, the robot will automatically screen and collect it, that is, the robot will detect the task status in the task pool in real time. If a new task is added to the task pool, the robot will actively screen the tasks in the task pool to identify the target task and collect it; 2) The robot will automatically screen and collect when it is idle, that is, when the robot has processed the target task and is in an idle state, it will actively screen the tasks in the task pool to identify the target task and collect it.

[0056] Preferably, in order to facilitate the above-mentioned retrieval of tasks in the task pool, a HashMap (hash table) method can be used to construct the task pool. HashMap uses the task type as the key and the value as the task list. The task list is sorted according to the priority of the tasks.

[0057] Two embodiments are provided below.

[0058] The first embodiment shows that a code completion task and a function test task are issued by humans.

[0059] 1) Humans issue tasks through the dialog box in the code editing window. After entering the command in the dialog box, the system automatically configures the various attributes of the task. The task message generated after the configuration is completed is shown in the attached Figure 3 .

[0060] 2) The task is added to the task pool and is set to the highest priority real_time for real-time execution, which can interrupt other low-priority tasks being executed.

[0061] 3) The robot will execute the task immediately after receiving it. After the task is completed, the task status is converted to "processed successfully" and the output is displayed in the code editing window.

[0062] 4) After the human chooses to accept, the returned result format changes to left-aligned and becomes code. The task reaches the state of human judgment and processing success, and the task object is released. At this point, the code completion task is completed.

[0063] 5) The dialog box input instructions can also specify the generation of test cases for the completed code files. The test robot will receive tasks from the task pool, generate test cases, and perform tests.

[0064] 6) Run the test case and output "All test cases passed!", then the robot has completed the test task. At this point, the function test task is completed.

[0065] The second embodiment shows that the robot issues code generation tasks and code testing tasks.

[0066] 1) The robot first reads the network communication module architecture document, which records:

[0067] -client.py: The main entry point for the client network communication module, including the functions of connecting to the server, sending and receiving data. It is responsible for handling the communication with the server and encapsulating the underlying network details.

[0068] -server.py: The main entry point of the server-side network communication module, which manually listens to client connections, receives and processes data sent by clients. It manages game sessions, multiplayer game state synchronization and other functions.

[0069] -protocols.py: defines the game communication protocol, including message format, data packet encoding and decoding rules, etc. This file is used to ensure that the data exchange between the client and the server is carried out according to the protocol.

[0070] -message handlers.py: Contains handlers for different types of messages, such as player moves, chat messages, etc. Each handler is responsible for parsing the message and performing the corresponding game logic operation.

[0071] -utils.py: Contains common utility functions and auxiliary functions in the network communication module, such as logging, error handling, data serialization, etc.

[0072] 2) The robot will automatically publish the programming tasks designed in it, for example, the robot automatically publishes the code generation task of client.py. The system automatically generates task messages according to the context and adds them to the task pool. The code generation robot takes the task. The task has a low priority and does not require human confirmation, but can be changed by humans.

[0073] 3) After the task is completed, the generated code will be written to client.py. At this point, the code generation task is completed.

[0074] 4) After automatically generating client.py, the robot will issue a code test task. After the task is added to the task pool, it will be picked up by the test robot and also has a lower priority.

[0075] 5) If the test does not report an error, no task will be issued. If the test reports an error, the robot will issue the client.py code debugging and optimization tasks based on the error information. The code test task is now completed.

[0076] It should be noted that the embodiments of the present invention have better practicability and do not impose any form of limitation on the present invention. Any technician familiar with the field may use the technical content disclosed above to change or modify it into an equivalent effective embodiment. However, any modification or equivalent changes and modifications made to the above embodiments based on the technical essence of the present invention without departing from the content of the technical solution of the present invention are still within the scope of the technical solution of the present invention.

Claims

1. A human-machine hybrid software development method, characterized in that: The steps include: Divide the software development activities into a plurality of tasks, create task messages for the tasks, configure message formats for the task messages, and extract task attributes of the corresponding tasks for the task messages; A human or a robot sends the task message to a task pool; The robot screens tasks in the task pool to identify and receive a target task; the robot obtains the content of the target task and runs the target task.

2. The human-machine hybrid software development method according to claim 1, characterized in that: The robot screens tasks in the task pool to identify target tasks and takes them, including: The robot screens tasks in the task pool according to the robot's role label, attribute label, resource measurement value and task priority to identify and claim the target task.

3. The human-machine hybrid software development method according to claim 2, characterized in that: The robot screens tasks in the task pool according to the attribute tags to identify target tasks and receive the tasks including: The attribute tags include a large language model and an operation method of the large language model. The robot obtains the compatibility with all tasks in the task pool based on its own attribute tags, eliminates tasks with a compatibility less than a preset threshold, and obtains a set of available tasks.

4. The human-machine hybrid software development method according to claim 3, characterized in that: The robot screens tasks in the task pool according to the attribute tags to identify target tasks and receive the tasks including: The available task set is sorted from high to low according to the degree of suitability, and the tasks in the available task set are sequentially taken as the target tasks.

5. The human-machine hybrid software development method according to claim 4, characterized in that: Before sorting the available task sets from high to low according to the suitability, the method further includes: The robot screens tasks in the task pool according to the priorities of the tasks, wherein: The available task sets are sorted from high to low according to the priorities of the tasks, wherein the priorities include several emergency levels, thereby obtaining the task sets of the several different emergency levels; Taking on the task sets of several different emergency levels in sequence; Among them, in the task set of the same emergency level, the tasks are sorted from high to low according to the adaptability, and the robot takes the tasks in the task set of the same emergency level as the target tasks in turn.

6. The human-machine hybrid software development method according to claim 5, characterized in that: Before the robot screens tasks in the task pool according to the priorities of the attribute tag tasks, the robot also includes: The robot screens tasks in the task pool according to the role tag and the resource metric value to match and obtain tasks corresponding to the role tag and having resource metric values ​​that meet the running requirements.

7. The human-machine hybrid software development method according to claim 1, characterized in that: The robot screens tasks in the task pool to identify target tasks and takes them, including: The robot detects the task status in the task pool in real time; if a new task is added to the task pool, the robot actively screens the tasks in the task pool to identify the target task and claim it; When the robot has processed the target task and is in an idle state, it actively screens tasks in the task pool to identify the target task and claim it.

8. The human-machine hybrid software development method according to claim 1, characterized in that: The task attributes of the task corresponding to the task message pulling include: Pull the task attribute of the corresponding task for the task message according to the context environment; the context environment includes a software development and testing environment and a software development environment; wherein: When developing a test environment for software, write requirements and publish test tasks in the code editing window through a dialog box, or publish test tasks for the selected code through shortcut keys; When developing an environment for software, you issue tasks by writing files or functions.

9. The human-machine hybrid software development method according to claim 8, characterized in that: The priority level of the test task of writing requirements and publishing them in the form of a dialog box is the highest priority; when the task pool receives the task, it will interrupt the tasks of other priorities being executed by the robot.

10. The human-machine hybrid software development method according to claim 8, characterized in that: Publishing a task by writing a file or a function includes: Pull the function of the task according to the functional module requirement document, and pull the function interface of the task according to the class and interface design diagram.

Images