VOSibilities

Attached to this post is a recording of a webinar originally delivered on February 3, 2010 that features Dennis Callaghan, principle analyst, enterprise software, The 451 Group. The topic was Where does BPM go now? A business and technology perspective. Callaghan reviews the consolidation in the BPM marketplace and discusses his predictions of the near-term future for BPM. This is coupled with a demonstration of the ActiveVOS BPMS, which is used to illustrate what is possible in a pure-play BPMS today.

Three versions of the podcast are attached. An iPod touch/iPhone-formatted .m4v, a Flash file that can be downloaded and/or played from the blog and a Windows Media 9-formatted .wmv

 VOSibilities podcast #42: Where does BPM go now? A business and technology perspective [65:57m]: Download (33)

 

 VOSibilities podcast #42: Where does BPM go now? A business and technology perspective [65:55m]: Play Now | Play in Popup | Download (62)
 VOSibilities podcast #42: Where does BPM go now? A business and technology perspective [66:02m]: Download (12)

This episode of CTO Tuesdays features our first guest CTO. John Newton, CTO and chairman of Alfresco Software, joins Michael Rowley to discuss how enterprise content management systems (ECM) can be combined with business process management systems (BPMS) to create compelling end-to-end business applications. ActiveVOS and Alfresco implement the new Content Management Interoperability Standard (CMIS), enabling these two important technologies to work together to produce a new generation of business process applications.

Attached to this post are three versions of the webinar. First is an iPod-formatted .m4v file. Second, a Flash .flv. Third, we have attached a Windows Media 9-encoded .wmv. Finally, we have also attached a PDF of the presentation John delivered.

We hope you enjoy this episode of CTO Tuesdays. We hope, over time, to have additional guest CTOs on the podcast to talk about complementary technologies. And we’d love to hear your suggestions for topics as well as your comments and feedback.

 CTO Tuesdays #12: ECM and BPMS Working Together [47:22m]: Download (68)

 

 CTO Tuesdays #12: ECM and BPMS Working Together: Play Now | Play in Popup | Download (80)
 CTO Tuesdays #12: ECM and BPMS Working Together [47:28m]: Download (15)
 CTO Tuesdays #12: ECM and BPMS Working Together: Download (28)

We are very pleased to announce that John Newton, CTO of Alfresco Software, will be our guest on CTO Tuesdays this week. Details are in the media advisory attached to this post. Register for the webinar at http://www.activevos.com/ctot

 Alfresco CTO to present on "CTO Tuesdays": Download (52)

We are pleased to make available a recording of a webinar originally presented on January 13, 2010 with Andy Berner of IBM and Michael Rowley of Active Endpoints. This webinar shows how business process modeling suites (BPMS) can be used with requirements gathering tools to support the entire lifecycle of a business process.

There are three formats available. First, an iPod-formatted .m4v. Second, a Flash .flv file which can be streamed directly from the blog or downloaded. Third, a Windows Media 9-encoded .wmv. The .wmv file is about 55MB in size; the other two are about 96MB.

Please feel free to request an evaluation of ActiveVOS to begin to apply what you see and learn in this webinar to your business processes.

 VOSibilities podcast #41: ActiveVOS 7 and IBM Rational Requirements Composer [75:46m]: Download (64)

 

 VOSibilities podcast #41: ActiveVOS 7 and IBM Rational Requirements Composer: Play Now | Play in Popup | Download (53)
 VOSibilities podcast #41: ActiveVOS 7 and IBM Rational Requirements Composer [75:46m]: Download (24)

This week, Michael Rowley presented “Using requirements gathering tools with a BPMS,” an interesting look at the relationship — and the possibilities — of using model-based BPMSs with requirements gathering tools.

We have posted three formats of the webinar replay. First is an iPod-formatted .m4v file. Also, a Flash file that can be played from the blog and/or downloaded. Finally, we have included a Windows Media 9-encoded .wmv file.

Please join us every week at noon ET, 9am PT and 17:00 GMT for CTO Tuesdays.

 CTO Tuesday #10 Using requirements gathering tools with a BPMS [40:59m]: Download (84)

 

 CTO Tuesday #10 Using requirements gathering tools with a BPMS [41:00m]: Play Now | Play in Popup | Download (78)
 CTO Tuesday #10 Using requirements gathering tools with a BPMS [41:01m]: Download (54)

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 (127)

 

 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 (41)
 CTO Tuesdays #9: BPM as an event source for CEP: Download (57)

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 (248)

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 (328)
 CTO Tuesdays #7: Adding Looping Links to BPEL [45:01m]: Download (202)

Attached to this post is a news release announcing availability of a new case study describing how ActiveVOS has been used to improve information classification in a government security agency.

 ActiveVOS BPMS Automates Information Sharing for Government Security Agency: Download (234)

Attached to this post is Upside Research’s implementation study of ActiveVOS at a North American government security agency. While the agency is not named for security reasons, the agency’s staff participated in the gathering of data for this report. The report documents the power of BPM to automate and enhance core processes — in this case, classification of information coming into and going out of the agency.

 ActiveVOS government security agency case study: Download (334)

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.

In episode #5 of our continuing webinar series on technical topics of interest to developers, architects and business analysts working with SOA-based business process management systems (BPMS), Dr. Michael Rowley, CTO, Active Endpoints compares and contrasts two different styles of message correlation. In episode #4, Michael outlined message correlation as defined by the BPEL standard. In this episode, Michael illustrates a different style of correlation, which relies on the execution engine to correlate incoming messages to specific processes. Michael also describes when and how each style (BPEL-managed vs. engine-managed) can be used and notes some pros and cons for each style.

There are two attached versions of the webinar replay (an iPod-formatted .m4v and a DivX-encoded .avi). As always, you can register for the next episode of CTO Tuesdays at http://www.activevos.com/ctot. We look forward to your comments, suggestions and feedback.

 CTO Tuesdays #5: Engine-managed correlation [30:10m]: Download (325)
 CTO Tuesdays #5: Engine-managed correlation [30:10m]: Download (265)

I have good news and bad news. The good news is that we (finally) have replays of episode #4 of CTO Tuesdays, our regular weekly webinar on BPM topics of interest to process designers and developers. The subject of this webinar is message correlation, an interesting topic that details how systems match up running processes and the messages for those running processes.

The bad news is that due to a technical issue, the audio for the host, our own Sonal Rajan, wasn’t recorded. This is shame because at the end of each topic, we always have an open Q&A session on the current topic to amplify the technical discussion. Unfortunately, these replays won’t have that Q&A because there’s no audio for the moderator. However, the actual presentation about message correlation was recorded just fine.

In the two attached versions of the webinar replay (an iPod-formatted .m4v and a DivX-encoded .avi), I have edited most of the silent introduction and the Q&A.

As always, you can register for the next episode of CTO Tuesdays at http://www.activevos.com/ctot.

 CTO Tuesdays #4: Message correlation [35:53m]: Download (367)
 CTO Tuesdays #4: Message correlation [35:53m]: Download (372)

In the latest episode of Dana Gardner’s BriefingsDirect Analyst Insight series, Dana covers the concept of business commerce clouds. Panelists commenting on this topic include: Tony Baer of Ovum, Brad Shimmin of Current Analysis, Jason Bloomberg of ZapThink and independent IT analysts Sandy Kemsley and JP Morgenthal. Have a listen to this podcast for these experts’ perspectives on SaaS, SOA, BPM, reliability, security and community as related to business commerce clouds.

In addition to the audio file, we have also posted a PDF transcript of the podcast, for your convenience.

 

 BriefingsDirect Analyst Insights Podcas [50:31m]: Play Now | Play in Popup | Download (1597)
 BriefingsDirect Analyst Insights Podcast : Download (156)

BPMN 2.0 and WS-BPEL 2.0 are the two most important standards for BPM today. But why are there two? Can’t you just care about BPEL or just care about BPMN? In fact, both standards matter and the two should be used together. To back that up, I have to convince you both that BPEL needs BPMN and that BPMN needs BPEL. In today’s post, I’ll concentrate on the first: why BPEL needs BPMN.

First, lets assume that you are convinced of the value of BPEL. You see that it is a great high-level language for creating business processes and orchestrating services. Its service-centric approach is simpler and better for long-term manageability and reuse than other approaches to business process management. It is an accepted OASIS standard with multiple vendor implementations, so investments in BPEL processes are not tied to a single vendor and you can find people who already know the language without having to train them from scratch.

But if you are convinced you want BPEL, why should you care about BPMN? There are two main reasons:

1) To get the value of a standard notation;

2) To improve collaboration with a wide variety of stakeholders in the process, since BPMN is a significant simplification over existing notations used for BPEL.

When WS-BPEL 2.0 was standardized, the OASIS Technical Committee chose not to standardize a graphical notation for it. This was unfortunate, since no one creates a business process by writing BPEL in XML, which is the only standardized representation. Every vendor, and every BPEL developer, creates their processes using a graphical representation, but that representation is different for every tool.

And the notations used by these tools haven’t really been very good. They typically provide a one-to-one correspondence between control flow constructs in BPEL and things on the canvas. However, if you use the BPMN notation, it shows a notation that can mostly be understood without any knowledge of BPEL or even BPMN for that matter (as long as the labels are chosen carefully).

Let me make both of these points with the help of a trivial process example. Take a look at the BPMN representation of a process that I’ll call the “Question” process.

(Click on each image to see a larger version)

It is trivial to follow what is going on, especially if you know the standard notation. You can’t tell by looking at this diagram, but I’ve used two different BPEL mechanisms for getting to the next activity. I use a BPEL link to get from “Receive Q” to the first diamond (the beginning of the BPEL if statement). I use a BPEL sequence to get from the second diamond (the end of the if) to the “Record Answer” activity.

The user who is looking at the graphical representation of the process doesn’t need to know about the distinction between these two mechanisms, so the diagram doesn’t show a difference. The developer may want to know about the difference, so ActiveVOS highlights them differently on mouse-over and shows them differently in the “process outline view”, but that isn’t really important for today’s discussion.

What is important is how different the process is represented in different tools due to the fact that no notation had been standardized. I’ll show what this process looks like in three different BPEL process designers.

Here is how ActiveVOS would represent this process in previous versions of the product (or using the optional “classic” style in 7.0):

Here is how the Eclipse BPEL Designer represents it:

And, here is how the designer for Oracle’s BPEL Process Manager represents it:

In all three of these representations, each of the paths through the if statement are represented by a bounding box. The problem with this representation is that nested if statements can result in so many nested bounding boxes that it is hard to follow what is going on. BPMN simply has arrows through each path and the paths merge back into a single control flow at a gateway diamond.

Also notice the differences in the handling of links vs. sequences. Both ActiveVOS classic and Eclipse represent sequences with their own bounding boxes, then any arrow that is a direct child of a sequence box is known to belong to the sequence, rather than being a real link. Eclipse also draws the links in different color. The extra sequence icon and corresponding bounding box just interferes with the ability for non-technical users to follow what is going on in the process.

Oracle’s designer is odd in this respect. Sequences are not shown in a bounding box, so they don’t clutter up the control flow (a good thing in my opinion), but links aren’t shown at all! There is a link from the “Receive_Q” activity to the if statement, but there isn’t any representation of it on the diagram. It shows the “Receive_Q” and the if as if they happen in parallel. You have to look into the properties of “Receive_Q” to discover that it has an outgoing link, and further rummaging to find out where it goes.

The BPMN representation is, by far, the easiest version of this small process to understand. The process illustrates just three constructs whose representation is simpler with BPMN than with other approaches: ifs, sequences and links. The other BPEL constructs are generally as easy or easier for non-technical users to understand than previous approaches.

But, as valuable as the improvement in readability may be, the greater value that BPMN brings to be BPEL is probably consistency. Having different tools represent similar constructs in such different ways is detrimental to one of the key values in having a standard: skills portability. With a common notation, people will be able to carry their knowledge of how to understand and work with standards-based business processes between vendor tools. It will also create a greater incentive for people to learn these technologies and for schools to teach them. After all, people aren’t usually to thrilled about investing a lot of energy into learning proprietary technologies, and no school really wants to be teaching proprietary technologies.