Automated Application Porting via Semantic Code Separation
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing methods for porting software applications to new architectures or platforms often result in non-conforming semantics, leading to potential breaks in functionality and reliability issues, particularly when migrating from one software architecture to another, such as from client-server to web-based systems, due to the lack of effective semantic preservation during the porting process.
Innovation Solution
The approach involves automated code transformations that separate code into components corresponding to a target architecture while ensuring semantic equivalence, using abstract syntax trees and transformational rules to generate output code that preserves the original application's behavior, and employing code separation techniques to identify and map components correctly across different architectures.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If a full rewrite is performed to port an application to a new architecture or platform, then the application can be migrated to the new architecture, but the semantics of the rewritten code may not conform to the original application behavior
Solution Approach 1:
The patent creates a virtual copy of the original application's abstract syntax tree and transformation rules to generate the ported application. This virtual copying mechanism allows the new architecture to be built by transforming the original code structure rather than rewriting it, thereby preserving semantics while achieving portability.
Solution Approach 2:
The patent introduces an intermediary transformation layer that acts as a mediator between the original application code and the target architecture. This intermediary layer, represented by the transformation rules and abstract syntax tree, translates and adapts the original code to the new architecture while maintaining semantic equivalence.
2Adaptability or versatility
If code refactoring is performed during porting, then the application can be adapted to new architecture, but the functionality may change and cause breaking changes in interfacing applications
Solution Approach 1:
The patent segments the application code into distinct components represented by the abstract syntax tree nodes. This segmentation allows selective transformation of specific code portions while maintaining the integrity of other parts, ensuring that functionality is preserved in the transformed segments while achieving architectural adaptability.
Solution Approach 2:
The patent changes parameters such as programming language, platform-specific APIs, and architectural patterns while maintaining the underlying semantic structure. By transforming parameters at the syntax level rather than altering the semantic logic, the patent achieves architecture adaptability without changing functionality.
3Productivity
If automated code transformation is used for porting, then the porting process can be streamlined, but semantic equivalence cannot be guaranteed
Solution Approach 1:
The patent incorporates feedback mechanisms that validate the transformed code against the original abstract syntax tree. This feedback loop ensures that the automated transformation process maintains semantic equivalence by continuously comparing the original and transformed code structures and correcting deviations.
Solution Approach 2:
The patent performs preliminary analysis of the original application code to build the abstract syntax tree and transformation rules before actual code generation. This preliminary action ensures that all semantic relationships are captured and encoded in the transformation rules, guaranteeing semantic equivalence in the automated porting process.
Data Source
AI summary
Techniques to automatically port applications to a mobile infrastructure using code separation with semantic guarantees are disclosed. Porting enterprise applications from to a target architecture another is effected via separating code into constituent layers of the target architecture. To preserve semantics, code transformations are enforced via an abstract syntax tree structure. The generated code may have various code wrappers and/or infrastructure elements so the ported application will operate in the target architecture. Various techniques are disclosed regarding specific code wrappers and/or infrastructure elements to address operating issues including, but not limited to, architectural issues, network latency, framework changes, regulatory issues.