Runtime Extension System for Bundled Web Applications
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Traditional bundled web applications are not customizable at runtime, as all modules must be bundled upfront and loaded as isolated applications, preventing extensions from interacting with the container application.
Innovation Solution
A method where the container application registers reusable code in a global context during bootstrapping, allowing extensions to access and utilize this code, enabling runtime extensibility and integration with the container application.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If modules are bundled together upfront in a traditional bundled web application, then the application can be loaded and executed as an isolated unit, but the application cannot be customized at runtime and extensions cannot interact with the container application
Solution Approach 1:
The application is segmented into a container application and separate extension modules. The container provides core functionality and registration mechanisms, while extensions are separate bundles that can be loaded dynamically at runtime. This segmentation allows the container to maintain reliable isolated execution while enabling runtime customization through selective loading of extension modules.
Solution Approach 2:
The system transitions from static upfront bundling to dynamic runtime loading. The container application dynamically loads extension modules based on runtime conditions, user preferences, or system state. This dynamic approach enables runtime customization while the container maintains its isolated execution environment through controlled interfaces.
2Adaptability or versatility
If extensions are loaded separately from the container application, then runtime customization is enabled, but deep integration and sharing of data and behavior between extensions and the container becomes difficult
Solution Approach 1:
The container application implements universal registration mechanisms and global context interfaces that can be used by any extension module. These standardized interfaces allow extensions to register components, access global state, and interact with the container through common protocols, reducing integration complexity while maintaining runtime extensibility.
Solution Approach 2:
A global context serves as an intermediary between the container application and extension modules. This mediator provides a standardized interface for extensions to register components, access shared data, and communicate with the container. The global context manages the interactions, simplifying integration while enabling deep functionality sharing.
3Adaptability or versatility
If the container application registers code in a global context, then extensions can access and utilize container code for deep integration, but access control and security management become more complex
Solution Approach 1:
The global context implementation includes feedback mechanisms that track which extensions access which registered components. This feedback information enables the system to enforce access control policies, manage permissions, and audit extension-container interactions. The feedback loop allows security management to operate based on actual usage patterns while maintaining code sharing capabilities.
Data Source
AI summary
Techniques disclosed herein permit bundled web applications to be extended at runtime. In particular, the functionality of a container application that is a bundled web application may be extended by extensions that are also bundled web applications. To enable such extensibility, the container application registers reusable portion(s) of its code in a global context during a bootstrapping sequence of the container application. Thereafter, extensions that are loaded may access and utilize the registered portion(s) of code, as if those extensions had been bundled together with the rest of the container application. In addition, extensions may be managed using scoping and/or permissions that control access to the extensions based on the container application mode that the extensions can be used with and white lists of users who are allowed to use the extensions, respectively.