|
Five Questions I Ask of Every .NET Release |
|
Every new .NET release brings a familiar wave of announcements, features, and improvements. But do we all read these announcements in the same way? Over the years, I have noticed that the questions I ask of a new release have changed considerably. From the excitement of discovering what's new to evaluating long-term support, architectural direction, and business implications, the way we read a release says quite a bit about how we grow as developers. Here are five questions I have learned to ask—and one additional consideration that becomes increasingly important with experience. |
|
Posted On : 13 Nov 2026 |
|
|
Firewalls and the Great Schism |
|
This article explores the historical clash between early distributed object models—like DCOM and CORBA—and the practical security realities of corporate firewalls. It details how silent network drops, dynamic port allocation issues, and operational friction forced software architecture to evolve away from seamless local-remote abstractions. Ultimately, it reveals how the industry compromised by turning to HTTP, Port 80, and XML to navigate around enterprise network boundaries.
|
|
Posted On : 04 Nov 2026 |
|
|
DCOM, MTS, COM+, and MSMQ — The Cost of Pretending |
|
A journey through DCOM, MTS, COM+, and MSMQ, exploring how Microsoft's distributed computing technologies attempted to make remote systems feel local. Along the way, it reveals a timeless lesson: complexity is rarely eliminated by abstraction, only moved somewhere else. |
|
Posted On : 28 Oct 2026 |
|
|
Contracts, Identity, Promises |
|
This article explores the ideas behind COM, from interface contracts and component identity to registration and activation. It examines how COM made reusable software components possible while introducing practical challenges around deployment, versioning, and machine configuration. Through these experiences, we revisit the promises and limitations of component-based development. The discussion sets the stage for understanding how DCOM extended these ideas across machine boundaries. |
|
Posted On : 21 Oct 2026 |
|
|
Prologue: The Original Temptation |
|
From RPC and COM to cloud services, gRPC, and AI tool calls, distributed computing has continually sought to make remote operations feel local. This article introduces a journey through the technologies, ideas, and trade-offs behind that pursuit. Along the way, we explore why location transparency is useful, where it breaks down, and why the network can never be entirely abstracted away.
|
|
Posted On : 14 Oct 2026 |
|
|
Real-Time at Last: SSE and SignalR in ASP.NET Core |
|
In Part 1, we walked through the pre-real-time era of server status updates: full page refresh, XMLHttpRequest, Ajax and fetch(), and short/long polling. What all of that machinery was really reaching for is a way for the server to simply tell the client when something happens, the moment it happens. That's what this post covers: Server-Sent Events (SSE) and SignalR, the two mainstream ways to get genuine server push in ASP.NET Core. |
|
Posted On : 23 Sep 2026 |
|
|
From Page Refresh to fetch(): The Pre-Real-Time Era of Status Updates in ASP.NET Core |
|
Almost every non-trivial web application eventually needs to answer a simple question: something is processing on the server, and the user needs to know when it's finished (or how far along it is). Generating a large report. Processing an uploaded video. Running a batch import. Training a model. Provisioning a resource. These operations may take longer than you want a single HTTP request to remain open, so the browser can't just wait around for a response — the user needs a way to check back in. |
|
Posted On : 16 Sep 2026 |
|
|
One Language to Rule Them? LINQ, Abstraction, and What's Next |
|
In Part 1, we traced how .NET's data formats each grew their own query language, and how LINQ emerged as Microsoft's attempt to paper over the fragmentation. In Part 2, we walked through that fragmentation format by format — and kept bumping into the same fact: sooner or later, almost everything gets funneled into objects, and queried with LINQ. |
|
Posted On : 19 Aug 2026 |
|
|
A Field Guide to .NET Data Formats |
|
In Part 1, we made the case that every data format grows its own language because the shape of the data dictates what kind of navigation makes sense. This part is the reference you actually bookmark: a walk through the formats a .NET developer runs into, the native language each one speaks, and a small idiomatic snippet for each so you can see the shape of the code, not just the theory. |
|
Posted On : 12 Aug 2026 |
|
|
The Many Languages of Data: How .NET Learned to Speak in Formats |
|
It's a Tuesday afternoon and you're debugging a feature that touches four different pieces of data. First, you write a SQL query to pull a customer record from the database. Then you filter an in-memory list of orders using LINQ. Then you parse a JSON payload from a third-party API, reaching for dot-notation and the occasional JSONPath expression. Finally, you open a legacy XML configuration file and, out of muscle memory, write an XPath query to find the node you need. |
|
Posted On : 05 Aug 2026 |
|