Flowable 5.22.0 release

October 13, 2016 by


Today we released the first Flowable engine version (5.22.0). This release is a fork of Activiti 5.21.0. There have been no package renaming or config file name changes. The easiest way to start using it is through the Maven:

<dependency>
  <groupId>org.flowable</groupId>
  <artifactId>flowable-engine</artifactId>
  <version>5.22.0</version>
</dependency>

The version 5 code is on the flowable5 branch on Github https://github.com/flowable/flowable-engine/tree/flowable5.
The version 6 code is on master https://github.com/flowable/flowable-engine.

The 5.22.0 release has the following highlights:

  • First Flowable release. With a new Maven group (org.flowable) and artefact id (flowable-engine etc), there are no changes to package names or config file names in the fork of Activiti.
  • Introduction of transient variables. Transient variables won’t be persisted in the process variable tables, but are still available on the execution for the duration of a single transaction. Transient variables can for example be used to store a REST response that is only needed to create a request to another REST service, or to use a Java service task result in the next Java service task without it getting persisted. You can read more about it here
  • Several bug fixes and smaller enhancements

A lot of people will also be wondering what will happen with the version 6 engine. It’s our main focus to get a new beta release out as soon as possible and we want to get the final 6.0 release out shortly after.

We understand that there will be a bit of confusion around starting the Flowable project. We don’t plan any package renaming or config filename changes for example. For now, please get in contact with us through the forum http://forum.flowable.org, and by creating issues on the Github issues page https://github.com/flowable/flowable-engine/issues.
The developers of the Flowable project are keen to help you answering your questions and helping out with possible issues.
The 5.22.0 release is the starting point for the Flowable project, a lot more releases will follow.

Flowable and Activiti: What the Fork?!

October 12, 2016 by


Ironically, the first thing we want to say is that we’re not fans of forking projects. We have been the core developers of the Activiti Java Business Process Management (BPM) project right from its beginnings to its current state, so this has not been an easy or quick decision. We acknowledge Alfresco’s stewardship of the Activiti.org project, and as employees we enjoyed considerable freedom to develop the project over several years. However, things didn’t work out as we expected or hoped. We came to the conclusion the only way to continue evolving our ideas was to fork.

Forking Happens

There are many examples of forks in open source, as Swapnil Bhartiya has recently described in May the Fork Be with You, including mention of one of the live topics of discussion currently within the Docker community. With Docker, the main concern appears to be the mixing of competitive and commercial elements into a core used by different commercial organizations, with people voicing pros (e.g. [Rob Hirschfeld] (https://robhirschfeld.com/2016/08/31/why-fork-docker-complexity-wack-a-mole-and-commercial-open-source/) and cons (e.g. Doug Davis). Let’s be clear about our intentions – the Flowable fork will remain liberal and open, and will be the focus of our future efforts in BPM, hosted on GitHub.

Forking Can Be Healthy

In the past, Matt Assay pointed out that forking is often good for innovation, which very much underpins our hopes. By keeping to our business process-oriented roots, we can innovate in the core of the BPM engine far more readily. Not all forks are successful, as Matthew Hughes highlights in Forking Good Great Ugly, but another recent fork, ownCloud / Nextcloud, where the development team became unhappy with the commercial management, seems to be succeeding NextCloud release OwnCloud fork ahead of schedule. In a similar vein, we have just pushed our first release of the fork for the V5 engine, including a powerful new feature, transient variables. We will be releasing an update to V6 soon as well.

Forking Can Confuse

Obviously, our biggest worry is the confusion to developers that a fork can introduce. Only time will tell if that can be overcome. If you’re unsure of jumping in, take a look at the authors in the code and the people working on the Flowable project. We are the people that know it best, and who have been driving the community, contributions and evolution over the years.

Thank You For Your Support

We’ve had a whole bunch of people contact us about their concerns with how things had been going (or more accurately, not going) and to show support in what we’re doing with this fork. Please take a look and get involved. Now’s the time to make your business processes Flowable.