API Simplification Process for Custom Software Systems

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Existing API systems are complex and cumbersome, requiring developers to sift through extensive documentation and source code to identify and remove unused functionality, which is time-consuming and inefficient.

Innovation Solution

An API simplification process that analyzes the source code of an API within a custom software system, identifies unused functionality based on the system's configuration, and automatically removes or deactivates it, generating a simplified API with reduced complexity.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Adaptability or versatility

If developers use existing comprehensive APIs with all possible functionality, then the API provides complete functionality and versatility, but the API becomes complex and time-consuming to navigate and customize

Engineering Contradiction:
ImproveAPI functionality completenessVSAvoidAPI complexity
Core Design Contradiction:
Adaptability or versatilityVSDevice complexity

Solution Approach 1:

The patent extracts only the necessary API functionality by analyzing the custom software system's source code to identify which API methods are actually used. Unused API methods are then removed from the API definition, creating a simplified version that contains only the functionality needed for the specific custom software system, thereby reducing complexity while maintaining required adaptability

Inventive Principle:
Principle #2Taking out (Extraction)

Solution Approach 2:

The patent applies local quality by customizing the API definition specifically for each custom software system based on its configuration. Instead of a one-size-fits-all comprehensive API, the system generates tailored API definitions that match the specific needs of each software system, making the API both complete for that system and simple to navigate

Inventive Principle:
Principle #3Local quality

2Device complexity

If developers manually review and edit API source code to remove unused functionality, then the API can be simplified, but the process becomes time-consuming and inefficient

Engineering Contradiction:
ImproveAPI complexityVSAvoidTime for API simplification
Core Design Contradiction:
Device complexityVSLoss of time

Solution Approach 1:

The patent implements self-service by having the system automatically analyze its own source code to determine which API functionality is used and which is not. The system performs the simplification process autonomously without requiring developer intervention, thereby reducing the time developers would otherwise spend manually reviewing and editing API source code

Inventive Principle:
Principle #25Self-service

Solution Approach 2:

The patent applies preliminary action by automatically performing the API simplification process during the software system configuration phase, before the developer needs to use the API. The system proactively identifies and removes unused functionality in advance, eliminating the need for later manual simplification work

Inventive Principle:
Principle #10Preliminary action

Data Source

PatentUS20250190179A1API simplification process
Publication Date: 2025.06.12 SAP SE
  • US20250190179A1 patent drawing
  • US20250190179A1 patent drawing
  • US20250190179A1 patent drawing

AI summary

Provided are systems and methods that can generate a simplified application programming interface for a custom software system that includes a pre-built application programming interface. In one example, a method may include receiving source code of an application programming interface (API) of a custom software system with built-in functionality for accessing the custom software system, identifying a subset of program components within the API which are not active based on a configuration of the software system, removing the subset of program components from the API to generate a simplified API for the custom software system, and transferring the simplified API to the storage.