Follow our Blog by Email

Wednesday, July 23, 2014

News from the front-(end)

The front-end of the camunda BPM platform has been under heavy development.
The web-apps have been externalized and separated into different projects,
which means that the "admin", the "cockpit" and the upcoming "tasklist" have their own repositories,
and those projects are now relying on the "UI commons" and the "Javascript SDK" libraries.

Tuesday, July 22, 2014

Embedded Case Management with CMMN in camunda BPM

In our latest alpha release we include a preview of the upcoming support for CMMN (Case Management Model and Notation) in camunda BPM. Time to have a look at CMMN and the way it is implemented in camunda BPM.

Monday, July 21, 2014

Scripting Everywhere in camunda BPM

With the last camunda BPM 7.2.0-alpha3 release we heavily extended the scripting support of the camunda BPM platform. We started to improve scripting support with the 7.2.0-alpha1 release and now we think we are done. It is now your turn to start using the different scripting languages and help us to polish this feature for our final release. To get an detailed overview of the scripting support please visit our user guide. introduces Simple Modeling Features

The latest release of the Javascript toolkit for BPMN introduces basic modeling features.

Read more about it in Nico's blogpost.

Saturday, July 19, 2014

The Case for Open Source Embedded Case Management

In camunda BPM we enhance our lightweight embedded BPMN Process Engine with case management features based on CMMN. CMMN is the new emerging industry standard for (Adaptive) Case Management (ACM) developed by the OMG (Object Management Group), the same consortium which is also behind  the BPMN 2.0 standard. I believe that lightweight open source solutions based on open standards can make a difference in the case management space. This is why.

The traditional "hard-coded" Approach

Traditionally, case management applications were hard coded. If an enterprise needed an application for handling credit applications, it would call on to their Java Developers (or worse: their Cobol Mainframe Developers), there would be some kind of software specification document written and the developers would get down to business and hard code the complete application logic in Java (or Cobol ;) ).
If the enterprise has a good software development process and skilled software developers, the result of this is usually also quite good: the application is exactly tailored to the specific requirements of the enterprise. However, there are also many downsides to this approach:  
  • due to the fact that the complete business logic is hard coded, it is hard to understand and change. Also, the implemented case logic may not correspond to the initial specification.
  • There are many "generic" parts of a case management application which have to be rewritten for each and every application.
  • If you have multiple case management applications, there is no "central monitoring" for all applications. There is no overview over both credit applications and customer support management, for example.

The blind Alley: Proprietary Suites

The answer to this is usually that an enterprise buys a proprietary case management suite. While these suites help enterprises to solve some of the problems of hard-coded case management applications, they come with an entirely new set of problems:
  • Vendor Lock In,
  • Usually these suites have an all-in zero-coding approach: everything from the user interface up to the business rules has to be "graphically configured". This limits developers to the possibilities that the vendor foresaw in the development tool and it keeps developers from doing what they do best: coding,
  • The applications are usually generic and cannot easily be adapted to the specific requirements an enterprise may have.

The Future is Open Source Embedded Case Management

So traditionally, enterprises had to choose between either developing everything themselves or buying an expensive proprietary case management suite. This is where I believe that lightweight, embedded case management based on open source and open standards can make a difference. If you use CMMN and a lightweight open source case engine like camunda,
  • You have minimal vendor lock-in due to open standards (CMMN, Java, ...) and Open Source,
  • You can leverage the CMMN standard for modeling executable Case Models which are more easy to understand and refactor than code,
  • The lightweight case engine can be embedded into custom applications so that you can still code many aspects (such as business logic, user interfaces, ...) in Java and other programming languages but on the other hand you can delegate the generic aspects (case instance state management, monitoring, ...) to the case management engine.

Friday, July 18, 2014

Advanced Asynchronous Continuations in camunda BPM

Asynchronous continuations are a a very powerful process engine feature. Up until now you could use asynchronous continuations in two ways:
  1. Before an activity. 
  2. Asynchronous process instantiation using the async start event. (Added in 7.0).
With camunda BPM 7.2.0-alpha3, Asynchronous continuations become even more powerful:
  1. You can now place an asynchronous continuation AFTER an activity. (HOT!)
  2. Asynchronous continuations are now supported on more BPMN 2.0 constructs, such as the Parallel Gateway.

Thursday, July 17, 2014

camunda BPM 7.2.0-alpha3 released: CMMN, Scripting, Async, Correlation, Model Api, Forms

Today we release camunda BPM 7.2.0-alpha3. Usually when we do a new alpha release, I write a Blogpost which gives an overview over the new features added in that release. But this time I cannot do that: there are simply too many new features to cover in a single blog post! So this time I will just give a bullet point list with the highlights and you guys will just have to wait for additional blogposts to come out in the next days.

So what is in the new Release?
  • CMMN support is greatly enhanced. (CMMN is the emerging OMG standard for Case Management). Documentation.
    • Support the basic case instance and plan item lifecycle,
    • support for stages, human tasks, case tasks and process tasks.
  • Scripting, everywhere:
    • Load script sources from classpath and deployment,
    • Auto-deployment of script sources,
    • Use scripts as sequence flow conditions, task listeners, execution listeners,
    • Greatly improved documentation.
  • Template Engines: you can now use FreeMarker and Apache Velocity as template engine as an alternative to a script engine. Template engines allow a more declarative approach to composing payload (XML, JSON, Email Templates etc...)
  • Javascript SDK and Forms: we started work on a reusable Javascript SDK which runs in Node.JS and the Browser. Providing
    • Convenient access to the REST Api Operations in Javascript,
    • Reusable Embedded Forms. Use Embedded Forms inside and outside of camunda Tasklist.
  • Enhanced Asynchronous Continuations
  • Enhanced Model API
    • Support for all event definitions and gateways
    • Support for writing BPMN DI
  • Enhanced Message Correlation: You can now correlate a message to all executions which match the correlation criteria. (Contribution by Michael Scholz
  • ...
Over the last 4 Weeks, over 70 Issues were closed. See the complete release Notes in JIRA.