Finally a good blog discussion related to the reason of existence for Business Process Management (BPM). It's about how analysis diagrams get transformed into executable processes.
Scott Francis' post Compliance for the BPMN Specification… Shooting the Moon? already gives real good comments on the recent blogs. That is what triggered me to put the approaches that I know of in a list.
When considering BPM as a management discipline, the goal is that the business people should be in control. So business people, which usually don't have a lot of software development skills, create diagrams to document how people and systems work together. These I'll refer to as analysis diagrams. In this context, BPMN is currently getting a lot of attention.
On the other hand, it might be decided that software support for these processes will be developed. In that context, an executable process is a piece of software that can be executed on a BPM System (BPMS) and which also has a graphical representation. The only real executable process language standard currently around is BPEL. But BPEL targets what I describe as a completely different use case, namely service orchestration.
That brings us to the obvious question of how are analysis diagrams different from executable processes and how to bridge between them. This is where *finally* an interesting debate is starting at the heart of BPM.
Here are the 3 approaches:
1) I'll start with our own approach, as of course, that is the best :-)
We believe that analysis diagrams can be created in many notations, BPMN being one of them. Then it is up to the IT department to select the best process language that fits with their needs and then produce an executable process that looks exactly like the analysis diagram. That way the diagram remains an excellent instrument in the communication between IT and business people. But as an executable process is actually software, it should te governed by the IT department. In a previous post about BPMN 2.0 I elaborate a bit more on how we see the collaboration between analysts and developers.
This approach is quite similar to those who claim that we should move to executable BPMN. BPMN 2.0 will most likely incorporate explicit execution semantics for all the diagram elements. I believe that this is a very pragmatic move by Oracle and IBM as they have BPEL products and pure-play BPM products in their portfolio. For the pure-play BPM products, the executable BPMN route basically puts the translation to an executable process under the hood and makes it therefor irrelevant. That way, the pure-play BPM vendors are not forced to use BPEL underneith as the mapping between BPMN and BPEL is basically broken.
But in our view, a naive adoption of making BPMN executable can easily lead to trouble. It's generally accepted that process diagrams need to be decorated with technical details before they can be executed on a BPMS. Most of thos technical details that do not translate to the business side.
But the same is true the other way round: be very careful with expressing too much business level details in the diagram as they might not translate to the executable process. So you want to keep those out of sight of the business analyst. In many cases a lot of those graphical notation bells and whistles are actually technical details. So if the naive way of making BPMN executable results into graphical programming, then it is not suited to support BPM as a management discipline. Business analysts should be able to model freely without being constrained by technical details.
So in conclusion, the primary focus of bridging between analysis diagrams and executable processes should revolve around just the basic boxes and arrows. That is the intersection that can facilitate communication between business and IT.
2) Another approach is roundtripping. As said above, most people have realized that this is basically broken... unless... You can develop so much tooling around it like Oracle or IBM. With a vast amount of tooling a BPMN diagram can be translated to an executable process in e.g. BPEL and then synchronization links can be maintained so that roundtripping becomes an option.
The downside of this is that the user actually has to maintain the synchronization links. A lot of effort will be spend by the developer team to feed in the synchronization information. And still the changes that are generated to the executable process when a business analyst updates the analysis diagram, will never be transparant. In most cases. the development team will still have to intervene and merge the changes and verify the interactions between the process and verify the correct operation of the process in the context of other related software components.
And IMO, some teams might spend the time to maintain 2 models and keep them synchronized, but in general, I think this is undermining a big part of the agility value of BPM.
3) The third approach I'll discuss here is expressed by Ismael Ghalimi in Why BPEL Matters.
In their approach comes down to mapping BPMN to BPEL. But he also adds that the resulting BPEL process should be considered as the bytecode.
In this approach there is a believe that an analyst diagram can be decorated with technical details to make it executable. I don't see yet how this can lead to anything else then graphical programming.
I'm really puzzled by this approach as it seems to me that it is taking the worst of two worlds. On the one hand, they create a hard link between the analysis diagram and the executable diagram which blocks the analyst from modeling freely. And secondly, why would you perform a clumsy translation to BPEL if it's kept under the hood? I could think of easier ways to execute BPMN natively then through a translation to BPEL.
If BPEL should remain under the hood, then I don't get why BPEL is so important? I agree with the standardization argument. But they are also building SimPEL, which he describes as a different syntax for BPEL.
Another point that I wish to challenge is that BPEL supports distributed transactions. Afaict, BPEL doesn't specify when the state of a process should be persisted and it doesn't state how that persistence should participate in a transaction, let alone how it should participate in a distributed transaction that spans multiple systems.
Let me know if I'm missing something.