Dynamic Rule Management via Non-Persistent Run-Time Files
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing software validation systems rely on hard-coded rules in files, leading to inefficiencies in managing and updating validation controls, causing idle time during validation and release procedures as files are edited or updated, and limiting the ability to validate data simultaneously.
Innovation Solution
Implementing a dynamic rule management system that uses soft-coded rules in non-persistent run-time files, where a rules template determines the necessary validation rules, allowing for real-time validation without requiring hard-coded controls, enabling ongoing editing and testing of rules while validation occurs.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Ease of operation
If hard-coded rules are used in files for validation, then validation controls can be defined and modified, but significant idle time occurs during validation procedures waiting for rules files to become available after editing
Solution Approach 1:
The system transitions from static hard-coded rules to dynamic soft-coded rules that can be modified at runtime. The rules are stored in a database and dynamically loaded into memory during validation, allowing rule updates without interrupting ongoing validation processes. This dynamic approach eliminates the need to wait for file availability and enables continuous validation operations.
Solution Approach 2:
The patent introduces a rules engine as an intermediary layer between the validation system and the rules database. The rules engine dynamically loads, manages, and executes validation rules in memory, acting as a mediator that decouples the validation process from file-based rule storage. This intermediary enables concurrent rule editing and validation operations without idle time.
2Adaptability or versatility
If hard-coded rules are edited or updated, then validation controls can be adjusted, but the file becomes unavailable for validation purposes during editing
Solution Approach 1:
The system implements dynamic rule loading where validation rules are loaded into memory from the database at runtime rather than being read from static files. This allows rules to be updated in the database while validation continues using the in-memory copy, ensuring both adaptability and reliability simultaneously.
Solution Approach 2:
The patent creates a copy of the validation rules in memory during the validation process. This in-memory copy serves as a working copy that can be modified without affecting the original database rules or interrupting validation operations. The copy mechanism enables safe concurrent editing and validation.
3Productivity
If soft-coded rules in non-persistent run-time files are used, then validation can occur simultaneously with rule editing and testing, but a different memory management approach is required
Solution Approach 1:
The patent employs non-persistent run-time files that are created fresh for each validation operation and automatically discarded afterward. These temporary files store the active validation rules in memory and are deleted after use, avoiding the complexity of persistent memory management while enabling simultaneous validation and editing operations.
Solution Approach 2:
The system creates new rule files in memory for each validation task and discards them after use, rather than maintaining persistent files. This discard approach simplifies memory management by ensuring no stale data remains, while the rules are recovered from the database on-demand for new validation operations.
Data Source
AI summary
Methods and systems are described herein for dynamic rule management without using hard-coded rules. A system may store, for example, in a persistent memory database, a first rule and receive a first request to process first input data using the first rule. In response to the first request, the system may retrieve a first rule template and initiate a first rule engine session. The system may generate, upon initiating first rule engine session, in a non-persistent memory database, a first non-persistent run-time file for validating the first input data using the first rule template. The first input data may be validated using the first non-persistent run-time file. The system may generate, for display, on a user interface, a validation confirmation for the first input data and end the first rule engine session.