BPM Arrives Into Puberty

Bruce Silver is in a real interesting discussion with Marlon Dumas. They are discussing how to synchronize the analysis model of a business process with the executable implementation of a business process.

In my opinion, most BPM Suite products are still in childhood or kindergarten, even when they may have many bells and whistles. The root cause is that most BPM products still pursue the goal of letting non technical business create executable software. The idea is that with a graphical tool, non technical business analists can graphical design a process that is executable on a BPM System. <synical>In general, it's simply not a good idea to put software, produced by a non-technical person into production.</synical> The more realistic goal is that BPM tools try to improve the communication between non technical business analyst and developers and support the development cycle of that type of software.

I have been saying for a long time that analysis and implementation cannot be unified. So it's nice to see that leading industry experts like Bruce and Marlon are coming to the same conclusions. Although they still have different ideas about the implementation parts of the equation, at least, we all seem to be acknowledging the necessary separation between analysis models and executable models of business processes:

"No one is talking about removing IT from the BPM lifecycle. In fact I even agree with your 3 roles, although I would describe their function slightly differently. The business analyst creates process models in BPMN. The solution architect (IT) makes model activities and gateways executable by configuring them via point-click dialogs and wizards (no code). The developer creates business services using Java, BPEL or whatever, which can also be bound to model activities to make them executable. The developer may be working in the SOA tool, while the business analyst and solution architect are using the BPMS."

The part where I see different is the conversions between the analysis model and the executable developer model. After an analysis model is translated into an executable process, there should be only 1 single executable process. That executable process can still be seen by the non technical people in read only mode. Consider this a projection, where the non technical view hides the the implementation details like transaction demarcations and only shows the graphical part and the business level properties and textual descriptions.

I don't think that roundtripping between the analysis model in BPMN and the executable model BPEL is feasible. It would be similar to maintaining a separate UML class diagram for the analysis of a domain model and for the implementation model. That is in practice simply not done. In my opinion, the goal should be that the executable process languages impose the least possible restrictions to make an analysis model executable.

That is the problem of using BPEL for BPM. People have started to realize that BPEL didn't deliver on all its promises. When its used as a service orchestration language to script new services as a function of other services, I didn't hear many complaints yet. But when BPEL was used for Business Process Management, that's when I heard a lot of complaints. It imposes too many restrictions and hence it's hard for an analyst that produced an BPMN analysis model to recognize the process after it has been translated to BPEL. Other languages like jPDL and XPDL are much better suited to make analysis processes executable without touching the graphical view. For one because those languages are graph based. And in the case of jPDL, an extra capability is Actions, which allow developers to add pieces of programming logic to the execution of a process without changing the diagram.

So when we (the BPM industry) would abandon the goal to let the analysts create executable software and acknowledge that, even in BPM, analysis models are different from executable implementations, then it would be a clear sign that we're moving from childhood into puberty :-)

If I recall correctly from this presentation, Neal Ford made a similar comment in general about Domain Specific Languages at his keynote in TSS Barcelona. The idea was that DSL's are there to create languages that make sense to non technical people.

JavaPolis Sold Out

JavaPolis sold out completely. It's hot cause you can hear about hot Java technologies from the source. The moments I'm looking forward to are a mix of solid traditions and fresh ideas.

The solid tradition is the Belgian beer tap at the JBoss booth. Imagine that! Not only do you get our software for free, but even our beer. I'm still thinking on how we can do something special this year at our booth. Probably Bela Ban's beerathlon, can serve as inspiration. A beerathlon is a race where you have to run 7 kilometers and on the way drink a pint at every pub. Maybe we can do some kind of coding competition. You have to drink a pint before you get the next failing test, which you have to make succesful faster then your competitor. It would be nice if we could include extra beers if you generated too many failing attempts.

As a teaser for the people that were too late with registration, I'll point out my highlights :-)

The fresh idea I'm looking forward to is the unconference. It's a very informal and unprepared way of getting together with your peers to talk about a certain topic. It should be a great way to meet new people and learn different perspectives.

Also, I'm looking forward to the introduction of Parleys.com V2. Parleys is of course nice for those who can't come to the conference itself. But it has a potential to change the way we educate ourselves in this fast paced industry.

Another fresh idea is the Tools in Action track. It really boosts the value of the first two university days. For those that don't know yet, the university days have typically longer talks of 3 hours with a break inbetween. That way it's possible to cover topics a bit deeper then in the typical conference session. But the new Tools track, all kinds of development tools will be showcased on half an hour. Definitely check out RichFaces/Exadel/JSFUnit and Ivy.

SEAM in Action is another talk that I think is going to be great. I saw Peter Hilton give this presentation in Rotterdam last month and he did an excellent job of explaining how to get started with SEAM in very simple terms.

Hope to see you all next week in Antwerp !

Even Microsoft People Use jBPM

As Hannibal would say: "I love it when a plan comes together". With jBPM being a platform for process languages, we never really fitted into the general accepted approach to Model Driven Architecture (MDA). While we do share many of the same goals like creating a better communication between business people and developers. We always believed that generating code from models was not the challenge. Instead,we always saw integrating the different languages in IDE tooling plugins as the real challenge. Now it seems that strategy is starting to pay off.

Ferran Rodenas gives a very good description of Visual studio and Domain Specific Language (DSL) tools. He's one of the few that can mix and match Microsoft with Java and other technologies. What's nice to see is that he opted for a modified version of our graphical jPDL eclipse designer in favor of a "solution based on DSL tools".

I think this really hits a potential problem with the current generation of Language Workbenches. They focus on building tools on top of a grammar. But more important and more difficult is the integration between all the different Domain Specific Languages (DSL) and general purpose programming languages. For example, think of a jPDL workflow process that refers to your class as a command. Then it would be really helpful if the class renaming refactoring propagated to the process. I'm not sure for all of them, but languages workbenches seem to be focussed more on building new languages and less on integrating the editors that result from that work.

For now, that is why we anticipate that the choice of the actually IDE technology platform (like eclipse) will be much more relevant then the choice of a language workbench. And that's why we keep on focussing to make the jBPM designer reusable and tweakable for all these kind of use cases.

Workflow In Java *Is* Sexy !

Ever since Marc Fleury started to wiggle with the foundations of the software industry, most people know that open source software doesn't just fall out of the sky. A good idea is not enough. It takes passionate people who believe they can make a difference. A project may start out as a hobby, but combining a day time job with after hours hobby rarely is sustainable for a longer period of time. That is in summary the idea behind Professional Open Source.

With the JBoss jBPM project, we are now having a kind of a luxury problem: The rate at which we can hire people from our community is greater then the number of contributors that join the project. Last night I talked about it to Stephan Janssen, the BeJUG chairman. Stephan suggested that maybe workflow is not sexy compared to hot technologies like Rich Internet Application (RIA) technologies and scripting languages.

That reminded me that BPM and orchestration still have a bad reputation in the developer community. Looking at all the other workflow technologies out there, I can't really argue with that perception. But in case of JBoss jBPM, it should be fairly easy to to show that our project is steaming hot and sexy! Especially when looking forward to what is coming in the next major version.

I'll start with the nittypittylittlelightest form of workflow ever and then build up to pure play BPM product features. In essence, the core of JBoss jBPM is a simple Java library to define and execute state machines. That is called the Process Virtual Machine. This already enables the simplest form of workflow in plain Java like this:

ProcessDefinition processDefinition = new ProcessFactory()
 .initial().behaviour(new WaitState())
   .transition().to("a")
 .node("a").behaviour(new SomeAutomaticActivity())
   .transition().to("b")
 .node("b").behaviour(new SomeHumanTask())
   .transition().to("c")
 .node("c").behaviour(new WaitState())
 .processDefinition();

Execution execution = processDefinition.startExecution();

What is really cool and sexy about our new PVM is that we have extracted the programming model for the nodes in a workflow in a NodeBehaviour interface. The NodeBehaviour interface looks something like this

public interface NodeBehaviour {

 /** called when an execution arrives in a node. */
 void execute(ExecutionController execution);

 /** called when an execution, positioned in this node
 * receives an external trigger. */
 void signal(ExecutionController execution, String signal);
}

With this API it becomes childsplay to implement any kind of state machine behaviour for your specific use case. Furthermore, you'll be able to create custom extensions to process languages like jPDL, BPEL or XPDL this way.

At the next level, XML parsing is added. I admit, this is the least sexy of all, but the point I'll make is that the XML parsing is also pluggable for each node. That is still a little bit sexy, no ? Each process language needs it's own parser. The parsers we build for the process languages are based on JAXP so there are no extra library dependencies introduced outside of the Java 5 JVM. Each process language will have it's parser that walks the main structure of the process XML document. Then to parse the nodes, a Binding interface is used like this:

public interface Binding {
 Object parse(Element element, Parse parse, Parser parser);
}

A node type now is made up of the runtime behaviour and the binding parser.

(btw, I hope that the language workbenches become mature soon on the Java platform. Instead of XML, I would much rather use a custom syntax language that has the look and feel of the Java programming language. But currently, that turns out to be harder for the graphical designer and the node pluggability)

Next is persistence. The sexy thing about our persistence is that in the PVM we'll support all forms of process persistence. As you saw above, processes can be created and executed without any relation to persistence.

Alternatively, you can read the process from an XML resource and save the state in your domain model object like for example an Order. A hibernate custom type that we supply takes care of converting the Execution field value into a state string, corresponding to the current node name. This is limited to a single path of execution, but it avoids the complete workflow database. The state is actually saved into your own domain model.

In case you do want the full workflow database to store the processes and executions, then we can easily link between your domain model objects (like e.g. an Order, Account or Customer) persisted with Hibernate and the process Execution.

For the process languages we support out of the box, we'll have hibernate mappings that store the process definitions and executions. But another sexy thing about the new PVM persistence is that you'll be able to add a new node with parser and complex configuration properties and keep the database schema stable.

Do you see it coming ? We're working towards easy customization of process languages. Development teams will rarely build a complete process language from scratch. But with the new PVM, they'll be able to take for example jPDL and extend it with their own custom node types very easily, without any deployment hassle.

Supporting this whole range of persistence options is IMO the most sexy of all! This is the main reason why BPM, workflow, orchestration and pageflow now all have different runtime engines. So with the new PVM, we'll be able to support the full deployment axis. This includes the different forms of persistence in both standard java and enterprise java. Apart from the deployment axis, there is the process language axis. So that gives some background into why this multitude of languages and runtime engines exist and how we're going to consolidate that.

Then on top of the XML and persistence, we're building out the usual BPM tooling like designers, web & administration consoles, business activity monitoring and so on. Since those tools are typically the only interface offered to developers, I can understand the bad reputation that BPM still has with developers. I hope that this post showed you that workflow can be sexy also for Java developers.

I can understand that in 5 years from now, workflow systems will be as boring as database systems. But in the meantime, building out the concepts and techniques behind those indispensable systems is ultimately sexy for clever developers.

So if you're looking for a sexy project to contribute to, look no further. JBoss jBPM is it !

Unifying Processes And Rules

In "A Vision for Unified Rules and Processes", Mark Proctor, lead of the Drools rules engine describes how he sees the further integration between rules and processes.

I believe that any company that isn't able to truly unify rules and processes into a single modelling system, how PegaSystems have done, will not be in a suitable position for the future. ... rules and processes must exist as first class citizens within the modelling and execution environment ... we need to make sure that we unify these models and allow it to go to much greater depths. Once rules and processes are fully integrated that modelling environment will benefit from any other declarative systems added, such as our plans to add Complex Event Processing (CEP) to the engine and language - this means we can have rules monitoring streams of data and triggering process milestones.

From a product point of view, I totally agree with Mark. In fact, I met him last week and I was impressed with the productization ideas they had for creating in integrated processes and rules environment.

For instance the Business Rules Management System (BRMS) manages the full lifecycle of rules from sources, over packaging to runtime deployment. The model and tooling that they have layed out would fit perfectly with jPDL processes. Futhermore, it supports both the developer use cases as well as the business user use cases. The drools vision in that respect is fully applicable to jPDL processes.

Similar for the business user test scenarios. Drools has a web UI for creating test scenarios on a business level. While this will not replace software testing based on something like JUnit, it does allow for business users to express basic scenarios. For non complex processes, this vision is also applicable to jPDL processes.

So if you look at it from a product point of view, we agree. The way I see this unification is a drools-jPDL integration is a single download that just can be unzipped to be installed. Integrated BRMS, console and designer. Drools has this approach and jPDL has the same appraoch with the suite distribution package.

But I see the componentization underneath the product quite differently. First of all I think that ruleflow should be merged with jPDL. They fit together and complement each other perfectly. I don't think that ruleflow should be a separate language from jPDL. Ruleflow could be build as a set of nodes build on top of the PVM. These nodes could be added to jPDL. Whenever you use them, you get a dependency on the drools.jar. This is just like with e.g. the beanshell based script node that we have now in jPDL.

Secondly, I don't think we need to integrate jar packages. IMO, "truly unify rules and processes" as Mark Proctor refers to, should be in the productized package that integrates jPDL (incl ruleflow) and drools. There is no need for the jars to merge in order to realize the vision as Mark Proctor describes it.

Yahoo Pipes, PVM and language-oriented programming

Paul Gallagher's blog "Pipes - Web 2.0 Wake-up Call for BPEL?" gives a very example nicely what we call a graph based execution language. And the best part is that he puts the Yahoo Pipes langauge in perspective with BPEL, paving the way for me to explain why its crucial for future workflow engines like our JBoss jBPM to support multiple process languages.

The only languages often associated with workflow, BPM and orchestration are BPEL, XPDL and BPMN. Of those, only BPEL defines exact execution semantics and hence it is called an executable process language. jPDL is another executable process langauge. Where BPEL is targetted to a web services / ESB environment, jPDL is targetted at a standard Java environment.

Similar to Java being referred to as a general purpose programming language, I refer to BPEL and jPDL as a general purpose process languages. But over the last years, with the more widespread adoption of jPDL, we get a lot of requests to create limited dialects of jPDL for specific purposes. For example approvals in a document management system or tracing of laboratorium experiments.

JBoss jBPM is designed as a platform for process languages. After we had put BPEL, jPDL and SEAM pageflow on one base framework called The Process Virtual Machine, we realized that we could build all these kind of languages on the same base technology. The componentization that we introduced supports this very well already.

As such, Yahoo Pipes are another nice example of a graphical process langauge.

Martin Fowler and Neal Ford recently introduced the notion of Language-oriented programming. The idea is to "build software around a set of domain specific languages”.
The more we realize how big the category of graph based execution languages actually is, the more excited that we get. With our new Process Virtual Machine technology underway, we are not far from building out a complete language workbench focussed only on graph based execution languages.

More concrete, based on the Process Virtual Machine we're building a complete software development kit for developing your own graph based execution language, including runtime, console and designer. You'll be able to code the runtime behaviour of process constructs in plain Java. Also included will be a mechanism to add designer forms, XML serialization and persistence of the process constructs. We see a lot of use cases for easy customization of general purpose process languages like jPDL.

Typically I don't really know how to start explaining the concept of how jBPM is becoming a language workbench for graph based execution languages. Thanks, Paul for providing this example and giving me an opportunity to explain the strategic direction of JBoss jBPM.

jBPM jPDL 3.2.2 released

jPDL is a simple workflow language targetted for the Java platform. We just released version 3.2.2, which fixes a number of bugs and minor (but crucial) enhancements. The detailed list of issues can be found in the jira changelog.

The suite and the runtime can be downloaded from sourceforge. Enjoy!

Great Book About JBoss jBPM

Last weekend I finally came around to reading "Business Process Management with JBoss jBPM". A brandnew book written by Matt Cumberlidge. It fills a gap in the jBPM offerings. Another milestone for the project.

The book targets architects, analysts and developers that want to get started with jBPM. Matt succeeded in bringing great value for all three target groups. It starts with a fresh look at the value of BPM and practical guidelines on how to start a BPM project. Installation of every required piece of software is explained in detail. Even less technical people will have no problems to get the software up and running with these very simple step by step instructions.

The ordering of chapters captures the full jBPM learning curve. After installation, a prototype business process is build in two iterations. Then, the more technical details are explained to transition from prototype to implementation. And finally a chapter on process improvement explains how the processes can be measured and analysed to find optimizations.

jBPM beginners can use this book as an easy to read tutorial to get jumpstarted with jBPM. The available documentation in jBPM itself is sometimes a bit too concise and basics are on the same level as advanced topics. Matt made a good distinction between the basics and advanced topics. The basics are explained in detail and the advanced topics are explained more briefly and referenced. It will lower the treshold for the learning jBPM significantly.

Also, I really like the structure of the book. It adds another dimension. Throughout the book, the link is made with the overall software development methodology and how BPM fits into that picture. It shows the value of BPM from the developer's point of view, which is much more interesting then the typical empty BPM promises on a management level.

Congratulations, Matt! Well done.

You can get the book at Amazon or directly at Packt publishing.

jPDL Webinar With Awsome Demo

Your last chance to register for the jPDL webinar that will include an introduction by me and a long demo by Micah Modell.

It's next Wednesday 11am EDT. Your boss is probably on holiday's while you're working hard. So it's not more then fair if you take the liberty to listen in on this cool webinar. On top fo that, you'll be impressing your boss when he gets back as you'll know the meaning behind the workflow buzzwords.

Don't miss it and register here.

Try out the new jBPM release 3.2.1 of jPDL

Ever tried a simple Java workflow engine ? This is the time to do it! Last week, we released jPDL 3.2.1. jPDL is the process language for writing statemachines in Java. jPDL is build in such a way that it supports Business Process Management (BPM), workflow and orchestration in standard as well as enterprise Java environments.

Download it from sourceforge and and check it out.

If you download and unzip the suite package, you get the full documentation, a graphical designer plugin for eclipse, the runtime engine preconfigured in a JBoss app server (jPDL also runs without an app server or on any other app server), and a web console. All preconfigured so that you don't have a hassle to get started and evaluate the process language.

Is BPMN The Solution For All Process Languages ?

I would like to start this freely available answer with "It depends...", the typical answer of expensive consultants :)

BPMN is clearly a great language for non tech analysts. But the approach that BPMN has to map BPMN to all the executable process languages is sometimes misinterpreted. The Process Virtual Machine describes how multiple process languages can be supported by one single runtime engine.

The text below started off as an explanation of how we can replicate that approach in a graphical process designer. But it also contains a no-so-traditional-but-nonetheless-realistic view on how business analysts and developers can jointly work together on the automation of business processes.

A component model for nodes
On the tooling end, the base framework should be able to display nodes and transitions. Like e.g. in BPMN, but ignore the decorations and the properties for a minute.

Then a process construct should be a plugin. The plugin contributes the following to the base plugin:

- shape: the tool could predefine the 4 BPMN shapes, but a node-plugin should be able to self-define it's shape with its own figure.

- configuration: the plugin should contribute a properties form to enter the configuration information for that node type. to enable this, the internal model of the process graph must have a dynamic set of properties.

- constraints: the plugin should be able to specify constraints like: this type of node can only have 1 outgoing transition. or: outgoing transitions from this node type can only be connected with node type z.

- decorations: which decorations are supported. maybe this could be done with icons so that apart from the BPMN decorations, node implementors can supply a graphical colourful icon.

The whole idea is that you should separate all the node type specifics from the basic process designer container.

Guidance for process languages
BPMN recognizes multiple process languages. But it has suggested a problematic approach to handle that.

BPMN defines a mechanism of bidirectional mappings from BPMN to executable process languages. This suggests that you could model in BPMN and then translate to any executable language. IMO, that is a unidirectional translation.

When an (non-tech) analyst starts to model a process, this has to be done in free modelling language like BPMN, visio or IDS Scheer's ARIS notation. Of course, those models only contain graphical information intended for human-to-human communication and they are not executable.

Executable processes exists of graphical structure and technical details to make a process executable. The graphical picture is the common language between analysts and developers. An executable process is human to system communication in the sense that it specifies to the computer system what it has to do.

The translation from a modelling process (graph only) to an executable process (graph and tech details) is a big one. First of all, the analyst may have modelled steps in the model that are not to be automated by the computer system. Second, the developer makes a selection as to which process language best fits his technical environment. It will most likely not be possible to keep the original process model as-is for the executable process because of the executable language specific constraints.

After the translation to an executable process, analyst and developers have a common language in the graphical part of the executable process. But now, the analyst lost his freedom to change anything he wants since that implies software changes.

This is why I come to the following conclusion: A process designer tool should support each process language individually. BPMN is one of those languages/notation. This is the free modelling tool. Then BPMN diagram can be converted (1 time translation) to executable process languages like BPEL, XPDL and jPDL. This translation should generate a new file.

For modelling an XPDL process for instance, the designer tool should present itself as a straight XPDL editor. All the parts that XPDL specifies should be exposed by the tool with their proper names (properties and node types). But where XPDL is undefined (like in the graphical notation), that is where BPMN can be used to complement. Same story for other executable process languages.

There is a big change going on lately

"There is a big change going on lately. A year ago, all BPM and workflow was centered around BPEL and around web service orchestration. And that was the way to go, that was the single process language that's going to make it. At that time we were already long time working on our multi-language approach."

After noisy attempts at the moscone, inbetween ringing phones of the labs crew, an eager housecleaning lady and an apologising hotel manager we managed to shoot an interview in San Fransisco at JavaOne this year.

New JBoss User Group Starts in Rotterdam

A brandnew JBUG Benelux is launched by Lunatech in Rotterdam, The Netherlands next Friday, June 8th. I'll be speaking about jPDL, but more importantly, there will be pizza's ! It will also be a great way to meet new collegue nerd developers or see how others use JBoss. Check out all the details on Peter Hilton's blog and drop him an email if you intent to come. I hope to meet you there.

Therapy for BPM

To start the therapy for the Business Process Management (BPM) identity crisis, we'll have to go back to its childhood. Why did we start messing with process languages in the first place ? Ah, yes! While all tools can draw process diagrams, the real reason was that we couldn't express process languages in traditional programming languages because they represent a sequence of instructions for the computer system. They don't have support for wait states.

To further expose the pathological state of BPM, I always use the DB metaphore: When I say relational DB, most of this audience thinks tables, columns, primary keys, foreign key references, SQL and so on. Every self respecting developer knows the concepts of this technology. For a technology that is a very sane state to be in. But in BPM, nobody knows the the concepts of state machines that can be used for business processes or what it means to execute those. Every engine has got its own execution model that looks like, but is not completely the same as the next engine. Yet we are creating process language proposals in abundance. It's like proposing query languages without knowing the difference between relational-, object-, hierarchical and object databases.

Can't be that difficult, right ? Afterall, it's just a state machine that we're adding to all programming language capabilities, no ?

Well, not quite so simple. State machines are used in a variety of ways. Different features and functions are added to improve support for those features. Also, there are different environments. E.g. a a service orchestration language like BPEL looks very different from a Java workflow language like jPDL. That creates a whole lot of combinations for which you can build dedicated process languages.

For therapy, the roots are state machines. All of those process languages have some form of state machine in there. That is because traditional programming doesn't have support for wait states (see many of my earlier blog posts).

Now let's reflect on this in real zen style. Close your eyes, but keep reading. Many flavours of process languages... many different features... but all represent some form of state machine.

After one of those sessions, it struck me that I should first learn how to walk before trying to run. Learning about the state machine basics is much more effective then trying to understand all the flavours of the different process languages. And once you get the state machine basics, it will be much easier to learn a new specific flavour of a process language if you need one.

Since I couldn't find good state machine concepts and terminology in the context of executable software, I just wrote it myself. I called it The Process Virtual Machine and a summary of that full article has been published at OnJava.

The Process Virtual Machine was my therapy for BPM. Every developer and BPM-er should read it and have an opinion on it. Feel free to let go and just share it as a comment on this post.

Workflow with jPDL at JavaOne

I'll be at JavaOne to talk about jPDL, the workflow and BPM language for the Java platform. The talk will be on Tuesday from at 3:20 PM in Esplanade 304/306. You don't want to miss it so put it in your agenda.

I'm always interested to meet new people. Ping me at tom dot baeyens at jboss dot com in case you want have a chat while I'm in SFO.

The Schizophrenic Nature Of BPM

Business Process Management (BPM) has always had this disturbing identity crisis. Here's an interesting discussion between industry titans in which several symptoms can be seen:

Keith Swenson: The tipping point for XPDL (see also the comments)
Keith Swenson: Are apples more useful than oranges
Bruce Silver: The real issues with XPDL, BPEL and BPMN
Keith Swenson: The diagram is the meaning
Bruce Silver: Diagrams, models, and Metamodels... Oh My!

I want to put this discussion into a perspective so that you can see why I think they don't speak the same language. This post will try to establish a realistic view on how process modelling and executability can be combined.

On the one hand, BPM is all about letting non-technical business analysts create diagram models in all freedom describing how people and systems work together. On the other hand, the promise of BPM is that you can drop these models into a BPM System and a piece of working software is the magical result. This duality is already indicated by Phil Ayres in the comments: "...and very simply put, both standards live up to their names: XPDL - Process definition language; BPEL - process execution language." According to me, that is just an indication of the fundamental schizofrenic state BPM is in currently.

If you think about it, these two goals are in fact very distinct; Business Process Analysis (BPA) means creating a description of how people and systems work together. It's describing what is observed. On the other hand, creating an executable process means specifying how the BPM engine should behave to support this process. This comes down to specifying what a computer system should do and in that respect, it is no different from traditional programming. It needs the same kind of deterministic accuracy and completeness. The language is different, but the exact behaviour of a software system is defined in an executable business process.

There is only 1 kind of product in the BPM industry that can give complete modelling freedom to the business analyst. Those are the drawing tools that only have a graphical notation, but no runtime engine part. Think products like IDS Scheer's ARIS suite and Visio. But the bulk of the products in the BPM space have a runtime engine part.

Most of these products with a runtime engine component have suffered badly from the schizofrenic nature of BPM. They try to hide the technical part as much as possible, while the remainder of this post will argue that a technical aspect is an intrinsic part of executable process languages and their process engines.

We have been telling it for quite a while now: The graphical model of a process should be separated conceptually from the technical details. An executable process is most often a combination of the two. The following picture shows how we envision the process as a combination of the graphical information and the technical details that make it executable.


Non technical business analysts can look at the graphical part only. Developers will manage the technical details so that the whole business process becomes executable on a BPM engine. In practice, the line between analyst and developer is a bit more blurry. Depending on their technical skills, analysts might already provide some technical details they know. But for the sake of this post, I want to highlight the dual nature of BPM and that's why I put analysts and developers in very distinct roles.

So this results in a situation where the business people can understand a view upon the software artifact that could represent a business process. At the same time, that process actually runs on the BPM engine in production. We also think it's very likely that business analysts come up with the initial diagram for the process to be developed. But we don't believe that in general, non technical people will be able to write both parts of the process. That would imply that non technical people would specify the mission critical parts of your enterprise's IT infrastructure. This thought is as ridiculous as it is scary. Regrettably, it is still preached by many of the BPM vendors today.

This point of view clearly shows that there is a technical aspect to making business processes executable. A good BPM engine should *not* try to make the technical people redundant (which is an agreeable but unreachable goal) , but instead it should facilitate and ease the collaboration between business analysts and technical people.

In software development, Domain Specific Languages (DSL) are described as limited computer languages for a specific purpose. Todays software is full of such languages that have to be combined with a framework. Think any XML language in a typical Java development project: ORM mapping, IoC configuration information, deployment descriptors, IoC bean wiring XML files. Looking at the technical aspect of BPM, an executable process language is just another DSL. Therefor, BPM engines should fit right into todays architectures of software development. And this should not be interpreted as "oh,... it's just a library for developers without any focus on the 'Business' in BPM". On the contrary.

Also in the engines, a technical aspect is often overlooked. A process engine as a monolithic black box is already useful in some scenarios. But a process engine becomes usable in a much broader set use cases when it can be easily embedded into an application. How easy can the workflow engine tables be integrated in my application database ? How easy can test scenarios for processes be written and executed ? How much library dependencies does the engine have ? How easy can the transactions of the workflow engine be embedded in my own application transactions ? All these questions become very relevant when you want to deploy a process engine other then in the black box mode.

The conclusion is that technical aspects of workflow and BPM engines do matter. It's not because business people are involved somewhere in the creation of processes that process languages or process engines cannot have a technical side. When product vendors try to hide those technical aspects, they end up with schizofrenic Frankenstein monsters. So beware. Cause you don't want such a creature to end up in the core of your IT infrastructure, now do you ?

BPEL Compared To jPDL

Michael Neale of the drools team is giving a Talk on JBoss jBPM for the Canberra User Group. He mentioned my <sarcasm>*looooove*</sarcasm> for BPEL and asked me the pitch. In my reply, I explained that I don't think BPEL is bad, but that you have to know when to use it and when other alternatives are more appropriate. I think my reply would be interesting for more people, so I share it here.

BPEL is a process language designed to work on in a web services environment because it is based on WSDL. WSDL could potentially map to java beans as well, but it naturally maps to web services, while WSDL doesn't map naturally to java beans.

Deploying a BPEL process leads to publishing of a web service (a WSDL service to be exact), that is your interface to the process. Internally in a bpel process, the process variables are XML snippets (or xsd basic types). BPEL has some control flow constructs and a construct to invoke a WSDL service. So in essense, BPEL is in fact a language to script a new web service as a function of other web services.

BPEL has a receive construct, which means wait here until this message is received over the published service. This implies that the overall execution behaves as a wait state. Consequently, long running (spanning multiple server side transactions with long periods inbetween) processes can be expressed in BPEL.

Expressing long running processes (== support for wait states) is a requirement to model typical business processes in a language. Business processes like handling an insurance claim take a long time and involve several requests to/transactions on the server. So to support business processes, the runtime engine needs to behave as a kind of state machine. While BPEL has the wait state feature, which is one of the requirements for executing business processes, the assumption of an all-web-services-world makes it hard to integrate BPEL based business processes with every day software development in e.g. Java.

The thing that nobody seems to understand is that you can build state machines in Java as well. And typically much more simple then in web services technologies. That is where jPDL fits in. In jPDL the interface is a Java API and the process variables are POJO's. So this language embeds far better in a Java project.

Conclusion is not that BPEL is bad. The conclusion is that you need to select the process language that fits with the environment in which you are working and with the requirements you have. Use BPEL if you want to script new web services as a function of other web services in a mostly webservices environment. Use jPDL if you need statemachine capabilities in a Java environment. In both technologies it is possible to make the bridge to the other side, but that is of course requires some mappings and translations. So it is all a matter of selecting your process language based on the main development environment.

My Previous Blog

My previous blog can be found at the JBoss Matrix.