Label-Based Software Customization for Conflict-Free Code Variants
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing software customization techniques face challenges in managing conflicts between base code and customized code, especially when different writing standards are involved, and metadata customization is often complex due to its non-readable nature, leading to difficulties in delivering customized software applications.
Innovation Solution
A system and method for software customization that tags customizations with labels to differentiate them from existing code or metadata, allowing for conditional logical selection during runtime or compilation to avoid conflicts and adhere to different standards.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If base code is customized to form a customized version, then the software can meet specific requirements, but conflicts arise with subsequent base code changes
Solution Approach 1:
The patent segments code into distinct layers: base code layer and customization layer. Each layer is independently managed with its own version control, allowing customization to be applied to specific base code versions without being affected by subsequent base code changes. This segmentation prevents conflicts by maintaining clear boundaries between base functionality and customized extensions.
Solution Approach 2:
The patent implements a nested structure where customization code is embedded within the base code framework but maintains independent identification through metadata tags. The customization layer nests within the base code structure while preserving the ability to selectively apply or remove customizations without affecting the base code integrity, thus resolving conflicts between customization and base code evolution.
2Adaptability or versatility
If metadata customization is performed, then software configuration flexibility is improved, but understanding and resolving conflicts becomes more complex
Solution Approach 1:
The patent introduces metadata as an intermediary layer between base code and customization. This metadata layer provides structured information about customization scope, version compatibility, and dependency relationships. The metadata acts as a mediator that automatically identifies and resolves conflicts between base code changes and customizations, reducing the complexity of conflict detection and management.
Solution Approach 2:
The patent uses metadata parameters to dynamically control the application of customizations based on base code version, environment, and configuration settings. By changing metadata parameters rather than manually managing code conflicts, the system automatically adapts to base code changes and maintains consistency between base functionality and customizations across different versions.
3Ease of manufacture
If code is merged from base and customization, then integration is achieved, but delivery under different writing standards becomes impossible
Solution Approach 1:
The patent segments the delivery process into separate artifacts: base code deliverables and customization deliverables. Each segment maintains its own writing standards and formatting requirements. The segmentation allows both base code and customization to be delivered under their respective standards while still functioning together when deployed, eliminating the conflict between integration and standard compliance.
Solution Approach 2:
The patent resolves the standard compliance conflict by operating in another dimension - the metadata configuration space. Through metadata, the system specifies which writing standards apply to which code segments, enabling multi-standard compliance within a unified delivery structure. This dimensional approach allows simultaneous adherence to different standards without requiring physical separation of code.
Data Source
AI summary
As described herein, a system, method, and computer program are provided for code customization. A customization of existing code or metadata defining a software application is received, to form a customized version of the software application. The customization is tagged with a label that differentiates the customization from the existing code or metadata. During runtime or compilation time, a conditional logical selection between the existing code or metadata and the customization is made, using the label.