Friday, January 23, 2026

Mike James reports C# has been named TIOBE Programming Language of the Year 2025 after the biggest year-over-year gain, even as Python cools from its mid-2025 peak. This post explains what the index does and does not measure, ties the momentum back to Anders Hejlsberg's component-oriented vision for C#, and explores what rising share could mean for hiring and the .NET ecosystem. The takeaway is steady momentum that may push C# past Java soon, with practical implications for teams choosing languages and tooling.

Prasad Raveendran walks through native validation for Minimal APIs in .NET 10, bringing them much closer to MVC controllers. This post shows how data annotations plus AddValidation enable a source generated validator that short circuits bad requests with consistent ProblemDetails, trimming boilerplate and keeping handlers focused on business logic. A small addition with a big impact on production readiness.

El Bruno ran into 100-second HttpClient timeouts while using OllamaSharp for long-running local model work and traced it to the library's fixed client timeout. In this post he packages the fix as a small extension so you can set timeouts directly on the OllamaSharp client, with quick, standard, and long presets. If you are doing video analysis or lengthy generations, this keeps your runs alive and your code tidy.

Baibhav Kumar unpacks Redis caching patterns that shape real production behavior, focusing on who owns the source of truth, who handles failures, and where latency lands. This post contrasts cache-aside, read-through, write-through and write-behind with practical tradeoffs, and includes a C# cache-aside example for .NET apps. A clear guide to choosing the safer default vs when to accept risk for consistency or speed.

Mohamed Baioumy from Microsoft explains how Azure SQL Database bakes high availability into the platform across General Purpose, Business Critical, and Hyperscale, and what actually happens during failover. This post walks through gateway routing, replica and storage models, and typical recovery times, then ties it back to app design with zone redundancy choices and why your .NET clients still need transient retries. Handy context for matching SLAs to the right tier while keeping ops overhead low.

Yoshifumi Kawai unveils ToonEncoder, a C# library that encodes a JSON-compatible TOON format to shrink LLM prompts by packing primitive object arrays into a compact, CSV-like layout. This post shows where TOON pays off in real apps, how to plug it into Microsoft.Extensions.AI with source generated converters using attributes like GenerateToonTabularArrayConverter and GenerateToonSimpleObjectConverter, and why encode only is often all you need for function calls. Expect practical guidance on selectively applying TOON so you save tokens while keeping JSON where it still fits best.

Yohan Malshika compares direct DbContext usage and the repository pattern in ASP.NET Core with EF Core, showing where each shines. This post lays out definitions, pros and cons, and a small code sample, then frames the decision around project size, domain complexity, and testing needs. You come away knowing when to keep it simple with DbContext and when an extra abstraction can save you pain later.

Gulam Ali H. unpacks List beyond the dynamic array mental model, showing how capacity growth, resizing, and iteration rules shape performance and correctness. This post walks through what happens under the hood, why operations like Insert and Remove can surprise you at scale, and when EnsureCapacity, TrimExcess, or alternative collections are the better fit.

Round The Code gives a quick tour of ASP.NET Core route constraints for Minimal APIs, showing how to push validation to the edge with int, bool, Guid, date and string rules, plus regex and file path checks. If your endpoints need to be picky about inputs, this post shows how to make the URL do the heavy lifting.

Jordan Rowles untangles why string.Empty and the empty string literal are usually the same object but can diverge when empty strings are created at runtime. This post demystifies string interning, how it impacts ReferenceEquals checks, memory usage, and debugging, and where String.Intern helps or hurts. Expect clear, practical guidance like preferring string.IsNullOrEmpty for checks and using string.Empty for intent.

Atakan Serbes unpacks the Mixed Mode Operations anti-pattern in ORMs, where bulk SQL updates bypass the change tracker and leave EF Core out of sync with the database. A concise guide for speeding up large updates without breaking the mental model of your Unit of Work.

Melisa demystifies how EF Core builds the IModel on first use, what DbContext actually does, and when OnModelCreating kicks in. This post explains why the model is cached and shared across DbContext instances, using a helpful blueprint vs worker analogy to make performance implications clear. Expect practical guidance on shaping the model with Fluent API and global filters without wasting cycles rebuilding metadata.