Our indefatigable documentation team just published a 52 page documentation addendum for JRules 6.x, covering all things related to synchronizing Rule Studio for Java and Rule Team Server.

Table of Contents

We received feedback from a number of customers stating that the existing documentation for synchronization was insufficient or inaccurate so we are very pleased to make good — and with luck improve your efficiency while using the product.

Please don’t hesitate to send us your comments and criticism!

An interesting press release this morning from Celent:

A new Celent report, Business Rules and Underwriting Automation at Travelers, presents a case study of how an insurance company achieved significant success in automating underwriting and pricing of several lines sold to its small business customers. The company is Travelers; the business unit is Select Accounts; the products are sold in its TravelersExpress program; and the key technologies supporting this initiative are a business rules management system (BRMS), predictive analytics, and service-oriented architecture (SOA).

It does not take much research to discover which BRMS is being used or the benefits realized!

This week Albin Carpentier and I helped to run JRules memory consumption benchmarks on IBM zSeries. Within R&D we have 24×7 remote access to a machine we rent from IBM in Dallas, Texas. A large bank in Europe is evaluating deploying JRules on the mainframe and Albin was able to quickly deploy the Rule Execution Server to WebSphere and DB2 running on z/OS so we could gather memory consumption statistics to help inform their decision.

The configuration tested was: zOS 1.9, DB2 8.1, WebSphere Application Server 6.1.0.16 and IBM JDK 5.

We used a proof of concept ruleset containing representative rules that were cloned to create rulesets with 33, 66, 132, 264 and 528 rules. Memory consumption was measured using the JDK 5 MemoryMXBean and MemoryPoolMXBean. We ran three scenarios:

1. Invoking the engine within a JVM (no WebSphere) using IlrContext,
2. Rule Execution Server on WAS using J2SE provider,
3. Rule Execution Server on WAS using POJO provider.

The product performed very well and we saw linear scalability in all three scenarios. The highest heap memory usage we saw was a very modest 35 MB on WebSphere with the Rule Execution Server.

I will be speaking at a new technical rules conference in Dallas October 22-24. The conference is unique in that it aims to assemble some of the leading implementors of rule engine technology to discuss the state-of-the-art, as well as new technical challenges and innovations.

Needless to say I am really looking forward to rubbing shoulders with these luminaries of the industry, though it’s fairly intimidating company! We are still working out the details of our presentation but I hope to present a really interesting customer use case which has extreme scalability and performance requirements. I believe the general application architecture deserves more attention as it could serve as a useful pattern for others.

If this sounds like your cup of tea I hope to see you in October - registration is open.

The ILOG and Wipro relationship has grown to provide our customers a combination of services and products for Legacy Modernization. The webinar held on June 19, 2008 was very well received and highlighted how the combination of ILOG JRules with Rules for COBOL and Wipro’s service with their Business Rule Extraction methodology can provide increased business value for our customer’s Legacy Modernization projects.

Wipro’s Legacy Modernization business rule extraction method is a four phased methodology (Extract, Catalogue, Realise and Manage). The design and implementation of those extracted business rules in JRules and Rules for COBOL provides the ongoing and future maintenance and management of those extracted business rules. Rules for COBOL provides native execution in COBOL by generating a COBOL subprogram from the rules that were authored in JRules.

The webinar attendees indicated through polling questions that COBOL still runs their organization’s business applications - 55% of the attendees stated that 75% of their applicaitons remained in COBOL with 35% of the attendees having 75% of their applications on the mainframe but not necessarily all in COBOL. For the polling question on business drivers for their legacy modernization project, there were 45% of the attendees stated that the key business driver was to improve IT time to deliver business changes and 23% of the attendees stated that the key business drivers was to lower IT integration costs.

The combination of business rule extraction with business rule management providing for a choice for deployment - Java or COBOL - is an excellent way your organization can begin to provide business value with your Legacy Modernization projects sooner rather than later.

Recently we’ve had a few questions about JRules support for Apple Mac OS X. The official line is that this is an unsupported platform, however with a few tweaks you can install and run the Linux version of JRules 6.7.1 on Mac OS X.

Unsupported Platforms

So what is an “unsupported platform”? Basically it means that our QA department does not test this platform. To contrast with a supported platform, for most of the supported platforms we have developers that actively use the platform as a day-to-day development environment. We run our nightly battery of unit tests on the supported platforms and we have a lot of in-house experience with the platforms, including within our tier-1 support and product experts. If you call customer support and you are using an unsupported platform unsurprisingly the first request will be to reproduce the problem on a supported platform.

Mac OS X is becoming a more popular environment for developers, though still niche compared to Linux or Windows. I recently installed JRules 6.7.1 on Mac OS X 10.5.3 (Intel) so I thought it might be useful to document the process.

1. Download and Install Eclipse 3.3.x for Mac OS X

You want the “Eclipse Classic 3.3.2 - Mac OS X (137 MB)” distro.

2. Install BIRT and DTP

Launch Eclipse and use the Eclipse Update Manager to install BIRT and the DTP Extender SDK from the Europa Discovery Update Site.

3. Download jrules671.bin

Download the Linux version of the JRules installer.

4. Run Installer

Open a Terminal window and type “bash jrules671.bin”. Complete the installation but select “/Applications/jrules671″ as the installation directory rather than the default. After installation is complete JRules will have been installed under “/Applications/jrules671/ILOG JRules 6.7.1″. The spaces in the path name will cause JBoss problems so you need to move the entire contents of the “ILOG JRules 6.7.1″ folder up one level to “/Applications/jrules671″ and delete the “ILOG JRules 6.7.1″ folder. Everything you installed should now be under “/Applications/jrules671″.

After moving your JRules install to “/Application/jrules671″ you also need to open the file “ECLIPSE_HOME/links/ilog.rules.studio.link” and replace the link with:

#Rule Studio Link to Eclipse Install
#Fri Jun 20 14:28:55 CEST 2008
path=/Applications/jrules671/studio

5. Increase JVM MaxPermSize

Open the file “/Applications/jrules671/shared/bin/build.xml” in a text editor. Replace the “jvm.permgen.flag” section with this:

<!-- Extends the default MaxPermSize if running on a Sun or Apple JVM -->
<condition property="jvm.permgen.flag" value="-XX:MaxPermSize=128m">
  <or>
	<equals arg1="${java.vendor}" arg2="Sun Microsystems Inc." />
	<equals arg1="${java.vendor}" arg2="Apple Inc." />
  </or>
</condition>

6. Launch the Sample Console

To launch the Samples Console and the various JRules modules you can use “/Applications/jrules671/shared/bin/build.xml”. Open a Terminal window and type: “ant samples.console”. You should see the Samples Console window appear and JBoss will launch with RTS, RES and RSM deployed. There should not be any errors in the Server trace panel.

7. Test Rule Studio, Rule Team Server and Rule Execution Server

Once JBoss has booted you can navigate to http://localhost:8080/bres and http://localhost:8080/teamserver to test the installation. You can run Rule Studio by executing the Eclipse from step 1.

Conclusions

I hope you found these tips useful. If you have corrections or any of your own tips to add please send them through the comments!

Last night I watched “Unforgiven” so I thought I’d continue the spaghetti Western theme today; looking at the challenge of developing, running and interpreting benchmarks for Business Rule Management Systems. I recently read the excellent article “Behind the benchmarks: SPEC, GFLOPS, MIPS et al” by Jon “Hannibal” Stokes. Although Jon discusses CPU benchmarking many of his points are relevant to rule engine benchmarking as well. For example, here is how he describes the various techniques used to to measure CPU performance:

• Real-world Applications: one of the most popular, and best, ways to benchmark a system is by running a real program on it and see how long it takes the program to complete a task.
• Kernels: a small, CPU-intensive portion of a real program that’s intended to be run on its own or as part of a benchmarking suite.
• Toy Applications: small programs like Quicksort or the Sieve of Eratosthenes that people cook up to compile and run on any computer.
• Synthetic Benchmarks: try to determine the average instruction mix of a typical program so that it can replicate that mix and run those types of instructions on the CPU.

The current “Academic Benchmarks” for BRMS fall somewhere within the definition of a “Kernel” or a “Toy Application”, probably closer to the latter. Although they can be useful for implementors of rule engines, I’d argue they are of no use to evaluators of rule engine technology and may be a significant distraction. ILOG has been guilty of publishing academic benchmark numbers in the past of course, so I am not putting us on a pedestal!

Academic Benchmarks

The issues with the academic benchmarks for BRMS are fairly well documented, and there seems to be a general consensus that they should not be used for reliable product performance comparison, however they keep cropping up! Even in Ruby!

Here are some of the problems:

• Very small number of rules (less than 50)
• Test worst-case RETE inference and agenda usage, which is rarely encountered with well designed applications
• Implement solutions to combinatorial search problems, typically better implemented using a CP Engine rather than a RETE engine
• The solutions are not verified, meaning that correctness may be inadvertently (?) sacrificed for speed. This is particularly the case for Waltz and WaltzDB for which I’ve never seen any verification of the results.
• The benchmarks are easy to “game” because every vendor ports from the original OPS5 source code into their own rule language, where they take advantage of their product’s features

For reference, I have included the descriptions for the three most famous academic benchmarks below (paraphrased from the paper “Effects of Database Size on Rule System Performance: Five Case Studies” published by Daniel Miranker et al). How representative do they sound of your application!?

Manners

Manners is based on a depth-first search solution to the problem of finding an acceptable seating arrangement for guests at a dinner party. The seating protocol ensures that each guest is seated next to someone of the opposite sex who shares at least one hobby.

Waltz and Waltzdb

Waltz was developed at Columbia University. It is an expert system designed to aid in the 3-dimensional interpretation of a 2-dimensional line drawing. It does so by labeling all lines in the scene based on constraint propagation. Only scenes containing junctions composed of two and three lines are permitted. The knowledge that Waltz uses is embedded in the rules. The constraint propagation consists of 17 rules that irrevocably assign labels to lines based on the labels that already exist. Additionally, there are 4 rules that establish the initial labels.

Waltzdb was developed at the University of Texas at Austin. It is more general version of the Waltz program. Walzdb is designed so that it can be easily adapted to support junctions of 4, 5, and 6 lines. The method used in solving the labeling problem is a version of the algorithm described by Winston [Winston, 1984]. The key difference between the problem solving technique used in waltz and waltzdb is that waltzdb uses a database of legal line labels that are applied to the junctions in a constrained manner. In Waltz the constraints are enforced by constant tests within the rules. The input data for waltz is a set of lines defined by Cartesian coordinate pairs.

Conclusions

If performance is one of your major buying criteria then I would strongly encourage you to build a proof-of-concept set of rules and data and verify rule engine performance in your own environment. It is impossible to meaningfully extrapolate from published academic benchmark results to your running application, with your rules and data, deployed to your OS and hardware. In addition this will also allow you to evaluate the BRMS from as many angles as possible, spanning ease-of-use, business user accessibility, support and professional services, performance, deployment platforms, scalability etc.

References

• OPS5 Benchmark Suite by Daniel Miranker (University of Texas)
• OPS5 Benchmark Suite by Daniel Miranker (CMU Artificial Intelligence Repository)/
• Lessons learned in benchmarking — Floating point benchmarks: can you trust them? John Markus Bjørndalen, Otto Anshus
• Behind the benchmarks: SPEC, GFLOPS, MIPS et al by Jon “Hannibal” Stokes
• Academic Benchmark Performance

I have recently completed a three-part series of white papers for architects and developers. The purpose of the series is to accelerate the understanding of ILOG Rules for .NET. These papers should help everyone make good architectural decisions. Part three of the series was published just this week and covers best practices for integrating ILOG Rules for .NET with Microsoft BizTalk Server. Your feedback is welcome!

All three papers are currently available from the URL below:
Click here for the X-Ray series

June 25th will mark the release of Eclipse “Ganymede”, aka Eclipse 3.4. To celebrate the Eclipse Foundation is organizing all sorts of informational and fun activities. For example, there is a spoof movie poster contest running. Here is my favourite so far:

We need to set aside some time to get familiar with the new features, assess the porting costs and evaluate when/if we will migrate Rule Studio for Java to Eclipse 3.4.

I recently had the opportunity to take a look at the newest member of our BRMS family, ILOG Rules for COBOL. We’ve supported JRules running on zSeries (both zOS and zLinux) for a few years now, but there is still an enormous number of legacy COBOL applications and it is not always easy to convince the zSeries administrators to install and configure a Java VM for efficient execution. To compound matters the last time I looked, invoking Java from a COBOL batch application was not trivial either. Throw in a teaspoon of Java vs. COBOL internal company politics and season with Java pricing differences, zAAP hardware/pricing acceleration, and Rules for COBOL becomes a compelling solution for a significant number of the Global 2000.

The workflow is pretty straightforward:

1. Import COBOL Copybook into Rule Studio for Java
2. Generate a BOM and Vocabulary from the Copybook data structures
3. Author rules as usual
4. Rather than exporting a ruleset archive, generate COBOL sub-programs (source code) from the rules, either from Rule Studio or from Rule Team Server
5. Include the generated sub-programs into the target master COBOL program and deploy the code to the mainframe

The advantage with this approach is that enterprises can divide-and-conquer their legacy modernization, incrementally externalizing their business rules from COBOL applications and moving them into the BRMS. They can continue to execute the rules as COBOL minimizing the disruption to their system infrastructure. They may also deploy the same rules to JRules, for re-use in other applications running outside the mainframe, and because the BRMS is the system of record for the business rules consistency is guaranteed.

If you are embarking on an SOA legacy modernization project I encourage you to look at the Transparent Decision Service support in JRules and Rules for COBOL. In my opinion the two are very complimentary as they allow you to “think big” while still “starting small” and avoid rip-and-replace, often associated with project failure in large scale legacy modernization projects.