IDIOM Decision Technology
The IDIOM Decision Manager is a desktop application built using XML technologies within a .NET framework. The Decision Manager generates source code that is implemented within a host environment. The generated runtime code is called the IDIOM Decision Engine.
The key architectural features of the IDIOM Decision Engine are:
- Passive - The Decision Engine only executes decisions when explicitly invoked by the calling application.
- Stateless - The runtime component does not store state between activations. All dynamic data is input to the Decision Engine at invocation. The Decision Engine modifies the state of the XML defined business objects and returns them.
- Decisions are compiled - all business decisions are compiled into the native programming language of the target platform (Java, C#). There is no runtime generation or interpretation.
- Deterministic - Decisions are executed in a well-defined order. For a given input and rule set, the path to derive the output is defined and testable.
- Simple static interface - The runtime interface to the IDIOM Decision Engine remains the same no matter what the rule set or input data. It does not change if the decisions are changed or re-generated. The application is isolated from the implementation of the decisions.
- Single point of integration - The Decision Engine does not (and can not) access any external applications or data. All data required by the Decision Engine to execute a set of decisions is supplied in the call to the server.
- Decisions are written against a business object model defined by an XML Schema.
These characteristics of the IDIOM Decision Engine differ substantially from more traditional rules engines. In contrast to the IDIOM Decision Engine, traditional rules engines are stateful, active and non-deterministic. Traditional rules engines maintain an active knowledge base of facts and rules. They execute continuously, firing rules in response to changes in input conditions and the state of their knowledge base. These rules engines are non-deterministic. A rule that has previously been determined not to be executable may subsequently be fired as a consequence of a change in the state of the knowledge base. As a consequence of their active and stateful nature, these rules engines are difficult to integrate with applications and tend to drive the architecture of the system.
In IDIOM, each language (Java, C#) has its own set of code fragments which are assembled in a highly ordered pattern during code generation. The order of code assembly is governed by the specification of the decisions and formulas that are captured and validated by the IDIOM Decision Manager. The end result of this process is high quality, high performance code in the language of choice that implements the decision formulas as prescribed by the user. This code is not dependent on any pre-installed runtime components, and there is no runtime licensing required.
The IDIOM Decision Engine has a simple local call interface that can be integrated in the manner that most suits the target architecture. Typical methods of integration include:
- Direct integration using local programming language API
- Wrapping IDIOM in a stateless session Java Bean
- Providing a loosely coupled interface via message-oriented middleware such as Sonic MQ, Microsoft MQ, IBM MQ Series or Java Message Service (JMS).
- Using IBM Business Rule Beans Architecture
- SOAP compliant web services interface
- Packaging as a COM callable DLL
This flexibility allows the IDIOM Decision Engine to be integrated into an application in the manner that best suits the particular architecture, rather than having to adapt or contort the architecture to accommodate the Decision Engine.
Another point to note is that the Decision Engine has a single point of integration: it integrates with the application entirely via the chosen call interface. The Decision Engine does not require integration with a database or any other external resource.
Secure Production Environments
For environments which maintain high degrees of security around their production code, IDIOM provides an option to place all aspects of code management within a secure production environment.
The IDIOM generator component, which assembles the program source, is a discrete component within the IDIOM Decision Manager that responds to an XML based specification of the Decisions. The generator can be detached from the IDIOM Decision Manager and placed in a secure environment – this means that only XML documents need to be passed into the production environment in order to implement new and changed decisions. Because all of the computer code is already validated and in the production environment, it is not possible for malicious or dangerous code to be introduced.
In fact, the XML document can be encrypted and certified by the IDIOM Decision Manager for transfer to the production generation tool.