Asynchronous State Engine with Plugin Transition Tables
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current business applications face complexity and maintainability issues when interfacing with external applications that need to affect state changes, requiring cumbersome 'if-then' conditions and frequent modifications to handle various external applications, leading to increased software complexity and difficulty in maintenance.
Innovation Solution
Implementing an asynchronous state engine with a state transition table that allows external applications to plug-in criteria for state changes, enabling the host application to hold states until responses are received from external applications, and specifying follow-up actions, thus decoupling the host application from external interactions and allowing flexible updates without modifying the host application itself.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If the host application uses traditional state engine with if-then conditions to handle external applications, then the application can process state changes, but the software complexity increases and maintenance becomes difficult
Solution Approach 1:
The patent segments the state engine functionality by separating the core state transition logic from external application-specific logic. The state engine is divided into a core component that handles state transitions and a plugin component that handles external application interactions. This segmentation allows the host application to maintain simple core logic while external applications can be added through plugins without increasing core complexity.
Solution Approach 2:
The patent introduces a state transition table as an intermediary layer between the state engine and external applications. This table acts as a mediator that stores predefined state transition rules and external application requirements. The state engine queries this table to determine how to handle state changes, eliminating the need for complex if-then conditions in the host application code and reducing software complexity.
2Adaptability or versatility
If the host application modifies itself to integrate new external applications, then the application can support new functionalities, but the maintainability decreases
Solution Approach 1:
The patent enables the system to adapt to new external applications through self-service mechanisms. The state transition table is designed to be externally modifiable, allowing new applications to register their requirements by updating the table without requiring host application modifications. The state engine automatically picks up these changes from the table, providing self-service integration capability that maintains ease of repair.
Solution Approach 2:
The patent creates a universal interface mechanism through the state transition table that can accommodate multiple different external applications with a single unified approach. Instead of creating specialized integration code for each application, the universal table structure allows any external application to define its state transition requirements in a standardized format, making the system multi-functional without increasing maintenance burden.
3Reliability
If the state engine waits for external application responses before state changes, then accuracy is improved, but the processing time increases
Solution Approach 1:
The patent applies preliminary action by pre-defining state transition rules and external application requirements in the state transition table before actual state changes occur. The table contains predetermined conditions and actions for each state transition scenario. When a state change is needed, the engine simply queries the pre-configured rules rather than making real-time decisions, ensuring accuracy while minimizing processing time.
Data Source
AI summary
Various embodiments of the present disclosure provide for an asynchronous state engine incorporated within a host application program. The state engine may operate based on a state transition table that may be updated independently of the host application. The state transition table may instruct the asynchronous state engine as to actions that should be performed prior to changing states. Such actions may include interacting with external applications. The state transition table may also instruct the host application to reside in a hold state until responses from external applications are received. Furthermore, the state transition table may instruct the host application as to follow up actions that should be performed when a state is entered. By allowing an external application to plug-in criteria for state changes within the host application, development of the host application may maintain a significant level of flexibility.