From a language design perspective (when it comes to "ease of optimization") it's much better than Java and comparable to C#.
But compiling C# with CoreRT (which is basically .NET Core's RyuJIT configured as an AOT compiler) shows just how little Go's compiler optimizes. Go would need to be even more "easy to optimize" than it is to make up the difference. Rust and C++ are both easier to optimize and their compilers are in a whole other league entirely, and it shows on the horrific compilation speeds.
I'm not sure what the right way to do these "benchmarks" is. Some of the code I've seen there was more low level and convoluted than stuff I'd write in C. Not even remotely representative of how the languages are used. Stupid rules like that one you mentioned also don't help since some languages get to preallocate and others don't.
In which case, maybe what you see is as good as you'll get.
> … some languages get to preallocate…
Here's Go using a library pool —
https://benchmarksgame-team.pages.debian.net/benchmarksgame/...
Because as-you-know the whole point is to "allocate zillions of short-lived nodes" —
The Swift Code looks like something you'd write in C.
Like this? (There are 8 other C++ binary trees programs.)
https://benchmarksgame-team.pages.debian.net/benchmarksgame/...
> … or Swift's reference counting.
Like this? (There are 4 other Swift binary trees programs.)
https://benchmarksgame-team.pages.debian.net/benchmarksgame/...
You could look at the different binary trees programs shown on the current benchmarks game.
Most people aren't building applications whose business requirements preclude preallocating memory except for languages which lack garbage collectors.
If we don't experience a performance problem, we don't need a workaround.
Errare humanum est.
"Energy Efficiency across Programming Languages" not "programming language performance in the general case".
I maintain a contrived benchmark is not a useful benchmark.
In this case for Go, the same as other languages that provide a library pool implementation.
Apparently the study authors found a use.
I mean, relative to many other mainstream languages including many of the JIT languages, Go is very efficient, but a lot of that efficiency comes from the language design (e.g., idiomatic value types) such that the compiler and runtime don’t need to be as smart.
Agreed that the benchmarks game is a pretty crumby measure of performance, but it typically imposes strange restrictions on Go that prevents it from showing its idiomatic performance (never mind its ceiling). For example, languages with garbage collectors aren’t allowed to preallocate memory for certain benchmarks even though that’s absolutely idiomatic in Go (because Go has value types) so you have languages with GCs optimized for languages where everything is an allocation which perform well and languages like C and Rust which are allowed to preallocate because they don’t have a GC (which is a weird criteria) and then you have Go which appears to be very slow because it’s forced to allocate in a tight loop.