Drools - Business Logic integration Platform

Drools Flow view in Guvnor with GWT Diagram

noreply@blogger.com (Mark Proctor) — Wed, 23 Jul 2008 14:37:00 +0000

We now have Guvnor displaying uploaded Drools Flow files. We use the native GWT XML api to read in the XML document and GWT Diagram to generate the diagram. At the moment it's view only, over time we will make it editable - which will sure beat round tripping with Visio that other platforms do.

GuvnorNG

noreply@blogger.com (Mark Proctor) — Tue, 22 Jul 2008 22:42:00 +0000

Work has already begun on GuvnorNG, which is the next generation web framework for Drools, which will hopefully be delivered next year. GuvnorNG is being written to provide the foundations for the JBoss SOA Platform governance tooling, so we need to make every aspect of it pluggable. So it'll have pluggable viewers and editors, be more flexible on the content types it can store and support dashboard layouts. Mike Brock, the MVELauthor, is the main person behind this at the moment. It's very early stages and Mike is working on the foundations, particularly state management and pluggability. He has made a screen caste so people can see it working, notice at the end how the refresh does not lose any state. You can find the Screencast here.

As always Mike is looking for contributors, it's a very interesting project that can be usable standalone, outside of Drools, for any enterprise to develop their governance software and dashboards with.

Rolodex Panel Assembly for Guvnor (Anton Arhipov)

noreply@blogger.com (Mark Proctor) — Sat, 19 Jul 2008 00:23:00 +0000

In my previous post about integrating rolodex into Guvnor I tried to create the example just with a set of pre-compiled images which are then assembled into drools-guvnor.war. But the real goal is actually to display the pictures stored in Jackrabbit repository for Guvnor.
Now, after some experiments with rolodex and Guvnor, I have a widget where one may upload a picture and display it.

Currently it can accept only one picture per RuleAsset class instance. Therefore the content handler for this asset should be extended to support multiple images per RuleAsset.

RolodexCardBundle images = getImagesFromAsset();
RolodexCard[] rolodexCards = images.getRolodexCards();
if (rolodexCards.length > 0) {
   final RolodexPanel rolodex =
   new RolodexPanel(images, 3, rolodexCards[0], true);
   layout.addRow(rolodex);
}

I have set the hight of the panel manually as the picture was cropped otherwise in the widget. (Don't know the reason yet). getImagesFromAsset() is used for converting the asset's content to the RolodexCard:

public RolodexCardBundle getImagesFromAsset() {
   return new RolodexCardBundle() {
      ClippedImagePrototype clip = new ClippedImagePrototype(
         GWT.getModuleBaseURL() + "asset?" + HTMLFileManagerFields.FORM_FIELD_UUID 
                                +  "=" + asset.uuid, 0, 0, 300, 200 );

      RolodexCard card = new RolodexCard(clip, clip, clip, 300, 100, 10);

      public int getMaxHeight() {
        return 200;
      }

      public RolodexCard[] getRolodexCards() {
        return new RolodexCard[]{card};
     }
  };
}

I've cheated with the code that composes the RolodexCard, as ClippedImagePrototype's javadoc says:

This class is used internally by the image bundle generator and is not intended for general use. It is subject to change without warning.

But the implementation of ClippedImagePrototype is actually what I need. Probably, if it is really the subject to change at any time, I would rather cope'n'paste this class into Guvnor code base.

TODO:
A heavy part of the work will have to be carried out by the content handler. The content handler will have to support the multiple images per asset and also perform some graphics routines in order to replace the pre-compilation phase implemented in rolodex to adjust images.

Guvnor BRMS and Eclipse Synchronisation

noreply@blogger.com (Mark Proctor) — Fri, 18 Jul 2008 21:12:00 +0000

The Guvnor (BRMS) and Eclipse synchronisation tool has made leaps and bounds in progress for the upcoming 5.0 Milestone 2 release. It now has full bi-direction synchronisation of files between Eclipse and Guvnor. A developer can now work locally with a rule, or other Guvnor assets, they can do lots of small commits to their SCM of choice and when they need to can upload or synchronise that asset with Guvnor. Eclipe diff viewing is also supported.

Synchronisation

Diff Viewer

Version History

Integrating Rolodex to Guvnor for Image Asset Types

noreply@blogger.com (Anton Arhipov) — Tue, 15 Jul 2008 21:18:00 +0000

In Guvnor, there are many different widgets that are used to display or edit different assets. One interesting widget is about to be added - a widget that could accept images and display them. For this purpose, rolodex, a widget that can display a stack of images, can be used. Rolodex uses deferred binding for the image generation and animation. Let's see how can we quickly add a new widget displaying some predefined images.

First, create a class, implementing RolodexCardBundle interface (from the rolodex library) and declare a few methods that will return the images (just like ImageBundle described in the book):

public abstract class Images implements RolodexCardBundle {

   /**
    * @gwt.resource img_3861.jpg
    */
   public abstract RolodexCard imgA();

   /**
    * @gwt.resource img_3863.jpg
    */
   public abstract RolodexCard imgB();

   /**
    * @gwt.resource img_3865.jpg
    */
   public abstract RolodexCard imgC();

   ...

   private final RolodexCard[] cards = new RolodexCard[]{ imgA(), imgB(), imgC() };

   public RolodexCard[] getRolodexCards() {
      return cards;
   }
}

Next, to display those images, create ImageSetWidget (or you-name-it) class extending DirtyableComposite:

public class ImageSetEditor extends DirtyableComposite {
 // asset and viewer are not used now...
 public ImageSetEditor(RuleAsset asset, RuleViewer viewer) {
   final Images images = (Images) GWT.create(Images.class);
   final RolodexPanel rolodex
        = new RolodexPanel(images, 3, images.imgA(), true);
   initWidget(rolodex);
 }
}

For Guvnor to be able to launch the editor, we have to modify EditorLauncher class:

...
else if (asset.metaData.format.equals(AssetFormats.IMAGE_SET)) {
 return new ImageSetEditor(asset, viewer);
...

AssetFormats should be supplied with the new constant for this new type, of course.

To allow user to create such widgets in UI, a new menu item needs to be added.

This means, ExplorerLayoutManger#rulesNewMenu() should be modified

m.addItem(new Item("New ImageSet",
 new BaseItemListenerAdapter() {
   public void onClick(BaseItem item, EventObject e) {
     launchWizard(AssetFormats.IMAGE_SET, "New ImageSet", true);
   }
}, "images/rule_asset.gif"));

And last, but not least we need to include the following line in Guvnor.gwt.xml

<inherits name='com.yesmail.gwt.rolodex.Rolodex'/>

Now, after the project has been rebuilt and redeployed we get the following widget on the screen:

Currenly, the widget is displaying a predefined set of images and animates them as we roll the mouse over. So we have now a rolodex-powered widget inside Guvnor. Sounds cool! :)

Now, there are a lot of TODOs to make use of this new cool widget.

Menus should be pluggable. So far I knew that the only class that we should generate in order to support adding new rule editor widgets. Without doubt, a user needs a button to create the widget in his workspace, and therefor we should inject the new menu item. I suppose we can generate this part also. Therefore we need to extract the ExplorerLayoutManger#rulesNewMenu() method into a separate class.
Currently I have an ant task ready to generate a new EditorLauncher class source to plug a new asset type editor. But perhaps, if we have more of these classes to be generated, I'd better add a new ruby script to do this job.

Upload of new images. There's no use of this widget if it can redisplay only the predefined set of images.

RuleAsset support for images.The images should be supplied via the RuleAsset, i.e. the content should be a class that could represent a set of images.

A content handler is required as well.

SVN url changes & a funny video

noreply@blogger.com (Michael Neale) — Tue, 15 Jul 2008 00:18:00 +0000

For those that care, our SVN urls have changed due to a migration. The repositories are the same, but the URLS different:

Developer URL: https://svn.jboss.org/repos/labs/labs/jbossrules/trunk/
Anonymous URL: http://anonsvn.jboss.org/repos/labs/labs/jbossrules/trunk/

If you have an existing working copy, you can use svn switch like following:

svn switch --relocate https://svn.labs.jboss.org/labs/jbossrules/trunk https://svn.jboss.org/repos/labs/labs/jbossrules/trunk .

(for developers).

Also, some may remember I mentioned Fair Isaac's "falcon" fraud detection system some time ago - which is in use by ANZ bank. I finally found the advertisement for this, I always think it is funny:

What is interesting is that they are promoting a fraud detection system as a strategic advantage,

Drools and WordNet

noreply@blogger.com (Mark Proctor) — Wed, 09 Jul 2008 14:23:00 +0000

Someone has made a working implementation of WordNet for Drools and posted it to the user mailing list, andI thought others might find it interesting so I've blogged it here. The link below is for the email and contains the paste code.
http://www.mail-archive.com/rules-users@lists.jboss.org/msg05918.html

http://en.wikipedia.org/wiki/WordNet
WordNet is a semantic lexicon for the English language. It groups English words into sets of synonyms called synsets, provides short, general definitions, and records the various semantic relations between these synonym sets. The purpose is twofold: to produce a combination of dictionary and thesaurus that is more intuitively usable, and to support automatic text analysis and artificial intelligence applications. The database and software tools have been released under a BSD style license and can be downloaded and used freely. The database can also be browsed online.

Drools Scalability

noreply@blogger.com (Mark Proctor) — Wed, 09 Jul 2008 14:20:00 +0000

We often get asked about Drools scalability in complex apps, so I thought I would link to this posting just done, where someone has Drools scaling to 900K facts on a 64bit JVM with reasonable performance.
http://www.mail-archive.com/rules-users@lists.jboss.org/msg05922.html

Drools and Machine Learning

noreply@blogger.com (Gizil Oguz) — Sun, 06 Jul 2008 17:26:00 +0000

I'm Gizil. I am doing my master thesis in Drools project. I'm working on decision trees. I have made an ID3, C4.5 implementation with rule generation. I'm investigating bagging and boosting algorithm in order to produce better rules.

I am using Annotations on object fields to be able to process extra information on the attributes of the objects. I'm generating the rules out of the trees by parsing the trees using depth first search and compiling with PackageBuilder before adding to the RuleBase. In the future I consider using MVEL for templating to generate the rules from the trees.

Target Attribute or Class Label

Since I implement a Supervised learning algorithm the class labels of the target class has to be given by the user. There are two ways to input the labels. The first and easy way is specifying one of the fields related to the target class as the label by the Annotation on that field. The second way is writing a getter function on the object class and specifiying by its Annotation.

Attribute Domains

The most common domain types are categorical and quantitative. Moreover, the decision trees need to deal with complex domains which are not simple primitive object types.

Categorical (discrete) domain is commonly constructed by a set of String values. There has to be a finite number of discrete values. The attributes are assumed to be categorical by default. Only if there is an annotation saying the opposite then the domain is treated as quantitative. The target attribute has to be categorical since it is not a regression tree implementation.

Quantitative (continuous) domain: Commonly, subset of real numbers, where there is a measurable difference between the possible values. Integers are usually treated as continuous in practical problems. This type of domain has to be discretized by defining a various number of thresholds (intervals) for each possible class. My implementation can discretize numerical attributes which are a set of real numbers and have quantitative domain.

For example: age < 15 as child

15 <= age < 20 as teenage

20 <= age as adult

Literal attributes which are set of Strings and have a continuous domain can also be discretized by defining a various number of sets for each possible class.

For example: letter element of {a, e, i, o, u} as vowel

letter not element of {a, e, i, o, u} as consonant

Complex domain implements a domain of an attribute that belongs to another object class. This type of domain needs more care because there are many possibilities such as Collections or references to the object class, itself.

Quinlan's C4.5 Algorithm

Comparing to the ID3 the C4.5 learning algorithm can tackle with harder domains that contain many number of possible values.

C4.5 deals with the numeric (integer or real) and continuous attributes using a discretization technic based on entropy.

Continuous Attribute Discretization

There are mainly two approaches of discretizing the continuous attributes. One approach is using a global discretization algorithm, which results in a smaller decision tree. A global discretization algorithm would ignore the relation of the continuous attribute with the other attributes. The other approach is at any node of tree dicretizing the continuous attribute on the current set of instances that means applying the global discretization algorithm during the training of the decision tree.

I implemented the Fayyad and Irani's the Minimum descriptive length method to discretize the numerical domains which is also used by the WEKA project. Fayyad and Irani used information gain approach while evaluating the effectiveness of the discretization. I also tried the Quinlan's gain ratio approach as an MDL method which is presented as a bit more fair evaluation of the domains due the normalization of the information gain by the information of the current data set based on the domain attribute. Moreover, there are some other approaches such as gini coefficient, or chi-squared test that need to be tested.

For example: Using the 15 Golf instances with 4 attributes (1 boolean, 1 literal and 2 numerical = 2 Categorical and 2 Quantitative) and Boolean target attribute I get a rule saying that the decision should be to play golf outside if the outlook attribute of the Golf object is "overcast". This rule's rank is 0.2858 which means that the rule is classifiying 28.58 % of the given Golf objects.

rule "#0 decision= Play classifying 4.0 num of facts with rank:0.2858"

when

$golf_0 : Golf(outlook == "overcast", $target_label : decision )

then

System.out.println("[decision] Expected value (" + $target_label + "), Classified as (Play )");

end

Drools Smooks Data Loader

noreply@blogger.com (Mark Proctor) — Sat, 05 Jul 2008 14:10:00 +0000

Smooks is a powerful open source ETL tool, it can transform variety of data sources.

Drools now supports an internal model, so ideally you want to be able to load different payloads, such as XML, into this model. I've just added support for this and it'll be in M2 :)

Here is an example of the api loading an XML file into a drools session, the xml entries for OrderItem are mapped into the internal class and inserted into the given session. The matching rules simple do a print statement.

declare OrderItem
    productId : long
    quantity : Integer
    price : double
end

rule someRule
when
    $i : OrderItem()
then
    System.out.println( $i ); 
end

PackageBuilder pkgBuilder = new PackageBuilder();
pkgBuilder.addPackageFromDrl( new InputStreamReader( getClass().getResourceAsStream( "test.drl" )) );

RuleBase ruleBase = RuleBaseFactory.newRuleBase();
ruleBase.addPackage( pkgBuilder.getPackage() );

StatefulSession session = ruleBase.newStatefulSession();

// Instantiate Smooks with the config...
Smooks smooks = new Smooks( "smooks-config.xml" );

// set rood id
DroolsSmooksConfiguration conf = new DroolsSmooksConfiguration( "root" );
DroolsSmooks loader = new DroolsSmooks( session, smooks, conf );
loader.insertFilter( new StreamSource( new ByteArrayInputStream( readInputMessage() ) ) );

session.fireAllRules();

The Rise of the Open Source BRMS

noreply@blogger.com (Mark Proctor) — Fri, 04 Jul 2008 19:32:00 +0000

The JavaRules blog has done an interesting take on the rise of the Open Source BRMS, titled "Drools, BRMS and Revolutions".

Here is a choice quote:
"Here’s another thing: More and more companies are using shareware or freeware products such as Linux, Open Office, Java, Eclipse, Net Beans, JBoss to run those $500K (final installed price) BRMS packages. Now they’re going to have another really good package to add in there; Drools. The line between commercial BRMS vendors and freeware vendors is becoming more and more blurred and, with the next year or two, should disappear altogether."

Drools 5.0 M1 - New and Noteworthy

noreply@blogger.com (Michael Neale) — Fri, 04 Jul 2008 12:23:00 +0000

Drools 5.0 will be the launch of what we call the Business Logic integration Platform (BLiP) - the BRMs is dead :) The future is for a unified and integrated solution for Rules, Processes and CEP - this is what users want and this is what we are aiming for.

Drools 5.0 will split up into 4 main sub projects, the documentation has already been split to reflect this:

Drools Guvnor (BRMS/BPMS)
Drools Expert (rule engine),
Drools Flow (process/workflow)
Drools Fusion (cep/temporal reasoning)

M1 is still very hairy and only for the hard core drools users, little documentation has been updated - although some Flow and Guvnor stuff has been. So you will have to rely on looking at code and unit tests, as well as asking on the mailing lists and irc - we hope this new and noteworthy document helps guide you too.

M2 will involve an API change as we refactor away from being rules centric, as discussed here, we will provide a legacy 4.0 wrapper jar for backwards compatability in some later milestones.

We hope that M3/M4 will start to be more user/public friendly as the feature set matures and bugs come in and we start to update the documentation. We are hoping for an August/Sept release.

5.0 M1 can be found on the main drools download page. The Binary with dependencies is particularly large, but the bulk of it is uml javadocs, we will try and address this in M2 or M3 where we will try and remove non public stable apis.

A Big Thanks to the following Contributors
Ming Jin - Package serialisation performance increase (10x improvement)

Matthias Groch - sliding windows algorithm research

Tino Breddin - temporal operators

Matt Geis - new DSL parser and enhancements
Steven Williams - various decision table tasks.

Guvnor (the BRMS component)

New look web tooling

Web based decision table editor

Integrated scenario testing

WebDAV file based interface to repository

Declarative modelling of types (types that are not in pojos)

This works with the new "declare" statement - you can now declare types in drl itself. You can then populate these without using a pojo (if you like). These types are then available in the rulebase.

Others:

Logic verifier
Improvements to guided editor (many)

CORE ENGINE

Asymmetrical Rete algorithm implementation
Shadow proxies are no longer needed. Shadow proxies protected the engine from information change on facts, which if occurred outside of the engine's control it could not be modified or retracted.

PackageBuilder can now build multiple namespaces
You no longer need to confine one PackageBuilder to one package namespace. Just keeping adding your DRLs for any namespace and getPackages() returns an array of Packages for each of the used namespaces.

Package[] packages = pkgBuilder.getPackages();

RuleBase attachment to PackageBuilder
It is now possible to attach a RuleBase to a PackageBuilder, this means that rules are built and added to the rulebase at the same time. PackageBuilder uses the Package instances of the actual RuleBase as it's source, removing the need for additional Package creation and merging that happens in the existing approach.

RuleBase ruleBase = RuleBaseFactory.newRuleBase();
PackageBuilder pkgBuilder = new PackageBuilder( ruleBase, null );

Binary marshalling of stateful sessions
Stateful sessions can now saved and resumed at a later date.
Pre-loaded data sessions can now be created.
Pluggable strategies can be used for user object persistence, i.e. hibernate or identity maps.

Type Declaration
Drools now supports a new base construct called Type Declaration. This construct fulfils two purposes: the ability to declare fact metadata, and the ability to dynamically generate new fact types local to the rule engine. The Guvnor modelling tool uses this underneath.
One example of the construct is:

declare StockTick
  @role( event )
  @timestamp( timestampAttr )

  companySymbol : String
  stockPrice : double
  timestampAttr : long
end

Declaring Fact Metadata
To declare and associate fact metadata, just use the @ symbol for each metadata ID you want to declare. Example:

declare StockTick
  @role( event )
end

Triggering Bean Generation
To activate the dynamic bean generation, just add fields and types to your type declaration:

declare Person
  name : String
  age : int
end

DSL improvements
A series of DSL improvements were implemented, including a completely new parser and the ability to declare matching masks for matching variables. For instance, one can constrain a phone number field to a 2-digit country code + 3-digit area code + 8-digit phone number, all connected by a "-" (dash), by declaring the DSL map like:

The phone number is {number:\d{2}-\d{3}-\d{8}}

Any valid java regexp may be used in the variable mask.

Complex Event Processing Support (Temporal Reasoning)

Drools 5.0 brings to the rules world the full power of events processing by supporting a number of CEP features as well as supporting events as first class citizens in the rules engine.

Event Semantics
Events are (from a rules engine perspective) a special type of fact that has a few special characteristics:

they are immutable
they have strong time-related relationships
they may have clear lifecycle windows
they may be transparently garbage collected after it's lifecycle window expires
they may be time-constrained
they may be included in sliding windows for reasoning

Event Declaration
Any fact type can assume an event role, and its corresponding event semantics, by simply declaring the metadata for it. Both existing and generated beans support event semantics:

# existing bean assuming an event role
import org.drools.test.StockTick
declare StockTick
  @role( event )
end

# generated bean assuming an event role
declare Alarm
  @role( event )
  type : String
  timestamp : long
end

Entry-Point Stream Listeners
A new key "from entry-point" has been added to allow a pattern in a rule to listen on a stream, which avoids the overhead of having to insert the object into the working memory where it is potentially reasoned over by all rules.

$st : StockTick( company == "ACME", price > 10 ) from entry-point "stock stream"

To insert facts into an entry point:

WorkingMemoryEntryPoint entry = wm.getWorkingMemoryEntryPoint( "stock stream" );
entry.insert( ticker );

StreamTest shows a unit for this.

Event Correlation and New Operators
Event correlation and time based constraint support are requirements of event processing, and are completely supported by Drools 5.0. The new, out of the box, time constraint operators can be seen in these test case rules:
test_CEP_TimeRelationalOperators.drl

As seen in the test above, Drools supports both: primitive events, that are point in time occurrences with no duration, and compound events, that are events with distinct start and end timestamps.

The complete list of operators are:

coincides
before
after
meets
metby
overlaps
overlappedby
during
includes
starts
startedby
finishes
finishedby

Sliding Time Windows
Drools 5.0 adds support for reasoning over sliding windows of events. For instance:

StockTick( symbol == "RHAT" ) over window:time( 60 )

The above example will only pattern match the RHAT stock ticks that happened in the last 60 clock ticks, discarding any event older than that.

Session Clock
Enabling full event processing capabilities requires the ability to configure and interact with a session clock. Drools adds support for time reasoning and session clock configuration, allowing it to not only run real time event processing but also simulations, what-if scenarios and post-processing audit by replaying a scenario.

The Clock is specified as part of the SessionConfiguration, a new class that is optionally specified at session creation time:

SessionConfiguration conf = new SessionConfiguration();
conf.setClockType( ClockType.PSEUDO_CLOCK );
StatefulSession session = ruleBase.newStatefulSession( conf );

Drools Flow

Drools 4.0 had simple "RuleFlow" which was for orchestrating rules. Drools 5.0 introduces a powerful (extensible) workflow engine. It allows users to specify their business logic using both rules and processes (where powerful interaction between processes and rules is possible) and offers a unified enviroment.

Interactive Debugger
Process Instance view at a specific breakpoint:

Current active nodes in a workflow in a specific breakpoint:
New Nodes
Timers:
A timer node can be added which causes the execution of the node to wait for a specific period. Currently just uses JDK defaults of initial delay and repeat delay, more complex timers will be available in further milestones.

Human Task:
Processes can include tasks that need to be executed by human actors. Human tasks include parameters like taskname, priority, description, actorId, etc. The process engine can easily be integrated with existing human task component (like for example a WS-HumanTask implementation) using our pluggable work items (see below). Swimlanes and assignment rules are also supported.

The palette in the screenshot shows the two new components, and the workflow itself shows the human task in use. It also shows two "work items" which is explained in the next section:

Domain Specific Work Items
Domain Specific Work Items are pluggable nodes that users create to facilitate custom task execution. They provide an api to specify a new icon in the palette and gui editor for the tasks properties, if no editor gui is supplied then it defaults to a text based key value pair form. The api then allows execution behaviour for these work items to be specified. By default the Email and Log work items are provided. The Drools flow Manual has been updated on how to implement these.

The below image shows three different work items in use in a workflow, "Blood Pressure", "BP Medication", "Notify GP":
This one ows a new "Notificatoin" work item:

extensible Process Definition Language (ePDL)
Drools 4.0 used Xstream to store it's content, which was not easily human writeable. Drools 5.0 introduced the ePDL which is a XML specific to our process language, it also allows for domain specific extensions which has been talked about in detail in this blog posting "Drools Extensible Process Definition Language (ePDL) and the Semantic Module Framework (SMF)". An example of the XML language, with a DSL extension in red, is shown below.

<process  name="process name" id="process name" package-name="org.domain"
xmlns="http://drools.org/drools-4.0/process"
xmlns:mydsl="http://domain/org/mydsl"
xmlns:xs="http://www.w3.org/2001/XMLSchema-instance"
xs:schemaLocation="http://drools.org/drools-4.0/process drools-processes-4.0.xsd" >

<nodes>
  <start id="0" />

  <action id="1" dialect="java">
      list.add( "action node was here" ); 
  </action>

    <mydsl:logger id="2" type="warn">
        This is my message         
    <mydsl:logger>

  <end id="3" />
</nodes>

<connections>
  <connection from="0 to="1" />
  <connection from="1" to="2" />
  <connection from="2" to="3" />
</connections>

</process>

Pluggable Nodes
The underlying nodes for the framework are completely pluggable making it simple to extend and to implement other execution models. We already have a partial implementation for OSWorkflow and are working with Deigo to complete this to provide a migration path for OSWorkflow users.

Other enhancements include exception scopes, the ability to include on-entry and on-exit actions on various node types, integration with our binary persistence mechanism to persist the state of long running processes, etc. Check out the Drools Flow documentation to learn more.

Drools Clips

A very alpha quality version of Drools Clips is now working and supports:

deftemplate
defrule
deffuction
and/or/not/exists/test Conditional Elements
Literal, Variable, Return Value and Predicate field constraints

You can look at the ClipsShellTest and LhsClipsParserTest get an idea of the full support. It's still early stages and it's very rough in places, especially on error handling and feedback as well as no view commands to display data. The Shell in action:

The screen shot is a contrived example but it does show a shell environment cleanly mixing deftemplates and pojos - note that Drools 5.0 does not require shadow facts, due to the new asymmetrical Rete algorithm. It also shows deffunction in use.

Texas October Rules Fest and Drools Team Meeting

noreply@blogger.com (Mark Proctor) — Wed, 02 Jul 2008 15:14:00 +0000

The Texas Rules User Group is organising a 3 day conference for Expert Systems starting October the 22nd - the October Rules Fest (ORF) . It's a non-profit event costing only $150 for the three days. This is a "No Fluff, Just Stuff" conference and the idea is to keep it technical so people can actually learn. The sessions are listed here, the speakers bios here and the agenda here. The sessions and speakers are still fluid at the moment, but I've been sent a more up to date version, which I've pasted at the end of this blog. There is also a promotion PDF here. I know the organisers are still searching for sponsors, to help justify the low cost for the event, so if you can help please do.

The Drools team will arrive a week earlier on the 15th of October and will be doing a 7 day team meeting at the Best Western Hotel. This meeting is open to the public, so if you want some hard core hands on coding do try and come down and join in with the coding fest :) This is a great opportunity to learn Drools at an indepth level and contribute back to the project, we can also assist helping you to solve any Drools extensions you are doing for your job - a great opportunity for you to get your managers time and budget approval :) The Best Western is currently only $89 per night, so very affordable.

The current tentative agenda for ORF is pasted below:

Wednesday AM	Tutorials
8:00 - 8:15	Pete Carapetyn	Data Fundamentals	Welcome
8:15 - 9:15	Dr. Kappleman	North Texas Univ.	Rules: Essential But Only Part of the Puzzle
9:30 - 10:20	Rolando Hernandez	BizRules.Com	Introduction to Business Rules Architecture and Rulebase Technology
10:30 - 11:20	Larry Terril	EBDX	Declarative vs Procedural Programming
11:30 - 12:30	Greg Barton	Greg Stuff	Introduction to Evolvable Rules
12:30 - 2:00	Lunch

Wednesday PM	Conference Begins
2:00 - 3:15	Jason Morris	Morris Technical Solutions (Jess)	The Ontology of Rulebased Systems
3:30 - 4:45	Edson Tirelli	Drools	CEP - Complex Event Procesing Based on Rete
5:00 - 6:15	Michael Neale	Drools	"Guvnor" - A BRMS for Drools and Managing Other Asset Types
6:15 - 8:00	Pub Night 1		??

Thursday AM	Vendor's Day
8:00 - 9:00	Dr. Levine	Unit Texas Arlington	Keynote 2: Brain mechanisms for Making, Breaking and Changing Rules
9:00 - 10:00	Art Torteloro	Visual Rules	Constraints and Integration of Methodology With Automation
10:15 - 11:15	Carlos Seranno-Morales and Carole Ann Berliotz-Matignon	Fair Isaac	TBD
11:30 - 12:30	Dr. Feldman	Open Rules	Using Constraing Programming in Business Rules Environment
12:30 - 2:00	Lunch

Thursday PM
2:00 - 3:15	??	Informavores	TBD
3:30 - 4:45	??	Haley Systems	TBD
5:00 - 6:15	Daniel Selman	ILOG	Sequential Rules and Their Applications
6:15 - 8:00	Pub Night 2		??

Friday AM	The Future
8:00 - 9:00	??	Countrywide	Keynote 3: Guest speaker
9:00 - 10:00	Dr. Hicks	Texas A&M, EZ-Xpert	Verification of Propositional Logic Systems and it's Implications
10:15 - 11:15	Gary Riley	CLIPS	RE-architecting CLIPS: recent Changes to Improve Performance, Integration and Internationalization
11:30 - 12:30	Mark Proctor	Drools	Declarative Programming with Rules, Processes and CEP
12:30 - 2:00	Lunch

Friday PM	Parallel and Conference Wrapup
2:00 - 3:15	Dr. Forgy	PST, Rete, Rete 2	Parallel Rulebase Technology (jco) - Parallel OPSJ, Rete, Rete 2, New Developments in Rulebase Theory
3:30 - 5:30	Everyone	Everyone	Conference Review
5:15 - 8:00	Pub Night 3	Party Time	Billy Bob's in Fort Worth

Drools Clips progress

noreply@blogger.com (Mark Proctor) — Tue, 24 Jun 2008 23:42:00 +0000

Made some progress over the weekend with Drools Clips, which will provide a Clips like language for Drools. Deftemplates are now working and I did some work on PackageBuilder so that it's now able to handle multiple namespaces and have a RuleBase attached to provide a more "shell" like environment suitable for Clips. Michael Neale also got a basic command line shell working. So what does it support?

deftemplate
defrule
deffuction
and/or/not/exists/test Conditional Elements
Literal, Variable, Return Value and Predicate field constraints

(click to enlarge)

The screen shot is a contrived example but it does show a shell environment cleanly mixing deftemplates and pojos - note that Drools 5.0 does not require shadow facts, due to the new asymmetrical Rete algorithm. It also shows deffunction in use. This will be part of Milestone1, that I'm hoping to tag tomorrow.

IDE re-license from ASL to EPL

noreply@blogger.com (Mark Proctor) — Mon, 23 Jun 2008 16:00:00 +0000

We are looking to re-license our Eclipse IDE code from Apache Software License to Eclipse Public License. The reason for this is to simply align with the bulk of the Eclipse projects out there, to make bundling, deployment and code re-use much easier. The runtime work will remain as ASL.

I don't consider this change any issue as the EPL license is not a controversial one, unlike the LGPL. If anyone can see any issues I guess we can always dual license under ASL and EPL, but I don't want to needlessly confuse things.

I'm looking for community feedback on this before I do the change.

Mark

Why you need Business Rules in your workflow

noreply@blogger.com (paul browne) — Tue, 17 Jun 2008 14:15:00 +0000

Tom Baeyens has a good post on the jBPM (JBoss workflow) community day that was held at the Guinness brewery in Dublin. As you'd expect, the slides have plenty of pictures of people drinking beer, and one or two pictures of people talking about workflow and business processes. (Do not adjust your TV set. This blogpost is about business rules).

What you might not expect is that Business Rules and Rule Engines were key to one of the presentations on the day. In case you missed How to combine (jBPM) Workflow and (Drools) Business Rules - here's the summary (with the slideset available on this blogpost).

Workflow (e.g. JBoss jBPM) is great - it allows you to take spaghetti code and draw it as a workflow diagram (flowchart) so that it can be reviewed by the business (the nice people who pay our wages). You then attach standard (Java) actions to these steps.
Only problem is when you come to a decision node (the one circled in red below): How do you decide to go left or right (in the workflow)? Normally this is coded in Java - good for us, but hidden from those nice business people (which means that this is more room for errors-in-translation).
Business Rules allow you to keep those decision making rules in Plain English: When something is true , then do this. That's it. The rule engine does most of the hard work.
Integrating Workflow and Rules is easy. Use JBoss Seam (link) or do it by hand (link). And it works on non-JBoss web / app servers such as Websphere, Oracle Application Server, Tomcat and Weblogic.
Repeat x6 : Use workflow and rules. Use workflow and rules ...

Maybe it's co-incidence but, Tom Baeyens is now using strangely Rules-y like examples over on his workflow blog .

In this case Tom talks about task assignment; You may have a step such as 'Signoff Loan' in your workflow - but who does this task? Often these rules are complicated (e.g. loans less than 10,000 Dollars go to a junior officer, loans over 10 Million go to a bank president etc.). Business Rules allow you to keep these workflow task assignments in (almost) plain English.

Drools Job Posting - Drools Designer (Croatia)

noreply@blogger.com (Mark Proctor) — Fri, 13 Jun 2008 11:35:00 +0000

Another job posting came in, so thought I'd highlight it in the blog.

Drools Designer
We are currently recruiting for an experienced software engineer with specific knowledge of Java and Rules engines, ideally DROOLS. You must have several years experience as a developer/ designer in enterprise environments, have an excellent grasp of rules engine concepts, supporting database design, and understand current web technologies.

The job is in Zagreb, but home based working is offered.

The opportunity is to work for a very innovative company in the media area on the developmen of a new technical platform. long term prospects very good. The position is that of designer, working with the software architect.

You must be able to demonstrate a very high level of intellectual curiosity about technologies and their use and deployment.

You must be fluent in english.

Click here for more details and to apply for this job.

Google Summer of Code project

noreply@blogger.com (Michael Neale) — Wed, 11 Jun 2008 23:49:00 +0000

Anton Arhipov (a drools contributor who has worked on some Eclipse stuff in the past) - got a proposal accepted as a Google Summer of Code project.

His project is to make Guvnor (the BRMS) work with multiple content types - and more importantly have "pluggable" content editors (something that is kind of new to do in GWT - as GWT code is statically compiled into javascript).

He blogs about his experiences here.

JBoss Benelux User Group

noreply@blogger.com (Kris Verlaenen) — Wed, 11 Jun 2008 11:54:00 +0000

I will be speaking next Friday (June 20th) at the JBoss Benelux User Group in Rotterdam (Netherlands) about Drools in general. So if you want a gentle introduction to Drools or want to chat afterwards, you can find the event details here:
http://www.lunatech-research.com/archives/2008/05/16/jbug-2008-06

Registration: http://www.lunatech-research.com/event/register/jbug4

Summary and programme:
The fourth Benelux JBoss User Group
- JBoss Portal - Julien Viet and Thomas Heute - JBoss
- Hibernate Search - Emmanuel Bernard - JBoss
- Woman in IT - Clara Ko and Linda van der Pal - jduchess.org
- JBoss Drools - Kris Verlaenen - JBoss

Date: Friday, 20 June 2008.
Arrive 13.30-14.00, presentations start 14.00, open bar 18.45 - 20.00.
Location: Staal Rotterdam, World Trade Center, Beursplein 33, 3011 AA Rotterdam

Allowing variable "masks" in DSL grammar - by Matt Geis

noreply@blogger.com (Edson Tirelli) — Fri, 06 Jun 2008 17:29:00 +0000

Revisiting some of the concepts Edson posted earlier, we decided to put ANTLR to use in how we handle DSLs.

At a high level, the logic used to parse a DSL entry was pretty straightforward. We were matching a pattern of "name=value", identifying a few groups inside the "name" block as variables (text surrounded by brackets, like "{name}"), and storing those variables for later use when the "value" block is substituted into the actual rule that needs to be expanded from a DSL into the DRL format that Drools knows how to work with.

However, we found that in certain circumstances, we'd pushed the regular expression to its limits. Its lifecycle consisted of the construction of a pattern string, followed by an optional capture group prepended to the DSL entry, and an optional capture group appended to it. Additionally, because Drools DSLs can handle regular expressions in the body of a DSL entry, we also had to allow our regular expression (and the corresponding escape codes) to identify embedded regular expressions. These pattern strings were defined in java files, so any spaces or backslashes had to be escaped as well. Add it all together, and you get a regular expression that was difficult to read, and more difficult to modify without causing an unintended ripple effect through the rest of the expression. Finally, we learned that the resulting expression was greedier than we wanted it to be. It was easy enough to write a line like

a user exists named "{name}" = User (name == "{name}")

But, if you have an object with a lot of attributes and want to support arbitrary creation of rules, you can't write a DSL expression for every possible permutation of attributes used in the LHS of your rule. Moreover, you may want to include constraints inside of a "from" or "exists" clause. To do so, you would want a DSL entry like

a user exists with {attribute} {value} = User (attribute == {value})

The pattern ended up matching not only the first constraint, but also part of subsequent constraints applied (there were DSL entries for the first constraint on any object, and for subsequent constraints), because any variable used was translated to a capture group of "(.*?)".

Edson had the idea of allowing users to define the exact nature of a variable, in other words...

a user exists with social security number "{ssn:\d{3}-\d{2}-\d{4}}" = User (ssn == "{ssn}")

Using ANTLR, we were able to parse the DSL entries and accurately isolate variable definitions, patterns within definitions, variable usage, and literal text. So now, it's straightforward to create a very strict matching such as...

[condition][]user has contact where {constraints}= u : User and exists (f: Person(where {constraints}) from u.contacts)
[condition][]where {attr:[A-Za-z0-9]+} is "{value}"={attr} == "{value}"
[condition][]and {attr:[A-Za-z0-9]+} is "{value}"=, {attr} == "{value}"

which could support a rule like

user has contact where firstName is "Edson" and country is "Brazil"

just as easily as it could support

user has contact where lastName is "Tirelli" and company is "Red Hat"

An even more user-friendly DSL can be built by the correct ordering of your DSL statements. For example, the addition of the following lines

[condition][]first name=firstName
[condition][]last name=lastName

would allow the user to rewrite the above rules as

user has contact where first name is "Edson" and country is "Brazil"

user has contact where last name is "Tirelli" and company is "Red Hat"

Take that approach, and create some simple token replacements like

[condition][]greater than = >
[condition][]less than = <
[condition][]is = ==
[condition][]where {attr:[A-Za-z0-9]+} is {value:[0-9]+}={attr} == {value} 
[condition][]and {attr:[A-Za-z0-9]+} is {value:[0-9]+}=, {attr} == {value}

and a universe of flexibility opens up in front of you, as you can now accurately construct sentence fragments and phrases.

(note that attention to the ordering of such DSL entries is CRITICAL, as expansion of one DSL entry will affect the matching of subsequent entries, so if you were to match line 3 above, lines 4 and 5 would never match -- you'd have to change "is" to "==" to make them match)

With the new ANTLR model, we were able to easily support the requirement to limit matches by user-defined patterns (on a variable-by-variable basis), as well as pave the way for future enhancements to DSL usage.

Finally, now that we are liberated from the usage of a few regular expressions that capture everything, we can move ahead with other features for Drools DSLs. What started as

{variable}

and progressed to

{variable:pattern}

could be extended do something like

{variable:[attributeName,attributeValue]}

Examples of a possible attribute include a literal enumeration of allowable values for that variable, the name of a function to invoke to validate that the captured variable is allowed, the name of a function to invoke that provides a list of allowable values (a feature that could be leveraged by both the Eclipse plugin and in Guvnor).

Take the pattern matching for a test drive, let us know how it works for you (or doesn't, if that's the case), and tell us if there are any features you'd like implemented.

Caveat emptor: My rewrite of the DSL engine to use ANTLR was the result of just such a feature request. The need for tighter variable binding (basically "named capture groups") was acknowledged, and I was invited to make the necessary changes. I had no idea that it'd be so involved, or that the effort would be as rewarding as it has been.

Matt Geis