To get started, it is probably best to download the full installer and follow the installer documentation, to guide you through the tools with a simple example. You can also import the examples module to have look at the numerous examples included in there.

We'll be updating some of the documentation and adding some quick starts and more examples in the next few weeks, so stay tuned!

Have fun!

Release notes

On top of some optimizations, bug fixes and small improvements, these are the most important new features in jBPM 5.2.0.Final.

Friday, November 18, 2011

Bruce Silver did a blog recently, wondering whether any tools already exist that truly support executable BPMN 2.0. He defines supporting executable BPMN 2.0 as not just following the graphical notation guidelines (that are probably not that different from BPMN 1.x), but also supporting the underling XML serialization. And not just the basic high-level elements, but also the details that are necessary to come to executable processes, like process data, data mappings, service interfaces, etc.

I believe that jBPM satisfies these requirements!

As of jBPM 5.0, we are now using the BPMN 2.0 specification, not just for the visual representation, but also as the underlying XML serialization. And it's more than an import/export format, it is the representation that our tools use to communicate with each other (instead of using yet another proprietary model for that). This means that you can round-trip your processes between your developers (using the Eclipse-based editor integrated in their development environment) and your business users (using the web-based designer) based on the BPMN 2.0 XML.

And yes, unlike some other vendors, we're following the BPMN 2.0 specification as close as possible, and avoid using custom extensions (whenever not necessary). This for example means that we use BPMNDI for storing the diagram information (i.e. location and size of the nodes etc.), like this (click here to see the full process):

jBPM already supports a significant subset of nodes (and other elements) that you can use to model executable processes. To get an idea of what this looks like using BPMN 2.0 XML, simply browse through the examples module. A full list of supported elements and attributes (which is very similar to the Common Executable subclass, but extended with a few more elements) is added as part of the documentation here.

And finally, our new Eclipse-based editor is almost ready, and that supports the full BPMN 2.0 specification, and uses the BPMN 2.0 XML to store these process models. You can for example download the BPMN 2.0 examples (that are included as part of the specification) and open them up, as shown in this screencast.

Monday, October 10, 2011

(If you want to help out and contribute to jBPM, read this blog all the way to the end, as we're looking for community assistance here!)

Using jBPM5, you can introduce your own domain-specific services in your processes. By defining your own services, they show up as custom service tasks in the graphical process editor. For example, if you would like to send tweets inside your business processes, a special twitter service task can be defined, as shown in the following screenshot.

Configuring domain-specific services has become even easier now, as we now allow you to import services like this from a service repository. You can just browse such a service repository and import the services you would like to use inside your processes. These will then automatically be added to your palette. You can also import a default handler that will be used to execute the service (although you're always free to override the defaults, for example for testing).

The import wizard is created as part of the latest version of the jBPM Eclipse plugin (and will be part of the next release, or you can already try it out by installing the latest plugin from the latest update site). It supports both repositories that are on your file system, or URL-based.

Click on the image below to see a screencast where we import the twitter service in a new jBPM project and create a simple process with it that sends an actual tweet.

[Note that you need the necessary twitter keys and secrets to be able to programatically send tweets to your twitter account. How to create these is explained here, but once you have these, you can just drop them in your project using a simple configuration file.]

We're building a service repository that contains predefined services that people can use out-of-the-box if they want to: http://people.redhat.com/kverlaen/repository. Currently it only contains a few services but we will migrate all existing services there over time.

And this is where we are looking for contributions! There are tons of interesting services and excellent projects that we would like to integrate with. We would like to offer out-of-the-box integration with a lot of those, by defining them as domain-specific services and adding them to the service repository, so people can import them in their processes. So if you would like to contribute integration with a service like that (e.g. facebook, google maps, etc.), or even your own project, let us know!

Thursday, October 6, 2011

There's just too much happening to blog about it all myself, but here are some interesting blog entries out there!

There will be a Drools & jBPM boot camp in San Francisco end of this month. It's free but you need to register. For people that are attending the RulesFest conference, definitely a must. There's one day dedicated to healthcare even. I personally won't be able to attend unfortunately, but other core developers will be. And I'll do a remote presentation on Clinical Decision Support on the healthcare day.

The jBPM form designer is coming along nicely! A new video, showing some of the more advanced UI components, is available here.

Eric Schabell put a version of the jBPM migration tooling in the cloud. This migration project helps you converting your jPDL processes into BPMN2, and they're looking for input and feedback.

Thursday, September 29, 2011

After the success of previous JUDCon conferences in for example Boston and Berlin, JUDCon is now visiting London! JBoss developers will be coming to London at Park Plaza Victoria on October 31st and November 1st. The first day, there is a "Rules, Workflow, SOA and EAI" track, including for example:

Friday, August 26, 2011

I'll be doing a set of workshops in September on jBPM5, in Japan and Australia this time. These workshops are a combination of presentations highlighting the various features, combined with practical sessions where you can try it out yourself using simple exercices on your own laptop. A more precise agenda of what will be covered is included in the links below.

Tuesday, August 9, 2011

Whenever human actors participate in business processes (for example using the jbpm-console), forms can be used to show information to these users and/or ask for additional input. For example, the performance evaluation example that is included in the installer uses a simple form (as shown below) to ask the user to fill in some data related to his performance evaluation.

jBPM5 allows you to define these forms yourself, using a HTML template approach, so that they can be used in the console.

We've also been working a Form Builder, a web-based application that also allows business users (and not only developers) to create these forms using a visual editor and drag-and-drop. Mariano has published a blog including a cool demo that shows the progress so far.

Not only is the form builder nicely integrated into the existing tooling, it also allows you to generate default forms based on the process definition (based on the expected input and output parameters of the user tasks or process). The user can then customize the generated form and start using it in the console almost immediately.

Friday, July 29, 2011

Most of you probably know that JBoss Application Server 7 has recently been released in the community. Due to its lightweight and modular approach, concurrency and much more, the startup time has descreased significantly, which is always nice to hear for developers! Although I still have to figure out how to get a cup of coffee in only 3 seconds now ;)

During my holiday break, I took some time to play with it, and see how difficult it would be to get jBPM5 running on AS7. It took me some time, but in the end I managed to get the jBPM console running on AS7. I'll describe the steps I took to get there now, but we'll try to get this integrated in the installer in the near future, so other people can start playing with this stuff more easily as well (any volunteers?).

I started with downloading JBossAS 7.0.0.Final and took the jBPM 5.1.0.Final jbpm console wars as a starting point.

Biggest change probably is the fact that as7 ships with JPA2 and hibernate4, while jBPM is still using JPA1 and hibernate3. Due to it's modular design, we can however still run hibernate3 applications on as7, we just need to add these dependencies ourselves now (and exclude hibernate4).

Add the following jars from the jBPM runtime to the WEB-INF/lib folder of the server war: hibernate-core, hibernate-entitymanager, hibernate-commons-annotations, hibernate-annotations, dom4j, javassist

Make sure to exclude the hibernate4 jars, by adding the following WEB-INF/jboss-deployment-structure.xml in the server war:

I got an error with my persistence.xml and JPA2 so I disabled JPA2 scanning by commenting out the JPA module (org.jboss.as.jpa) and subsystem (urn:jboss:domain:jpa:1.0) in the standalone.xml configuration file.

Data sources are no longer specified by dropping a *ds.xml in the deploy folder but as part of the configuration. In configuration/standalone.xml, add the following datasource:

Notice that we also changed the jndi name of the datasource as we need to use one of the known domains (jboss in this case). This means you also need to change the name of the datasource in your persistence.xml.

The security configuration is also different, you should now add a security domain in the standalone.xml and copy the users.properties and roles.properties file in the WEB-INF/classes folder:

There is another persistence.xml file in the jbpm-human-task jar (which is also bundled in the server war) which actually shouldn't be there, and is picked up by as7 at deploy time, so you should just delete that persistence.xml file (as for example discussed in this blog).

Finally, there was a problem in the FormProcessingFacade of the bpm console code. It was no longer picking up correctly when a form was sending data as plain/text, as there were now new properties in the media type related to encoding that made the equals fail. So I had to change line 228 in FormProcessingFacade to this (checking only for plain/text mediatype and simply ingoring properties:

Ok, this might sound a little scary, but don't worry, you won't have to do all this manually yourself, once we update the build to generate as7-compatible wars and update install script, it should be able to handle most of this! I just wanted to share this with anyone who might be trying to do something similar.

Still need to check how to deploy the BIRT reporting engine on as7 and then the jbpm-console is fully functional. Tihomir has already looked at deploying the designer on as7 and generated a customized war in the build for that.

Tuesday, July 5, 2011

One example that is part of the jbpm-examples module is the request example, an advanced example that shows you how you could use a BPMN2 process to handle incoming requests. The process uses some of the more advanced features to model flexibility in your process in combination with business rules to specify part of the business logic.

The example itself is available in the jbpm-examples module so you can download and try it out yourself, but here are two small screencasts that show it in action. It uses a very simple demo client (that was created for this demo to make it easier to show some of the features). Some of these features are:

request validation using a business rule task

ad-hoc sub-process where the user can select process fragments to execute

As already mentioned in the jBPM 5.1 release notes, there is now a new jbpm-examples module that contains a set of sample BPMN2 processes that show how to model and use some of the features, like how to do looping and multi-instances, human task management and task forms, etc.

You can simply import the jbpm-examples folder in Eclipse to take a look at the processes and test and debug them using the associated Java main classes or junit tests.

The largest set of processes is probably the BPMN2 junit tests. For most of the BPMN2 constructs that are currently supported, there are probably one or a few tests that show how it works. On top of that, there are a few larger examples that show some more advanced features, like:

Thursday, June 30, 2011

SwitchYard is a lightweight service delivery framework providing full lifecycle support for developing, deploying, and managing service-oriented applications.

You mean like an Enterprise Service Bus (ESB)? Yeah, kind of. At it's core, SwitchYard provides an embeddable services runtime with limited dependencies, allowing you to deploy and run services where you need them. The main difference between SwitchYard and traditional ESB offerings is that we are trying to make the runtime a transparent detail in the service lifecycle. SwitchYard aims to keep you focused on your services by providing tooling to help define, test, and manage the important details of a service - it's contract, policies, configuration, composition, and management . After all, the least important detail of your service is where it runs.

Good news, as this next-generation ESB will already offer jBPM integration in its 0.2 release, where SwitchYard services can easily be invoked from inside a jBPM process, as a domain-specific service.

Thursday, June 23, 2011

jBPM is a flexible open-source Business Process Management (BPM) Suite. The core of jBPM is a light-weight, extensible workflow engine written in pure Java that allows you to execute business processes using the latest BPMN 2.0 specification. It can run in any Java environment, embedded in your application or as a service. On top of that, it supports a lot of tooling to support the business process through its entire life cycle, both for developers and business users. This includes an Eclipse plugin, web-based Designer, repository, management console, etc.

jBPM 5.1 includes a lot of small bug fixes and feature enhancements based on the feedback we received from the community (for jBPM 5.0). Most important improvements include:

The web-based Designer has been extended significantly to support all BPMN 2.0 constructs and to allow full round-tripping between the Eclipse-based and the web-based editor. It also supports domain-specific nodes now, can be embedded, etc.

A new jbpm-examples module contains a large number of example processes to show features like human tasks (including data passing and task forms), looping, multiple instances, rule-based integration, etc. I will describe some of these examples in more detail in some additional blog entries in the next few days.

The documentation has been refactored, updated and extended. There's a new Overview and Getting Started chapter, and much more. And we'll continue this work in the next few weeks as well, so you can expect more details soon.

The new BPMN 2.0 Eclipse plugin has made significant steps forward as well. The goal of this new editor is to support the full BPMN 2.0 specification . It's still work in progress but it can already be used to create executable BPMN2 processes and execute them on jBPM5. We'll be working hard to improve the usability in the next few months.

Smaller feature enhancements, like

Automatic synchronization of processes in the jbpm-console when new proceses are deployed on the Guvnor repository

Simplified data passing to and from human tasks (and forms)

Extended BPMN2 engine with support for repeating timers

Support for multi-threading

A full overview of everything that was included can be found in the jBPM JIRA.

jBPM 5.1.0 is synchronized with Drools 5.2.0, which also has just been released. If you want to know more, take a look here.

I'd like to thank everyone that contributed to this release! This includes not just the core developers obviously, but everyone in the community that contributed in one way or another, from testing, improving documentation, creating examples, bug reporting to submitting patches and feature contributions!

Tuesday, June 21, 2011

I'll be speaking about jBPM5 at the JBoss OneDayEvent in Munich on October 13th, 2011.

As the successor of the successful JBoss OneDayTalk 2010 conference, the JBoss User Group Munich e.V. will organize a full day JBoss conference in Munich again. On 13.10.2011, everything will once again revolve around JBoss technologies and Java frameworks, with the focus on current topics such as Enterprise in the Cloud, Security, Operations, High Availability, Scalability, ESB, Web 2.0, Mobile, Clustering, and BPM / BPEL / BRM content.

There will be a lot of interesting presentations about a ton of different JBoss technologies, given by core developers themselves. So this is the ideal opportunity to get all these technical details you're looking for and asking those hard questions! Or just to meet and greet the people behind the projects.

Wednesday, June 15, 2011

Most of the core developers of the jBPM and Drools team have been trying desperately to get to Buenos Aires. But the volcano in Chile has made that very difficult.

I'm back home, never got any further than Madrid, so they put me on a flight back home instead after two days of hotel and no immediate opportunity to still go the Buenos Aires. I'll do my jBPM5 presentation remotely and will try to be available as much as possible (man, this is Eyjafjallajokull all over again).

But it seems like the volcano issues are dying out. As a result of all this delay though, the Thursday workshop day will unfortunately have to be cancelled. But Friday is confirmed, so the workshop will take place! We'll just have to rearrange the content a little into one day again. And this will give everyone the opportunity to reach Buenos Aires in time as well.

But you can't argue with nature! So enjoy the trip and the workshop, from what I've heard it's worth it ;)

Tuesday, May 31, 2011

So if you're interested in picking up jBPM 5.1 as soon as possible, definitely give this release candidate a try, and let us know if there are any problems left, or if you see small enhancements we could still squeeze in that would make your life easier.

This week, I'll also be working on improving the documentation. The documentation itself is constantly growing, so I will try to restructure it a little as well, so it will be easier to find the information you might be interested in. Main ideas are to:

Include an overview chapter that will introduce the different components and how they work together (as people are sometimes overwhelmed by all the information on all the different components)

Add links between chapters, so you can more easily find more information, or what to read next once you've finished your current chapter.

Structure the documentation better, for example by component or by level of complexity.

We always welcome any feedback in this area as well, so if you have any feedback or recommendations for us, definitely let us know.

Monday, May 9, 2011

It's been a lot of hard work and fun at JBossWorld last week. Not only did I have to give 4 presentations about jBPM5, I've spent a lot of time talking to existing and potential new users about their experiences and what they like to see in the future as well.

If anyone is looking for the presentations, I added them to my slideshare account (where you can also download them). The first two on JUDCon were more developer-focussed:

The two presentations on JBossWorld gave an overview of jBPM5 basics and how you can use it to model a lot more advanced, flexible business processes as well, in combination with business rules and events:

And there were a lot of other very interesting presentations and demos as well. If you haven't seen the JBossWorld keynote demo just yet, I suggest you take a look at that !

Next week we still have the two bootcamps in New York and Washington, after that I'll be heading back home. As a result of all this traveling, we haven't been able to do the jBPM 5.1 release yet unfortunately. But this will be taken care of the week we return.

Friday, April 22, 2011

There's some discussion going on about some of the details in the BPMN 2.0 specification, more specifically the use of the process data input and process data outputs.

One of the issues of using an XSD to check the validity of an XML file (as the BPMN2 specification provides), is that the XSD does not express all the constraints that a process must fulfill to be valid. A lot of constraints are expressed in the narrative sections of the specification. That's why Bruce Silver is working on a profile for BPMN interoperability (BPMN-I) that could be used to check additional constraints, with the goal of achieving true interoperability between different vendors by making a lot of the "hidden" rules explicit.

During that work, Bruce (I hope he doesn't mind me calling him Bruce, maybe I should say Mr. Silver based on my appreciation for the work he has done and is still doing in this area ;)) discovered some discrepancies (or at least some confusing statements) in the specification itself when it comes to the use of process data inputs in relation to data input associations. I'm not going to try and explain the issue in detail, I would like to refer the readers that might be interested in the details to his blog and the followup blog, as it contains all the details, including numerous references to the spec itself and a discussion on the topic. But to make a long story short:

Can a process data input be used as the source of a data input association of task that is contained inside the process?

Since Bruce is asking for input from other interested parties, and jBPM is offering a BPMN 2.0 engine, I thought I'd give it a try. But since I couldn't find a way to put all this information and picture as a reply on his blog itself, I decided to write this blog entry and include my reply here (and to avoid splitting up the discussion I would suggest to add comments related to this topic on his blog as well). And at the same time I can invite other readers to give their 2 cents as well ;) So here it goes:

It seems to me, from reading the specification, that data input and output associations are meant to be "local", by which I mean they are not intended to be referenced from outside the element in which they are defined. On top of that, it also seems to me that they are intended to be "immediate" or "instantaneous" (not sure this is the best term but I couldn't come up with a better one at this point), meaning they are "executed" when they are reached, but they don't exist anymore after that.

Therefore, I would agree with your statement that process data inputs should not be the source of a data input association, as the process data input association only exists when the process is invoked and at that point, that data input association is executed. [I also believe that using a process data input when the process is actually started by a timer start event confusing, as it's unclear where this information would come from, but that's another issue.]

So how would you use your process data inputs in the remainder of your bpmn2 process then? I think the ioSpecification of the process, that contains these process data inputs, should also contain data output associations that map these data inputs to more persistent (as opposed to immediate or instantaneous) item-aware elements like a property or a data object. These can then serve as the source of other data input associations. So you don't directly use a process data input as the source of a data input association of (for example) a task, but you rather first map the process data input to a property using a data output association (as part of the process ioSpecification) and then use this property as the source of the data input association of the same task.

A screenshot of this in a real process is shown below (note that I deliberately chose a slightly different example to avoid using a start timer event in combination with a process data input as this makes it only more confusing):

You don't often come across people with such an in depth knowledge of how ioSpecifications in BPMN2 actually work, so I must admit I enjoyed reading the discussion so far ;)

Monday, April 4, 2011

Even though business processes aren't code (we even recommend you to make them as high-level as possible and to avoid adding implementation details), they also have a life cycle like other development artefacts. And since business processes can be updated dynamically, testing them (so that you don't break any use cases when doing a modification) is really important as well.

When unit testing your process, you test whether the process behaves as expected in specific use cases, for example test the output based on the existing input. To simplify unit testing, jBPM5 includes a helper class that you can use to greatly simplify your junit testing, by offering:

helper methods to create a new knowledge base and session for a given (set of) process(es)

you can select whether you want to use persistence or not

assert statements to check

the state of a process instance (active, completed, aborted)

which node instances are currently active

which nodes have been triggered (to check the path that has been followed)

get the value of variables

etc.

For example, conside the following hello world process containing a start event, a script task and an end event. The following junit test will create a new session, start the process and then verify whether the process instance completed successfully and whether these three nodes have been executed.

Testing processes that don't interact with the environment like this one are really easy to test but in general aren't that realistic ;) Real-life business processes typically include wait states, invocation of external services, etc. One of the advantages of our domain-specific process approach however is that you can easily specify different implementation of the node depending on the context. This means that, when you are unit testing your business process, you can register test handlers that can be used to verify whether specific services are requested correctly, and provide test responses for those services. For example, imagine you have an email node or a human task as part of your process. When unit testing, you don't want to send out an actual email but rather test whether the email that is requested contains the correct information (for example the right to email, a personalized body, etc.).

The following example describes how a process that sends out an email could be tested. This test case in particular will test whether an exception is raised when the email could not be sent (which is simulated by notifying the engine that the sending the email could not be completed). The test case uses a test handler that simply registers when an email was requested (and allows you to test the data related to the email like from, to, etc.). Once the engine has been notified the email could not be sent (using abortWorkItem(..)), the unit test verifies that the process handles this case successfully by logging this and generating an error, which aborts the process instance in this case.

You can configure whether you want to execute the junit tests using persistence or not (by default using an in-memory H2 database which is started by the junit test itself and by using a history log), simply by passing a boolean whether you want to use persistence or not when calling the super constructor.

We will extend the set of out-of-the-box assert statements over time, but if you do need additional assertions for your use cases, you can already extend the set yourself by looking at the implemention of the existing ones and simply tweaking where necessary. And let us know if you create some reusable ones, we'll add them to the code base!

If you combine these test features with the advanced debugging capabilities, (as for example shown in this screencast) you can use this to walk through the process one step at a time and figure out what's happening internally. We're working on extending this even further to support full simulation and testing capabilities. This would allow you easily define and run various test scenarios, replay an execution log, etc. The foundation is already there (like a simulation clock and the definition of execution paths), but we're still working on the user interface that would make this useable by not just developers but also business users.

Saturday, April 2, 2011

First, there is 2 days of JUDCon, May 2 - 3. JUDCon is an event by developers, for developers. I attended JUDCon Berlin last year and it is a great place for developers to learn the details of different technologies and meet the core developers and other community developers out there. Presentations will include a range of deep technical dives into JBoss Community projects and related technical topics of developer interest. And the hack fests allow you to do some real coding as well.

There are a handful of jBPM-related presentations, and many many more. Check out the agenda and register today!

Immediate after JUDCon and on the same venue, there is JBoss World and Red Hat Summit, May 3 - 6, where there will be numerous presentations on a lot of different topics, (j)BPM being one of them. We'll be touching on a wide area of from the core engine itself to event-driven BPM and decision management. Details in the agenda, and don't forget to register!

Friday, March 18, 2011

I recently did an interview for JBoss Asylum. They bring us regular updates on what's new at JBoss by doing podcasts and inviting guests to talk about special topics.

With the release of jBPM 5.0, now was my time to get attacked by Max Rydahl Andersen, Emmanual Bernard and Michael Neale ;)

This episode had some bad luck with respect to the audio recording and took a while to get edited down to listenable quality. The news are therefore a bit out of date but the interview with Kris Verlaenen about jBPM 5 is all filled with great and interesting content.

The interview part has good audio and you can skip to the 22m33s mark to hear about jBPM 5.

We are again sorry that Emmanuel Bernard messed up the recording, but we will back soon with a new interviewee and with better sound ;)

Thursday, March 17, 2011

Business Rules and Business Process Management the Open Source Way

Join Red Hat and Accenture on Tuesday 29th March at Accenture Old Bailey to understand how Business Rules Management Systems (BRMS) and Business Process Management Systems (BPMS) can help businesses leverage technology more effectively and increase productivity. See how Enterprise Open Source is leading the way with powerful capabilities and industry-leading innovation.

There will be 2.5 hours of technical talks, starting at 9am. Full timings and agenda here.

Talks (from core developers, there are other talks too):

Introduction to Rule Based Systems (Mark Proctor)Introduces Drools and explains what a rule based system is and how it works. We will also cover event processing on a rule based system.Why BPMN2 Matters (Kris Verlaenen)jBPM5 has just been released as premier Open Source BPMN2 implementation. Come and hear how this changes your whole legacy approach to BPM.

Using Guvnor for Enterprise Systems (Geoffrey de Smet)Guvnor provides a web interface to your knowlege systems, such as rules and bpm. This talk provides a gentle introduction into Guvnor and how to use it.

Decision Tables in Depth (Michael Anstis)Decision Tables is now a major focus for us, we want to show you why we'll have the slicket decision table environment out there.

Tuesday, March 8, 2011

I recently bought myself a new Android phone, and as a developer, that obviously means I have to try and write my own application for it ! :)

And since we always claim jBPM is such a lightweight engine that you can embed it practically anywhere, I decided to give that a try: run the jBPM5 engine on Android. Some people might be thinking, why would I want to do that? Well, my primary goal was just as a proof of concept. But maybe, if we extend that proof of concept a little more and add more Android tasks, end users without any real development experience might be able to use it do model simple Android applications as well, who knows!

So after downloading the Eclipse tooling and following a hello world example, I decided to create a simple process that first asks the user for some keyword and then uses this keyword to search the jBPM community forum for entries containing that keyword (I know, not rocket science, you don't really need a workflow engine for that but it's just a demo example).

After adding the jBPM5 jars to the classpath, I updated my application to start this process when the application is started. I also created two domain-specific services for Android, one for requesting some input from the user (where I then bind this result to a process variable) and one for showing a web page (which shows a URL, which I created based on the input of the user).

And it worked almost[*] out of the box! So this is what it looks like (on the emulator, but it runs nicely on my phone as well). First you start the jBPM application ...

The first node in the process will ask you for a keyword you want to search for ...

And the last node will show the results of the query on the jBPM community forum in a browser ...

I'm pretty sure there are a lot of developers out there that try to play with new technologies like this, so if you're interested in playing with this and maybe extending this a little, let me know. Imagine we add a few more default services for showing an image, getting some file, getting GPS location, etc. Would be pretty cool if you could create more advanced applications like that.

[*] A small modification is needed in org.drools.util.CompositeClassLoader. Apparently, the Android JVM doesn't allow null as the parent classloader so I changed that to super(CompositeClassLoader.class.getClassLoader()) in the constructor, and that works fine.

He has also been nominated for the JBoss Community Recognition Awards 2011 in two categories, I know you would do him a big favor by voting for him, he's definitely got my vote for all the work he's been doing !

We would like to show you our new and improved BPMN 2.0 Eclipse editor, which is currently being developed for jBPM 5.1 and will support a much larger part of the BPMN 2.0 specification (hopefully even including basic choreography and conversation).

For this, we've had a lot of help from the guys at Codehoop. They've been working on it for the last few months, and we believe it's currently at a stage where people can start to play it with and give us feedback.

(click on image to enlarge)

Features:

It supports almost all BPMN 2.0 process constructs and attributes (including lanes and pools, annotations and all the BPMN2 node types).

Support for the few custom attributes that jBPM5 introduces.

Allows you to configure which elements and attributes you want use when modeling processes (so we can limit the constructs for example to the subset currently supported by jBPM5, which is a profile we will support by default, or even more if you like).

Since it is still work in progress, there are still a few limitations or missing elements, but we should be able to clean it all up pretty soon, and include it as part of jBPM 5.1. But if you're looking for an open-source BPMN2 editor and might be interested in participating, let us know !

You can find the codebase here. We will be providing an easy-to-use update site for installation once we reach the final milestone, but if you already want to give it a go and build it from source:

Fetch the source and import the projects into Eclipse.

The project is reusing the Eclipse BPMN2 meta-model project for loading / saving BPMN 2.0 XML, so you will need to download and import the projects from the Eclipse BPMN2 repository (git://git.eclipse.org/gitroot/bpmn2) as well.

If you then run as Eclipse application, a new Eclipse environment should come up.

Create a new BPMN2 diagram by selecting File -> New -> Other and then select BPMN2 Diagram Wizard (under BPMN2 category).

There is also a Wiki page that contains some screenshots useful information.

Codehoop is a small agency building Eclipse toolkits and Java+Scala enterprise middleware. The team has been excited to work with Fortune 500 companies as well as small startups. The result is a great variety of expertise on Eclipse technologies, ranging from database management to code editors, visual modelling and vector-based animation studio.

Tuesday, March 1, 2011

The recording for the webinar on jBPM5 is now available here. For people that want to get access to the slides, I uploaded them here.

A lot of people attended one of the two available sessions, and as a result, there wasn't enough time to answer all the questions. But as promised, we are trying to answer each an every one of them. I will post a blog entry with the questions and answers as soon as possible.

"Here is an example of creating and executing a simple BPMN2 process created with the Oryx designer (click on the screenshot below). It shows off the ability to create both business rules and BPMN2 processes in the same environment and expose them to the client application that consume them.

In order to recreate this example, you must use the latest version of the Oryx designer which you can download from here (rename it to designer.war and replace your existing one in $jbossHome/server/$config/deploy directory). If you prefer to use the jbpm-console for executing the process instead of from Eclipse like shown in the example, you can do that as well if you define the process as part of the defaultPackage (or update your jbpm-console configuration to load processes from another package)."

Thursday, February 10, 2011

With the first jBPM5 release out there, the work isn't done! We have lots of existing customers that need support or are eager to move to the new version and need some assistance. On top of that, we obviously want to keep improving and extending our latest version with new and exciting features.

That's why we are looking for someone who is willing to take on the challenge and join the team ! No need anymore to find some spare time to do contributions to jBPM, now you can do it fulltime.

Are you looking for something new and exciting and do you have what it takes? Previous experience with jBPM, BPM in general or open-source is a plus ;) Are you interested in joining the jBPM team to solve issues and add new features? Let us know !

Tuesday, February 8, 2011

With the release of jBPM 5.0 also come new presentations. And this time, I'll be doing a runthrough of the different tools, so you can get a feeling of what the different tools look like and see them in action.

The webinar will be on February, 24th and there will be two slots available, to make sure there is something that fits your time zone.

Monday, January 31, 2011

jBPM is a Business Process Management (BPM) system, allowing you to specify, execute and manage your business processes, for both developers and business users. The jBPM core is a solid, lightweight engine that can be embedded inside your application or deployed as a service.

The most important features of the jBPM 5.0 release are:

a core engine supporting native execution of business processes following the latest BPMN 2.0 specification

web-based tooling for business users including web-based editing of your business processes, a process management console, human task lists, etc.

jBPM 5.0 is one of the most powerful engines out there (already supporting a large set of constructs as defined in the BPMN2 specification), not only does it allow dynamic adaptations and migration, but it also supports flexible and adaptive processes.

Last, but not least, jBPM5 is not an isolated process engine but it can also be used as one of the component inside a much larger solution. If your real-life business problem for example has to deal with flexibility, events or is data-driven, we allow powerful integration with business rules, event processing and other services in your environment. This allows you to select how to model (each part of) your business knowledge, effectively combining these different paradigms into one solution.

To get you started, are you looking for some screenshots or screencasts? Or want to start browsing the documentation? Or you really want the hands-on experience? Then try out the (full) installer and run the ant script to set up a demo environment, that will guide you through a few of the components using a simple example. The installation chapter in the documentation contains a few screencasts to help you out. After that, you can continue reading the documentation, play with the example by modifying it, or start your own project.

Thursday, January 27, 2011

With the release of jBPM 5.0 around the corner, lots of people are very eager to start using it. And luckily for us, they are willing to share their experience, so that other might be able to benefit as well. So here are some blogs you might find interesting if you're getting started as well.

Vignesh has kindly created a "Getting started with jBPM 5" video. He's put it up on his blog here.

"I once wrote a blog on setting up jBPM 3 with jBoss ESB which proved useful to lot of folks. Now I am going to present a similar one for the all-new jBPM5. There is indeed a huge difference between the two and I must admit that the new product stack is looking very good, loaded with many must-have options any BPM product should ship with.I will write about all the technical insights in a separate post. One good news you should know is that the installation has got a lot easier in this version. Let's just get started with jBPM 5, install it, and see it for ourselves."

The guys at Plugtree have also created a tutorial that helps you create a process that includes variables, constraints, etc.

"This posts aims to teach the basics of modelling your processes into JBPM5. You’ll learn how to use the builtin Eclipse editor to create simple processes, with branching, joining, external variables and code constraints."

Looking for even more? Here's a post that groups a number of posts, videos and tutorials about jBPM5.

Tuesday, January 18, 2011

One of the missing pieces in the jBPM 5.0 CR1 release was the inclusion of a process repository. Luckily, your waiting time is over!

A process repository is an important part of your BPM architecture if you start using more and more business processes in your applications and especially if you want to have the ability to dynamically update them. The process repository is the location where you store and manage your business processes. Because they are not deployed as part of your application, they have their own life cycle, meaning you can update your business processes dynamically, without having to change the application code.

Note that a process repository is a lot more than simply a database to store your process definitions. It almost acts as a combination of a source code management system, content management system, collaboration suite and development and testing environment. These are the kind of features you can expect from a process repository:

Persistent storage of your processes so the latest version can always easily be accessed from anywhere, including versioning

Build and deploy selected processes

User-friendly (web-based) interface to manage, update and deploy your processes (targeted to business users, not just developers)

Authentication / authorization to make sure only people that have the right role can see and/or edit your processes

Categorization and searching

Scenario testing to make sure you don't break anything when you change your process

Collaboration and other social features like comments, notifications on change, etc.

Synchronization with your development environment

Actually, it would be better to talk about a knowledge repository, as the repository will not only store your process definitions, but possibly also other related artefacts like task forms, your domain model, associated business rules, etc. Luckily, we don't have to reinvent the wheel for this, as the Guvnor project acts as a generic knowledge repository to store any type of artefacts and already supports most of these features.

The following screencast shows how you can upload your process definition to Guvnor, along with the process form (that is used when you try to start a new instance of that process to collect the necessary data), task forms (for the human tasks inside the process), and the process image (that can be annotated to show runtime progress). The jbpm-console is configured to get all this information from Guvnor whenever necessary and show them in the console.

If you use the latest snapshot version of the jbpm-installer, that should automatically download and install the latest snapshot of Guvnor as well. So simply deploy your assets (for example using the Guvnor Eclipse integration as shown in the screencast, also automatically installed) to Guvnor (taking some naming conventions into account, as explained below), build the package and start up the console.

The current integration with the jbpm-console uses the following naming conventions to find the artefacts it needs (though we hope to update this to something more flexible in the near future):

All artefacts should be deployed to the "defaultPackage" on Guvnor (as that is where the jbpm-console will be looking)

A process should define "defaultPackage" as the package name (otherwise you won't be able to build your package on Guvnor)

Task forms that should be associated with a specific process definition should have the name "{processDefinitionId}.ftl"

Task forms for a specific human task should have the name "{taskName}.ftl"

The process diagram for a specific process should have the name "{processDefinitionId}-image.png"

If you follow these rules, your processes, forms and images should show up without any issues in the jbpm-console.

About Me

Kris is a Senior Principal Software Engineer at JBoss, by Red Hat, where he leads the jBPM project (an open-source business process management (BPM) suite), and is also part of the Drools project (an open-source Java rules engine). The jBPM project consists of a lightweight workflow engine in Java that support native BPMN 2.0 execution and various tools and features around that to support business processes throughout their entire life cycle.

Kris did a PhD in Computer Science at the Katholieke Universiteit
Leuven, Belgium. His main research area is policy-based management,
i.e. using declarative policy rules for configuring services, resulting
in highly-configurable, reusable services. He has experience and a
great intrest in policy-based and rule-based systems, workflow
management, service-oriented software development and clinical decision
support.

In his spare time, Kris also does athletics (ROBA) and plays volleybal (Berg Op Wijgmaal, Heren2).