Discussion about an Idea runtime less and GC less version of .net?

[IrakliLomidze]

Discussion about an Idea runtime less and GC less version of .net?

Once managed code and runtime was an advantage of the java and .net. But as time is passed, now .net runtime is a big downside of the .net. Especially when we have to upgrade to the new version every 3 years, that is costly.

Many solution architects, including me, are seriously considering starting to migrate on native code platforms. Go, Rust, Moder C++.

I love C# and would be happy If I see runtime less .net core edition, having optional classes without GC. With reference counters (e.g., smart pointers in C++) and user management (manually free up memory).
I’m really interested in what the community and Microsoft itself think about it?

[Clockwork-Muse]

• You can get self contained versions of applications by packaging the runtime with them, for a particular platform/OS. This preserves the runtime used for a given build of the application.
• You can build a runtime-less version with ahead-of-time compilation, for a particular platform/OS. This can massively cut down on deployed size (and other benefits).

The issue is that it means you need to build a specific binary/package for each platform/OS (and potentially for each version of them, too). The runtime is used to alleviate that consideration. In particular, backwards compatibility is usually pretty good.

Especially when we have to upgrade to the new version every 3 years, that is costly.

Outside of patches for security reasons, you don't have to. You can keep using old runtime versions. Note that it's best to consider it part of your deployment infrastructure, like your target OS. Additionally, a good test suite and CI/CD can make testing for an upgrade easier to manage.

Go

Go has a GC. Many C++/Rust applications will build small specific-purpose memory management systems (especially game engines).

[IrakliLomidze]

GC is a major downside of the solution, especially when we have high load scenarios.
C++ and Rust are good because of the code execution's predictability, which does not have a managed environment. Sometimes it works fine, sometimes not (Uncertney when GC will perform its task).

I remember a few years ago, there was an idea of C# native compilation.

[Cheatoid]

https://github.com/dotnet/runtimelab/tree/feature/NativeAOT ?

[IrakliLomidze]

My Idea, instead of code execution dependency to external runtime to compile code to native code.

benefits:

1. Code will be significantly faster.
2. Code will be more compact if we will have a good linker.
3. In many scenarios, manual memory management gives better perfomace.
4. Code obfuscation is better.

[huoyaoyuan]

GC is a major downside of the solution, especially when we have high load scenarios.

GC won't be a downside, especially when comparing to non-pooled/optimized malloc.

Code will be significantly faster.

It won't. Tiered JIT is quite fast for long running code like servers.

Code will be more compact if we will have a good linker.

It won't. Native code is naturally larger than managed code.

In many scenarios, manual memory management gives better perfomace.

I'd say no. It's very hard to implement good memory management.

Code obfuscation is better.

That's true, but makes little sense. And it will be possible once NativeAOT lab get productized.

These are all of common misunderstandings about GC/JIT. When talking about real-time and absolute no latency, GC does be unsuitable. But for throughput, GC is quite good.