BPMN 2.0 and WS-BPEL 2.0 are the two most important standards for BPM today. But why are there two? Can’t you just care about BPEL or just care about BPMN? In fact, both standards matter and the two should be used together. To back that up, I have to convince you both that BPEL needs BPMN and that BPMN needs BPEL. In today’s post, I’ll concentrate on the first: why BPEL needs BPMN.
First, lets assume that you are convinced of the value of BPEL. You see that it is a great high-level language for creating business processes and orchestrating services. Its service-centric approach is simpler and better for long-term manageability and reuse than other approaches to business process management. It is an accepted OASIS standard with multiple vendor implementations, so investments in BPEL processes are not tied to a single vendor and you can find people who already know the language without having to train them from scratch.
But if you are convinced you want BPEL, why should you care about BPMN? There are two main reasons:
1) To get the value of a standard notation;
2) To improve collaboration with a wide variety of stakeholders in the process, since BPMN is a significant simplification over existing notations used for BPEL.
When WS-BPEL 2.0 was standardized, the OASIS Technical Committee chose not to standardize a graphical notation for it. This was unfortunate, since no one creates a business process by writing BPEL in XML, which is the only standardized representation. Every vendor, and every BPEL developer, creates their processes using a graphical representation, but that representation is different for every tool.
And the notations used by these tools haven’t really been very good. They typically provide a one-to-one correspondence between control flow constructs in BPEL and things on the canvas. However, if you use the BPMN notation, it shows a notation that can mostly be understood without any knowledge of BPEL or even BPMN for that matter (as long as the labels are chosen carefully).
Let me make both of these points with the help of a trivial process example. Take a look at the BPMN representation of a process that I’ll call the “Question” process.
(Click on each image to see a larger version)
![clip_image002[4] clip_image002[4]](http://www.vosibilities.com/wp-content/uploads/2009/11/clip_image0024_thumb.jpg)
It is trivial to follow what is going on, especially if you know the standard notation. You can’t tell by looking at this diagram, but I’ve used two different BPEL mechanisms for getting to the next activity. I use a BPEL link to get from “Receive Q” to the first diamond (the beginning of the BPEL if statement). I use a BPEL sequence to get from the second diamond (the end of the if) to the “Record Answer” activity.
The user who is looking at the graphical representation of the process doesn’t need to know about the distinction between these two mechanisms, so the diagram doesn’t show a difference. The developer may want to know about the difference, so ActiveVOS highlights them differently on mouse-over and shows them differently in the “process outline view”, but that isn’t really important for today’s discussion.
What is important is how different the process is represented in different tools due to the fact that no notation had been standardized. I’ll show what this process looks like in three different BPEL process designers.
Here is how ActiveVOS would represent this process in previous versions of the product (or using the optional “classic” style in 7.0):
![clip_image004[4] clip_image004[4]](http://www.vosibilities.com/wp-content/uploads/2009/11/clip_image0044_thumb.jpg)
Here is how the Eclipse BPEL Designer represents it:
![clip_image006[4] clip_image006[4]](http://www.vosibilities.com/wp-content/uploads/2009/11/clip_image0064_thumb.jpg)
And, here is how the designer for Oracle’s BPEL Process Manager represents it:
![clip_image008[4] clip_image008[4]](http://www.vosibilities.com/wp-content/uploads/2009/11/clip_image0084_thumb.jpg)
In all three of these representations, each of the paths through the if statement are represented by a bounding box. The problem with this representation is that nested if statements can result in so many nested bounding boxes that it is hard to follow what is going on. BPMN simply has arrows through each path and the paths merge back into a single control flow at a gateway diamond.
Also notice the differences in the handling of links vs. sequences. Both ActiveVOS classic and Eclipse represent sequences with their own bounding boxes, then any arrow that is a direct child of a sequence box is known to belong to the sequence, rather than being a real link. Eclipse also draws the links in different color. The extra sequence icon and corresponding bounding box just interferes with the ability for non-technical users to follow what is going on in the process.
Oracle’s designer is odd in this respect. Sequences are not shown in a bounding box, so they don’t clutter up the control flow (a good thing in my opinion), but links aren’t shown at all! There is a link from the “Receive_Q” activity to the if statement, but there isn’t any representation of it on the diagram. It shows the “Receive_Q” and the if as if they happen in parallel. You have to look into the properties of “Receive_Q” to discover that it has an outgoing link, and further rummaging to find out where it goes.
The BPMN representation is, by far, the easiest version of this small process to understand. The process illustrates just three constructs whose representation is simpler with BPMN than with other approaches: ifs, sequences and links. The other BPEL constructs are generally as easy or easier for non-technical users to understand than previous approaches.
But, as valuable as the improvement in readability may be, the greater value that BPMN brings to be BPEL is probably consistency. Having different tools represent similar constructs in such different ways is detrimental to one of the key values in having a standard: skills portability. With a common notation, people will be able to carry their knowledge of how to understand and work with standards-based business processes between vendor tools. It will also create a greater incentive for people to learn these technologies and for schools to teach them. After all, people aren’t usually to thrilled about investing a lot of energy into learning proprietary technologies, and no school really wants to be teaching proprietary technologies.