jBPM @ JBUG Benelux

This Friday, I'll talk about the Process Virtual Machine at the next JBUG Benelux meeting. These JBUG events are especially interesting since there is always a great interaction and lots of discussion that spawns from (and during!) the presentations. I'm looking forward to it.

Pete Muir will kick off with a 'SEAM In Action' talk. I saw Pete's presentation two weeks ago at JBossWorld Orlando and it was great. Pete is an excellent speaker and he's got some great handwaiving manouvres. Then I'll be talking about the Process Virtual Machine. And the last but not least, Bart Schuller and Daan Hoogenboezem will bring a testimonial about their experiences using jBPM. It's always great to get such direct feedback. Hopefully there is some positive in there as well :-)

For those of you more interested in the packaging rather then that content, the event will be hosted in Paddy Murphy's, an "vette" Irish pub in Rotterdam. Lunatech does the hosting of the event and we will take care of the Guinness.

I'm sure you don't want to miss this. Hope to see you there !

jBPM @ FOSDEM

I'll be speaking about "Workflow in Java" this afternoon from 15:00 till 16:00 in room AW1.120. Due to misunderstandings, this talk didn't make it into the conference guide. So this blog post is an attempt to avoid an empty room :-) Hope to see you there.

JBossWorld Recap

JBossWorld was last week in Orlando, FL. Of course, we took the opportunity to meet up in advance with the core JBoss developers. It still surprises me each time how the communication at such meetings can be intense, distributed, apparently anarchistic and yet extremely effective ...often even at 1am at the bar.

My presentation "A Lightweight Approach to Business Processes with JBoss jBPM" was in the very first slot. I always like that very much as jet lag and parties tend to undermine my concentration as the week progresses.

Met up with my good friends at SeeWhy. They might be able to contribute an initial version of the log/event generation in the Process Virtual Machine. The open source collaboration model in practice. Cool.

Same open source spirit for NexusBPM. Matthew Sandoz has already extended jPDL with new node types in the engine and in the graphical designer. Good to see that a long term vision becomes reality. We're happy that Matthew is interested to donate his contributions to the jBPM community and we will be assisting him in the process of doing so.

By coincidence, IDS Scheer's ProcessWorld conference was also taking place at the exact same location at the exact same time. I saw Sandy Kemsley blogging about it and pinged her to have a meeting. We definitely agreed that translating analysis models into executable software artifacts is not as easy as most BPMS vendors make us believe. For many other observations of the BPM market we thought very similar, which is surprising given our different background. Only when it came down to roundtripping between the analysis model and the implementation models of business processes, I seriously doubted if that was achievable, while Sandy had good faith that the big BPM players some day will find a way to make that transparant.

Another interesting meeting was with our new CEO, Jim Whitehurst. Everyone was enthousiast about the fact that he managed to analyse and express exactly where the problems are located in such a short period. Now our expectations him to get them fixed are very high :-)

A last anecdote that I would like to share is my jogging experience around the Marriott World Center. It turned out to be extremely difficult to find a track for jogging. Even the driveway to the hotel was a 4 lane street without cycle or pedestrian facilities. Eventually I saw a golf court behind a small pond and grass. There was a sign before the pond. I assumed it was going to be "Don't walk on the grass" and given my struggles so far, I was completely prepared to ignore it. But the sign didn't say anything like that. Instead it had a much more effective message: "Don't feed the alligators!". It worked for me :-)

SOA Done The Hard Way

You don't see many public cridible reports about results of SOA projects. So that's why Chris Muir 's testimonial is interesting.

The overall message in Chris' post is that there are a lot of practical problems between the dream and reality of SOA development.

"Just because the underlying Web Service communications allow you to communicate in a standard fashion, it doesn't mean the systems or organisations you communicate to are following any standards internally."

Top of the bill was:

"In addition only 1 of the 3 suppliers actually had test systems we could build our application against. And for the supplier that did have a test system we literally had to phone them to ask them to flush the data each time we did a test. So much for quick agile development."

But the post contains much more in depth insight about the practical things that can go wrong in SOA projects. Definitely worth a read.

It expresses very well how Oracle's Fusion doesn't really address most of the practical issues. In fact, they are very hard (if at all) to address. That's why I'm happy with JBoss' practical developer oriented approach that gives full control to developers. With the tool suite that we're building, we focus not to introduce unnecessary levels of complex indirections.

What is BPEL really ? And what are process component models ?

I included a very simple description of what BPEL really is in my article "Process Component Models: The Next Generation In Workflow ?", published at InfoQ. Basically the article is about different forms of workflow and Business Process Management (BPM) and it tries to demystify some of the common misconceptions around BPM. And at the end, a new approach to building embeddable runtime engines is introduced: Process component models. With process component models, it's possible to serve the different forms of workflow and BPM by executing multiple process languages natively on top of one core simple state machine library.

What Possesses These Open Source Developers ?

Joe Walker desrcibes it in a very realistic way for me:

"
The funny thing about getting heavily involved in an open source project is the roller coaster ride you embark on. There's the buzz from seeing the hits to the web server and reading what people think of your project. There's the gnawing feeling of responsibility when you discover very large websites using your code, and you're worried about bugs you might have created. There's the total flat feeling when a friend tells you they're taking your code out of a project because they prefer an alternative; and there's the burnout when you just can't keep up with the volume of work, and realize that a huge percentage of what you do is not directly development related.

My experiences with open source have opened a huge number of doors. I've met people that I wouldn't have met otherwise and had job offers that I wouldn't have dreamed of before. There really is a magic buzz to open source.
"

Right on, Joe!

Process Modelling And Process Execution

Jim Sinur talks about a lesser known aspect in BPM and workflow: the interaction of process modeling with process execution. He walks through 5 use cases of BPM and explains which tools that apply best: modelling tools or a Business Process Management System (BPMS, aka runtime process engine).

The part of it that I think is not enough known is the differentiation between the modelling tools and the process engines. The aim of modelling tools is to let the analyst create a diagram to help with documenting business processes. On the other hand, the aim of the BPMS is to track the progress of process executions and to execute the automated parts of it on a computer system.

BPMSs offer modelling capabilities, but since those models need to be executed later on, there is more to it then just the diagram. The diagram of an executable process will be more restricted then a diagram of an analysis model. Also the diagram of the executable process will be tied to software execution so changes to the diagram lead to changes to software execution.

There are some good tools for process analysis and there are some good BPMSs that support a graphical diagram view onto their executable processes. But making the link between those two worlds is not handled by today's technologies.

BPEL is known as a BPM language. It's an executable process language. And because of its focus on WSDL and executability, it is not suitable to let a non technical business analyst model a business process.

BPMN is mostly known as a graphical notation for business process diagrams. It's a good language for the business analysts, but creating easy and maintainable bindings to executable process languages is not yet demonstrated. Especially the gap between BPMN and BPEL is too big to keep in sync with round tripping.

So this leads to a software development cycle for processes that is completely similar to any other software automation project. Non tech business analysts can create analysis models. From analysis models, implementation models can be distilled. After that translation, the business analyst will only be able to see the implementation models in read only mode. The analyst will still recognise the diagrams, which results in a common language between the business analysts and the development team. That is a big added value that BPMSs can bring.

XPDL and jPDL have already today are most suited for aligning the executable process model with the analysis model. While BPEL is very complementary technology on an ESB, it is still very problematic in making the link between analysis models and executable models.

With jPDL 4 that we are currently conceiving, it will be possible to just add technical details to the analysis model and keep the original diagram as-is for the executable process. That is quite an achievement as the analysis model will not have taken into account persistence, transaction demarcation and concurrency details. Making all of those technical details fit into any Java application architecture is something that we can be proud of. But let's not make this into a jPDL blog.

The main message of this blog was that the link between modelling tools and process execution engines is still not as good as most people assume. Especially not with the two technologies that are mostly known: BPMN and BPEL. While the link between BPMN and BPEL is broken, both technologies can still be very usefull on their own.

BPM, A Peel Of SOA And The CIO Filter Syndrome

Jim Sinur kicks an open door and expresses the current general ideas around BPM and SOA in "What is the Nature of the BPM/SOA Codependence?"

I think in many ways the views expressed in that post are too limited and I'll sketch where I would like to see a broader vision. Since the tenor of the post is very representative for todays generally accepted viewpoint, I'll discuss that general viewpoint, even when it goes a bit outside this post of Jim.

In the BPM section, he describes that a human task that doesn't require a lot of thinking can be considered a candidate for automation:

There is another class of work that revolves around human activity where the knowledge level is not as intense and revolves around workflow-like activities. This work has also eluded automation at the level that a service would be needed.

The fact that the word 'service' is used bothers me. As if there no other forms of automation then a service. This particular phrase is an example of a broader mistake that I see with business level people talking about software. Their view seems to be limited to BPM and SOA only.

This is what I would call the CIO level filter. The CIO level filter only lets those parts of software development pass that can be understood by business people. BPM and SOA, but also rules fit into that category. Executable business processes and executable rules are in essence pieces of software. These languages try to create a representation that are understandable by non technical people. That is how they should be treated. All too often, non technical people tend to forget about the software nature of executable business processes and executable rule bases and discuss them in the plain english interpretation.

I believe many BPM folks miss insight on general application development to talk about software architectures. In my opinion, applications are developed in silos. Connectivity between application silos is enhanced with the typical SOA, WSDL, WS-* armoury. But BPM is much broader applicable then only on top of services.

There are many forms of process languages. Some of them like BPEL are only targetted at the services level. Others like jPDL are targetted to be used inside application development. So my point is that business processes, in the business sense of the word, translate over many layers of the software architecture, not only the services layer. Some business processes might be implemented on the services level only, in which case BPEL is a good candidate. While other business processes might be implemented as part of a Java application, in which case jPDL is a better option. Other business processes might be easier to implement in plain Java code.

Executable process languages come in different flavours and different habitats. The choice of executable process language should be a technical one. A company can manage their business processes better and more agile by leaving the choice for the process language to the technical team. All too often I see situations where the technology is selected upfront.

On Jim's SOA part, there is another occurence of what I would call the CIO filter syndrome:

The power of the SOA architectural approach is that it enables autonomous subsystems to be assembled into entities (SOA applications / processes ) that can be as cohesive externally as applications built with older architectural approaches (classic components, modularization, or object-oriented paradigm).

The benefit of SOAs over these older approaches is increased agility and greater tolerance for change throughout the life cycle of a system, especially compared with a system that assumes tight coupling and homogeneity across the subsystems.

I agree with the message that an SOA is all about increasing connectivity between loosely coupled components. The interoperability of WS-* infrastructure that is available today helps to simplify and speed up the connectivity problem. But that doesn't take away the applications at the end of the connectivity need to be build and developed. When building applications, tight coupling is a blessing. Without typesafety and refactoring, application development would take considerably longer. Without synchronous method invocations as in Java, applications would run infinitely slower.

So it's not new versus old. It's loosely coupled versus tightly coupled, knowing that inside an application silo, tightly coupling has great advantages. So I think that application development is as relevant as it was before, the only thing that was added recently is a set of standard technologies with which you can easily put a peel of SOA around your applications.

This still leaves the difficult task of the software architect to define what functionality is build in which application and what interfaces will be exposed to the SOA connectivity layer.

In summary, the CIO filter syndrome is that non technical business people try to come to conclusions about software architectures by only looking at the languages and parts of the architecture that they understand. Try to avoid it :-)

BPM Arrives Into Puberty

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

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

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

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

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

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

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

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

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

JavaPolis Sold Out

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

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

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

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

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

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

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

Hope to see you all next week in Antwerp !

Even Microsoft People Use jBPM

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

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

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

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

Workflow In Java *Is* Sexy !

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

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

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

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

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

Execution execution = processDefinition.startExecution();

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

public interface NodeBehaviour {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Unifying Processes And Rules

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

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

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

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

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

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

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

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

Yahoo Pipes, PVM and language-oriented programming

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

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

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

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

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

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

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

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

jBPM jPDL 3.2.2 released

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

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