VOSibilities

This time on CTO Tuesdays, the BPMS podcast, we discuss what persistence of state offers process developers and BPM users. Michael Rowely, host of the podcast and CTO at Active Endpoints discusses what persistence is, how it works and what the potential performance costs might be.

We hope you enjoy this podcast. We’d love to hear your feedback on the series. Just email us or leave a comment here.

Remember: sign up for next week’s CTO Tuesdays here. We will be expanding on persistence to talk about BPMS support for long-running transactions.

 CTO Tuesdays #16: The state of BPMS state: persistence for process [50:18m]: Download (35)

 

 CTO Tuesdays #16: The state of BPMS state: persistence for process [50:17m]: Play Now | Play in Popup | Download (36)
 CTO Tuesdays #16: The state of BPMS state: persistence for process [50:22m]: Download (10)

In this episode of CTO Tuesdays (our 15th!), Active Endpoints CTO Michael Rowley discusses an elegant way of bridging the world of BPEL and the Java world. Then, after the technical presentation, Rowley discusses in the Q&A how, when and why process developers might want to use Java in their processes and warns against “speaking BPEL with an accent.”

There are three formats of the webinar attached to this post. For iTunes and iPod touch/iPhone users, an .m4v is available. A Flash file that can be streamed from the blog and/or downloaded is attached and a Windows Media 9 .wmv is also available.

Please remember to register for next week’s CTO Tuesdays at http://www.activevos.com/ctot

 CTO Tuesdays #15: Using Java with business processes [36:51m]: Download (83)

 

 CTO Tuesdays #15: Using Java with business processes [37:00m]: Play Now | Play in Popup | Download (130)
 CTO Tuesdays #15: Using Java with business processes [37:00m]: Download (37)

Attached to this post is a replay of a webinar we recently presented with our UK partner, T-Impact. T-Impact has deep expertise in BPM in industries like telecom. In this webinar, they detail their approach to BPM and how they use ActiveVOS to deliver process applications for their clients.

There are three formats attached to this post. First, an iPod touch/iPhone-formatted .m4v. We also have a Flash file that can be streamed from the blog and a Windows Media 9-encoded .wmv.

 VOSibilities podcast #45: An introduction to T-Impact [65:25m]: Download (65)

 

 VOSibilities podcast #45: An introduction to T-Impact [65:23m]: Play Now | Play in Popup | Download (49)
 VOSibilities podcast #45: An introduction to T-Impact [65:30m]: Download (15)

OK, I know…the title “preventing problems through static analysis” doesn’t exactly make you want to spend 40 minutes watching the replay of episode #14 of our weekly tech talk on BPMS technology.

But you’d be missing a really interesting and, dare I say it, fun topic. Trust me.

This week Michael Rowley tackles bugs in BPMSs. Bugs are just a part of life when creating business applications. But what about when you are creating process applications using a model-based BPMS? What happens then? How does the BPMS help you identify — even prevent and eliminate — bugs? Watch this episode to find out how standards like BPMN 2.0 and BPEL work together to help make designing and executing process applications more error-free.

As always, we have three formats of the podcast posted. There’s an iPod touch/iPhone .m4v; a Flash file that can be streamed from the blog and a Windows Media 9 .wmv.

 CTO Tuesdays #14: Preventing problems through static analysis of business processes [37:12m]: Download (89)

 

 CTO Tuesdays #14: Preventing problems through static analysis of business processes [37:10m]: Play Now | Play in Popup | Download (69)
 CTO Tuesdays #14: Preventing problems through static analysis of business processes [37:17m]: Download (48)

On this episode of CTO Tuesdays, we explore an important concept in software modeling: structured vs. unstructured modelers. Examples of both types are compared and contrasted. Also, the ActiveVOS BPMN 2.0 modeler, which blends the best of both types of modelers is demonstrated.

Three versions of the webinar are attached to this post: an iPod-formatted .m4v file, a Flash .flv file and a Windows Media 9-formatted .wmv.

 CTO Tuesdays #11: Structured and unstructured BPMN modeling [46:13m]: Download (179)

 

 CTO Tuesdays #11: Structured and unstructured BPMN modeling [46:11m]: Play Now | Play in Popup | Download (177)
 CTO Tuesdays #11: Structured and unstructured BPMN modeling [46:14m]: Download (109)

Every Wednesday at noon ET, 17:00 UTC, we present a live webinar followed by a Q&A with our product manager, Mike Moniz, that takes a look at the features of ActiveVOS BPMS. You can always register for the upcoming webinar here.

However, we realize that this is a very inconvenient time for people in Asia-Pacific and some other time zones. So, we occasionally record the most recent webinar and post it to the blog. Attached to this post are three versions of the same recording. One, a .m4v file, is intended for iPod touch/iPhone users and is also available in our podcast feed. Second is a Flash .flv file (which can also be played directly on the blog). Finally, there’s an Windows Media 9-encoded .wmv. These files are large, because the webinar lasted over an hour. But the content is worth the download time.

 VOSibilities podcast #40: ActiveVOS 7 demonstration [77:31m]: Download (357)

 

 VOSibilities podcast #40: ActiveVOS 7 demonstration: Play Now | Play in Popup | Download (210)
 VOSibilities podcast #40: ActiveVOS 7 demonstration [75:07m]: Download (128)

CTO Tuesdays is back for 2010!

In our first episode of the new year, Active Endpoints CTO Michael Rowley covers some basic theory of how complex event processing (CEP) works and makes the case for integrating a CEP engine directly into the BPM engine. Topics covered include the Event Processing Language (EPL), time windows as a method of correlating disparate events and event streams. In short, a fascinating — and accessible — introduction to a hot technical topic.

We have attached several formats of the webinar replay to this post. First, for iTunes subscribers, we have a .m4v file, perfect for taking along on your iPod. RSS feed subscribers will automatically receive this file. Also, there’s a .flv file which can be played directly on the blog (click where it says “click here” to play it). Also, we have attached a Windows Media 9-encoded .wmv file. Finally, the slides Michael presented are attached as a .pdf.

Be sure to join us live every Tuesday at noon ET, 9am PT, 17:00 UTC for a new topic. You can always register for the upcoming CTO Tuesdays webinar at http://www.activevos.com/ctot. Replays are usually posted here on our blog within 48 hours.

We have an exciting agenda of upcoming episodes, and later in the first part of Q1, we hope to guest CTOs join us for their perspectives on technical topics. We hope you will join us live each week.

 CTO Tuesdays #9: BPM as an event source for CEP [42:59m]: Download (188)

 

 CTO Tuesdays #9: BPM as an event source for CEP [43:00m]: Play Now | Play in Popup | Download (1)
 CTO Tuesdays #9: BPM as an event source for CEP [43:15m]: Download (103)
 CTO Tuesdays #9: BPM as an event source for CEP: Download (97)

In the last quarter of 2009, ActiveVOS sales grew rapidly. Details are in the attached press release.

 ActiveVOS Experiences Rapid Sales Growth in Q4 2009: Download (370)

As those of you who follow us know, we’re very proud of the fact that ActiveVOS is built from the ground up on standards. We strongly believe that standards support is the entry price for any BPMS that hopes to change the way process applications are built and deployed.

Now, I am pleased to report that OASIS has announced that the WS-BPEL Extension for People (also known by its alliterative shorthand name, BPEL4People) 1.1 specification is available for public review. In addition, the companion specification, WS-HumanTask 1.1, is also available for public review. ActiveVOS 7 implements both WS-HumanTask and BPEL4People.

In short, these two standards marry automated processing with a vastly updated and more intelligent approach to human workflow that (finally!) makes including people in complex processes as easy as including any system task.

Consider the graphic above. Prior to WS-HumanTask (and BPEL4People), creating human tasks usually required interaction with a proprietary workflow system that didn’t necessarily integrate easily with the rest of the application architecture:

One of the motivations of WS-HumanTask was an increasingly important need to support the ability to allow any application to create human tasks in a service-oriented manner. Human tasks had traditionally been created by tightly-coupled workflow management systems (WFMS). In such environments the workflow management system managed the entirety of a task’s lifecycle, an approach that did not allow the means to directly affect a task’s lifecycle outside of the workflow management environment (other than for a human to actually carry out the task). Particularly significant was an inability to allow applications to create a human task in such tightly coupled environments.

This graphic neatly shows how these new standards separate — and standardize — the work items from the processing of those items. All in all, a huge step forward for a new generation of process apps.

When you do take a look at the specs, I hope you’ll notice the level of commitment Active Endpoints has made to developing and finalizing these standards. Two of our technical leaders, Luc Clément and Michael Rowley, are listed as editors for the drafts. They are helping make a lasting contribution to BPM through their efforts to bring these standards to market, in partnership with the other members of the OASIS Technical Committee.

Attached to this post is a reply of the December 8, 2009 edition of CTO Tuesdays. CTOT is a weekly webinar presented by Active Endpoints CTO Michael Rowley which presents a technical topic of interest to BPM users. CTOT discusses the “how” and “why” of technologies like BPMN and BPEL at a detailed technical level and is of interest to enterprise architects, developers and managers who want to understand the latest in BPM technology.

This episode takes a look at how it is possible to meld the “Wild West” control flow of BPMN 2.0 with the more buttoned-down control flow of BPEL. Rowley gives an example of a BPEL extension that effectively marries these two standards in a way that preserves the best of both BPMN modeling and BPEL execution.

There are two versions of the webinar replay file attached. First is an iPod-formatted .m4v. Also available is a Windows Media 9-encoded .wmv file.

You can always register for the upcoming CTO Tuesdays webinar at http://www.activevos.com/ctot. Registration is free. Access replays on the Wednesday following the webinar at http://www.ctotuesdays.com or via RSS feed at http://www.ctotuesdays.com/feed.

Be sure to join us next Tuesday, December 15, 2009 at noon ET, 17:00 UTC, 9am PT for a very special CTO Tuesdays in which Michael Rowley will deliver an introduction to BPMN 2.0. If you are interested in BPM and BPMS technology, you won’t want to miss this episode.

 CTO Tuesdays #7: Adding Looping Links to BPEL [45:01m]: Download (385)
 CTO Tuesdays #7: Adding Looping Links to BPEL [45:01m]: Download (248)

Frequent visitors to our blog (and we hope you become one) will have already that we are in the middle of a fascinating discussion on the question of execution engines. Now, Rob Barry of searchSOA.com has weighed in with this post.

We welcome your comments and feedback on this topic.

Also, we would also like to invite you to our weekly webinar CTO Tuesdays. Every Tuesday at noon ET, 17:00 UTC, Active Endpoints CTO Michael Rowley discusses a single technical topic in 30 minutes, followed by a Q&A from the audience. In the recent past, we’ve covered topics like the BPMN 2.0 diamond control flow and engine-managed execution. Our most recent webinar delved into the the issues of dead path detection in BPEL and how to model in BPMN 2.0 to avoid duplicate activity execution.

You can always find the replays of the webinars on this blog in the “CTO Tuesdays” category (RSS feed here). Registration for the next CTO Tuesdays webinar is always available here.

I am very pleased to post a recording of what I personally think was the most interesting CTO Tuesdays talk we’ve had yet. This time, Active Endpoints CTO Michael Rowley discussed BPMN 2.0 and BPEL control flows, pointing out the “trap doors” in BPMN 2.0 notation that can, for example, lead to unintended simultaneous downstream process execution and how BPEL (still using BPMN 2.0 notation) can effectively prevent hard-to-understand and -debug process applications in a BPMS.

CTO Tuesdays has been getting great feedback from our growing audience, and I’d like to offer this week’s episode as a good example of why. The discussion of BPMN 2.0 and BPEL flows is something you might not find elsewhere, delivered in an objective way and surrounded by stimulating questions and discussion with attendees. I hope you will join us every Tuesday at 17:00 GMT and participate as well. You can register at http://www.activevos.com/ctot. The replays are always available at http://www.ctotuesdays.com or via our RSS feed at http://www.ctotuesdays.com/feed

 CTO Tuesdays #6: Diamond patterns in BPEL and BPMN [51:17m]: Download (375)
 CTO Tuesdays #6: Diamond patterns in BPEL and BPMN [51:17m]: Download (254)

Bruce Silver saw my previous post on the simplicity of BPMN vs. BPEL for execution and wondered: “Are we still debating this?”

Still?

The BPMN 2.0 spec just went to beta in August and no vendor yet has an implementation of the new BPMN 2.0 execution language. So at this point the debate is just getting started. We can only compare what exists (BPMN 2.0 with BPEL execution) with the theoretical idea of a product that will someday implement the new BPMN 2.0 execution language.

At that point we will be able to get a real side-by-side comparison. Until that time, we have to guard against “shiny-new-thing syndrome,” where the newly envisioned technology gets to paint a wonderful picture looking toward the horizon, while actual working technology has to compete against that vision bearing the stains that come from living where the rubber meets the road.  Although, in this case, even the horizon envisioned by the BPMN 2.0 execution language is tainted by some pretty scary-looking smoke.

Bruce dismissed my assertion that BPMN 2.0 on top of BPEL is simpler than the new BPMN 2.0 execution language with the following:

Simpler for whom?  When you sort it all out, he’s actually saying BPEL is simpler for an engine vendor because it doesn’t have overlapping or alternative constructs like BPMN does.  No one would argue with that, but who cares?  No engine vendor is going to support every possible BPMN 2.0 element and attribute called out in the metamodel.  And I’m not saying just in the first release.  Not ever.  In that sense, BPMN 2.0 is not a self-contained execution language like BPEL is.

We disagree. Because we’ve actually built an execution engine, we know that it is actually pretty easy to implement alternative overlapping language constructs. This debate about simplicity isn’t about what a vendor can build — it’s about what the ultimate impact of that engine technology is on the user who designs and deploys processes on that engine.

My concern is for the poor person who is trying to figure out what is going wrong with a process that occasionally gets stuck. Forward progress for a process that uses the BPMN 2.0 execution language depends on a complex interplay between a huge number of constructs: event handlers, correlation mechanisms, data-flow with optional and required data, and token-based control flow that has to account for multiple tokens flowing simultaneously on a single sequence flow.

The problem with a language that is large and complex is that it is hard to have any confidence that what you’ve created will always work the way that you expect it to in production, especially when you can only test a small subset of the exponential number of possible execution scenarios.

Bruce’s admission that “BPMN is not a self-contained execution language” is noteworthy and I hope people pay close attention to it. Why do people care about standards for the languages that they use for their software? The answer is portability – primarily portability of skills but also portability of code and interoperability of tools. Basically, they are looking for an ecosystem around the language.

I love the fact that portability of skills will be enhanced by the standardization of BPMN as a notation, but for all of the constructs that are necessary to get the thing to actually execute, it seems like there are two choices: use BPEL, which is (despite assertions to the contrary) quite portable, or use some vendor’s subset/interpretation of the new BPMN 2.0 execution language. By “interpretation” I mean that even strict conformance to BPMN 2.0 admits incredible levels of freedom that are counterproductive to the creation of a language ecosystem. The most egregious example of this is the fact that the type system is pluggable. Few things are more important in a language than the type system, and yet BPMN 2.0 allows vendors to choose their own.

Bruce’s attack on the use of BPEL with BPMN rests on the assumption that: “BPEL is inherently block oriented, like a computer program, while BPMN is inherently graph oriented, like a flowchart.” Actually, BPEL supports both styles (although with some caveats). Here is a process built using ActiveVOS that is standard BPEL:

Doesn’t this look like a flow chart to you?

The one caveat that BPEL put on this style is that the loops have to be nested. This is where I agree with Bruce – without any extensions, BPEL does have an issue with “interleaved loops.” From my experience, interleaved loops are not the most common case, but if you do have a process where interleaved loops are the most natural way to represent it, what do you do? You have two choices: 1) with the use of variables, you can always rework the graph so that the loops aren’t interleaved; or, 2) you can use an extension to BPEL that removes the looping links restriction. This is an extension that is supported by both Active Endpoints and IBM and does away this nagging issue in the mapping between BPMN and BPEL. And it does this without thowing the entire language out the window and starting from scratch to make a bigger, more complex language.

We are pleased to present a recording of a webinar originally delivered on November 19, 2009 entitled Modeling Process Applications with BPMN 2.0. The webinar features Forrester Research Principal Analyst Jeffrey Hammond who delivers a talk called Balancing the Costs and Benefits of Software Modeling.

Active Endpoints CTO Michael Rowley then demonstrates using a BPMN 2.0 modeler to create executable BPEL processes.

A panel with Jeffrey and Michael follows the presentations.

Attached to this post are three files. An iPod-encoded .m4v file, a Windows Media 9-encoded file and a PDF of the slides that Jeffrey and Michael presented.

 VOSibilities podcast #39: Modeling process applications with BPMN 2.0 [80:03m]: Download (385)
 VOSibilities podcast #39: Modeling process applications with BPMN 2.0 [80:03m]: Download (4387)
 VOSibilities podcast #39: Modeling process applications with BPMN 2.0: Download (317)

BPEL is complex and BPMN is simple, right? After all, BPMN has a nice graphical notation. The BPEL standard only specifies what the language looks like in XML. That alone ought to be enough claim the prize for BPMN.

However, what if you use BPMN’s notation for a process but use BPEL for the executable representation? This removes the graphical vs. XML distinction and can “hide” the non-graphical BPEL as represented in XML. You end up with a BPMN model everyone can understand and a BPEL model your computers can execute. It’s like the two sides of a coin: there are different pictures on each side, but the coin itself is always both sides at once.

However the question of which is simpler gets more complicated when you also consider that the new BPMN 2.0 specification includes hundreds of constructs in its meta-model that have no graphical representation. Now, which is simpler, BPMN with BPEL or BPMN with the new BPMN 2.0 execution language? What may seem obvious (BPMN with BPMN 2.0 execution) isn’t the slam-dunk choice many people might expect it to be.

BPMN 2.0 has two different — but equal — compliance points for execution: BPEL Process Execution Conformance and Process Execution Conformance. This means that BPMN 2.0 standardizes the use of BPEL as the execution language for BPMN, but it also offers the option of making BPMN executable by using new constructs that have been added to the BPMN notation specifically to support execution. These new constructs depend on the execution semantics that have been defined for almost everything in BPMN.

So, which is simpler? Believe it or not, using BPMN with BPEL execution is dramatically simpler than trying to execute processes using the new BPMN 2.0 execution language. I know this sounds counter-intuitive, so I will justify it in this post and a series of follow-up posts on the same subject.

Before I get into the details of why I believe BPMN with BPEL is better, a little history might help clarify the question. There are some factors that caused the BPMN 2.0 standard to eventually become more complex than BPEL. (I know, I know, BPEL has the reputation of being far too complex…but hear me out.)

BPMN was designed to be a language for communicating from one person to another, not from a person to a machine. Languages used for human communication have a natural, and appropriate, tendancy to grow. Whenever people find that they frequently need to convey something that is awkward to express with their current vocabulary, they invent a new word. English, which is especially amenable to such growth, surpassed one million words last year. Just consider “unfriend” or “netbook,”  new words to express new ideas.

The same is true for graphical modeling languages. Look at UML (Universal Modeling Language). It started as the unification of three fairly simple graphical notations (best known by their respective primary inventors: Rumbaugh, Coad & Yourdan, and Grady Booch). Once they unified their modeling languages and people started using them in earnest, they grew larger and larger, with new diagrams and new elements on those diagrams with each successive version. Sure there was always overlap in what could be expressed by different diagrams or different elements, but in each case, there were situations where one was more natural to the reader than the other. The fact that different constructs have imprecise overlapping meanings is of little concern in a language meant for people, since people are comfortable with choosing among a variety of ways of expressing the same thing, each with their own nuances and connotations.

But while notation creep is a useful way of expanding spoken languages or graphical notations, it is not such a good thing for a language that must be directly executable on a computer.

That’s because it is always a problem to take such a large language and give it formal executable semantics. The problem usually isn’t with a lack of rigor in the definition of any one construct. The problem is with the exponential number of combinations of those constructs.

Good programming languages typically add new fundamental primitives very cautiously. Consider how much hard preparatory work was done in the Java community before Java introduced generics into the language, or the hand wringing that is gripping that community as they grapple with the addition of closures to the language. The way it typically works is that some eminently-respectable, highly-credentialed expert (like Neal Gafter, in the case of closures) will make a seemingly very well-thought-out proposal that describes how the new construct will simplify the lives of so many programmers. Then another equally eminent expert (like Josh Bloch, in this case) will find unintended consequences of the new construct when it is used in combination with other things in the language.

That was just for one language feature. The BPMN 2.0 execution language has dozens of features that have never really been used together in an execution language. For example, the BPMN 2.0 execution not only has a variety of ways of handing the control flow for multiple incoming sequence flows, activities also can’t execute until all of the required inputs from one of the activities input datasets has become available. In other words, it has a fairly complex data flow model intertwined with its control flow model.

Another example is message correlation. BPEL has, in the past, been criticized for the complexity of its approach to correlation, but BPMN has two different correlation mechanisms. Key-based correlation is basically equivalent to BPEL’s correlation mechanism, although the standard has invented all new terminology for the various components. It then defines a new concept of context-based correlation. Rather than trying to convince you that it is complex, I’ll just include the complete explanation of it from the BPMN 2.0 specification (yes, in a 500-page specification, there are no examples or additional explanations for these concepts):

In context-based correlation, the Process context (i.e., its Data Objects and Properties) may dynamically influence the matching criterion. That is, a CorrelationKey may be complemented by a Process-specific CorrelationSubscription. A CorrelationSubscription aggregates as many CorrelationProperty-Bindings as there are CorrelationProperties in the CorrelationKey. A CorrelationPropertyBinding relates to a specific CorrelationProperty and also links to a Formal-Expression which denotes a dynamic extraction rule atop the Process context. At runtime, the Correlation-Key instance for a particular Conversation is populated (and dynamically updated) from the Process context using these FormalExpressions. In that sense, changes in the Process context may alter the correlation condition.

Confused yet? Are you wondering not just why BPMN 2.0 needed to define and redefine an important concept like message correlation, but also wondering how, precisely, to implement BPMN correlation?

These are just a couple of the ways that BPMN’s new execution language is more complex that using BPMN with BPEL. BPEL is now a known commodity. It’s widely implemented. Many production applications are running BPEL today. There are many people with experience with it and the concepts in the language are well understood. With BPMN 2.0, it now has a standardized notation, so there is no need to work with a new language that is a big bag of language constructs whose interactions have never been exercised together.