WebAssembly Component Framework for Glue-Code-Free Service Integration

Resolve Bottlenecks,
Find Innovative SolutionsGenerate Solutions

Solution Overview

Problem

Writing glue code for integrating fragmented software components is time-consuming and requires rewriting when services change, leading to inefficiencies and increased development time.

Innovation Solution

A composable processing framework using a WebAssembly component model allows developers to create custom code in their preferred language, leveraging WebAssembly runtime and interfaces to automate host language bindings, enabling efficient integration across programming languages and services without manual glue code.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Reliability

If glue code is written to integrate fragmented software components, then component integration is achieved, but development time and maintenance effort increase

Engineering Contradiction:

Improvecomponent integrationVSAvoiddevelopment time

Core Design Contradiction:

ReliabilityVSLoss of time

Solution Approach 1:

The patent introduces a WebAssembly runtime as an intermediary layer between host languages and WebAssembly components. This runtime automatically handles binding generation, memory management, and communication protocols, eliminating the need for manual glue code while enabling seamless integration of components written in different programming languages.

Inventive Principle:

Principle #24Intermediary (Mediator)

Solution Approach 2:

The patent replaces manual mechanical binding processes with automated WebAssembly component interfaces. Instead of developers manually writing glue code to connect components, the system uses standardized WebAssembly interfaces and a runtime environment to automatically generate bindings and manage component communication, significantly reducing development effort.

Inventive Principle:

Principle #28Mechanics substitution (Replace mechanical system)

2Reliability

If glue code is written in a specific host language, then integration is achieved, but code must be rewritten when services change

Engineering Contradiction:

ImproveintegrationVSAvoidservice changes

Core Design Contradiction:

ReliabilityVSAdaptability or versatility

Solution Approach 1:

The patent segments the integration layer into separate WebAssembly components that can be independently developed, tested, and replaced. Each component has well-defined interfaces through the WebAssembly component model, allowing individual components to be swapped or updated without affecting the entire system, thus improving adaptability to service changes.

Inventive Principle:

Principle #1Segmentation

Solution Approach 2:

The WebAssembly runtime provides universal binding generation capabilities that work across multiple host languages and service types. The standardized component interfaces enable the same integration framework to handle diverse services (databases, message brokers, HTTP services) without requiring language-specific glue code, enhancing versatility and adaptability.

Inventive Principle:

Principle #6Universality (Multi-functionality)

3Reliability

If manual glue code is used for integration, then component connection is achieved, but code reuse is limited

Engineering Contradiction:

Improvecomponent connectionVSAvoidcode reuse

Core Design Contradiction:

ReliabilityVSProductivity

Solution Approach 1:

The patent enables code reuse through WebAssembly component interfaces that can be instantiated and composed multiple times. Components are defined once with standardized interfaces and can be copied, instantiated, and composed in different configurations across multiple services and applications, significantly improving code reuse efficiency compared to manual glue code approaches.

Inventive Principle:

Principle #26Copying

Data Source

PatentEP4428676B1Composable processing framework based on web assembly component model

Publication Date: 2026.01.21 SAP SE

Figure 1
Figure 2
Figure 3

AI summary

In an example embodiment, a common, composable abstraction is provided that allows components to work efficiently across programming languages and services without the need to write glue code. Application developers can concentrate on the application logic itself. The functionality of services can be developed by framework developers only once, using the programming language of their choice.