Source Code Segmentation for Automatic Design Association
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current software development environments face challenges in efficiently sharing code and maintaining code/design associations, leading to difficulties in upgrading and managing code, files, and databases.
Innovation Solution
The method introduces a bridging mechanism by analyzing existing source code to encapsulate control and process elements as augmented state machines and kernels, allowing for meta-data attachment and automatic code/file/database association, enabling sub-subroutine level software sharing and upgrading.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Extent of automation
If conventional code sharing models are used, then code can be shared at the subroutine level, but code sharing at the sub-subroutine level is not possible and manual association of code with design is required
Solution Approach 1:
The patent segments subroutines into smaller functional blocks called code blocks, which can be independently shared and managed. This segmentation enables sharing at the sub-subroutine level by breaking down large subroutines into manageable code blocks that can be selectively shared across different projects while maintaining automatic association through metadata tags.
Solution Approach 2:
The patent introduces metadata as an intermediary layer between code blocks and design elements. This metadata contains identification information that automatically associates code blocks with their corresponding design elements, eliminating the need for manual association while enabling fine-grained code sharing through the metadata-driven connection system.
2Productivity
If developers manually locate and associate code blocks, then code-design association can be maintained, but the process is time-consuming and error-prone
Solution Approach 1:
The patent implements self-service through automatic association mechanisms where code blocks automatically link to their corresponding design elements via embedded metadata. The system performs the association task autonomously without requiring developer intervention, thereby eliminating time loss while maintaining code-design association integrity and enabling efficient code sharing.
Solution Approach 2:
The patent applies preliminary action by pre-tagging code blocks with metadata containing identification information before the code sharing process. This preliminary tagging enables automatic association to occur seamlessly when code blocks are shared, eliminating the need for time-consuming manual association operations while ensuring accurate code-design linking.
3Ease of manufacture
If entire subroutines are shared, then code sharing is simple to implement, but it is inefficient to share code that is not required
Solution Approach 1:
The patent segments subroutines into smaller code blocks that can be selectively shared based on actual requirements. This segmentation allows developers to share only the specific functional blocks needed rather than entire subroutines, reducing unnecessary code sharing while maintaining ease of implementation through the standardized code block format and metadata-driven association system.
Solution Approach 2:
The patent extracts specific functional blocks from larger subroutines to create shareable code blocks. This extraction process allows only the necessary portions of code to be shared and reused across projects, eliminating the waste of sharing unnecessary code while maintaining simplicity through the standardized extraction and sharing mechanism.
4Adaptability or versatility
If code and design become disassociated, then development flexibility is improved, but maintaining code-design and file/database association becomes difficult
Solution Approach 1:
The patent implements feedback through bidirectional association between code blocks and design elements via metadata. When code blocks are modified, the system automatically updates associated design elements and file/database references, and vice versa. This feedback mechanism maintains synchronization and association automatically, providing development flexibility while eliminating the complexity of manual association maintenance.
Solution Approach 2:
The patent uses metadata as an intermediary to maintain associations between code blocks, design elements, and file/database references. This metadata layer acts as a mediator that automatically tracks and synchronizes relationships, allowing development flexibility through independent modification while automatically maintaining all necessary associations without manual intervention.
Data Source
AI summary
A system and method for automatic code-design and file/database-design association. Existing source code is analyzed for process and control elements. The control elements are encapsulated as augmented state machines and the process elements are encapsulated as kernels. The new elements can then have meta-data attached (including, a name, I/O method, and test procedures), allowing software code sharing and automatic code/file/database upgrading, as well as allowing sub-subroutine level code blocks to be accessed directly.