Customer Reviews

jBPM Developer Guide

5 star:		(0)
4 star:		(2)
3 star:		(3)
2 star:		(0)
1 star:		(0)

 

 

The jBPM Developer Guide is a PACKT publishing offering, which is publishing books on technical subjects for sme time now. They offer good quality books, with nice artwork and feel to them. This one is 350 pages and feels like you should be able to carry it with you as a reference guide to jBPM. PACKT is based in Birmingham, UK but the Credits page lists a team that contains the author (South American), a proof reader, two reviewers (South American) and a list of editors (India mostly).

After reading the Preface I was wondering what these people all did, for they surely can not be proud of the English used. Please don't get me wrong, it is English that is correct, but it is definitely English from a non-native speaker. This is a shame as it degrades the reading experience and is sometimes even down right annoying. I would expect proof readers, reviewers and editing teams to take more care with the final results.

That being said, the contents looks promising with chapters covering:

* soft introduction to BPM
* some graph programming and a first process
* setup of the development enviornment (jBPM, JBoss Drools, JBoss ESB, Maven, MySQL, Eclipse and SVN)
* jPDL
* implementing an example process
* persistence in jBPM
* Human Tasks with an example
* process variables
* looking closer into some advanced features

This book makes the promise with the title that it will be giving us developers an in depth look at jBPM. This is the measure I am using when reviewing each chapter, asking myself if it fills a need I have as a developer. This is not a beginners book is the impression I had when looking at the cover. Also of note, this is not a cheap book, so I expect value for my money.

I will jump right into the review, providing my impressions of each of the first six chapters:

Chapter 1
=========
This is an introduction chapter that tosses out lots of technological terms for the new jBPM developer.

This chapter you can skip.

Chapter 2
=========
This chapter attempts to take you through some basic BPM functionality for implementing a process engine (just a very basic one). It is kind of fun to see happen, but not needed for jBPM usage.

This is also a chapter you can skip without missing anything important for your jBPM development experience.

Chapter 3
=========
This chapter is going to get into the nitty-gritty with a jBPM deep dive. This is the feeling I am getting. A small comment, the jBPM background/history is a bit on the thin side and not founded in facts. Also first we are forced to take a walk through the [...] community stack, nothing to do with jBPM yet.

On page 75, the real business starts, we dive into jBPM and build it via Maven and SVN. I really like this, as most books on community projects fail to give even a simple Maven explanation. You will have no excuses to not have a running jBPM check out from the community projects repository after this chapter. We are off and running!

From page 75 onwards, this is a must read chapter.

Chapter 4
=========
In depth dive into jPDL, nothing but good things to say about this.

A must read chapter.

Chapter 5
=========
A real example project is setup, starting from the business side which is nice for the beginners but a bit of a waste for the developers. We never are involved with this part of the project and have to make do with the results.

The only let down on this chapter is the finishing section, which requires you to download the provided projects code to see how you can create an initial unit test to march through the process as designed in this chapter. This is such a fundamental step in every project you will do in jBPM that I am a bit disappointed that the author did not walk us through the code snippets in the chapter itself.

This is a must read chapter.

Chapter 6
=========
Persistence and all things devoted to how jBPM uses this and how you set it up. Very good detail and clarity.

A must read chapter.

Chapter 7
=========
Tasks are dealt with in the chapter with a very good example to show you how it all works. At this point that the book gives us a practical example instead of homework, bit of inconsistency here.

Still, a must read chapter.

Chapter 8
=========
More persistence, dealing with how it happens when you hit wait states. Would have like to see more about how this is a best practice as too many jBPM implementations take the initial lead from the provided examples found on-line and implement everything in Nodes. Nothing mentioned about lazy initialization or loading in Hibernate, something you will run into in advanced cases when you implement your complicated processes.
A nice end to this chapter is provided by updating the running example process to use the techniques discussed in this chapter. This is nice.

A good chapter you need to read.

Chapter 9
=========
More than you really need to know about process variables, but that is exactly what I want from a developers guide type of book. This chapter is a perfect example of what I want from every chapter in this type of book, well done! Strange finish though, the homework section is back in this chapter.

Don't miss this chapter, good developer guide material that will help make you the jBPM guru in your development shop.

Chapter 10
==========
Here the author deals with advanced topics from jPDL, which means forks, joins, super states, process states, email nodes and property passing in your handlers. It is thorough, but I would really have expected some more suggestions as to best practices, especially on forks and joins, which WILL bite you in the butt on your real life implementations. It is a good chapter, finishing off jPDL for you.

Don't want to skip this chapter or you will have a half empty toolbox at work.

Chapter 11
==========
When I read the title I was expecting advanced topics from real life practices to tell me about the best practices using the previous material. It turns out to be about applying the chapter 10 material to the running example, thus the author takes us through adding in super states and process states to his example process.

A very good handling of the asynchronous usage of jBPM and how the jobExecutor works finishes out this chapter. Very important stuff and I thought it was forgotten. It would have been more symmetric to first introduce this in the previous chapter and then apply it as was done with the other advanced topics, but this is a matter of style.

A good chapter to read and pay attention to the jobExecutor section.

Chapter 12
==========
With a title of 'Going enterprise,' I was curious how we were going to finish out the book as this was the last chapter. Well, it is a good overview of the deeper configuration issues encountered when working in JEE environments.
There were lots of solution tips sprinkled in this chapter, nice touch. The jobExecutor is handled but this time interacting with JMS queues. Timers, reminders and the Mail service are covered.

Then we hit a wall. The book it seems is now finished. No conclusion, no tying it all together with the final look at our running example project and no summary of the entire book. This feels like I am missing chapters or left hanging. Bummer.

This chapter is very important none the less, don't think of skipping this one.


Final conclusions:
==================
So my final conclusions are that this book is very much an improvement on the previous jBPM PACKT publishing offerings. It does cover jBPM fairly well and for a beginner it is now the place to start your education (should you decide not to take the Red Hat education offerings). Go out and get your copy, it will help you along the road to becoming a guru in your jBPM development projects.

What about my running list of questions and impressions? Here they are for posterity, maybe they will make it into future publications:

* extremely disappointed with the readability/editing job done by PACKT publishing as mentioned in part I (again, this has nothing to do with the author)
* no resources or references section in the book
* lots of Wikipedia references in-line, never a good thing to use as a primary reference
* miss exception handling as an advanced feature?
* in handling of a Nodes and Transitions nothing is mentioned about dynamic transitions
* no best practices given when implementing jBPM projects?
* the author gives us "homework" in the first three chapters, but then it just stops until the ninth chapter, rather a shame
* don't understand why all these technologies have been used in a jBPM Developer Guide (Drools, ESB, Maven, MySQL, Eclipse and SVN)
* not sure the author has experienced "life in the trenches" with jBPM?
* why is the focus only on jBPM 3.x and nothing is said about jBPM 4.x, the only actively developed version of jBPM at the time of this books writing?

The book is meant for java developers, but takes the developer by the hand in the first couple of chapters to walk them through some of the required concepts and the tools that will be used in the book. Some more experienced developers may end up skipping the first few chapters.

Although jBPM can support many languages (jPDL, BPEL, Pageflow), the book focuses on jPDL to keep the scope of the book under control. Once again, this is a good thing to keep discussions focused on the framework, and not on the language being used with it.

After the introductory chapters, the book gets into more interesting details about jPDL, Persistence, Human Tasks, etc. The topics are covered in details, examples are provided and it does a decent job of making sure that developers have all the basic tools they need to work with jBPM.

The last chapter, chapter 12 titled "Going Enterprise" touches lightly on some of the topics required for going to a Java EE environment. It is interesting and could go in more details but ends abruptly, with a conclusion that is not worthy to be called the conclusion to a book.

The book was written with jBPM 3.2.6 in mind although jBPM 4.0 was actually released in July 2009 and jBPM 4.3 was released basically at the same time as the book was released. This may look like the author did not use the latest and greatest version of jPBM, but actually, considering the fact that jBPM 4 was a full re-write some of the features were missing from version 3.2.6 it makes sense.

Version 3.2.6 is also the latest version that was officially supported by a company, which means that if you want to use version 4 in a production environment, you are on your own with the community. For some, that may make a big difference.

Now that jPBM 5 has been announced (leaving jBPM 4 where? I am not sure), I look forward to seeing an updated version of that book in a little while when jBPM 5 has matured into something more concrete.

All in all, a decent book for developers getting started with jBPM, as long as they are using version 3 and not version 4 of the framework.

It's a pitty because it's an excellent book but it arrives late. jBPM 4.3 is out an quite a lot of code has changed.

This book does a good job of covering jBPM, a very popular embeddable process manager for Java. As the title suggests, it's written from a developer-centric point of view. (So much so that the reader is guided through writing their own minimal BPM implementation in the front part of the book, a novel approach to teaching a framework.) The books is best read while simultaneously reviewing the published source code, so you might as well consider the electronic version.

Pros:
- Teaches the venerable jBPM 3
- Covers necessary details like persistence and JEE-deployment
- Provides good source examples to match chapter text

Cons:
- Not really a page-turner
- jBPM is transitioning in a big way, but this book will remain relevant for years yet

All things considered, I'd recommend this book to anyone who is going to use jBPM beyond the tire-kicking stage. If you're going to use jBPM for real, this book is worth the price.

The book is intended for newbie programmers. The contents are a nice tutorial for somebody interested in a hands-on guide.

Pros:
- This is a good starting point for Java programmers that are interested in developing process-aware information systems.
- There are many illustrated examples that can also be downloaded.
- The authors clearly explain how to set up the basic architecture (tools) for starting to work with jBPM (ch.3) and create the workflow/process models with jPDL (ch. 4, 5 and 10)
- From ch. 6 to 9, the authors detail very nicely how to use persistence with a human-oriented workflow, i.e. jBPM plus a data base.
- Ch. 11 shows possible issues that can be found in the execution environment, which gives a valuable point to this book. Ch. 12 gives an introduction to jBPM in an enterprise deplyment; however, this is so short.

Cons:
- The sections and subsections are not enumerated which is sometimes very confusing for the reader.
- The book is a good introduction to business process development, but it doesn't show any advanced techniques like: execution of BPEL processes for service composition, by using a system developed with jBPM in the architecture described in ch. 12 (p.325).
- Given the introductory level of the book, this looks like a tutorial to develop workflows as we already used to develop with other technologies, but now by using jBPM. The trade-off of using this new technology is that this still doesn't follow a standard like BPMN, BPEL or XPDL. So, I still doubt if there exists a mapping between JPDL and BPMN, and a mapping JPDL into BPEL.
- The authors expend just one chapter (ch. 12) in a more advanced, practical and interesting topic: applicability of jBPM in the enterprise, which should be the core of the book if the idea is to get more Java programmers, CIOs and practitioners into this new framework/technology.