Semantic Variable Linking for Modular Binary Object Updates
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
The existing linker/loader technology in contemporary operating systems, such as AIX, Linux, and Z/OS, is inadequate for handling the complexities introduced by Object Oriented programming languages, requiring entire programs to be retranslated for changes like adding or removing virtual functions, which restricts the flexibility and maintenance of shared libraries.
Innovation Solution
A method where software code is translated into binary objects using semantic variables for hard-coded values, allowing only affected objects to be recompiled, rather than the entire program, by creating a table of semantic variables that can be replaced with hard-coded values during the linking or loading process.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If traditional linker/loader technology is used, then programs can be loaded into memory, but entire programs must be retranslated when changes are made to shared libraries
Solution Approach 1:
The patent segments the translation process by introducing semantic variables that separate compile-time constants from runtime values. This allows individual binary objects to be translated independently without requiring retranslation of the entire program when shared libraries are modified, directly resolving the contradiction between adaptability and translation time.
Solution Approach 2:
The patent introduces semantic variables as intermediaries between the binary objects and hard-coded values. These semantic variables act as mediators that can be replaced during linking or loading, enabling modifications to shared libraries without requiring complete retranslation of dependent programs.
2Productivity
If semantic variables are introduced to enable modular updates, then only affected objects need recompilation, but the translation process becomes more complex
Solution Approach 1:
The patent applies preliminary action by pre-translating source code into binary objects with semantic variables embedded, but not yet resolved to hard-coded values. This preliminary translation stage separates the compilation process from the final value resolution, enabling faster updates since only affected objects need recompilation rather than complete program retranslation.
Solution Approach 2:
The patent changes the parameter representation from direct hard-coded values to semantic variables that can be dynamically resolved. This parameter change enables the system to maintain productivity by allowing selective recompilation while managing complexity through standardized semantic variable handling mechanisms.
3Adaptability or versatility
If shared libraries are made resizable and modular, then flexibility in library updates is improved, but compatibility issues between different program versions arise
Solution Approach 1:
The patent introduces dynamics by making class sizes and object layouts adjustable rather than fixed. Semantic variables enable the system to dynamically adapt to different class definitions and memory layouts, allowing shared libraries to be resized or modified without breaking binary compatibility with existing program versions.
Solution Approach 2:
The patent implements feedback mechanisms that allow the system to detect and resolve compatibility issues when semantic variables are resolved. This feedback loop ensures that when shared libraries are modified, the system can identify and address potential compatibility problems, maintaining reliability while enabling flexibility.
Data Source
AI summary
A method of converting software code to an object on a computing device may include receiving the software code at the computing device and translating at the computing device the software code to an object file. Translating the software to the object file may include determining that the software code includes an item of interest that requires a value being coded into the object. The method may also include creating a variable to represent the coded value and storing the variable, which is linked to the coded value, in a table of variables associated with the object file.