Drools - Business Logic integration Platform

Drools Smooks Data Loader

2008-07-05T15:10:00.004+01:00

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

2008-07-04T20:32:00.004+01:00

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

2008-07-04T13:23:00.005+01:00

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

2008-07-02T16:14:00.005+01:00

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

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

The current tentative agenda for ORF is pasted below:

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

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

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

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

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

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

Drools Clips progress

2008-06-25T00:42:00.003+01:00

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

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

(click to enlarge)

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

IDE re-license from ASL to EPL

2008-06-23T17:00:00.002+01:00

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

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

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

Mark

Why you need Business Rules in your workflow

2008-06-17T15:15:00.003+01:00

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

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

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

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

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

Drools Job Posting - Drools Designer (Croatia)

2008-06-13T12:35:00.002+01:00

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

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

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

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

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

You must be fluent in english.

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

Google Summer of Code project

2008-06-12T00:49:00.002+01:00

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

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

He blogs about his experiences here.

JBoss Benelux User Group

2008-06-11T12:54:00.003+01:00

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

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

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

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

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

2008-06-06T18:29:00.005+01:00

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

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

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

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

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

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

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

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

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

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

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

which could support a rule like

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

just as easily as it could support

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

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

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

would allow the user to rewrite the above rules as

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

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

Take that approach, and create some simple token replacements like

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

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

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

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

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

{variable}

and progressed to

{variable:pattern}

could be extended do something like

{variable:[attributeName,attributeValue]}

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

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

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

Matt Geis

Drools Puzzle Round 3: Mastermind

2008-06-01T13:44:00.005+01:00

Important: Participation Rules. The rules are updated. Links to past puzzles and result reports can be found at the end of that entry.

Difficulty of this round: middle++

Submission deadline: August 16th, 2008
Submission email: droolspuzzle@gmail.com

This time we'd like to see implementation of the codebreaker for a variation of the classic game "Mastermind".

Please refer to the wikipedia Mastermind page for the game's basic rules. Our variation employs 12 different colors and 8 code slots. The CodeMaker.java is provided here. Participators must use this class as codemaker. The inline documentation of this class explains the judging rules in detail. The main method in the CodeMaker.java demonstrates how to call the code getter and how to use the answer judge.

Participators are required to write the codebreaker part of the mastermind application. Maximal trials is not specified in our codemaker, your should design a strategy which can minimize the number of trials.

Your test code should break 1000 different codes and output

the number of average trials for breaking a code,
the average time used for breaking a code

Something looks like this:

long totalTrials = 0;
long startTime = System.currentTimeMillis();

for (int i = 0; i < 1000, i++){
CodeMaker maker = new CodeMaker();
CodePeg[] code = maker.getCode();

// call your code breaker routine here
//...
}
long endTime = System.currentTimeMillis();

System.out.println("Average trials per code-breaking: " + totalTrials/1000);
System.out.println("Average time per code-breaking: " + (endTime - startTime) / 1000 + " ms");

Your code should be reasonably packaged and documented. Please by all means document your strategy as comprehensible as necessary.

Drools Job Board Posting, NY

2008-05-30T22:44:00.003+01:00

Just thought I'd highlight a job posted on the Drools job board at the moment. Remember the job board is free and all adverts also appear on the side of this blog for maximum exposure.

Core java/J2EE Web Developer
Investment Banking, New York, NY

Development on Insight - strategic risk management tool for Sarbanes-Oxley Section 404 risk assessment. Production support on applications, which includes coordinating with 3rd party vendors and providing support for SOX S.404 users globally. Co-development with 3rd party vendor. Reporting development using JasperDecisions. Work with business users on formulating requirements. Develop technical specifications from business requirements. Unit and integrated systems testing. 5+ yrs of Java/J2EE development on presentation tier and back-end. Open Source frameworks: Spring, Struts, Hibernate, Apache/Tomcat, JBPM, DROOLS. O/S: Linux and Unix. Database: UDB and Sybase. Others: Linux/Unix scripting, Eclipse IDE, MS Office. Familiarity with GoF and J2EE Design Patterns. Desirable Skills: Experience in the financial industry, JUnit, ANT.

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

Accessing Guvnor as a Filesystem (WebDAV)

2008-05-23T06:47:00.001+01:00

Just checked in to trunk, is the capability to access the repository back end as a filesystem. This is useful for a whole lot of cases (including, for instance, saving Excel directly to the repository). Its also a neat lead into the ability to have files both in the repository for governance and editing, and in the IDE for devlopers (probably lots of other uses as well).

This is using the WebDAV standard (Level 2 compliance). WebDAV is reasonably well supported by most operating systems, many end user applications, and various 3rd party clients (and command line utilities for those so inclined). It works over http(s).

Here is a look-see of how a repository looks in OSX finder:

And here it is in windows (xp) explorer:

How to setup: On the repository side - nothing ! The url to access it is the same as the repository server, with /webdav on the end (instead of any HTML file). You can drill down in the URL if you like, by adding: webdav/packages/ - "packages" is required (at the moment it provides a package centric view - packages are folders for this purpose). You can copy and delete packages just like folders, drag and drop things to your hard drive etc...

On the client side:
* Mac OSX finder: Press Apple-K, and then enter the URL (it will prompt for some credentials to access the repository).
* Windows XP: Go to "My Network Place", then "Add a network place" - and use the URL (you can create a shortcut to it on the desktop or wherever.
* Cyberduck: an excellent free client for OSX that works much better then finder (OSX finder is inefficient, and tries to do Naughty Things which gave me no end of grief...)
* Other apps, such as excel, can support webdav URLs more directly if needed.

Versioning:
As the repository is versioned, this is essentially an automatic versioning file system. To avoid millions of trivial little versions being created, it won't create a version with every little save, it will wait until a certain amount of time has passed before creating a new version in the repository automatically (but you won't notice anything from the filesystem point of view). If you really want it to create a new version, you can delete it and drag a new copy over again.

Some caveats:
OSX finder will not let you copy and paste (mostly due to its inability to rename copies to anything useful - maybe fixed in a future version of Finder), so don't try (if you want to copy something, drag it to your mac desktop, rename it, edit etc, and then drag it back).

Efficient Binary Protocol Marshalling for Drools Stateful Sessions

2008-05-18T04:56:00.003+01:00

New code has been added, in trunk for a highly efficient binary protocol marshalling for stateful sessions. While Drools 4 supported standard serialisation of Working Memories, it used the default serialisation, this is both very slow and memory bloating. It also has the problem that it just serialises the user objects with it.

The new marshalling implementation allows for a strategy approach when handling the marshalling of user objects. You register different strategies for different name spaces. Currently we have two strategies, Serialised and Identity. Serialised just writes the user object to the stream via standard readObject/writeObject methods. Identity assigns the user object an id, from an int counter, and places it in a map and writes the id to the stream. Reading in uses that map to lookup the user object. Identity strategy is thus stateful, the write method can only be called once but read can be called repeatedly. Other strategies will be added, such as hibernate place holder support. Users can of course write there own.

So what does this give?

Session pause/resume, ideal for moving a session to a new server or restarting an existing server.
General snap shotting, backup. You could do a poor man's high availability by snap shotting the session at the end of each transaction. Later we will be extending this binary protocol to support journalling and also replication via clustering.
Pre-loaded session templates. If you repeatedly create stateful sessions with the same base set of data and the insertion time is annoying, now you can just populate the session once and write out to a byte[] and use that as a template for further session creations.
Long term persistence, needed for our process integration work.

You can see the MarshallingTest to look at the integration tests in place at the moment.

In integrationtests' SerializationHelper you can see the helper methods there demonstrating how it all works.

The DefaultMarshalling class uses the Identity strategy if it is not passed a strategy factory. The Identity strategy is used throughout the tests.

The read/write marshalling is maintained in two files InputMarshaller and OutputMarshaller, this will allow better handling of backwards compatiblity in the future.

It's still very alphaware, but please do start trying it. I need to tidy up the debug output and will do that soon, I'll probably make each read/write method take a String which will be written to the log when debug is on. It currently sorts a number of map/set data structures, this is for debugging so that testing can round trip for data loss, I will make sure that it can be disabled for production. The following types don't yet marshall, not sure how to handle date/time stuff at the moment:
Temporal Sessions do not marshall
Scheduled rules, duration attribution do not marhsall

Implementations have not been added for accumulate, collect, from and rightinputadapter.

We are just hooking up the process marshalling into this at the moment.

Mark

A REST API for Drools

2008-05-06T12:26:00.003+01:00

Part of the work for the Drools 5 repository is a Rest API - to allow content to be accessed remotely. The initial purpose of this is to let assets in the repository be synced with files in a developers workspace.

Rest turns out to be a perfect fit, we have the usual verbs:

PUT: update content (create a new version).
POST: create a new asset
DELETE: delete an asset
GET: retrieve asset content, or package listing

All actions are of course in the context of a package - but this is all specified by the url:

http:///api/packages//

So for instance, doing a PUT to: http:///api/packages/SomePackage/SomeAsset.drl will update the content of the SomeAsset.drl.

This may be terribly useful to some, terribly un-interesting to others, but at the very least people should appreciate the ability to get and update content to files/workspace from the repository without error prone import processes.

JavaOne 2008

2008-05-02T01:46:00.004+01:00

Whilst Mark or Edson's proposals for JavaOne 08 were not accepted (they made the mistake of not including Netbeans or Glassfish in the titles ;), Michael will be attending.

Not doing any specific presentations, but happy to talk, do some ad-hoc demos and generally hang out. I will be around the JBoss/Red Hat stand at least some of the time.

Its a bit of a long trip over from my end of the world, and am not looking forward to the horrific jet-lag that awaits me.