Java and BPM Developer blog

Menu

Monthly Archives: October 2013

I’ve been reading the new Drools JBoss Rules 5.X Developer’s Guide book, and I’m really pleased with it. It’s a very thorough compendium of Drools and jBPM introductory contents, up to the point of high performance tuning and application integration.
I specially liked the Decision Tables explanation, full of examples to understand how to configure them. It’s a pity how they had to cut the rule templates explanation, but since it is no longer part of Drools 6 supported APIs, I would say it was for the best.
For people wishing to get a preview of the book contents, chapter 6 discussing stateful knowledge sessions can be downloaded here.
When I reached the jBPM chapter, I was quite surprised. Explaining all of Drools concepts can be quite coumbersome, enough to fill a full book, and the same happens for jBPM concepts alone. I didn’t expect to see so much explanations of jBPM concepts on a Drools book, so it was a very pleasant plus! It helps you a lot in configuring process definitions using Eclipse editors.
It also teaches a lot about how to integrate the runtime in a full web application. These sort of examples have the great advantage of letting the reader see the components as they would run in the same configurations they can use later on in production environments. Most books, blogs, trainings and examples only provide junit tests that, even if they cover the full contents of the framework, don’t show them interacting with a full architecture. Having such a big portion of the book dedicated to this topic was both refreshing satisfying, as it was very well explained, especially the spring integration examples.
Integration chapters were very thorough. One thing though: I recommend reading chapter 11 before chapter 10, because they use the integration tools on the eleventh chapter to build the webapp in the tenth chapter.
The last piece that I found to be actually brilliant was the “Learning about Performance” chapter. It is one of the clearest descriptions I’ve seen of the Rete algorithm and how to make it work better for your particular domain. That chapter alone is something I would recommend even for people who has already learnt Drools and jBPM concepts.
In conclusion, I can see that this book tried to cover everything in just one book, and did the closest thing possible to reality; covering most of the topics in detail and giving an interesting introduction to the rest of the concepts. Drools 6 related books are around the corner, but this title will provide a very good introduction for people wishing to get started on Drools and I hope you get a chance to read it if you’re just starting on Drools or if you’ve been working on it for a while.
Cheers!

I’m really excited over next week Drools and jBPM training! We’ll be traveling today and before I go, I wanted to leave you this updated list of the contents of the course, with an additional UberFire part on the first day.

Places are limited but there’s still room, subscribe while you can!

Also, remember that on 23 and 24 at 3:00 PM we will have the free Drools and jBPM workshops for anyone who wishes to ask anything to kie core developers Mauricio Salatino and Michael Anstis!

Greetings everyone! In this post I’ll be showing one of the exercises we will be playing with in the next Drools & jBPM Training in London, October 21-25. There’s still time to register so go ahead!

This exercise shows a process interaction of something us developers and analysts know pretty well: managing requirements in a sprint. It’s something that we do everyday, so we don’t have to waste so much time explaining the domain, and we can get really fast to the process definitions and how to do each task.

It’s also a very good example to run through all the things related to a process execution:

Automated tasks: Jenkins interactions in a continuous interaction environment, automatic deploys and tests, email notifications, all have a use in this small case

Process interactions: Each requirement in a sprint is a process by itself, and the sprint runs as a process too.

Rules execution tasks: We can use them to validate requirements, define initial priorities, and probably a lot more.

The processes look something like this for the requirements: You can see that we have all the requirement life cycle defined in this process definition; when developers do it, when it has to be tested, what to do if bugs are found… and finally, the process instance is completed when no more bugs are found in the requirement implementation.

This one is for the sprint: It’s a bit more cryptic, but the objective is simple. It starts and distributes all requirements priorities using rules, then starts each requirement in a process using a script task. The process will then finish when a signal is sent to the instance that either all requirements are completed or the sprint was manually closed.

We will show you a small test case where you can simulate all the steps of these processes, learn how to make them intercommunicate using different methods, how to run them using custom handlers, and also asynchronous executors, and we will have a lot of fun learning how to add new features to the processes and the runtime. You can download the example from here to play with it in the meantime!

I’ll be reading the Drools JBoss Rules latest book over the next few days, and will be posting my two cents about it as soon as I finish it. I’ve read it’s previous version and loved it, so I’m pretty sure this one will be even better. Stay tuned to hear more about it 🙂

Hello everyone. I’m glad to let everyone know that along with Plugtree’s Public Training in London, we will be having two very special invites doing Drools and jBPM 6 workshops on October 23 and 24. Michael Anstis and Mauricio Salatino (A.K.A. Salaboy). We will be updating the agenda pretty soon to accomodate for both things, but dont worry: We still have plenty of time to cover all topics and questions. This is just a huge plus!!

The topics of the workshops will be related to Drools and jBPM internals, so it will be a great opportunity to ask really complex questions by the very people driving the projects. We’ll be reserving seats for everyone who comes to the training, and both workshops will be free, but seats are limited, so please reserve before they run out!

Hi there, I’m glad to announce the contents of our Drools and jBPM Training. I will be posting here the training material and some speaker notes about the training slides. Please feel free to give us feedback about the content and suggest us missing topics to include.

The roadmap

In this post I’m sharing the Roadmap for this training release, because it’s a work in progress I need some time to get the material published and ready for the community. Please share some feedback about the proposed topics. I will be glad to improve it in order to get a quality training from the everyone’s perspective!

Day 1: Theory introduction: All levels

Part 1: Introduction: A brief introduction about the company, the trainer, our position regarding JBoss projects, and our passions. We intend to cover as quickly as possible the needed knowledge and tools to understand and work through the demos given in this course, as well as present the different technologies and theoretical background we’ll cover in the course.

Part 2: Theoretical Background: We’ll explain in this section all relevant information regarding AI methodologies and principles on which rule and process engines rely on. We’ll cover topics from knowledge generation and gathering, how systems work around such knowledge to emulate domain experts, how rules apply to such mechanisms and in what way do rules work. Also, we’ll cover the theory behind BPM (Business Process Management), its history and life cycle. We’ll continue with topics such as planning problems and event processing, and how all these methodologies work together.

Part 3: Drools coverage: Once the theoretical background is covered, we’ll get an initial glimpse at all the tools that Drools provides to cover them. We’ll make a thorough review of the structure of business rules, events and processes. We’ll also see components of the Drools toolkit (for both versions 5.5 and 6.0) that allow us to handle a knowledge repository and how they interact with the rest of the runtime components.

Part 4: Architectural Overview: Once the technical components of the Drools platform are covered, we’ll take some special time to discuss best practices and known frameworks to handle different Drools based projects architecture. We’ll see how the components interact with each other, as well as how they fit in the overall structure of a system. We’ll discuss different approaches to handling rule and process executions, from embedded architectures to SaaS approaches, covering stateful and stateless executions.

Part 5: Practical quickstart: We’ll cover the basic steps to create your first drools and jBPM project, both using Drools version 5.5 and 6.0. We’ll introduce some “Hands On” projects for you to get familiar with the initial APIs, as well as demonstrations of the existing runtime tools to both create and execute knowledge creating very little to no code at all.

Day 2: Drools part 1: Medium technical level onward

Part 1: DRL Syntax: We cover all the details regarding writing DRL files (the syntax in which Drools technical rules are written). We introduce all components of a rule and all the syntax sugar that exists. How to define conditions, consequences, attributes, events, and queries. We cover as well the API needed to run rules both in Drools 5.5 and 6.0, as well as a Hands On exercise to get familiar with it.

Part 2: Drools Internal Mechanisms: We’ll study in detail how Drools transforms DRL files into an executable runtime, gaining a huge insight on how to make faster and better rules. We’ll cover the different elements in its execution network, as well as the full mechanism that activates rules in a runtime environment

Part 3: DSL and Decision Tables: We’ll study other ways that the Drools platform allows us to define rule based knowledge, DSL (domain specific language) to write rules in a natural language, and Decision Tables to write rules similar in structure in an Excell based stylesheet. We’ll see also a Hands On Exercise to get familiar with the API needed to run them.

Part 4: Drools Fusion Introduction: We’ll get into detail on the event processing mechanism of the drools platform. We’ll cover all the different temporal operators, handling data entry points, time correlations and processing events as both isolated events or streams of events. We’ll cover the API to run them both in Drools 5.5 and 6.0.

Part 5: OptaPlanner Introduction: We’ll learn the deatils of planning problems and how to solve them using this Drools component. We’ll see different example problems solved by the tool as well as how were they implemented. We’ll cover the configuration tutorial and optimization tools, along with a Hands On exercise to see how to run it using Drools 5.5 and 6.0.

Part 6: Debugging, Logging and Tuning: Once all components are thoroughly covered and we are already familiar with the APIs, we’ll start seeing different tools to trace the rules behaviour as well as process executions. We’ll see different tricks that will allow us to identify errors and unexpected behaviour in our rules and processes just as if they were in our everyday code.

Day 3: Drools part 2: Medium technical level onward

Part 1: Drools Guvnor – KIE Workbench Definitions: We’ll learn in this module about the different versions of the Knowledge Management System (KMS) provided by the Drools platform. We’ll learn to define a model and to author our own knowledge assets, scuh as rules, DSLs and Test Scenarios.

Part 2: Drools Guvnor for end Users: We’ll introduce the different components of the KMS from a user persective. We’ll get familiar with all the components in the action toolbar, metadata and version management, as well as package configurations to learn how to adminstrate our knowledge

Part 3: Drools Guvnor Administration Topics: We’ll get familiar with managing the KMS from an administrator perspective. We’ll see how to manage backup strategies, user permissions, logs, and verifications.

Part 4: Rules Design Patterns and Best Practices: We’ll cover best practices for creating and maintaining rules, how to manage the data model, best practices for fact classification, rules extensions and exception handling. We’ll learn as well about the life cycle of rules, and issues regarding performance and scallability, and how to tackle them.

Part 5: What’s new in Drools 6: We’ll cover the different aspects of the new Drools distribution in more detail. We’ll learn the reasons for the changes that have taken effect in the API, as well as the improvements in both functionality and usability of the platform. We’ll learn about PMML importing and Spring and Camel integration.

Day 4: jBPM part1: Medium technical level onward

Part 1: jBPM Introduction: We’ll get a quick introduction to the jBPM project history and it’s integration with Drools. We’ll cover the different jBPM runtime components and its functions, and an example of a business process. We’ll compare jBPM with other products, and we’ll see the advantages of jBPM by comparison. We’ll see the structure of a Business Process, how to define them using BPMN2 and how to run them using the jBPM APIs.

Part 2: BPM For Development: We’ll cover the different stages in BPM where development is more involved, as well as how is the best way to perceive the software writing work related to running effective Business Processes. We’ll finally see how this allows a best fit from an End User perspective.

Part 3: jBPM Components Overview: We’ll cover all the different components of the jBPM platform, and how they fit together. We’ll discuss several practices that allow for effective Business Process Management, and how the jBPM components fit best into those best practices.

Part 4: BPMN2 Writing and Using: We’ll learn in more detail an industry wide standard for writing proceses called BPMN2, its elements, and how jBPM covers it. We’ll see a code demo to jBPM, and how to handle and test different types of processes and subprocesses.

Part 5: jBPM Initial APIs: We’ll cover the different API components for both versions 5.4 and 6.0 of the jBPM platform. We’ll analyze the best way to test processes, how to configure its persistence, and how to work with human tasks.

Day 5: jBPM part 2: Medium technical level onward

Part 1: jBPM Basic example: We’ll learn a few different processes and we’ll see different tests to see how to interact with external services, handle rule execution from our processes, create process that react from external events, and how to pass and check data between tasks of a process instance.

Part 2: jBPM Domain Specific Processes: We’ll discuss the different extensions that BPMN2 process files and the jBPM runtime allow to interact with external applications in detail. We’ll see the different parameterizations allowed for that interaction and how they bind to the jBPM runtime. We’ll learn also about the difference between immediate and deferred external system interactions, with some examples and a Hands On exercise.

Part 3: jBPM Human Interaction: We’ll discuss in detail how the jBPM runtime deals with tasks performed by people, instead of external systems. We’ll see the special characteristics of human interaction, and existing standards to integrate it into applications, including security injection, task life cycle, and some examples with a Hands On exercise.

Part 4: jBPM Persistence: We’ll discuss the way jBPM persists information in detail, and how it is persisted. We’ll see how to configure the persistence and how to use it. We’ll see examples as well with a Hands On exercise.

Part 5: jBPM Advanced Topics: We’ll learn special tricks that will allow us to manage persistence from the session perspective in different strategies than the one used by the jBPM standard persistence. Also, we’ll learn a few tricks to handle external notifications regarding process execution, and tricks to use the process designer to its full potential. We’ll also learn how to debug process executions, which will allow us to identify errors and unexpected behaviour in our processes just as if they were in our everyday code.

Please, feel free to write me back and propose me more topics that interest you. I’m very flexible and I will do my best to reduce the learning times of this amazing project.