Frontend Input Buffering for Deferred Script Loading
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Cloud-based software platforms face inefficiencies in loading page elements, leading to increased bandwidth and processor utilization, as many users only utilize a subset of features, resulting in longer apparent pageload times due to the rendering of infrequently used elements and associated scripts.
Innovation Solution
A method where a backend application determines which frontend-executable script elements are likely to receive user input within a threshold time and marks less frequently used elements for deferred loading, using an input buffer script to handle inputs until the elements are fully loaded, optimizing the order of element loading based on user interaction history.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If all page elements and scripts are loaded simultaneously, then complete functionality is available, but apparent pageload time increases
Solution Approach 1:
The patent segments the page loading process by dividing scripts into two categories: those likely to receive user input within a threshold time period (loaded immediately) and those unlikely to receive input (deferred). This segmentation allows the page to load critical functionality first while deferring non-critical scripts, thereby reducing apparent pageload time while maintaining complete functionality when needed.
Solution Approach 2:
The patent applies preliminary action by pre-determining which scripts are likely to receive user input based on historical data before the user actually interacts with the page. This allows the system to proactively load only the necessary scripts first, rather than waiting for user actions to trigger script loading, thus reducing perceived load time while ensuring functionality is available when needed.
2Loss of time
If frequently used elements are prioritized for loading, then apparent pageload time decreases, but less frequently used elements are deferred
Solution Approach 1:
The patent implements a dynamic script loading strategy where the system continuously monitors user interactions and adjusts script loading behavior accordingly. When a deferred script becomes relevant (i.e., the user interacts with its associated UI element), the system dynamically loads that script. This dynamic approach ensures that frequently used elements are prioritized for fast loading while maintaining the ability to provide full functionality when needed.
Solution Approach 2:
The system uses feedback from user interactions to determine when to load deferred scripts. By monitoring user actions on UI elements associated with deferred scripts, the system receives feedback that triggers the loading of previously deferred scripts. This feedback mechanism ensures that full functionality is maintained while optimizing initial load performance for frequently used elements.
3Reliability
If user input buffering is implemented for deferred elements, then functionality is maintained, but system complexity increases
Solution Approach 1:
The patent introduces an intermediary buffering mechanism that sits between the user interface elements and the deferred scripts. When a user interacts with a UI element whose script is deferred, the buffer captures the input and holds it until the script is loaded. This intermediary buffer simplifies the overall system architecture by providing a standardized way to handle deferred interactions without requiring complex event replay or state management mechanisms.
Data Source
AI summary
Systems and methods for servicing page requests from a cloud-based software service. In particular, page tree elements defining a page requested from a backend of a cloud-based software service can be can be transmitted in a manner that prioritizes elements and functionality likely to be interacted with by a particular user first (e.g., within a threshold time of apparent pageload completion). Other elements unlikely to be interacted with by the user may be loaded asynchronously and/or on a deferred basis. Inputs provided to these elements can be buffered by an input buffer script to capture unexpected inputs thereto.