bpmNEXT 2014: BPMN MIWG Demo

The BPMN Model Interchange Working Group is all about (as you might guess from the name) interchanging BPMN models between different vendors’ products: something that OMG promised with the BPMN standard, but which never actually worked out of the box due to contradictions in the standard and misinterpretations by some vendors. To finish off Wednesday morning at bpmNEXT, we have a live demo involving 12 different tools with participants in different locations, with Denis Gagne of Trisotech (who chairs the working group) and Falko Menge of camunda (who heads up the test automation subgroup) on the stage, a few others here on the sidelines, some at the OMG meeting in Reston, and some in their offices in France and Poland.

To start, different lanes of the process were designed by four different people on IBM Blueworks Live, Activiti, camunda and W4; each then exported their process models and saved to Dropbox. Denis switched back and forth between the different screens (they were all on a Google Hangout) to show us what was happening as the proceeded, and we could see the notifications from Dropbox as the different files were added. In the second stage, Bonitasoft was used to augment the Blueworks Live model, itp-commerce edited the Activiti model, and Signavio edited the camunda model. In the third stage, ADONIS was used to merge together the lanes created in several of the models (I lost track of which ones) into a single process model, and Yaoqiang used to merge the Signavio and camunda models. Then, the Trisiotech Visio BPMN modeler was used to assemble the ADONIS and Yaoqiang models into the final model with multiple pools. At the end, the final model was imported into a number of different tools: the Trisotech web modeler, the Oracle BPM modeler, the bpmn.io environment from camunda, and directly into to the W4 execution engine (without passing through a modeling environment). Wow.

The files exchanged were BPMN XML files, and the only limitations of which tool to use when was that some only support a single pool so had to be used at the earlier stages where each tool was only modeling a single lane or pool. This is how BPMN was supposed to work, but the MIWG has found some number of inconsistencies with the standard and also some issues with the vendors’ tools that had to be corrected.

They have developed a number of test cases that cover the descriptive and analytic classes within BPMN, and automated tools to test the outcome of different vendors’ modelers. Over 20 BPMN modelers have been tested for import, export and roundtrip capabilities; if you’re a BPMS vendor supporting BPMN 2.0 (or claiming to), you should be on this list because there are a lot of us who just aren’t going to write our own XSLT to translate your models into something that can be read by another tool. If you’re a process designer using a BPMS, shame your vendor into participating because it creates a more flexible and inclusive environment for your design and modeling efforts.

This is hugely valuable work that they’re doing in the working group; note that you don’t have to be an OMG member to get involved, and the BPMN MIWG would love to have others join in to help make this work even better.

We’re off for lunch and a break now, then back for six more sessions this afternoon. Did I mention how awesome bpmNEXT is?

ACM Workshop at BPM2012: BPMN Smackdown by @swensonkeith

In the last portion of the ACM workshop at BPM 2012, we had a couple of short non-research papers, the first of which was by Keith Swenson, in which he posits that BPMN is incompatible with ACM. He starts by saying that it’s not a critique of BPMN in particular, but of any two-dimensional flow diagram notation. He also makes a distinction between production case management and adaptive case management – a distinction that I find to be a bit artificial since I don’t think that there’s a hard line between them – where PCM systems have developers creating systems for people to use, whereas ACM has people doing the work themselves. The distinction between PCM and ACM has created a thin, rarified slice of what remains defined as ACM: doctors and lawyers are favorite examples, and it is self-evident that you’re not going to get either doctors or lawyers to draw event-driven BPMN models with the full set of 100+ elements for their processes, or to follow rigidly defined processes in order to accomplish their daily tasks. Instead, their “processes” should be represented as checklists, so that users can completely understand all of the tasks, and can easily modify the process as required.

He states that drawing a diagram (such as BPMN) requires a level of abstract thinking that is common with developers but not with end users, hence BPMN is really a programming language. Taking all of that together, you can see where he’s coming from, even if you disagree: if a system uses BPMN to model processes, most people will not understand  how BPMN models work [if they are drawn in full complexity by developers, I would add], therefore won’t modify them; if all users can’t modify the process, then it’s not ACM. Furthermore, creating a flow model with temporal dependencies where no such dependencies exist in reality hinders adaptability, since people will be forced to follow the flow even if there is another way to accomplish their goals that might be more appropriate in a particular context.



My problem with this is that BPMN has been used by developers to create complex flow models because both the language and their organization allows them to, but that’s not the only way to use it. You can use a limited subset of BPMN to create flow models – in cases where flow models are appropriate, such as when there are clear temporal dependencies – that are understandable by anyone involved in those processes. You can create a BPMN diagram that is a collection of ad hoc tasks that don’t have temporal dependencies, which is semantically identical to a checklist. You can create alternative views, so that a model may be viewed in different forms by different audiences. In other words, just like Jessica Rabbit, BPMN isn’t bad, it’s just drawn that way.

Process Modeling With BPMN

I’m sitting in on Bruce Silver’s online BPMN course this week: this is the same as his onsite course, just using remote classroom tools to allow him to present and demonstrate to us, then get our feedback using typed chat. It’s a combination of lecture and hands-on, using a 60-day license for the business edition of the itp-commerce BPMN Visio add-in that is included with the course. The course runs 11am-3:30pm (Eastern) for three straight days, which took a bit of schedule juggling to be able to attend most of it; not sure if he is recording this for us to access after the course, which would be a nice benefit especially for those doing the certification exam. I use a lot of BPMN with my customers in my role as a process architect, but Bruce’s knowledge of the standard and its usage far outweigh mine, and I’m sure that I will learn a lot in addition to providing a review of the course for my readers.

He’s using the itp-commerce Visio tool, in spite of the hefty price tag ($975 for the Business Edition, $1,535 for the Professional Edition that also includes serialization; the free edition does not include full BPMN 2.0 support), because it natively supports Bruce’s methodology and style validation, which he covers in his book BPMN Method and Style and uses in this course. There are other Visio add-ons for BPMN 2.0 modeling, including one from Trisotech on the Business Process Incubator site that I’ve been using lately since it has a full-featured (but branded) version that customers can use for free, or the full non-branded version for the price of a BPI premium membership. Visio 2010 supports BPMN natively, but not the 2.0 version – if you’re a big Microsoft Visio customer, you might want to start agitating with Microsoft to include that via a service pack, since their current line seems to be that there isn’t sufficient demand for it yet. Bruce and I both believe that BPMN 2.0 support will become a significant differentiator for modeling products by the end of 2011, and Microsoft really needs to get on board with this if they’re going to be a player in the BPMN 2.0 market. There are some nice features in the itp-commerce tool that we didn’t cover in the course, such as simulation and BPMN 2.0 interchange, but many of those are available in lower-cost alternatives: I think that this is a race to the bottom price-wise, since Microsoft will eventually just include all of this in Visio natively.

He started with some basic definitions of BPMN and how it differs from flowcharts – especially in the area of collaboration, extra-process events and exception handling – highlighting the notions of standardization and of the hierarchical view that allows for inclusion of expandable subprocesses, rather than trying to put everything on one enormous top-level process model. He also covered how BPMN creates a bridge between business analysts who are creating these models, and developers who are making them executable, including the BPM systems that make the models directly executable without a lot of coding. He also discussed what’s not in the BPMN standard, such as user interface for human steps, data models, dynamic work assignments, rules, KPIs and anything to do with the higher-level strategy and goals. Although you may see some of these implemented in a BPMS, those will be done in a proprietary manner, and learning how to do that in that particular tool won’t be transferrable to other tools.

As I often do when I’m presenting a quick look at BPMN in a client presentation, he talked about the full BPMN 2.0 standard, with its new support for choreography and conversation diagrams, execution semantics and an XML schema for model interchange between tools, and highlighted that it’s possible to use the descriptive and analytic subclasses (subsets) of the standard if you don’t need to learn all 100 elements of the standard: the descriptive is for business analysts to be able to model processes as documentation, and the analytic is a minimum subset required to model executable processes.

Bruce keeps bringing it back to the value and benefits of BPMN: why it’s important both in terms of its modeling capabilities, and in the role as a standard for widespread understanding. There are a lot of BPMN detractors, but I don’t see the problem if you don’t try to shove the entire standard down the throats of business people: using the descriptive subclass (plus a few more elements), I’m able to have non-technical business people understand the notation in about 5 minutes, although it would take them a little bit longer to be able to create their own diagrams.

After an hour or so of initial presentation to provide the necessary background, Bruce shared his screen and had us all start up Visio with the itp-commerce add-in, and we started modeling some BPMN. As those of you familiar with BPMN know, there are only three main objects in a BPMN diagram: activities, gateways and events. The fun stuff comes with all the adornments that you can add to those three basic objects to indicate a huge variety of functionality.  We started off with a high-level straight-through order process, then added gateways for the exception paths. We started to learn some of the guidelines from Bruce’s style guide, such as using a gateway not to indicate work but only as a question testing the output state of the previous activity (which I always do), and using a separate end event for each distinct end state (which I rarely do but probably will start, since you can label the end events with the states). I also learned a standard Visio trick for moving the placement of the text on a connector using the Text Block tool, which allows you to snug labels of flows leaving a gateway right up to the gateway regardless of the connector length – cool! There were some great questions from the attendees, such as whether you can eliminate the gateway symbol and just have the labeled flows leaving the preceding activity, as you might in traditional flowcharting; in BPMN, that would denote have all of the paths be executed in parallel, not have one path or the other executed, so that’s not a legal representation of an exclusive OR gateway. Gateways can create a lot of confusion, because in spite of how they are often referred to as “decisions”, the decision is actually made in the previous activity, and the gateway just tests the result of that decision.

A great deal of day 1 alternated between some short presentations (a couple of slides each) on concepts, then exercises that allowed us to model those in diagrams ourselves, reinforcing the concepts immediately. While we were doing the modeling, Bruce would talk about other information about the concept, such as explaining some of the benefits and rules of pools while we were adding pools and lanes to our diagram, or the same for subprocess syntax. We saw some of the less-used but essential constructs such as ad hoc subprocesses, in which the contained activities don’t have a flow, and may be completed in any order (or not at all): this is how BPMN represents case management-style processes, for example, where the possible tasks are known but the order and applicability of any given task is not known. He also pointed out (and quizzed us on) common errors, such as having the same activity within a subprocesses and also in the process that calls it.

By the end of the first day, we had learned all of the Level 1 elements (effectively the BPMN 2.0 descriptive subclass), quite a bit of Bruce’s style guidelines around the use of those elements, and we were creating our own BPMN diagrams using those elements. At the start of day 2, after a recap, Bruce talked about having a BPMN method and style – whether it is his or not – so that there are standardized ways of using BPMN: in spite of it being a standard, it is possible to create diagrams that mean the same thing but look different, and having some standard usage makes it a more powerful communication tool within your organization. His method works toward four basic goals:

  • Structural consistency: a variety of the style points that he’s been covering, such as explicit end states and hierarchical composition
  • Readability: top-down traceability through levels of the process and subprocesses
  • Model completeness: diagram doesn’t require additional documentation to describe the process
  • Shareability with IT: models created by business analysts are aligned with the level 2 models used for executable processes

He then took us through the steps of his method for modeling processes that meets these goals; this was part of the essential intellectual property that he had to pass on to us (as opposed to the most standard BPMN on day 1), but too dense with slides and lecture rather than hands-on. Following that, he went through his BPMN style guides, which were also all lecture, but went much more quickly since these tended to be quick rules rather than larger concepts that we saw in the method section, and also we had covered a lot of these already in the exercises and the method. He did a blog post with a first cut of the rules and style of BPMN, both the standard BPMN rules and his style guidelines, plus a later post showing an example of reworking a process model to meet his style guidelines. The first is a great reference if you decide not to cough up for the itp-commerce product that will do the style validations for you; in reality, once you start using these for a while, they’ll become second nature and you won’t need to have them validated. He provided an updated list of the rules as part of the course, and has given me permission to republish, which I will do in a following post.

For the second half of day 2, we moved on to Level 2 BPMN elements (Analytic subclass) with more of the hands-on exercises on events: one of my favorite topics, since events are the most powerful yet the least understood of all BPMN elements. As Bruce pointed out, no one (not even him, and certainly not me) memorizes the table of 50 or so possible event permutations: for level 1 (descriptive subclass used by business analysts), you only need to know six of them (all start and end events), although I usually teach business analysts a couple of the intermediate events from level 2 as well. He suggests focusing on message, timer and error events, adding another nine to the six we’ve already seen; if you master these 15, then have to look up the others as required, you’re way ahead of most people using BPMN today.

Day 3 saw us still covering events via a combination of lecture and exercises; after timers on day 2, we moved on to message events and had a ton of great discussions on some of the finer points of BPMN usage (e.g., a script task that executes purely within the BPMS versus a service task that calls an external service). Message events are critical if you want to start modeling executable processes; intermediate message events are essential for automated messaging outside the process or organization, and boundary message events manage external events that modify or interrupt processes while in flight.  We also covered error events, and Bruce provided some supplementary information on other event types. Interestingly, Bruce is constantly reevaluating how BPMN can and should be used, with some changes over what he published in his book. He was a bit short on time for the last part of day 3 – the course timing definitely needs a bit of work – but we branched into splits and joins, went around iterations, and waded through multi-participant pools (which had an unfortunate effect on my brain).

He finished up with model validation using the itp-commerce add-in to Visio, which optionally validates against his style guide as well as the standard BPMN rules. As he puts it, any modeling tool that doesn’t provide validation against the BPMN specification is a toy, suitable only for drawing nice pictures. I suppose you could argue that after Bruce’s course, you will be able to validate automatically as you model so don’t need a tool to do it, but think of it as being like a spell-checker for process models: we all need a little help once in a while. 😉

He invited us all to go ahead and do the certification exam (no extra fee if done in the next 60 days), and showed one of the example multiple choice questions that had four possible answers, and received votes for all four of the answers from the class, showing that this is not quite as simple as it seems (yes, I got the right answer). If we pass that part, then we have to create a process model from one of our own processes of a specific level of complexity, following his method and style, and submit it for his review. Suffice it to say that certification via his BPMessentials exam will actually mean that you have mad BPMN skillz, it’s not just a certificate for showing up for the course.

Some potential improvements for the course:

  • It’s a bit hard to demo and talk at the same time, and Bruce could have captured screencams of some parts of the Visio demos to playback for us while he was discussing what we needed to do next, then just gone to Visio live for the finer points of demonstration; that would have made it easier for him to focus on describing what was happening rather than focusing on the actual drawing activity.
    • Some of the finer lecture points (such as going through the method and concepts) were a bit slow-moving, since Bruce would talk to one very dense slide for a number of minutes rather than having multiple slides with less information to absorb. Some restructuring of the slides would improve this, especially to show model snippets on the same page as the concept points, or possibly a much quicker summary to start, then return to the concepts later to reinforce.
    • The non-modeling exercises (e.g., defining the process scope given a specific scenario) didn’t work very well online, since there’s no fluid interaction with the participants, just the chat window with Bruce responding to the chat questions verbally when he sees them. In a regular classroom environment, he could ask for verbal solutions and write it out on a chart as they developed more collaboratively; here, all he could do was walk through the exercise and his solution. I’m not sure that a more interactive online collaboration tool would make a big dent in this problem; some things are just made for face-to-face (or at least audio) interaction. These sections could be enhanced by showing the process model solution at the same time as the exercise description – or better yet, a screencam – so that as he walks through it, he could point out how it manifests in the process.
    • It would be great to see a summary of the redundant elements in BPMN 2.0, with the preferred one (if one is preferred) indicated. For example, send/receive tasks are the same as intermediate throwing/catching message events except if you want to put boundary events (e.g., for error handling or timeouts) on the tasks in an executable process; a gateway is implied to be XOR if it has no marker; parallel split gateways and exclusive merge gateways are implied without showing the gateway. Although some of these are reflected in Bruce’s style guidelines, we just stumbled across some of them throughout the course.

    I definitely learned some of the finer points of BPMN that I didn’t already know, and I will be going back to some BPMN diagrams that I’m working on with clients and clean up the style a bit with what I’ve learned. With this being an online course, I could multitask with other activities during the parts that were review for me; for a BPMN newbie (the target audience), the pace would have been just about right.

    There are few people who have this depth of BPMN knowledge, and Bruce is the only one who I know who is doing this as a professional trainer: his is the only BPMN course that I recommend to my clients. He needs to work out a few bumps in how the online course works, but in general, I thought this was a great course, perfect for a business analyst who is already doing some process modeling but doesn’t know any BPMN, but also informative for those of us with some prior knowledge of BPMN.

    Integrating BPM and Enterprise Architecture

    Michael zur Muehlen presented this morning on integrating BPM and enterprise architecture, based on work that he’s done with the US Department of Defense. Although they use the DoDAF architecture framework in particular, the concepts are applicable to other similar EA frameworks. Like the Zachman framework, DoDAF prescribes the perspectives that are required, but doesn’t specify the artifacts (models) required for each of those perspectives; this is particularly problematic in DoD EA initiatives where there are likely to be many contractors and subcontractors involved, all of whom may use different model types to represent the same EA perspective.

    He talked briefly about what makes a good model: the information must be correct, relevant (and complete) and economical (with respect to level of detail), as well as clear, comparable (linked to reality) and systematic. From there, he moved on to their selection of BPMN as the dominant standard for process modeling, since it has better event handling than UML activity diagrams, better organizational modeling than IDEF0, and better cross-organizational modeling than simple flowcharts. However, many tools support only a subset of BPMN – particularly those intended for process execution rather than just process modeling – and some tools have non-standard enhancements to BPMN that inhibit interoperability. Another issue is that the BPMN specification is enormous, with over 100 elements, with some different constructs that mean the same thing, such as explicit versus implicit gateways.

    They set out to design primitives for the use of BPMN: where they “outlawed” the use of certain symbols such as complex gateways, and developed best practices for BPMN usage. They also mapped the frequency of BPMN symbol usage from internal DoD models, those that Michael sees in his practice as a professor of BPM at Stevens Institute of Technology, as well as samples found on the web, and came up with a distribution of the BPMN elements by frequency of usage. This research led to the creation of the subsets that are now part of the BPMN standard, as well as usage guidelines for BPMN in terms of both primitives and patterns.

    In addition to the BPMN subsets (e.g., the most commonly implemented Descriptive subclass), they developed naming conventions to use within models, driven by the vocabulary related to their domain content. This idea of separating the control of model structure from the vocabulary makes sense: the first is more targeted at an implementer, while the second is targeted at a domain/business expert; this in turn led to vocabulary-driven development, where the relationship between capabilities, activities, resources and performers (CARP analysis) is established as a starting point for the labels used in process models, data models (or ontologies/taxonomies), security models and more as the enterprise architecture artifacts are built out.

    Having defined how to draw the right models and how to select the right words to put in the models, they looked at different levels of models to be used for different purposes: models focused on milestones, handoffs, decisions and procedures. These are not just more detailed versions of the same, but rather different views on the process. The milestones view is a high-level view of the major process phases; handoffs looks at transitions between lanes with all activities with a lane rolled up to single activity, primarily showing the happy path; decisions look at major decision points and exception/escalation paths; and procedures showing a full requirements-level view of the process, i.e., the greatest level of detail that a business analyst is likely to create before involving technical resources to add things such as service calls.

    To finish up, he tied this back to the six measures of model quality and how this approach based on primitives conforms to these measures. They’ve achieved a number of benefits, including minimizing modeling errors, ensuring that models are clear and consistent, and ensuring that the models can be converted to an executable form. I’m seeing an increased interest with my clients and in the marketplace on how BPM and EA can work together, so this was a great example of how one large organization manages to do it.

    Michael posted earlier this year on the DoDAF subset of BPMN (in response to a review that I wrote of a BPMN update presentation by Robert Shapiro). If we go back a couple of years before that, there was quite a dust-up in the BPMN community when Michael first published the usage distribution statistics – definitely worth following the links to see where all this came from.

    Learning to Love BPMN 2.0

    The last presentation of the IRM BPM London conference before the final panel, and Chris Bradley and Tim Franklin of IPL are presenting on BPMN 2.0. Bradley started with a brief history of BPMN from its 1.0 release in 2004 by BPMI to the present day 2.0 release, now under OMG. It was interesting to see their list of what BPMN does not do: state transitions, functional decomposition, organizational hierarchies and data modelling, which explains why some BPMS products are starting to build those functions into their integrated development environment to be defined along with the process models. [Note that although I normally use US spelling due to the geographic location of most of my audience, I’m using “modelling” here after Bradley point out that the US spelling, “modeling” should rhyme with “yodeling” 🙂 ]

    Franklin took over to get into the details of the notation, particularly the differences between the 1.x and 2.0 versions and the new elements and diagram types in 2.0. I’m not going to review all of that; there’s a lot of existing material both on this blog and in other locations, including a webinar that Robert Shapiro gave earlier this year on BPMN 2.0.

    Bradley took the stage again to discuss all the other things that have to happen after you get started on BPMN 2.0, particularly modelling data and aligning that with the process models, whether that’s being done in an integrated tool or two different modelling tools. I agree with him that it’s critical for process, data and organizational modelling efforts to be linked, although I think that’s more likely to have happen via MDM rather than by having a single integrated modelling tool.

    His summary said it all: BPMN is simple (if you can read a flowchart, you can understand BPMN); BPMN is robust (can be used for both high-level design/architecture and detailed process model execution/implementation); and most importantly, BPMN and process models are only part of the big picture, and need to be linked to other information assets such as data and organizational models.

    You may not have come out of this session actually loving BPMN 2.0, but at least you’ll respect it in the morning.

    The Great BPMN Debate of 2010

    I go off on vacation for a week, and a firestorm erupts around BPMN usage by business people. It’s taken me the weekend to comb through all the posts and comments; there’s a lot of reading here, and I recommend checking out the discussions in the comments on each of these posts as well as the posts themselves.

    Where it all started

    BPMN for Business Professionals: Burn Baby Burn: Jim Sinur blogs about how BPMN is too hard for business people, touching off a storm of comments on this post, and several posts from others on the same subject.

    The responses

    Process for the Enterprise » Blog Archive » Apparently BPMN is Too Hard: Scott Francis responds to Jim Sinur’s post, saying that if you’re already flowcharting processes, then BPMN (at least the basic set) really isn’t much different from that, and provides the benefit of standardization. He doesn’t want to let the business off the hook of learning a new skill when it’s really not that hard, and provides some benefit to the business (not just to IT).

    Dave Thinking Aloud: BPMN only part of the solution: Dave French agrees with Scott’s post and offers a great quote: “It would be really scary if those responsible for the operation of multimillion dollar enterprises can’t take on the meaning of a set of symbols that can be put on a small wallchart”. My thoughts are pretty much aligned with Scott and Dave’s.

    BPMN 2.0: no longer for Business Professionals | On Collaborative Planning: Keith Swenson points out that most of the enhancements to the new version of BPMN are for developers, not business people, turning it into a graphical programming language for processes. He questions whether vendors will move from BPMN 1.2 to 2.0 if their focus is on modeling rather than execution. I think that Keith is throwing the baby out with the bathwater here: although a lot of new constructs have been added that make BPMN more useful for developers, that doesn’t make the basic subset inappropriate for business people who are already mapping their business processes with flowcharts. In the absence of any specific direction, I most often see business people (and business analysts) use flowcharts to represent their business processes; introducing them to the simplest BPMN subset will at least put some standardization around those flowcharts so that there’s no confusion over the shapes used on the diagram, and to reduce some of the spaghetti around flowcharting events.

    On IT-business alignment and related things » BPMN “not for the business”? Let’s lose the hype: Neil Ward-Dutton takes a similar middle ground to mine: “there’s significant evidence to suggest that a core subset of BPMN symbols are absolutely usable by business analysts with experience in high-level analysis and design and provide great results in terms of delivering a common language across multi-disciplinary teams”. BPMN is not useful to everyone. And business people are never going to learn more than a subset of BPMN. That’s not justification for stating that BPMN has no value for business.

    Chris Adams Responds to: “BPMN for Business Professionals: Burn Baby Burn” by Jim Sinur (Gartner): Chris Adams relates a conversation with a CIO who had BPMN representations created for business processes that were too complex for the business to understand. Sounds like these weren’t modeled by the business, or at the right level.

    The wrap-ups

    Process for the Enterprise » Blog Archive » I See Business Professionals… Using BPMN: Scott Francis wraps up a lot of the discussions, finishing with the statement “Regardless of what the theory says, the practical reality is our customers’ businesses are using this stuff”. I find that this is true for me as well: my customers are using flowcharting extensively for modeling business processes, and with a small amount of guidance, they are using the simplest subset of BPMN. I know that’s right up there with the theory that it’s aerodynamically impossible for bumblebees to fly, and yet they persist in doing so.

    BPMN Quotes of the week « Adam Deane: Adam Deane wraps up the week of BPMN blog posts with the best quotes drawn from several of them.

    My take

    BPMN | How to explain BPMN to Business Users | VOSibilities: The replay of a webinar that I did in June on BPMN and business users. I make the points that the subset is all that’s needed for business, and that there’s a difference between knowing enough BPMN to create models and knowing enough BPMN to understand models. Here’s just the slides:

    In short: BPMN isn’t for all uses, but if your business people are already flowcharting their business processes, then teaching them a few BPMN symbols in order to standardize those flowcharts has benefits.

    BPM Summer Camp: Business Users and BPMN

    I presented today on the second part of Active Endpoints’ BPM Summer Camp, discussing just how much BPMN your business users and analysts need to know. Michael Rowley, CTO of Active Endpoints, gave a demo of BPMN using their system, including illustrating a number of the concepts that I introduced in my presentation.

    You can view and download my slides here:

    A few other references based on the questions at the end of the presentation:

    We have the third and last part of BPM Summer Camp, “Five Things You Should Never, Ever Try in Process Development”, on July 22nd; head over to the landing page to sign up for that, as well as see a replay of the first two parts.

    BPMN In The Real World Slideshow

    Webinar done, we’re just on the final Q&A; I saw about 170 people logged in at one point, a pretty good turnout. The replay will be available on the VOSibilities blog or on iTunes.

    Here’s my slides, with the “Process Model Hall Of Shame” removed:

    As I mentioned in the presentation, there are a lot of great resources on the BPMN standard; my presentation was about how people are actually using it rather than the standard itself.

    BPMN 2.0 Industry Update

    It’s webinar day here at Column 2: this is my third in a row, this one an update on the BPMN 2.0 standard by Robert Shapiro, who participates in both the OMG BPMN 2.0 and WfMC XPDL 2.2 standards efforts. We’re already starting to see vendor support for BPMN 2.0, even though it’s not yet fully released, as well as books and training materials.

    The concept of subclasses in process modeling has been included in this version, where there is a simple subset of eight elements used for process capture by non-technical process analysts/owners (start, end, sequence flow, task, subprocess, expanded subprocess, exclusive gateway, parallel gateway), then a larger subset for a “descriptive” persona, a larger-still subset for a “DODAF” persona, then the entire set of more than 100 elements.

    You can download the accompanying PowerPoint deck for a more complete view of subclasses and their corresponding personas. I can certainly understand why many of the event variations were pushed out of the simple subclass, but I’m not sure that I agree with excluding pools and lanes, since these are pretty commonly used constructs. Also not sure why the US DoD’s enterprise architecture standard is impacting what is supposed to be an international standard.

    These subclasses are important for vendors of modeling tools, but also for those looking to use BPMN as a standard for representing processes: this gives a good idea of how to split up the standard by the type of reader (persona) so that you don’t overwhelm the less technical audiences with too much detail, but also provide the greater levels of details for complete process specification.

    Shapiro went on to discuss what most consider to be the most important (and likely the most controversial) part of BPMN 2.0: diagram interchange; BPMN 2.0 does not include an XSD schema, and there is ongoing work to create an XSD that is aligned with the metamodel. For those of you who follow BPM standards, you’ll know that XPDL is currently the de facto standard for process model interchange, supported by many vendors; these efforts are continuing in a separate organization (BPMN is managed by OMG, XPDL by WfMC) so it’s good that Shapiro and others are there to bridge the efforts across the two standards. We’re now seeing the emergence of XPDL 2.2, which will support the interchange of BPMN 2.0 process models. XPDL may eventually disappear in the face of a comprehensive BPMN 2.0 diagram interchange standard, but that will take years to happen, and a lot can happen in that time. In the meantime, XPDL will likely be used as an alternative diagram interchange format for BPMN 2.0 diagrams, with vendor support required for both standards.

    The Business Process Incubator site has been created by several of the companies participating in both BPMN and XPDL standards efforts as a source for information as well as a variety of standard-related tools such as Visio templates. Shapiro also predicts that many tool vendors will release web-based BPMN 2.0 modelers, as well as BPMN and XPDL converters.

    If you’re interested in where BPM standards are headed, it’s worth listening to the entire webinar, especially the Q&A at the end; I imagine that it will be available at the registration link on the WfMC site that I posted in the first paragraph.

    Robert Shapiro on BPMN 2.0

    Robert Shapiro spoke on a webinar today about BPMN 2.0, including some of the history of how BPMN got to this point, changes and new features from the previous version and the challenges that those may create, the need for portability and conformance, and an update on XPDL 2.2. The webinar was hosted by the Workflow Management Coalition, where Shapiro chairs the conformance working group.

    He started out with how WPDL started as an interchange format in the mid-90’s, then became XPDL 1.0 around 2001, around the time that the BPMN 1.0 standard was being kicked off. For those of you not up on your standards, XPDL is an interchange format (i.e., the file format) and BPMN prior to version 2.0 is a notation format (i.e., the visual representation); since BPMN didn’t include an interchange format, XPDL was updated to provide serialization of all BPMN elements.

    With BPMN 2.0, serialization is being added to the BPMN standard, as well as many other new components including formalization of execution semantics and the definition of choreography model. In particular, there are significant changes to conformance, swimlanes and pools, data objects, subprocesses, and events; Shapiro walked through each of these in detail. I like some of the changes to events, such as the distinction between boundary and regular intermediate events, as well as the concept of interrupting and non-interrupting events. This makes for a more complex set of events, but much more representative.

    Bruce Silver, who has been involved in the development of BPMN 2.0, wrote recently on what he thinks is missing from BPMN 2.0; definitely worth a read for some of what might be coming up in future versions (if Bruce has his way).

    One key thing that is emerging, both as part of the standard and in practice, is portability conformance: one of the main reasons for these standards is to be able to move process models from one modeling tool to another without loss of information. This led to a discussion about BPEL, and how BPMN is not just for BPEL, or even just for executable processes. BPEL doesn’t fully support BPMN: there are things that you can model in BPMN that will be lost if you serialize to BPEL, since BPEL is intended as a web service orchestration language. For business analysts modeling processes – especially non-executable processes – a more complete serialization is critical.

    In case you’re wondering about BPDM, which was originally intended to be the serialization format for BPMN, it appears to have become too much of an academic exercise and not enough about solving the practical serialization problem at hand. Even as serialization is built into BPMN 2.0 and beyond, XPDL will likely remain a key interchange format because of the existing base of XPDL support by a number of BPM and BPA vendors. Nonetheless, XPDL will need to work at remaining relevant to the BPM market in the world of BPEL and BPMN, although it is likely to remain as a supported standard for years to come even if the BPMN 2.0 serialization standard is picked up by a majority of the vendors.

    The webinar has about 60 attendees on it, including the imaginatively named “asdf” (check the left side of your keyboard) and several acquaintances from the BPM standards and vendor communities. The registration page for the webinar is here, and I imagine that that will eventually link to the replay of the webinar. The slides will also be available on the WfMC site.

    If you want to read more about BPMN 2.0, don’t go searching on the OMG site: for some reason, they don’t want to share draft versions of the specification except to paid OMG members. Here’s a direct link to the 0.9 draft version from November 2008, but I also recommend tracking Bruce Silver’s blog for insightful commentary on BPMN.