neonsunset

5 ms·

1.
by neonsunset 7mo ago
.NET also now has an (amazing) alternate low-pause/effectively pauseless GC: https://github.com/VSadov/Satori Builds: https://github.com/hez2010/Satori/releases how to use? do self-conta
2.
by neonsunset 7mo ago
Default value is only relevant for structs. You can setup an analyzer rule to ban this for structs which have, say, an empty constructor. It’s a similar problem to Go and C++ except it’s worse in the latter two.
3.
by neonsunset 8mo ago
Even back in .NET Core 3.1 days C# had more than competitive performance profile with Go, and _much_ better multi-core scaling at allocation-heavy workloads. It is disingenuous to say that whatever it ships with is huge also. The common mis
4.
by neonsunset 8mo ago
.NET's string.Split implementation is very close to what the article showcases, even 3-character limit is there: https://github.com/dotnet/runtime/blob/main/src/libraries/Sy...
5.
by neonsunset 9mo ago
C# :) async Task<User> FetchUser(int id, HttpClient http, CancellationToken token) { var addr = $"https://api.example.com/users/{id}"; var user = await http.GetFromJsonAsync<U
6.
by neonsunset 9mo ago
Just don't ship to PlayStation and discourage others until Sony changes (is forced to) policy.
7.
by neonsunset 9mo ago
I saw the email, and thanks. This is okay - I did not exercise (nor anyone should) good impulse control when dealing with bad faith arguments, which inevitably led to an account ban. Either way, Merry Christas!
8.
by neonsunset 9mo ago
What? NRTs are used everywhere with WarningAsErrors:nullable also gaining popularity. Whatever environment you are dealing with C# in, if it’s the opposite I suggest getting away from that ASAP.
9.
by neonsunset 9mo ago
FWIW JIT is rarely an issue, and enables strong optimizations not available in AOT (it has its own, but JIT is overall much better for throughput). RyuJIT can do the same speculative optimizations OpenJDK Hotspot does except the language ha
10.
by neonsunset 9mo ago
https://github.com/niklas-heer/speed-comparison/blob/9681e8e...
11.
by neonsunset 9mo ago
Nim "cheats" in a similar way C and C++ submissions do: -fno-signed-zeros -fno-trapping-math Although arguably these flags are more reasonable than allowing the use of -march=native. Also consider the inherent advantage popular la
12.
by neonsunset 9mo ago
C# actually already has limited lifetime analysis :) https://em-tg.github.io/csborrow/ > Ownership model for example, would it be possible to enforce practice via some-sort of meta framework? It should be possible
13.
by neonsunset 9mo ago
Try that on ARM64 and the result will be the opposite :) On M4 Max, Go takes 0.982s to run while C# (non-SIMD) and F# are ~0.51s. Changing it to be closer to Go makes the performance worse in a similar manner.
14.
by neonsunset 9mo ago
> Go fastest language with own compiler (ie not dependent to GCC/LLVM). C# is using CoreCLR/NativeAOT. Which does not use GCC or LLVM also. Its compiler is more capable than that of Go.
15.
by neonsunset 9mo ago
Whether the value is null (and under which conditions) is encoded into the nullability of return value. Unless you work with a project which went out of its way to disable NRTs (which I've sadly seen happen).
16.
by neonsunset 10mo ago
Not books but it's really important, in my opinion, to go through official documentation https://learn.microsoft.com/en-us/dotnet/core/whats-new/ https://learn.microsoft.com/en-us&#x
17.
by neonsunset 10mo ago
.NET Native is essentially dead. NGEN is specific to .NET Framework. It is possible to dynamically link multiple binaries with the same runtime with NativeAOT but it is very exotic and undocumented path that is not guaranteed to be stable.
18.
by neonsunset 10mo ago
in .NET, async/await does not protect you from data races and you are exposed to them as much as you are in Go, but there is a critical difference in that data races in .NET can never result (not counting unsafe) in memory safety viola
19.
by neonsunset 10mo ago
Note how practitioners of .NET praise it and non-practitioners (users of .NET Framework) criticize it.
20.
by neonsunset 10mo ago
What papercuts?
21.
by neonsunset 10mo ago
It is as simple as what you get with Cargo, and possibly even more readable. .NET, unlike Go, has all needed management commands built into its CLI too: dotnet new {template}, dotnet add/remove package, dotnet sln add/remove, etc.
22.
by neonsunset 10mo ago
Ref structs are hard to solve because they require, in some ways, a lot more work than the way C# solved the lifetimes as the lifetimes in F# may need to become much closer to what they are in Rust. Some constructs may not be able to consum
23.
by neonsunset 10mo ago
> has an edge on some domains due to having unboxed types If a language makes "unboxed types" a feature, a specific distinction, and has to sell "removing global lock" as something that is a massive breakthrough and n
24.
by neonsunset 10mo ago
> C#/f# are safer from that particular problem and more performant than either go or swift, but have suffered from the same deserialization attacks that java does. They have not in the past 10 years.
25.
by neonsunset 10mo ago
If anything, the Mono runtime is what prevents heavier (ab)use of SIMD types in the standard library, or at least it causes additional required effort to make it not regress in performance since it's nowhere near as capable as CoreCLR.
26.
by neonsunset 10mo ago
It is atypical for otherwise mainly high-level languages to have this. Moreover, C# and F# get this through completely independent work runtime libraries and RyuJIT, not by being lazy and having LLVM do everything which is also why Go and J
27.
by neonsunset 11mo ago
You are not "forced" into unsafe APIs with Vector<T>/Vector128/256/512<T>. While it is a nice improvement and helps with achieving completely optimal compiler output, you can use it without unsafe. For e
28.
by neonsunset 11mo ago
This is outdated. let foo = task { let! data = getData() return data.value } In F#, you interoperate with Task<T> transparently, and there is a number of community libraries to further enhance the experien
29.
by neonsunset 11mo ago
Thank you for the article. I noticed the statement > A second drawback is that async/await has a performance cost. CPU-bound code written with async/await will simply never be as fast or as memory-efficient as the equivalent sy
30.
by neonsunset 11mo ago
However old, .NET Framework was still using a decent JIT compiler with a statically typed language, powerful GC and a fully multi-threaded environment :) Of course Node could not compete, and the cost had to be paid for each thinly sliced m

More ›