Flowable (V6) VS Micronaut

I’m doing a lot of exploratory work with BPMN right now.

I think if your business is largely transactional (think Stripe), there is a lot of value to be had by framing your development as “business process automation”.

The term (and BPMN) has a lot of enterprise baggage, but some of the tools out there [0][1] are well suited to orchestrating services (and people where necessary) as a single automated process. The the ability to build that flow visually using BPMN, and then execute it in a workflow engine where you can monitor it, audit it, and optimize over time is pretty compelling.

Here’s an interesting read on the topic: https://www.infoq.com/articles/events-workflow-automation/

[0] https://github.com/camunda-cloud/zeebe

[1] https://github.com/flowable/flowable-engine

The specification playground is called microprofile, where new specifications are rapidly prototyped. Some products are built around only that platform like quarkus, helidon or Micronaut.

In Java the standard library does not tell you how to build an http server - there are a lot of frameworks for that and you can choose one that fits to your particular needs. It doesn't have be Tomcat. For example, you can go with Spring Boot - probably the most popular right now and it indeed wraps around Tomcat but in a way that lets you be almost unaware. But since you're starting, I'd recommend you look into Micronaut and/or Quarkus.

[2] - https://micronaut.io/

I can't speak to how prevalent it is in the industry, but something my team has started doing in our web services is building with GraalVM and deploying native images. The build time can be super long, but the benefit is incredibly fast start-up time, which really benefits horizontal scaling. We're using Quarkus (https://quarkus.io), which is largely built on Vertx which was mentioned elsewhere, but other frameworks (Micronaut (https://micronaut.io) comes to mind) make it easy and SpringBoot is also working on support. If your doing containers/kubernetes native images feel like the way to go.

Another option I'd consider would be Dropwizard, which is really just a curated collection of good tools that work well together. If you wanted to get into the frameworks that abuse annotations like Spring, I'd look at Quarkus or Micronaut first, personally.

There are projects that feel lighter-weight such as Micronaut and DropWizard, although in many regards I feel like this is just a perception (Spring is quite modular and you can pull in what you need, but that process can involve some nitty-gritty tailoring because the default is batteries-included).

My experience is that it's not only the usage of annotations, but the way Spring handles/implements those annotations which is confusing.

As an example, Micronaut[1] also uses annotations a lot, but their implementation is a lot easier to reason about, because there is less indirection with proxy objects and other weird stuff that Spring uses.

Micronaut does not implement nearly as many annotations as Spring though, which basically means less functionality pre-built. I'm not sure that's a bad thing, but it could be.

[1] https://micronaut.io/