Tuesday, January 31, 2012

Drools 5.4.0.Beta 2 released

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:

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

Thursday, January 26, 2012

Wumpus World Update

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

Wednesday, January 25, 2012

Wumpus World

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.


Monday, January 23, 2012

Guided Decision Tables - An update

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


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


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


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

Friday, January 20, 2012

jBPM Form Builder roadmap

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

  1. 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.
  2. 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)
  3. 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.
  4. 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.
  5. 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.
  6. 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. 
  7. 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.
  8. 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.
  9. 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.
  10. 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.
  11. 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.
  12. 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)
  13. Pagination items: Create UI components that would allow to create very large forms within several pages, all part of the same form.
  14. 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.
  15. 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.
  16. 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.
  17. 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.
  18. 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.


Thursday, January 19, 2012

Guided Decision Table - Copying\pasting rows

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

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:

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)
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.
NodeType nodeType // enum for join, exists, not etc to allow for casting to correct node
String nodeName // enum for join, exists, not etc
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")
ksession.insert( new Person("yoda));
ksession.retract( fh );

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.

Wednesday, January 18, 2012

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

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
firstName : String
lastName : String

and on Java classes:

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.


Friday, January 13, 2012

Fine Grained Property Change Listeners (Slot Specific)

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:
You can see the unit test here:

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:

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


Tuesday, January 10, 2012

jBPM Form Builder follow-up

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!


Guided Decision Table supports BRL columns

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

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?

Friday, January 06, 2012

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

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.



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

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.


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.


e-mail: icaart.secretariat@insticc.org

Wednesday, January 04, 2012

The Decision Model IP Trap - Part Drei

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.

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

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