Incremental Software Loading via Code Update Loader
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
In centralized computing systems managing multiple versions of software, upgrading software products is time-consuming and expensive due to redundant loading of minor differences between plugin versions, especially when dynamically loading plugins for coexisting versions.
Innovation Solution
Implementing an incremental approach to dynamic loading, where only the differences between plugin versions are loaded, and unchanged code is retrieved from previous versions, using a centralized management system with a code update loader that iteratively checks for required code portions across dependent packages.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If dynamic loading is applied to coexisting software versions, then software version flexibility is improved, but processor usage efficiency deteriorates due to redundant code loading
Solution Approach 1:
The patent segments the software code into modular packages with version identifiers, allowing the system to load only specific code portions corresponding to the requested software version rather than loading entire software suites. This segmentation enables selective loading of version-specific code while sharing common code across versions, thereby improving processor usage efficiency while maintaining software version flexibility.
2Adaptability or versatility
If all plugin versions are dynamically loaded, then software functionality is improved, but loading time increases due to redundant code
Solution Approach 1:
The patent extracts and identifies the specific code portions that differ between plugin versions, separating version-specific code from common code. When loading, the system extracts only the necessary version-specific code portions rather than loading entire duplicate copies of all code, thereby reducing loading time while maintaining full software functionality across versions.
Solution Approach 2:
The patent implements partial loading by loading only the necessary code portions required for the requested software version rather than loading all possible code. The system performs just enough loading action to satisfy the specific version requirement, avoiding excessive loading of redundant code, thus reducing loading time while preserving complete functionality for that version.
3Use of energy by moving object
If incremental approach is used for dynamic loading, then processor usage efficiency is improved, but system complexity increases
Solution Approach 1:
The patent performs preliminary actions by pre-organizing code into versioned packages with clear dependency relationships and version identifiers before runtime. The system pre-processes and structures the codebase into incremental units that can be efficiently loaded, which simplifies the runtime loading process despite the initial organizational complexity, ultimately improving processor usage efficiency.
Solution Approach 2:
The patent introduces an intermediary code update loader that manages the complexity of incremental loading by mediating between the request for specific software versions and the actual code loading process. This intermediary component handles the logic of identifying, selecting, and loading only the necessary incremental code portions, shielding the rest of the system from complexity while improving processor usage efficiency.
Data Source
AI summary
A method and a system for dynamic loading of incremental changes of software in a centralized data management system are provided herein. The method may include the following steps: requesting to load a specified code portion for a specified version of the software; checking if the specified code portion is provided by a specified software package associated with the specified version; in a case that the specified code portion is provided by the specified software package, loading the class from the specified package; in a case that the specified code portion is not provided by the specified software package, iteratively checking in earlier packages upon which the specified package depends, until the specified code portion is found; and loading the specified code portion from the earlier package where the specified code portion is found.


