Posts in Category: book

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!

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

Quick book review: ‘The Process – Business Process Modeling Using BPMN’

Due to the fact I was sick today, I was able to work a bit on my book backlog. So, when I was waiting in the doc’s office, I finally finished The Process – Business Process Modeling Using BPMN, written by researchers of the Business Process Technology Group of the university of Potsdam.

The book tells the story of Tom, who is hired by the fictional company LasterTec to provide insights into how LaserTec works. While on the job, he learns about process modeling and BPMN. The following chapters describe the journey of Tom into the BPMN landscape, and how he is able to document and find bottlenecks int the processes of LasterTec. If you want to know how the story ends, you should give the book a reading 😉

So, here are in short the pro’s and con’s of the book:


  • The book is entry-level. Since I already have some BPMN experience I was able to quickly go through the first chapters, but I found myself concentrated while reading the more complex stuff (specifically on of the latests chapters on compensating activitites and business transactions). However, if you are already experienced in the BPMN field, this book will teach you not much new.
  • The BPMN information is nicely integrated with the story of Tom. So you’re getting an actual story that, for me, is much nicer to read than your average tech book. The story also allows you to digest the information easier. The downside of this approach is that the book is not a reference. Luckily, the book contains a BPMN reference poster, which you can also download here.
  • Many of the processes that Tom encounters are really industry-worthy. For a few of the processes described I really got a déjà-vu feeling since the process incorporated stuff I had to implement in the past in a similar way. So no academic reasoning or constructs in this book! (which is surprising, given the authors).


  • The book is pretty short (about 180 pages) and in the end, I had the feeling there could be more to it. However, purely seen as an introduction to BPMN, the book is perfect.
  • Like I said, the book is a perfect entry-level book, but if you want to do some real process modeling, you’ll definitely need to read up on some more advanced stuff and get some practical experience. However, you are well prepared for this journey with the bagage from the book.
  • I ordered the book through Amazon and had to pay an extra import tax (only Amazon US had the book in store at the time I ordered) of 10 euro. So since the book only counts 180 pages, every page costs about 20 eurocents. In my opinion, that’s a bit too much. I think the book is perfect for an e-book, so I rather would have bought it in that format.


I liked reading the book and I finished it with only one pause between the reads. Taking into account that in fact the book describes a specification, this definitely is a good sign. The information covered in the book is limited, but in the end you get all the basics of BPMN and are ready to take on simple business procesess. The book uses examples from the industry and comes with a handy reference poster. In my opinion, the target audience of the book are managers or developers/analysts who need an introduction to BPMN.

If the Potsdam researchers are publishing an (e-) book about BPMN 2.0 in the future (perhaps now Tom is already married and teaching BPMN to his children …) , I’ll definitely give it a read!