API Prioritization via Dependency Ranking Scores
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing methods are inefficient in detecting and prioritizing application programming interfaces (APIs) within large software artifacts, such as legacy systems, which often consist of thousands of classes and hundreds of thousands of methods, making it difficult to determine which elements should be exposed for reuse in mobile applications or new software artifacts.
Innovation Solution
A method and system that analyze application code to identify dependencies between software elements, calculating a ranking score for each element to indicate its likelihood of being an API, using static and dynamic analysis to determine external accesses and invocations, and employing algorithms like page rank to prioritize API candidates.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If manual analysis methods are used to identify APIs in large software artifacts, then detection precision may be maintained, but productivity is severely reduced due to the sheer volume of classes and methods
Solution Approach 1:
The patent replaces manual mechanical analysis with automated computer-based analysis. The system uses software to automatically parse source code, build dependency graphs, and calculate ranking scores, substituting human effort with computational processes that can handle large volumes of software elements efficiently
Solution Approach 2:
The patent introduces ranking scores as a new parameter to prioritize API candidates. By calculating numerical scores based on dependency analysis and external access patterns, the system transforms the qualitative task of API identification into a quantitative ranking problem, enabling efficient filtering and prioritization of candidates
2Measurement precision
If all software elements are analyzed equally to detect APIs, then measurement precision is maintained, but loss of time increases due to the need to examine every class and method
Solution Approach 1:
The patent segments the analysis process into distinct phases: dependency graph construction, external access identification, and ranking score calculation. This segmentation allows the system to process software elements in an organized manner, focusing computational resources on the most relevant analysis steps rather than uniformly examining all elements
Solution Approach 2:
The patent performs preliminary dependency analysis before API detection. By first building a dependency graph and identifying external accesses, the system prepares structured information that accelerates the subsequent API ranking and detection process, avoiding the need for complete re-analysis of all software elements
3Measurement precision
If comprehensive dependency analysis is performed on all software elements, then API detection precision is improved, but device complexity increases due to the computational requirements
Solution Approach 1:
The patent extracts only the essential information needed for API detection: dependency relationships and external access patterns. By focusing on these specific aspects rather than analyzing all properties of software elements, the system maintains detection precision while reducing computational complexity
Solution Approach 2:
The patent applies partial action by calculating ranking scores for all software elements but then focusing detailed analysis only on high-scoring candidates. This approach performs comprehensive preliminary screening followed by targeted deep analysis, balancing precision requirements with computational feasibility
Data Source
AI summary
Methods, computing systems and computer program products implement embodiments of the present invention that include receiving, by a computer, application code including a set of software elements, and identifying dependencies between the software elements. Based on the dependencies, a respective ranking score can be calculated for each of the software elements, the respective ranking score for a given software element indicating a likelihood that the given software element is configured as an application programming interface (API).