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:
https://github.com/mariofusco/drools/blob/xpath/drools-compiler/src/test/java/org/drools/compiler/xpath/XpathTest.java

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

Share/Bookmark

Tuesday, March 10, 2015

UF Dashbuilder - Activity monitoring in jBPM

syndicated from http://dashbuilder.blogspot.com.es/2015/03/uf-dashbuilder-in-jbpm-for-activity.html

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!

Share/Bookmark

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:
https://www.youtube.com/watch?v=WgZTdfLis0Q

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.





Share/Bookmark

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:

Downloads
Documentation
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 (http://camel.apache.org/uris.html).

Workbench
  • 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. 

Share/Bookmark

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!


   




Share/Bookmark