Small steps with big feet

JBoss @ Fosdem 2010

This weekend, Brussels is again the place to be for every open-source enthousiastic. For the first time ever and with some help from the JBoss User Group Belgium, there is now a JBoss devroom where different JBoss talks will be given. The event is completely free, so no reason not to be there!

There will also be a jBPM talk, done by our friends at Camunda.

The complete program can be found here: http://www.fosdem.org/2010/schedule/devrooms/jboss

Hope to see you at the JBoss booth!

Book review: jBPM Developer Guide by Mauricio Salatino

I’ve managed to give the jBPM Developer Guide by Mauricio Salatino, which was sent to me less than a mont ago by the people of Packt, a thorough read. Reviewing a book is not a simple task, certainly not when the topic is quite familiar. So I started every chapter by writing down some notes of what I would expect to find, and checked while reading if the content could cover my expectations.

Since many people will simply skip to the conclusion part (at least, that’s what I do when I read a book review), I’ll start off with The Short Review.

The Short Review

Basically a book review needs to answer the following question:

Would you recommend the book?

Yes. I would certainly recommend the book to any novice jBPM user. The book covers practically all jBPM3 concepts and gently builds up the complexity of the content. Having this book a few years ago when I started out with jBPM, would have saved me tremendous time. Granted, the book has some minor flaws (see The Long Review), but it currently is the best guide and reference when you want to start using jBPM. period.

The Long Review

In the following sections, I will summarize for each chapters the notes I’ve taken while reading the book.

The book is published by “Packt Publishing”. The nice thing about Packt is that they are generally fast to publish books about new and exciting, mostly open source technologies. On top of that, they also invest a part of the profit back into the project, which is a noble deed if you ask me.

In general

• This book is about jBPM3, not jBPM4. One might think this is a bad thing, but do remember that jBPM3 is extremely stable and is part of the JBoss SOA-Platform for many years to come (today jBPM3 is the only official supported version by Red Hat – these things take quite a time). People that are familiar with jBPM3, will have no problems to make the jump to jBPM4.
• A general nuisance is the language usage throughout the book: although the sentences are syntactical correct, they often not feel ‘right’. Others have already commented on this fact, so I’m not going into it here. I don’t blame the author: he shows a great amount of enthusiasm and jBPM knowledge, but with a little more editorial reviewing, this book could have gotten that little extra edge.
• The book is great for jBPM starters, no single doubt about that. However, I would have liked to see more ‘best practices’ and advanced configurations (JMS/SOA/etc.). Let’s hope for a next jBPM book that covers those topics

Preface and Chapter 1: Why developers need BPM

This chapter is a bit overwhelming for beginners. The author tries very hard to convince people of the rightness of open source software (which is perfectly valid ), but it’s too heavy as a starter chapter. This chapter would have been a good appendix, I guess.

Oh yeah, I don’t necessarily agree with Mauricio’s definition of a ‘BPM suite’. You’ll understand it when you read it

Chapter 2: jBPM for Developers

Good introduction to some important concepts like wait states, nodes, process definition vs instance, etc. The downside of this chapter is that it tries to explain these concepts by building a simple state machine in Java code. In my opinion, 99% of the jBPM starters will find this too overwhelming. I found it fun to read, but then again my day job is to build such “state machines”

Luckily, it goes uphill from here. My advice would be to read the chapters 1/2 after starting from chapter 3, and only giving them a quick read either way.

Chapter 3: Setting up Our Tools

Mandatory chapter for every beginner. I really liked the fact that nothing is “taken for granted’, as tools like SVN and Maven are also covered with some text. Many technical books assume that this is common knowledge, but experience has taught me this certainly is not the case. I also really liked the ‘community’ take on things in this chapter. The author explains and demonstrates that by knowing maven, svn, etc. every one can contribute to open source ecosystem. As a core jBPM dev, I was happy to find these encouragements.

This chapter demonstrates in depth how tools (Maven, Eclipse, etc.) need to be configured to get the maximum out of your jBPM experience. Also the jBPM project structure is touched, which is in reality a true knowledge advantage I’ve not yet seen in many jBPM users.

A small side remark (has no influence on jBPM novices, ofc.): the history of jBPM is a bit skewed, which is a bit of a pity if you’re closely involved with the project (eg. jBPM was orginally not created by JBoss)

Chapter 4: jPDL language

When I was reading this chapter, I noted down “To the point! This is the content you need”! I can’t express it better than that. A must-read chapter for every jBPM adept.

I was delighted too see that the author often explains functionality by referring to snippets in the source code. In my opinion, this is the way open source tech books should be. When I was still a jBPM consultant, I often looked at the source code to learn how corner cases where handled, or what exactly a certain operation does, etc. As Ronald often states on the jBPM User Forum: the best documentation is the source.

Chapter 5: Getting Hands Dirty with jPDL

In this chapter, the topics explained in the previous sections are used in a real project. The use case is interesting and has great didactical value. I had some reservations when I read the use case, and noted down some questions on how the author would tackle them (if they were tackled at all). I was happy to find them all answered by the end of the chapter. Perhaps a small remark could be here that the jBPM configuration isn’t showed in this chapter. This could be a bit confusing for some starters, since it involves some “magic” that is easy to explain.

Chapter 6: Peristence

Really thorough and detailed explanation of jBPM persistence. Excellent transaction explanation and great diagrams that explains what happens in which situation (automatic nodes, wait states, when updates happen, etc.). Really every aspect is covered (for example even Hibernate caching is touched), nice!

Imo, perphaps the best chapter of the book.

Chapter 7: Human Tasks

Perfect follow-up for the previous chapter. Good, detailed content about probably the most important construct of any BPM engine. I also really like the webapp approach at the end of the chapter: this is the stuff why people buy the book.

Chapter 8: Persistence and Human Tasks in the Real World

This chapter perfectly aligns with the previous Human Task sections: good and very detailed content.

Chapter 9: Handling information

Great explanation about variable usage in jBPM. The content is good for starters and should get you going quite far. But in my opinion, some things should have gotten more attention, since variables are an area in which many mistakes are made in real life projects. Some topics that could have gotten more love: hibernate objects as variable (+ why !), serializable (what about synchronisation problems?), business keys for process instances (why do you need them).

Chapter 10: Advanced features

This chapter definitely covers some advanced features. It even managed to surprise me: I had totally forgotten about the superstate indirections using “../” in the node names (altough I’ve used it a lot on a certain project) and the book mentioned this little detail! Also start tasks were covered – nice!

Some topics which I have needed a lot in my past projects weren’t covered (but this is really advanced stuff, and definitely not for startes): subprocess binding, more database schema focus, e-mail node and custom HQL queries using the jBPM objects. So altough I really liked the chapter, it could have gotten extra points when dealing with those topics.

Chapter 11: Advanced topics in practice

Not to miss chapter since here asynchronous execution is explained. The books goes really deep in the nitty gritty details of async executions – which I like. However in my opinion, the book doesn’t stress enough the crucial importance of the async functionality enough. But after reading this chapter, you’ll definitely be able to understand and try it for yourself.

Chapter 12: Going Enterprise

Explanation of what the jbpm-enterprise jar offers. Some good practices are states here, like the EJB intermediate layer with ids (jBPM4, anyone?). Also remote client usage is covered, together with Timers and job (VERY good explanation btw).

As my conclusion already can be found in the beginning of this post, I’ll repeat here the one-sentence summary. If you are starting out with jBPM, there is no better book or guide to get you guys. Highly recommended!

Updated hello world tutorial for jBPM 4.3

While checking my tweets this weekend, I found out that Niklas Gustavsson updated the jBPM 4.0 Hello World example to jBPM 4.3. Altough not complicated if you know jBPM and Maven, I’m sure many people will find it helpful. Since my Hello World article is still one of my top posts (visitor-wise), I decided to post here how you can get Niklas’ work in your Eclipse (thanks Niklas!).

You can find the source code on git:

http://github.com/protocol7/jbmp4-helloworld

(small remark, you’ve misspelled jbpm, Niklas )

Clone the repository locally:

git clone git://github.com/protocol7/jbmp4-helloworld.git

And prepare the project for your IDE (I’m using Eclipse):

cd jbmp4-helloworld

mvn eclipse:eclipse

You can now import the project into Eclipse (File -> import -> Maven project). Note that you need a Maven plugin, such as m2Eclipse. Find the Main.java class and run it.

The content of my previous post about this example are still valid today (hurrah for API stability ), so please read further there.

jBPM Screencast: from the drawing board straight to executable BPMN 2.0

In my last blogpost about BPMN 2.0, I already showed how BPMN 2.0 processes could be executed natively on the jBPM4 engine. Of course, the main advantage of BPMN is that we have a standardized and industry-accepted language to describe business processes – executable and non-executable ones. This also means our story is but complete if we have the modelling part covered.

As described in many previous posts, we’re closely collaborating with the guys from Signavio. They have created a fantastic web based BPMN editor and develop the core of the editor in open source.

In this screencast, I show how a BPMN 2.0 process created with the Signavio editor can be exported, dropped into Eclipse and deployed to the jBPM engine – without any change to the process file!

Major milestone:

BPMN 2.0 processes modelled with Signavio

can now directly be executed on the jBPM4 engine

The process I’m using for the screencast is shown below (it is an advanced process we use to test our Inclusive Gateway implementation). Also note that I’m using the cool new embeddable process model feature in Signavio – try to zoom in and out or click on the header .

Inclusive gateway example

Sign up for your own Signavio account

The example is a bit abstract, but shows clearly how well our BMN 2.0 implementation copes with something as advanced as the inclusive gateway. By the way, many kudos go out to the jBPM PVM (Process Virtual Machine) created by Tom, which made the implementation a breeze. I haven’t found anything in the BPMN 2.0 spec yet which I could throw against it and make it sweat.

All right, time for the screencast. In the screencast, I’m using the online version of Signavio. We’re currently discussion with the Signavio team when and how we’ll ship a BPMN 2.0 editor with the jBPM distribution. Expect some news on this front for the 4.4 or 4.5 release! You can however, try out the fully functional modeller already for a trial period.

I have deliberately been sparse with information in this post, because I’ve added audio to the screencast (and yes, I do have a serious cold :p), so don’t forgot to pump up your speakers as you’ll miss a lot of the fun otherwise. Click on the image below to view the screencast.

jBPM talk @ JDD09 online on Youtube

I just found out that the friendly people of Proidea (organisation behind the Java Developers Day or ‘JDD’ in short) have put the jBPM talk online which we did back in October.

The talk is divided into four parts, all nicely organized in a playlist on the Proidea Youtube channel.

Pictures of the talk (and the rest of the event) can be found here.

Enjoy!

Native BPMN 2.0 execution with the freshly released jBPM 4.3

Happy 2010 to all the folks who read this blog! I’m extremely pleased to start this  year with a bang by announcing that jBPM 4.3 has been released!

As we announced last month, the major achievement of this release is the native BPMN 2.0 execution on top of the PVM. See the announcement itself for more information, examples and a shiny movie.

The main goal of the first release of our BPMN 2.0 implementation was to implement the ‘basic’ part of the specification. Using the basic constructs, one should already get quite an impression how BPMN 2.0 can be used in practice with jBPM. We’re extremely proud that we’ve managed to include the BPMN 2.0 implementation as an integral part of the jBPM framework. This means that no database or API changes are required when you want to start using BPMN 2.0 with jBPM. Heck, enabling BPMN 2.0 in jBPM requires one single line of configuration. Just check the example of the previous BPMN 2.0 blogpost to see all this sweetness.

The complete distribution zip file can be found on http://sourceforge.net/projects/jbpm/files/

This distribution includes quite a few examples to get you started. The developers guide that is shipped with the distribution also contains a whole new chapter about how to implement BPMN 2.0 processes using jBPM 4.3. The content of the documentation is detailed and people with no prior BPMN 2.0 knowledge should be able to understand it without much problems. See the subdirectory /doc/devguide to find this guide. Or you can take a look online(link to my own version, online doc on docs.jboss.org isn’t yet updated due to past holiday season – but this can change any moment now).

To finish up, let me quote one of our prominent Community Users, Bernd Rücker:

“2010: the year of BPMN 2.0″

Of course, BPMN 2.0 isn’t the only thing we’ve been doing the last two months. Check our JIRA for a complete changelog. Most noteworthy new features are the ejb and jms invocation for JPDL – features that are easy to leverage for a future jBPM BPMN 2.0 release …

As always, thanks for reading!

Upcoming review ‘jBPM Developer Guide’ by Mauricio Salatino

Building an open source framework sure is a rewarding experience. You see community people logging issues, contributing patches, answering forum posts, joining the community days, etc.

And sometimes there is a crazy enthusiast user who sacrifices *a lot* of his free time to write a jBPM book. Heck, writing a jBPM book has been a long-lived dream for me … but some things always seem to come between that dream and reality (you know, like building a BPMN 2.0 implementation on top of jBPM). But that’s probably just an excuse, I know.

Writing a book takes a lot of time and effort and it’s an adventure that’s not to be taken light-heartedly. So many, many, many kudos to Mauricio Salatino for writing the just released “jBPM Developers Guide”! Just click on the book cover on the left to get more information or to order your own copy.

The people of Packt publishing were so kind to send me a review copy of this book, which I received this morning (see picture below). So expect a review coming up soon (I’m going to give it a thorough reading).

jBPM goes BPMN!

For those who follow the jBPM internal discussions a bit, the marriage of jBPM and BPMN will come as no surprise. Since this summer we’re coding away at a native BPMN2 implementation on top of our Process Virtual Machine (PVM), and you might have seen tweets or forum posts passing by where the term ‘BPMN’ pops up. However, the only proof were some classes in our SVN trunk …. until now!

In this post I’ll give you a sneak peek of our current BPMN2 execution effort which will be documented, QA’d and incorporated in the jBPM 4.3 release (scheduled January 1st). Many thanks go out to our community members Ronald Van Kuijk and Bernd Rücker, who have contributed a significant amount of  ideas and code (and in fact, still are contributing to the BPMN2 implementation now as we speak). This is open-source power at its fullest…

Happy times indeed!

What is BPMN2?

Basically, the Business Process Modeling Notation (BPMN) started out a pure graphical notation standard for business processes, maintained by the Object Management Group (OMG). Version 2.0, which currently is in beta, adds execution semantics to the specification and this is of course where it gets interesting for jBPM.

The primary benefit of BPMN2 is that it is a standard accepted by the IT industry, which means that process models become portable (graphical and execution-wise) across process engines such as jBPM. Since process executions are the raison-d-être of jBPM, it is only natural we are now investing in BPMN2. People who are familiar with JPDL (the current native language of jBPM) will have generally no difficulties in learning the BPMN2 language, as many constructs and concepts are shared. In fact, from a high-level point of view, BPMN2 and JPDL are in concept solving the same problem (which is a biiiiig difference with BPEL – but that’s a story I’ll let other tell).

Of course, this is just the nutshell explanation. You can find a lot more information in our wiki.

Enough talking … show me how it works!

The business process we’re going to implement looks as follows (click to enlarge – created using the wonderful editor from our friends at Signavio).

You might recognize this example, since we’ve also implemented it in JPDL as an example in our distribution.

The business process is simple: an employee can start a new process and make a request for a certain amount of vacation days. After the request task has been completed, the manager will find a verification task in its tasklist. The Manager can now decide to accept or reject this request. Depending on the outcome (that’s the little rhombus on the outgoing transitions, or better said ’sequence flow’ as it is called in BPMN. It means that there is  a condition that must be true to follow it), a rejection message is send or the process ends.

As is the case with JPDL, BPMN2 uses an XML language to define the process definition. Our business process looks like this in BPMN2 XML:

<?xml version="1.0" encoding="UTF-8"?>
<definitions id="vacationRequest"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://schema.omg.org/spec/BPMN/2.0 BPMN20.xsd"
 xmlns="http://schema.omg.org/spec/BPMN/2.0"
 typeLanguage="http://www.w3.org/2001/XMLSchema"
 expressionLanguage="http://www.w3.org/1999/XPath"
 targetNamespace="http://jbpm.org/example/bpmn2/vacation_request"
 xmlns:jbpm="http://jbpm.org/bpmn2">

 <process id="vacationRequestProcess" name="BPMN2 Example process">

   <startEvent id="start" />

   <sequenceFlow id="flow1" name="fromStartToRequestVacation"
     sourceRef="start" targetRef="requestVacation" />

   <userTask id="requestVacation" name="Request Vacation"
       implementation="other">
     <potentialOwner resourceRef="user" />
     <rendering id="requestForm">
       <jbpm:form>request_vacation.ftl</jbpm:form>
     </rendering>
   </userTask>

   <sequenceFlow id="flow2"
     name="fromRequestVacationToVerifyRequest" sourceRef="requestVacation"
     targetRef="verifyRequest" />

   <userTask id="verifyRequest" name="Verify Request"
       implementation="other">
     <potentialOwner resourceRef="manager" />
     <rendering id="verifyForm">
       <jbpm:form>verify_request.ftl</jbpm:form>
     </rendering>
   </userTask>

   <sequenceFlow id="flow3" name="fromVerifyRequestToEnd"
       sourceRef="verifyRequest" targetRef="theEnd">
     <conditionExpression xsi:type="tFormalExpression">
        ${verificationResult == 'OK'}
     </conditionExpression>
   </sequenceFlow>

   <sequenceFlow id="flow4"
       name="fromVerifyRequestToSendRejectionMessage" sourceRef="verifyRequest"
       targetRef="sendRejectionMessage">
     <conditionExpression xsi:type="tFormalExpression">
        ${verificationResult == 'Not OK'}
     </conditionExpression>
   </sequenceFlow>

   <scriptTask id="sendRejectionMessage" name="Send rejection Message"
       scriptLanguage="bsh">
     <script>
       <![CDATA[System.out.println("Vacation request refused!");]]>
     </script>
   </scriptTask>

   <sequenceFlow id="flow5"
     name="fromSendRejectionMessageToEnd" sourceRef="sendRejectionMessage"
     targetRef="theEnd" />

   <endEvent id="theEnd" name="End" />

 </process>
</definitions>

Most of the constructs are straightforward, certainly if you’re coming from a JPDL background. Do note that the Resource construct isn’t correctly implemented (yet), but that should be solved for the 4.3 release. Also note that you already can add taskforms to your user tasks (see line 33-35 for example).

Also interesting to note is the way how the outcome of the user task is used is for guiding the flow through the process (line 41 and 49). We could have used an exclusive gateway to do the same (which is also already implemented), but we’re using formal expressions on the outgoing sequence flows coming from the user task, just to show you we can.

That’s cool … but I’m a Java developer!

Rest assured: everything that makes jBPM a blessing to use is here to stay. Tom has put a tremendous effort in the jBPM PVM and we now are reaping the fruits of his work. BPMN2 is implemented on top of the PVM, which means that many things come for free: database persistency, database transactions, the service and query API’s, etc. it all just works.

So, when we want to test a business process, we use the same Java approach which we always had with jBPM:

public class VacationProcessTest extends JbpmTestCase {

  protected void setUp() throws Exception {
    super.setUp();

    NewDeployment deployment = repositoryService.createDeployment();

    deployment.addResourceFromClasspath("vacationrequest.bpmn.xml")
    String deployId = deployment.deploy();
    registerDeployment(deployId);

  }

  public void testRequestRejected() {

    ProcessInstance pi = executionService.startProcessInstanceByKey("vacationRequest");

    // After process start, peter (employee)
    // should be a candidate for the task
    Task requestTasktask = taskService.createTaskQuery()
              .candidate("peter").uniqueResult();
    assertNotNull(requestTasktask);

    // After this task is completed,
    // a manager (eg alex) is be able to see a 'verify' task
    TaskQuery verifyTaskQuery = taskService.createTaskQuery()
                                           .candidate("alex");
    assertNull(verifyTaskQuery.uniqueResult());
    taskService.completeTask(requestTasktask.getId());

    Task verifyTask = verifyTaskQuery.uniqueResult();
    assertNotNull(verifyTask);

    // When completing the verification task,
    // we also need to store the result of the decision
    // (will be done through the taskform normally)
    Map<String, Object> vars = new HashMap<String, Object>();
    vars.put("verificationResult", "not OK");
    taskService.completeTask(verifyTask.getId(), vars);

    // With a rejection, we should see
    // the 'sendRejectionMessage' task in the history log
    HistoryActivityInstance hai = historyService.createHistoryActivityInstanceQuery()
      .activityName("sendRejectionMessage").uniqueResult();
    assertNotNull(hai);
    assertProcessInstanceEnded(pi);

  }

}

So what you’re seeing here is

• Testing BPMN2 business processes in pure Java code that everybody understands
• in a way which is exactly the same as for JPDL
• and using the very same API which we are all familiar with
• and using the very same database schema as before!

What’s there not to like? In my opinion, the argument of the same API is really really really powerful. The PVM is showing its power at its fullest! To configure your jBPM installation for BPMN2, you just have to add this line to your jbpm.cfg.xml file:

<import resource="jbpm.bpmn.cfg.xml" />

Conclusion: using BPMN2 processes in your application with jBPM is extremely easy. Everything you know about embedding and configuring jBPM is just as before … except that you’re now using a portable and standard process language.

What else?

A lot. Just check our wiki to see what’s planned for the 4.3 release. When talking in pure BPMN2 constructs, these are all planned for next month: Exclusive Gateway (XOR), Parallel gateway (AND), Service Task (Java based), Manual Task, Receive Task (Java only), Script Task, User Task, None start event, None end event, Terminate end event, Sequence Flow, Conditional Sequence flow, Formal expression, Interface (Java), Resource + ResourceParameter. More is possible, if we go to bed a bit later than usual

To finish this sneak peek, here is a screencast of our jBPM console executing the BPMN2 example process which is described above. In this screencast, you’ll see Peter (the employee) requesting 5 days of vacation using our business process. After he finishes the request task, he logs out. Mike, a manager, now logs in and finds the vacation request in his task list. He rejects the request since there is too much work. Peter will now be notified with a rejection message (for this demo, just a printout to the console). The forms you see are using the same taskform mechanism which I described earlier.

The last part of the screencast shows that the reporting functionality, which was already available for JPDL, also works for the BPMN2 processes. Even better, since the PVM defines a shared database schema, reports can aggregate data based on JPDL and BPMN2 processes without any problem!

Until next post!

Joram

Devoxx 2009 slides and pictures

Two weeks ago, you could already read here that jBPM would be well represented on the Java conference of Europe, Devoxx. And it simply was a blast. As an open-source developer, there is nothing more rewarding than talking with the end-users that employ our software for their day-to-day jobs. We’ve received tons of feedback, use cases and appreciation to keep us goind until next year!

University session & BOF

Our adventure started out Monday morning, where Tom and I were scheduled for a University session of 3 hours.

The presentation went smooth, lots of people in the room (I’m guessing 250-300, including some very heavy jBPM addicts) and the Demo Gods also named Murphy didn’t intervene during the live demo. In my opinion, this was one of my best talks of jBPM ever, certainly content-wise. If you’re starting out with jBPM, there is in my opinion no better introduction than this talk. So do check out Parleys to see the whole talk (currently non-free).

University session slides

You can find the slides of the University session on Slideshare:

The BOF

Later that day, we were also scheduled for a BOF. Some interesting topics were touched, including ‘graphical vs xml’ modeling. Many thanks to our Greek friend Paris are due here, he really was able to spark the discussion with his statements (still get the laughs when I think about his discussion with Pete Muir about Seam during the BOF). He was able to join us for a drink afterwards, and we learned that he was actually using jBPM in a big high-demanding project. Interesting fellow.

Conference session

The conference session was basically a slimmed-down version of the uni talk. The main difference was that we now used the Train Ticket demo and that Tom was now giving live demos (different one from the uni talk). Of course, the Demo Gods did intervene and made Tom’s laptop freeze. Luckily he managed to get everything up and running before it was his time to speak…. but I can tell you: I was sweating it while doing the intro talking Luckily it wasn’t really showing, as you can see on the picture:

Me in action (picture by Devoxx team)

You can find the slide again on Slideshare:

See you next year!

I’ve attented Devoxx for the last three years, but this one was really special due to the fact I was now attending as a speaker. Many thanks to the Devoxx team for scheduling three jBPM sessions, and of course many thanks to Tom for letting me co-present with him.

Of course, this limited post does no justice to the week we spent at Devoxx. I saw some really cool stuff (eg. project Arquillian), networked with tons of interesting people, talked with dozens of jBPM users and generally was only home after midnight Can’t wait until next year!

If you want to see more pictures, take a look at those taken by Eric Schabell. In a couple of them, Tom and me are also popping up. Imo, the best one is the JBoss booth shot when we were handing out free beer

jBPM @ Devoxx

Next week, the Java Circus is once again in town (or at least, in the country). That’s right, it’s time again for a whole week of edutainment in Devoxx!

jBPM is extremely well represented this year, and together with Tom we’ll be doing 2 talks (uni & conference) and a BOF. Koen has also promised to fly back from the States, which means that 3/4 of the jBPM team is attending Devoxx. Don’t miss the opportunity to convince us of your issues/features for jBPM

More information like agenda and content can be found on Tom’s blog: ‘Planning Your Devoxx Schedule’.

Until next week!