Java-Hello-World-Enterprise-Edition VS javalin.github.io

If you judge productivity by lines of code, absolutely.

https://github.com/Hello-World-EE/Java-Hello-World-Enterpris... is an excellent demonstration of this.

This reminds me of the "enterprise programming" mindset in OOP where people would make factories, strategies, strategy factories etc. just for the sake of it (instead of those solutions serving a real need) and ending up codebases that look like Hello World enterprise edition.

No other language or framework seems to get the same scrutiny as JavaScript.

The Enterprise Java solutions never seem to get as much discussion but we all recognize it also as being equally if not more so absurd[1]. This is true of every language and framework that gains mass adoption and use. Scala projects are crazy complex, the python 2 to python 3 migration was a mess, none of these are problems. They reflect the improvements in every metric to the underlying platforms and systems - end user experience, developer experience, reliability, testability etc.

JavaScript is in a phenomenal place today - we have come "full circle" but with better tooling, new capabilities, improved experiences etc.

There's a lot of keeping up with the jones' - that's partly nice as its job security and partly nice as a reflection of engineers improving our own ecosystem.

[1] https://github.com/Hello-World-EE/Java-Hello-World-Enterpris...

It’s bad, but not as bad as the enterprise edition

Hello World Enterprise Edition - https://github.com/Hello-World-EE/Java-Hello-World-Enterprise-Edition

You might actually have to think about writing longass assembly hello world, but I can spin up fifteen Enterprise Java Hello World APIs in an afternoon.

Haven't written Java in years, but I'd take an enterprise edition program written in it, much like this one: https://github.com/Hello-World-EE/Java-Hello-World-Enterprise-Edition

The size statistics page is super cool: https://github.com/byronka/minum/blob/master/docs/size_compa...

Reasoning this way about software and dependencies more often seems like a good thing, just so we're aware of what we're actually getting into, especially with projects that use npm.

I actually hadn't heard of Javalin before, which also seems nice: https://javalin.io/

Aside from that, I've also had good experiences with Dropwizard - which is way simpler than Spring Boot but at the same time uses a bunch of idiomatic packages (like Jetty, Jersey, Jackson, Logback and so on): https://www.dropwizard.io/en/stable/

I do wonder whether Minum would ever end up on the TechEmpower benchmarks and how it'd stack up against the other libraries/frameworks there, those benchmarks are pretty interesting.

Counter-example: https://javalin.io/ uses Servlets, and seems to be doing quite fine without annotations.

Yes, and it was not that well designed to be honest... the successor is quite a lot nicer and it's called Javalin[1].

Same philosophy but just got things right where Spark, being the "first" (in the Java world, using the design inherited by Sinatra[2]) had a few design issues.

[1] https://javalin.io/

[2] https://sinatrarb.com/

I strongly advocate frameworks like https://javalin.io/ and Jooq (https://www.jooq.org/) if you are going to start a new project in Java.