- Quarkus with GraalVM compiles your Java app to native code. There is no JIT or warm up, memory footprint is also low. By the way, the JVM Hotspot JIT can actually make your Java app faster than your Go or Rust app in many cases [citation needed] exactly due to the hot path optimizations it does.
- GC tuning - I don't even know who does this. Maybe Netflix or some trading shops? Almost no one does this nowadays and with the new JVM ZGC [0] coming up, nobody would need to.
> You can’t ship a minimal standalone binary without pulling in a JVM.
- You'd need JRE actually, e.g., 27 MB .MSI for Windows. That's probably the easiest thing to install today and if you do this via your package manager, you also get regular security fixes. Build tools like Gradle generate a fully ready-to-execute directory structure for your app. If you got the JRE on your system, it will run.
> Dependency management and classpath conflicts historically plagued Java
The keyword here is "historically". Please try Maven or Gradle today and enjoy the modern dependency management. It just works. I won't delve into Java 9 modules, but it's been ages since I last saw a class path issue.
> J2EE
Is someone still using this? It is super easy writing a web app with Java+Javalin for example. The Java library and frameworks ecosystem is super rich.
> “Write once, run anywhere” costs: The abstraction layers that make Java portable also add runtime weight and overhead.
Like I wrote above, the HotSpot JIT is actually doing the heavy lifting for your in real time. These claims are baseless without pointing to what "overhead" is meant in practice.
---
0 - https://inside.java/2023/11/28/gen-zgc-explainer/ or https://www.youtube.com/watch?v=dSLe6G3_JmE
I believe Netflix has moved to ZGC with no tuning. Their default setup is to set the min/max heap to the same size, enable always pretouch, and to use transparent huge pages [0]. GC tuning is something of the past. Once automatic heap sizing for ZGC and G1 land you won’t even need to set the heap size [1][2]. They’ll still use more ram because the vm and jit, but the days of it holding on to ram when it doesn’t need it should be over.
[0] https://netflixtechblog.com/bending-pause-times-to-your-will...
1. Startup time and latency
Cold start penalties: Java apps typically take longer to start than Go, Rust, or even Python scripts. For short-lived CLI tools or serverless workloads, this is a real drawback.
JIT warmup: Performance often relies on the JIT compiler optimizing hot paths, which means peak performance comes only after warmup, not instantly.
---
2. Memory consumption
High baseline footprint: Even trivial Java apps often take hundreds of MB of RAM just for the JVM, class libraries, and runtime structures. Compare that to Go or Rust binaries which can run in a fraction of the memory.
GC overhead: Modern garbage collectors are good, but they still consume memory headroom and CPU cycles. Low-latency GC tuning is non-trivial and often leads to further bloat.
---
3. Distribution and deployment
Huge runtime baggage: You can’t ship a minimal standalone binary without pulling in a JVM. A simple “Hello World” isn’t self-contained like in Go or C.
Container inefficiency: In cloud-native/containerized environments, Java apps are notorious for high memory requests and tuning requirements compared to leaner languages.
---
4. Complexity of tooling
Build tools are heavy: Maven and Gradle are infamous for their slowness and complexity, often requiring downloading gigabytes of dependencies.
Jar hell: Dependency management and classpath conflicts historically plagued Java, and while better today, it still contributes to the “bloated” reputation.
---
5. Historical baggage
Enterprise legacy: “Enterprise Java” (J2EE, app servers, Spring monoliths) left a legacy of verbose, heavyweight systems that contrasted with lighter ecosystems (Node.js, Go microservices, etc.).
Language verbosity: Although modern Java has improved (records, lambdas, etc.), the ecosystem still carries a reputation for wordiness and boilerplate.
---
6. Comparative benchmarks
In microservices and high-performance environments, Go and Rust often outperform Java both in latency and resource efficiency.
For small tools or CLI utilities, Java is rarely chosen because of its startup time and memory overhead.
---
7. Culture and perception
“Write once, run anywhere” costs: The abstraction layers that make Java portable also add runtime weight and overhead.
DevOps annoyance: Running Java apps at scale often requires constant GC tuning, heap sizing, and JVM parameter tweaking, which makes it feel heavyweight compared to languages with leaner defaults.