Distributed Software Development via Transparent RPC Emulation
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Developing distributed software for distributed systems is cumbersome due to the need for developers to learn multiple programming languages and implement remote procedure calls (RPCs) or inter-process communication (IPC) mechanisms, complicating the development process and increasing costs.
Innovation Solution
A method and tool that identify and separate routines in a single computer program to create functionally equivalent routines for different computing devices, using an inter-process communication mechanism, allowing direct calls to be emulated for remote invocations, thus simplifying the development process and focusing on business logic rather than operational details.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If developers implement distributed software using traditional methods with multiple programming languages and RPC/IPC mechanisms, then the software can run on different computing devices, but the development complexity and time increase significantly
Solution Approach 1:
The patent segments the development process into two distinct phases: a development phase using a single programming language with direct calls, and a runtime phase where the runtime environment automatically generates and executes the appropriate RPC/IPC code. This segmentation allows developers to work with simplified code while the system handles the complexity of distributed communication automatically.
Solution Approach 2:
The patent introduces a runtime environment as an intermediary between the developer's code and the actual distributed system execution. This runtime environment automatically generates the necessary RPC stubs, proxies, and communication code, shielding developers from the complexity of implementing distributed protocols manually while ensuring proper execution across different devices.
2Reliability
If developers learn multiple programming languages and IPC mechanisms to develop for different computing devices, then they can create platform-specific optimized software, but the training time and costs increase
Solution Approach 1:
The patent creates a universal development approach where a single programming language and a set of standardized attributes can target multiple computing device platforms. The runtime environment on each platform provides platform-specific optimizations and implementations while maintaining a consistent development model, allowing developers to write code once and deploy it across diverse devices without extensive platform-specific training.
Solution Approach 2:
The patent uses parameter changes in the form of attributes that can be attached to code elements to specify target platforms, communication protocols, and other execution parameters. By changing these parameters rather than rewriting code, the same source code can be adapted to different computing devices with platform-specific optimizations applied automatically during the build or runtime process.
3Ease of operation
If developers manually implement RPC mechanisms for remote invocations, then precise control over communication is achieved, but the development time and effort increase
Solution Approach 1:
The patent applies preliminary action by having the runtime environment pre-generate all necessary RPC stubs, proxies, and communication infrastructure code before execution. Developers declare their intent using simple attributes on existing code, and the system automatically performs the complex task of generating communication protocols and remote invocation mechanisms, significantly reducing development time while maintaining control over the communication behavior through declarative specifications.
Data Source
AI summary
In a method for building distributed software, a single computer program may be written which includes distinct sets of routines defining operation at distinct computing devices (or types of computing devices) in a distributed system. Direct calls may be made between routines, even if the routines define operation of distinct computing devices. Through examination and processing of the computer program, multiple computer programs which collectively constitute distributed software for the distributed system are created. Each program defines the operation of a computing device within the system. Direct calls are emulated using instructions for inter-process communication which effect remote routine invocation transparently from the perspective of the developer. In the result, the run-time operation of each output computer program at its respective target computing device is consistent with the operation defined for that computing device within the input computer program. Advantageously, the developer may be shielded from numerous implementation details.