Wrapping up a year of Flowable goodies
Blog: Flowable Blog
2019 has been another of those years where we’ve taken huge
steps forward in various aspects of Flowable, both in open source and
commercially. It’s been a hard year from
the sheer volume of work the team have taken on, though that doesn’t seem to
have diminished everyone’s desire to keep pushing the technology forward.
One standout achievement was winning the best in show at
bpmNEXT’19, having also won it the year before.
The voting is by the audience, which at this conference is our peers in
the BPM and Intelligent Automation industry, so they know what’s what. Winning it was the result of work behind the
scenes by all members of the team.
Looking back, what was the theme for 2019? I don’t think there was one other than
keep pushing in all directions: improve performance (even more); extend
functionality in the core BPMN, CMMN and DMN engines; and enrich the platform
that binds them together in a full application solution.
There were a couple of really significant releases of the Flowable engines. The first one early in January added an important addition to the underlying database schema with a table that contained all the information about active instances. Before, you had to get information about earlier steps in a process instance from the history tables. This change really helps performance, because the active instances are not impacted by the size of the historic instances (you don’t have to prune the history tables just to fix performance issues, although we added that option too). It also makes it much easier to query processes.
The CMMN engine has matured both in its coverage,
performance and extensions, all driven by use in a wide range of real-world
projects. There really are too many
important changes to list, so read through the link above for some of the
details. We’ve also started pushing the
envelope of how you can use CMMN, which you’ll see much more of in 2020. It’s also become clear that we need to help
introduce CMMN concepts more widely to our community, so expect more blogs that
talk about how we’re using it.
A highlight in another release was support for
CockroachDB. This came about as the
result of a very fruitful collaboration between Flowable and Cockroach Labs
engineering teams. Best of all, it was
driven by the market not by marketing, so it’s being used for real.
There’s going to be another major Flowable open source
release any day now (though it may be at the beginning of January to make sure
we can enjoy the Christmas holiday period).
A lot of the code is already out there, just not packaged into a
release. The biggest features have
already been previewed at FlowFest’19 last month. If you weren’t there, make sure to come next
year.
FlowFest was another big part of 2019 – SAP offered to host the event this year, as well as announce their use of Flowable. A lot of talks covered the new features that have been developed. On the engines, there were three biggies: tight coupling with event / message technologies, such as Kafka; batch instance migration of complex process models; and deeper monitoring and logging of engine execution. These will continue to be built on in 2020. The videos of the talks will become available very soon – keep looking here for links or follow our account on YouTube.
One of the biggest new features that will feed innovation
over the next cycle of releases is the event stream integration. There’s so much activity in event-based
infrastructure now that we expect to get quite creative about how Flowable
technology can be used here. This is
also where the declarative, event-driven nature of CMMN will show real
benefits.
So far, I’ve just talked about the core and open source work
that’s been done. There’s a huge number
of steps we’ve taken forward in the commercial product suite, usually
leveraging additional capabilities in the engines. We’re on a journey to augment the core
process engines with other services that allow you to build sophisticated
solutions rapidly. The market label is
“Low Code”, though we’ve been using the term “Deep Low Code” to emphasise the
difference of a technology built on powerful, standard models with additional application
engines.
This year saw the platform saw the addition of security
models, data models, service repository, re-usable action models, and a
flexible template service and model.
Together, these provide the building blocks for almost every solution
our customers have needed. Yes, there’s
still developers and code needed, but not as much is needed. This makes the development of solutions
faster, more repeatably and requiring less maintenance.
The user interfaces for the commercial product has also
moved forward in a similar way, with many more options to configure and re-use
what’s provided out of the box. The
recent addition of custom case views is also just a hint of what’s coming in
the next release. Building app driven
primarily by models has been at the roots of the Flowable team for many
years. In 2019, we have the foundations
that will allow us to step up to a new level.
Early next year, the Flowable team will have been building our core engines for a decade, starting from the Activiti days (see our history). One of our primary goals has been to have a process engine that, as well as being highly performant and scalable, was happy to run in almost any Java environment and invoked in a wide variety of ways. In 2019 we made the decision to embrace Spring Boot more completely, reflecting its benefits and popularity, making it a piece of cake to use, but without making it any harder to continue outside this framework.
This flexibility has served us well, allowing the core
technology to evolve in isolation from the environments it’s being used
in. As different containers, clouds and
service invocations have come into fashion and acceptance, Flowable has been
able to adapt and ride them without having to rearchitect. We’re looking forward to 2020 and the
challenging opportunities that are waiting for us. Bring it on.
Leave a Comment
You must be logged in to post a comment.
