Micronaut 2.0: a full stack Java framework for modular, testable applications

I agree. Having used reactive Java and the Elixir/OTP model of message passing, I can safely say that I'd never go back to reactive Java unless I was forced to. It feels like you are fighting the language the whole time.

It is terrible, and has hidden gotchas.

Use it only if you really really have to, then check if you can't do it in Kotlin instead with native async/await syntax, and only if the answer to those questions is "no", continue to shoot yourself in the foot.

The reactive model is not here because people like it but because it enable to do optimizations that are normally mostly impossible to do. The real breakthrough is to use reactive programming + Rsocket which allow true asynchronous real time applications.

And rejoice yourself, Kotlin Flow/coroutines has a clean API that feels synchronous and that still manage to be reactive streams compliant! It's mostly perfect and project loom will be the ice on the cake! Others platforms (non JVM) really have a lot to learn in this regard

I've used a reactive model on the front-end for several years now (MobX at one job and then RxJS at another) and haven't encountered anything I would call "Observable Hell". I will admit that cascading side-effects can be hard to debug, but they're also a code smell. The whole point of the reactive pattern, IMO, is allowing you to have as few open-ended side-effects as possible. i.e., reactions that change state (instead of re-computing a pure function) should be scrutinized heavily and kept to a minimum. If they're kept to a minimum, then in my experience they remain manageable and fairly easy to reason about.

Micronaut supports Kotlin coroutines since 1.3.

You're mostly stuck to Rx outside Kotlin, tho.

It's wrong to focus on the reactive part - it's a feature that it is fully supported, but Micronaut is a generic framework that has both synchronous and async support. It's real secret sauce is the ability to make API building extremely concise, well type checked and performant (for JVM based apps - 10-100ms scale startup times etc.).

For example, this is a Hello World API in Groovy (this is almost literally the entire Application):

    @Controller('/hello') 
    class HelloController {
        String index() {
            'Hello World' 
        }
    }

But I also hate to see my colleagues spawn threads and polling the whole time waiting for something happening, all without timeout

We've changed the URL from https://objectcomputing.com/news/2020/06/26/announcing-micro... to that documentation page. When a project hasn't been discussed on HN before, it's usually best to have the submission be about the overall project rather than the latest release.

(This is the exact opposite of the usual pattern, by the way! if anyone's curious: https://news.ycombinator.com/item?id=23071428)

Can you comment about how to actually use this approach for something useful? I've gotten toy services working with graal nativeimage, but every time I try moving a pre-existing project, I find that some library causes a problem.

I think it's a bit of misleading marketing. Sure, Micronaut (just like Quarkus and Helidon) is ready to be compiled with Graal out-of-the-box. But it doesn't magically make any library you use work with Graal, and it also doesn't mean you cannot get code based on other frameworks like Vert.x or Spring Boot work with Graal (with varying degrees of extra effort).

Also, from all the benchmarks I've seen, GraalVM is not a free lunch. Native images trade peak performance for faster startup times and lower memory usage. It's a worthwhile trade for some people, but not for everyone.

And yes, I know there are features like Profile-guided Optimization that can theoretically bring Graal closer to JIT in terms of peak performance, but these requires a very expensive Enterprise license ($18 per core/month).

Anyone that cares about AOT in Java could have gotten one of the commercial JDKs that offer it since around 2000, what GraalVM brings into the table is not having to pay for such tooling, although the best optimizations are still only available on the professional version.

Try Helidon then

But if the goal is performance, why then not move to C++ or Rust

A Java framework which tries to do at compile-time what other frameworks usually do at run-time (dependency injection, SQL query generation, etc.)

(Yours is a lost cause.)

Same old same old, this drives me nuts on so many open source project websites. I wonder how many good libraries languish in obscurity because of the lack of something simple like an elevator pitch on their landing page, or worse there is one but it's an overload of incomprehensible-to-outsiders jargon.

Since the project doesn't seem to have been discussed on HN before, we've changed the URL from https://objectcomputing.com/news/2020/06/26/announcing-micro... to one that answers this question more directly.

There are actually 3 frameworks in Java that are competing head to head with Go, Micronaut, Quarkus and Helidon.

Helidon is spearheaded by Oracle and currently fails to get some tractions. Micronaut is the baby of Graham Rocher one of the father of Grail (RoR in Groovy) and Quarkus is the baby of Emmanuel Bernard one of the father of Hibernate and supported by RedHat.

All of them run on either a standard JVM or let you use Graal SVM which compiles Java to native with roughly the same trade off as Go (latency is more important than throughput).

At my company, we have prototyped the migrating of a Go application that relies heavily of Kafka to Micronaut or Quarkus. We have found that Micronaut is less polished and more buggy than Quarkus but take it with a pinch of salt because it's just 5k of code.

Yeah. It's very slow to load right now.