Ask HN: What is a modern Java environment?

Here is what we use and I'd recommend to others.

The most common: - Kotlin for most of the backend code, but Java for shared libs. We still use Java 8 for some libs which may be used in Android, that's an unfortunate reality

- Gradle for build config

- Spring for application architecture

And few things that may significantly improve your dev process, but are not so common:

- Spring Reactor (and Webflux) for processing data and requests. Takes a time to learn, but it worth it

- Thymeleaf for UI

- Spock for testing. Highly recommended for designing tests

- Testcontainers for integration tests

- Micrometer to see what's going on with your app. I.e., to export all internal metrics to use with Prometheus/Grafana/etc

For the environment

- SDKMan to manager the environment

- Gradle Application plugin or Google's Jib to pacakge your app. First prepares a Zip with all binaries, second a Docker container

- IntelliJ IDEA

- Github Actions - turns out to be the most usable CI. Though the Jetbrains TeamCity may be better for a large team

We have a multi-project gradle build, all our code is in Kotlin, we use micronaut as our base framework and we use IntelliJ as our IDE - this setup has worked great for us over the past year.

I admit we do miss that part. Instead for us it's `sudo apt -y install app-name`

I have been thinking of writing up a series of articles on this. Without going into too much detail:

* IDEA

* Deploy on Google App Engine, Digital Ocean App Platform, Heroku, Elastic Beanstalk, etc - get out of the ops business entirely.

* Guice as the backbone, no Spring/Boot. I wrote a tiny dropwizard-like "framework" to make this easier: https://github.com/gwizard/gwizard but there's a laughable amount of code here, you could build it all from scratch with minimal effort. This is about as lightweight as "frameworks" get because Guice does the heavy lifting.

* JAX-RS (Resteasy) for the web API. IMO this is the best part of Java web development. HTTP endpoints are simple synchronous Java methods (with a few annotations) and you can test them like simple Java methods.

* Lombok. Use @Value heavily. Cuts most of the boilerplate out of Java.

* Junit5 + AssertJ. (Or Google Truth, which is almost identical to AssertJ).

* Use functional patterns. Try to make all variables and fields final. Use collection streams heavily. Consider vavr.io (I'll admit I haven't used it in anger yet, but I would in a new codebase).

* StreamEx. Adds a ton of useful stream behavior; I don't even use basic streams anymore.

* Guava. There's just a lot of useful stuff here.

* For the database, it really depends on what you're building. Most generic business apps, postgres/hibernate/guice-persist/flyway. Yeah, folks complain about hibernate a lot but it's a decent way to map to objects. Use SQL/native queries, don't bother with JPQL, criteria queries, etc.

* Hattery for making http requests (https://github.com/stickfigure/hattery). This is another one of mine. I make zillions of http requests, functional/immutable ergonomics really matter to me.

* Github actions for CI.

* Maven for the build. Yes, it's terrible, except for every other build system is worse. Gradle seems like it should be better but isn't. I'd really love some innovation here. Sigh.

> Java is getting something right that I don't see much elsewhere: Dependency Injection. Combine this with a mocking framework and you can write _actual_ isolated unit tests for every single part of your stack

Since dotnet core started this has been front and center in C#. So there are other stacks doing this.