Runtime Instruction Rewriting for Cross-Platform App Feature Changes
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing methods require developers to search and modify source code to change application features, necessitating recompilation and distribution through platforms like iTunes or Google Play, which is inefficient and labor-intensive.
Innovation Solution
A system that modifies machine-readable instructions at run-time to alter application behaviors without decompiling or accessing source code, using components like pre-process application, rule generation, and distribution components to automate feature modifications across different platforms and devices.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Ease of manufacture
If developers manually search and modify source code to change application features, then the application can be updated, but the process requires recompilation and is labor-intensive
Solution Approach 1:
The patent introduces an intermediary system that sits between the original application and the execution environment. This intermediary automatically modifies machine-readable instructions at runtime without requiring developers to manually search and edit source code. The system intercepts method calls, applies predefined transformation rules, and executes modified instructions, thereby eliminating the labor-intensive manual modification process while enabling rapid feature changes.
Solution Approach 2:
The system performs preliminary actions by pre-defining modification rules and transformation logic before runtime execution. Instead of modifying source code during development, the patent establishes a framework of rules that automatically transform machine-readable instructions when the application runs. This preliminary setup allows developers to define modification strategies in advance, eliminating the need for time-consuming manual code search and edit cycles.
2Adaptability or versatility
If source code modification is performed to update application features, then feature changes can be implemented, but recompilation is necessary which increases complexity
Solution Approach 1:
The intermediary system acts as a mediator that separates feature adaptability from source code modification complexity. It provides a rule-based transformation layer that enables flexible feature changes without requiring developers to navigate complex source code structures or perform recompilation. The intermediary handles the complexity of instruction transformation automatically, while developers simply define high-level modification rules.
Solution Approach 2:
The patent replaces the mechanical process of manual source code editing and recompilation with an automated electronic system. Instead of physically searching through code files, editing text, and triggering compilation processes, the system uses automated rule engines and transformation algorithms to modify application behavior. This substitution eliminates the complex manual workflow while maintaining feature adaptability.
3Productivity
If manual source code modification is used to update features across multiple builds, then each build must be individually modified, but this increases labor and costs
Solution Approach 1:
The patent creates a universal modification system that can apply the same transformation rules across multiple application builds and platforms simultaneously. The rule-based intermediary framework is platform-agnostic and can modify machine-readable instructions regardless of the target build or distribution platform. This universality allows a single set of modification rules to serve multiple builds, eliminating the need for individual manual modification of each version.
Solution Approach 2:
The system uses copying by applying the same modification rules and transformation logic across multiple builds without creating separate modified versions of source code. Instead of copying and manually editing each build's source code, the patent copies the modification framework and rules, which then automatically adapt to each target build at runtime. This approach dramatically reduces labor while maintaining consistency across multiple distributions.
Data Source
AI summary
Modification of application implementation may include modification, addition, and/or removal of machine-readable instructions. Modification of machine readable instructions prior to run-time may modify implementation of one or more features. Physical computer processor(s) may be configured by computer readable instructions to obtain machine-readable instructions. Machine-readable instructions may, cause a target computing platform to implement an application when executed. Physical computer processor(s) may obtain information regarding implementation of the application by the target computing platform and analyze the machine-readable instructions and/or the information to create one or more rules for modifying application implementation by the computing platform. Physical computer processor(s) may modify the machine-readable instructions based on the rules to add features to and/or remove features from the machine-readable instructions. The system may distribute the modified machine-readable instructions to effectuate the modified machine-readable instructions to be implemented by the target computing platform.