23 February 2026

Web Components Are the Comeback Nobody Saw Coming

When Web Components were first introduced, browser support was a bit spotty, and developers were keen to use the latest framework. Now, developers are getting tired of the complexity of frameworks, and Web Components are fully supported in all major browsers, so they are making a comeback.

Why Developers Are Ditching Frameworks for Vanilla JavaScript

On a similar note, many developers are choosing to use vanilla JavaScript instead of frameworks. The simplicity of native JavaScript can add performance benefits.

Traditional Code Review Is Dead. What Comes Next?

Human reviewers tend to do line-by-line PR reviews, which tend to focus on style and formatting, and miss the bigger picture of the code changes. AI code reviews can analyze the entire code change and provide feedback on the overall design and architecture. Whereas code reviews were often a bottleneck, the AI code review can help a human reviewer to do a quick “LGTM” review, they may accept AI hallucinations.

LazyCache is deprecated

Use HybridCache instead.

Pass the State

The problem with code like this:

public IEnumerable<Item> GetOversized(IEnumerable<Item> items, int minOversize)
{
    return items.Where(item => item.Size > minOversize);
}

is that it’s capturing the scope - in this case, it’s wrapping minOversize in an object.

To make this allocation-free, we can use a static method and pass the state as a parameter:

public IEnumerable<Item> GetOversized(IEnumerable<Item> items, int minOversize)
{
    return items.Where(static (item) => item.Size > minOversize);
}

This won’t compile because the static means that the lambda can’t capture any state. So we need to pass the state as a parameter:

public IEnumerable<Item> GetOversized(IEnumerable<Item> items, int minOversize)
{
        return items.Where(static (item, ctxMinOverSize) => item.Size > ctxMinOverSize, minOversize);
}

This way, we can avoid the allocation of the closure object.

Making foreach on an IEnumerable allocation-free using reflection and dynamic methods

You might know that in order to use foreach on a collection, you need to implement IEnumerable (or IEnumerable<T>).

Unexpectedly, the compiler uses pattern matching to find a GetEnumerator() method that looks like IEnumerable - it doesn’t actually use the interface.

This article explains in detail why this is more efficient and works without allocations.

What came first: the CNAME or the A record?

Description of how an attempt at memory usage reduction triggered a wave of DNS outage.

A DNS lookup is a sequence of queries. Some parts of that chain may contain expired records, and so the resolver would lookup the expired records and append the new value to the end of the chain. The problem is that the specification is ambiguous about the order, but many implementations would expect the original order.

Clock Synchronization Is a Nightmare

How to keep your clocks in sync. There’s no such thing as the correct time - there’s just various ways to get a good enough time.

Simple OCR and NER Feature Extraction in C# with ONNX

Describes the components of extracting text from an image. Not using fundamentals, but using libraries and models, like OCR for dummies.

How to Start a New .NET Project in 2026

Starts off with the basic settings that you want in all your projects, like Directory.Build.props, Directory.Packages.props and .editorconfig. After that it goes into more specifics that depend more on your preferences, like Aspire, OpenTelemetry and GitHub Actions.

Creating and consuming metrics with System.Diagnostics.Metrics APIs

How to use System.Diagnostics.Metrics to create and report on metrics.

Lease Pattern in .NET: A Lock With an Expiration Date That Saves Your Data

The problem with indefinite locks is that they have these three false assumptions:

• The lock holder can always release the lock.
• Everyone can observe the release.
• Time does not jump.

A lease is a lock with a time limit that requires the owner to keep renewing that claim if he wants to keep the lock.

It goes on to describe how to use Redis as the lease store.

Phishing on the Edge of the Web and Mobile Using QR Codes

In-depth report on the techniques and prevalence of QR code phishing (quishing) attacks.

New runtime async is hitting .NET 11 - Part 1

Currently async and await are implemented as a compiler transformation that generates a state machine. In .NET 11, the runtime will have native support for async methods. This article doesn’t go into much detail, but I expect to hear a lot more about this.

Pagination, Sorting & Searching in ASP.NET Core Web API

Describes how to do this on your API:

GET /api/movies?pageNumber=2&pageSize=5&sortBy=rating desc&search=sci-fi

Redefining the Software Engineering Profession for AI

How AI gives a boost to senior engineers, but a drag to junior engineers who lack the experience to question the AI. But you need to hire juniors and train them up to become seniors.