Mainframe Source Code Error Detection via Knowledge Graphs
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Mainframe application builds lack efficient error detection tools, leading to significant inefficiencies due to lengthy build times and unnecessary resource consumption, as errors are only detected after the build is completed.
Innovation Solution
A computing platform configures dependency and error knowledge graphs to analyze mainframe source code, identify potential errors, and update the code with corresponding solutions, then sends the updated code to a mainframe build and deployment engine for automatic execution.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If mainframe source code is analyzed using knowledge graphs to detect errors before build, then error detection capability is improved, but device complexity increases
Solution Approach 1:
The patent introduces knowledge graphs as intermediary structures that mediate between the source code and the build system. These knowledge graphs capture dependencies, data flows, and control flows, serving as a intermediate representation that enables error detection without requiring complex analysis of the entire build system. The knowledge graph acts as a mediator that simplifies the detection process while maintaining high reliability.
Solution Approach 2:
The system performs preliminary analysis of the source code to construct knowledge graphs before the actual build process. This preliminary action includes identifying dependencies, data flows, and control flows, and storing them in knowledge graphs. By performing this analysis beforehand, the system can quickly detect errors during the build process without having to perform complex real-time analysis, thus improving reliability while managing complexity.
2Reliability
If complete mainframe build is executed to identify errors, then error detection accuracy is improved, but build time increases
Solution Approach 1:
The system performs preliminary construction of knowledge graphs that capture the essential structure and dependencies of the source code before the build process. This preliminary action includes analyzing dependencies, data flows, and control flows, and storing them in the knowledge graph. During the build process, error detection leverages this pre-computed information, allowing for accurate error detection without requiring a complete rebuild, thus reducing build time while maintaining detection accuracy.
Solution Approach 2:
The build process is segmented into phases that utilize the knowledge graph. Instead of performing a complete build to detect errors, the system segments the analysis into: (1) knowledge graph construction from source code, (2) error detection using the pre-built knowledge graph, and (3) selective rebuilding only of affected components. This segmentation allows for accurate error detection while minimizing the time required by avoiding unnecessary rebuilding of unaffected components.
3Reliability
If mainframe build is completed to detect errors, then comprehensive error identification is improved, but resource consumption increases
Solution Approach 1:
The system performs preliminary construction of knowledge graphs that comprehensively capture dependencies, data flows, and control flows before the build process. This preliminary action ensures that all potential error sources are identified and stored in the knowledge graph. During error detection, the system queries this pre-computed knowledge graph rather than performing comprehensive analysis during the build, achieving complete error identification while minimizing resource consumption during the actual build process.
Solution Approach 2:
The system segments resource-intensive analysis operations from the build process. The knowledge graph construction, which requires comprehensive resource consumption to achieve complete error identification, is performed as a separate preliminary step. The actual build process then leverages this pre-computed information for lightweight error detection, significantly reducing resource consumption while maintaining comprehensive error identification capability.
Data Source
AI summary
A computing platform may configure a dependency knowledge graph indicating file dependencies for mainframe applications, and an error knowledge graph indicating errors and corresponding solutions for the mainframe applications. The computing platform may receive mainframe source code. The computing platform may analyze, using the knowledge graphs, the mainframe source code to identify potential errors and corresponding solutions. Based on identifying an error in the mainframe source code, the computing platform may cause the mainframe source code to be updated according to the corresponding solution. The computing platform may analyze, using the dependency knowledge graph and the error knowledge graph, the updated mainframe source code to identify remaining errors. Based on identifying an absence of the remaining errors, the computing platform may send, to a mainframe build and deployment engine, the updated mainframe source code, which may cause the mainframe build and deployment engine to automatically execute a build process.