When in doubt, just use C# and ASP.NET Core.
It's blazing fast.
.NET 11 RC2 is even faster.
For me, it's the best overall major web framework - auth, config, logging, perf, modular middleware, DI, cross-plat, etc.
But I didn't expect this:
Julien Couvreur retweeted
.NET and F# are here waiting for you all
Very fast inner loop compile times
Strong type systems
Great deployment models
Julien Couvreur retweeted
LLM Inference Engineering - Problem and Solution
Problem: LLMs are slow
Solution: KV Cache - Avoid recomputing previous tokens.
Problem: KV Cache consumes huge memory
Solution: PagedAttention - Manage KV memory efficiently.
Problem: GPU is underutilized
Solution: Continuous Batching - Dynamically add/remove requests.
Problem: Token generation is sequential
Solution: Speculative Decoding - Generate and verify multiple tokens together.
Problem: Attention requires large memory usage and expensive memory movement
Solution: FlashAttention - Reduce memory usage and memory movement during attention.
Problem: KV Cache is still large
Solution: MQA / GQA - Share K/V across multiple query heads.
Problem: Many optimizations need to work together
Solution: vLLM - Build an efficient inference engine.
Problem: Applications repeatedly process the same prefixes
Solution: RadixAttention / Prefix Caching - Reuse previously computed work.
Problem: Models are too large
Solution: Quantization - Reduce model memory and computation.
Problem: Large models are expensive
Solution: Distillation / SLMs / MoE - Make inference itself cheaper.
Keep Learning, Keep Sharing, and Keep Growing.
Julien Couvreur retweeted
This is one of the best engineering blogs you'll ever read.
Not *just* because you'll learn a lot, but because @vmg sprinkles in a bit of everything.
A great story. History of git infrastructure. Distributed systems. Benchmarks. All written by someone who can speak to every point from deep, personal experience.
It's also 5,300 words, so grab a drink and enjoy.
Julien Couvreur retweeted
How Fast is #dotnet 11 Runtime Async? | Medium
medium.com/@skyake/how-fast-…
Julien Couvreur retweeted
Diffs you can edit!
Edit mode is now in beta on diffs[dot]com, and we want your help to perfect it.
We’re running an online hackathon this week. Build something with diffs, and show us what the new edit mode can do. Post your entry in the comments by 5pm PT on Monday August 10th. Winners get exclusive Pierre Computer Company merch.
Julien Couvreur retweeted
TypeScript creator @ahejlsberg puts TypeScript 7 through its paces, compiling the 2.3M-line @code codebase in under five seconds, and breaking down how the new 10x faster Go-powered compiler and language service scales with shared-memory concurrency.
We definitely need better code review tools.
I also started a proof-of-concept, with the goal of combining great diffs (local or online), comments (to local agent and online peers) and agentic buddy.
It's implemented as a GitHub Copilot App canvas. Still iterating...
👇
Julien Couvreur retweeted
Since file-based apps landed in .NET, I stopped writing .ps1 and .sh files for helper scripts in my repos.
With shebang support, we can run them directly on Unix as ./tools/foo.cs. And when combined with Spectre.Console.Cli and CliWrap, we can get a lot done with very little code.
It is awesome.
learn.microsoft.com/en-us/do…
After 25y at Microsoft, including 10 working on Roslyn, I'm moving on to new adventures.
I'll still post about interesting C# and AI experiments. Hoping to push extension constants in for C# 15.
To follow new C# features, watch the feature status page: github.com/dotnet/roslyn/blo…
Julien Couvreur retweeted
Blogged: Closed class hierarchies - Exploring the .NET 11 preview - Part 4
andrewlock.net/exploring-the…
In this post I describe what a closed closed hierarchy is, how to create one, and discuss why you might want one
#dotnet #csharp
We merged a C# 15 preview feature into .NET 11 preview 7: labeled break and continue statements.
Allows `break` and `continue` to optionally specify a label that identifies which loop or switch statement to target.
Example below.
Spec: github.com/dotnet/csharplang…
We merged a C# 15 preview feature into .NET 11 preview 6: extension indexers.
It allows declaring and consuming indexers defined in `extension` blocks.
```
static class E
{
extension(...)
{
int this[...] { get ... set ... }
}
}
```
Spec: github.com/dotnet/csharplang…
Julien Couvreur retweeted
Second for second, @tylercowen packs more substance into a talk than anyone I'm aware of. This is a clear, non-hysterical, and somewhat soothing discussion of our AI future.
We merged an early C# 15 preview feature into .NET 11 preview 5: closed class hierarchies.
Allows a `closed` modifier on a `class` declaration.
A `closed` class prevents direct inheritance from other assemblies, so pattern matching can treat its derived types as a complete set.
Spec: github.com/dotnet/csharplang…
```
public closed class C { ... }
```

















