Marlon Dumas provided a thoughtful response to my post on roundtripping. In order to address it point by point, I am reposting Marlon’s comment here in a new thread., with my responses inserted:
Bruce,
I agree with many of the points you make, but I strongly disagree with the proposition that BPEL is like an assembly language and that the readability of BPEL code generated from BPMN diagrams is unimportant. My three main counter-arguments are:
1) You won’t remove the developer from the BPM lifecycle, simply because no business analyst will ever be willing to write something that resembles an XPath expression, or any other expression language. And how would you otherwise encode in an executable manner all your conditional expressions and data transformation functions which you need to run your processes and move data around? One simply needs to look at the experiences of early adopters of the “BPM on top of SOA” paradigm, such as Danske Bank which has been running a project in this space for 4-years. They have three roles: business analyst who designs high-level process model is a flowcharting notation like BPMN, the solution architect who refines these models and identifies what parts of the model will be automated and how, and finally the developer who translates them (manually) into an executable process model (see detailed discussion here: http://brahe.org/MamboPHD/index.php?option=com_docman&task=docclick&Itemid=31&bid=27&limitstart=0&limit=5)
Bruce: No one is talking about removing IT from the BPM lifecycle. In fact I even agree with your 3 roles, although I would describe their function slightly differently. The business analyst creates process models in BPMN. The solution architect (IT) makes model activities and gateways executable by configuring them via point-click dialogs and wizards (no code). The developer creates business services using Java, BPEL or whatever, which can also be bound to model activities to make them executable. The developer may be working in the SOA tool, while the business analyst and solution architect are using the BPMS.
2) If we simply don’t care about the BPEL code, why would vendors not just build an engine that directly executes BPMN models? If a vendor already has a good BPEL engine, it is not extremely difficult (given the engineering resources available to them) to adapt it so that it interprets BPMN directly. And this would avoid the additional hurdle of maintaining a complex translation between BPMN and BPEL which would only make things harder to trace and to debug. If really a vendor was very keen to translate BPMN into something else, it would make much more sense to translate it into a lower-level language than BPEL, such as for example into a set of event-driven rules that can be executed in a highly scalable Complex Event Processing (CEP) engine.
Bruce: My point exactly. Basically what Lombardi, Appian, and Cordys did. Most vendors have a serviceable engine already, so if it supports the semantics expressed in BPMN, another option is to make BPMN the design surface and hide the proprietary internal language. That would describe Savvion, TIBCO, webMethods, and soon I think BEA and others. Why not a CEP engine? Why not, if it works? The test of an engine is performance, robustness, and cost. Does anyone care what its internal language looks like? My point is that BPEL’s strength is there are inexpensive high-performance engines available from multiple sources. That has nothing directly to do with the language itself.
3) After investing so much in BPEL, it is unlikely that vendors such as Oracle and IBM will replace it with BPMN. BPMN has to be complementary to BPEL (i.e. at a higher level of abstraction).
Bruce: Not replace BPEL with BPMN, since they don’t really compete. I’m saying replace direct BPEL editing (in the BPM suite, not necessarily in the SOA toolset) with BPMN plus point-click wizards, more Lombardi-style. Both vendors you mention have taken baby steps in that direction already, and I predict in a couple years BPM from both Oracle and IBM will be a lot more business-friendly in their tooling, without giving up the underlying BPEL runtime.
4) Even if we decide to use BPMN to define executable processes (as various vendors are currently pursuing), we will need two versions of BPMN: “Business BPMN” and “Executable BPMN” and these will be targeted at different types of users (e.g. business analysts versus architects/developers). The concerns of the business analyst are not the same as those of the solution architect and those of the developer. The business analyst will want to annotate his/her models with attributes capturing risks, compliance requirements, as well as simulation parameters. The solution architect and the developers are interested in extracting and moving data around, in defining application bindings, in addressing security, scalability and reliability issues,
Bruce: I agree that not all process models have the intention of execution, and also that the BPMN style employed may differ slightly in those two cases, but I think that’s a result of the immaturity of BPMN education. Not sure if you are saying this, but I also maintain that BPMN has a lot of attributes put in there just for BPEL generation, and these are generally ignored. If that’s what you mean by executable BPMN, I agree get rid of that stuff. Whether intended to create executable or not, there is also the divide between modelers who care about things like event throw-catch, multipool processes linked by message flows, and transaction compensation, and those who don’t. These are also the features missing from many BPMN-based tools, so there should be some kind of dividing line related to model portability conformance classes, and I am working with the XPDL guys to promote this idea.
If ever you change your mind and are looking for a BPMN-to-BPEL translation which is fairly complete AND produces readable BPMN-to-BPEL code, just point your Firefox browser here:
http://www.bpel4chor.org/editor/
Take a look for example at the PriceRequest BPMN model. After opening it, you can export it to BPEL with the fourth button in the menu from left to right (”Export to BPEL4Chor”).
NOTE: This fully online BPMN editor only works with the Firefox browser and it takes about 10 to 15 seconds to load into your browser window. It’s work in progress, If you can not get your favorite BPMN model properly exported into BPEL using this online editor, just drop an e-mail to: gero.decker@hpi.uni-potsdam.de
Bruce: Based on what you say here and also privately, this tool sounds totally cool. I’m going to check it out!
Tags: BPMN


December 4th, 2007 at 3:28 am
I think Marlon has the wrong end of the stick. The issue is not generating readable BPEL for developers, the issue is reflecting any changes to the process model made by the developers back to the analysts. So long as the developers are using a different representation of the process there is room for errors of interpretation when the analysts try to put the developer’s (BPEL) changes back in to the BPMN model. It means that someone, probably the developer, has to be able to look at the BPEL representation and know which bits of BPEL correspond to which bits of BPMN in order to even know where in the BPMN map the changes have been made.
It’s error prone, manual and inefficient. But worst of all it perpetuates the us-and-them attitude between analysts and programmers and it’s about time we started getting over that. Working together on the same model is a great place to start.
December 6th, 2007 at 9:46 am
Craig:
Even though the work of this team of researcher is remarkable, I wholeheartedly agree with you. I wrote this article to explain the reason in more details.
http://www.infoq.com/articles/.....ies-of-bpm
JJ-
December 14th, 2007 at 2:32 am
Hi Craig
I agree 100% with you, and our apparent disagreement only comes from the fact that you are reading my comments out of their initial context. I can only agree that, ideally, all stakeholders should be speaking the same language and they should be speaking it in the same way, even if we should acknowledge that different stakeholders are concerned by different aspects.
I repeat what I wrote before: If we simply don’t care about the BPEL code, why would vendors not just build an engine that directly executes BPMN models? But that’s a question for vendors. Who knows? Maybe in one or two years time, a big vendor is going to release a BPMN execution engine - bypassing BPEL completely.
Now that we agree that business analysts, solution architects and even developers should ideally all be talking the same language, let’s go back to the original context in which the discussion was raised.
The problem is that, as we speak, several projects are using BPMN (or similar notations) at the business level and BPEL at the implementation level. The Danske Bank project is an example, but also in Australia I’ve seen at least one other project in the same situation. In these projects, BPEL code is not assembly code: there are actual people working on this code. So our question is: what type of tool support can we provide to help projects that are juggling between BPMN and BPEL? This is the context of the discussion, An in this context, I contend that, given the choice between generating unreadable BPEL code vs generating readable BPEL code, I believe vendors should be generating readable BPEL code. Moreover, as we have shown in our work, it is not significantly more difficult to generate readable BPEL code than unreadable one. I also suggest you to take a look at Oracle BPA, which provides functionality to propagate changes in the BPEL code back to the BPMN code and vice-versa.
Now, if we were all using BPMN, we wouldn’t have this problem. Although I contend that we would have other problems, such as reconciling multiple overlapping views on BPMN models. At this stage, BPMN does not have a notion of “views” or “profiles”.
We also seem to agree with Bruce that nobody is asking business analyst to write XPath expression, and that’s very reassuring.
December 20th, 2007 at 4:21 am
OK, I understand where you were coming from, and yes, if you must use a BPEL engine for BPM then obviously it’s good to have a developer-friendly translator.
As for Oracle BPA, we did a proof of concept with them and the round-tripping simply did not work in any useful way. And the translation into BPEL required so much coding to get to work that in the end the business analysts could not demonstrate the result to the business users because the final process was quite different from their original ARIS model.