Multi-Flavored Software Execution From Singular Code Base
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Traditional software deployment methods require multiple builds of a computer program to support different versions, leading to inefficiency and a large executable size due to the need for all possible functional features to be present, even if not all are used by end users.
Innovation Solution
A method and system for multi-flavored software execution from a singular code base, where an interpreter receives a request to interpret only selected portions of source code annotated with specific version tags, transforming the code into byte code for a virtual machine, allowing multiple versions without requiring a large executable.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If all possible functional features are included in the executable program, then the program can support multiple versions, but the executable size becomes massive
Solution Approach 1:
The patent segments the monolithic executable into separate shared libraries for different functional features. Each library contains code for specific features, and the linker dynamically combines only the required libraries based on version tags, avoiding inclusion of all possible features in a single executable.
Solution Approach 2:
The patent creates a universal base executable that can support multiple versions through dynamic library loading. The executable contains version identification logic and automatically loads appropriate feature libraries at runtime, making it adaptable to different versions without being tied to a single feature set.
2Manufacturing precision
If multiple different builds are created for different versions, then each version can be optimized, but the deployment complexity increases
Solution Approach 1:
The patent merges multiple version-specific builds into a single universal executable that uses dynamic library loading. Instead of maintaining separate executable files for each version, the system combines them into one executable that automatically selects and loads the appropriate feature libraries based on version tags, simplifying deployment while preserving version optimization.
Solution Approach 2:
The patent introduces dynamic library loading and version tag-based selection mechanisms that allow the executable to adapt its behavior at runtime. The system dynamically determines which version is needed and loads corresponding libraries, replacing static multi-build approaches with a flexible dynamic resolution system.
3Ease of manufacture
If a single deployable program with selective feature enabling is used, then deployment is simplified, but the executable size remains large due to all features being present
Solution Approach 1:
The patent segments the program into a core executable and separate shared libraries for different functional features. This allows the executable to remain relatively small while maintaining deployment simplicity, as the libraries are loaded dynamically only when needed rather than being statically linked into the main executable.
Solution Approach 2:
The patent introduces shared libraries as intermediary components between the executable and the functional features. These libraries act as intermediaries that can be selectively loaded and unloaded, allowing the system to maintain simple deployment while avoiding the inclusion of all features in the main executable at once.
Data Source
AI summary
Embodiments of the present invention provide a method, system and computer program product for multi-flavored software execution from a singular code base. In an embodiment of the invention, a method for multi-flavored software execution from a singular code base is provided. The method includes receiving a request in an interpreter to interpret a version of source code of a computer program the interpreting transforming the source code into byte code executable by a virtual machine. The method thereafter includes responding to the request by performing in the interpreter source code interpretation only of selected portions of the source code being annotated by tags corresponding to the version.