There is a special reduced introductory price, so be sure to get your copy before the price goes up.  Also note that the Kindle version will be released around the end of July 2011.  There are few process modeling / BPMN 2.0 books available for Kindle, and this is the one to own.

Description:

An updated guide to business process modeling covering a broad range of necessary topics for understanding the new era of process design. A must-have book for business analysts, IT architects, and anyone interested in driving process improvement with a more efficient means of communication. The concise materials in this book focus on modern process design. Developed from actual practices, these techniques are proven in many of the most advanced processes, in production today. More than BPMN 2.0, the book is about Process modeling 2.0 concepts which stress decision and event modeling.

• Most important topics related to business process modeling.
• Quick guide to OMG’s BPMN 2.0 notation.
• Common patterns based on proven design.
• Decision modeling and business rules patterns.
• Event processing patterns.
• Combined process, decision, and event modeling.
• Characteristics of various process types.
• Process Modeling Framework (PMF) for consistent, structured design
• Process Discovery through effective requirements gathering techniques.
• Considering the organization as part of process design.

A special thanks to Jessica Holbrook for the beautiful cover design, Robert Kern for the easy to read layout, and Dr. Richard Welke for the forward.

In this new book we are  including some new groundbreaking material about merging business rules and complex event processing along with traditional process modeling.   According to most leading industry analysts (Gartner, Forrester, IDC, etc), we are at a point where techniques and technologies are merging.  This level of complexity and sophistication requires an overarching governance methodology to be successful.   For this reason I included 30+ paged dedicated to the Process Modeling Framework (PMF).   Thirty pages is not nearly enough on this topic, but at least it’s enough to get started with understanding layered process structures.  The Microguide book strategy is to give a jump-start on the topic of process modeling but yet provide enough details to use the content in the real-world.

I still have plans to publish the process patterns book and the more detailed PMF book.  But because of my fairly recent career path change, my perspective has greatly changed. And, the industry as a whole has changed since 2008.   We are now in the fourth wave.  Therefore the content I had previously created has to be updated.

Keep your eyes open for the new book.  It should be showing up on Amazon.com by mid June 2011.   And thanks again for everyone’s support on making the search term “BPMN” on Amazon.com list my previous book in the top three.

- Rick Geneva

Continuing coverage of the BPMN 2.0 specification, this post will focus on the new event types.   Prior to 2.0, BPMN had several problems when it came to escalating events and dealing with events in parallel.  Often I would end up using a pattern with multiple loops inside of loops to accomplish seemingly simple activities. Furthermore, it was difficult to distinguish between human centric and system centric activity for a mixed-mode diagram that includes both.

One goal of BPMN is to bring the SOA camp, the business analysts,  and the process modeling communities closer together.  A side effect of this has been that BPMN is very messaging intensive. For complex interactions, multiple pools are used, which requires lots of messaging lines to keep activity in sync between participants .  This is sometimes a problem for people who come from a flowchart/workflow backround using tools such as Visio, which essentially allows you to create a really bad BPMN diagram due to the lack of diagram validation.  Often I see messaging lines within a pool going between lanes, when what was really intended is to do a simple escalation.  Antoher common problem prior to BPMN 2.0 is showing enough detail without having to show the intricate patterns of looping and dealing with multiple events in parallel.


We are starting to see a shift from multiple pools and lanes to more of a style based on a single pool with no lanes, which means less explicit messaging notation. On the other hand, we are starting to see more capability in BPMN to document highly technical processes for the SOA community.


New Event Types

In this post I will cover the new BPMN escalation event and parallel multiple event.

Escalation event

The escalation event is new in the BPMN 2.0 specification.  The shape looks like the Star Trek symbol.  I’m not sure what you call it, but it somewhat resembles an upward facing arrowhead.  The full pallet of escalation events are available.  However, it’s important to note that both start (interrupting/non-interrupting) and both intermediate types can only be used with subprocesses. Only the throwing shapes can be used within normal sequence flow.   This implies that escalation can only be thrown from within a subprocess that has a catching shape.  The intermediates are used on the subprocess border, whereas the start types are used within the subprocess.  Note that you should review non-interrupting events in my previous post for more details on how non-interrupting events work.

BPMN 2.0 Escalation Events

Prior to the introduction of the escalation event, the only way to effectively accomplish the equivalent behavior was to throw an exception, or use a timer on a subprocess border. Both of these alternate patterns introduce potentially unwanted side effects.   If the exception event is used, there is no non-interrupting catching shape. Therefore the parent scope would always be cancelled, and only exceptional flow would be executed. But in the case of escalation, most often this is not the case.  For example, a participant is working on a problem which requires escalation to a manager. The original participant will continue the work, although the manager is now involved.  This is a collaborative escalation mode which requires a dynamic parallel flow, generated by the non-interrupting escalation event.  This would not be possible with an exception event.  Furthermore, a timer would not be appropriate in this case either because the event is not based on time. Instead, it’s based on a condition generated during the execution of a task, probably by the participant performing the task.

Escalation Event Example (non-interrupting)

The example above shows the non-interrupting start event catching the intermediate throw escalation event.  Again, note that if the start escalation event were interrupting (solid), the step “do more work” would not occur.   The start and intermediate catching events can only be used within or attached to a subprocess border.  To further clarify this behavior, study the following example:

Intermediate Escalation example

In this example the handler is on the subprocess border.  Technically this process will execute identically to the one above, with one easily overlooked difference.  The participant handling the escalation in example 1 can directly collaborate with the other active tasks, because they are both in the same scope.  Example 2 has an event handler that is external to the subprocess, which means that the handler does not have access to the same data and event scope as the other active tasks.  All communication between tasks would have to be handled in some other way.  Also note that external synchronization back into the main flow is required, because two parallel paths were created. Failure to synchronize would have the same consequences as explicitly using a parallel split with no merge. The inclusive merge is used because at design time we won’t know if the escalation path will occur or not.  Got it?  If not, bear with me for a few more posts and I’ll get back to these patterns.  For now I”m only covering the spec.

Parallel Multiple Event (inclusive behavior)

As of BPMN 1.2 the multiple event had only exclusive behavior, meaning that a single qualifying event would trigger the shape.  The inner shape of the event is a pentagon.

Multiple Events: Exclusive Behavior

Adding to this shape, you can see the new non-interrupting variety of both the start and intermediate shapes.   Refer to non-interrupting events in my previous post for details on how non-interrupting events work.


BPMN 2.0 introduces the parallel multiple event, which has inclusive behavior, meaning that all related events are required in order to trigger the shape.   There is no throwing type for this shape, because a parallel throwing multiple event would probably raise more questions than it solves.  Anyway, there are interrupting and non-interrupting varieties of the start and intermediate types.

Parallel Multiple Event shapes

Officially the specification calls this a parallel event, because it must receive all events to trigger the shape.  To help eliminate confusion I’ve also been referring to the behavior as inclusive, meaning that all events are included.  But actually, the parallel behavior is much closer to the truth of the use case.  The term ‘parallel’ is somewhat ambiguous because it might imply that all events must be received at the same time.  In reality, parallelism in BPMN does not mean that activities execute at the same time. Instead it means that multiple activities or events are enabled in parallel, and have the potential to occur at the same time.   Just because a task or event is enabled doesn’t necessarily mean that it will execute.  A parallel multiple event requires that all events in the correlation set to be triggered before the condition is satisfied.  Only then will the entire event trigger be fulfilled.

The epitome of complexity

The usefulness of this shape is debatable.  Most BPM vendors have not added support for many of the BPMN shapes because they just don’t make sense for an executable system.  In fact, about half of the BPMS vendors on the market today are using only a subset of BPMN 1.0 or 1.1.   To some, this might seem like a negative point towards the vendors.  But the reality is that most people have a hard enough time understanding the basic subset of BPMN, let alone something as complex as a “non-interrupting parallel multiple start event”.  For those of you just tuning in, this would mean that I have a generic shape acting as a filter for a bunch of specific events, and if this condition were to occur, launch an exceptional flow, in parallel, to deal with the problem.  Otherwise, keep working as normal.   Now see, that wasn’t so bad, was it?


For this shape to actually be useful in a diagram, you are doing one of two things; being purposefully vague (shorthand notation), or you are implying some sort of CEP (complex event processing) mechanism.   So, as I mentioned earlier, BPMN is getting simultaneously easier to use, and more complex at the same time.  Something as simple as a rope can be quite useful, but people somehow manage to hang themselves with it every day.

- Rick Geneva

BPMN 2.0 adds a lot of new concepts.  Many of these are long overdue to be added to the spec.  Others are a totally new concept.  In this post we are going to take a look at one of the long-overdue fixes to the BPMN specification; the intermediate events on the subprocess border.

In previous versions of BPMN, placing an event on the subprocess border meant that when the event was triggered, the exceptional flow would become active.  Also, this means that normal flow stops.  In the diagram below, subprocess A ceases when the timer event is triggered.  Instead, the “handle timeout” subprocess is active at that point.  In other words, subprocess A has been interrupted.

Intermediate Interrupting Event

There is another use case that BPMN 1.2 did not cover.  What if the timer event isn’t supposed to interrupt subprocess A?   Just to clarify, in the BPMN 2.0 specification, Interrupt means that the parent subprocess will end.  This is similar to a cancel, but cancellation is another concept and another shape entirely.  So it’s called interruption.  There is another use case for non-interrupting events that has long been a challenge prior to 2.0.

Interrupting and Non-Interrupting Events

Introduced in BPMN 2.0 is the concept of non-interrupting events.  They are illustrated with a dashed line instead of a solid line.

Intermediate Events (catching)

The difference is that when the event is triggered, the exceptional flow occurs in parallel to the main flow.  This means that you need to be careful how you use it.  Special attention is needed to how the two paths merge.  I recommend treating it just like any other parallel situation, using a gateway to merge.  But which gateway?  Parallel would be the obvious choice.  But remember that a parallel considers all paths to be active on the merge. This would cause a process deadlock if the event was never triggered.   Instead, the recommended merge shape is the inclusive gateway.

Intermediate Non-Interrupting Event

The gateway is used for flow control.  Without it, a potential exists that someone could misinterpret the diagram. I never recommend using implicit merge behavior because the risk is high that it might be misinterpreted.  This is especially true in this case because a small change such as a dashed line now means that we have a potential parallel situation. Most people new to BPMN won’t know this, and people not yet familiar with BPMN 2.0 might not spot this subtle, but critical difference.

Non-interrupting start event

This is where it gets complicated.  I had to read this part of the specification several times to figure out how a start event could be non-interrupting.  There are some small examples in the specification, but to fully understand what’s happening here we’ll have to talk about scopes of subprocess and many other concepts.  For now I’ll just introduce the idea and if you have any questions, please feel free to comment and I will reply.

First, let’s talk about scope.  When something occurs inside of a subprocess, the details are not available externally.   For example, if I were to assign an activity to you that requires several steps, I would use a subprocess.  Within that subprocess I don’t have access to the details of what you are currently doing, and I don’t have access to any data artifacts being created.   The subprocess is essentially functioning independently.  However, the subprocess has access to any information defined in the higher-level scope, such as a pool, or parent subprocess when subprocesses are nested.

Because of the limitations of subprocess scope, the event handler for a subprocess doesn’t actually have access to the data and activities contained within the subprocess.   Because of this problem, BPMN 2.0 introduces the non-interrupting start event.

Non-Interrupting Start Event

When a subprocess starts, non-interrupting start events inside the subprocess are activated.   When the subprocess completes, the evens are deactivated.  So there is a scope of when they are available to be triggered that is the same as the scope of the subprocess.

Also because of the subprocess scope, there is a change in accessibility of the events and the related exceptional flow.  Any activity or event on the exceptional flow can access anything from the parent scope.  In this case, everything is in the same subprocess scope, so both A and B can access the timeout handler, and likewise, the timeout handler can access both A and B.

This sort of behavior is significant because of the parallel behavior. In the example above, when the timer is triggered, a parallel flow is introduced.  The parallel flow is outside the scope of the original activity, which might cause synchronization issues. So you might to use additional events such as signals to keep things happening in the correct order.

Because the non-interrupting flow is in the same subprocess, a merging gateway is not needed. A subprocess has an implicit merge capability.  But you still have to pay attention to details.  If the timeout handler is not completed until after subprocess B, the entire subprocess will still be held back until timeout handler is completed.  This is the nearly identical behavior to the interrupting pattern shown above with the merging gateway.  The main difference is in the scope and visibility of data.

I asked the question why they didn’t just reuse the intermediate instead of the start.  I think it would have been easier to learn. It seems that many folks at OMG are very strict about using start and end events inside every subprocess.  However, the spec doesn’t explicitly say that intermediates are disallowed.  I suppose that using an intermediate as a start of a flow is just as confusing.   Prior to BPMN 2.0 I used to draw the entire pattern in yet another parent subprocess, and create any data artifacts in the higher-level parent scope so that both normal and exceptional flow would share a common scope.    So I can see where this new feature of BPMN 2.0 will be useful.  However, I recommend using text annotations so that people who read your diagrams are clear on the exact behavior you are trying to achieve.

BPMN getting complicated?

I have already received feedback based on my last few posts that BPMN is getting way too complicated.  In some ways I agree, but we also have to consider every use case and have a clear way of illustrating it.    Up until quite recently I was very hard-core on teaching every BPMN shape.  I’m now taking a different approach to process modeling.  Sometimes you need all of the shapes, and sometimes you don’t.  It also very much depends on who the audience is. For the engineering crowd, use every feature of BPMN to the maximum extent.  For the strictly business people, I suggest looking at the basic subset of BPMN and letting others worry about the complexity.  This is yet more evidence that we need a multi-tier process design.  You cannot shove everything into one process model and expect everyone to read and understand it.

I’m not making any promises of timeline yet, but I have a new book in the works that will help clarify the spec and make recommendations on which shapes to use in which situations.

Comments and questions welcome.

- Rick Geneva

This post is a continuation of the Highlights from BPMN 2.0 series.

At Last!  The long awaited changes to the numerous problems with the event based gateway.   First off, there was only one type of event based gateway in BPMN 1.0 – 1.2, and it is exclusive behavior.  Exclusive event behavior means that only one event can trigger the gateway.  Also, there was only one shape that served a dual role of start and intermediate event, yet the shape did not have any variations as the event shapes do (see Demystifying the Event Based Gateway from my previous post).

First, let’s take another look at the original Event Based Gateway from BPMN 1.0 – 1.2

Event Based Exclusive Gateway

Event Based Gateway (Exclusive, Intermediate)

The inner pentagon shape signifies multiple events.  The double circle signifies intermediate usage. Lastly, the outer diamond shape signifies a gateway.  When you combine these attributes you get a gateway that handles multiple event types.  Also note that the inner pentagon shape signifies that only one of the potentially numerous events are needed to trigger the gateway.   In many use cases of process modeling, this is less than adequate for the job.  In many cases I’ve had to create some very elaborate patterns to work around the shortcomings for this shape.  The previous BPMN 1.2 specification allowed for this shape to be used as a start or intermediate event.  With all this ambiguity you might now understand why I wrote a post called “Demystifying” the Event Based Gateway.  Still, there were many use cases that were just too complicated to understand.  So I’m quite pleased to see that BPMN 2.0 finally fixes these problems.

Event Based Start Gateway

Event Based Start (exclusive)

Adding only a slight variation of the original shape, the Event Based Exclusive Start Gateway (that’s a mouthful of words) uses the start event (single circle) instead of the intermediate (double circle).   It’s used as the start event, with intermediate events to the right.  Hopefully by the time the spec is released they will allow for start events to be connected to the right of this shape.   But either way it works for me.  This saves me at least 10 minutes of explanation every time this topic comes up in one of my training classes.

Event Based Inclusive

Event Based (Inclusive, Start)

Event Based (Inclusive, intermediate)

This is where the BPMN 2.0 spec gets interesting.  There has long been a use case where you need to receive multiple events to trigger a process to start or to continue. Previously the only option was to put the event based gateway in a loop until all events have been received.  But then this caused another problem where the same event could potentially be received more than once, which is often undesirable.  In BPMN 2.0 you the new inclusive multiple event shape is introduced (discussed in more detail in a later post).  The shape is an empty plus (+) shape (white filled).  This type of event signifies that all associated events must be received before the event is triggered.  So when you put this event type inside the diamond, you then have a gateway that is only triggered when all events are received.  Note that there are both start and intermediate variations of this shape.

Next post: Event shapes in BPMN 2.0

Comments and questions much appreciated and encouraged.

- Rick Geneva

Data Artifacts

Data Artifact

The data artifact shape was introduced in BPMN 1.0 and it is used to illustrate that some type of data is associated with shapes on the diagram. The problem with this shape is that it’s too generic to be widely used.  Also, it relies on the fact that everyone can understand the abstract concept of what a data artifact actually is.  Most people I talk to see this shape as a document, but don’t initially realize that it could in fact be representing a database record.  And then there was the problem of showing if it’s just one item or many.  In the case where it is actually many items, my diagram would be cluttered by a bunch of these.

Multiplicity

Data Artifact Collection

BPMN 2.0 introduces the Data Artifact Collection object.  In general, the three bars ||| indicate multiplicity.  They are used on several shapes.  In my previous post I showed the new activity shapes with the three bars as being multiple instance.  The meaning is similar with the new data artifact collection shape.  The additional annotation on the shape indicates that there are multiple items in the collection of data artifacts.  An example could be a pile of documents.  Or it could mean that multiple database records are involved.  In the IT architecture world, when dealing with data, this could symbolize an array of data.

Input and Output

Data Artifact Input

Data Artifact Output

The arrow annotation on the data artifact shape indicates that the data is either inbound or outbound, depending on the color of the arrow.  White indicates that the data is being received.  Black indicates that the data is being sent.  Sending and receiving is always relative to the participant pool where the shape is located.  For example, sending on one pool usually means that data is receiving in the opposite pool.  But we are also seeing a departure from the notion that swimlanes are required in all diagrams.  Many diagrams are abstracted, and show the perspective of only one participant.  The sending and receiving data artifact can help to clarify diagrams drawn in this style.

BPMN 2.0 is becoming more friendly to the technical crowd.  Early in 2009 I did a presentation at AJUG (Atlanta Java Users Group).  This group is primarily for Java software programmers and enterprise data architects.  They were very interested in SOA (Service Oriented Architecture) but there was some scepticism in the crowd as to whether or not BPMN would affect the world of programming. I showed a few diagrams that actually generate executable software code, but the story was not yet convincing to some.

My opinion on this topic is that BPMN will not replace traditional programming technique, because we still have a need for doing things “the old way”.  But reinventing the wheel in programming every day is very inefficient.   Already we have good IDEs (Integrated Development Environments) that generate code based on patterns. The next logical step in evolution of the IDE is to represent something technical via a graphical icon.  UML made an attempt at doing this, but UML was not very friendly to the business community.   So now BPMN is adding some of the same concepts as in programming, but abstracted in a way that both business and IT can understand it.

The main idea behind BPM is that business and IT architecture collaborates in a common environment, using a common modeling notation, with the goal of automating and improving processes.  This often means that a business analyst will define the need for a technology to handle data.  Data systems understand input and output.  So now we have shapes that can help to create requirements for IT without having to go into diagrams of explicit messaging.   For example, we could say that a task has an output of a customer record.  Drawing the UML class diagram of a customer record is pointless at this level of abstraction because we are focusing on process flow, not data definition.  Later, IT architects can design the customer object to whatever schema is required.  The point is that we know where in the process flow that the customer object is being used.  This not only helps for gathering requirements today, but also later on when we want to change processes.

Note that both the input and outputs can have the multiplicity (three bars ||| ) notation, indicating that a collection of data is used for the input or output.

Data Source Artifact

Data Source Artifact Shape

The data artifact shape is abstract, meaning that it could represent many types of data, or even a part in a manufacturing assembly line process.  Some modeling tools have extensions with extra icon annotations that are non-standard.  I don’t suspect BPMN is going to add shapes for everything, because it would be even more difficult to get everyone to agree (this would be a spec killer).   However, there has long been a need for clarifications on diagrams concerning data that is detached (in transit) or if it’s associated with a permanent data storage location.

The Data Source Artifact shape should be familiar to most people, because it’s similar to the database shape from flowcharts.  However, there is a distinct difference in BPMN from the flowchart shape.  A data source is not only a database, but it could also represent an abstract data source, such as a hard drive where documents are stored.  In the modern information age we have many types of data stores.  Often, data stores are virtualized, existing somewhere in the could on the Internet.  But for all practical purposes the general concept is similar a database.  Just be aware that this shape doesn’t necessarily mean “database”.

The new specification is over 500 pages long, which is much more than most of us have time to digest.  Furthermore, the specification is heavily laden with XML and references to mapping BPMN to the BPEL runtime. This is quite useful for standardizing BPM systems but might be more technical than the average process modeler wants to hear about.  Over the next few posts on this blog I will be highlighting some of the most important changes, and what it means to you as a process modeler.

In this post I will describe the new BPMN 2.0 task and activity types.

Activity Category

Often in my BPMN class I have a student who asks “how can I tell if the activity is a person or a system task?”.  Prior to BPMN 2.0 the only way to tell was to look at in the lanes in the pool, if you are using this style. Otherwise you would have to use a text annotation to clarify the intent of the digram.  BPMN 2.0 adds new icon annotations to the tasks. These icons are optional, but I encourage you to use them because it brings a lot of clarity to a diagram.

BPMN 2.0 Task Shapes

For example, there is now a manual task and a human task.  The difference is that the human task is meant for a BPM system or an application such as CRM where a task can be assigned to a person.  A manual task could mean many things, all of which are outside the scope of a typical system interaction diagram.  For example, a postal worker who sorts letters, a factory worker who assembles product, or a bicycle courier who delivers a package.  Manual tasks are sometimes just as important to an organization as tasks in a BPM system.  Therefore you should model these activities, and show a clear differentiation between the two types of human activity.

Messaging

The message task is something new, and solves a problem from the previous BPMN 1.2 specification.   Often, communications are not necessarily a one-way message.    The spec allows for either a task for a message event to send and/or receive messages. Students in my classes often ask me when should a task be used, and when should it be an event.  This usually results in a half hour lesson on the semantics and style of using task vs. event.  Thankfully, the 2.0 spec helps solve this problem.  The main intent here is to use a task for blocking communication, also known as synchronous.  In Synchronous communication, the initiator must wait for a reply before continuing with the next activity in a process.  This means that the initiator has a very active role in the communication, and a task should be used instead of an event.   In BPMN 1.2 I used the intermediate message event with a two-way message.  This was somewhat against the spec, but in order to illustrate the nature of the process, it was necessary.  So now we have a shape to solve this problem.

System Activity

System tasks were always a bit of a mystery in BPMN.  Often you would see a task that simply stated it was performed by the system, or an application.  The problem is that there was no way to tell what the system is actually doing.  The usage of rules, services, and scripts is very common in a BPM system.  But without a shape to differentiate which category of activity, the reader of the BPMN diagram was left to guess.  Again, the only way around this problem was to use a text annotation.  BPMN 2.0 adds three new icon annotations to activities, which helps cut down on text, and speeds the creation and interpretation of diagrams.

The service activity is a much welcome addition because now the business analyst who creates a process diagram can easily show where services are being consumed.  IT architects can now more easily justify the usage of BPMN instead of UML for process oriented projects.  This is a tiny change, but I think it will make a giant leap forward in terms of business and IT collaboration.

Scrips or Services

Not every system task in a BPM system is a service.  In an SOA system (service oriented architecture) this might be the case, but again, not always true.  Many tasks are simple scripts, which could be JavaScript, XPath, or other languages.  Often these scripts are proprietary to the BPM system that implements them.  But to communicate in a vendor neutral way, we must use shapes that are generic.  Often a higher level diagram will specify “a system task” but gives no reference on how it should be implemented.  So now with BPMN 2.0 you have a clear differentiation of service task verses script task.

Business Rules

Rules and process work together closely in a BPM system.  Prior to BPMN 2.0 there was no clear way to illustrate a rule activity.  The condition event didn’t quite work, because a rule is not actually an event.  Rules more closely resemble services, but a rule is a very specific type of service, often maintained by business people instead of IT.  Most BPM systems have their own BRE (business rules engine) or decision table system.  The rule shape represents the execution of a business rule.  This is quite useful in process modeling when you are working in a higher level multi-tier diagram structure and you are not yet ready to show the full details of a business rule.

Multi-Instance Activities

In a previous post Ins and Outs of Process Loops I pointed out a problem in the BPMN 1.2 specification related to multi-instance process loops.  The annotations state that the activity occurs multiple times.  However the spec says that the execution could be either in parallel, or in series.  But there was no way to tell which was which unless you looked at the “properties” which is unique to the BPMN system or the modeling tool.

BPMN 2.0 Multi-Instance Activity

My advice at the time was to use a text annotation to clarify the diagram.  This has now been fixed in BPMN 2.0.  The shape on the left is the parallel execution, which means all instances will execute simultaneously.  The subprocess on the right is the serial execution, meaning that all instances will occur one following the other.    Both of these shapes describe a “for-each” behavior because there is a set number of iterations.  In contrast, “do-while” and “do-until” loop types do not have a defined limit before the activity starts.   But a for-each normally would have a set number of iterations (for x = 1 to 5…).

Note that the looping subprocess and task shapes are still valid (no changes).

Next Post:  Artifact Shapes in BPMN 2.0

- Rick Geneva