August 06, 2007 | Comments: (0)
Test Center Tracker: BRMS wars, mainframe futures, and encryption caveats
BRMS Pushmi-Pullyu: Doctor Doolittle's two-headed llama has nothing on ILOG's JRules, a product that is moving forward and backward at the same time. JRules 5.0, which James Owen reviewed in June 2005, was a silky combination of strong performance and rich rule tools, nabbing the highest score we've given to a rule management system. But by the time of Owen's evaluation of JRules 6.0 and top rival Blaze Advisor 6.1 in July 2006, JRules had not only lost ground in performance to the Fair Isaac engine, it stumbled on documentation at the same time it introduced more complexity in its tools and repository. With Version 6.5, reviewed last week by Stephen Nunez, JRules continues the flow of important new functionality -- now exposing decision logic as Web services -- but hasn't reversed the ebb in performance, documentation, or general ease of use.
Project Big Green: We already knew that the mainframe is harder to kill than Stephen Seagal. The mainframe's resource management and high availability features are unparalleled, and it has virtualization capabilities that the x86 can only dream about. Although "mainframe migration" stories sprout like weeds from enterprise IT publications, if you ask deep-pocketed IT shops (think IRS) that can actually afford what they really want, they'll tell you they're running their most important apps on Big Iron. Turns out there may be another reason to invest in the monoliths: IBM claims they are more energy efficient than little iron. See Ted Samson's report in Sustainable IT.
Encryption dos and dont's: Embarrassing data breaches are all the rage these days, and encryption seems like a sensible, no-brainer solution. But as Roger Grimes points out in Friday's column, file encryption is not as simple as lock and key. Encryptors can require a surprising amount of free disk overhead. Some files will refuse to be encrypted. Some encryption processes leave readable traces of file text behind. Before you take the plunge, check these considerations and caveats from the Security Advisor.
Posted by Doug Dineley on August 6, 2007 10:52 AM
May 21, 2007 | Comments: (0)
Impressions of InterACT: Business Rules as a Science
I just returned from the Fair Isaac user conference, InterACT, in San Francisco, where I attended sessions on the new lineup of products for BRMS. There they introduced a new product roadmap and vision for Enterprise Decision Management (EDM), which includes their Blaze rule engine.
Fair Isaac's vision of the future for BRMS includes not only the traditional management of the business rule lifecycle, but also the application of the company's modeling and analytic environment to the optimization of the decision making process. This is achieved by linking the company's modeler product, used to build mathematical models of, for example, consumer behavior, with the Blaze 6.5 rule engine to execute rules based on those behaviors.
An example of this might be a rule that says:
If the user is in the high risk category
then increase rate by 50 basis points
How do we know if the user is in the high risk category? Because the modeling tools can construct a detailed mathematical model of high risk customers in a particular industry. When these models change, or "drift," they can be updated in the modeler and the new model deployed to the Blaze rule engine with a point and click interface.
Furthermore, using the Decision Optimizer, business analysts can simulate various business rule scenarios and determine the effect that changing rules will have on profits or other variables in the models. This allows analysts to maximize the "decision yield" of a rule base.
These new developments may mark the beginning of a move from art to science for business rule systems, and I look forward to a full review of Blaze, Modeler, and Decision Optimizer in the near future.
Posted by Steven Nunez on May 21, 2007 06:20 AM
April 09, 2007 | Comments: (0)
Preview: Haley 6.0 extends business rules to business people
Haley Systems today introduced version 6.0 of the Haley Business Rules Suite, a BRMS that boasts both a strong pedigree and some unique features. The company was founded in 1989 by Paul Haley, the ex-Inference chief scientist who helped develop ART, one of the first commercially successful rule engines.
The Haley 6.0 BRMS suite consists of three components: Haley Authority, a rule authoring environment; Haley Rules Server, a rule execution engine; and Haley Collaboration Server, a Web application that enables distributed rule management and authoring.
The rule server offers two deployment options: either an all-Java version that will run in any J2EE compliant application server or a natively compiled version intended for speed-critical applications. Interestingly, both versions are compiled from the same code base. I did not have an opportunity to benchmark the preview version of the rule server, so performance measurements will have to wait until I get my hands on the final release.
HaleyAuthority is the thick-client, Java-based, desktop application for creating and maintaining rule ontologies; from here you can import existing business object models, configure rule services as part of an SOA, or build a new model from scratch. This is where all the heavy lifting is done in creating an environment whereby business analysts can author and maintain business rules.
The Collaboration Server is the basis for remote rule authoring and maintenance via a Web services interface. The collaboration server is also used as the back end for custom rule editors or maintenance tools. Haley provides a DHTML client (IE and Firefox only) for rule editing and an Excel plug-in for managing rules in a spreadsheet format ("tabular rules" in Haley parlance).
The Excel plug-in provides an interface very similar to the DHTML client; and though it is limited to tabular rules, it does illustrate the possibilities of custom interfaces. The source code for the Excel plug-in, as well as the JavaScript for the DHTML client, is available as part of the freely downloadable SDK to help get developers started.
Haley has taken an interesting approach to the problem of presenting rules to business users who will update and maintain the rule base. While most vendors offer a mechanism that allows for the substitution of various phrases, verbs, and nouns in business rules, the resulting rules still look like computer code and take a bit of getting used to on the part of the business analyst.
The Haley approach is almost like typing English sentences. The system has an auto-completion feature that suggests syntactically correct alternatives, and from what I saw it generally makes good guesses. Business rules written in this system almost read like ordinary sentences and paragraphs, easing the learning curve for non-programmers.
This NLP (Natural Language Processing) technology is used consistently throughout the product set, and it's available in all authoring environments, even the Excel plug-in. This is a fascinating technology, with applications beyond mainstream BRMS. I can think of some interesting uses in the Semantic Web, for example.
Building upon the NLP framework, Haley offers knowledge packs for two industry verticals, mortgage lending and insurance. Based on the MISMO and ACCORD XML standards respectively, these knowledge packs offer pre-built language customizations, meaning that all of the industry standard phrases and vocabulary are there from the start. All that remains is for a business analyst to start entering rules.
I was impressed by the fact that the system offers the same interfaces to external applications as it uses internally. The same goes for Haley's XML: everything in the system communicates using KML (Knowledge Modeling Language). This means that the Haley supplied components, or applications that your IT department creates, all use the same document format. The result is less likelihood of bugs and smoother integration for custom applications. This might explain why Haley is marketed as an OEM option for embedded rules engines.
Haley Business Rules Suite 6.0
Availability: Now
Pricing: Haley Authority authoring tool starts at $3,000 for a development and test environment; Haley Rules Server starts at $15,000.
Verdict: Haley 6.0 appears to be a well-designed and consistent business rule management platform, featuring advanced language modeling capabilities and solid XML support throughout. I'm looking forward to taking a closer look in the coming weeks.
Posted by Steven Nunez on April 9, 2007 10:07 AM
March 05, 2007 | Comments: (0)
Preview: JRules 6.5 steers into SOA
As SOA continues to gain momentum, integration of business decision logic into service architectures becomes increasingly important. ILOG JRules version 6.5 smooths the way with a wizard-based deployment mechanism, called Transparent Decision Services, that gives technical business analysts the ability to develop and deploy SOAP-based business rule services without working with code. Other refinements in version 6.5 include a Semantic Query feature and an upgrade to Eclipse 3.2 for the Rule Studio.
With the recent focus on SOA and event-driven architectures in the enterprise, business rule analysts will appreciate the ability to deploy decision logic as enterprise services using the Rule Studio and Execution Server components of the JRules 6.5 stack -- no Java compilation steps required. Although the initial setup and deployment of the rules does require an analyst with some technical knowledge of Rule Studio and Execution Server, once setup is completed business users can manage the rules without technical assistance.
Transparent Decision Services only works with Business Object Models (BOMs) defined in XML, but since most SOAs pass XML data in and out of services anyway, this is not a significant limitation. Overall, Transparent Decision Services simplifies and streamlines the management of business rules within an SOA. It's a move in the right direction.
The new Semantic Query feature is an extension of the query tools introduced in version 6.0. These constructs allow you to query for rules based on the possible run-time conditions, as opposed to static rule conditions. An example of the new type of query this permits might be, "Find all rules such that each rule may lead to an application rejection." This makes it easier for a policy analyst to identify the rules of interest, since they may be located by action (or condition) values. This version also includes hooks for custom extensions of queries using Java.
With this release JRules takes a first step forward into the SOA space and enables decision services to be rapidly updated by business analysts. That alone makes the upgrade worthwhile for enterprises implementing SOA. On the downside, the documentation is still sorely in need of improvement. The user manual, now weighing in at 3,456 pages, is available in HTML and PDF, but neither of these formats is very good for working with such a large document set. I miss the Windows Help version of the documentation from JRules 5. It had a great search tool, extensive hyperlinks, and the docs were a lot easier to use.
Posted by Steven Nunez on March 5, 2007 04:27 PM
November 03, 2006 | Comments: (0)
Review Extra: Jess 7.0 and JBoss Rules 3.2 code examples
One big difference between Jess and JBoss Rules, the top two open source rule-based systems (reviewed here by James Owen, aka Bubba the Rules Cat), is the degree of friendliness of their rule languages to ordinary mortals. Venerable Jess is pithy and cryptic, owing to its roots in artificial intelligence research. JBoss Rules, the new kid on the block, offers a more natural syntax that business users will find easier to grasp. A bit of history from Bubba:
Jess opened the door for expert systems (especially rule-based systems) to move from LISP to C to C++ to Java. After all, CLIPS ran as a C/C++ compiler that was nothing more than an extension of LISP/OPS (ListProcessing/Official Production Systems, "production" being a rule) to C then to C++. Jess was just the next logical extension. Dr. Ernest Friedman-Hill wanted to keep in lock-step with CLIPS which wanted to stay in lock-step with OPS which still has that same, archaic syntax. Unfortunate, because it isn't what the Java guys wanted.But the EE guys picked it right up, the plant production people (oil patch guys) used it, and so did I and a few academics who could get it for free. (I had to pay my $100 for the source code just like everyone else.) Jess was and is a great system, but it hasn't caught on with many in the business and financial world. After all, the business analysts make the rules, the IT guys have to write them in whatever language they can master, and Jess was not on the top of the list until about three or four years ago.
The Jess code for the assignSeat or find_seating rule (same code, different names) of the Miss Manners benchmark is shown below. As you can imagine, the old CLIPS syntax will present a steep learning curve to most business analysts. However, programmers will find it much more concise than the equivalent code in JBoss Rules or some other BRMS engines.
(defrule find_seating
?ctxt <- (Context (state assign_seats))
(Seating (seat1 ?seat1) (seat2 ?seat2) (name2 ?n2) (id ?id)
(pid ?pid) (pathDone yes))
(Guest (name ?n2) (sex ?s1) (hobby ?h1))
(Guest (name ?g2) (sex ~?s1) (hobby ?h1))
?count <- (Count (c ?c))
(not (Path (id ?id) (name ?g2)))
(not (Chosen (id ?id) (name ?g2) (hobby ?h1)))
=>
(assert (Seating (seat1 ?seat2) (name1 ?n2) (name2 ?g2)
(seat2 (+ ?seat2 1)) (id ?c) (pid ?id) (pathDone no)))
(assert (Path (id ?c) (name ?g2) (seat ( + ?seat2 1))))
(assert (Chosen (id ?id) (name ?g2) (hobby ?h1)))
(modify ?count (c (+ ?c 1)))
(printout t seat " " ?seat2 " " ?n2 " " ?g2 crlf)
(modify ?ctxt (state make_path)))
Compare the above with the same code (the now-famous Miss Manners assignSeat or find_seat rule) for JBoss Rules shown below. The JBoss Rules code is easy and familiar enough that most business analysts could learn it in only a day’s time (with a bit of help from a Java programmer).
rule findSeating
when
context : Context( state == Context.ASSIGN_SEATS )
Seating( seatingId:id, seatingPid:pid,
pathDone == true, seatingRightSeat:rightSeat,
seatingRightGuestName:rightGuestName )
Guest( name == seatingRightGuestName,
rightGuestSex:sex, rightGuestHobby:hobby )
Guest( leftGuestName:name , sex != rightGuestSex,
hobby == rightGuestHobby )
count : Count()
not ( Path( id == seatingId,
guestName == leftGuestName) )
not ( Chosen( id == seatingId,
guestName == leftGuestName,
hobby == rightGuestHobby) )
then
int rightSeat = seatingRightSeat.intValue();
int seatId = seatingId.intValue();
int countValue = count.getValue();
Seating seating = new Seating( countValue, seatId,
false, rightSeat, seatingRightGuestName,
rightSeat + 1, leftGuestName );
assert( seating );
Path path = new Path( countValue, rightSeat + 1,
leftGuestName );
assert( path );
Chosen chosen = new Chosen( seatId, leftGuestName,
rightGuestHobby );
assert( chosen );
System.err.println( "find seating : " + seating
+ " : " + path + " : " + chosen);
count.setValue( countValue + 1 );
modify( count );
context.setState( Context.MAKE_PATH );
modify( context );
end
Posted by Doug Dineley on November 3, 2006 03:00 AM