Hyperconverged Data Structure for Dynamic User Interface Generation
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing user interface generation systems face inefficiencies due to the use of hierarchical data structures, which lead to longer load times and increased storage requirements, and lack adaptability, especially when dealing with static content that requires flat data structures.
Innovation Solution
The implementation of a hyperconverged data structure that combines the efficiency of flat data structures with the customizability of hierarchical structures, allowing only the necessary data to be described for rendering, rather than user interface semantics, and using a server to organize user interface nodes into both tree and table structures for dynamic and customized UI generation.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If a hierarchical data structure is used to render user interfaces, then the system can provide dynamic and customizable UI experiences, but the recursion algorithms required to traverse the tree structure take longer as the hierarchical structure becomes deeper and more complex, resulting in longer load times
Solution Approach 1:
The patent segments the data structure into two distinct parts: a hierarchical tree structure for organizing UI elements and their relationships, and a flat table structure for storing metadata and constraints. This segmentation allows the system to leverage the strengths of both structures while avoiding their respective weaknesses.
Solution Approach 2:
The patent introduces a second dimension to the data structure by creating a flat table representation alongside the hierarchical tree. This additional dimension enables efficient traversal and querying without requiring deep recursion through the tree structure, thereby reducing load times while preserving customizability.
2Adaptability or versatility
If a hierarchical data structure is used for user interface generation, then dynamic and customizable UI generation is enabled, but storage requirements increase and flexibility for changes to data is reduced
Solution Approach 1:
The patent extracts metadata and constraints from the hierarchical structure and stores them in a separate flat table. This extraction reduces the storage burden on the tree structure and allows for more efficient data management and flexibility in handling changes.
Solution Approach 2:
By introducing a flat table dimension for storing metadata, the patent reduces the complexity and storage requirements of the hierarchical structure while maintaining its dynamic and customizable capabilities.
3Adaptability or versatility
If user interface semantics are stored along with metadata in existing computerized techniques, then dynamic user interface is achieved, but storage requirements increase and adaptability and flexibility for changes to data decrease
Solution Approach 1:
The patent segments user interface semantics from metadata and stores them in separate structures. Semantics are represented in the tree structure through node relationships, while metadata is stored in the flat table, reducing overall complexity and improving flexibility.
Solution Approach 2:
The patent separates semantics and metadata into different dimensions of the data structure, allowing independent management and optimization of each, thereby reducing complexity while maintaining dynamic UI capabilities.
Data Source
AI summary
Methods and systems are described for automatically rendering a customized user interface (UI). A server receives a request to generate a UI, the request including a user identifier and a workflow identifier. The server determines a template based upon the workflow identifier, comprising areas for insertion of custom UI elements. The server captures a list of UI nodes, each UI node comprising metadata. The server organizes the UI nodes into (i) a tree data structure comprising an anchor UI node and child UI nodes, and (ii) a table data structure of identifiers for the nodes in the tree structure, values, constraints, and the metadata for the corresponding UI node. The server inserts the metadata into the areas for insertion using the tree data structure and the table data structure. The server renders a graphical UI based upon the metadata.