Software Hierarchy Restructuring via Dependency Clustering
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Legacy software systems suffer from increased complexity and maintenance costs due to false dependencies between interface and implementation files, leading to longer compilation times and larger preprocessed code sizes, with existing solutions being unsuitable for large datasets and lacking user control over restructuring extent.
Innovation Solution
A method that determines dependencies between program units, represents them as bit strings, clusters correlated bit strings into partitions, and creates new interface files based on these partitions to minimize false dependencies, allowing user-controlled restructuring.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Device complexity
If interface files include multiple program units to reduce the number of interface files, then the number of interface files decreases, but false dependencies increase and compilation time increases
Solution Approach 1:
The patent segments interface files into multiple specialized interface files based on clustering analysis of dependency patterns. Instead of having one large interface file containing all program units, the system divides them into logical groups that are included only where needed, reducing false dependencies and compilation time while maintaining the necessary number of interface files for modularity.
Solution Approach 2:
The patent changes the organizational parameter of interface files from a flat structure to a hierarchical structure based on clustering results. By analyzing dependency parameters and reorganizing program units according to their actual usage patterns, the system optimizes the balance between the number of interface files and compilation efficiency.
2Reliability
If interface files include all program units to ensure completeness, then coverage is improved, but preprocessed code size increases
Solution Approach 1:
The patent extracts only the necessary program units into each interface file based on clustering analysis of actual dependencies. Instead of including all program units in every interface file to ensure completeness, the system selectively includes only those units that are actually needed by the corresponding implementation files, thereby reducing preprocessed code size while maintaining interface completeness where required.
3Device complexity
If automated reorganization of code hierarchy is performed to remove false dependencies, then dependency structure is improved, but user control over restructuring extent is lost
Solution Approach 1:
The patent introduces feedback mechanisms that allow users to review clustering results and control the extent of restructuring. The system analyzes dependency patterns and presents reorganization options to users, who can then decide whether to accept the automated reorganization or modify it. This feedback loop maintains improved dependency structure while preserving user control over the restructuring process.
4Device complexity
If graph-based algorithms are used to partition dependencies, then false dependencies are removed, but handling of large datasets becomes inefficient
Solution Approach 1:
The patent replaces traditional graph-based algorithms with a clustering-based approach that is more efficient for large datasets. Instead of using complex graph partitioning methods that scale poorly, the system uses clustering techniques that can handle large numbers of program units and dependency relationships more efficiently, maintaining dependency optimization while improving processing efficiency for large codebases.
Data Source
AI summary
Method, apparatus, and computer readable medium for restructuring a software program hierarchy having interface files and implementation files that include the interface files are described. In one example, dependencies between program units in the interface files and the implementation files are determined. The dependencies are represented as a plurality of bit strings. Correlated bitstrings of the plurality of bit strings are clustered into a plurality of partitions. Each of the plurality of partitions is transformed into corresponding program units. New interface files are respectively created having the corresponding program units for each of the plurality of partitions.