Small steps with big feet

Screencast: New Activiti Explorer

One of the highlights of the latest release of Activiti, is absolutely the new revamped (= redesigned and rewritten) Activiti Explorer app. In the screencast below, I’ll give a quick tour of the app.

Activiti Explorer (The Next Generation) has all the features of the previous version. Some new features include (but not limited to) support for

• Different types of task lists
• Event stream
• Comments
• Standalone tasks
• Subtasks
• Attach any content to a task
• Process instance view
• Administration (previously found in Activiti Probe)
• Profiles

More info & screenshots can be found in the Activiti userguide.

For the tech people: the app has been completely rewritten using Vaadin (you might have noticed we’re big fans). The source can be found in the Activiti svn repo.

 

Screencast

Make sure to set the screen full-size, and change to 720HD (Youtube doesnt allow embedding it as HD and changing the size at the same time – sorry!)

Screencast: BPMN 2.0 import in the Activiti Designer

I mentioned in my last blogpost that the latest release of the Activiti Deisgner is feature-packed. Besides ‘diagram interchange’ support, the other major milestone is support for importing any BPMN 2.0 process.

In the following screencast, I demonstrate that this is no empty promise. Using a non-Activiti BPMN 2.0 editor (the open-source Yaoqiang editor in this case), a process is modeled and later imported and enhanced in the Activiti Designer.

Enjoy! Be sure to set the video to full screen to enjoy it to the fullest

Screencast: from zero to executable process with the Activiti Designer

The Activiti 5.2 release contained tons of new features. One component that has been doing major leaps with every release, is the the Activiti Designer plugin for Eclipse. In the latest release, both BPMN 2.0 ‘diagram interchange’ and BPMN 2.0 import have been added. The first one enables that your process looks exactly the same on every BPMN 2.0 compliant editor. The second one allows to import any BPMN 2.0 compatible process and enhance it in the comfortable environment of Eclipse. Furthermore, the Activiti Designer is completely contributed by four Dutch guys in their free time (and two of them are writing the Activiti book)… yessir, this is one piece of open-source awesomeness.

In the following screencast I demonstrate how you can model a BPMN 2.0 process using the Activiti Designer, how you can easily generate a skeleton unit test from that model and finally how you get it running in Activiti explorer. And that all in less than 10 minutes! Enjoy.

Be sure to set the video to full screen to enjoy it to the fullest

Screencast: process instance visualisation in Activiti 5.2

Another month, another Activiti release! Read all about the newest and best release (so far of course) on Tom’s blog.

One feature that many people have asked for in the past is added to this release: it is now possible to graphically visualize a process instance and show which steps exactly are currently active. I’ve made a short screencast demonstrating this new feature.

Many thanks go to Maciek Próchniak, who contributed this feature. He needed it for an Activiti demo and decided to implement it. That’s open source power at work!

Great technical in-depth blogpost about Activiti internals

Just wanted to give the blogpost of Tomasz Nurkiewicz the exposure it deserves.It is a well-written, in-depth accurate post describing some of the internal workings of Activiti, without forgetting to throw in a funny line here and there. On top of that, you can download the source code of everything he explains at the end of the post!

Furthermore, if you are interested in more articles, screencasts and presentations about Activiti, all are bundled on the following page: http://docs.codehaus.org/display/ACT/Presentations+and+Articles. Feel free to add blogs there, if you think they belong there.

Getting started with Activiti … in less than a minute

At Activiti, we know that first impressions matter. Nowadays, and certainly in the software world, if you don’t convince people within the first ten minutes after download, huge chance that your product ends up in the trash bin.

With Activiti we have set ourselves a more challenging  goal. If we can’t convince people in the first minute after download, we’re doing something wrong.

So no excuses on not having enough time to try out Activiti: getting started with Activiti takes only one minute of your time! Or even less, depending on your machine speed. That’s quite a fresh idea, isn’t it, if you know what hassle it is to get some competitor products running .

To prove we’re serious, the following screencast shows the one minute after downloading Activiti from the website, and running the demo setup, which installs a complete Activiti environment for you.

If you want to do this yourself, just follow these steps:

• Download Activiti from Activiti.org
• Unzip the downloaded file
• Open a terminal window and navigate to the setup folder inside the unzipped folder
• Type ant demo.start and hit enter

And that’s all there is to it!

BPMN 2.0 officially released

It certainly took a while to ‘finalize’ the release of the BPMN 2.0, but the folks at OMG have  tagged BPMN version 2.0 as final !

What does this mean for you and Activiti?

Absolutely nothing, since Activiti already implements the final specification since the 5.0.alpha4 release. The XSD, constructs, sematics etc haven’t changed one bit. Activiti has been and will always be on the front of BPM advancement.

My gut feeling is that very soon you will see many vendors coming out with their BPMN 2.0 support (which might be a reason for the delay of the ‘final tag’ of the spec, according to some of the rumors )

Thanks Camunda for notifying me of this news!

Tutorial: call an EJB in a BPMN 2.0 process using Activiti and Spring

Since its conception, Activiti has always had a great integration with Spring. In this tutorial, I’m going to demonstrate how this integration can be leveraged to call an EJB (the approach works for EJB versions 2 or 3) in a BPMN 2.0 process. Whether you like them or not: the fact is that much business logic has been/is being written in EJB’s, but luckily Activiti makes calling an EJB plain, simple and fun.

The environment for this tutorial is as follows:

• Activiti 5.1
• Spring 3.something
• JBoss 5.1.0

The EJB I’ll use for this tutorial is probably the dullest piece of ‘logic’ you’ve ever seen: it does nothing more than transform the given String parameter to uppercase and return it.

@Stateless
public class ToUpperCaseBean implements ToUpperCaseRemote {

  public String toUpperCase(String s) {
    return s.toUpperCase();
  }

}

This EJB session bean is running on the JBoss server (or any other JEE container).

I’m using the default Activiti-Spring integration, so I’m not going to describe the whole spring config here. Suffice to say I have my ProcessEngine configured as a Spring bean:

<bean id="processEngineConfiguration" class="org.activiti.spring.SpringProcessEngineConfiguration">
  <property name="databaseType" value="h2" />
  <property name="dataSource" ref="dataSource" />
  <property name="transactionManager" ref="transactionManager" />
  <property name="databaseSchemaUpdate" value="true" />
  <property name="jobExecutorActivate" value="false" />
</bean>

<bean id="processEngine" class="org.activiti.spring.ProcessEngineFactoryBean">
  <property name="processEngineConfiguration" ref="processEngineConfiguration" />
</bean>

...

I’m going to run the BPMN 2.0 example process in standard Java environment, so I need to access the EJB through its remote interface. I’m actually going to let Spring do all the hard work, by defining a Spring bean that’ll wrap all the dirty JNDI stuff for me:

<jee:remote-slsb id="toUpperCaseEjbBean" resource-ref="false"
		 business-interface="be.jorambarrez.ejb.ToUpperCaseRemote"
		 jndi-name="ToUpperCaseBean/remote" />

The BPMN 2.0 process in which I’ll call the EJB is again as simple as possible, to make my point. I’m sure you can imagine more awesome scenario’s for it. Here, the process has a start, a call to the EJB, the output of the call (ie the uppercased String) and that’s it.

In BPMN 2.0 XML, this boils down to the following:

<process id="callEjbExample" name="Call EJB example">

    <startEvent id="theStart" />
    <sequenceFlow id="flow1" sourceRef="theStart" targetRef="callEjb" />

    <serviceTask id="callEjb"
                 activiti:expression="${toUpperCaseEjbBean.toUpperCase(var)}"
                 activiti:resultVariableName="var" />
    <sequenceFlow id="flow2" sourceRef="callEjb" targetRef="outputResult" />

    <scriptTask id="outputResult" scriptFormat="groovy">
    	<script>
    		out:println "uppercased version = " + var
    	</script>
    </scriptTask>
    <sequenceFlow id="flow3" sourceRef="outputResult" targetRef="theEnd" />

    <endEvent id="theEnd" />

  </process>

For this tutorial, the serviceTask definition is the most interesting:

<serviceTask id="callEjb"
     activiti:expression="${toUpperCaseEjbBean.toUpperCase(var)}"
     activiti:resultVariableName="var" />

When process execution arrives at the serviceTask, it will execute the toUpperCaseEjbBean.toUpperCase(var) expression. The toUpperCaseEjbBean is actually our wrapped EJB as a Spring bean (see the Spring config above), on which we here invoke the toUpperCase method. This Activiti-Spring-expression integration is pretty cool, right? On the last line, you can see the result of executing the expression is stored in the var variable.

All that is left to do is execute this process on the Activiti engine:

// setup the Spring container and get the Activiti ProcessEngine bean from it
ApplicationContext context = new ClassPathXmlApplicationContext("spring-context.xml");
ProcessEngine processEngine = context.getBean(ProcessEngine.class);

// Deploy process
processEngine.getRepositoryService().createDeployment()
  .addClasspathResource("callEjbExampleProcess.bpmn20.xml")
  .deploy();

// Run process
Map<String, Object> variables = new HashMap<String, Object>();
variables.put("var", "Activiti, the rock-solid BPM engine");
processEngine.getRuntimeService().startProcessInstanceByKey("callEjbExample", variables);

Which spits out (of course) following console output:

And that’s all there is to it! If you want to try it for yourself, here are the sources, packaged as two Maven projects: one for the ejb and one for running the process.

Without Spring?

If you’ve taken a look at the sources, you’ll notice that getting the dependencies right isn’t trivial. Hell, 99% of my time went to figuring out which libraries I needed and why the hell asm was three times on my classpath with different versions.

In the next months, we’ll be adding a ‘native’ way of calling EJB’s in a BPMN 2.0 process, without having to go through Spring. That way, you’ll just need Activiti and we’ll take care of everything behind the scenes. However, the approach in this tutorial can be used for many other use cases: JMS, webservice calls, some legacy system, etc. Conclusion of this story: If you can wrap it in a Spring bean, you can use it in your BPMN 2.0 process.

Adhoc workflow with Activiti: introducing Activiti KickStart

(for those with a limited attention span: there is a screencast at the bottom!)

2010 was awesome. We had the launch and explosive growth of Activiti in ways that none of us were able to forecast when we started the Activiti-adventure. 2011 will continue to amaze, no single doubt about that. To kick of this 2011-amazement-rollercoaster-ride, I’m very proud to introduce the latest addition to the Activiti platform: Activiti KickStart.

What’s this all about?

KickStart grew out of the idea that each and every company has processes that are done in an adhoc way. These are processes that are ‘discovered’ on the fly: some people want to collaborate or a certain document needs to be handled in a specific order by different departements. A BPM platform such as Activiti is a well-suited solution to achieve this, but the threshold and cost to actually model, deploy and execute these kind of processes in the traditional sense is way too high.

Activiti KickStart gives you a simple and intuitive UI that allows you to create such processes in a matter of minutes. No need to model anything, no need to actually know or understand BPMN, no need to do any coding, … KickStart really and seriously lowers the threshold to automate your workflow processes.

The processes created with KickStart are directly deployable to the Activiti repository. They are also immediately usable in Activiti Explorer, and they are fully BPMN 2.0 compliant, which means they can be edited in any modeling tool that understands the BPMN 2.0 file format. And best of all, the workflows can be edited at any time, truly honoring the adhoc nature of these processes.

What can I do with it?

• Adhoc workflow: often, coordination is required between different people or groups in a company. You know how it normally goes: sending an email here, doing a telephone there … which often ends up in a mess of nobody knowing what or when something needs to be done. However, a business process management platform such as Activiti is an excellent way of distributing and follow-up everything, as it is intended to track exactly such things. KickStart allows you to create processes for adhoc work in a matter of minutes, and distribute and coordinate tasks between people easily.
• Prototyping/Proof-of-concept: before diving into complex BPMN 2.0 modeling and thinking about all complex aspects of , it is often wise to get all people involved aligned and work out a prototype that shows the vision of what needs to be done. KickStart allows to do exatcly that: create a business process prototype on the fly, to get your ideas visible for everyone.
• Simple processes: some processes are just simple by nature, and every company has them. Think about an expense process, a holiday leave process, a hiring process, etc… These kind of processes are probably already being done using paper or e-mail. KickStart allows to model these processes quickly and change them whenever it is needed. As such, KickStart really lowers the threshold to automate these business processes.

Obviously, you are not limited to these use cases. As history proves, people always tend to use and enhance these things in ways we can’t image today .

When can I use it?

Activiti KickStart is available today! It is part of the freshly released 5.1 release, and installed by default if you run the Activiti demo setup. Just visit activiti.org and download the latest release, we’re open source after all .

Note that KickStart is by no means ‘finished’ (which software product ever is). But in the Activiti and open source way of doing things, we want to show you as early as possible what we’re cooking. Using the feedback, ideas and contributions of you and the rest of the Activiti community, KickStart will grow and mature in a way no commercial vendor can keep up with us.

Screencast

A picture is worth a 1000th words, so a movie will definitely be able to show you the power and ease of Activiti KickStart.

Automatic BPMN 2.0 process diagram generation in Activiti

Just wanted to give a sneak peek of what I’m working on for the upcoming 5.1 release: automatic BPMN process diagram generation when you deploy a process definition to the Activiti engine. The diagram generation is triggered when your process definition contains the BPMN 2.0 ‘diagram interchange’ (or DI for short) information. This DI information is available when you use the Activiti Modeler and (very soon) the Activiti Eclipse Designer.

The following screencast shows it in working. Here I upload a test BPMN 2.0 process through Activiti Probe. In Activiti Explorer, I can now see the auto-generated process diagram. The generated process is not really usable, is just uses all the constructs which the Activiti engine supports so I could verify I didn’t miss anything