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.

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

VOSibilities podcast #45: An introduction to T-Impact

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.

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

CTO Tuesdays #14: Preventing problems through static analysis of business processes

But what is the state of BPMN 2.0 usage in the real world? This webinar, originally broadcast on February 18, 2010, offers some answers.

The bottom line? BPMN 2.0 usage is gaining traction — it’s becoming the modeling notation of choice for everything from documentation to creating executable process applications. If you are interested in what BPMN can do for you, you will want to watch this webinar replay to learn more about BPMN and how people are using it today. Watch Sandy Kemsley show you how not to create BPMN models as she parades models from the “BPMN modeling hall of shame.” And you can also watch as Michael Rowley shows you how to make BPMN executable with BPEL. At the end of the webinar is a very stimulating Q&A in which Kemsley and Rowley discuss the future of the BPMN specification and answer attendees’ questions.

A variety of formats are attached to this post, including a Flash format that can be streamed from the blog. Also, the slides Sandy and Michael presented are available in PDF form.

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

VOSibilities podcast #44: The state of BPMN: an update from the real world

That’s how we feel about business process management systems (BPMS) and enterprise content management systems (ECM). These two important technologies are made for each other.

If you have an important business process you want to automate, it’s likely to have people, processes and documents that all need to work together. And, you are likely to want everything to work together based on open, industry-wide standards. We’d go so far as to say, it’s an absolute requirement that the BPMS and ECM be totally based on standards.

That’s what Alfresco and ActiveVOS offer together. The best capabilities; the most openness.

Watch the replay of this webinar — and the absolutely brilliant demo of ActiveVOS BPMS and Alfresco ECM working together — to see how you can quickly, easily and compatibly produce better process applications for your organization.

There are three formats attached to this post, along with a PDF of the slides presented in the webinar. First is an iPod touch/iPhone-formatted .m4v. Second, a Flash .flv file that can be downloaded or played from the blog. Third, a Windows Media 9-encoded .wmv is available.

We hope you enjoy this introduction to combining BPM and ECM technologies.

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

VOSibilities podcast #43: Combining BPMS and ECM for better process applications

XPDL 2.1 is already supported by many tools, including ActiveVOS, so extending XPDL to support the new constructs in BPMN 2.0 will provide the fastest path for most vendors to achieve some level of interoperability of their BPMN 2.0 models.

Nonetheless, I’ve found that most people who have asked Active Endpoints about model import/export formats have been people who have the wrong idea of how to work with a BPMS. These are people who are trying to hold on to their old waterfall methodology for building software, where there are separate tools for building process models during analysis from the development tools that are later used to create the software. In that world, there is a constant need to translate back and forth between the tools as changes may occur on either side.

And there’s the rub. The roundtrip translation always loses so much information that the effort to keep the separate representations in sync and accurate outweighs the value of using the automatic export / import functionality. Eventually, changes made on the analysis side get redone on the implementation side by hand, and vice versa.

The right way to work is to let the BPMS own the model. Yes, you may want to allow early requirements gathering to use simpler modeling tools, but those tend to be fairly informal flow charts anyway. Once you get involved in real modeling you should use the modeling capabilities of your BPMS. By “real modeling”, I mean that you are at the stage where the precise semantics of the notation used is important, since it is going to drive the actual semantics of the resulting software.

In the early phases, the process models are diagrams where the labels on the diagram are what really matter. For example, the arrows coming out of an activity might formally imply that both directions can be followed at once, but the labels on the arrows have labels that imply that one one of them will happen. This is OK during the early stages of modeling, since it is another human who is going to be reading the model and they can guess what was really meant (or they can ask, if they aren’t sure).

Once you are ready to do real modeling, it is time to get the BPMS involved. That way the process model you create will go the rest of the way through the lifecycle of the project without need for translation, much less round-trip translation. How you get from the informal stage to the formal stage of process modeling isn’t really all that important. Yes, you can use XPDL 2.1, but it doesn’t really even matter if you have to redraw it from scratch. Drawing it is very fast in a capable designer like ActiveVOS, and the person doing the modeling is already going to have to be carefully considering each jot and tiddle of the original diagram to determine how to correctly model what the user really wanted to begin with.

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

The BPMS owns the model

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.

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

CTO Tuesdays #12: ECM and BPMS Working Together

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.

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

CTO Tuesdays #11: Structured and unstructured BPMN modeling

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.

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

VOSibilities podcast #41: ActiveVOS 7 and IBM Rational Requirements Composer

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.

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

VOSibilities podcast #40: ActiveVOS 7 demonstration

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.

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

CTO Tuesdays #10 Using requirements gathering tools with a BPMS

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.

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

CTO Tuesdays #9: BPM as an event source for CEP

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

ActiveVOS Experiences Rapid Sales Growth in Q4 2009

In this episode, Active Endpoints CTO Michael Rowley gives what might be the most concise, “digestable” overview of BPMN 2.0 available on the Web. If you are new to BPMN and want to see what it can do for you and your organization, this content is for you. In this webinar, Rowley discusses basic BPMN notation, including activities, events and gateways. And, in an expansive Q&A following the presentation, Rowley answers questions about the use and capabilities of BPMN.

There are four attachments contained in this post. First, an iPod-formatted .m4v recording of the webinar. This is for subscribers to the podcast in iTunes (search on “vosibilities”). Next, is a Flash .flv file which is intended to stream from the blog, though at the small size I have to limit the player to on the blog (416×312), it’s not the best experience. The .flv file itself is at 640×480, so feel free to download it if you want to play it locally. Next we have the original-sized Windows Media 9-encoded .wmv file. Finally, a PDF of the slides Rowley presented are attached.

We hope you find this content useful. You can always access the replays of CTO Tuesdays here on our blog, www.vosibilities.com in the “CTO Tuesdays” category, in our podcast on iTunes and via www.ctotuesdays.com or, for an RSS feed, www.ctotuesdays.com/feed. We’re trying to make it easy to find and use this content, so if there’s a method you prefer we haven’t accounted for, please let us know.

CTO Tuesdays will return to our every-Tuesday-at-noon-ET schedule in early January, 2010.  Next year we have some exciting additions planned, including guest appearances of CTOs from other leading technology companies. Make sure you sign up to attend every week. You can always sign up for the next episode at www.activevos.com/ctot.

Finally, in answer to a question we had in the Q&A, here’s a link to the OMG specification for BPMN 2.0. In Annex A of this document, you can find the differences between BPMN 1.2 and BPMN 2.0.

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

CTO Tuesdays #8: An Introduction to BPMN

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.

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

CTO Tuesdays #7: Adding Looping Links to BPEL

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.

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

searchSOA.com on the BPMN 2.0 with BPEL discussion

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

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

CTO Tuesdays #6: Diamond patterns in BPEL and BPMN

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.

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

BPMN 2.0 with BPEL — the debate is just starting

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.

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

VOSibilities podcast #39: Modeling process applications with BPMN 2.0

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.

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

Which is simpler: BPMN or BPEL?

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.

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

CTO Tuesdays #5: Engine-managed correlation

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.

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

CTO Tuesdays #4: Message correlation

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.

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

Why use BPMN for BPEL?

I think you will find Michael’s explanation of BPMN 2.0 event notation especially valuable.

I have attached two versions of the recorded webinar to this post. The first is an iPod-formatted .m4v. Also attached to this post is a Windows Media format .wmv file.

We have also made signing up for CTO Tuesdays and accessing the replays much easier. You can always sign up for the upcoming session of CTO Tuesdays at http://www.activevos.com/ctot. Replays are always available at http://www.ctotuesdays.com. And, an RSS feed of the replays is available at http://www.ctotuesdays.com/feed.

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

CTO Tuesdays #3: BPMN and BPEL events

Attached to this post are three files. A PDF of the slides Dr. Rowley presented, an iPod-formatted .m4v file (which requires QuickTime or iTunes to be installed) and a more-or-less standard .avi file. The .avi is the larger of the two video files.

Due to a technical error (I didn’t press “show” on GoToMeeting), the first few minutes of the video show Michael’s slides, not the ones I am discussing. Since this is just an introduction, you won’t miss anything. I’ve put those “missing” slides into the .pdf file, so you can follow along if you want to.

We had a very lively panel discussion at the end of the presentation; I hope you’ll have the time to listen to the discussion that follows the presentation.

As always, we are very interested in your feedback, comments and topic suggestions.

One more note: you can always register for the upcoming CTO Tuesdays session by visiting http://www.activevos.com/ctot. We hope you join us for next week’s webinar.

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

CTO Tuesdays #2: Introduction to WS-HumanTask

Every Tuesday, Active Endpoints’ CTO Michael Rowley, will present a topic of interest to BPM users. Our inaugural topic was an explanation of the meaning and uses of the BPMN 2.0 diamond symbol. If you are interested in learning BPMN 2.0 — or if you just want to brush up on some of the more advanced considerations in using this basic BPMN symbol — you will find this recording very instructive. Concepts are demonstrated in ActiveVOS 7’s new BPMN 2.0 modeler.

Attached to this post are two versions of the webinar: an iPod-formatted .m4v file our podcast subscribers will automatically receive and an H.264-encoded .avi file (which is much larger at about 113MB).

We welcome your input and suggestions for CTO Tuesdays. Contact us via email at editor at activevos dot com. Today, the best way to be notified of upcoming CTO Tuesdays is to be on our mailing list. And, the best way to get onto our mailing list is to download a trial of ActiveVOS. You can also register for upcoming CTO Tuesdays by clicking on the link in the right hand column of any interior page on www.activevos.com.

We are working hard on making registering for CTO Tuesdays easier. But because of the demand for education on topics like BPMN 2.0, we started the webinar series without waiting to dot all the “i’s” and cross all our “t’s.”

Update: You can now register for CTO Tuesdays by clicking the link in the right-hand column of any page on www.activevos.com except the home page. So, just navigate into the site a little and you’ll get a little reward: easy access to registration for CTO Tuesdays.

Updated update: You can now always register for the upcoming CTO Tuesdays at http://www.activevos.com/ctot.

We hope you enjoy this recording and that you will join us as your schedule permits for the live CTO Tuesdays every Tuesday at noon ET, 9am PT, 16:00 GMT (17:00 GMT after the end of US daylight savings time in November, 2009).

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

CTO Tuesdays #1: The BPMN diamond

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

Dennis Byron on ActiveVOS 7 BPM

“BPM suites that focus on business users, they don’t get technical enough,” said Alex Neihaus, VP of marketing at Active Endpoints. “They become islands of computing and sit off by themselves. And with BPMS for architects and developers, the level of cost and complexity is beyond the level of what most people are willing to undertake.”

This “third way” between the cost and complexity of stacks from Oracle and IBM and the unfulfilled promises of Lombardi and Pegasystems to integrate easily across the enterprise are why we believe we have become so popular among development teams. Looking past old buying habits and the new politics of “end user” BPM, our customers are seeking great technology at an affordable price that can be used to create integrated processes as that are themselves services.

You can read Rob’s entire blog post here.

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

SOA Talk blog covers ActiveVOS 7

As we promised in part 1 of of our discussion on the new features in the ActiveVOS 7 BPMS, we are delighted to post part 2 of a conversation among me (Alex Neihaus), Luc Clément and Michael Rowley. In this second podcast, Michael and Luc cover topics that are of interest to enterprise architects, developers and operations staff. Topics include continuous development (including support for the open-source Hudson project) and new features in the BPMN designer that improve productivity and operational enhancements.

We hope you enjoy this podcast.

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

VOSibilities podcast #38: ActiveVOS 7.0, part 2

We’re very excited to be able to post a sneak preview of the brand-new BPMN 2.0 designer that’s coming in ActiveVOS 7.0.

We’ve also posted a screenshot tour of our new ActiveVOS Central application.

We hope to have additional screenshot galleries up soon.

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

A sneak peek at BPMN 2.0 and ActiveVOS Central in ActiveVOS 7

This version is a draft of the What’s New in ActiveVOS 7.0 document. Please check back frequently for updated versions.

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

What’s New in ActiveVOS 7.0

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

Michael Rowley to present SCA at UCLA Java Users Group

I’m pleased that my recent disagreement with JP Morgenthal was noticed by Joe McKendrick, on his Service Oriented blog, and by Loraine Lawson at ITBusinessEdge. Now, having set the record straight, we can step back a little and start a more general discussion about SCA and why it’s a powerful new approach for developing applications. Loraine made a few comments in particular that got me thinking more about the value of SCA to a chief architect who is “prioritizing and rationalizing applications from an enterprise perspective.”

Once this architect has prioritized the needs of IT for the enterprise, it is critical that the architect’s development team has the right “tools” to update or create the applications that will meet those enterprise priorities. The development team also wants to improve its ability to maintain the application in the long run. I put the word “tools” in quotes in the previous sentence to emphasize the fact that I am using the word in its most general form. Your programming language is a tool. The design patterns you follow are tools. And, of course, the middleware infrastructure you use is a tool. J.P. is just wrong to assert that SCA will lock you into dependency on a vendor. There is no reason that middleware has to lock you in to a vendor any more than using a programming language locks you into a vendor, but that is only true if the middleware uses…

standards (and the right standards at that). If SCA were just some vendor’s tool that was promising great things, J.P. and everyone else would be right to be skeptical. But it isn’t proprietary, it’s a standard.

There are a few important reasons why this is important. It is always difficult to hire people who are skilled in a vendor’s proprietary technology and any application that depends on the technology is always at risk, since the vendor may choose to “improve” the technology in a direction that is retrograde for you. Or, the vendor could possibly abandon it altogether.

A good middleware standard is like a high-level language. It raises the level of abstraction that developers work in, so they can think about the actual problem being solved instead of fiddling with bits – or SOAP headers.  There are three recent standards that do exactly this: BPEL, BPMN and SCA.  BPEL is a language that is specifically designed around creating and using services, so it is also inherently middleware. Then there is BPMN, which standardizes the notation — the look of the business process on the design canvas — so that developers and non-developers alike can share an understanding of what is going on. And finally there is SCA, which allows developers to create, wire, package and deploy services without having to sweat the details of the numerous WS-* standards for every service that is created or used.  It, like high-level languages, raises the level of abstraction without significantly constraining what a developer can accomplish.

Forcing a development team to avoid recent advances in middleware today would be like having a manager in the 1970’s forcing their developers to program in assembler due to a mistrust of languages like FORTRAN. Productivity would suffer.

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

If SCA is a tool, it is a power tool

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

Butler Group reports on ActiveVOS

In a podcast we recorded last week,  Luc Clément — our product manager — mentioned in passing that we were about to post a new sample that describes in detail how to actually implement a human task in a business process.

Since we can’t post a link easily inside the podcast — and this sample is really something anyone considering a BPMS should see — I wanted to make sure to point out that the sample is now available here. If you want a trial download of ActiveVOS to walk through the sample in, please download it here.

ActiveVOS has become very popular among BPM users because it makes it easy to include human tasks in larger business processes. It’s obvious, of course, that no business process application would be complete without integrated human tasks. What’s been missing is a complete, standards-based way to combine automated and human tasks into a process as well as a standardized way to expose the work item list to real people. ActiveVOS’s standards-based implementation (using both BPEL4People and WS-Human Task) is detailed in this sample, which we recommend to anyone considering a BPM implementation.

You can work through the sample at your leisure. It’s a great way to learn how human tasks and processes work together in a modern BPMS. The sample is also a marked contrast to yesterday’s separate workflow systems which must be manually integrated with automated systems and which vary widely in the way the tasks are delivered to end users.

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

Human task, meet computer. Both of you, meet happy development team

Keith Swenson has posted this interesting list of questions to ask a BPM vendor.  I liked his emphasis on standards, since it is so important that the hard work that goes into creating business processes not be trapped in proprietary technology.  However, I think he concentrated on the wrong standard — XPDL.  If you really care about safeguarding your investment in your processes, the standard that you should care the most about is BPEL4People.

Don’t get me wrong, XPDL has its place.  ActiveVOS can both import and export XPDL version 2.1 (the latest version).   But XPDL is not a technology that will allow you to take an business process that is executable on one vendor’s BPM engine and move it to another vendor’s engine.  It just won’t work.  If you are lucky, the resulting business process diagram will look recognizable because the “abstract model” (as XPDL calls it) will import successfully.  But don’t get your hopes up about saving all the work that you did on the executable details.

The problem is not that XPDL has no place to put those executable details — it does.  It just doesn’t put enough constraints on what should go there.  There are just too many different things you can do, so no two tools do the same things.   Also, the bar for being able to say that you support XPDL 2.1 is just too low.  If a tool exports something that conforms to the XML Schema (possibly with liberal use of extensions) and import doesn’t barf on any Schema-valid input, then the tool conforms.  But don’t look for guarantees that you will see, much less be able to execute, anything reasonable.

By contrast, users of ActiveVOS have had great success in using BPEL-based business processes that were created by either IBM, Oracle or TIBCO tooling.  They have also found that the BPEL generated by ActiveVOS can be used by the tools of those other vendors.  That is real investment protection.

I do like Keith’s idea of having a list of questions for BPM vendors to help in the evaluation process.  I think the best way to organize such an evaluation is around four key areas.

Are the key BPM standards supported?

• Does the product generate executable WS-BPEL 2.0 processes?
• Can you model processes using BPMN?
• Does the product use the BPEL4People for activities that are handled by people?
• Are worklists and tasks exposed through the WS-HumanTask standard?
• Does it support the important enterprise web-service standards, such as WS-Security and WS-ReliableMessaging?
• How about non-SOAP access to services, such as JMS, REST or plain Java?
• Does the product import and export XPDL?

Does the development environment make the process developer highly productive, especially for processes that are larger than mere toys?  For some important examples, how easy is it to:

• Incorporate existing web services into a process?
• Detect changes to web service definitions and update the process accordingly?
• Define services provided by the process (including defining XML Schemas and WSDL)?
• Define new human tasks using existing data definitions (XSDs)?
• Prepare the input data for human tasks or services?
• Support services that “call back” into a running process, and specify the appropriate data to use for correlation?
• Find all uses of a variable within a large process?

An executable process is deployed software.  What support is available for ensuring and maintaining its quality?

• Is there test case generation?
• Is there test suite support?
• Is there remote debugging?
• Is there Metadata for controlling the difference between staging and deployment?
• Can you new versions without effecting existing process instances?
• Can you deploy new versions that do change existing process instances?

What can be done to a running instance?  Can you:

• See where it has been (with anotations on the process diagram)?
• View current and historical data?
• Change data?
• Skip activities?
• Single step through activities?
• Rewind execution, optionally reverting all process data to what it was?

What kind of runtime console support is there?

• Can you get reports with either operational or business information?
• Can the end user create any kind of new report and incorporate it into the runtime console?
• How powerful is the query capability to find a process instance you care about?

All of these characteristics of a BPMS will eventually be important to anyone that is creating the kind of critical business processes that will really transform a business.  Knowing the answers to these questions can help you to avoid making the wrong choice.

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

Thinking about BPM? What you should REALLY ask your BPMS vendor

You have to admit that the economic news these days has become truly frightening. In the US, joblessness has reached levels not seen in decades. Across the planet, governments are being forced to intervene in their economies in unprecedented ways.

But this isn’t a blog about economics. Instead, it’s a blog about a technology — business process management (BPM) — that allows enterprises to respond to these challenging times.

Jim Sinur of Gartner wrote this week about how customers’ perceptions of what BPM can accomplish for them today have changed from what they were just before the current economic upheaval. And to nobody’s surprise, the economic climate has pushed aside technical benefits in favor of bottom-line considerations like reducing costs and improving quality.

We have just one suggestion to add to the mix: think about saving big bucks in the BPM system itself.  Consider the costs of having to integrate multiple “stack” products to achieve a BPM application — having to build the car from a kit before you can drive it. Consider the costs of BPMN-only systems which cannot directly execute the application without being either proprietary or adding megabytes of hand-coded Java. Consider, finally, the costs of delay because your company simply cannot afford millions for a BPM system.

We like to think that ActiveVOS is the ideal product for these times: open, comprehensive, all-in-one, easy-to-learn and -deploy. But most of all, affordable. Maybe the silver lining in all this economic turmoil is that customers’ costly-is-better price prejudice with respect to BPM will dissolve on the alter of necessity and allow them to discover BPM that’s both better and less costly. That’s ActiveVOS. And it’s one reason we’ve recently displaced IBM at a giant European insurer and why we continue to gain market traction. Do yourself a favor: see if your BPM vendor posts its prices. We do, right here. We want you to know going in what a great system costs.

When your company is looking to BPM applications to save more pennies, it only makes sense that you would want to squeeze costs out of the BPM system itself. And it’s pretty clear that what Jim’s clients were thinking, too.

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

What do BPM users want?

The press release and accompanying white paper are attachments to this post.

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

Commodities Trader Trafigura Redesigns Core Systems with ActiveVOS

Details are in the press release attached below as well as in Luc’s previous pre-holiday post about the demo. Included in the press release are instructions on how you can download a customized version of the ActiveVOS demo to experiment with the application on your own machine.

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

Active Endpoints Announces New Learning Tool for Java Developers

Do you know what this logo is?  It’s the new Pepsi logo. What does Pepsi have to do with SOA?

To start off 2009 with a bang, Anne Thomas Manes has written a blog post declaring the term “SOA” dead. Like her previous post on the “failures” of SOA, this post is certain to get a lot of attention.

But a careful reading shows Ms. Manes only wants to kill the term SOA, not, of course, the technological movement which it defines and which she asserts is still critically important to improving application development.

I’ve heard this desire to make SOA a dirty word a lot lately, even inside Active Endpoints. And, as a marketing person, I recognize it for what it is: message fatigue from the avant-garde.

Like the marketing guys at Pepsi, the cognoscenti are tired of talking about SOA. They need something new, something exciting, something…effervescent to talk about. It’s not that the term SOA is dead…it’s simply boring, pedestrian.

In a startup company, the biggest marketing danger is thinking that the “world” knows what you’re saying. When you are small, the noise level around you is so high and the competition is so stiff that your message can’t ever get out unless you stick with it. But creative people don’t like repetition. They thrive on the new. So many technology startups fools themselves into thinking that “everyone knows” what they do. And they move on…into obscurity.

Like a startup company, the thought-leaders that truly believe in SOA as a way of doing things are about to abandon the term at the exact moment it becomes a mainstream, accepted way of doing things.Their need for the new — at least new terminology — threatens consolidation of the very movement they championed. (And it risks generating cynicism among thought-leaders who get frustrated by the incomplete adoption of the “latest thing.” It’s a self-fulfilling cycle: how can something be completely adopted if pundits abandon technology before the movement is consolidated?)

Incomplete adoption is possible because the companies contemplating SOA now are the middle and late adopters. They aren’t the early people who conflated an ESB with SOA. Adopters today are not bleeding-edge customers. They let someone else suffer those pangs.

ActiveVOS’s success in 2008 was, in part, because customers aren’t interested in technological debates. Instead, they wanted modern, affordable, all-in-one technology to achieve their business objectives. They don’t “debate” SOA. They simply implement it.

And in a surprising number of cases in 2008, ActiveVOS displaced or was installed alongside the SOA offerings from IBM and Oracle. Why? Because the never-ending need for “newness” in those products…uh, excuse me…”stacks”…makes them indigestible for customers looking to actually achieve something with their application portfolios. Like the pundits, many big competitors of ours keep “revising the logo,” confusing their customers and delaying consolidation of the SOA movement into the mainstream.

So, would a new term help SOA? I don’t think so…it’s like the Pepsi logo. It makes a lot of leading-edge people feel great. (“Wow, isn’t that beauuuutiful?”)  But it unnecessarily confuses large numbers of people who thought they understood what was going on and who had just begun to dip their toes into the SOA water. 

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

Giving SOA terminology a nip/tuck

‘Twas the night before New Year’s and all through the house
Not a process was broken, not even a browse.

The ActiveVOS users sat by their computers with anticipation
In hopes that the “Bring SOA Home for the Holidays” judges would like their contest submission.

When out in the judges’ office there arose such a clatter
Every Active Endpoints employee wondered what was the matter.

And what to their wondering eyes should appear
But the judges with the list of three lucky winners of some really cool Lenovo gear!

—————————————————————————————————–

I hope you enjoyed reading this little parody of “The Night Before Christmas” as much as I enjoyed writing it. Seriously, we have some good news. Because of the great response to our contest “Bring SOA Home for the Holidays,” we have extended the submission deadline to New Year’s Eve – December 31, 11:59pm.

It’s easy and fun! Download a supported 30-day trial of ActiveVOS, the world’s leading visual orchestration system, and tell us how you would use it in your SOA, BPM, BPEL or BPMN projects. Make this holiday season a winner for you and your company. Try ActiveVOS…win a Lenovo netbook! Visit www.soaholiday.com for details and contest rules.

Happy Holidays!

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

“Bring SOA Home for the Holidays” contest extended to 12/31

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

Active Endpoints Joins Web Services Test Forum

Bruce writes:

Because BPEL is more “technical” than BPMN, it is favored by developers who find nothing more annoying than business-types wanting to “collaborate” on implementation.

I disagree that developers don’t want to collaborate with their business-minded colleagues. This is the stereotype, of course, but in my experience it really hasn’t been true. The real question is whether or not business analysts and developers need to work on same model. Neither the developer nor the business analyst really wants this since they have different needs.

Bruce talks about one of these differences: business people using unstructured graph-oriented control flow vs. the structured control flow favored by developers. It’s clear why these different users would need different ways to diagram control flow.

So these difference needs dictate different representations. With the unstructured control flow, it is pretty easy to get into trouble (where “trouble” is defined as something that’s unclear at execution time) . For example, some modelers prefer to use conditional sequence flow (small diamonds on outbound transitions) rather than XOR gateways. Kieth Swenson has a good example and a couple blog posts (here and here) that discuss this. Unfortunately, with the current semantics, it is easy to get into trouble.

Think about this process model:

The business analysts might not think very hard about whether the thing could be red and blue, so at runtime it turns out that both paths could be taken and then you would end up with two simultaneous executions of “D”. That is legal, but probably not what was desired and difficult to debug.

It is the transition from unstructured to structured — as the model is handed from the business analyst to the developer — that causes these issues to surface. The developer will still use something that uses the BPMN notation, but with limitations that basically make it look structured. So yes, round trip is hurt. The developer doesn’t hand back to the modeler the same picture. It has been unwound a bit. This is a less comfortable style for the business analyst, but it’s certainly still understandable.

I don’t think Bruce disagrees with most of this thinking, because what he concludes is exactly in line with my thinking:

We need to recognize that standards for process modeling and process execution have different purposes and benefits. They should be linked, but with proper attention to those differences.

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

BPMN? BPEL? Both? What’s right for a process execution standard?

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

Dana Gardner: Active Endpoints beefs up visual orchestration system

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

SearchSOA.com: ActiveVOS “…is beginning to show dividends”

Also, there’s still time to enter the Bring SOA Home for the Holidays contest. Simply by downloading ActiveVOS and submitting your good ideas, you could win a very, very cool Lenovo netbook.

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

Active Endpoints ships ActiveVOS 6.0.2

In this webinar, Paul Fremantle, CTO of WSO2 and Mike Moniz, product manager here at Active Endpoints, describe and demonstrate SOA development tools that precisely meet today’s requirements. With the global economic situation deteriorating daily, enterprises, organizations and governments need SOA-based application development systems more than ever to be able to do more with less and respond to these challenging times. SOA is a natural response to the crisis and therefore, SOA adoption is accelerating.

Better yet, because of the cost savings and productivity SOA-based BPM systems yield, tough economic times mean that more and more organizations are looking beyond the bloatware of proprietary systems from IBM, Oracle and SAP and towards open-source and standards-based SOA systems like ActiveVOS and WSO2 ESB. In this webinar, you will see SOA software products, based on open standards like BPEL and BPMN, that are at the same time accessible, affordable and offer capabilities far beyond the piece-parts solutions from old-line legacy SOA providers,

This webinar replay even has more than a little excitement in it. At about 50 minutes, we lost the voice phone bridge. You can either skip forward about three minutes, at which time we restored the audio or you can enjoy the drama in my voice as I switch first to VoIP, then back to the phone. We do recommend that you listen to the Q&A starting at about 54 minutes as there is some very good discussion in that part of the replay.

Finally, I’ve posted multiple versions of the webinar as well as a PDF of the slides we presented. Podcast subscribers will automatically received the iPod-formatted .m4v file. This file is about 137MB in size. Also available are a Windows Media 9-encoded .wmv file at about 95MB and a DivX-encoded .avi at 423MB. When you play the .m4v file on the blog, it plays at 320×240 so it will fit on the page. But the file itself plays at 640×280 in iTunes or in QuickTime. Both the .wmv and .avi have much higher resolution and if you have the bandwidth, please feel free to download any or all of these episodes.

We hope you enjoy learning about how you can affordably develop, deploy and manage BPM applications using the latest SOA technology, and we welcome your comments.

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

VOSibilities podcast #21: ActiveVOS and the WSO2 ESB: Mainstream SOA for tough economic times

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

Active Endpoints and WSO2 to host joint webinar

In this fascinating podcast, Michael Rowley, director of strategy and technology at Active Endpoints discusses the history of how the Business Process Modeling Language (BPMN) and the Business Process Execution Language (BPEL) were unfortunately “separated” at birth. He also describes why BPMN and BPEL belong together and what the current efforts in the standards organizations working on BPMN and BPEL are doing to re-unite these two critical standards for SOA-based development.

The good news is that SOA developers are the ultimate winners of the inevitable reconciliation of BPMN and BPEL, but as Rowley describes, the reconciliation isn’t intended — and indeed shouldn’t be — a perfect union.

Rowley concludes by describing what ActiveVOS 6.0 delivers today for SOA developers who want to work with BPMN and BPEL in a single, integrated, deployable product.

We hope you enjoy this podcast, and, as always, welcome your comments on this podcast.

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

VOSibilities podcast #19: Why BPMN and BPEL were (unfortunately) separated at birth and what it means for SOA developers

A couple of weeks ago, I was asked to review a new book on creating SOA-based applications. I was surprised to be invited to review a technical book because I am pretty lightweight technically. But I was also pleased that this blog has attracted enough readership so that the publisher thought a mention here could help get the word out about this new book.

Despite my trepidation that reading the book would tax my understanding of the technology (after all, I am a marketing guy, not a developer), I found reading Business Process Driven SOA using BPMN and BPEL  (Matjaz Juric and Kapil Pant, 305 pages, Packt Publishing, August 2008, $59.99) surprisingly easy.

Still, to be very honest much of the technical discussion was lost on me. To my novice eye, the book is well organized and well presented. The initial chapter presents an excellent argument for developing SOA applications; later chapters move progressively from conceptual modeling to BPMN and then into the deployment of processes using BPEL.

My only regret is that the authors were forced to (I hope they didn’t want to) use the Oracle stack of products to illustrate many of the actual implementation considerations, especially when describing BPEL. Naturally, it hurts me to read all about a competitor’s product, especially when we believe ActiveVOS 6.0’s BPMN-to-BPEL integration is far easier to use and implement. Had the authors used the ActiveVOS visual orchestration system, they could have eliminated pages of Oracle product names descriptions and “when to use what” recommendations.  Maybe the authors will consider changing for the next edition of the book.

But as I read the book, it occurred to me that my surface understanding of the technology actually made it easier for me to see the “theology” inherent in the BPMN and BPEL debate we so often hear about. Consider this passage:

The fundamental difference between BPMN and BPEL is also the reason why some tools have started providing extensible features…to allow a round-trip feedback loop between the business process users working in BPMN and technical teams developing in BPEL…This is a topic of debate, as we are asking our business community to think like a programmer and model business processes to create consistent technical output in the form of BPEL, which is unfair.

Here, the authors have the exposed the fundamental issue for creating SOA-based BPM applications: should the top-down, business-analyst creates-a-model-for-everything, BPMN view of work reign supreme? Or should the structured, execution-oriented BPEL approach to automation be ascendant?

My answer? It depends. If you are in a company in which the objective is 100% transparency of processes, in which people are told what to do and how to do it, in which creativity flows from the BPMN diagram, your approach is clear…and doubleplusgood. (And, yes, I have an opinion.)

OTOH, if you believe that computers are tools for people, that it’s better to let machines do the repetitive parts of a process while easily including less-structured human tasks, you have the choice of a different approach using BPEL and BPMN. And I think the choice has a lot to do with your company’s cultural ethos.

Still, what’s nice about these standards is even though they’ve been put together in a shotgun wedding and the marriage is far from comfortable, the union of these two technologies gives users ultimate flexibility to implement SOA applications as they prefer. And as a book to illustrate how to implement these choices, you can’t go wrong with Business Process Driven SOA using BPMN and BPEL (as long as you don’t use Oracle stuff to do it).

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

A great SOA read..just wish they’d used ActiveVOS 6.0

Unlike the very popular ActiveVOS 6.0 demo on our website, this animation focuses less on the amazing technical features of ActiveVOS 6.0 and instead discusses the concepts that a visual orchestration system in general, and ActiveVOS 6.0 in particular, provides.

The animation runs about 7.5 minutes and I’ve uploaded a smallish version .m4v that will play on the blog and on iTunes, a larger DivX-encloded .avi, as well as much larger QuickTime .mov.

We hope you enjoy watching this and, even more, that it will explain our passion for visual orchestration systems and why we believe they are the answer for really making it possible to produce SOA and services-based applications quickly and easily.

Post from: VOSibilities, the Active Endpoints BPMS blog

Learn more about ActiveVOS

VOSibilities podcast #17: ActiveVOS 6.0 concepts