Topic
Languages, Runtimes & Performance
JIT, AOT, async, memory and benchmarking. Follow the code that runs and measure what it costs.

Memory and Allocations in .NET: Measure, Find the Owner, Then Optimize
A map of .NET memory work: allocation versus retention, what the JIT and the GC decide, how to measure first, find who owns retained memory, and when pooling and zero-copy pay.

Async Work Is Not on the Thread Stack: Tracing Suspended .NET Code
A checkout hangs at an await while every thread looks idle. Find it on the heap with dumpasync, fix the race, and measure what dumps and traces cost a live .NET 11 service.

Why .NET 11 Removes This Box, but Keeps That Allocation
One pricing hot path on .NET 10 and .NET 11: int? and decimal? boxes stop allocating, a Guid? box and escaping boxes do not. The JIT code, the measurements and the fix.

A Performance Diagnosis That Survives the Allocation Explanation
Allocation fell 74% and latency did not move. Test competing explanations on a real ASP.NET Core and SQLite endpoint, see what each profiler records, and hand over a decision.

Runtime Async in .NET 11: Who Builds the State Machine Now?
In .NET 11 the JIT, not the C# compiler, can implement async methods. Compare the IL and x64 of both builds and measure what changes for completed and suspended calls.

ASP.NET Waits with Low CPU: Find the Queue Before Changing the Pool
A catalogue API on four vCPUs served 5 requests a second with .Result and 147 with await. Read the counters and stacks, see how the pool adds threads, and why MinThreads only hides it.

Why Your .NET Payload Survives: Trace the Roots, Unlink and Drain
Follow the reference that keeps an export's 16 MiB document alive on .NET 9, read it with gcroot, measure what the leak hides, and build a subscription that unlinks and drains.

A Timeout Is Not Cancellation: WaitAsync, WhenAny and Lost Commits
Task.WaitAsync and Task.WhenAny end your wait, not the work. A measured checkout lab shows the lost and duplicated commit, who still holds the operation, and the fixes that work.

Reusable ValueTask Sources: When Is It Safe to Call Reset?
Build an IValueTaskSource that survives reuse: release in GetResult, reserve completion before SetResult, and stop an inline consumer from breaking the next receive.

Lazy<T> Under Contention: Racing Factories, Cached Failures, Blocked Threads
What each LazyThreadSafetyMode really does on the first call: losing factories that keep their side effects, exceptions cached forever, blocked callers, and an async cache that recovers.

ArrayPool Across await: Leases, Ownership Transfer and Real Savings
Reproduce a pooled buffer that sends another order's bytes, see how ArrayPool.Shared is built, transfer ownership through a queue and measure what pooling saves and costs.

Same Service, Different Numbers: A Measurement Contract for .NET
One ASP.NET Core service, six runtime settings, three runs each: why a fresh process, tiering, PGO, ReadyToRun and the GC mode move p50 to p99, and what every number must state.