Error prediction and self-repair method, device and medium for low-code application

Abstract

This invention discloses a method, device, and medium for error prediction and self-repair in low-code applications, belonging to the field of low-code platform technology. It addresses the technical problems of existing low-code platforms, which rely heavily on manual testing, are prone to lag, have blind spots, and are difficult for non-professional developers to diagnose deep-seated logical errors. The method includes: classifying and configuring business scenarios in the low-code platform, collecting and obtaining scenario constraint data; performing error prediction detection on the low-code data at both dynamic and static levels to obtain dynamic and static error results; performing error prediction detection on the low-code data at the machine learning prediction layer to obtain machine learning layer error prediction results; classifying and repairing both dynamic / static error results and machine learning layer error prediction results to obtain repair result information; and blocking high-risk error results to obtain blocking result information; thereby completing error prediction and self-repair in the low-code application.

Description

Technical Field

[0001] This application relates to the field of low-code platform technology, and in particular to a method, device and medium for error prediction and self-healing in low-code applications. Background Technology

[0002] Traditional low-code platforms rely on manual testing to verify the correctness of logic, which has three major bottlenecks: Lag: Errors are only discovered during runtime, resulting in high repair costs and significant project risks. Coverage blind spots: Complex combinations of business rules can easily create hidden vulnerabilities that are not easily discovered by testers. Professional dependence: Non-professional developers find it difficult to diagnose deep-seated logical errors, and existing static analysis tools can only detect syntax errors, which are ineffective for business logic. Summary of the Invention

[0003] This application provides a method, device, and medium for error prediction and self-repair in low-code applications to solve the following technical problems: existing low-code platforms rely heavily on manual testing, which can easily lead to lag and certain blind spots in coverage, making it difficult for non-professional developers to diagnose deep logic errors.

[0004] The embodiments of this application adopt the following technical solutions: On one hand, embodiments of this application provide a method for error prediction and self-repair in low-code applications, including: classifying and configuring business scenarios in a low-code platform through a visual interface, collecting and obtaining scenario constraint data; performing error prediction detection on the low-code data at the dynamic and static levels according to the intelligent agent corresponding to the scenario constraint data, obtaining dynamic and static error results; performing error prediction detection on the low-code data at the machine learning prediction layer, obtaining machine learning layer error prediction results; classifying and repairing both the dynamic and static error results and the machine learning layer error prediction results, obtaining repair result information; blocking high-risk error results, obtaining blocking result information; and completing error prediction and self-repair in low-code applications based on the repair result information and the blocking result information.

[0005] This application's embodiments proactively identify potential logical errors through an intelligent agent before application deployment on a low-code platform, shifting the fault discovery point from "runtime" to "development time." A knowledge base mapping error types to remedial measures can also be established, enabling automatic repair of deterministic errors and accurate suggestions for complex errors. Furthermore, leveraging the low-code platform and error prediction and self-repair capabilities reduces the number of problems developers need to manually resolve during application development, thereby improving development efficiency. Automated error prediction and repair functions reduce the time spent on manual error investigation and repair, lowering development costs. Simultaneously, through dynamic and static error prediction, potential errors can be identified early, reducing bugs that appear after application deployment and thus improving the overall quality of the application. Because error prediction and self-repair functions can address problems promptly, application crashes or performance degradation are reduced, thereby improving user experience.

[0006] In one feasible implementation, business scenarios in the low-code platform are categorized and configured through a visual interface, and scenario constraint data is collected and obtained. Specifically, this includes: configuring data related to the low-code platform for the business scenarios through the visual interface, and extracting the core constraints of each business scenario; wherein, the business scenarios include: UI component configuration, business process configuration, data model configuration, and integration interface configuration; configuring the core constraints into the intelligent agent in the low-code platform so that the intelligent agent can perform business logic judgments and determine the scenario constraint data based on the intelligent agent.

[0007] In one feasible implementation, based on the agent corresponding to the scenario constraint data, error prediction and detection are performed on the low-code data at both dynamic and static levels to obtain dynamic and static error results. This includes: based on the configured agent and through a rule base, performing static error detection on the low-code data in the low-code platform regarding basic low-code information to obtain low-code static detection results; wherein, the static detection includes: syntax detection, structure detection, process detection, interface detection, and source code detection; performing a match detection between the components corresponding to the low-code data and the bound data to obtain specific component static detection results; and combining the low-code static detection results and the specific component static detection results to obtain static error results at the static analysis layer.

[0008] In one feasible implementation, based on the agent corresponding to the scenario constraint data, error prediction and detection are performed on the low-code data at both dynamic and static levels to obtain dynamic and static error results. This includes: dynamically simulating the execution of the low-code data through a preset dynamic simulation layer to obtain a simulated workflow; performing full-coverage detection of all branch paths on the simulated running program of the low-code data through the symbol changes in the simulated workflow, and performing error detection processing on the virtual workflow after full-coverage detection based on the Monte Carlo stress testing method to obtain dynamic error results; and combining the dynamic error results with the static error results to obtain the dynamic and static error results.

[0009] In one feasible implementation, error prediction detection is performed on the low-code data under a machine learning prediction layer to obtain machine learning layer error prediction results. Specifically, this includes: using a GNN model to perform error prediction calculations on the graph structure data in the low-code data under a component configuration method to obtain component-level prediction error results; using a Transformer model to perform error prediction calculations on the business rules described in natural language in the low-code data under business logic conflicts to obtain business logic prediction error results; and combining the component-level prediction error results with the business logic prediction error results to obtain machine learning layer error prediction results based on the machine learning prediction layer.

[0010] In one feasible implementation, before classifying and repairing both the dynamic and static error results and the machine learning layer error prediction results to obtain repair result information, the method further includes: positioning both the dynamic and static error results and the machine learning layer error prediction results as error result information based on the low-code platform; classifying the error result information using the intelligent agent to obtain error data types; wherein, the error data types include: deterministic errors, errors that can provide suggestions, and high-risk errors; and classifying and labeling the error data types to obtain a graded strategy to be repaired.

[0011] In one feasible implementation, both the dynamic and static error results and the machine learning layer error prediction results are classified and repaired to obtain repair result information. Specifically, this includes: if the error data type is a deterministic error, the repair classification strategy is determined as an automatic repair strategy, and the agent performs repair execution processing on the deterministic error under the relevant repair rule base to obtain automatic repair result information; wherein, the deterministic error includes at least: null pointer risk, infinite loop, and type mismatch; if the error data type is a suggestion-providing error, the repair classification strategy is determined as a manual confirmation repair strategy, and according to the error suggestion repair list, the error code location is marked and the repair suggestion is matched and displayed for the suggestion-providing error to generate manual confirmation repair result information; the automatic repair result information and the manual confirmation repair result information are combined to obtain the repair result information to be executed by the agent.

[0012] In one feasible implementation, high-risk error results are blocked to obtain blocking result information. Specifically, this includes: if the error data type is a high-risk error result, the release status of the low-code application is determined to be a halted release status, and a corresponding high-risk error report is generated; the halted release status and the high-risk error report are determined as blocking processing strategies based on the low-code platform, and the blocking result information is generated.

[0013] Secondly, embodiments of this application also provide a low-code application error prediction and self-healing device, the device comprising: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions executable by the at least one processor to enable the at least one processor to execute the error prediction and self-healing method for a low-code application as described in any of the above embodiments.

[0014] Thirdly, embodiments of this application also provide a non-volatile computer storage medium, wherein the storage medium is a non-volatile computer-readable storage medium storing at least one program, each program including instructions, wherein when the instructions are executed by a terminal, the terminal performs an error prediction and self-healing method for a low-code application as described in any of the above embodiments.

[0015] This application provides a method, device, and medium for error prediction and self-healing in low-code applications. Compared with the prior art, the embodiments of this application have the following beneficial technical effects: 1. Improve development efficiency: Through low-code platforms and error prediction and self-healing capabilities, developers can reduce the number of problems they need to solve manually during application development, thereby improving development efficiency.

[0016] 2. Reduce development costs: Automated error prediction and correction functions can reduce the time spent manually troubleshooting and fixing errors, thereby reducing development costs.

[0017] 3. Improve application quality: Through dynamic and static error prediction, potential errors can be detected in advance, reducing bugs that appear after the application goes live, thereby improving the overall quality of the application.

[0018] 4. Enhanced user experience: Error prediction and self-healing features can handle problems in a timely manner, reducing application crashes or performance degradation, thereby improving the user experience.

[0019] 5. Simplify maintenance: The self-repair function can automatically fix some common errors, reducing the workload of maintenance personnel.

[0020] 6. Enhance system stability: By blocking high-risk errors, the further spread of errors can be prevented, thus enhancing system stability.

[0021] 7. Improve the accuracy of error prediction: By combining dynamic and static error prediction with machine learning prediction layers, data can be analyzed more comprehensively, thus improving the accuracy of error prediction.

[0022] 8. Visual interface enhances usability: A visual interface is provided for classifying and configuring business scenarios, enabling users without a technical background to participate in application development and lowering the technical threshold. Attached Figure Description

[0023] To more clearly illustrate the technical solutions in the embodiments of this application or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments recorded in this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort. In the drawings: Figure 1 A flowchart illustrating a low-code application error prediction and self-healing method provided in this application embodiment; Figure 2 This is a schematic diagram of the structure of a low-code application error prediction and self-healing device provided in an embodiment of this application. Detailed Implementation

[0024] To enable those skilled in the art to better understand the technical solutions in this application, the technical solutions in the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, and not all embodiments. Based on the embodiments of this specification, all other embodiments obtained by those skilled in the art without creative effort should fall within the scope of protection of this application.

[0025] This application provides a method for error prediction and self-healing in low-code applications, such as... Figure 1 As shown, the error prediction and self-healing method for low-code applications specifically includes steps S101-S106: S101. Through a visual interface, classify and configure business scenarios in the low-code platform, and collect and obtain scenario constraint data.

[0026] Specifically, it is necessary to first configure the low-code platform data for each business scenario through a visual interface and extract the core constraints for each business scenario. These business scenarios include: UI component configuration, business process configuration, data model configuration, and integration interface configuration.

[0027] Furthermore, the core constraints are configured into the agents in the low-code platform so that the agents can make business logic judgments and determine the scenario constraint data based on the agents.

[0028] As a feasible implementation method, based on business scenarios within the low-code platform, configurations are divided into four categories: UI component configuration, business process configuration, data model configuration, and integration interface configuration. Constraint data for these configuration scenarios is collected through a graphical interface. Then, the core constraints within the low-code platform are configured via a visual interface, which can be used by the intelligent agent for business logic judgment.

[0029] S102. Based on the agent corresponding to the scene constraint data, perform error prediction and detection on the low-code data at the dynamic and static levels to obtain dynamic and static error results.

[0030] Specifically, based on the configured agent and using a rule base, static error detection of low-code data in the low-code platform is performed to obtain low-code static detection results. Static detection includes: syntax detection, structure detection, process detection, interface detection, and source code detection.

[0031] Furthermore, a match check is performed between the component corresponding to the low-code data and the bound data to obtain the static detection results of the specific component.

[0032] Furthermore, the low-code static detection results and the specific component static detection results are combined to obtain static error results under the static analysis layer.

[0033] In one embodiment, the static analysis layer of the error prediction agent can perform static analysis on the low-level code using a rule base, analyzing or checking the syntax, structure, process, and interfaces of the code to identify errors in the source code. Development languages ​​include common programming languages ​​such as Java, Python, and JavaScript. Simultaneously, this layer can be combined with specific components to analyze and check whether the types of the components and the bound data match.

[0034] Furthermore, a pre-defined dynamic simulation layer is used to dynamically simulate the execution of low-code data to obtain a simulated workflow.

[0035] Furthermore, by simulating the symbol changes in the workflow, a full-coverage test of all branch paths is performed on the simulated running program with low-code data. Based on the Monte Carlo stress test method, error detection and processing are performed on the virtual workflow after the full-coverage test to obtain dynamic error results.

[0036] In one embodiment, the dynamic simulation layer of the error prediction agent simulates the program execution process by dynamically executing code. Errors can be detected by exploring all branch paths through symbolic variables input into the workflow. Alternatively, Monte Carlo stress testing can be used to randomly generate test data, execute a virtual workflow, and record abnormal state points to discover errors in the program.

[0037] Furthermore, the dynamic error results are combined with the static error results to obtain dynamic and static error results.

[0038] S103. Perform error prediction detection on the low-code data under the machine learning prediction layer to obtain the machine learning layer error prediction results.

[0039] Specifically, the GNN model can be used to perform error prediction calculations on graph structure data in low-code data using a component configuration approach, thereby obtaining component-level prediction error results.

[0040] Furthermore, the Transformer model is used to perform error prediction calculations on the business rules described in natural language in the low-code data under the condition of business logic conflict, and the business logic prediction error results are obtained.

[0041] Furthermore, the component-level prediction error results are combined with the business logic prediction error results to obtain the machine learning layer error prediction results based on the machine learning prediction layer.

[0042] In one embodiment, the machine learning prediction layer of the error prediction agent uses a dual-model collaborative approach in machine learning for learning and prediction, that is, it uses both a GNN model and a Transformer model. The GNN model is used to process graph-structured data and predict component-level errors; the Transformer model is used to analyze business rules described in natural language and predict business logic conflict errors.

[0043] S104. Classify and repair the dynamic and static error results as well as the machine learning layer error prediction results to obtain the repair result information.

[0044] Specifically, dynamic and static error results, as well as machine learning layer error prediction results, should all be classified as error result information based on the low-code platform.

[0045] Furthermore, the error result information is categorized by an intelligent agent to obtain error data types. These error data types include: deterministic errors, errors that can provide suggestions, and high-risk errors.

[0046] Furthermore, the erroneous data types are further classified and labeled to obtain the classification strategy to be repaired.

[0047] Furthermore, if the error data type is a deterministic error, the repair classification strategy is determined as an automatic repair strategy. An intelligent agent then performs repair execution processing based on the relevant repair rule base to obtain automatic repair result information. Deterministic errors include at least: null pointer deception, infinite loops, and type mismatches.

[0048] In one embodiment, during the automatic repair of the agent, for deterministic errors such as null pointer destructives, infinite loops, and type mismatches, the agent can automatically repair them according to the corresponding repair methods. This process requires no manual intervention and only provides the repair result.

[0049] Furthermore, if the error data type is an error that can provide suggestions, the repair classification strategy is determined to be a manual confirmation repair strategy. Based on the error suggestion repair list, the error code location is marked for errors that can provide suggestions, and the repair suggestions are matched and displayed to generate manual confirmation repair result information.

[0050] Furthermore, the automatic repair result information and the manually confirmed repair result information are combined to obtain the repair result information to be executed by the intelligent agent.

[0051] In one embodiment, during the manual confirmation and repair process of the repair execution agent, for errors that provide suggestions, repair suggestions can be listed according to the error suggestion configuration. The location of the error code and the repair effect after selecting a repair suggestion are displayed visually. This process requires manual selection and confirmation of the repair result, or the repair can be completed manually by writing the code.

[0052] S105. Block high-risk erroneous results to obtain blocking result information.

[0053] Specifically, if the error data type is a high-risk error result, the release status of the low-code application will be determined as a halted release status, and a corresponding high-risk error report will be generated.

[0054] Furthermore, the suspension of release status and high-risk error reports are identified as blocking handling strategies based on the low-code platform, and blocking result information is generated.

[0055] In one embodiment, during the blocking process of repairing the agent, for high-risk problem scenarios (scenarios with high-risk erroneous results) and errors that cannot be repaired automatically or through suggestions, the release of the low-code application will be directly aborted to prevent the deployment of applications with serious vulnerabilities. Simultaneously, a corresponding error report is generated, which is then modified and re-released by the developers. This process represents a special scenario for agent repair and does not provide a circuit breaker mechanism with automatic repair capabilities.

[0056] S106. Based on the repair result information and the blocking result information, complete the error prediction and self-repair of low-code applications.

[0057] Specifically, by utilizing a low-code application configuration method with error prediction and self-healing capabilities, and based on the repair and blocking results generated by this method, runtime error prediction can be performed during the low-code configuration phase, allowing for early error detection and accelerating application iteration. Intelligent support ensures efficient error repair, reduces reliance on professional developers, and shortens error repair time.

[0058] Furthermore, a federated learning evolution mechanism can be configured into this application. This involves training error prediction models locally on each tenant's end, aggregating model parameters through a central server, updating the global model, and then distributing it to all ends, thus implementing a federated learning evolution mechanism. The federated learning architecture continuously improves error prediction accuracy, enhancing the quality protection of low-code platforms.

[0059] In addition, embodiments of this application also provide a device for error prediction and self-healing in low-code applications, such as... Figure 2 As shown, the error prediction and self-healing device 200 for low-code applications specifically includes: At least one processor 201; and a memory 202 communicatively connected to the at least one processor 201; wherein the memory 202 stores instructions executable by the at least one processor 201 to enable the at least one processor 201 to execute: Through a visual interface, business scenarios in the low-code platform can be classified and configured, and scenario constraint data can be collected and obtained. Based on the intelligent agent corresponding to the scene constraint data, perform error prediction and detection on the low-code data at the dynamic and static levels to obtain dynamic and static error results; Detects erroneous predictions at the machine learning prediction layer on low-code data, and obtains the erroneous prediction results of the machine learning layer. The dynamic and static error results, as well as the machine learning layer error prediction results, are all classified and repaired to obtain the repair result information. High-risk erroneous results are blocked to obtain blocking result information; Based on the repair and blocking results, error prediction and self-repair of low-code applications can be achieved.

[0060] This application's embodiments proactively identify potential logical errors through an intelligent agent before application deployment on a low-code platform, shifting the fault discovery point from "runtime" to "development time." A knowledge base mapping error types to remedial measures can also be established, enabling automatic repair of deterministic errors and accurate suggestions for complex errors. Furthermore, leveraging the low-code platform and error prediction and self-repair capabilities reduces the number of problems developers need to manually resolve during application development, thereby improving development efficiency. Automated error prediction and repair functions reduce the time spent on manual error investigation and repair, lowering development costs. Simultaneously, through dynamic and static error prediction, potential errors can be identified early, reducing bugs that appear after application deployment and thus improving the overall quality of the application. Because error prediction and self-repair functions can address problems promptly, application crashes or performance degradation are reduced, thereby improving user experience.

[0061] The various embodiments in this application are described in a progressive manner. Similar or identical parts between embodiments can be referred to mutually. Each embodiment focuses on describing the differences from other embodiments. In particular, the device and medium embodiments are basically similar to the method embodiments, so the description is relatively simple; relevant parts can be referred to the description of the method embodiments.

[0062] The devices and media provided in this application are one-to-one with the methods. Therefore, the devices and media also have similar beneficial technical effects as their corresponding methods. Since the beneficial technical effects of the methods have been described in detail above, the beneficial technical effects of the devices and media will not be repeated here.

[0063] Those skilled in the art will understand that embodiments of this application can be provided as methods, systems, or computer program products. Therefore, this application can take the form of a completely hardware embodiment, a completely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, this application can take the form of a computer program product embodied on one or more computer-usable storage media (including but not limited to disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code.

[0064] This application is described with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of this application. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, special-purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, generate instructions for implementing the flowchart... Figure 1 One or more processes and / or boxes Figure 1 A device that provides the functions specified in one or more boxes.

[0065] These computer program instructions may also be stored in a computer-readable storage medium that can direct a computer or other programmable data processing device to function in a particular manner, such that the instructions stored in the computer-readable storage medium produce an article of manufacture including instruction means, which are implemented in a process Figure 1 One or more processes and / or boxes Figure 1 The function specified in one or more boxes.

[0066] These computer program instructions may also be loaded onto a computer or other programmable data processing equipment to cause a series of operational steps to be performed on the computer or other programmable equipment to produce a computer-implemented process, thereby providing instructions that execute on the computer or other programmable equipment for implementing the process. Figure 1 One or more processes and / or boxes Figure 1 The steps of the function specified in one or more boxes.

[0067] In a typical configuration, a computing device includes one or more processors (CPU), input / output interfaces, network interfaces, and memory.

[0068] Memory may include non-persistent storage in computer-readable media, such as random access memory (RAM) and / or non-volatile memory, such as read-only memory (ROM) or flash RAM. Memory is an example of computer-readable media.

[0069] Computer-readable media includes both permanent and non-permanent, removable and non-removable media that can store information using any method or technology. Information can be computer-readable instructions, data structures, modules of programs, or other data. Examples of computer storage media include, but are not limited to, phase-change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technologies, CD-ROM, digital versatile optical disc (DVD) or other optical storage, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other non-transferable medium that can be used to store information accessible by a computing device. As defined herein, computer-readable media does not include transient computer-readable media, such as modulated data signals and carrier waves.

[0070] It should also be noted that the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or apparatus. Without further limitation, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or apparatus that includes said element.

[0071] The above description is merely an embodiment of this application and is not intended to limit the scope of this application. Various modifications and variations can be made to this application by those skilled in the art. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of this application should be included within the scope of this specification.

Claims

1. A method for error prediction and self-healing in low-code applications, characterized in that, The method includes: Through a visual interface, business scenarios in the low-code platform can be classified and configured, and scenario constraint data can be collected and obtained. Based on the intelligent agent corresponding to the scenario constraint data, perform error prediction and detection on the low-code data at the dynamic and static levels to obtain dynamic and static error results. The low-code data is subjected to error prediction detection at the machine learning prediction layer to obtain the machine learning layer error prediction results. The dynamic and static error results and the machine learning layer error prediction results are all classified and repaired to obtain repair result information; High-risk erroneous results are blocked to obtain blocking result information; Based on the repair result information and the blocking result information, error prediction and self-repair of low-code applications can be completed.

2. The error prediction and self-healing method for low-code applications according to claim 1, characterized in that, Through a visual interface, business scenarios in the low-code platform are categorized and configured, and scenario constraint data is collected and obtained, specifically including: Through a visual interface, the data configuration related to the low-code platform is performed for the business scenarios, and the core constraints of each business scenario are extracted; wherein, the business scenarios include: UI component configuration, business process configuration, data model configuration, and integration interface configuration; The core constraints are configured into the agent in the low-code platform so that the agent can perform business logic judgments and determine the scenario constraint data based on the agent.

3. The error prediction and self-healing method for low-code applications according to claim 1, characterized in that, Based on the agent corresponding to the scenario constraint data, error prediction and detection are performed on the low-code data at both dynamic and static levels to obtain dynamic and static error results, including: Based on the configured agent, and through a rule base, static error detection is performed on the low-code data in the low-code platform to obtain low-code static detection results; wherein, the static detection includes: syntax detection, structure detection, process detection, interface detection, and source code detection; The components corresponding to the low-code data are matched with the bound data to obtain the static detection results of the specific components. The low-code static detection results and the specific component static detection results are combined to obtain static error results under the static analysis layer.

4. The error prediction and self-healing method for low-code applications according to claim 3, characterized in that, Based on the agent corresponding to the scenario constraint data, error prediction and detection are performed on the low-code data at both dynamic and static levels to obtain dynamic and static error results, including: The low-code data is dynamically simulated and executed through a preset dynamic simulation layer to obtain a simulated workflow; By measuring the symbol changes in the simulated workflow, a full-coverage detection of all branch paths is performed on the simulated running program of the low-code data. Based on the Monte Carlo stress test method, error detection and processing are performed on the virtual workflow after the full-coverage detection to obtain dynamic error results. The dynamic error result is combined with the static error result to obtain the dynamic and static error result.

5. The error prediction and self-healing method for low-code applications according to claim 1, characterized in that, The low-code data is subjected to error prediction detection at the machine learning prediction layer to obtain the machine learning layer error prediction results, specifically including: Using the GNN model, error prediction calculations are performed on the graph structure data in the low-code data under a component configuration method to obtain component-level prediction error results; Using the Transformer model, the business rules described in natural language in the low-code data are used to perform error prediction calculations for business logic conflicts, and the business logic prediction error results are obtained. The component-level prediction error results are combined with the business logic prediction error results to obtain the machine learning layer error prediction results based on the machine learning prediction layer.

6. The error prediction and self-healing method for low-code applications according to claim 1, characterized in that, Before classifying and repairing both the dynamic and static error results and the machine learning layer error prediction results to obtain the repair result information, the method further includes: The dynamic and static error results and the machine learning layer error prediction results are all positioned as error result information based on the low-code platform; The intelligent agent performs data classification processing on the error result information to obtain error data types; wherein, the error data types include: deterministic errors, errors that can provide suggestions, and high-risk errors; The erroneous data types are classified and labeled to obtain a classification strategy to be repaired.

7. The error prediction and self-healing method for low-code applications according to claim 6, characterized in that, The dynamic and static error results, as well as the machine learning layer error prediction results, are all classified and repaired to obtain repair result information, specifically including: If the error data type is a deterministic error, then the classification strategy to be repaired is determined as an automatic repair strategy, and the agent performs repair execution processing on the deterministic error under the relevant repair rule base to obtain automatic repair result information; wherein, the deterministic error includes at least: null pointer risk, infinite loop, and type mismatch; If the error data type is the type of error that can provide suggestions, then the repair classification strategy is determined as the manual confirmation repair strategy, and according to the error suggestion repair list, the error code location is marked and the repair suggestions are matched and displayed for the type of error that can provide suggestions, generating manual confirmation repair result information; The automatic repair result information and the manually confirmed repair result information are combined to obtain the repair result information to be executed by the intelligent agent.

8. The error prediction and self-healing method for low-code applications according to claim 1, characterized in that, High-risk erroneous results are blocked, and the blocking result information is obtained, including: If the error data type is a high-risk error result, the release status of the low-code application will be determined as a halted release status, and a corresponding high-risk error report will be generated. The suspended release status and the high-risk error report are identified as blocking processing strategies based on the low-code platform, and the blocking result information is generated.

9. A fault prediction and self-healing device for low-code applications, characterized in that, The device includes: At least one processor; and, A memory communicatively connected to the at least one processor; wherein, The memory stores instructions executable by the at least one processor to enable the at least one processor to perform an error prediction and self-healing method for a low-code application according to any one of claims 1-8.

10. A non-volatile computer storage medium, characterized in that, The storage medium is a non-volatile computer-readable storage medium that stores at least one program, each program including instructions that, when executed by a terminal, cause the terminal to perform an error prediction and self-healing method for a low-code application according to any one of claims 1-8.

Images