Executable Code Analysis for Non-Portable API Detection
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
The complexity and cost of developing and deploying enterprise-level computer system applications are increased due to the need for scalability, availability, and interoperability, with traditional portability verification tools being inefficient in identifying non-portable features that may lead to compatibility issues across different application server vendors, even when they claim compatibility with the same standards.
Innovation Solution
A method and system for detecting non-portable application programming interface usage via executable code analysis, which identifies conditions for inclusion of object classes within acceptable classes, analyzes executable code to generate a portability verification report, and specifies portability criteria without modifying source code, ensuring compliance with standard API specifications.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Measurement precision
If traditional portability verification tools are used, then source code access is required for analysis, but this increases development cost and complexity
Solution Approach 1:
The patent uses deployment descriptors as an intermediary to verify portability without accessing source code. The tool analyzes the compiled application's deployment descriptors, which contain information about API usage and configuration, thereby mediating between the need for verification and the restriction of source code access
Solution Approach 2:
The patent replaces the mechanical process of source code analysis with automated analysis of deployment descriptors and executable code metadata. This substitution eliminates the need for manual source code review while maintaining verification capability through automated tooling
2Adaptability or versatility
If executable code analysis is used instead of source code access, then vendor dependency is reduced, but detection precision of non-portable features may be compromised
Solution Approach 1:
The patent performs preliminary analysis during the deployment descriptor validation phase, before actual deployment. By checking API usage against the specification early in the process, the system identifies non-portable features proactively, allowing developers to correct issues before they cause deployment problems
Solution Approach 2:
The patent implements a feedback mechanism where the portability verification tool provides detailed reports on non-compliant API usage. The system compares detected API calls against the application server specification and feeds back specific violations, enabling iterative improvement of application portability
3Reliability
If comprehensive quality assurance testing is performed across multiple platforms, then application compatibility is ensured, but testing cost and time increase substantially
Solution Approach 1:
The patent performs preliminary portability verification by analyzing deployment descriptors and executable code metadata before actual deployment testing. This preliminary analysis identifies potential compatibility issues early, allowing developers to address them before investing time in extensive multi-platform testing
Solution Approach 2:
The patent applies preliminary anti-action by proactively detecting and flagging non-portable API usage patterns before they can cause deployment failures. The system prevents compatibility problems by identifying violations of the application server specification in advance, rather than waiting for testing to reveal issues
Data Source
AI summary
A method for detection of non-portable application programming interface usage via executable code analysis includes identifying one or more conditions for inclusion of an object class within a set of acceptable object classes, wherein a reference to any object class of the set of acceptable object classes by an application is in compliance with a specified portability criterion. The method further includes analyzing an executable version of the application to identify object classes referenced by the application, and generating a portability verification report for the application, wherein the report indicates that the application violates the specified portability criterion if an object class referenced by the application does not meet at least one of the conditions for inclusion in the set of acceptable classes.