Have you looked at Graal and its ability to produce native images for JVM languages? Languages and the ways they are compiled/run are at least somewhat independent. Nothing about Java, Scala, or Kotlin says that they can't be compiled to native code. That's exactly what the Graal native image compiler does. For both Scala and Kotlin there are also separate native compilers as well. When compiled in this way, they produce executables that spin up very quickly with a lot less memory overhead. Indeed, both Scala and Kotlin have compilers that can target JVM bytecode, JavaScript, or native executables. It isn't clear to me that Go has much of an advantage over those platforms because, like them, it has a garbage collector stopping the user from really controlling memory. Rust is a different story because it lacks the garbage collection and does give the user greater control over how memory is allocated.

This doesn't really change the story for dynamic languages as their dynamic nature tends to preclude them from being compiled into efficient executables. There is only so much you can do when a call to something like `obj.foo()` could go to pretty much anything or even fail because `obj` doesn't have a `foo`.

I feel like there there is potentially an interesting blog post on the topic of how well different languages can use different compiler backends to be optimized for different environments.