dotnet rely a lot on the JIT to optimize code
So cases when you run your program once (middleware, short lived servers) the performance is abysmal
Never trust "ultra optimized & cheated" benchmarks where they run the same code 1_000_000_000 times
And the time/resources it takes to reach steady state is also something to keep in mind, warming up the JIT isn't free
Hence the reason why most people looked at Go as an alternative to both dotnet/Java/Scala
.NET has had AoT compilation since v1. What, exactly, are you talking about?
Sure, rely on JIT for stuff like webapps and the like, but a CLI tool that is designed to run once would be a good candidate for AoT compilation, which, as I stated before, .NET supports.
Also you're dramatically overstating how mature AOT is for dotnet
https://github.com/dotnet/runtimelab/tree/feature/NativeAOT
>This repo is for experimentation and exploring new ideas that may or may not make it into the main dotnet/runtime repo.
[1]: https://docs.microsoft.com/en-us/dotnet/core/deploying/ready...
>R2R binaries improve startup performance by reducing the amount of work the just-in-time (JIT) compiler needs to do as your application loads.
and
>However, R2R binaries are larger because they contain both intermediate language (IL) code, which is still needed for some scenarios
and
>Ahead-of-time generated code is not as highly optimized as code produced by the JIT. To address this issue, tiered compilation will replace commonly used ReadyToRun methods with JIT-generated methods.
* You can AOT compile .NET, that has been true for a while but now it is a first class option
It's been a while i haven't used dotnet, but just take any available benchmark, and compare default results with
UnrollFactor = 1
IterationCount = 1
WarmupCount = 0
There are probably more options, but i forgot them
https://benchmarkdotnet.org/articles/configs/jobs.html#run
> You can AOT compile .NET, that has been true for a while but now it is a first class option
That's not true at all, if you refer to R2R, it's only partial, your code is still JIT'd at runtime, it only helps to speedup a little bit the cold startup time
AOT compilation? I'll believe it when they'll release it, until then, it's all speculation
Devil's in the details, but there -is- AOT compilation[0]. While it hasn't been released as an official product, it has been used for a few projects including a commercial game [1]. And yes, they're looking into the next steps to make it a 'released' thing.[2]
[0] - https://github.com/dotnet/corert/
[1] - https://github.com/dotnet/corert/issues/8233#issuecomment-65...
[2] - https://github.com/dotnet/runtimelab/tree/feature/NativeAOT
>This repo is for experimentation and exploring new ideas that may or may not make it into the main dotnet/runtime repo.
Talented people are working on CoreRT, sadly it doesn't seems to be the focus of the product manager, hence my concerns
Running the same code a lot is certainly not cheating, a lot of code where performance really matters is actually doing the same thing over and over.
.NET 5 added source generators, which are one part that is necessary to get to a point where ahead of time compilation would be feasible for typical .NET projects. So this is an aspect that Microsoft seems to be looking into now.
For people who have not been following .NET closely, there is a thing called Blazor that runs in the browser using web assembly. To get the download size down, a linker is used to remove classes and methods that are not being used. You can also use this when deploying other types of apps.
https://docs.microsoft.com/en-us/aspnet/core/blazor/host-and...
Also, Java takes longer to reach steady state as it starts execution in an interpreter, then JIT compiles hot methods. .NET skips the interpreter and goes straight to JIT compilation.
So if you're targeting .Net 1.0 this "PSA" is impactful, otherwise, it isn't really accurate. It could hypothetically apply if you created a new .Net process each execution (thus invalidating the GAC) but even then you could just add ngen to your build/deployment process.
https://docs.microsoft.com/en-us/dotnet/core/whats-new/dotne...
<RuntimeIdentifier>linux-x64</RuntimeIdentifier>
<PublishReadyToRun>true</PublishReadyToRun>
Also, who is that most people? Go is a tiny language compared to Java and C#.