Frank's Blog

New Thesis on the Pi-Calculus and BPM 

Today I found some time to provide the Master thesis of Olaf Märker at the BPM spot: A Virtual Machine for Implementing Resources with Dynamic Behavior in the Pi-Calculus (Thesis in German).

Olaf investigated the implementation of a REST-based architecture inside a pi-calculus-based virtual machine. Inside the thesis, you find a neat introduction to Business Process Management (BPM), Service Orientation, Resource Orientation, and the pi-calculus. Afterwards, Olaf married resources and processes and discussed the architecture for a pi-calculus-based resource server. He finally implemented a virtual machine for the pi-calculus based on the ideas introduced earlier.

Olaf also provided the source code written in Ruby, but it requires a lot of additional packages, like Postgresql, plruby, and certain Ruby gems.

So, if you're interested in the future of BPM engines, I highly recommend taking a closer look!
[ view entry ] ( 3366 views ) permalink $star_image$star_image$star_image$star_image$star_image ( 3 / 4707 )
BPMN 2.0 drafts  

The BPMN 2.0 draft specifications are out for inspection (#1, #2). Yes indeed, there are two different proposals following the request for proposals from the OMG.

The first proposal comes from IBM, Oracle, SAP, and Unisys as submitters, but also IDS Scheer, Software AG, TIBCO, Intalio, etc. are listed as contributors. Interestingly, even two consultants are named: Accenture and CapGemini. This proposal is strongly based on the original specification.

The second proposal comes from Adaptive, Axway Software, EDS, Lombardi Software, MEGA International, Troux, Unisys as submitters (note Unisys twice!). Additional contributors are networks like BPM Focus or large industries such as Lockheed Martin. Their proposal strongly focuses on aligning the existing BPMN notation with the Business Process Definition Metamodel (BPDM) of the OMG.

BPMN itself now seems to be named Business Process Model and Notation instead of Business Process Modeling Notation. The change in the name also points out the major efforts of the 2.0 specifications: the definition of a sound meta-model.

In the following discussion, I focus on the highlights of the first proposal. I personally stick to that one, since it resembles the style of the existing BPMN specification and enhances it further. The second proposal, in contrast, looks more like a set of tables and figures that is hardly readable. It also doesn't seem to contain really noteworthy information beyond a meta-model for BPMN. More interestingly, of course, is the fact that most major BPM vendor stick to the first proposal.

Now, let's discuss the scope of the BPMN 2.0 draft specification (as in all following paragraphs, I consider the first proposal):

"The BPMN 2.0 specification extends the scope and capabilities of the BPMN 1.1 in several areas:
- Formalizes the execution semantics for all BPMN elements
- Defines an extensibility mechanism for both process model extensions and graphical extensions
- Refines event composition and correlation
- Extends the definition of human interactions
- Defines a choreography model
This specification also resolves known BPMN 1.1 inconsistencies and ambiguities."
(cited from the draft)

Out of scope are aspects such as
"- Definition of organizational models and resources
- Modeling of functional breakdowns
- Data and information models
- Modeling of strategy
- Business rules models"
(cited from the draft)

The major enhancements of the specification include an XML Schema-based a meta-model, support for choreographies, execution semantics, a refined BPEL-mapping, and a lot of smaller additions and fixes.

XML Schema-based meta-model

All of the BPMN elements are described in XML schema, so that a standard meta-model is provided. What is still missing---besides the headline---is a visual interchange meta-model. This will be quite useful, since otherwise the models must be auto-layouted.


An optional part of the specification introduces choreography models as a third kind of model type. The other two are orchestrations (private, abstract) and collaborations. Choreography (in terms of the specification) is "a definition of the expected behavior, basically a procedural contract, between interacting Participants. While a normal Process exists within a Pool, a Choreography exists between Pools (or Participants)". A choreography thus basically resembles an interaction view (such as Let's dance), whereas collaboration processes resemble an end-point view. I don't want to go into detail; the picture below shows an example.

The choreography consists of so-called choreography tasks, which denote a set of interacting participants. The name of the interaction is written in the center, whereas the different participants are shown at the top and the bottom (there can be more than two participants). The initiating participant is shown with a shaded background. The draft specification defines a number of rules on how the choreography tasks could be combined.

When we talk about choreographies, we also need to talk about conversations, defined in BPMN as "[a conversation] is a set of message exchanges (Message Flow) that share the same Correlation". The specification also defined several kinds of correlation (key-based, expression-based) which are closely related to BPEL. However, the section on choreographies and conversations is still quite incomplete.

Execution semantics

The BPMN now also sports informal execution semantics. The core concept here is a scope, which describes the context in which execution of an activity happens. The scope has a lifecycle with states like activated, in execution, completed, in compensation, etc. Those lifecycles are also defined for other constructs. The execution semantics itself is described in a tabular fashion for the different flow objects. Furthermore, the description directly points to the corresponding workflow patterns. What is missing, however, is a formal representation. The OR-Join, for instance, is still only described very vague. On the other hand, the informal description keeps a lot of freedom for implementers.


The BPEL-mapping now assumes the BPD to be sound, which I find a quite imprecise requirement, since BPMN doesn’t has a formal semantics based on Petri nets (where soundness is defined on): "To map a BPMN orchestration process to WS-BPEL it must be sound, that is it must contain neither a deadlock nor a lack of synchronization. A deadlock is a reachable state of the process that contains a token on some sequence flow that cannot be removed in any possible future. A lack of synchronization is a reachable state of the process where there is more than one token on some sequence flow. For further explanation of these terms, we refer to the literature."

Still, the provided BPEL-mapping is a major step forward, since it now focuses on the mapping of simple patterns instead of examples. More elaborate BPMN to BPEL mappings are left to tool vendors by stating a rather hard requirement: "The observable behavior of the target WS-BPEL process MUST match the operational semantics of the mapped BPMN process. Also, the mappings described in section 11.1 SHOULD be used where applicable".

Other enhancements

The draft specification also contains a lot of other enhancements such as multiple pool instances, markers for the different task types, collections of data objects, or extensions for human interactions (performers, owners). The specification defines an explicit extensibility model that can be used to integrate other artifacts.

The events have been extended (once more) and some of them are now available in a non-interrupting fashion. A new kind of event resembles the star trek symbol, it is used for escalation. The attached intermediate events can now also be represented as so-called event sub-processes. Those are drawn inside the surrounding process and have access to the context of the parent process.

The specification still does not define a specific data-format or query language, but XML Schema and XPath are highly recommended.

Final remarks

I personally like the draft specification pretty much. Readers familiar with the 1.1 specification will feel right home and find a lot of clarification. I also like the idea of adding a new model type, the choreographies. The key ideas of interactions are, however, difficult to explain to people used to end-point-based choreographies. Furthermore, all the difficult things like enforceability need to be considered.

The specification itself is written rather informal, with sometimes lazy use of keywords, such as activity lifecycle (do they mean an activity instance lifecycle?). I do understand that the specification is not a self-contained book on BPM, but at least they should cite the terminology they use. The same holds for the mentioned concepts like soundness or enforceability. Still, the specification is labeled draft and I suppose many things will be well polished in the final release.

Addition: Torben pointed me to three blog entries of Bruce Silver discussing the IBM et al proposal for BPMN 2.0: #1, #2, #3. Thanks Torben!
[ view entry ] ( 3742 views ) permalink $star_image$star_image$star_image$star_image$star_image ( 3 / 5141 )

Last week I attended the 6th International Conference on Business Process Management (BPM2008). In contrast to most other conferences I visited in the past, I didn't had a talk of my own. Instead, I reviewed a bunch of papers and acted as a session chair. The session chair was quite funny, since one of the presenters was unable to finish his speech in time. Indeed, right after he told me that he needed more time, he switched to a slide titled something like "violating time constraints".

The conference itself was very interesting and I met a bunch of old colleagues and yet another one of new contacts. What I found a bit disappointing was the very slow progress in the area of semantics. Nevertheless, other areas like mining or process analysis have moved ahead.

Another interesting news is the fact the you can by unlocked iPhones in Italy for as low as 500 Euro (8GB). This is especially interesting since I've read today that Amazon plans to sell unlocked iPhones in Germany for 750 Euro. My suggestion: Invest the 250 savings in a nice trip (incl. flight and hotel) to Milano. But be warned that a beer costs about 8 Euro in downtown!

Last but not least I'm giving you some impressions:

The Banca Popolare di Milano welcomed us right at the airport.

The building at the Politecnico di Milano where the conference took place.

The crowd of attendees during a break.

Prof. Weske from the HPI, Potsdam presented the web-based modeling tool Oryx.

Paul Harmon, Executive Editor and Founder of gave an interesting keynote.

Milano has a large castle in the center of the city.

A downtown view.

Torben, a colleague of mine, Jan, and myself in the underground.

[ view entry ] ( 3017 views ) permalink $star_image$star_image$star_image$star_image$star_image ( 3.1 / 4451 )
Still alive 

Yes, it's time for me to give a ping that I'm still alive. In addition to my job transition to inubit AG, I also moved to a new apartment. To get a bit out of the theoretical thoughts, I assembled the IKEA kitchen together with my brother---85 flat boxes and more than 600 kilogram in weight. That took quite some time and should be a good excuse.

But now I'm back into business---semantics this time. While semantic (web) has been claimed to be the next big thing(tm) for some time now, the excitement has settled. While some might claim that it's dead at all, I think some important preconditions have matured in the meantime. Most of it can be found at the Semantic Web Activity Homepage of the W3C.

In particular, the Resource Description Framework (RDF) and its variants such as RDFS (schema) and RDFA (annotations), SPARQL as a query language for RDF, and the Web Ontology Language (OWL) provide a number of interesting technologies to really integrate semantics into products. I'm not talking about the blue from the sky, but rather about simple, pragmatic things like data mappings or business rules that are connected to business processes and organigrams via ontologies.

An important step is the integration of an RDF database into Oracle 11g. It's not that I personally like to spend sooo much money, but it means that there's a professional, performance optimized RDF store available.

Last but not least, I'm still working on bringing you an updated introduction to the Business Process Modeling Notation (BPMN). It will be based on a chapter of a technical report that I wrote some years ago, but covers BPMN 1.1. In the meantime you can take a look at the old report here.
[ view entry ] ( 3744 views ) permalink $star_image$star_image$star_image$star_image$star_image ( 3 / 274 )
BPMN 1.1 stencils available 

I recently updated the BPMN stencils for OmniGraffle according to version 1.1 of the OMG specification: BPMN 1.1 stencils.

The major difference to the previous release is the differentiation between catching and throwing events. All start events "catch" something, whereas all end events "throw" something. The intermediate events have been split into catching and throwing ones. Hence, some kinds of events, such as send, are now delivered in four different flavours. Throwing events are visually distinguished via black/white contrasts.

Another interesting addition is the introduction of a signal event. On page 46 of the specification, it is promoted as: "A BPMN Signal is similar to a signal flare that shot into the sky for anyone who might be interested to notice and then react. Thus, there is a source of the Signal, but no specific intended target.". It would be very interesting to see possible implementations of this kind of event. As usual, the specification leaves a lot of questions for research papers. Consider for instance this BPMN 1.1 BDP:

Can you intuitively understand its semantics?

UPDATE (Feb 23, 2008): I couldn't stop Alexander from creating BPMN 1.1 stencils for Visio 2003. They can also be found here: BPMN 1.1 stencils. Thanks for providing the stencils!
[ view entry ] ( 3226 views ) permalink $star_image$star_image$star_image$star_image$star_image ( 3 / 3473 )

<<First <Back | 1 | 2 | 3 | 4 | 5 | 6 | 7 | Next> Last>>