Dynamic Language Add-ins for Static Host Extensibility
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing application hosts like Excel® can only support a single compiled language for extensibility, making it difficult to provide extensibility using dynamic languages such as M, R, and Python, and limiting multi-threading functionality.
Innovation Solution
The method involves using language add-ins with static extensibility points, allowing multiple dynamic languages to extend the application host by searching for user code, determining its language, and executing it through a language provider, enabling functions to be added, removed, or updated dynamically, even if the application host expects static functions.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If a single compiled language is used for extensibility, then the application host can maintain stable static interfaces, but the system loses adaptability to support multiple dynamic languages
Solution Approach 1:
The system segments the extensibility architecture into separate language providers, each handling a specific dynamic language. This allows the host application to support multiple languages without mixing their execution contexts, resolving the contradiction by organizing complexity into manageable, isolated units while maintaining multi-language adaptability
Solution Approach 2:
The patent introduces an intermediary layer (the extensibility mechanism with language providers) between the static host interface and dynamic language code. This intermediary translates and manages the interaction between static interface expectations and dynamic language behaviors, enabling multi-language support while preserving interface stability
2Reliability
If static compiling is required for extensibility, then interface stability is ensured, but the time to deploy and update functions increases
Solution Approach 1:
The system implements dynamic code loading and execution capabilities within the extensibility framework, allowing functions to be loaded, executed, and updated in memory without requiring static compilation and restarting. This enables interface stability to be maintained while dramatically reducing deployment time, as code can be dynamically instantiated and hot-swapped
Solution Approach 2:
The system performs preliminary validation and type checking of dynamic code before execution, ensuring interface stability is maintained without requiring full static compilation. This preliminary action verifies compatibility with static interfaces while allowing rapid deployment of validated code
3Adaptability or versatility
If multiple dynamic languages are supported, then adaptability improves, but the complexity of managing different language runtimes increases
Solution Approach 1:
Each dynamic language is handled by a dedicated language provider that encapsulates its specific runtime, interpreter, and execution context. This segmentation isolates runtime management complexity within individual providers while presenting a unified interface to the host, enabling multi-language support without centralized complexity
Solution Approach 2:
The extensibility framework provides universal language-agnostic interfaces and management mechanisms that work across all dynamic languages. This universal layer handles common concerns like function registration, parameter passing, and result retrieval, reducing the complexity of managing diverse language runtimes through standardized interactions
Data Source
AI summary
Using language add-ins with one or more static extensibility points of an application host. The method includes searching for user code in a user code store. Some user code is found in the user code store. A determination is made as to the language of the user code from among a plurality of predefined languages. The user code is provided to a language provider for the determined language. A function invocation is received from an application host. The function invocation is matched to at least a portion of the user code. The at least a portion of user code corresponding to the function invocation is executed via the language provider.