Automated Monolithic Application Refactoring to Microservices
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Monolithic computer applications face limitations in scalability and flexibility, requiring extensive manual effort and time to refactor into microservices, often resulting in sub-optimal outcomes due to the complexity of code constructs and processes.
Innovation Solution
An automated refactoring method using natural language processing (NLP) and machine learning models to transform textual input into context-aware tokens, determine groupings and associations with code constructs, and generate invocation sequences for refactoring into microservices, leveraging usage data and meta-information to identify processes and recommend optimal microservice configurations.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Extent of automation
If manual refactoring methods are used to transform monolithic applications into microservices, then expertise and control can be applied to complex code constructs, but the process requires extensive manual effort and time
Solution Approach 1:
The system enables self-service by automatically analyzing code constructs, generating microservice architectures, and producing implementation code without requiring manual intervention. The refactoring process serves itself by using AI models to understand and transform the monolithic application structure into microservices independently
Solution Approach 2:
Manual mechanical refactoring efforts are replaced with an AI-based automated system that uses natural language processing, code analysis, and machine learning models to perform the refactoring. The system substitutes human expert manual work with automated intelligent analysis and code generation capabilities
2Ease of operation
If manual refactoring is performed on complex monolithic codebases, then detailed understanding and control can be achieved, but extensive expertise and manual effort are required
Solution Approach 1:
An AI-based intermediary system is introduced between the monolithic application and the microservice target architecture. This intermediary automatically analyzes the complex code constructs, understands their relationships, and transforms them into microservice components, shielding users from the complexity while maintaining operational simplicity
3Adaptability or versatility
If traditional refactoring approaches are used, then existing code constructs can be modified, but scalability and flexibility limitations of monolithic architecture persist
Solution Approach 1:
The system automatically segments the monolithic application into independent microservice components by analyzing code constructs, identifying boundaries, and generating separate service modules. Each microservice can be independently deployed, scaled, and modified, providing the flexibility and adaptability that monolithic architectures lack
Data Source
AI summary
Refactoring a monolithic computer application can include transforming textual input into context-aware tokens represented by machine-processable data structures, the textual input acquired from text associated with a computer application having a monolithic architecture for implementing one or more application processes. Based on co-occurrence frequencies among the context aware tokens, one or more groupings of context-aware tokens can be determined. An association between each grouping and a code construct can be determined. Invocation sequences based on time series analyses of computer-generated usage data generated in response to execution of the one or more application processes can be generated, each invocation sequence linking two or more code constructs based on a time series analysis linking groupings that correspond to the linked code constructs. A recommendation for refactoring the computer application into a plurality of microservices can be generated, each microservice corresponding to one or more invocation sequences.