New Drools Logos

As mentioned before Drools 5.0 will be the launch of what we call the Business Logic integration Platform (BLiP) which aims to provide a unified and integrated solution for Rules, Processes and CEP.

Drools 5.0 will be split 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)

We've had great help from Cheyenne Weaver from Red Hat in designing new logos for these sub projects and have gone through many revisions, I thought I'd show the latest and possibly final revision in this blog. Mr Trout, the current Drools logo, will stay and be the main ambassador and logo for the entire project as these logos are for the sub projects. Take a look below and tell us what you think.

Click to enlarge

Drools Flow view in Guvnor with GWT Diagram

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

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)

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

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

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

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

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

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

Building Decision Trees

The simplest approach is building a single decision tree from the data set. However, this approach is not very powerful when the classification problem gets harder.

Bagging: Boostrap Aggregating

Given a set of N instances, each belonging to one of K classes here is the outline of the algorithm used to construct a decision tree forest:

For each decision tree

Draw a random sample of size N from the learning set with replacement (boostrapping)

Build the decision tree using the random sample

Output: The class labels with the maximum number of votes for each instance (a tree's vote is its prediction for an instance)

Boosting: AdaBoost

Instead of drawing boostrap samples from the original data set boosting maintains weight for each instance. The higher the weight of the instance is, the more the instance influences the decision tree being trained. At each trial (each decision tree) the weights are adjusted in a way that the weight of the misclassified instances is increased. The final classifier aggregates the learned decision trees like the bagging but each decision tree's vote is a function of its accuracy.

Classification Performance

I tried different data sets:

• Poker Hand: 25010 instances with 10 attributes (5 literal and 5 integer = 5 Categorical and 5 Quantitative), Literal target attribute (10 possible values)
• Triangle: 10000 instances with 3 attributes (3 double = 3 Quantitative) and a Boolean target function. The target function is to label the object if it is a valid triangle checking the length of 3 edges

(z < x + y) && (x < z + y) && (y < x + z)

So far bagging and boosting provide some interesting advantages from machine learning point of view. Let's look at some classification results:

Using Single C4.5 decision tree

• Poker hands: 10.96% classification error
• Triangle: 19.23% classification

Bagging C4.5 Decision Trees

• Poker hands: 8.9% classification error
• Triangle: 19.19% classification

Boosting C4.5 Decision Trees

• Poker hands: 0.0% classification error
• Triangle: 8.61% classification

Boosting definetely improves the classification performance. But it is harder to say the same for bagging. Even if bagging improves the classification performance a little in the Poker hands example it does not make the same effect with the Triangle example. As we can see boosting the decision trees can produce perfect classification on the data set.

Drools and Machine Learning

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. 

1. 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.


2. 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
3. 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

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

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

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

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