Generative Aspect-Oriented Programming Middleware Stubs
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional middleware development platforms require sophisticated knowledge of interface description languages (IDL) and specific language mappings, leading to inefficient development due to cluttered middleware-specific information in stubs and skeletons, and pose challenges when switching between different middleware systems.
Innovation Solution
A generative, aspect-oriented programming (GAOP) system that generates middleware-independent stubs and skeletons, propagating authentication context, specifying timeouts, and providing target component identities, thereby isolating developers from middleware-specific details and enabling seamless interaction between components.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If conventional middleware-specific stubs and skeletons are used, then middleware functionality is provided, but developer productivity is reduced due to cluttered middleware-specific information and requirement of sophisticated IDL knowledge
Solution Approach 1:
The patent extracts and removes middleware-specific information (such as IDL references, CORBA markers, and middleware API calls) from the generated stubs and skeletons. This extraction process creates a clean, simplified interface that maintains the essential middleware functionality while eliminating the cluttered middleware-specific details that hinder developer productivity.
Solution Approach 2:
The patent introduces a generative programming system as an intermediary between the developer and the middleware. This system automatically generates simplified stubs and skeletons that act as mediators, translating high-level developer code into middleware-specific calls without requiring developers to directly interact with complex IDL definitions or middleware APIs.
2Adaptability or versatility
If middleware-specific stubs and skeletons are generated, then middleware interoperability is achieved, but complexity increases when switching between different middleware systems
Solution Approach 1:
The patent creates a universal generative programming system that can generate stubs and skeletons for multiple different middleware systems (such as CORBA, DCOM, RMI) from a single unified interface description. This multi-functionality allows developers to switch between middleware systems without rewriting their application code, as the same high-level interface can be generated for different middleware implementations.
Solution Approach 2:
The patent employs parameter changes by allowing the generation system to accept different middleware-specific parameters or configuration settings while maintaining the same high-level interface structure. By changing implementation parameters rather than structural elements, the system achieves adaptability to different middleware systems without increasing switching complexity.
3Reliability
If strict IDL interface definitions are used, then middleware interoperability is ensured, but ease of operation is reduced due to rigid interface constraints
Solution Approach 1:
The patent segments the interface definition into two distinct layers: a high-level abstract interface that developers interact with (providing ease of operation) and a low-level middleware-specific interface generated automatically (ensuring interoperability). This segmentation allows the strict IDL definitions to remain in the background while developers work with simplified, more intuitive interfaces.
Data Source
AI summary
A system uses generative aspect oriented programming to propagating context between components in a component server, the system produces code that, when executed, implicitly propagates authenticating context between a client component and an invoked component which the client component invokes in a component server. The system generates a function that allows the specification of a timeout between the client component and the invoked component that the client component invokes in the component server. The timeout function receives a user-defined timeout value to be applied for interface invocations between the client component and the invoked component. The system further generates a function declaration that, upon execution, discloses a target component identity between a client component and an invoked component that the client component invokes in the component server. The target component identity specifies a specific identity of a target computer system to which an interface invocation between the client component and the invoked component is directed.