I sat down with Innovations Software Technology, now part of the Bosch group, to get my first good look at Visual Rules in a while. Release 4.4 is the current version (they released 4.3 in November and 4.4 just this week).
The tool is written in Java and based on Eclipse. About half their users are pure Visual Rules users, the other half are using it in conjunction with other Eclipse plug-ins and modules. Their Eclipse components have two perspectives – a Modeling one focused on rules and an Integration one focused on technical implementation options and integration with the rest of the Java environment. Everything seems nicely integrated with Eclipse and projects/packages can contain non-Visual Rules objects for clarity and management.
The repository follows a package hierarchy model similar to Java’s with projects within those packages that contain rule models. Packages provide scoping for the rule models and everything in the tool is strongly typed, using a business object model that is based on Java. All the usual repository features – versioning, check-in/check-out, locking etc. – are supported. Each rule model contains the rules, data types, actions and data definitions it needs. Models are scoped and parameterized using the data definitions.
The core model is a flow rule – something like a combination of decision or rule flow and a decision tree. A branching model of rules with actions and assignments possible at every node (not just the lead nodes as you might see in a decision tree) is represented in a nice graphical editor. Branches and rules can be activated and deactivated and sub-flows defined and called. Loops can be defined and an extensible palette of actions is available such as setting values and calling services. Loops can be defined and rules can be represented using a decision table. The decision tables, like the flow rules, have a nice drag-and-drop interface and use the traditional decision table approach rather than a rule-sheet style. By default, decision tables assume only a single action can be taken. The user can specify that multiple matches in a decision table (matching all valid conditions instead of just the first valid one) are allowed so that the decision table can be used for additive/multiplicative scorecards (important when integrated predictive analytic models with business rules). All the editors offer syntax highlighting and error markers as well as scoping of data elements to those available in context.
Data access is much as you would expect with the ability to map data elements to database schemas, Java beans, POJOs and XML schemas. In each case the data model can be interrogated and data elements created ready to be used in rules.
The environment also allows the definition of test cases – input data matched with rule model and expected outputs – and can use the same generated code to execute the tests. No integration with jUnit was offered which seemed like an obvious step given the use of Eclipse, but the environment did allow a set of tests to be executed and reviewed in a single pass. In addition some pretty basic verification and validation is offered and a nice graphical debugger. Even though code is generated, the debugger works entirely on the graphical model of the rules making adding stop points, checking values etc easy for someone familiar with the rules but not the code. Rules and packages can also be explored using a dependency graph that, like the rest of Visual Rules, has a nice interface.
Visual Rules has a nice document generator- PDF or HTML – and the diagrams support free-form text, labels and notes for annotation all of which are included in the documentation. Rule management is only possible within the Eclipse framework – the web based environment is strictly focused on metadata and version review not on editing. Although the Eclipse editor has a draft view of a Flow Rule that allows for a business user to specify a model without having to get into the gory details, this lack of a web-based metaphor struck me as a limitation of an otherwise very nice environment. It should be noted that the Innovations Software folks tell me that a web-based UI for rule management is coming in a release later this year which is excellent news.
The Team Server functionality supports teams and release management. It provides rule versioning, audit logs (nicely integrated into the UI), visual comparison of versions and granular permissions down to the rule level. Projects can be versioned and released also. You can deploy code to the Execution Server, a Java application, to have the rules exposed as a web service or Decision Service. All the code and WSDL is generated. The execution server can run on Tomcat or an application server or any other Java container and provides a web monitoring console for deployed rules.
One of the distinctive features of Visual Rules is that it generates Java code rather than using a Rete or other inferencing engine. Obviously this has pros and cons. Visual Rules’ Execution Serer offers hot-swap updates of rules, like many engine-based environments, but it was not obvious what they do to handle those circumstances where inferencing would be useful or essential.
Overall I liked the product – it has a nice look and feel and some great features for manipulating the rules. I was glad to see the repository and rule management features and I am looking forward to seeing the web-based UI. Some strong validation/verification would be welcome also.