Drools & jBPM

DeveloperConference 2012 in Brno, Czech Republic 17 - 18 February 2012

noreply@blogger.com (Geoffrey De Smet) — Wed, 08 Feb 2012 09:12:00 +0000

Next week, on Friday 17 February, I 'll be presenting a introduction to Drools, Guvnor and Planner at the DeveloperConference 2012 in Brno, Czech Republic.

There are plenty of other interesting JBoss talks, about topics such as CDI, Arquillian Drone, Errai, Infinispan, Hibernate OGM, ... The entrance is free, so join us if you're in the neighborhood.

Drools & jBPM Info Sheet

noreply@blogger.com (Mark Proctor) — Tue, 07 Feb 2012 18:55:00 +0000

We've made an Info Sheet that provides an overview of Drools, jBPM and Guvnor. Feel free to download it and hand it out in your public presentations. There are 13 pages in total. You'll need to sign in to slideshare to download. Big text and lots of pretty pictures and very sexy, but not to be used for "extra" curriculum activities ;)
http://www.slideshare.net/MarkProctor/drools-jbpm-info-sheet

Welcome Alexandre Porcelli

noreply@blogger.com (Mark Proctor) — Tue, 07 Feb 2012 14:43:00 +0000

Alexandre Porcelli has joined the Drools&jBPM team today. Alexandre is an Antlr guru and also leads the Open Spotlight project, http://porcelli.github.com/OpenSpotLight/.

Alexendre will initially be helping out on the Guvnor work for jBPM, then in a few months time we hope that he'll lead our work around distributed computing.

Alexendre lives in sunny Brazil, you can read more about him here,http://porcelli.com.br/.

Wumpus World Lives!!!

noreply@blogger.com (Mark Proctor) — Tue, 07 Feb 2012 03:16:00 +0000

Wumpus world continues to improve and is now fully playable. The UI has a lot more polish now and nearly all of the code has been moved to DRL now, including the swing graphics rendering for the cave and the sensor panels. You'll need to use master head to try it. Java is just used to build the kbase from the drl files and to create the swing panels, buttons and forms. WindowBuilder was used to graphical layout things.

The final thing I have to do is allow for client integration, so that people can write rules to automate the hero.

https://github.com/droolsjbpm/drools/blob/master/drools-examples/src/main/resources/org/drools/examples/wumpus/init.drl
https://github.com/droolsjbpm/drools/blob/master/drools-examples/src/main/resources/org/drools/examples/wumpus/commands.drl
https://github.com/droolsjbpm/drools/blob/master/drools-examples/src/main/resources/org/drools/examples/wumpus/collision.drl
https://github.com/droolsjbpm/drools/blob/master/drools-examples/src/main/resources/org/drools/examples/wumpus/score.drl
https://github.com/droolsjbpm/drools/blob/master/drools-examples/src/main/resources/org/drools/examples/wumpus/view/ui.drl
https://github.com/droolsjbpm/drools/blob/master/drools-examples/src/main/resources/org/drools/examples/wumpus/view/paintCave.drl
https://github.com/droolsjbpm/drools/blob/master/drools-examples/src/main/resources/org/drools/examples/wumpus/view/paintSensor.drl

Cave is hidden, playing the game purely with Sensors.

Cave is now shown, but unvisited rooms are greyed out.

Cheating reveals all, I have shot the Wumpus Dead

Window Builder with MigLayout was used to create the panels, buttons and forms

Here is the code to incrementally render the cave rooms:

function void paintCaveCell(String image, Cell cell, GameView gv, GameUI gui) {
     int rowIndent = 20;
     int colIndent = 5;
     int rowPad = cell.getRow() * gv.getCellPadding();
     int colPad = cell.getCol() * gv.getCellPadding();
     int y = (4 - cell.getRow()) * 50 - rowPad + rowIndent;
     int x = cell.getCol() * 50 + colPad + colIndent;
     
     Graphics caveG = gui.getCavePanel().getCaveG();
     caveG.setColor( Color.WHITE ); // background
     caveG.fillRect( x, y,  gv.getCellWidth(), gv.getCellHeight() );
     caveG.drawImage( ImageIO.read( GameView.class.getResource( image ) ), x, y, gv.getCellHeight(), gv.getCellWidth(), gui.getCavePanel() );
}

rule "Init CaveDirty" when
    not CaveDirty()
then
    insert( new CaveDirty() );
end

rule "Create CompositeImage" when
    $c : Cell()
    not CompositeImageName( cell == $c )
then
    CompositeImageName cin = new CompositeImageName($c, "", "", "", "");
    insert( cin );
end  

rule "Reset CompositeImage" when
    $cin : CompositeImageName()
    not Cell( row == $cin.cell.row, col == $cin.cell.col)
then
    retract( $cin );
end    

rule "Base Paint" when
    $c : Cell()
    $cin : CompositeImageName( cell == $c );
then
end    

rule "Paint Gold" extends "Base Paint" when
    Gold(row == $c.row, col == $c.col)  
then
   modify( $cin ) { gold = "gold" };
end

rule "Paint Empty Gold" extends "Base Paint" when
    not Gold(row == $c.row, col == $c.col)  
then
   modify( $cin ) { gold = "" };
end

rule "Paint Pit" extends "Base Paint" when
    Pit(row == $c.row, col == $c.col)  
then
   modify( $cin ) { pit = "pit" };
end

rule "Paint Empty Pit" extends "Base Paint" when
    not Pit(row == $c.row, col == $c.col)  
then
   modify( $cin ) { pit = "" };
end

rule "Paint Wumpus Alive" extends "Base Paint" when
    Wumpus(alive == true, row == $c.row, col == $c.col)  
then
   modify( $cin ) { wumpus = "wumpus_alive" };
end

rule "Paint Wumpus Dead" extends "Base Paint" when
    Wumpus(alive == false, row == $c.row, col == $c.col)  
then
   modify( $cin ) { wumpus = "wumpus_dead" }
end

rule "Paint Empty Wumpus" extends "Base Paint" when
    not Wumpus(row == $c.row, col == $c.col)  
then
   modify( $cin ) { wumpus = "" }
end


rule "Paint Hero Direction Up" extends "Base Paint" when 
    $h : Hero( direction == Direction.UP, row == $c.row, col == $c.col )
then
     modify( $cin ) { hero = "hero_up" };
end    

rule "Paint Hero Direction Down" extends "Base Paint"  when
    $h : Hero( direction == Direction.DOWN, row == $c.row, col == $c.col  )
then
    modify( $cin ) { hero = "hero_down" };
end   

rule "Paint Hero Direction Left" extends "Base Paint"  when
    $h : Hero( direction == Direction.LEFT, row == $c.row, col == $c.col  )
then
    modify( $cin ) { hero = "hero_left" };
end    

rule "Paint Hero Direction Right" extends "Base Paint" when
    $h : Hero( direction == Direction.RIGHT, row == $c.row, col == $c.col  )
then
    modify( $cin ) { hero = "hero_right" };
end 

rule "Paint Empty Hero" extends "Base Paint" when
    not Hero( row == $c.row, col == $c.col  )
then
    modify( $cin ) { hero = "" };
end   

rule "Paint Hidden Room" when 
    $gui : GameUI( cavePanel != null && cavePanel.caveG != null  )
    $cd : CaveDirty() @watch(!*)
    $gv : GameView(showAllCells == false)
    $c : Cell(hidden == true) 
then
   paintCaveCell( "hidden_room.png", $c, $gv, $gui);
   modify( $cd ) { dirty = true };
end


rule "Paint Empty Room" when 
   $gui : GameUI( cavePanel != null && cavePanel.caveG != null )
    $cd : CaveDirty() @watch(!*)   
   ($gv : GameView(showAllCells == true) and $c : Cell() ) or
   ($gv : GameView(showAllCells == false) and $c : Cell(hidden == false) )      
   CompositeImageName( cell == $c, pit == "", wumpus == "", gold == "", hero == "" ) @watch(*)
then
   paintCaveCell( "empty_room.png", $c, $gv, $gui );
   modify( $cd ) { dirty = true };
end 

rule "Paint Non Empty Room" when
   $gui : GameUI( cavePanel != null && cavePanel.caveG != null )
   $cd : CaveDirty() @watch(!*)   
   ($gv : GameView(showAllCells == true) and $c : Cell() ) or
   ($gv : GameView(showAllCells == false) and $c : Cell(hidden == false) )    
   $cin : CompositeImageName( cell == $c, ( !(hero != "" && pit != "")  &&  // don't draw a hero on the same square as a pit or an alive wumpus, as the game is over
                                            !(hero != "" && wumpus == "wumpus_alive") && 
                                            !(pit == "" && wumpus == "" && gold == "" && hero == "") ) ) @watch(*)
then
    paintCaveCell( $cin.pit + $cin.wumpus + $cin.gold +  $cin.hero + ".png", $cin.cell, $gv, $gui );
    modify( $cd ) { dirty = true };
end

rule "Redraw Cave" no-loop salience -500 when
   $gui : GameUI() 
   $cd : CaveDirty( dirty == true )
then
   $gui.updateCave();
   modify( $cd ) { dirty = false };
end

Drools Developer's Cookbook review

noreply@blogger.com (Edson Tirelli) — Fri, 03 Feb 2012 16:30:00 +0000

A few weeks ago Packt Publishing released the Drools Developer's Cookbook, written by Lucas Amador. I had the opportunity to review an early draft of the book last year and when I received my copy of the released book I was eager to read it and check out how was it. I am glad to say I am pleasantly surprised.

Packt is known for publishing many high quality books on open source projects and it has already published 2 other books on Drools, but managed to publish this 3rd book with a completely different perspective and as so, allows readers to choose which ones they would benefit more from.

While JBoss Drools Business Rules, by Paul Browne, focus its content on higher level rule authoring and an earlier version of Guvnor, Drools JBoss Rules 5.0 Developer's Guide, by Michal Bali, is a deeper tutorial-style reading that builds on the examples from chapter to chapter, detailing how every piece of the puzzle fits together.

Drools Developer's Cookbook on the other hand, as the name implies, contains recipes on how to leverage Drools' features to effectively build business solutions. This is an excellent format for those with some knowledge of the platform and that want a detailed reference on how to use specific features. While the Developer's Guide is more suited for a throughout reading, the cookbook is a good reference material that can be read on a chapter basis in any order the reader wishes.

Each recipe is divided in usually 3 sections:

"Getting ready" details which setup steps are necessary to use the feature/complete the task in that recipe, like for instance, additional jar dependencies or configuration options are required.
"How to do it..." is a step by step explanation of how to use the feature/complete the task.
"How it works..." is my favorite section and explains how and why things work the way they do. This is important knowledge that can be leveraged to achieve different goals.

Some recipes also have references for additional documentation or information.

The book covers an extensive set of components and features, as can be seen in the table of contents: from the core Drools Expert, to Guvnor, Fusion, Planner, Camel/Spring/JPA integration and even a bit of jBPM. I think the book will be really helpful to a large percentage of the Drools user base.

Unfortunately, the book is not perfect. There are some minor issues, like some typos in some of the printed examples. The good news is that this is totally offset by the great support Packt provides to all their published books. The (fixed) source code is available for download, and I imagine the errata should be soon available as well.

The over 40 recipes in this book are an excellent resource, and I am sure it will left the readers looking forward for more!

Happy Drooling

Traveling Salesman Problem demo with Drools Planner

noreply@blogger.com (Geoffrey De Smet) — Fri, 03 Feb 2012 16:12:00 +0000

Implementing TSP or vehicle routing in Drools Planner 5.4.0.Beta2 and earlier was difficult. But starting from 5.4.0.CR1, such use cases are easy and far less code to implement. And they are compatible with real-time planning.

Just take a look at the Traveling Salesman Problem (TSP) demo. It shows adding cities in real-time and demonstrates how easy it is to change the constraints:

Coming soon: a vehicle routing example and even better scalability.

Drools Cookbook

noreply@blogger.com (Mark Proctor) — Thu, 02 Feb 2012 09:56:00 +0000

http://link.packtpub.com/ivHAPZ

Drools 5.4.0.Beta 2 released

noreply@blogger.com (Toni Rikkola) — Tue, 31 Jan 2012 13:49:00 +0000

We're happy to announce the release of Drools (Expert, Fusion, Planner, Guvnor) 5.4.0.Beta2.

Documentation, Release Notes and Downloads are detailed below:

Download the zips from the bottom of the drools download page.

To try out the examples, just unzip one and run a runExamples.sh/.bat script.

See the JBoss Maven repository for a list of all released artifacts.

It will be synced to Maven Central automatically in a couple of hours.

Read the new and noteworthy changes here.

Try it out and give us some feed-back (user list, issue tracker).

Wumpus World Update

noreply@blogger.com (Mark Proctor) — Thu, 26 Jan 2012 22:15:00 +0000

I made further progress with Wumpus World today, as previously blogged here. The project is checked into drools-examples, execute "WumpusWorldServer" to run.
-larger sensor icons
-bump and scream sensors added
-left, right buttons now rotate left and rotate right.
-hero faces direction based on rotation
-can now shoot arrows
-wumpus can die

Wumpus World

noreply@blogger.com (Mark Proctor) — Wed, 25 Jan 2012 08:28:00 +0000

I've just committed a working version of Wumpus World, an AI example covered in in the book "Artificial Intelligence : A Modern Approach". It's not complete yet, as I still need to add the ability to shoot arrows and to clumb out of the cave. But the rest of it is there and working.

When the game first starst all the cells are greyed out. As you walk around they become visible. The cave has pitts, a wumpus and gold. When you are next to a pittt you will feel a breeze, when you are next to the wumpus you will smell a stench and see glitter when next to gold. The sensor icons are shown above the move buttons. If you walk into a pitt or the wumpus, you die.

Here are the slides that I used in my presentation for Wumpus World, along with a demo, at Judcon India 2012. The code will be part of 5.4 beta 2 going out today/tomorrow.

A more detailed overview of Wumpus World can be found here.

asdf

Guided Decision Tables - An update

noreply@blogger.com (Michael Anstis) — Mon, 23 Jan 2012 10:04:00 +0000

The guided decision table editor in Guvnor has come a long way since it was first added to Guvnor in 2008 so I thought it worth while consolidating the efforts we've made into a short summary so those unfamiliar with recent developments can re-consider what a powerful tool Guvnor now posses.

The editor in 2008

Complete re-write

When Guvnor moved from GWT-EXT to vanilla GWT we took the opportunity to re-write the entire editor. GWT's table widgets did not offer the flexibility we wanted to provide users in their authoring environment: We wanted users to be able to quickly and easily build tables enabling them to concentrate on their rules rather than data-entry. Thus the new editor was born offering keyboard or mouse navigation, in-cell editing together with merging and grouping of cells.

The editor as it is today

Guided construction

To make the initial definition process as pain-free as possible we added a Wizard to walk users through creation. The Wizard also offers users the ability to generate an expanded form table.

The wizard

Merging

Merging of cells combines cells with identical values into one; thus providing a quick way to change the value of multiple cells in a single operation (of course, you could equally select multiple-cells with either a mouse-drag operation or keyboard but we felt merging minimized the process). Merging was also the precursor to grouping of cells, a powerful facility to collapse sections of the table whilst authoring.

Merged cells

Grouping

Merged cells can be collapsed into one. All editing operations continue to work as normal: copying-pasting rows and editing cell values etc. The only difference being that you can effectively hide sections of the table. Copying and pasting a grouped row also offers a convenient way to duplicate sections of the table (before editing as appropriate).

Grouped cells

Extended and Limited Entry

What type of decision table editor would we have without offering both Extended Entry and Limited Entry? Extended entry allows constraint and action values to be defined in the table body; whereas Limited entry moves the entire definition to the column itself with the body simply allowing the user to define which constraints and/or actions apply.

Limited Entry

Analysis

Support has been added to detect mistakes in your decision table. Currently we detect 2 types of problem and want to add many more.

Impossible matches
Conflict detection

Conflict detection

Integration of jBPM work items

Rules are frequently used from within jBPM to drive dynamic processes. What better then than providing a means for jBPM Work Items to be used in your rules' consequences? Work Item input parameters can be bound to Facts or their properties and likewise output parameters used to populate Facts.

Use of BRL fragments

Column definitions have historically only been able to offer a thin veil of abstraction. With the introduction of BRL fragments, columns can be defined using the full range of Guvnor's guided rule authoring capabilities (including DSL) which, coupled with Limited Entry, allows a higher level of abstraction to be realized.

A BRL fragment column

Roadmap

Whilst, you might agree, significant progress has been made made there is still a long way to go. There still is a tremendous amount of work we want to complete before feeling our decision table offering is as complete as we'd like.

Round-trip between Excel and Guvnor
Improved integration of V&V to provide visual feedback
Further V&V to check conflict, completeness, ambiguity, subsumption etc
Expansion and contraction
Enforcement of multi-hit and single-hit variants
Typed input of default values and lists of permitted values for Conditions
Pluggable editors for domain types
Column and row drag and drop
Horizontal decision table
Integration of WorkingSets

jBPM Form Builder roadmap

noreply@blogger.com (Marian Buenosayres) — Fri, 20 Jan 2012 14:31:00 +0000

Greetings from Argentina. This post will try to cover a general view of where the form builder is right now and where it is going to be in the near future. You can get a current status view from the video below:

On this video you can see a great deal of how the form builder works today. It doesn't cover the jBPM console integration part or the automatic form generation option, but it allows you to see how users will experience working with the form builder. To download the project, you can find it in the following locations

Nightly builds

In the next few days, I'll start keeping a stable release on this other address as well:

Feel free to download, comment or join. That pretty much covers where the form builder is right now. As to where it is heading, here's an initial roadmap

jBPM Form Builder Roadmap

Adding HTML5 templates: Current items work with pure GWT and HTML4 for Freemarker. The idea is to build a new renderer that will allow users to export to Freemarker as well, but allowing them to export using HTML5 instead of HTML4 to create the forms. The idea as well is to create as many menu options to properly cover HTML5 capabilities, such as audio and video tags, menus, fieldsets and so on.
Adding new validations: Current validations cover basic concepts, like number or email validation. The idea is to expand and improve validation definitions, in order to allow both client side and server side validation to any level of complexity. Among new validations that are thought to be added, there will be regular expression validation, multi-field validations (applied directly to the form), and rules-based validation (in order to define a ruleflow-group specially to validate the correctness of input data)
Adding script helpers to add dynamic ui components on client side: Script helpers are shown in the video above. They allow a user with very little knowledge of javascript to create scripting solutions for UI component's event handling. The idea is to create a new script helper to allow javascript to add a new visual component on a particular layout and layout position when an event happens.
Cleaning up effects and form items library: Current implementations of form items (the UI components you drop on your form) and form effects (the actions available when you right click on a form item) are done in a way that could be made configurable with a proper refactor. The whole idea is to make it more easily extensible, minimizing the amount of code to be added to create a right click action for UI components, or a UI component itself.
Adding tests for effects and form items library: Along with the previous item, some refactoring will be made to allow a better separation of display logic from actions logic, in order to create better test prepareness on the code side. Along with that, proper tests will be implemented for the form items and effects library.
Adding server validation to the generated form's API: Extension of the form utility API used from jBPM console, to handle validations on server side.
Adding server interpretation of complex objects to the generated form's API: Currently, all form submit responses are treated like a map of simple data. The idea is to create complex object associations to particular paths in the form definition, in order to create the proper objects on submit time. This will benefit both user task definitions and rule-based form validations.
Adding template management for complex objects for the generated form's inputs: The previous item covers submit to server rendering of request data, from simple data types to complex data types. This item covers the other way around, for when a user task is given a complex type and needs to decompose it to make it available for form input data. It will allow the user to define paths within an object when defining form inputs.
Improvement of properties edition panel to add better coverage of properties for form items: This comes in hand with item 4. Once a proper management of form item properties is done, there will be a need for a better way of editing such properties.
Improvement on tree and edition panel visualization: Bug fixing and visual highlighting in the current form are two of the main things to be tackled by this bullet.
Allow switching layouts once they're filled without losing content: Currently, once you define a layout and start adding content to it, the only way to change layouts is to create a new one and move all the content manually. This item is thought to be able to do that automatically.
Adding script helpers to allow onEvent simple validations on client side: Along with validation library expansion and server validation API, this item is thought to allow some validations to happen on the client side, to be handled on particular events (i.e. like on the change of value of an input field)
Pagination items: Create UI components that would allow to create very large forms within several pages, all part of the same form.
Definition of a standard page layout for a given user or role: Most companies have a template structure for most of their forms (wether it has a logo on a particular place, a standard stylesheet, etc). The idea is to allow designers to define such page layout and force its use to either some people or a group of people within the company.
Definition of standard UI visualization strategies for particular types of data: This is to aid the automatic form generation. The idea is to allow users to define, for example, the standard way to create visual content for Strings, Integers, Booleans and so on. It should cover complex data types as well.
New translators and renderers for JSF, XUL, Android, IPhone and Swing: Among other technologies, this would be a nice subset to cover. The order of the technologies and the omission of any don't express any priority whatsoever.
Adding effects to allow loading contents from an ajax script or from an array variable: This way, content from a form could be loaded from an external source from the client side.
Importing of inputs from other external sources: Right now the only way to import inputs on the IO Data tab is to have them defined inside a BPMN2 process. The idea is to be able to take them from a server invocation, a user file, or any other way. This will also allow to define forms for other platforms different than the BPM engine.

Cheers,
Mariano

Guided Decision Table - Copying\pasting rows

noreply@blogger.com (Michael Anstis) — Thu, 19 Jan 2012 16:26:00 +0000

Before starting the next big feature, I relaxed a bit (Mark will kill me ;-) ) and added the ability to copy and paste rows in the guided Decision Table editor in Guvnor.

This feature comes to the Template Data grid for free.

Video here.

Project Idea: Debug Helper

noreply@blogger.com (Mark Proctor) — Thu, 19 Jan 2012 03:38:00 +0000

Have a great project for any intrepid rule exlorers. The project itself is not too difficult and will make it really easy for people to get an idea for what is going on inside of the engine. The below is an early concept idea sketched out, don't take it as a spec to be rigidly followed :) You know where to find us if you want mentoring on this task:
http://www.jboss.org/drools/irc

While the rule itself is named, patterns are not. By allowing patterns themselves to take on ids, we can specify capture points. This is already possible for rule terminal nodes via listeners for rule activation, but users would still need to write their own handlers. The proposal here is to write a utility that will capture propagations during a given start/stop period that users can later inspect for both activations and join attempts. This will allow users to know exactly what is happening underneath.

Blow shows a rule with 3 potential capture points:

package pkg1

rule r1 when then
   Person( name == "xxx" ) @id(p1)
   Location( name == "xxx" ) @id(l1)
then
end

1) The terminal node, via the rule name.
2) p1
2) l1

The idea is to be able to turn on monitor, that has a start(), stop() and clear() methods. When started it will capture the insert, update, retract propagations. Further it should be possible to write assertion utility to assert on the state of the captured information.

When capture is turned on for a given capture point it will record a List of instances. As different nodes have different data, there is a base node and a child node. Every time a propagation happens an instance is created and added to the montior representing the current state.

BaseCapture
   NodeType nodeType       // enum for join, exists, not etc to allow  for casting to correct node
   String nodeName           // enum for join, exists, not etc
   Collection
 rules   // Rules is a collection, as the node  might be shared
   Activation activation      // Activation at the root of the WM  operation (may be null, if the acion came from outside of the wm).
   FactHandle[] f                // fact at the root of the working  memory operation
   FactHandle[] fh              // fact[] that entered the node

JoinCaptire extends BaseCapture
   Direction direction              // Left/Right enum
   FactHandle[] successJoins // the opposite fact handles that were  successfully joined with, during this montioring session
   FactHandle[] failedJoins    // the opposite fact handles that were  unsuccessfully joined with, during this monitoring session.
                                                //Note if the  propagation was from the left the join arrays will all be an length of 1.
RulePropagation extends BasePropagation
   RuleStatus status        // Matched, UnMatched, Fired

For example lets say I want to monitor the propagations on l1 and r1, that happens during two working memory actions. I can do the following:

ksession.insert( new Person("darth"));
fh = ksession.insert( new Location("death star));
NodeMonitor l1monitor = ksession.getMonitor("pkg1/r1/l1")
NodeMonitor r1monitor = ksession.getMonitor("pkg1/r1")
l1monitor.start();
r1monitor.start();
ksession.insert( new Person("yoda));
ksession.retract( fh );
l2monitor.start();
r2monitor.start();

List props = l1monitor.getResults(JoinCapture.class);
List props = r1monitor.getResults(RuleCapture.class);

l1monitor will show left propagation for yoda and a successful join for death star
r1 will have two entries. It will show a match (activation creation) but it will also show an unmatch, due to the retract.

Fine Grained Property Change Listeners (Slot Specific) (Mario Fusco)

noreply@blogger.com (Mark Proctor) — Wed, 18 Jan 2012 00:27:00 +0000

Just a quick recap of what I did until now to check if we are all on the same page and also agree with the naming convention I used.

The property specific feature is off by default in order to make the behavior of the rule engine backward compatible with the former releases. If you want to activate it on a specific bean you have to annotate it with @propSpecific. This annotation works both on drl type declarations:

declare Person
@propSpecific
firstName : String
lastName : String
end

and on Java classes:

@PropSpecific
public static class Person {
private String firstName;
private String lastName;
}

Moreover on Java classes you can also annotate any method to say that its invocation actually modifies other properties. For instance in the former Person class you could have a method like:

@Modifies( "firstName, lastName" )
public void setName(String name) {
String[] names = name.split("\\s");
this.firstName = names[0];
this.lastName = names[1];
}

That means that if a rule has a RHS like the following:

modify($person) { setName("Mario Fusco") }

it will correctly recognize that both the firstName and lastName have been modified and act accordingly. Of course the @Modifies annotation on a method has no effect if the declaring class isn't annotated with @PropSpecific.

The third annotation I have introduced is on patterns and allows you to modify the inferred set of properties "listened" by it. So, for example, you can annotate a pattern in the LHS of a rule like:

Person( firstName == $expectedFirstName ) @watch( lastName ) // --> listens for changes on both firstName (inferred) and lastName
Person( firstName == $expectedFirstName ) @watch( * ) // --> listens for all the properties of the Person bean
Person( firstName == $expectedFirstName ) @watch( lastName, !firstName ) // --> listens for changes on lastName and explicitly exclude firstName
Person( firstName == $expectedFirstName ) @watch( *, !age ) // --> listens for changes on all the properties except the age one

Once again this annotation has no effect if the corresponding pattern's type hasn't been annotated with @PropSpecific.

I've almost finished with the development of this feature (at the moment I am missing the compile-time check of the properties named in the @watch annotation together with some more exhaustive tests), so if you think that I misunderstood something or there is room for any improvement (or you just don't like the annotation's names I chose) please let me know as soon as possible.

Mario

Fine Grained Property Change Listeners (Slot Specific)

noreply@blogger.com (Mark Proctor) — Fri, 13 Jan 2012 22:30:00 +0000

Mario just got a first cut working for fine grained property change listeners. Previously when you call update() it will trigger revaluation of all Patterns of the matching object type in the knowledeg base.

As some have found this can be a problem, forcing you to split up your objects into smaller 1 to 1 objects, to avoid unwanted evaluation of objects - i.e. recursion or excessive evaluation problems.

The new approach now means the pattern's will only react to fields constrained or bound inside of the pattern. This will help with performance and recursion and avoid artificial object splitting. We previously discussed this here:
http://blog.athico.com/2010/07/slot-specific-and-refraction.html
You can see the unit test here:
https://github.com/droolsjbpm/drools/blob/ca55c78429cbc0f14167c604c413cdc3faaf6988/drools-compiler/src/test/java/org/drools/integrationtests/MiscTest.java

The implementation is bit mask based, so very efficient. When the engine executes a modify statement it uses a bit mask of fields being changed, the pattern will only respond if it has an overlapping bit mask. This does not work for update(), and is one of the reason why we promote modify() as it encapsulates the field changes within the statement. You can follow Mario's chain of work on this at his github activity feed:
https://github.com/mariofusco.atom

The adventerous amoung you can pick this up from hudson, or from maven, and start playing now. My hope is that this will make drools much easier to use:
https://hudson.jboss.org/hudson/job/drools/lastSuccessfulBuild/artifact/drools-distribution/target/
Btw we are after a name. Drools is not a frame based system, so "slot specific" doesn't seem appropropriate. Property Specific seems a bit of a mouth full. I'm quite liking High Fidelity Change Listeners :) any other suggestions?

slot-specific is the name used by Jess for this feature, . It's also the standard way that Clips COOL works, which is the Clips OO module. Although that's partly a side effect of the triple representation of properties used in COOL, and the modifications are triple based. I don't know what mechanism Jess is using to enable this.

Mark

jBPM Form Builder follow-up

noreply@blogger.com (Marian Buenosayres) — Tue, 10 Jan 2012 13:55:00 +0000

Greetings! Among the things developed over the last two weeks for the jBPM Form Builder, here are the ones worth mentioning:

Script helper refactor: Some of the classes had issues when being stored on the server side, due to dependencies with GWT client-side classes. A small refactor was made to make them GWT independent, and utilize the GWT API from a particular view object to render on screen.
User roles implemented: JAAS implementations for JBoss and Jetty are available now as stated in my last post. The jBPM Installer inside my fork has the necessary implementations for JBoss, and the Jetty implementations are available to start up the project from the Debug mode in the Eclipse Plugin. Profiles are created as described previously: web designer and functional analyst. Web designer has all the functions available (can define forms, custom menu items and use any item available), while functional analyst can only define forms using the menu items authorized by the web designer.

The whole idea behind these components will be to facilitate web designers to administrate component standarization from inside the form builder.
And here's some of the next items on the to do list:

HTML5 templates: Current form generation templates for Freemarker work with HTML4. There will be a new set of them that will use HTML5, which will probably lead to new menu items to fully cover HTML5 components.
More script helpers: Current script helpers allow to make an easy implementation of an ajax service call, a combobox population ajax call, and to toggle visualization of a particular component (selected by id). There will be more script helpers, focused on creating new visual components on runtime and live validation of fields. And that's where the next one falls in
More validations: We had a few simple validations to start checking where to store them and what to do with them. Now that they seem to reach a plateau where no major refactor is needed, it is a good moment to start adding a lot more validations to the ones that are already there.

That will be all for now. Cheers!

Mariano

Guided Decision Table supports BRL columns

noreply@blogger.com (Michael Anstis) — Tue, 10 Jan 2012 13:49:00 +0000

Work has been completed to allow BRL fragments to be used as both (or either) Condition and Action columns in the Guided Decision Table within Guvnor.

You can see the feature in action here and read more about it below.

Adding a BRL column

A BRL fragment is a section of a rule created using Guvnor's (BRL) Guided Rule Editor: Condition columns permit the definition of "WHEN" sections and Action columns the definition of "THEN" sections. Fields defined therein as "Template Keys" become columns in the decision table.

A Condition BRL fragment

An Action BRL fragment

Consequently any rule that could be defined with the (BRL) Guided Rule Editor can now be defined with a decision table; including free-format DRL and DSL Sentences.

BRL fragments are fully integrated with other columns in the decision table, so that a Pattern or field defined in a regular column can be referenced in the BRL fragments and vice-versa.

A decision table with BRL fragments and regular columns

Source from BRL fragments

Fosdem Brussels 4 February 2012: Planner, Guvnor and jBPM designer

noreply@blogger.com (Geoffrey De Smet) — Tue, 10 Jan 2012 10:01:00 +0000

Fosdem is a free conference on Open Source in Brussels in the first weekend of February. It's a fun conference and getting quite big, filled with Open Source engineers and enthusiasts: long beards, red hats and Mozilla T-shirts are not uncommon :)

Marco Rietveld and I will be presenting in the JBoss.org dev room on Saturday:

There are a lot of other interesting talks too, such as Infinispan, Openshift, Forge, ... so if you're in the neighborhood, join us. Did I mention the entrance is free?

Last Chance - Drools & jBPM at ICAART (Portugal) 4th International Conference on Agents and Artificial Intelligence

noreply@blogger.com (Mark Proctor) — Fri, 06 Jan 2012 16:17:00 +0000

The event is just one week away from being cancelled if we don't get more attendance. So if you are thinking of going, better sign up now, before it's too late.

Mark

---------------

Droosl & jBPM @ ICAART 2012 is now confirmed, and myself (Mark Proctor) and Dr Davide Sottara will be there. If you have any interesting research on or with Drools & jBPM that you would like to present on the day, let us konw.
6-8 Febuary 2012
Vilamoura, Algarve, Portugal
http://www.icaart.org/tutorials.asp

The day is a tutorial day aimed at all levels. It will start with general introductions to the technology but will slant off to more of our research based projects such as Drools Semantics and Chance, as it's part of an academic conference. We would also like to give an opportunity for the people to present their own research, slots can be anything from 20minutes to 60 - contact me if you are interested mproctor at codehaus d0t org.

There will also be plenty of time for discussions and help with your own projects.

Abstract

Drools is the leading open source, industry focused, rule engine. While Drools started life as a Rete based forward chaining engine, it has since transcended. It's ongoing mission is to explore declarative paradigms from a practical and industrial perspective, to boldly go where no engine has gone before.

The tutorial will start with a gentle introduction, suitable for all level of expertise, covering the core language and functionality slowly expanding into more complex areas. The topics covered include, but are not limited to:

Basic Concepts:

Patterns, Constraints and Unification
Data Driven and Goal Oriented Inference using Forward Chaining and (Opportunistic) Backward Chaining
Truth Maintenance
Temporal Reasoning and Complex Event Processing
Functional Programming
Traits and Declarative Models

Advanced Topics:

Decision Tables
Rule and Workflow Integration
Hybrid Rule-Based Systems
Agents and Services
Unified Testing

Brief biography of Mark Proctor

Mark Proctor received his B.Eng in Engineer Science and Technology and then his M.Sc. in Business and Information Systems; both from Brunel University, West London. His M.Sc. thesis was in the field of Genetic Algorithms; which is where he discovered his interest for anything AI related.

Mark became involved in the Drools expert system project at an early stage and soon became its project lead. Mark then joined JBoss (later acquired by Red Hat) as an employee when the Drools project was federated into the JBoss middleware stack.
Mark now leads the effort at Red Hat for a unified platform for declarative technologies; with a focus on rules, event processing, workflow, semantics, distributed agents and governance.

Brief biography of Davide Sottara

Davide Sottara received his Ms. Degree in Computer Science(2006) and his Ph.D (2010) in Computer Science, Electronics and Telecommunications from the University of Bologna.
His research and development interests include Artificial Intelligence in general and Decision Support Systems in particular, focusing on hybrid systems combining predictive models and rule-based systems.

Since 2006, he has been working on the development of intelligent DSSs in the environmental and medical field. He is a member of the Drools open source Community, leading a sub-project on the extension of production rule engines to support hybrid and uncertain reasoning, and he's also involved in the RuleML rule language standardization initiative. He is currently working on remote health-care systems enhanced with AI-based predictive, diagnostic and planning features.

Contacts

e-mail: icaart.secretariat@insticc.org

The Decision Model IP Trap - Part Drei

noreply@blogger.com (Mark Proctor) — Wed, 04 Jan 2012 20:35:00 +0000

part 1 part 2 part 3

Recently Mr Suleiman Shehu wrote a misleading rebuttal on my blog posts "The Decision Model IP Trap" and "The Decision Model IP Trap - Part Deux ". He took great pains to declare that his article was balanced and impartial.

On a side note, interesting post by the famous John Carmack from ID Software on patents - "Yes, it is a legal tool that may help you against your competitors, but I'll have no part of it. Its basically mugging someone." [Carmack]

Mr Suleiman Shehu attempts to argue that patents and open source do mix, and mix regularly, in an effort to highlight my unreasonableness for not considering TDM within Drools. He cites patents owned by Oracle for Java and the recent Oracle and Google court case of those patents as the basis for those arguments. Further he tries to explain that the KPI usage policy is perfectly acceptable for any Open Source project.

Each and every fact he uses to form the basis of his argument is provably incorrect and shows he has no understanding of licensing within Open Source, or the different factions in Open Source, which admittedly is not a simple topic, but that is no excuse. You cannot bundle all of Open Source under a single umbrella argument, each license has different restrictions and guarantees. Having built his rebuttal on misguided, misunderstood and false assumption (points 1 to 4) he then slides to conjecture on my beliefs and motives for which he has no evidence (points 5 to 7). This completely nullifies any claims he has for impartiality, balance or integrity.

I have kept an original copy of his article here. For brevity purposes I have abridged his points, in a way I feel encapsulates his intent. In the original copy I created two columns, where the first column shows the section numbers that correspond with the points in the main document, which is in the second column. This is to show the source for the abridged version in this article.

It was not so long ago that Open Source Systems (OSS) came with a lot of uncertainty. Providing certainty was a large part that allowed mass OSS adoption of both developers and users. Patents create legal uncertainties.

Licenses like (but not limited to) the GPL and Apache License bring certainty, over the years they have built up strong brand recognition that creates instantly known commodities for social charters and usage restrictions of a project. These are catalysts allowing for OSS communities of developers and users to thrive. The licenses do what they say on the tin, you don't need expensive lawyers to hunt down potential additional restrictions. As a leader of an OSS project I value the certainty these bring. I won't stand quietly by, while others seek to dilute those certainties and to muddy the water of respected OSS brands that many have worked hard to establish.

Bearing this in mind, here are the main points:

1) There is no reasonable reason why Drools cannot embrace TDM – WRONG.

1.1) Legally this cannot happen. The Apache license forbids contributions which are covered by patents not made available under the terms guaranteed by the Apache license. The license is crystal clear on this. The same is true for the GPL.

1.2) This actually rebuts his entire article, and is probably the end of the discussion. But for completeness I will falsify each and every fact that Mr Suleiman Shehu uses.

2) Drools is written in Java. Java is patented, your world is already using patents, so what's your problem – WRONG.

2.1) There are no patents for the Java language specification. The term Java is trademarked and you must pass certification to use it. Java can be used to refer to the platform, which is the language specification + libraries + virtual machine. Oracle has patents for its virtual machine, the JVM.

2.2) The Java language specification has no patents. It is possible to implement a VM that can execute Java which does not infringe upon Oracle's patents; see Kaffe: http://www.kaffe.org/. The Java specification provides a safe buffer from possible infringement of patents, from the perspective of developers targeting the Java language.

2.3) This is why patenting of methodologies, specifications and business practices is actually far more dangerous that patents for implementations, where alternative implementation techniques can nearly always be found. If the Java language specification was patented, it would be impossible to do an implementation that does not infringe – in such a situation Java would not have taken off in OSS.

2.4) Illustrating this argument further, Drools DRL is derivative of Ilog's IRL, while IBM may hold patents for the execution of IRL, that has no bearing on our derivative implementation for the IRL language. If however IRL was patented, that would be much more chilling. So it is important to understand the difference in patenting of a specification, which is absolute, and implementationswhich can be worked around.

3) Oracle granted OpenJDK exceptions for those patents, as long as you obey its specification. Why is that different to KPI granting OSS exceptions. If its good enough for them (OpenJDK), why isn't it for you – WRONG.

3.1) When Sun placed its JVM implementation under the GPL license all its patents were also made available under terms of the GPL license. While the Apache license explicitly gives universal and perpetual usage of patented contributions, the GPL has similar implicit terminology. The patent licensing under certification is something completely different and is considered an additional guarantee.
http://en.swpat.org/wiki/Java_and_patents

"OpenJDK is has been distributed by Oracle under GPLv2.[1] GPLv2 includes two implicit patent licences, so users of OpenJDK should be safe, and modified versions of OpenJDK should also be safe (even if they're heavily modified).

“The protections in the GPL are unconditional. The software doesn't have to comply with any specifications in order to benefit from these protections."

3.2) KPI could better clarify its OSS exception. The use of the term “Open Source” creates ambiguity as each license brings different issues that need to be tackled. For this they need a better understanding of OSS licensing – GPL/MIT/BSD/ASL. As stated above for either Apache or GPL, you either provide universal and perpetual access to those patents or you don't. A project cannot be under the terms of GPL if it contains additional restrictions. If there are restrictions on usage, then it's not GPL. Also be aware that providing access to patents for GPL projects does not make them available to Apache licensed projects – see 4.

4) Java is patented, you are safe if you certify - see 3. Which is why Oracle is suing Google. So if those people can work with patents, why can't you – WRONG.

4.1) As stated in point 3, OpenJDK is not "licensing" patents under restrictive terms based on certification. Those grants are universal and perpetual within the GPL eco-system. So using 4's for the "if it's good enough for them, why isn't it for you" is broken. This is further falsified by point 2 where Drools targets a language specification that is not patent encumbered. Oracle is not suing Google for making something that executes Java like code, the Java language specification is not patented. It believes the Google VM infringes its patents. As stated in point 2 it is possible to implement Java while not infringing patents, Google certainly believes they don't infringe on those patents. Even if Google is found to infringe on some Oracle patents, that does not distract from the fact that Java, the language spec, is not patented and all OpenJDK patents are available under the terms of the GPL.

4.2) Google's issue is related to different OSS eco-systems, which is an entirely different subject and out of scope. In short Google's VM is licensed under the Apache License while OpenJDK is under the GPL. Those perpetual and universal grants are restricted to those eco-systems they were placed under. GPL v ASL is a subject completely out of scope. So again, it has got nothing to do with one OSS project using patents under restrictive "certification" terms, see point 3. If Google had placed its VM under the GPL, Oracle would not be able to sue them.

-------

Having shown that each and every fact he uses to support the basis of his argument is completely wrong lets now turn to the darker sides of his blog, where he misappropriates someone's comment and slides to conjecture on my beliefs and motives, for which he has no evidence. This completely nullifies any claims he has for impartiality, balance or integrity.

5) Jacob Feldman, from Open Rules, as an Open Source vendor has endorsed the TDM patent position. "If KPI TDM patent usage rights statement appears to be acceptable to Jacob at OpenRules – an open source decision management company www.openrules.com ) what is there to prevent you from using TDM within Drools?" - MISAPPROPRIATION

5.1) Before you misquote someone whose comment was intended to be amicable simply to avoid conflict, you should probably check with them first before you use them as a full blown endorsement. I have known Jacob personally for many years and have already spoken to him on the matter. And I think I've already answered well enough, time after time, why even legally this is prevented.

6) "The only people who have the moral right to own patents are open source software companies who will naturally use their patents defensively." - CONJECTURE

6.1) That is complete conjecture with no basis of evidence. I have never and will never claim any arguments based on morality. Yes, I believe that patents hinder innovation in software. Yes, I believe that patents restrict the potential of Open Source, as it cannot license patents (as proven in points 1 to 4). This has nothing to do with morality. I am invested in Open Source, I have every right to protect my interests and my employers interests and attempt (within the law) to limit those that might negatively impact on said interests. In the same way any individual or company has every right to hold patents to protect their interest. Morality has nothing to do with it.

7) "Mark believes that this TDM patent should be made available to the wider community on an Apache licence because I believe (but I cannot prove this belief) that Mark would have liked to integrate TDM with Drools in some way and therefore argues that an open source project should not be encumbered with any software patents." - CONJECTURE

7.1) This is so bad in so many ways that I don't even know where to begin. It borders on being libellous. You are trying to claim that I wish to appropriate someone else's property because I wish to use their ideas.

7.2) I've repeatedly said, in almost every thread on this subject, that I consider the research projects Prologa and XTT2 to be far more extensive, and that I will be using those. That alone falsifies any conjecture you are trying to make. Shame on you.

7.3) I think I made it clear in point 6 that my motives are simply about protecting my interests. I'm invested in Open Source, I believe patents restrict the potential of Open Source and I have every right to execute in a way to negate those restrictions.

7.4) I have never said I believe that they "should be made available". That's a very strong statement, insinuating I believe in the appropriation of someone else's property based on arguments of morality. Larry came to me and asked if we would use TDM within Drools, I cannot legally do so under the terms of the Apache license. If they wish for Drools to incorporate TDM, they need to license it under those terms - the choice is theirs and theirs alone. "Should" doesn't come into it.

7.5) Patents create a ‘walled garden’, Drools cannot license those patents under restrictive terms. Thus wider adoption of TDM is not in my employer's commercial interests, as we cannot provide implementations for those potential customers who want TDM. I have every right to protect my employer's commercial interests by communicating this issue to potential TDM adopters, to ensure they do not become excluded from from Open Source.

Mark
Disclaimer: This post is made in a personal capacity. Nothing written above should be construed as Red Hat's corporate position.

Less boilerplate in Planner: Generic MoveFactory

noreply@blogger.com (Geoffrey De Smet) — Sun, 25 Dec 2011 16:39:00 +0000

The recently released Drools Planner 5.4.0.Beta1 includes 2 Generic MoveFactories. That means it's no longer required to implement a MoveFactory and Move to use a local search optimization algorithm such as Tabu Search or Simulated Annealing.

For example, the MachineReassignment example configures Tabu Search like this:

  <localSearch>
    <selector>
      <selector>
        <moveFactoryClass>org.drools.planner.core.move.generic.GenericChangeMoveFactory</moveFactoryClass>
      </selector>
      <selector>
        <moveFactoryClass>org.drools.planner.core.move.generic.GenericSwapMoveFactory</moveFactoryClass>
      </selector>
    </selector>
    <acceptor>
      <propertyTabuSize>5</propertyTabuSize>
    </acceptor>
    <forager>
      <minimalAcceptedSelection>1000</minimalAcceptedSelection>
    </forager>
  </localSearch>

Notice that there is no MachineReassignment specific code in there whatsoever. But if I wanted to, I could easily mix in a custom MoveFactory implementation too.

Planner comes with 2 generic move factories out of the box:

GenericChangeMoveFactory: A GenericChangeMove changes 1 planning variable of 1 planning entity to another planning value. For example: Given course C1 in room R1 and period P1, change its room to room R2.
GenericSwapMoveFactory: A GenericSwapMove swaps all the planning variables of 2 planning entities. For example: Given course C1 in room R1 and period P1 and Course C2 in room R2 and period P2, put course C1 in room R2 and period P2 and put course C2 in room R1 and period P1.

They are slightly slower than a custom implementation, but equally scalable.

The Decision Model IP Trap - Part Deux

noreply@blogger.com (Mark Proctor) — Fri, 23 Dec 2011 13:41:00 +0000

part 1 part 2 part 3

A while back I published this article titled the “The Decision Model Trap”, http://blog.athico.com/2011/11/decision-model-ip-trap.html. In short it highlighted the dangers of adopting a patented methodology and my opinion on Red Hat's stance on the matter. The patent is owned by the Knowledge Partners International (KPI) who push TDM.

My article was referenced in a thread, started by Jacob Feldman from Open Rules, in a linkedin group for “The Decision Model”. It's a closed group, A copy is provided online here. The original link is here:

I'll quote Jacob below:
“First I learned about a possible patent for The Decision Model from Mark Proctor – see http://blog.athico.com/2011/11/decision-model-ip-trap.html. But it was impossible to find any references to it on the web. Besides, neither Larry nor Barb ever mentioned anything about the patent (at least to me). So, I thought that was just a misunderstanding.

However, on Dec. 6, 2011 USPTO apparently granted a patent to Larry and Barb – see http://www.freepatentsonline.com/8073801.html. I believe it would be only helpful if the Decision Model authors openly explain their position regarding this patent to all of us. Otherwise, such a “holiday present” may scare the entire decision modelling community to stay away from TDM. “

The thread turned hostile with a KPI representative demanding I clarify my motivations and then resorting to belittling me – but I'll come back to that later. The result was that eventually KPI made an announcement on their objectives and intentions with regards to the patent and TDM. The link for this is here:

Lets look at this briefly:
Objectives of the Patent Policy:

To ensure that we are able to evolve what we started without risking an infringement of someone else's patent.
To share the ideas behind The Decision Model in an orderly way.
To protect its rigor, hence its reputation.”

With the current insanity of the various patent systems, having to play the patent game, just to protect yourself is a reality. However restricting 3rd party use of that patent is not necessary to achieve the later two goals. Trademark and certification is a perfectly adequate, if not far superior and more effective way to achieve those goals. Unless they have other objectives, not listed, I invite them to license their patent under terms similar to that in the Apache Software License.

Then lets get onto their next statement:
"Vendors who provide Open Source Software, and who wish to incorporate TDM can obtain a royalty-free license for Open Source software. There will be a certification fee and process for Open Source vendors who desire this optional software certification."

Talk about the classic honey trap. Ring ring, ring ring..... "hello?... Hey KPI it's 2002 calling, they want their business ideas back". For those that don't get the joke it's a play on the "hey hunny, its the 80s calling, they want their hair back" :) Seriously the world has moved on, it's clued up, they don't fall for that clap trap any more. KPI, there is an awesome website, that covered the SCO débâcle, called groklaw.net - very recommended reading. If you are an OSS vendor and take KPI up on their offer, you aren't not Open Source - end of story. Just don't do it to yourself, you deserve better, your customers deserve better.

It's old news now that KPI through a partner is trying to infect the OMG Decision Model and Notation standard effort, http://www.omgwiki.org/dmn-rfp/doku.php. Private emails have been sent between the various heavyweights in the OMG process. I think the general sentiment was "not a chance in hell". So that's one nail in the coffin. A proprietary and encumbered methodology will die when faced with an un-encumbered official and open standard.

They may however try to argue that their patent covers the resulting DMN standard, regardless of whether the DMN group accepts their proposal. The result on the industry in general could be chilling. I would urge KPI to re-read groklaw.net about what happened to SCO when they tried to enforce bogus patents. Yes that's right, “SC...Who?” - it's doubtful your reputations and company brand would survive if you became hostile on an open standard and/or an open source implementation of that standard. RIP TDM.....

So let's now get back to that linked in forum posting. As the thread was started by quoting my initial blog, when someone asked what impact this could have on the industry, I felt that I had every right to re-iterate a key point from the article. That while TDM continues to be patented the industry will move around and beyond it, and that the work we are doing lifting from the extensive research made available in the Prologa and XTT2 will also make it's patent irrelevant.

Michael Grohs, VP of Business Development @ KPI, jumped in demanding I declare my motivations – as if I was some how being underhanded. I don't think he had taken the time to read my article. I think it makes my stance and motivations very clear. But then I believe he was more interested in posturing than substance. I'll show two key points from the article, I think they show my stance and motivations pretty clearly.
“...snip...
Open Source and Patents do not mix. When you get software from Red Hat you are guaranteed its 100% Open Source, not maybe OS or partly OS. From top to bottom, inside and out 100% OS goodness.
...snip...
In the mean time we in the Drools team will continue to take our inspiration from the excellent and unencumbered research projects; Prologa and XTT2.
http://www.econ.kuleuven.be/prologa/
http://ai.ia.agh.edu.pl/wiki/hekate:xtt2”

The thread continued to regress into noise. With further indications that I was trying to be underhanded, by demanding I declare my motivations. It was insinuated that I don't live in the real world, that the patents I have through Red Hat make me hypercritical for demanding “special rights”:
“but then world is full of people who believe that they are entitled to special rights which they believe other people should not have. “

In general there seemed to be a lack of understanding on the use of defensive patents within OSS, particularly on how they have virtually no restrictions, beyond that defensive clause – as specified in the Apache Software License. There also seemed to be a lack of understanding on the walled garden patents create, shutting off the OSS research world - which is why I oppose this so vehemently.

Finally Michael, a VP @KPI, just decided to get full out snotty on me. I couldn't figure out if he was trying to belittle me or indicate that I was being underhanded by concealing that I work for Red Hat – or maybe both. I guess when you have nothing of substance to say, just use insults:
Michael:”Mark I understand that your and Edson's patent is assigned to your employer Red Hat and not to the World, but correct me if I am wrong. So it is actually Red Hat who does the gifting. “

I apologise in advance for the slightly over pompous use of “I”. Those that know me, know that while I evangelise the technology, that I will big up the Drools community in general and it's achievements - I do not try to add grandeur directly to my personage, that actually I'm a little shy of direct attention. I believe Michael thought I was some peon of a developer, scuttling along to my masters commands. So given the circumstances, I felt that a point should be made:

Michael:"I understand that your and Edson's patent is assigned to your employer Red Hat and not to the World, but correct me if I am wrong. So it is actually Red Hat who does the gifting. "

mark:"I'm really not sure what point you are trying to make with this comment. When you have to reach for semantic interpretations it makes you sound bitter and doesn't become an industry professional. I'm not even sure I should dignify it with a response.... but then I wouldn't be me :)

"So it is actually Red Hat who does the gifting"
I don't make it any secret that I'm employee of Red Hat, I'm very proud to work for the worlds number one Open Source company.

But I don't know if that is the point you are trying to make, or if you are trying to belittle me by arguing semantics on the appropriation of the term "we". Much as Suleiman keeps trying to talk down to me by using terms like "real world" and "special rights". So I guess I should answer both possibilities, neither are becoming for you.

I'm the co-founder and creator of Drools, I did this before joining JBoss. The choice to license Drools under the Apache Software License was mine and done before joining JBoss - JBoss was later acquired by Red Hat. It is this license, that I chose, that grants those free and perpetual rights. In fact it is this license that ensures that neither I nor Red Hat nor anyone else contributing to Drools project may file a patent that is not covered under this free and perpetual rights, when that patent relates to Drools.

While at Red Hat it was my choice to file the patent and my choice to do the work necessary for the patent, I could have chosen not to file a patent. Edson also had those same personal choices and we did the work together.

I would say considering those choices that I made I have a write to use the term "we". We as in myself, Edson and Red Hat.

"and not to the World"
You are trying to argue the points of assignment and usage and gift? I'm not sure which part of the following you don't get:
"a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work" "

It doesn't get more "gifting" than this. Well maybe it can. Having watched a user gorge themselves on christmas pudding, mince pies and port. I could wrap the patent in silver paper with stars on it, tie a red bow around it, put on my Red Fedora and climb down the chimney and ram it down their throats. Is that "gifty" enough for you? :) to clarify the term "their" I mean "the world".

......next? “

Anyway I'm looking forward to what Jan Vanthienen, one of the decision table godfathers, has to say on the matter in the new year. I'm guessing that he's not pleased that someone took his work, changed the names used in the terminology and patented it.

Mark
Disclaimer: This post is made in a personal capacity. Nothing written above should be construed as Red Hat's corporate position.

Drools : A Journey towards a Meta Framework for Hybrid Reasoning Systems

noreply@blogger.com (Mark Proctor) — Tue, 20 Dec 2011 10:40:00 +0000

Introduction

Recent versions of Drools have started to show our direction towards a hybrid reasoning system, going beyond production rule systems. In 2011 we introduced prolog style derivation trees, with reactive materialised views, we also introduced traits. In 2012 we'll continue to build out more of the prolog like functionality and traits will expand to description logic for semantic reasoning.

To make further progress I feel we need to smash apart our current infrustructure that is hard coded for the rigid way PRD systems where designed 30 years ago. In that time the structure of PRD systems hasn't change that much. In essence they have an agenda + conflict resolution strategy. Simple "groups" have been added by various systems be it a single push/pop stacks or rufeflows. Further execution control has been hard coded via attributes.

If we could break Drools down into smaller components, each with life cycles, event models, hook points and designed for compositability - what would this look like? This would provide more of a meta framework, so the author can define how it's execution should behave and open up Drools to a wider variety of research and problem solving.

Existing PRD behaviour can be easily provided as an "out of the box meta configuration", however it is hoped via "macro's" power users can implement other useful types of behaviours and provide those to end users as fully encapsulated macro's.

By opening up the way that Drools components can be easily brought together we hope to make it easier for people to try out different research ideas - without having to develop yet another engine. This will allow ideas to go beyond that conceived by the core development team.

I hope the introduction of a macro concept for rules will allow for a more pattern oriented approach to rule engine development.

When reading this document please cast aside preconcieved ideas of what a rule engine is or how it works. The document is conceptual in nature and at this stage I would like conceptual input on how to progress the ideas, and not spend 95% of the time argueing over which symbols or keywords to use, or whether it's needed (see http://www.bikeshed.com). Expect many rough sketches, incomplete syntax etc, it is conceptual brain storming and not an implementation spec.

Continuous updates to this article can be found here.

Module

Additional ideas on modules for rules can be read as part of the research on Venus:
Venus: An Object-Oriented Extension of Rule-Based Programming (1998)
An Overview of the VenusDB Active Multidatabase System (1996)

The module concept can be introduced as generic container for rules. The module consists of a name and arguments. Parenthesis can be ommitted if no arguments are specified. There are also further member variables, internal to the module. A module supports attributes. A module can specify a single parent module, there is a MAIN module which is the default parent of all modules. A module may optional extend other modules

<@attribute(....)>*
module <module_name> ( <arguments>*)
 <parent module_name>? 
 <extends <module_name>+>* 
 <variables plus optional initialisation>*

A DRL can have multiple modules specified. Within the DRL file all rules that come after that module name are associated with the module.

module A
 rule r1....
 end 

 rule r2...
 end

module B(String s, Person p) 
 var Book b  

 rule r3... 
 end  

 rule r4... 
 end

NOTE) Can modules span namespaces? What does a namespce mean for a module, does it live within the namespace or is it global? For now assuming scoped to namespace.:

A module can be called like a java Runnable, the caller's method signature must match the specified arguments or a runtime exception is thrown

Module m = kruntime.packages["org.domain"].modules["A"]
ModuleHandle bhA = m.run()

m = kruntime.packages["org.domain"].modules["B"]
ModuleHandle mhB =m.run( "S", new Person("darth") );

The parameter variables are available to the rules inside of the module, in a similar manner that globals are. An array pattern referencing the arguments is injected as the root pattern to each rule. This not only makes the variables available but acts as a control object for when rules can fire with those variables. The ModuleHandle has a "stop" method that results in that array element being retracted, and thus the rule cannot fire any more for those variables. Even rules associated with that module that do not depend on those variables has the root control fact injected.

mhB.stop()

Note that a module can be called multple times with different arguments, each results in a different ModuleHandle. Should a module be called with existing arguments the previous ModuleHandle is returned. So you can consider a module instance module + variables.

Passed module arguments may or may not be facts, if they are facts they may be modified (unlike globals) and patterns will respect and react to that change as normal. The module's called signature is updated.

The role of member variables is for scoped data avaliable to events, such as counters or intermediary objects.

(NOTE) If we want to make member variables available to rules, we will need to think carefuly about the behaviour, as they have more potentially more complications than globals. Currently they are only available as fields on events, see the activation-group variance.

Match

A Match is the same as the traditional Activation concept in PRD systems. It has an array of FactHandle's for the matched objects. But we recognise the Match can be active or dormant, and use a boolean to represent this, and that even information on dormant matches can be useful in reasoning systems. A Match is considered active if it is ellible for for foring and has not yet done so.

Match 
 FactHandle[] facts 
 boolean active

(NOTE) Maybe instead of "boolean active" we should have an enum, and possible also including "running" as a state. ACTIVE, RUNNING, DORMANT.

(NOTE) It's possible for a rule + facts to fire multiple times without relaxing (made false). We should optional keep a counter for the number of times fired, and even each execution can be time stamped.

Module Properties

Module Properties
activeSize // number of active Matches, queries can be used for more complex cases using rule attributes
dormantSize // number of dormant Matches, queries can be used for more complex cases using rule attributes
activeMatches // Collection of active Matches
dormantMatches // Collection of dormant Matches

(NOTE) The size and and collection properties only contain relevance for eager matching algorithms that compute an entire cross product for each WME change. Future versions of Drools may optionally implement some lazy matching and in those situations the user's understanding of those properties may be a problem.

Module Methods

Module Methods
 cancel() // all active matches are made dormant
 cancel( Match ) // cancels a match, i.e. sets it dormant, if already dormant this method does nothing.
 refresh() // all dormant activates are made active, however filters such as calendars, enabled etc are still obeyed
 refresh( Match ) // refreshes a match, i.e. sets it active if it's dormant, if it's already active it is ignored
 halt() // The state of the module is preserved, but no
 continue() //
 addListener() // type inference adds the listener implementation to the correct list(s).                  
               // Listener composition for  single instance is allowed, meaning it is added to multiple listener lists.
 start(Object[] args)
 stop()

Module Events and Lifecycle

A Module has a life cycle to which listeners may be added.

Module Events
onEnter // when a module is called
onExit  // when a module is stopped
onMatch // when a rule is matched
onRematch // when a rule is matched and is matched again, without relaxing first (via update)
onUnmatch // when a rule stops being matched
onBeforeFire // before a rule for this module fires
onAfterFire // after a rule for this module fires
onHalt // tells the listener halt has been callled
onResume // tells the listeners resume ahs been called
onEmpty // when the size == 0, all Matches are dormant -- other potential events --
onBeforeRuleEvaluation // before a wme insert/update/delete for this module
onAfterRuleEvaluation// after a wme insert/update/delete for this module

onEmpty will only be triggered after the first rule evaluation phase. i.e. it does not fire after onEnter, before the rule evaluation phase has had a chance to execute.

(NOTE) Other potential events are before/after rule evaluation. Each WME insert/modify/update causes a rule evaluation, and could be listend to via onBeforeRuleEvaluation and OnAfterRuleEvaluation. This poses problems with concurrency where potentially multiple insertions/updates/modifies could be happening at the same time. So at best it's a listener scoped to a fact, we cannot guarantee the resutling matches are assocated with this event, unless serial rule evaluation is enforced - which may be a possible configuration for a module.

DRL will support the ability to declare literal functions attached to these listeners, the exact syntax for this is TBD. But the keyword will probaby be "on.". We will support .Net style delegate operators for = and += when adding or setting listeners.

on.Enter += {
}

Those listeners can also be added from java code.

Simulation the Agenda

A Module itself doesn't do anything other than obey the life cycle of the prescribed events, it doesn't even fire a rule, making it dormant. The only thing the Module does is maintain the list of active and dormant matches.

However this then allows a much more flexible system to which the end user can customise the behaviour. For instance the traditional agenda+conflict resolution strategy can be implemented via the onMatch/onRematch/onUnmatch listeners.

class Agenda implements onMatch, onUnmatch, onRematch { 
 ....
}

The above class implements a composition of event listener interfaces, but it only needs to be added to the module once

module.addListener( new Agenda() );

This means each module may have it's own conflict resolution strategy. Some may want more traditional lifo execution, but anything else is possible. Such as rule definition order, or async execution. Listeners can be combined, but that means that order IS important. Some listeners may want to preevent a rule from firing, others may want to prever other rules from firing after the current rule has fired.

Async rule execution

Fire each match asyncronously as it matches.

onMatch + { asyncFire( match ); }

Manual Interaction Agenda

Because the listeners are now fully pluggable and whether a rule fires or does not, or is cancelled is fully pragmatic it is possible to just expose the Module via an interactive GUI and the end user can see the conflict set and specify which rule(s) to fire.

As WME actions occur the users GUI will be updated showing the active matches, however none will fire without user selection. This means the user can interrogate the state of each Match and the fact it contains to select whch rules to fire. The user can also see dormant matches and "refresh" them so they can become available for firing again.

This could be taken a step further where a user sees a dash board of modules and all are inactive and the user can manually activate modules they wish to see evaluated.

Simulating existing rule execution behviours

activation-group plus variance

Other rule attribute behaviours can be implemented by combining listeners, although listener order is obviously important. For instance this listener can be added AFTER the agenda listener, and it simulates the existing "activation-group" behaviour, such that only the first activation fires for a conflict.
activation-group

onMatch += { 
 module.cancel(); // cancels all other matches
}

We could do a variance on this that fires the first 3 activations, and cancels the rest

onEnter += { count = 0 } // count is a module member variable
onMatch += { 
 if ( count++ == 3 ) {      
      module.cancel(); // cancels all other matches    ]
 }
}

ruleflow-group

ruleflow-group behaviour is very simple to simulate. jBPM injects a trigger member variable, that on exit calls telling jBPM to trigger the next nodes in the flow, which may be ruleflow-group nodes or other jBPM nodes

onEmpty { module.stop() } // stopping the module causes onExit to fire
onExit + {
 node.triggerCompleted()
}

agenda-groups

agenda-groups implement a push/pop stack behaviour. Only the stack tip executes, the others are considered "halted". To acehive this the consequence of any rule needs to call the following three methods:

module1.halt();
module2.onExit += { module1.resume() };
module2.call();

So that halts the current module and executes "pushes" the next module, when that module finishes "pops" the caller is resumed.

Simulating agenda-filters
If a match is cancelled, and made dormant it is not propagated to the next listener in the onMatch event.

onMatch += {
 if ( <boolean expr> ) {
     module.cancel( match );
 }
}

Events as facts

Events are also inserted as facts, so can be matched in rules too. Member variables are fields on the events

rule  activationGroupVariance when 
 m : OnMatch( count < 3 )
then 
m.count++
end

Parent Modules and Module Scoping

Modules can contain sub modules, they can ony be called from within the scope of the parent module.Sub modules will have access othe parent modules member variables and parameter variables.

Module Reuse and Extension

A module can extend other modules. The exact semantics of this will need a lot more extensive though, but i'll outline something to get started. When a module extends another module it effectively copies the definitions of all the contained rules.However those rules will match and fire completely indepedantly of the source.

Macro's to abstract module configuration

All this manual configuration would become very cumbersome to the end user, and potentially far too complex. The idea is that all the above complexity is for power users, this is then encapsulated via macro's for end users. I don't intend to outline a Macro system for Drools yet, as that is a different subject in itself and will need a lot of though. For now I'll use <macro "name">, pontentially these can be listed. But how macro's are defined and applied are completely open to debate. These macro's are then expanded at complie time to provide all the required listener behaviour:

Module xxxx 
macro activationGroup( "g1" )

module xxx 
macro agenda module xxx 
macro agenda activationGroup( "g1 )

module xxx 
macro default

Drools 5.4.0.Beta1 released

noreply@blogger.com (Toni Rikkola) — Tue, 20 Dec 2011 10:15:00 +0000

We're happy to announce the release of Drools (Expert, Fusion, Planner, Guvnor) 5.4.0.Beta1.

Beta1 finally introduces the simulation and testing work that we've been talking about for so long. This will provide a unified environment for simulation and testing over time for rules, workflow and event processing. Beta1 also demonstrates our continued effort to fully commodotise the decison table paradigm, using the excellent research provided by Jan Vanthienen's Prologa project, some high lights for the decision table improvements are listed below.

Limited and Extended entry wizards
Automatic decision table generation to expanded form
Improved rule templating flexibility
Work Item integration (declarative lazy environment bound functions)
Impossible Match detection
Conflict Match detection

Documtation, Release Notes and Downloads are detailed below:

Download the zips from the bottom of the drools download page.

To try out the examples, just unzip one and run a runExamples.sh/.bat script.

See the JBoss Maven repository for a list of all released artifacts.

It will be synced to Maven Central automatically in a couple of hours.

Read the new and noteworthy changes here.

Try it out and give us some feed-back (user list, issue tracker).