Isolated Code Detection in Monolithic Applications
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Legacy monolithic computing applications face challenges in scalability, resource allocation, and modernization, requiring transformation into microservices to meet modern computing demands, but this process is complex and inefficient due to the need for manual identification and extraction of independently deployable components.
Innovation Solution
A software modernization service that automatically detects 'islands' of independent code within monolithic applications, visualizes dependencies, and assists in breaking these dependencies to facilitate the extraction and deployment of these components as microservices, serverless functions, or containers, minimizing code changes and leveraging cloud-based services for improved scalability and efficiency.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Measurement precision
If manual identification and extraction of independently deployable components is performed, then transformation accuracy is improved, but productivity deteriorates
Solution Approach 1:
The system performs self-analysis by automatically detecting islands and bridges in the codebase without requiring manual code review. The software modernization service executes automated static analysis to identify independently deployable components, eliminating the need for manual inspection while maintaining high transformation accuracy through algorithmic detection of code dependencies and coupling relationships.
Solution Approach 2:
The patent replaces manual mechanical analysis of code with automated computational analysis. Instead of developers manually reviewing and identifying extractable components, the system uses automated graph modeling and static analysis tools to detect islands and bridges, substituting human cognitive processes with algorithmic operations that are both accurate and scalable.
2Manufacturing precision
If comprehensive code analysis is performed to identify independent components, then manufacturing precision is improved, but device complexity deteriorates
Solution Approach 1:
The codebase is segmented into discrete islands (independently deployable components) and bridges (dependencies between components). By dividing the monolithic application into manageable segments based on coupling analysis, the system achieves precise component identification without requiring analysis of the entire codebase as a single complex unit, thereby reducing the effective complexity of the analysis task.
Solution Approach 2:
The patent introduces an intermediary graph model that represents code dependencies between islands and bridges. This intermediate representation layer simplifies the complex code analysis task by transforming raw code relationships into a structured graph format, making it easier to identify independent components while managing the complexity of dependency analysis.
3Productivity
If automated island detection is implemented, then productivity is improved, but measurement precision deteriorates
Solution Approach 1:
The system incorporates feedback mechanisms where the graph modeling service continuously refines island detection based on analysis results. The software modernization service uses feedback from bridge identification and dependency analysis to improve the accuracy of island detection, allowing automated processing to maintain high precision through iterative refinement rather than relying solely on initial detection accuracy.
Data Source
AI summary
Disclosed are various embodiments for isolated code detection from application code analysis. Various application components may be identified from a source code file or a bytecode file of a computing application. A graph model representative of the computing application is generated having nodes and bridges that connect some nodes to other nodes. The graph model is generated such that at least one of the nodes is an isolated node having less than a threshold number of bridges connecting to other nodes, which is indicative that a corresponding one of the application components can be implemented as an independently deployable component of the computing application.