Spinal Tap's "put it up to 11". My laptop (Kubuntu) has volume controls that allow me to override 100% and take it to 150%.

I can wind it up to 15! \||/ (is there an official ASCII art four finger devil's horns)

\m/

I noticed that audio quality begins degrading above 100% (at least if the media is already at high volume), so it really is a useful concept. I'm unsure what Linux distro I'm recalling this from, but it was useful on my little old netbook from college

The sections that follow are full of real improvements. A bounds check removed, an allocation that no longer happens,

Annoyingly the.net blog seems to have started to use LLMs to write their copy. Using "real" twice in one paragraph - do LLMs do that? Lots of commas is a tell for me.

This is a long one. It’s meant to be. Grab your hot beverage of choice, settle in, and let’s turn it up.

Ugh.

These comments about potential LLM usage are so boring. Stephen is doing this kind of blog post since 6+ years. They all look the same. Read it! It’s very good. Performance deep dives with this kind of quality are rare.

Ok, fair enough. I may have over compensated for this one. I found the Spinal Tap, "this one goes to 11 stuff" so irritating that I might have not thought it through. It's such a tired joke by now. I did enjoy his Frozen reference last year.

Not too sure here. I use quite a few commas, too.

I suspect it was done old school: Written by Stephen and passed to a LLM to fill in all those links and other garnish and then passed back for final polish by Stephen. That's how I do my write ups (but generally without the LLM bit for shorter efforts).

This is a long write up, and I'm sure it will have been assisted, but in the right way, and not a sloppy way.

I've dropped several commas before conjunctions, soz!

This is the loudest release of .NET to date(!)

Backing you up on this. I smelled LLM and hit cmd+w.

Dumb Q: should a non-systems-language dev know/read assembly?

    ; Arm64
    --- .NET 10
    +++ .NET 11
    @@ -13,8 +13,6 @@
                ble     G_M000_IG04

    G_M000_IG03:
    -            cmp     w1, w2
    -            bhs     G_M000_IG05
                str     wzr, [x0, w1, UXTW #2]

    G_M000_IG04:
    @@ -25,4 +23,4 @@
                bl      CORINFO_HELP_RNGCHKFAIL
                brk     #0

    -; Total bytes of code 68
    +; Total bytes of code 60

I know C#/F# decently well, but is there any reason to actually pull out the ol textbooks and learn wtf the above is saying?

You don’t need to, but if you ever want to really optimise some code, understanding what it turns into on the target CPU really helps. Especially if you know the implications for any particular instruction (cost of memory access, potential branch prediction misses, etc)

The three* letter mnemonics are usually pretty easy to decode, even if you don’t know the architecture: anything beginning with ‘B’ will be branch, so ‘ble’ is branch if less than or equal. L and S based mnemonics are unusually Load and Store from and to memory. After that it’s understanding the stack and registers and you’re pretty much good to go.

Everything in assembly is loading something from memory into registers doing something basic with those registers, like add/divide/etc and then putting the result back into memory or using the result to make a decision to jump to processing instructions from another place in memory.

Most devs won’t ever need to know this stuff, but as someone who grew up with computers that could barely do anything without grinding to a halt (8bit computer, 2mhz processor, 32kb of RAM, 20kb of which is for the screen), knowing this stuff was essential; however I still find this stuff useful today, even with my C# work.

I am a bit of a performance tuning nerd though, so…

[*] or more

Kinda. I use the `disassemble` function in Common Lisp quite a bit, and I can't work backwards to explain what a function is doing based on the disassembly.

BUT what I can do is see which functions are being inlined, which values are in memory versus in registers, see if things are being boxed and unboxed a lot, see if SIMD is being used, etc.

And more importantly I can compare two versions of a function to see which one looks better by those criteria. It's not perfect, but IME it works really well for guiding optimization.

I should add that I read the book "Assembly Language: step-by-step" by Jeff Duntemann, and wrote a Tic-Tac-Toe game in assembly ages ago, so that helps a bit to understand the syntax.

(And technically that's a patch file :-)

Impressive technical work and authorship. My quibble, which seems significant in context, is what happened with AoT?

AoT is still a thing. Presumably a lot of the JIT improvements would also improve the generation of AoT-compiled code.

I hope that’s the case but I’d feel a lot better to see it in print.

C#/.NET are very well-represented in LLM data - from enterprise back-end code to games. A language to use for sure.

Flip side: LLMs have to be very explicitly told to code in "modern" .NET and C# due to lack of representation in the training set.

Case in point: extension members from C# 14 is one that LLMs commonly stumble on and requires an explicit example. It still sometimes says that this is not valid syntax.

    extension(SomeType instance)
    {
        public OtherType DoSomething() { ... }
    }

Agents really struggle on this one for some reason.

Even older releases have a few that I notice LLMs making mistakes on like use of `System.Threading.Lock` over `Object` when locking.

these blog posts have really turned me into a dotnet evangelist. love the framework & language.

Too bad there’s such a lingering culture of Windows and creaky Lenovos and Dells around it. I’m sure it can be different, but I’m not taking my chances ever again. Simply not worth my sanity.

[flagged]

Not sure when your last foray into the .NET ecosystem was, but every since it is xplat and unified (.NET 5 probably) it is a real joy. I use VSCode as IDE for C# on my mac, and deploy to Linux.

He didn't say you can't use Linux or MacOS, he said there's still a culture of being Windows and Microsoft only across .NET shops. As an ex .NET dev I can confirm, the community is quite close minded, language is awesome.

I think it's changing a lot recently. Our eng team of ~150 has been fully macos for several years now and we've deployed to Linux for ten.

I've been using .NET almost exclusively on Linux since it was called .NET Core 2.0, and development platforms other than Windows do feel like second class citizens. Any time you venture into anything remotely advanced, the tooling is usually Windows only.

"Everything" expects you to use MSSQL, even if today there's ok official support for PostgreSQL and SQLite. Most "thought leaders" of various sorts are on Windows and expect you to use it. This pervades throughout the ecosystem.

Can't see this ever changing as it's not in MS' interest to turn other operating systems into good .NET development platforms.

I'm sure you know more about this than me, but EF works fine with SQLite for a project I work on. There are limitations, but I think there's a difference between the idea of EF deliberately not implementing some features for SQLite and SQLite itself not having support for some EF features (which is the reality I'm familiar with).

SQL Server is the flagship database project on the Microsoft side and that team surely has some imperative to facilitate the EF vision. It simply must be less of a priority for the PostgreSQL and SQLite maintainers to do so. Is that really a valid dig on the .net ecosystem, though?

This post was so refreshing to read, because it reminds me of a time of solid engineering & writing in a pre-AI era.

I’m afraid posts like this might become fleeting.

looks like a large chunk of this was written by claude though :(

the technical parts are fresh as ever but the writing style is awful, man

I hope there will be some kind of runtime async support for the current or a new asyncmethodbuilder. That is amazing work.