Here the abstract for this webinar:

camunda fox is a light-weight BPM Platform based on the successful open source – project Activiti. It is based on our extensive experiences in BPM and extends Activiti with important components, tools and services that will increase your productivity and allow its application in mission critical standalone BPM scenarios.

In this webinar you will get an overview about camunda fox that allows you to evaluate the platform for your own BPM project.

Register via the Alfresco homepage for free:

• German webinar, 30-May-2012, 10am-11am (Timezone Berlin)
• English webinar, 30-May-2012, 2pm-3pm (Timezone London)

We are looking forward to it

How the user perceives it

The following BPMN shows how the user takes part in the process. Please note, that the whole blog uses the BPMN methodology we explain in our book on BPMN (unfortunately only German or Spanish at the moment) or in this blog post.

The process from the perspective of the user

Note that there are basically two different possible flows for the user, either a score is provided immediately and he can do the whole work at once or the score is provided later and he has to come back later, query his task list and do the last step in the process model from there. To make this more clear, I visualized the flows by adding screen-shots of the application I developed as a prototype:

The user has to come back via the task list when the score is received asynchronously

The user experiences one page-flow when the score is retrieved immediately

The automated process for the engine

As I said earlier, we have an automated business process for implementing this application. Using a process engine for this task comes handy for two features we can leverage in this case: First we need some persistence if the score is not returned immediately and second we want to add some escalation if the answer is not in time. With an BPMN 2.0 Engine like Activiti, we just have to add an attached boundary timer event to really implement an escalation, awesome.

The following image shows the process model as I deploy it later to Activiti, basically three things are remarkable:

• The number of UserTasks does not match the number of forms the user sees. This is not uncommon since the granularity of the user forms is basically dependent on the technology, on your smartphone you might have more forms than in a normal browser on your wide screen at work.
• The form we use to enter the customer data in the beginning does not correspond to an user task. This form is filled before the process instance is started at all (if the user cancels here, no process instance will be started at all).
• We do user validation within the process engine and have a first user task for entering additional data. This means, that if the users stops here and closes his browser, the process instance will remain in the Activiti database and he can continue later from the task list. I decided to model it like this in the demo, it is not the only possibility, agreed, there would be alternatives, but I consider it not to be unrealistic to first have a “safe point” after validation in this case.

Process automated in Activiti

How do we get this together?

In order to understand the big picture we need to have a look at the JSF user interface I developed for our small use case, which is included in the following process model. You can see that for example the customer details are “just” two forms which are implemented by a simple page-flow in JSF (page-flows are built-in). But for the other “flow logic” we need to call the process engine.

User, Activiti and the JSF Layer in between

But how do we get the synchronous one page-flow feeling for the user for this?

UI-Mediator-Pattern

UI Mediator Pattern

Done

The demo application

Cool, but how to implement it? Actually it doesn’t take more than the camunda fox platform community edition, which includes a JBoss AS 7, and an evening of time. The whole application can be checked out from our public SVN: https://svn.camunda.com/fox/demo/fox/customer-registration-ui-mediator/trunk/. You just have to build it using Maven and deploy the resulting war on the fox platform and it should work.

Important addition (2012-April-28): I adjusted the code in the showcase to use JMS for the asynchronous response. That works pretty well and shows how to correlate an incoming JMS message to the right process instance. In order to get this running you have to enable the JBoss full profile to get it working! Here you find the standalone.xml you need, just replace the existing one in your JBoss 7 (or you build that yourself, in our fox user guide we have documentation for this, unfortunately this is currently not open for public but only for our enterprise customers).

Implementation details

I don’t want to repeat how to build process application with the camunda fox stack here, we showed that for example in this blog post and recently wrote a JavaMagazin article which is published soon. I want to concentrate on the UI mediation parts of it, where I used some CDI magic. At least it felt like magic

First I specialize the existing BusinessProcess bean from the Activiti CDI module. Now my own bean is used instead of the original one and I can add additional code which is always executed (a bit like Interceptors). In this bean I only hook in the UiMediator, which is described next.

/**
 * Specializes {@link BusinessProcess} bean to add generic code needed for UiMediator
 */
@Specializes
public class UiMediatedBusinessProcessBean extends BusinessProcess {

  //we do not have a logged in user in the demo app
  private String currentUser = "kermit";

  @Inject
  private UIMediator uiMediator;

  @Override
  public void completeTask() {
    Task task = getTask();
    super.completeTask();

    if (task != null) {
      uiMediator.checkProcessInstanceStatus(task.getAssignee(), task.getProcessInstanceId());
    }
  }

  @Override
  public ProcessInstance startProcessByKey(String key, Map<String, Object> variables) {
    ProcessInstance processInstance = super.startProcessByKey(key, variables);
    uiMediator.checkProcessInstanceStatus(currentUser, processInstance.getProcessInstanceId());
    return processInstance;
  }
}

The UiMediator just does the work I described above: it checks if a task is created for the same user in the same process instance immediately. If yes, it just saves it to some properties, which we can use in the JSF page-flow to route to the correct pages.

@RequestScoped
@Named("uiMediator")
public class UIMediator implements Serializable {

  @Inject
  private TaskService taskService;

  @Inject
  private FormService formService;

  private String nextTaskId;

  private String nextTaskForm;

  /**
   * check for new task in same process for same user
   */
  public void checkProcessInstanceStatus(String assignee, String processInstanceId) {
    nextTaskId = null;
    nextTaskForm = null;
    if (processInstanceId != null && assignee != null) {
      List<Task> tasks = taskService.createTaskQuery().taskAssignee(assignee).processInstanceId(processInstanceId).list();
      if (tasks.size() == 1) {
        nextTaskId = tasks.get(0).getId();
        nextTaskForm = formService.getTaskFormData(nextTaskId).getFormKey();
      }
    }
    // possible extension here: wait a couple of (milli)seconds to check if that task is reached asynchronously if you have this requirement
  }
  public String getNextTaskId() {
    return nextTaskId;
  }
  public String getNextTaskForm() {
    return nextTaskForm;
  }
}

For the page-flow we now add navigation rules, that every time a process instance is started or a task is completed (the later is shown in the code below), we check the UiMediator for a next form. If this is provided we go on this page, otherwise we go back to the task list. The nice thing about this implementation is, that our application does not need any specific code, the whole solution is pretty generic, you only need the correct navigation rule to form a proper page-flow in JSF (maybe if I have another evening of time I will come up with a workaround for this ).

<navigation-rule>
  <navigation-case>
    <from-action>#{businessProcess.completeTask()}</from-action>
    <if>#{uiMediator.nextTaskId==null}</if>
    <to-view-id>/app/taskList.jsf</to-view-id>
    <redirect/>
  </navigation-case>
  <navigation-case>
    <from-action>#{businessProcess.completeTask()}</from-action>
    <if>#{uiMediator.nextTaskId!=null}</if>
    <to-view-id>/app/#{uiMediator.nextTaskForm}.jsf</to-view-id>
    <redirect>
        <view-param>
            <name>taskId</name>
            <value>#{uiMediator.nextTaskId}</value>
        </view-param>
    </redirect>
  </navigation-case>
</navigation-rule>

That’s it. Not so hard actually, right? A good example of the power of using Java EE 6 together with camunda fox (including BPMN 2.0 and Activiti) for Process Applications Feedback welcome!

Compensation

Compensation is a means for “undoing” the effects of an action. For example, say you charge the amount of 500€ to a credit card. If you later detect that this was an error, you may want to undo this. One way of doing that is crediting the same account 500€.

Now wait, isn’t that what transactions are for? Can I not just rollback the transaction in which I charged the 500€ and I am done?  – Well yes, but there are two problems:

• The service you are using might not support transactions.
• You might notice that it was wrong to charge the 500€ too late, at a time where the transaction is already committed.

In both cases we cannot simply “go back in time” and do as if nothing happened. On the contrary, we need to make something else happen, in order to compensate the effects of an action we erroneously committed.

(As we know from real life experience, this is not always that simple and therefore, in general, compensation is not always a strict “undo” action. Consider the case where you send a letter to a customer and then later notice that you need to compensate the sending of the letter. At that point, the customer might have already read the letter. You cannot simply “undo” that fact. What you might do in that situation is send a second letter, asking the customer to forget about the first one.)

Compensation in BPMN 2.0

In BPMN, the concept of compensation is introduced, using compensation events and compensation handlers. For example, the following excerpt of a process shows how we can declare that the “book hotel” activity can be compensated using the “cancel hotel reservation” activity. If a task has multiple instance characteristics (like the “book hotel” task in this example), the compensation handler is invoked for each instance that completed successfully.

The intermediate throwing compensation event allows us to trigger the compensation of the scope it is hosted in or of a specific activity from that scope:

When compensating a subprocess, the execution used for executing the compensation handlers has access to the local process variables of the subprocess in the state they were in when the subprocess completed execution. To achieve this, a snapshot of the process variables associated with the scope execution (execution created for executing the subprocess) is taken. Form this, a couple of implications follow:

Compensation in activiti 5.9

Activiti supports compensation boundary events and intermediate throwing compensation events.

The following limitations apply:

The concept of compensation is also used in transaction subprocesses.

Transaction subprocesses in BPMN 2.0

A transaction subprocess can be used to group multiple activities to a logical unit of work with a consistent outcome. Since BPMN transactions are long running transactions, they make use of compensation for ensuring consistency in case a transaction fails.

A transaction can have three different outcomes:

• A transaction is successful, if it is neither cancelled nor terminated by a hazard. If a transaction subprocess is successful, it is left using it’s outgoing sequenceflow(s). A successful transaction might be compensated if a compensation event is thrown later in the process.
  Note: just as “ordinary” subprocesses, a transaction may be compensated after successful completion using an intermediary throwing compensation event.
• A transaction is cancelled, if an execution reaches the cancel end event. In that case, all executions are terminated and removed. A single remaining execution is then set to the cancel boundary event, which triggers compensation. After compensation is completed, the transaction subprocess is left using the outgoing sequence flow(s) of the cancel boundary event.
• A transaction is ended by a hazard, if an error event is thrown, that is not caught within the scope of the transaction subprocess. (This also applies if the error is caught on the boundary of the transaction subprocess.) In this case, compensation is not performed.

The following diagram illustrates the three different outcomes of a transaction:

Relation to ACID transactions: it is important not to confuse the bpmn transaction subprocess with technical (ACID) transactions. The bpmn transaction subprocess is not a way to scope technical transactions.  A bpmn transaction is different from a technical transaction in the following ways:

Since bpmn transactions are long-running by nature, the lack of isolation and a rollback mechanism need to be dealt with differently. In practice, there is usually no better solution than to deal with these problems in a domain specific way:

To sum it up: while ACID transactions offer a generic solution to such problems (rollback, isolation levels and heuristic outcomes), we need to find domain specific solutions to these problems when implementing business transactions.

Transaction Subprocesses in Activiti 5.9

The BPMN specification requires that the process engine reacts to events issued by the underlying transaction protocol and for instance that a transaction is cancelled, if a cancel event occurs in the underlying protocol. As an embeddable engine, activiti does currently not support this.

A bpmn transaction guarantees consistency in the sense that either all activities compete successfully, or if some activity cannot be performed, the effects of all other successful activities are compensated. So either way we end up in a consistent state. However, it is important to recognize that in activiti, the consistency model for bpmn transactions is superposed on top of the consistency model for process execution. Activiti executes processes in a transactional way. Concurrency is addressed using optimistic locking. In activiti, bpmn error, cancel and compensation events are built on top of the same acid transactions and optimistic locking. For example, a cancel end event can only trigger compensation if it is actually reached. It is not reached if some undeclared exception is thrown by a service task before. Or, the effects of a compensation handler can not be committed if some other participant in the underlying ACID transaction sets the transaction to the state rollback-only. Or, when two concurrent executions reach a cancel end event, compensation might be triggered twice and fail with an optimistic locking exception. All of this is to say that when implementing bpmn transactions in activiti, the same set of rules apply as when implementing “ordinary” processes and subprocesses. So to effectively guarantee consistency, it is important to implement processes in a way that does take the optimistic, transactional execution model into consideration.

The following is a larger example of a transction subprocess which can be executed by activiti:

Message Start Event

Example with multiple message start events

We now support the message start event, not only the none start event. The difference is basically the API method you have to call and the big advantage is, that this allows multiple start events in one process model, as you can see in the example. The API is pretty straightforward and allows to name the incoming message:

RuntimeService.startProcessInstanceByMessage(String messageName);

To handle the message start events we added infrastructure to Activiti 5.9 to handle messages overall. So we are currently only one step away from supporting intermediate message events, message events on event based gateways and boundary message events. We currently expect this to appear with Activiti 5.10 (scheduled for first of august).

Signal Event

We added the BPMN 2.0 Signal as you can see in the example on the left. A Signal can be either triggered by some throwing event from within the engine itself or you can trigger it from the outside of Activiti with a new API call:


RuntimeService.signalEventReceived(String signalName);


Intermediate Throwing None Event used for KPI’s

Example of intermediate none event

A small change in the code but a huge step for Business-IT-Alignment: We added the intermediate throwing non event, which basically does nothing. The spec says this should be used to mark an intermediate state (or milestone) in a process. This makes is a perfect place to record some KPI’s and it is more natural to read than some service tasks doing this (the workaround before Activiti 5.9). To the intermediate event you can attach some logic which is executed when a process instances passes by, this is done in the normal Activiti way by using a configurable execution listener. Here you can pass information to your BAM or BI solution for monitoring purposes. This is how the XML looks like:

<intermediateThrowEvent id="noneEvent">
  <extensionElements>
    <activiti:executionListener event="start"
        class="com.camunda.SampleKpiListener" />
  </extensionElements>
</intermediateThrowEvent>

Event Subprocesses

Event Sub Process

Event sub processes can be triggered by an event (like message events, error events, signal events, timer events, or compensation events) and are either interrupting the normal process flow or they create a new token and work in parallel (non-interrupting). This is quite powerful to handle interruptions in the normal flow or to handle e.g. inquiries for a process instance which should not disturb the normal flow. In Activiti 5.9 we added only the interrupting behavior for error events, the non-interrupting one and all other event types are still open issues and good candidates to be included in 5.10 (especially the message event).

Event based gateway

Event Based Gateway example

The event based gateway allows to wait for the occurrence of one of multiple events, you can already use timers and signal events here, message shall follow in Activiti 5.10.

BPMN Compensation and Transactions

Another great thing we started is to support BPMN 2.0 transactions, cancellation and compensations. This is in an early experimental phase (so please go ahead, try it out and tell us your feedback!), but some basics area already included in Activiti 5.9. Daniel has an own blog post ready especially for that topic, so stay tuned, that will be published shortly on this blog.

Limitations

We basically concentrated on the engine and the camunda fox tool chain with the fox-modeler (OEM based on Signavio) and the fox-designer (based on the Eclipse BPMN2 Modeler). Since these tools know the full range of BPMN 2.0 they are already capable to handle the new features. If you work with your own BPMN 2.0 compliant modeler, it should work as well.

In the Activiti Open Source project please note that the Activiti Designer (Eclipse) does not yet support all the new elements and the graphical visualization of processes in the Activiti Explorer (Web-GUI) cannot render some of them new elements, leaving “white holes” or some wrong renderings in parts of the process.

We have a new story about process visualization and the “where am I in the process” pics on the near roadmap, then we should be able to be full BPMN 2.0 compliant here as well and bypass limitations with the current rendering on IBM Server machines. Stay tuned for this!

Please note, that we marked some of the constructs as “experimental” in the Activiti user guide, because they are pretty fresh. We work on stabilizing them for camunda fox and Activiti 5.10.

Other new features worth mentioning

• Error boundary Event now can handle faults on service tasks: By this you can catch and handle exceptions from Java code executed from a service task. Before 5.9 you could only catch errors from an error end event within a subprocess.
• Suspending and Resuming Process Definitions and Instances: We now have support in the API to “pause” instances or whole process definitions. Then the process instance cannot move on and no timers or the like fire (until you reactivate the instance). I see a couple of use cases for this, starting from a temporary problem in a single process instance to an emergency stop to whole process definitions. The API looks like this:
  
  RuntimeService.suspendProcessInstanceById(String processInstanceId);
  RuntimeService.activateProcessInstanceById(String processInstanceId);
  RepositoryService.suspendProcessDefinitionByKey(String processDefinitionKey);
  RepositoryService.activateProcessDefinitionByKey(String processDefinitionKey);

• Exclusive jobs and plugability of the job executor infrastructure: We can now exchange the job executor easily, which we needed for our camunda fox platform, especially for support of WebSphere, WebLogic and the like, where we use the application server capabilities instead of starting an own thread pool (as Activiti does it out-of-the-box). Exclusive jobs now add more “safety” by default but allow for more configuration for the advanced. This will be explained in more depth by a later blog post of Daniel.

For all the details have a look into the release notes.

Special thanks to…

I really want to thank my camunda team for their excellent work on the Activiti 5.9 and the camunda fox 6.0.0 release. The BPMN language additions would not be possible without you guys! Namely that is our fox scrum team (with Andreas, Christian, Roman and partly Nico), Daniel who really did an outstanding job in implementing new infrastructure in the Activiti core engine almost besides his other work and Falko, who basically is Mr. BPMN 2.0 Specification Great job! Thanks as well for the Alfresco guys for a lot of housekeeping, community and coding work. Special thanks go to Tijs, who seems to never sleep.

Download it now

Download Activiti 5.9 from the Activiti Website today. By the way: We work on a community release of camunda fox as well, which basically includes a community version of our JBoss 7.1 integration (some of you may know that as the “fox-server-preview”). We plan to finish that end of march, so the next milestone is already in sight!

Weiter geht es mit Jakob, der den aktuellen Stand zu “BPMN – Best Practices & Roundtrip” darstellt, klingt wie immer, ist aber auch wie immer ganz neuer Content, da sich in einem halben Jahr doch immer viel verändert.

Nach dem Mittagessen geht es weiter mit Michael Paulsen, besser bekannt als Pul, vom Versandhaus Bader, der aus Kundensicht einmal Ihr BPM Vorgehen beschreibt, das Ganze unter dem Titel “Geschäftsideen auf die Straße bringen – Was die IT für eine agile, prozessorientierte Unternehmensarchitektur leisten kann“.

Dann kommt Anne Rozinat von Fluxicon und beleuchtet einmal das zugegeben noch futuristische, aber meiner Meinung nach sehr interessante Thema “Process Mining: BPM auf den Kopf gestellt“. Ich habe sie gebeten, das auch konkret an Hand von Praxisbeispielen zu illustrieren.

Last but auf jeden Fall not least kommen noch Gernot Starke und Daniel Lübke und erzählen über den “Einsatz von arc42 zur Architekturdokumentation in Prozessautomatisierungsprojekten“. Auch wenn sie sich etwas gesträubt haben auf den BPM Day zu kommen, finde ich persönlich das Thema genau in der Kombination super spannend und bin sehr gespannt auf den Vortrag.

Activiti Vorträge
Zu Activiti gibt es dann wie versprochen auch 2 Vorträge, allerdings nicht auf dem BPM Day sondern

• Auf dem Finance Day (am Dienstag 17.04.2012) erzählt mein Kollege Nils Preusker mit mir über “eine leichtgewichtige BPM-/SOA-Infrastruktur mit Activiti und Camel“, wobei wir aktuelle Erfahrungen aus einem Kundenprojekt im Bankenbereich “verarbeiten”.
• Auf dem Java EE Experts Day (am Freitag 20.04.2012) habe ich dann mit meinem Kollegen Daniel Meyer sogar 1,5 Stunden Zeit mit “BPM und Java EE : Das perfekte Team für Prozessanwendungen?” richtig in die Tiefe einzusteigen und die Verbindung von Java EE 6 mit einer leichtgewichtigen Process Engine (zufällig Activiti ) darzustellen und gerne auch zu diskutieren.

Die JAX wird also richtig spannend, ein Besuch lohnt sich!

SOA, BPM & Integration Days 29.02-01.03.2012 in München

Vom 29. Februar bis 1. März 2012 präsentiert das Business Technology Magazin die nächsten SOA, BPM & Integration Days. Die hochkarätige Konferenz richtet sich an Softwarearchitekten, IT- und Projektleiter, die ohne jeglichen Marketingfilter und ohne langatmige Einführungen, praktisches Kow-how für ihre geschäftskritischen Projekte erhalten möchten. Insgesamt 24 Sprecher, 12 interaktive Sessions, ein Speaker Panel, 2 Keynotes und 6 Workshops stehen zur Auswahl. Teilnehmer profitieren vor Ort von der Autorenrunde des SOA Spezial Magazins (Publikation von Software & Support Media), von bekannten Buchautoren und langjährigen Sprecher der JAX-Konferenzen. Im Mittelpunkt der SOA, BPM & Integration Days 2012 stehen diesmal vor allem drei Schwerpunkte: Adaptive Prozesse, SOA-Security und Systemintegration. Weitere Informationen zur Konferenz finden Sie auf www.soa-bpm-days.de.

Dort gebe ich pünktlich zum Activiti 5.9 Release am Donnerstag den 01.03. einen “Power-Workshop” zu Activiti: Activiti – Die „Less-Code“-BPM-Plattform für Softwareentwickler. Kommen lohnt sich! Ich freue mich auch hier auf Diskussionen und Feedback zu Activiti.

Get ready for your free lunch

The true value of Open Source

Let me start with a very short story I experienced myself: We use Zimbra, an Open Source Exchange alternative. They have an API. I wanted to develop a small tool helping in resource allocation for consulting, basically by accessing the calendars. The documentation was lousy. But I could get it running pretty quickly, because I used Maven, which accesses the sources, downloaded them and I could look into the project sources in a minute without any hazzle. I never wanted to write a single line in Zimbra, but I could understand how it was meant to be and could debug into it, so I could finish my project right away.

Believing that the true (and only) benefit of Open Source is getting something for free is wrong! But having the source code available helps in your projects and fastens development. And by the way this is a great possibility to improve your development skills, by looking into a lot of other code, see what is understandable for somebody new to the project, experience good interface design and so on. I really think there is no other good way of coding the future, than to have the source available.

And it brings you another very important advantage: less risk. You can always understand the code, maybe even fix a bug yourself in an emergency and find a lot of Java consultants out there, who are able to help.

camunda fox Open Source Strategy

So source code is vital, that is something we believe. That is why we ship the source code for all components of our platform to the client (with the exception of the fox modeler, since it is an OEM deal with Signavio, not our code). But we do not open source all of it. Why this?

Because we want to protect some of our investments in camunda fox, the pain and learning we did the last year, the code we wrote. In short: We want to keep our business case healthy. Even open source enthusiasts should understand this, because the open source projects (like Activiti) benefit from it as well (as described above). But we want to be fair and honest (truly!) and that’s why we stick to a clear rule: If we collaborate in open source projects, what we do there is open source as well.

Currently that means we leverage, collaborate with and contribute to two open source projects:

• The embeddable Activiti Engine.
• The Eclipse BPMN2 Modeler project.

To draw a clear line it means, that nothing else of what we do on top of these projects in camunda fox is open source (at least not at the moment, but not planned as well to be honest). This includes the application server integration (e.g. WebSphere), the monitoring tool fox-cockpit, the Business-IT-Alignment tool fox-cycle and the camunda fox extensions for the Eclipse Designer (then called fox-designer).

There are two things in this statement maybe confusing Activiti old hands:

1.) Cycle is not Open Source?

True, cycle – kicked of as camunda fox in the beginning – was soon merged into the Activiti project and got Activiti Cycle under open source license. That was a time when there was a Activiti Modeler and the Open Source project aimed for a full BPM platform. This was actually a too big scope, so the Activiti Open Source project focused on the embeddable engine and removed components not in scope of that (this was a longer discussion to be honest). That’s why we moved cycle to camunda fox. Since maintaining the Activiti Modeler (an outdated older, but open source version of the commercial Signavio tool) was not on our road-map, we focused on getting this to work with the commercial Signavio. We always only open sourced connectors for cycle suitable for open source tools. So with JIRA and Signavio we basically didn’t had much left to open source, so we decided to better make a clear communication and no half-baked open source and removed Cycle as an open source project, where we currently do not have the time and energy to make a proper open source project out of it. That’s why it vanished from the open source space, and I am sorry that this was not clear from the beginning. On the other hand we have not yet seen adoption in the open source world anyway.

2.) Is the camunda fox Eclipse Designer different than the Activiti Designer?

Yes, indeed. Alfresco has a very different goal with Activiti, which is document management workflows within their ECM. We go for BPM. That means, we have much more requirements on the completeness of BPMN elements, but as well on the robustness and usability of the graphical tooling, where the Activiti Designer has some limitations. That’s why we joined the Eclipse BPMN2 Modeler project and use that as a basis to add our own extensions to maintain everything needed for camunda fox/Activiti. Everything we do in the Eclipse Plug-In is Open Source, only the extensions are part of the commercial camunda fox platform, since the open source effort is currently bundled in the Activiti Designer.

Thanks for reading

Actually the posts from today were long. But I felt some urge to write it because of various feedback I got, and to express the value “transparency and clear communication”, which is really important to me as individual and camunda as a company. And I thought I should explain basically the Java developers out there, what we are doing and why, because I am sure that Activiti is the best thing since sliced bread (or maybe even better), and it will never die as long as at least some of you consider buying camunda fox Let me know what you think…

For a dead horse this is moving too fast...

Productization of camunda fox and Alfresco ECM

commit progress activiti svn

• integration: We integrated Activiti in various Java EE 6 application servers.
• cockpit: a web-tool for process controlling, monitoring and administration.
• designer: an eclipse plug-in for the developer to model BPMN 2.0 (not based on the Activiti Designer, see next blog post of today).
• modeler: a web-based BPMN 2.0 editor targeting business users (based on Signavio).
• cycle: a business-it alignment tooling capable e.g. of the round-trip with BPMN 2.0 between designer and modeler.

commit progress all fox repos

Why do I tell you that? Because that matters a lot for the future of the Activiti project in the long run. Since we make sure that we have an aligned tooling and a business case, where we can earn money. We build a stable business on top of Activiti, as does Alfresco. We both worked on our product in the last months, so there was less time to invest in the Open Source Engine and the Community. I am sorry for this, but actually I think it was a good decision for the longer future.

But wait, shouldn’t investment in the community pay off by itself? That is one of the drivers of open source, give-and-take, right? I think yes, but first a process engine is not Linux, it is a niche product, and second the core of the engine is quite critical, where you should not mess around. Typically contributers come when they work on a customer project, but go when this project went live. We always have ramp-up and project management overhead with every contribution, that is why there are not just a present. Every patch or feature provided must be reviewed, properly tested, maybe discussed and maintained in the long run. Just because it is open source don’t ease these requirements of professional software engineering.

And even then it is sometimes hard to channel these contributions into proper product management. And product management is something a lot of open source projects are missing. Done right this leads to a better product. Unfortunately I forgot who told me this quote, but it goes: “The problem of Open Source projects is, that they don’t have a customer“. I think it is true, you have to have customers driving your product and priorities, then you get in the right direction, but you need to invest time and energy to listen to your customers and process their feedback.

This adds another possible stumbling block: If you have passionate individuals in your open source project, coding new features in their free time at night, they easily become frustrated if business priorities does not match personal preferences. Let’s face it: This is why professional software development is not a hobby, it is a job (even if it involves much more fun and passion than a lot of other jobs, puh, lucky us). Another way of thinking about it is expressed in the book “crossing the chasm“: We try to make Activiti/camunda fox ready to enter a market, where you don’t have to be a Java crack in order to get a process engine running and where you have to set up your tool chain yourself. It is about providing some “peace of mind” (which should NOT be confused with zero code bpm suites, but that is something I think I don’t have to mention again in this post). It shall bring the right tooling even to people which now have to use some proprietary but technically inferior tooling because of lacking productization in open source technology.

So this is my thinking on commercial open source. This is why I think that productization is the more important thing in the current phase for Activiti even if that means that we have less time for the community. It will be good in the long run.

But: Amazing new features in Activiti 5.9

That’s said, there are some really good news about Activiti 5.9, which will be released on first of march (as documented in our Wiki by the way). We did develop quite some new features, most of them for our customer to be honest, but available for everybody, e.g.:

• Intermediate signal event (throw / catch),
• Intermediate none event (usable for KPI’s),
• Event based gateway,
• Interrupting error event subprocesses,
• (Multiple) message start events,
• BPMN 2.0 transaction sub process, cancel end event & cancel boundary event,
• BPMN 2.0 compensation activities and throwing compensation event.

Wait for the final list when we will release 5.9, some of the features mentioned will be marked experimental until they have stabilized, we expect Activiti 5.10 to contain everything rock-solid! Regarding transparency, you can see the detailed issues in the Activiti JIRA. That’s quite some work we did at camunda for our open source community, isn’t it? So Activiti is far from being dead. Believe me

Since this post started to get a bit more philosophical anyway, I want to add a second blog post immediately about the camunda fox open source strategy, since this is a question we get as well, especially since Activiti Cycle became camunda fox cycle, feel free to read as well: camunda fox open source strategy.

Als kleiner Vorgeschmack kommen jetzt schon mal zwei Auszüge: Das Vorwort zur 3. Auflage, und ein Interview mit John-Uwe Scherberich von Energie Südbayern, die BPMN für die Prozessdokumentation in 2011 eingeführt haben (siehe auch unser Praxisbericht). Viel Spaß beim Lesen

Vorwort zur 3. Auflage

Kürzlich, beim abendlichen Bier am Rande einer Konferenz, fragte uns eine gar nicht so unbekannte Persönlichkeit der deutschen IT-Szene: “Ihr bei camunda, ihr seid doch so ein junges, unkonventionelles Team. Warum beschäftigt ihr euch eigentlich mit so einem Alte-Männer-Thema wie BPM?”.

Das hat uns zu denken gegeben.

Business Process Management ist also ein Thema für alte Männer? Zugegeben, es weckt gewisse Assoziationen an dunkle Anzüge und diskrete Krawatten, also an die typische, das Selbstbewusstsein unterstützende Berufsbekleidung von Leuten, die sich nicht sicher sind, ob ihre Arbeit eigentlich einen Nutzen stiftet. Das ist nicht gerade jung und unkonventionell, und zu unserem Selbstverständnis passt das auch nicht. Aber, fragten wir uns, warum macht uns BPM dann so viel Spaß?

Weil wir mit BPM dafür sorgen, dass ein Unternehmen besser funktioniert! Das gilt auch und gerade für den Einsatz neuer Technologien, weshalb BPM-Projekte häufig einen sehr innovativen Charakter besitzen. Es ist einfach unglaublich spannend, völlig neue Möglichkeiten der Wertschöpfung nicht nur grundsätzlich zu erforschen, sondern auch ganz konkret umzusetzen. Und das nicht “nur” auf der konzeptionellen Ebene, in strategischen Papieren oder PowerPoint-Präsentationen, aber eben auch nicht “nur” in den Tiefen der technischen Implementierung, in denen man gar nicht mehr weiß, warum eigentlich dieses oder jenes programmiert werden soll. Sondern eben ganzheitlich, sowohl betriebswirtschaftlich als auch softwaretechnisch, von Anfang bis Ende und A bis Z.

Wir kennen keine Disziplin, die einem so umfassenden Anspruch mit derart konkreten Methoden und Technologien gerecht wird wie BPM.

Außerdem glauben wir, dass das ganze Thema “BPM” in eine neue Phase eingetreten ist, die mit dem traditionellen Verständnis von Prozessmanagement im Sinne verstaubter Organisationshandbücher, abgehobener “Performance-Analysen” und wohlklingender, aber völlig unverbindlicher Management-Empfehlungen nichts mehr zu tun hat.

Wir treffen mehr und mehr Menschen, die sich um derartiges Geplänkel nicht scheren, die einfach nur wollen, dass etwas besser funktioniert. Das sind die “neuen BPM-Cracks”, und sie sind ungeduldig. Sie interessieren sich nicht für politische Ränkespiele und akzeptieren keine scheinbaren Sachzwänge. Sie beherrschen neue Methoden und Tools, und diese nutzen sie, um denjenigen zu helfen, die bereit sind, neue Wege zu gehen und damit diejenigen zu überholen, die lieber im Status quo verharren.

Diese neuen BPM-Cracks nutzen BPMN. Sie haben verstanden, dass BPMN anspruchsvoll ist und wenig zu tun hat mit dem Malen von Ablaufdiagrammen, die für die bereits erwähnten Organisationshandbücher verwendet wurden. Sie gehören einer weltweiten Community an, die einen gemeinsamen Standard nutzt und weiterentwickelt. In dieser Community gibt es nicht mehr “die IT”, der man einen Auftrag übergibt und die diesen gefälligst umzusetzen hat. Die IT ist kein Bestandteil, sondern eine Facette dieser Community, so wie sie eine Facette eines modern aufgestellten Unternehmens ist, in dem Business und IT völlig losgelöst von der Abteilungszugehörigkeit eine vertrauensvolle, kontinuierliche und sehr intensive Zusammenarbeit praktizieren.

BPMN wurde im Februar 2011 in der Version 2.0 verabschiedet, und in der Praxis ist sie mittlerweile etabliert. Der Standard wird zur Prozessdokumentation genutzt, für die Analyse und Verbesserung von Prozessen und natürlich für die Prozessautomatisierung. Wir haben inzwischen über 500 unterschiedliche Menschen in unseren Projekten und Seminaren an BPMN herangeführt und die unterschiedlichsten Abläufe modelliert. Wir haben auch ihre Grenzen kennengelernt, beispielsweise bei der Modellierung von Prozessen, die von Fall zu Fall höchst unterschiedlich ausfallen und daher schwer vorherzusehen sind.

Unter www.bpmn.info/anwender finden Sie eine Auflistung von Organisationen, die BPMN einsetzen. Bei vielen wird BPMN in der Breite genutzt, also mit zahlreichen Modellierern. Daraus ergeben sich besondere Herausforderungen, weshalb wir diesem Thema in der 3. Auflage ein neues Kapitel gewidmet haben.

Wir wünschen Ihnen Erfolg bei der Arbeit mit BPMN und hoffen, auch Sie in den Reihen der unkonventionellen Menschen begrüßen zu dürfen, die eine Menge Spaß an einem scheinbaren “Alte-Männer-Thema” haben.

Einführung von BPMN: Ein Interview

John-Uwe Scherberich, Leiter Organisationsentwicklung

Jakob: Hallo John-Uwe, Du hast in 2011 mit Deinem Team bei der Energie Südbayern eine erfolgreiche BPM-Initiative gestartet. Was wurde bislang erreicht und was möchtet Ihr noch erreichen?

John-Uwe: Für unser Team der Organisationsentwicklung und der damit verbundenen Rolle “Zentraler Prozessmanager” stellte sich die Aufgabe, wie wir eine möglichst einfache und leicht zu handhabende Prozessdokumentation im Unternehmen vorhalten.

Hier sind dann im Laufe der Jahre die verschiedensten Prozessmodelle und deren Dokumentation entstanden. Es wurden Prozesse in den unterschiedlichsten Anwendungen und Dateiformaten erstellt. Von Excel-Diagrammen über PowerPoint-Präsentationen bis hin zu Visio-Prozessmodellen, die teilweise sogar in Word-Dokumente eingefügt wurden – alles das hat sich in den letzten Jahren so angesammelt. Von einem Standard war da wirklich nicht zu sprechen, obwohl wir natürlich hinsichtlich der Prozessmodellierung unsere Empfehlung hatten.
Begleitet hat uns in all den Jahren eine übersichtliche Prozesslandkarte, die alle unternehmensrelevanten Prozesse darstellt. Damit die Dimension deutlich wird: Wir reden hier von über 200 Einzelprozessen in verschiedensten Detailierungsstufen und auch unterschiedlichsten Komplexitätsgraden.

Unsere Herausforderung und Motivation in 2011 bestand einerseits darin, ein verbindliches Regelwerk und einen Standard für die zukünftige Prozessdokumentation, für die Verwaltung und Versionierung und für die Aufgabenstellung der am GPM Beteiligten zu schaffen. Andererseits war es das Ziel, die Prozessarbeit auch weiterhin in den jeweiligen Fachbereichen dezentral aufzustellen, und ein auf unsere Bedürfnisse abgestimmtes internes GPM-Netzwerk zu schaffen. Transparenz über die Prozessarbeit für das ganze Unternehmen ist uns dabei sehr wichtig. Und das haben wir erst mal geschafft!

So sehen wir unsere künftigen Schritte: Wir wollen unsere Prozessmodelle optimieren und hinsichtlich ihres Reifegrades weiterentwickeln, was besonders für unsere Massenprozesse gelten wird. Hier werden wir verstärkt eine neue und erweiterte IT-Sichtweise in die Prozessmodellierung einbringen.

Jakob: Warum habt Ihr Euch zu Beginn des Projektes für BPMN entschieden und nicht für eine andere Prozessnotation?

John-Uwe: Wir haben Erfahrungen mit unterschiedlichen Notationsformen gesammelt, unter anderem auch mit EPK-Modellierungen. BPMN 2.0 erschien uns von Anfang an sehr attraktiv, da sie eine klare und eindeutige Logik hervorbringt. Sie ist einfach zu modellieren und liefert hinsichtlich ihrer Skalierung in der Anwendung hervorragende Optionen.

Jakob: Ihr setzt die BPMN bislang vor allem für die organisatorische Prozessdokumentation ein. Kritiker behaupten gerne, die BPMN sei gerade für diesen Zweck zu kompliziert. Wie siehst Du das?

John-Uwe: Diese Aussage kann ich nicht unterstützen. Die eindeutige Logik der Notationssprache macht es am Ende doch einfacher, oder?
Unserer Erfahrung nach ist es hilfreich, am Anfang eine Vorauswahl der zu verwendenden BPMN-Symbole zu treffen. Nach gewachsenem Grundverständnis und entsprechender praktischer Übung bei den Modellierern kann das Angebot der Symbolpallette sukzessive erweitert werden.
Des Weiteren bin ich der Meinung, dass es eher die Softwaretools sind, die das ganze kompliziert machen. Umso wichtiger war es uns, ein Tool zu finden, das zu unseren Bedürfnissen passt. Dafür haben wir einen erheblichen Teil unserer Zeit investiert.

Jakob: Was sind aus Deiner Sicht die wesentlichen Erfolgsfaktoren und Best Practices, wenn man mit BPMN arbeiten möchte?

John-Uwe: Erst einmal sollte man aus der Veränderungsmotivation heraus das große Bild entwickeln. Ganz am Anfang ist die Frage zu beantworten:”Was wollen wir erreichen?”. Die Ziele dann SMART zu definieren, versteht sich von selbst. Ich warne eindringlich vor zu hoch gesteckten Zielen, die sich am Ende als unrealistisch herausstellen. Im nächsten Schritt geht es darum zu hinterfragen, wer dabei unterstützen kann und bei wem Widerstände welcher Art zu erwarten sind. Als geeignete Methode bietet sich hier die Erarbeitung einer Stakeholder-Matrix an. Und damit ist man dann schon mitten im Change-Management-Prozess. Dieser ist m.E. schon zu Beginn zwingend zu berücksichtigen und einer der wesentlichen Erfolgsfaktoren für die Implementierung.
Erst dann ist die Frage des Tools und dessen Funktionsumfangs zu erarbeiten. Die Anforderungen müssen in einem Lastenheft konkret formuliert werden. Das unterstützt die spätere Toolauswahl. Ab diesem Prozessschritt geht nichts mehr ohne die zukünftigen Anwender. Da sie diejenigen sind, die mit dem Tool arbeiten müssen und hoffentlich auch wollen, ist ihre Meinung und ihre Anforderungsdefinition so wichtig. Der Rest orientiert sich an dem klassischen Prozess des Software-Auswahlverfahrens, der Implementierung der Anwendung, den Tests und dem Roll-Out. Ich empfehle, bei der Auswahl des Tools auf jeden Fall den sogenannten Beauty Contest durchzuführen. Man sollte sich die Software vom Hersteller direkt vorstellen lassen und selber im Team auf einer Testumgebung eigene Erfahrungen sammeln und dokumentieren. Oft kommt es in dieser Phase noch zu Veränderungen der Anforderungen und ihrer Priorisierung.
Im Rahmen des Change-Managements haben wir auch die Erfahrung gemacht, dass die Einführung eines neuen Verfahrens für die Prozessmodellierung und -dokumentation schon frühzeitig in der Einführungsphase zu kommunizieren ist. Wir haben dazu in unserem Intranet ein Wiki installiert und regelmäßig über den Stand der Einführung und die tägliche Prozessarbeit kommuniziert. Auch die entsprechenden Regelwerke sind hier erfasst und stehen allen Prozessverantwortlichen zur Verfügung.

Jakob: Und was würdest Du aus heutiger Sicht anders machen?

John-Uwe: Aus heutiger Sicht würde ich noch früher einen konkreten und klar umrissenen Rahmen für die Prozessarbeit, deren Anforderungen und Regelungen verbindlich vereinbaren und im Rahmen der Betrieblichen Dokumentation publizieren. Das bringt dann ein klares Commitment aller Beteiligten zu dem Vorhaben.

camunda @CeBIT

If you are visiting CeBIT 2012 and you are interested in the topics above, you shoud also pay a visit to camunda’s booth in Hall 2, Booth B68. We will share our extensive project experiences in BPMN 2.0 and Activiti with you, and will explain and demonstrate, why camunda fox is the best Enterprise Solution, if you plan to automate your business processes in a Java-environment.

Have we peaked your interest? Then we look forward to meeting you there

By the way: If necessary, you can also get a free CeBIT Ticket from us. Please contact Maria Courmont.

camunda bei der Neujahrsfeier 2012

2012 ist schon nicht mehr ganz so jung – aber für alle, die sich für camunda generell interessieren, kommen jetzt ein paar Status-Infos zum Stand unserer Unternehmensentwicklung:

In 2011 haben wir erstmalig mehr als eine Million EUR Umsatz erzielt (sogar deutlich mehr). Das macht uns natürlich stolz, zumal wir nicht einfach “irgendeine Unternehmensberatung” oder “irgendein IT-Dienstleister” sind, und ständig “irgendwelche Consultants” in Projekte stecken, nur um kräftig Tage zu fakturieren. Stattdessen fokussieren wir uns nach wie vor zu 100% auf BPM, und treten viel mehr als “Enabler”, also “Befähiger” unserer Kunden auf, denn wir geben konzentriertes Know-how zu einem abgrenzbaren Themenkomplex weiter. Dementsprechend kurz sind in der Regel auch unsere Einsätze, und dementsprechend breit ist unsere Kundenbasis: Insgesamt haben 254 unterschiedliche Unternehmen und Behörden in 2011 unsere Leistungen in Anspruch genommen, wovon 48 Neukunden waren.

Aber natürlich gab es auch Projekteinsätze, die wir vor allem deshalb durchführten, weil wir bei spannenden und innovativen BPM-Projekten gerne am Ball bleiben und daraus wiederum Know-how für unser “Premium Consulting” ziehen. Zugenommen haben in 2011 auch die “begleitenden Coachings” auf Basis eines punktuell abrufbaren Kontingentes, wie es zum Beispiel Energie Südbayern für die Einführung von BPMN in Anspruch genommen hat (siehe Praxisbericht).

Neben den Themen BPM im Allgemeinen und BPMN im Besonderen hat in 2011 auch ganz klar das Thema Activiti zugenommen: Deutlich mehr als die Hälfte unserer Einsätze im Premium Consulting und der Projektarbeit bezogen sich auf diese ja noch vergleichsweise junge Open Source BPM-Lösung. Wir merken also sehr deutlich, dass Activiti in der Praxis angekommen ist und im Grunde einen ähnlichen “Siegeszug” erlebt wie die BPMN – wenn auch im kleineren Maßstab. Besonders spannend ist für unsere Consultants auch der Einsatz im Ausland, der dank Activiti in 2011 bereits spürbar zugenommen hat (innerhalb Europas, aber auch weltweit).

Da der Einsatz von Open Source beim Kunden natürlich einige Fragen aufwirft (Support, Stabilisierung, aber auch fehlende Features) ist es kein Wunder, dass wir diese Fragen zunächst punktuell, inzwischen aber auch in einer vollständigen Lösung beantwortet haben: camunda fox wurde geboren. Wer sich für die Aktivitäten von camunda in 2012 interessiert, findet hier auch bereits die primäre Antwort .

Mit dem Auftragseingang ist natürlich auch unsere Mannschaft gewachsen, die inzwischen 16 Köpfe zählt und Anfang Januar ihre traditionelle Neujahrsfeier zelebrierte (siehe Foto, wenngleich vier Kollegen leider nicht dabei sein konnten). Wir sind also – ganz bewusst – nach wie vor ein überschaubares Team, und ich denke in mancherlei Hinsicht auch ein einzigartiges: Hervorragend in unserer Kernkompetenz BPM, sind wir gleichzeitig unseren Werten verbunden. Viele der scheinbaren Sachzwänge der traditionellen Geschäftswelt werden von uns schlicht und egreifend ignoriert, und wir sind nicht trotzdem, sondern gerade deshalb erfolgreich.

Wer also BPM liebt und gleichzeitig den Mut hat, neue Wege zu gehen, damit eine Organisation besser funktioniert, den laden wir herzlich ein, uns auch in 2012 zu begleiten: Als Kunde, Partner oder Mitarbeiter. Gemeinsam werden wir eine Menge bewegen