Friday, March 13, 2015

Reactive Incremental Graph Reasoning with Drools

Today Mario got a first working version for incremental reactive graphs with Drools. This means people no longer need to flatten their models to a purely relational representation to get reactivity. It provides a hybrid language and engine for both relational and graph based reasoning. To differentiate between relational joins and reference traversal a new XPath-like was introduced, that can be used inside of patterns. Like XPath it supports collection iteration.

Here is a simple example, that finds all men in the working memory:
Man( $toy: /wife/children[age > 10]/toys )

For each man it navigates the wife reference then the children reference; the children reference is a list. For each child in the list that is over ten it will navigate to its toy's list. With the XPath notation if the leaf property is collection it will iterate it, and the variable binds to each iteration value. If there are two children over the age of 10, who have 3 toys each, it would execute 6 times.

As it traverses each reference a hook is injected to support incremental reactivity. If a new child is added or removed, or if an age changes, it will propagate the incremental changes. The incremental nature means these hooks are added and removed as needed, which keeps it efficient and light.

You can follow some of the unit tests here:

It's still very early pre-alpha stuff, but I think this is exciting stuff.

Tuesday, March 10, 2015

UF Dashbuilder - Activity monitoring in jBPM

syndicated from

Last week, the jBPM team announced the 6.2.0.Final release (announcement here). In this release (like in previous ones) you can author processes, rules, data models, forms and all the assets of a BPM project. You can also create or clone existing projects from remote GIT repositories and group such repositories into different organizational units. Everything can be done from the jBPM authoring console (aka KIE Workbench), a unified UI built using the Uberfire framework & GWT.

   In this latest release, they have also added a new perspective to monitor the activity of the source GIT repositories and organizational units managed by the tooling (see screenshot below). The perspective itself it's just a dashboard displaying several indicators about the commit activity. From the dashboard controls it is possible to:

  • Show the overall activity on our repositories
  • Select a single organizational unit or repository
  • List the top contributors
  • Show only the activity for an specific time frame

  In this video you can see the dashboard in action (do not forget to select HD).

Contributors Perspective

  Organizational units can be managed from the menu Authoring>Administration>Organizational Units. Every time an organizational unit is added or removed the dashboard is updated.

Administration - Organizational Units 

   Likewise, from the Authoring>Administration>Repositories view we can create, clone or delete repositories. The dashboard will always feed from the list of repositories available.

Administration - Repositories

   As shown, activity monitoring in jBPM can be applied to not only to the processes business domain but also to the authoring lifecycle in order the get a detailed view of the ongoing development activities.

How it's made

The following diagram shows the overall design of the dashboard architecture. Components in grey are platform components, blue ones are specific to the contributors dashboard.

Contributors dashboard architecture

  These are the steps the backend components take to build the contributors data set:

  • The ContributorsManager asks the platform services for the set of available org. units & repos. 
  • Once it has such information, it builds a data set containing the commit activity.
  • The contributors dataset is registered into the Dashbuilder's DataSetManager.

   All the steps above are executed on application start up time. Once running, the ContributorsManager also receives notifications form the platform services about any changes on the org. units & repositories registered, so that the contributors data set is synced up accordingly. 

   From the UI perspective, the jBPM's contributors dashboard is an example of hard-coded dashboard built using the Dashbuilder Displayer API which was introduced in this blog entry. The ContributorsDashboard component is just a GWT composite widget containing several Displayer instances feeding from the contributors data set.

   (The source code of the contributors perspective can be found here)

    This has been a good example of how to leverage the Dashbuilder technology to build activity monitoring dashboards. In the future, we plan for applying the technology in other areas within jBPM, like, for instance, an improved version of the jBPM process dashboard. We will keep you posted!

Monday, March 09, 2015

Zooming and Panning between Multiple Huge Interconnected Decision Tables

Michael has started the work on revamping our web based decision tables. We've been experimenting with HMTL5 canvas with great results, using the excellent Lienzo tool. First we needed to ensure we could scale to really large decision tables, with thousands of rows. Secondly we wanted to be able to pan and zoom between related or interconnected decision tables. We'll be working towards Decision Model and Notation support, that allows networked diagrams of Decision Tables.

You can watch the video here, don't forget to select HD:

Notice in the video that while you can manually pan and zoom it also has links between tables. When you select the link it animates the pan and zoom to the linked location. 25s to 47s in is showing  that we can have really large number of rows and keep excellent performance, while 55s is showing the pan speed with these large tables. Initially the example starts with 50% of cells populated, at 1m in we change that to 100% populated and demonstrate that we still have excellent performance.

jBPM 6.2.0.Final released

The bits for the jBPM 6.2 release are now available for you to download and try out !  

Version 6.2 comes with a few new features and a lot of bug fixes !  New features include a.o. EJB, (improved) OSGi and Camel endpoints support, a new asset management feature (to introduce a development and release branch and promote assets between both), social profiles and feeds and the ability to extend the workbench with your own plugins!

More details below, but if you want to jump right in:

Release Notes

Ready to give it a try but not sure how to start?  Take a look at the jbpm-installer chapter.

jBPM 6.2 is released alongside Drools (for business rules) and Optaplanner (for planning and constraint solving), check out the new features in the Drools release blog, including a brand new rules execution server and the Optaplanner release blog as well.

A big thank you to everyone who contributed to this release!

Some highlights from the release notes.

Core services

  • EJB: the jBPM execution server (that is for example embedded in our web-based workbench) now also comes with an EJB interface.  A refactoring of the underlying jbpm-services now makes the execution services accessible using pure Java, CDI, EJB and Spring. Remote interfaces using REST and JMS are still available as well of course !  A lot more details are described in Maciej's blog here.
  • Deployments (defining which versions of which projects are currently active in the execution server) are now by default stored in the database.  This greatly simplifies the architecture in a clustered environment in case you are only using our runtime side of our web tooling (for example by having dedicated execution servers in production).
  • Our asynchronous job executor has improved support for requeuing failed jobs and for recurring jobs (e.g. daily tasks).
  • OSGi: Full core engine functionality is now available on top of OSGi.  A significant number of additional jars (including for example the human task service, the runtime managers, full persistence, etc.) were "OSGi-fied". Specific extensions and tests showing it in action are available for Apache Karaf and Aries Blueprint (in the droolsjbpm-integration repository).
  • Camel endpoint URIs: A new out-of-the-box service task has been implemented for using Apache Camel to connect a process to the outside world using some of the numerous Camel endpoint URIs. The service task allows you to for example specify how to pass data to an FTP endpoint by configuring properties such as hostname, port, username, payload, etc. for some common endpoints like (S)FTP, File, JMS, XSLT, etc. but you can use virtually any of the available endpoints by defining the URI yourself (

  • Form Modeler comes with improved support for adding custom logic to your forms using JavaScript on changes, and support for configurable ComboBox and RadioGroup fields, and simple List types.
  • Asset management: It is now possible to make a repository a "managed repository".  This allows you to split up a repository in multiple branches, one for doing development and on for releasing.  Users can then request various assets to be promoted to the resource branch when ready.  This promotion process, and the linked build and deploy processes, are defined using a BPMN2 process as well and include approval and build tasks.  Check the documentation for more details.

  • Social features, like user profiles (including gravatar pictures), and various event feeds like the most recent assets you worked on, on recent changes by other users.

  • Contributors perspective is a new out-of-the-box report (using the new dashbuilder technology) that gives high-level insight in who is changing what in your repositories.
  • Pluggable workbench:  you can now extend the workbench with your own views, menus, etc. using workbench plugins. Available features includes creation of perspectives via a programmable or a drag and drop interface, create new screens, editors, splashscreens and dynamic menus. 

Friday, March 06, 2015

Drools 6.2.0.Final Released

We are happy to announce the latest and greatest Drools 6.2.0.Final release.

This release in particular had a greater focus on improved usability and features that make the project easier to use (and adopt). Lots of improvements on the workbench UI, support for social activities and plugin management, as well as a brand new Execution Server for rules are among the new features.

Improved Wizards

Execution Server Management UI

Social activities

Contributors dashboard

Perspective editors

Here are a few links of interest:

We would like to use the opportunity to thank all the community members for their contributions to this release and also JetBrains and Syncro Soft for the open source licenses to their products that greatly help our developers!

Happy drooling!


Thursday, February 19, 2015

Submit your work to the 9th International Web Rule Symposium (RuleML 2015)

Professor at Freie Universitaet Berlin
Dear CEP Colleagues,

I would like to encourage you to submit your research in the field of rules, rule-based reasoning and its applications to RuleML 2015 (

It is an excellent opportunity for a high impact conference publication (; e.g., RuleML is in the top 100 venues for impact factor in CiteSeerX

Also note, that there are several additional collocated events, e.g., the Recommender Systems for the Web of Data Challenge (, the Doctoral Consortium (, the 9th International Rules Challenge with competitive prizes for the best rule base, the Reasoning Web Summer School, RR 2015 and the Workshop on Formal Ontologies meet Industry (, as well as the 25th CADE 2015.

If you are doing your Phd in this field I would like to point you to the Reasoning Web Summer School ( and the joint RuleML/RR Doctoral Consortium ((, where you can submit your Phd paper. Accepted RuleML Phd papers and demo papers will be published in the Challenge proceedings which are listed in DBLP ( and fully indexed e.g. in Scopus.
Also the workshop on Formal Ontologies meet Industry (FOMI 2015) might be relevant for you if you are working on Ontologies (

And, further interesting things will happen at RuleML 2015, such as an ISO Common Logic, OMG API4KB and OASIS LegalRuleML face-to-face meeting. We will also have a Berlin Semantic Web Meetup during RuleML on August 4th. Details will follow soon on the Meetup website:

Thank you and hope to see you in Berlin, Germany in August,

(General Chair RuleML 2015)

Prof. Dr. Adrian Paschke
AG Corporate Semantic Web
Freie Universitaet Berlin

Monday, February 09, 2015

The Relationship of Decision Model and Notation (DMN) to SBVR and BPMN (Full Article)

"Publications by James Taylor and Neil Raden[2], Barbara von Halle and Larry Goldberg[1], Ron Ross[7], and others have popularized "Decision Modeling."  The very short summary is that this is about modeling business decision logic for and by business users.
A recent Decision Modeling Information Day conducted by the Object Management Group (OMG)[4] showed considerable interest among customers, consultants, and software vendors.  The OMG followed up by releasing a Request for Proposals (RFP) for a Decision Model and Notation (DMN) specification.[5]  According to the RFP,
"Decision Models are developed to define how businesses make decisions, usually as a part of a business process model (covered by the OMG BPMN standard in Business Process Management Solutions).  Such models are both business (for example, using business vocabularies per OMG SBVR) and IT (for example, mapping to rule engines per OMG PRR in Business Rule Management Systems)."
This quote says a little about how DMN may relate to SBVR[6] and BPMN[3], but there are many more open questions than answers.  How do SBVR rules relate to decisions?  Is there just one or are there multiple decisions per SBVR rule?  Is there more to say about how SBVR and DMN relate to BPMN?
This article attempts to "position" DMN against the SBVR and BPMN specifications.  Of course, DMN doesn't exist yet so the concepts presented here are more the authors' ideas about how these three specifications shouldrelate to each other, than reality.  We present these ideas in the hope that they will positively influence the discussions that lead up to the DMN specification."

Friday, December 19, 2014

UI Front-end Developer Job Opening in the Drools and jBPM team

We are looking to hire a front end developer to work closely with our UXT team to make our web UI's look and work beautifully. The ideal candidate will have an artistic flair and solid grounding in what makes a good UI. Our existing web tooling can be seen here.

The developer will be working with Java, GWT, Errai, HTML5 and JS. The role is remote.

Friday, November 21, 2014

Red Hat JBoss BRMS and BPMS Rich Client Framework demonstrating Polyglot Integration with GWT/Errai/UberFire and AngularJS

Last week I published a blog highlighting a presentation I gave showing our rich client platform that has resulted from the work we have done within the BRMS and BPMS platforms, the productised versions of the Drools and jBPM projects. The presentation is all screenshots and videos, you can find the blog and the link to the slideshare here:
"Red Hat JBoss BRMS and BPMS Workbench and Rich Client Technology"

The presentation highlighted the wider scope of our UI efforts; demonstrating what we've done within the BRMS and BPMS platform and the flexibility and adaptability provided by our UI technology. It provides a great testimony for the power of GWTErrai and UberFire, the three technologies driving all of this. We can't wait for the GWT 2.7 upgrade :)

As mentioned in the last blog the UberFire website is just a placeholder and there is no release yet. The plan is first to publish our 0.5 release, but that is more for our BRMS and BPMS platforms. We will then move it to GWT 2.7 and work towards a UF 1.0, which will be suitable for wider consumption.  With 1.0 we will add examples and documentation and work on making things more easily understood and consumable for end users. Of course there is nothing to stop the adventurous trying 0.5, the code is robust and already productized within BRMS and BPMS - we are always on irc to help, Freenode #uberfire.

That presentation itself built on the early video's showing our new Apps framework:
The Drools and jBPM KIE Apps Framework

The above video already demonstrates our polyglot capabilities, building AngularJS components and using them within the UF environments. It also shows of our spiffy new JSFiddle inspired RAD environment.

I'd now like to share with you the work we've done on the other side of polyglot development - this time using GWT and UF from within AngularJS. It was important we allow for an AngularJS first approach, that worked with the tool chain that AngularJS people are familiar with. By AngularJS first, I mean that AngularJS is the outer most container. Where as in the above video UF is already running and is the outer container in which individual AngularJS components can be used.

Before I detail the work we've done it's first best to cover the concepts of Screens and Perspectives, our two main components that provide our polyglot interoprability - there are others, but this is enough to understand the videos and examples that come next. A Screen is our simplest component, it is a DIV plus optional life cycle callbacks. A Perspective is also a DIV, but it contains a composition of 1..n Screen with different possible layout managers and persistence of the layout.

  • CDI discovery, or programmatically registered.
  • DIV on a page.
  • Life cycle callbacks.
    • OnStart, OnClose, OnFocus, OnLostFocus, OnMayClose, OnReveal.
  • Decoupling via Errai Bus.
    • Components do not invoke each other, all communication handled by a bus.
  • Editors extend screens, are associated with resource types and provide the additional life cycles
    • onSave, isDirty.
  • CDI discovery, or programmatically registered.
  • Composition of 1..n Screens, but is itself a DIV.
  • Supports pluggable window management of Screens.
    • North, East, South West (NESW).
      • Drag and Drop docking capabilities.
    • Bootstrap Grid Views.
      • Separate design time and runtime.
    • Templates (ErraiUI or AngularJS).
      • Absolute control of Perspective content and layout.
  • Supports persistence of Perspective layout, should the user re-design it.
    • Only applicable to NESW and Bootstrap Grid views.

A picture is worth a thousands words, so here is a screenshot of the Perspective Builder in action. Here it uses the Bootstrap Grid View layout manager. Within each grid cell is a Screen. The Perspective is saved and then available from within the application. If the NESW layout manager was used there is no separate design time, and all dragging is done in-place and persistence happens in the background after each change. Although it's not shown in the screenshot below we also support  both list (drop list) and tab stacks for Screens.

Now back to what an AngularJS first approach means. 6 different points were identified as necessary to demonstrate that this is possible.
  1. UF Screens and Perspectives should be available seamlessly as AngularJS Directives.
  2. Bower packaging for a pre-compiled UFJS. UFJS is the pre-compile client only version of UF.
  3. UFJS can work standalone, file:// for example. UFJS can optionally work with an UF war backend, allowing persistence of perspectives and other optional places that UFJS might need to save state as well as access to our full range of provided services, like identity management.
  4. Support live refresh during development.
  5. Nested Controllers.
  6. Persistence and routing.
  7. Work with tools such as Yeoman, Grunt and Karma.
Eder has produced a number of examples, that you can run yourself. These demonstrate all of the points have been solved. You can find the code here, along with the README to get you started. We did not provide video's for point 7, as I believe the video's for points 1 to 6 show that this would not be a problem.

Eder has also created several short videos running the examples, for each of the use cases, and put them into a YouTube playlist. He has added text and callouts to make it clear what's going on:
AngularJS + UF PlayList
  1. Overview explaining what each video demonstrates (33s).
  2. AngularJS App + UFJS, client only, distribution using Bower. (2m30s).
    • Install and play with UFJS through Bower
    • Create a Native AngularJS App
    • Integrate this app with UFJS
      • Show UF Screen Directives
      • Show UF Perspective Directives
  3. AngularJS App + UFJS client and UF Server.
    • 1 of 2 (3m58s).
      • Download UF War
      • Install and run on EAP
      • Download and run our Angular demo on Apache
      • Show AngularJS Routes + UF Integration
    • 2 of 2 (4m06s).
      • Use UF to create Dynamic Screens and Perspectives
      • Encapsulate an AngularJS template in a UF Screen
      • Show an AngularJS App (inside a UF screen) nested in a parent controller.
        • Demonstrated multiple levels of controller nesting.
  4. KIE UF Workbench RAD environment with AngularJS component.
  5. Uberfire Editor working seamlessly as an Eclipse editor.
For completeness the original video's showing the JSFiddle inspired RAD environment, which demonstrates an UF first polyglot environment, have been added to the playlist. See point 4. above

Finally just to show of, and because we can, we added a bonus video demonstrating a UF editor component running seamlessly in Eclipse. This demonstrates the power of our component model - which has been designed to allow our components to work standalone in any environment. We use Errai to intercept all the RPC calls and bridge them to Eclipse. Because the virtual file system our editors use, like other services, is decoupled and abstracted we can adapt it to the Eclipse File io. For the end user the result is a seamless editor, that appears native. This allows the development of components that can work on the web and in Eclipse, or even IntelliJ. We'll work on making this example public at a later date.

Here are some screenshots taken from the video's

(click image to enlarge)

(click image to enlarge)

(click image to enlarge)

(click image to enlarge)

(click image to enlarge)

(click image to enlarge)

(click image to enlarge)

(click image to enlarge)

Finally to all those that said it couldn't be done!!!!

Wednesday, November 05, 2014

Red Hat JBoss BRMS and BPMS Workbench and Rich Client Technology

Last week I did a blog highlighting the recent R&D we are doing to make our web platform easily extensible and allow the development of a self service apps platform. The blog had two video links showing progress.

Today I gave a presentation that highlighted the wider scope of our UI efforts; demonstrating what we've done within the BRMS and BPMS platform and the flexibility and adaptability provided by our UI technology. It provides a great testimony for the power of GWTErrai and UberFire, the three technologies driving all of this. We can't wait for the GWT 2.7 upgrade :)

As mentioned in the last blog the UberFire website is just a placeholder and there is no release yet, we'll be working on that over xmas, along with documention to make things more easily understandable and consumerable for end users.

The presentation is now live up on Slideshare and I've taken time to embed all the video's within it.

The presentation is mostly self explanatory screenshots with headers with videos scattered throughout - many of which are previous video's you might have seen before. It provides a very good over, using scatter gun approach, of what we have done, what we are doing and where we are going. Two of the videos around the extensible workbench and the technical web ide have audio commentary.

It starts by showing the existing BRMS and BPMS stuff before moving onto the new extensibility efforts. Finally it covers a new demo we've done with the workbench reskinned for a more technical audience. It also shows ACE integration for java and xml editing, as well as real time provisioning and running of Spring Pet Clinic application within the workbench.