IDIOM Decision Manager - Technical Overview

The IDIOM Decision Manager is a desktop application built using the latest Microsoft C# and XML technologies within a .NET application. The Decision Manager generates C# or Java source code that is implemented within a host environment behind the IDIOM supplied static interfaces, and accessed either by native method calls or by using any of the supplied adapters. All generated and supplied code for the runtime is provided in source code form, to be compiled into an 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 Decision Engine does not store state between activations. All dynamic data is input to the Decision Engine at invocation or via reference table lookups. The Decision Engine modifies the state of the XML defined business objects and returns them. [Note: use of external reference data introduces a dependency].
  • Decision Models 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 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.
  • Decisions are written against a business object model defined by one or more XML Schemas.
     

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 test and to integrate with applications, and they tend to drive the architecture of the system.
 

In IDIOM, each language (Java, C#) has its own generator which assembles the source code 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 automates the defined decision making. This code is not dependent on any pre-installed runtime components or servers, and no licensed runtime components are required to deploy an IDIOM Decision Engine.
 

The IDIOM Decision Engine has a simple local call interface that can be integrated in the manner that most suits the target architecture. Supplied 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)
  • SOAP compliant web services interface
  • Packaging as a COM callable DLL
  • Packaging within a variety of BPM interface components, (examples include Biztalk, Singularity)
  • Packaging within data integration tools - for example, Talend
  • Integration into Adobe Flex applications
  • Integration into Lotus Domino applications
  • Integration into RAD tools - for example, Portrait, CA-Plex, Jade
     

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. IDIOM provides a free set of sample integration components or reference implementations to get you started.
 

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 generation and management within a secure production environment. The Production Release feature can be also be used to assemble a manifest of all artifacts (XML defined decision model, audit logs, generated documentation, generated source code) which is digitally certified before transfer to the production environment.