Average Reviews:
(More customer reviews)Are you looking to buy
jBPM Developer Guide? Here is the right place to find the great deals. we can offer
discounts of up to 90% on
jBPM Developer Guide. Check out the link below:
>> Click Here to See Compare Prices and Get the Best Offers
jBPM Developer Guide ReviewThe 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?
jBPM Developer Guide OverviewThis book is a complete developer's guide to working with jBPM in a J2EE enterprise environment. It is packed with examples of implementations that will provide you with all the experience needed in real-life implementations. Extensive discussions about how the framework is implemented internally will contribute to creating a robust knowledge of when and how your projects will include this framework. This book is mainly targeted at Java developers and Java architects who need to have a deep understanding of how frameworks behave in real-life implementations. The book assumes that you know the Java Language well and also know some widely used frameworks such as Hibernate and Log4J. You should also know the basics of relational databases and the Eclipse IDE. A brief introduction to Maven2 is included in this book but extra experience might be needed for more advanced usages.
Want to learn more information about
jBPM Developer Guide?
>> Click Here to See All Customer Reviews & Ratings Now
