This is missing the forest for the trees.

Languages are very complex, you will not get a good picture of their overall strengths and
weaknesses if you limit yourself to a very zoomed-in view, like comparing a few features of
the languages themselves.

As an example, consider the digital camera market vs the cameras in smartphones.

The digital camera is a clear winner! So many features. The quality of photos taken is
objectively better in every metric too.

And yet the digital camera market is dying, completely killed by smartphones.

But why, the features are cleary better right?!

Because we're looking at it wrong, we're tunnel-visioned on the "camera" part. We need to
look at what actually matters.

Thankfully, that's simple to answer and is the same for every product in existence. All that
matters is the user experience.

Nobody wants extra features on their camera, nobody wants a camera in the first place, nobody
wants to take photos either. What people actually want is to preserve the moment of their first
born child taking their first steps. The technology is irrelevant as long as it lets the user
do what they really want.

Why would I want a digital camera when my smartphone has a decent enough one that is effectively
free and always available? A low quality camera on you is infinitely more valuable than the
professional camera at home.

Programming languages are no different, just that "users" in this case are programmers,
which seems to be confusing to some.

What is the developer experience of using Java vs Go? - that's the real question you need to
answer to get to the bottom of this.

Start a new project and write some code in both languages, compare the experiences. Be wary of
biases, if you have pre-existing experience in one of the languages it's going to shadow
your judgement (the curse of knowledge). Pay attention to aspects of good design - how many
pointless decisions do you have to get through before actually shipping code?

Go eliminates whole areas of pain points:

- Dependency management? Go modules.

- Tests? Built-in.

- Code formatting? Built-in autoformatter.

- Compilation time? As fast as it gets.

- Distribution? Single binary.

- Writing code? Minimal ceremony, just make a function.

- Performance? The idiomatic code you write will naturally perform well due to value types,
explicit pointers, a culture of straightforward code with no needless indirection. If
you need to optimize, the profiling tooling is great and the optimizations themselves
straightforward due to intuitive language and GC semantics - just reduce allocations.

- GC? A single implementation, good enough for 99% of cases. Two whole knobs available if
you really need to tune it. Performs well due to the language not getting in its way.

- Standard library? Excellent, good balance between batteries-included and bloat. The built-in
HTTP server is suitable for 80%+ of workloads.

- Concurrency? Core to the language - syntactically supported green threads. The entire
language and its ecosystem are built with it in mind.

- Linting? Community-made linter runner with a curated list of good linters.

- Found a bug in a library? No problem, the library is written in straightforward Go, the
same flavor of Go you've been writing. It's of course autoformatted as well.

There you go, a single go-to solution to each problem. The language's designers have gotten all
the pointless details out of the way for you. You get to focus on writing code.

Now compare the above points with Java.

Go was designed for developers, with the same philosophy Steve Jobs designed Apple
products for users. Java wasn't. Simple as.