I think it should always be mentioned when people call java fat, that the core language is usually fast enough. What makes java "fat" is the mentality of "Frameworks".
For me, Go seems like java, but without the fucking frameworks.
Needing to bring a very large, very complex virtual machine to execute your program adds a lot of “fatness” IMO.
And for those that want the free beer version instead, using a fat jar with linked jvm.lib is hardly different than packing Go's runtime in an executable file.
The idea seems to be there and "obvious" in a way, but haven't been able to pinpoint exactly what it is.
Is it a feeling or an actual metric?
e.g. When I work with Java in IntelliJ, things don't feel significantly slower than developing Node in WebStorm. Is it perhaps the way the code looks, in terms of verbosity?
I do agree that frameworks contribute to this feeling of Java, but again, is it because a Spring Boot webserver boots slower than a Node one?
Or maybe, say a Java cli program vs a C++ one. Is it the speed at which things run?
Could it be that, because we know Java uses a VM then it "should" be slower than compiled code and thus it's fatter?
What is that "thing" that makes us determine that a language is fat or light?
Edit: that said, Java was created when we didn't have containers. (Just as Clojure was created before Java had lambdas and aggregate streams). So it may be the time to come back closer to the metal again, but as you point out, we need to maintain a clear mind while contemplating that.
What exactly constitutes overhead is debatable, but generally anything that is not strictly necessary for the functionality is considered as such... Even if it has useful tradeoffs.
Examples from Java are the GC, compound types need to be objects and thus are wasting space with type and vtable pointers, and the jvm is actually an interpreter (one with only stack semantics at that).
Since C++ has none of that, it is quite natural to say that it is more lightweight than Java.
But that in itself is not necessarily a judgement about execution speed, although it is heavily implied. If you write Java in a way that it is heavily jitable and doesn't stress the GC, you can end up with a faster program than a naive C++ version would achieve.
But all else being equal, the C++ version will be ever so slightly fester, because less stuff to do means more stuff done.
So I was wondering if it was something that people felt differently, or if it was mainly the same theme, as it seems like it is.
In the same way the word modern is thrown around in the context of languages that have evolved a bit, I think heaviness is a notion that is an indicator of how committed the person is to the tradeoffs made by the tech: a heavy language made tradeoffs erring on the side of technical debt and the light one has not.
But it's easier to present one's own preferences as technical facts when trying to flame or troll.
In the case of frameworks, they often make choices for you, they are opinionated. It's easier to get unhappy about it, in a bike shed sort of way