Event-Driven Programming Model for Scalable Distributed Applications
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current software development practices, particularly in distributed systems, face challenges in achieving agility and adaptability due to the lack of a unified programming model, leading to business and technical silos, constrained interoperability, and difficulties in testing and debugging, which hinder the transformation into real-time digital businesses.
Innovation Solution
A cloud-native architecture that utilizes an event-driven programming model with a system agent program executing dynamically assigned functions in a blackboard memory, enabling parallel execution and context sharing between inter-dependent processes, and dynamically assigning web containers based on published events to facilitate complex event processing and dataflow modeling.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If a unified programming model is implemented for event-driven processing, then interoperability and adaptability improve, but system complexity increases
Solution Approach 1:
The patent introduces an event broker as an intermediary component that mediates between event sources and event consumers. The event broker receives events from multiple sources, standardizes their format, and routes them to appropriate consumers, thereby improving interoperability without requiring direct integration between all system components. This mediator approach reduces system complexity by centralizing the integration logic.
Solution Approach 2:
The event-driven programming model provides a universal framework that can handle diverse event types and communication patterns through a single standardized interface. The model supports multiple event sources, consumers, and routing strategies within one unified architecture, enabling different systems to interoperate without custom integration code for each pair of components.
2Productivity
If asynchronous parallel dataflow processes are used, then processing speed and scalability improve, but difficulty in testing and debugging increases
Solution Approach 1:
The patent incorporates comprehensive event logging and tracing mechanisms that provide feedback about event flow through the asynchronous parallel dataflow processes. Each event carries metadata including source, destination, timestamp, and processing state, enabling developers to track event progression through multiple parallel streams. This feedback mechanism makes testing and debugging feasible by providing visibility into otherwise opaque asynchronous operations.
3Adaptability or versatility
If dynamic application construction is enabled, then adaptability to changing requirements improves, but loss of information and increased complexity occur
Solution Approach 1:
The event-driven model enables applications to be constructed dynamically by pre-defining event handlers and subscription mechanisms that can be activated and configured at runtime. Event sources and consumers are registered in advance with their processing logic, but the actual event flow and active subscriptions are determined dynamically based on runtime conditions. This preliminary setup reduces information loss by preserving the event processing logic while allowing flexible activation.
Data Source
AI summary
An example method comprises receiving one or more published events by an event hook application program interface (API) from one or more client applications, passing a model to a web server configured to generate web containers in concurrent threads, receiving, by any number of worker nodes, each web container, each of the worker nodes including a system agent program for dynamically assigned functions, the web containers being provided to the any number of worker nodes for logical isolation of system agent execution in memory, and performing the dynamically assigned functions by the system agent program in a blackboard memory, the blackboard memory being a shared memory with non-blocking reads and writes and performing functionality, the dynamically assigned functions being executed in parallel and at least two of the dynamically assigned functions sharing context between inter-dependent processes.