Client-Server Code Generation via Tree Hierarchy
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Traditional client-server systems face performance issues and user experience delays due to the need for server requests for calculations, and existing solutions either increase server load, duplicate business logic, or require frustrating initial downloads and maintenance challenges.
Innovation Solution
A computer system generates first executable code for the server and second executable code for the client based on common source code, using a tree hierarchy to implement business logic, allowing calculations to be performed locally without server latency and maintaining logic synchronization.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If business logic is coded in the business-logic layer to be deployed on the server, then system safety and ease of maintenance are improved, but system performance and user experience deteriorate due to server request delays
Solution Approach 1:
The patent segments the business logic into two parts: critical logic remains on the server for safety, while non-critical calculation logic is extracted and deployed to the client as executable code. This segmentation allows calculations to execute locally without server requests, eliminating delays while maintaining server control over core business rules.
Solution Approach 2:
The patent introduces an intermediary component - a code generation system that creates executable code from the business logic layer. This intermediary translates server-side logic into client-executable form, enabling the client to perform calculations independently while the server maintains authority over the original logic definitions.
2Loss of time
If business logic is duplicated in the user-interface layer to improve responsiveness, then user experience improves, but software bugs increase due to coordination difficulties
Solution Approach 1:
The patent creates a controlled copy of the business logic for client execution. Instead of manual duplication, the system automatically generates executable code that is a faithful representation of the server-side logic. This automated copying process ensures consistency and eliminates the coordination errors that plague manual duplication approaches.
Solution Approach 2:
The business logic serves itself by being automatically transformed into client-executable code. The same logic that runs on the server is systematically converted and deployed to the client, allowing the client to execute calculations independently without requiring manual synchronization or coordination between separate codebases.
3Loss of time
If large pieces of business logic are pushed to the client initially, then responsiveness improves, but initial download experience and maintenance difficulty worsen
Solution Approach 1:
The patent applies partial action by deploying only the specific portions of business logic needed for client-side calculations, rather than pushing the entire business logic layer. This selective deployment reduces download size and improves initial user experience while still enabling local execution of necessary calculations.
Data Source
AI summary
A computer system generates first executable code in a first programming language based on common source code, where the first executable code is configured to execute at a server in the client-server environment. Then, the computer system executes the first executable to produce relational objects that constitute a tree hierarchy, where a given relational object defines a relationship between nodes and end points in the common source code. Next, the computer system generates second executable code in a second programming language based on the tree hierarchy, where the second executable code is configured to execute at a client in the client-server environment, and where the second executable code implements a subset of the common source code associated with the relational objects which is based on a user context.