Articles
Engineering that holds up in production
Long-form articles on .NET, Azure, databases and AI systems. Each one explains a mechanism, shows code that has been run, and names the trade-off.
-

JIT, ReadyToRun or Native AOT? Four .NET Release Decisions
Choose a publish mode for four .NET applications. Use the CLI, API and worker migration results to decide which gains justify a rollout and when to keep the old build.
-

Memory per .NET Instance: Working Set, Heap and What Stays Alive
Follow the memory a worker needs to deliver a file. Compare allocations, resident memory and GC pause time across .NET 10 and 11, then choose the next diagnostic.
-

How to Compare .NET JIT and Native AOT by CPU per Completed Job
Compare .NET 10 and 11 under rising ASP.NET Core traffic. Read p99 alongside missed requests, CPU per correct response and the delay introduced by the load generator.
-

Measuring .NET Startup Through the First Correct Response
Measure the wait from process launch to valid XML, trace the first ASP.NET Core response, and turn a .NET 10 versus 11 CLI comparison into a nightly batch budget.
-

Build Host, Target, Receiver: Where a Native .NET Build Runs
Follow an Intake build from macOS to Windows and Linux. Diagnose a missing loader and see which CPU and operating system each native, virtualized or translated run actually tested.
-

Trimming and Reflection in .NET. What Do IL2026 and IL3050 Promise?
Trace a missing XML name and an empty HTTP error to the published files. Compare analyzer warnings, generated JSON metadata and the native method map before signing off.
-

Native AOT Has No JIT: What Does Expression.Compile Run?
Follow a customer rule from its expression tree into a native interpreter, check the managed bytes per call, and see when plain delegates can replace the tree.
-

ReadyToRun in .NET: When the JIT Replaces Precompiled Code
Open a ReadyToRun assembly, follow a precompiled method into a later JIT tier, and weigh the file-size cost against the work left on the first request.
-

Tiered Compilation: Why .NET Compiles the Same Method Twice
Follow one payload check from quick code to an optimized body, watch a running loop change tiers, and decide what to measure before changing your worker image.
-

When Does a C# Method Become Machine Code? JIT and AOT, Traced
Trace one C# method from IL to its first JIT body. Follow the same portable assembly on an Intel Xeon, an AMD EPYC and an Apple M3 Max to see which instructions each runs.
-

Same Source, Two Publishes. What Does a .NET Release Ship?
Follow an export that passes the .NET build and fails before it writes the partner document. Open the launcher, inspect its dependencies and test the published tool.
-

Blazor with AI: Streaming, Client-Side Search and the Hidden Network
Where AI work runs in Blazor, what streaming does to rendering and state, what moves to the browser in semantic search, and the requests a component makes that nobody sees.
-

Read the SQL Server Plan Before You Tune: Rows, Grants and Statistics
A map of SQL Server tuning: how statistics drive estimates, what an actual plan shows about rows read, grants and spills, what monitoring costs, and how to verify maintenance and recovery.
-

Observability in .NET: Telemetry Cost, Schema Drift and One Trace
A map of .NET observability: what telemetry costs before the sampler decides, what a full pipeline drops, how its schema ages, and how one order reads as one trace across a queue.
-

Async in .NET 10 and 11 from the Inside: From await to Thread Pool
What the compiler and the .NET 11 JIT build for an await, where a suspended method lives, how the thread pool resumes it, and what timeouts, cancellation and reuse really do.
-

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.
-

Human Approval After a Restart: One Reviewed Proposal, One Local Effect
Bind approval to the exact draft, evidence and policy, resume a pending review from an Agent Framework checkpoint in a new process, and recover a lost receipt without a second effect.
-

When an Agent Coordinator Has a Real Choice
Drop selector calls where the dependency graph already decides, keep a checked selector only at a real fork, and charge every attempt so a fluent loop that makes no progress still stops.
-

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.
-

RAG That Keeps Its Evidence: Eligibility, Coverage and Licensed Claims
Filter before Top K, check that the selected set covers every required fact, accept only sentences their citations license, and carry an evidence identity into the next stage.
-

Local Models and Polish Routing: Evaluate the Errors, Not the Average
A local model changes where inference runs, not what its scores mean. Evaluate English and Polish pairs, separate agreement from correctness, and see why a margin threshold misleads.
-

Azure Decision APIs: Root, Deployment, Operation and Token Audience
Microsoft-Decision-1 and Azure OpenAI Decisions use different paths, serializers and token audiences. Bind each to one validated C# profile and keep the token inside the deadline.
-

Native Decision API Clients in C#: Wire Shapes and Stalled Bodies
Build one C# client for System One and OpenAI Decisions that maps answers by meaning, parses strictly, owns one deadline past the headers and reports every failure as a distinct outcome.
-

From AI Draft to Accepted Work Order: One Service, Real Review
A complete-looking AI draft can pass every validator and still overstate its evidence. Route forms and IChatClient through one service and bind approval to revision and evidence.
-

Decision APIs: Derive the Threshold From the Cost of Each Error
A probability is not an action. Derive automation and review thresholds from error costs, model imperfect reviewers, rank a scarce queue and check what calibration must hold.
-

Designing a Decision Contract That Preserves Meaning in C#
Write the rubric first, give choice, predicate and score their own C# types, and reject what a JSON schema cannot see: missing candidates, inconsistent means and duplicate keys.
-

What a Decision Probability Actually Computes: Logits to Labels
The same {"department":"technical"} can come from generation, a classifier or label scoring. Work through softmax, candidate sets, multi-token labels and schema masks to see what 0.88 means.
-

Decision APIs in .NET: One Judgment Inside a Working Support Desk
What a decision API is, how it differs from a chat model, why three vendors shipped one in five weeks, and how one bounded judgment fits inside a working .NET support desk where C# owns the action.
-

A Small Agent Platform on Azure: Events, Claims, Workers and a Restart
Service Bus events start agent work. Commit the event and the job before settling, claim against the source of truth, and see what survives faults, duplicates and a killed worker.
-

An AI Agent on SQL Server: Typed Intent, Real Read-Only, Rows Read
One question, four answers. Give a SQL agent a typed tool, a login SQL Server restricts, and measured rows read, then check every read-only claim with a command.
-

Why This Total Changed: Lineage, Retries and Freshness to Screen
Follow one dashboard total from the order system to the screen: lineage that explains every change, retry history that keeps the failed attempt, and freshness measured end to end.
-

Hash Aggregate Spills: Read the Memory Grant Before Tuning It
A SQL Server 2025 report spills despite an overestimate. Measured fixes show why a better estimate made it worse, why grant hints drift, and which change removed the spill.
-

SQL Maintenance and Diagnostics as Products: Verify the Postcondition
A green statistics job can update the wrong table, sample instead of scan or leave no histogram, and a loose check calls it current. Verify the step by identity and version the diagnostic.
-

What an AI Business Still Owns When Models and Code Get Cheap
A cheaper model and a six-week rebuild take less than they seem. Find the promise around the code a business still owns, and how an investor tests it with a ledger of claims.
-

Semantic Search in Blazor WebAssembly: Where the Cost Moves
Run an embedding model in a Web Worker behind a Blazor component and measure what it moves: a 40 MB first visit, per-query time against a server, tokenizer and int8 pitfalls, caching, cleanup.
-

Azure Blob Downloads in .NET: Buffers, Ranges and Safe Publication
Copy arrays, transfer sizes and OpenRead buffers are three different knobs. Real SDK calls show what each one sends, how cut connections resume, and how to publish only verified bytes.
-

The Hidden Network Work of a Blazor Search Box
Out-of-order responses, stale errors and abandoned server work in a Blazor search box, measured on .NET 11, and a component where debounce, cancellation and a generation each do their job.
-

One Refund, Not Two: Agent Side Effects Across Timeouts and Restarts
A .NET support agent refunds through a payments API. Keys, receipts, reconciliation and a fence keep one refund per intent through lost replies, retries, restarts and reset chats.
-

When SQL Monitoring Becomes the Workload: Scans, Viewers and Locks
A four-row dashboard tile can out-read the business it watches, queue writers behind its own lock wait, and a ring-buffer poll can cost seconds. Measure, share one snapshot, read events by offset.
-

SQL Server Recovery You Can Rehearse: Restore, Runbook and Cutover
A verified backup still left the billing service broken, and a planned cutover lost invoices. One SQL Server 2025 rehearsal: restore, a runbook that refuses wrong steps, a fenced cutover.
-

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.
-

Engineering Judgment When AI Writes the First Draft
One team, four AI-drafted changes that all pass their tests: what judgment looks like when syntax is free, how to disagree with a confident machine, and what juniors and writers still need.
-

Modernize an ASP.NET API Without Rewriting Its Wire Contract
A rewrite from MVC and Newtonsoft.Json to minimal APIs and System.Text.Json can answer 200 and still change the bytes every client sees. Pin the wire, adapt it, measure the gain.
-

Streaming AI Answers in Blazor: Stop Old Requests Rewriting the View
A late chunk, an old validation verdict or a stale cleanup can corrupt a streaming Blazor answer. Guard every await, define Stop, throttle renders and test the orderings.
-

SQL Date Filters: Keep the Business Day and Count the Rows Read
Compute 23-hour and 25-hour local days at both ends, filter with typed half-open intervals, and see why a CONVERT(date) seek still read twice the rows on SQL Server 2025.
-

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.
-

Agent Authority You Can Prove: Reviews, Budgets and Loops That Stop
An agent that changes records and spends credits needs authority decided at the effect: a reviewer bound to the exact change, live permissions, reservations and a loop with typed endings.
-

From Laptop to Azure: Proxies, Identities and a Recipe That Proves It
Why an ASP.NET Core app breaks behind a proxy and on Azure: forwarded headers, managed identity, cache keys, and a deployment recipe that proves its result.
-

Telemetry Is a Schema: One Contract for a .NET AI Platform
A library upgrade renamed gen_ai.system and zeroed a dashboard. Treat .NET AI telemetry as a schema: contract tests, an adapter, cardinality limits and redacted prompts.
-

Buying AI for a Real Process: the Demo, the Pilot, the Evidence Gaps
Read what an AI demo quietly supplies, price the accepted result instead of the generation, design a pilot that can fail usefully, and state readiness as evidence gaps per responsibility.
-

RAG in .NET, Part 1: Restartable Ingestion and an Index Under Load
Import versioned documents so that a crash never publishes half a revision, then measure what a pgvector HNSW index finds, misses and costs under filters and updates.
-

Move ONNX Inference Behind HTTP Without Changing the Computation
Pin the embedding task as a contract, prove the HTTP path returns the same bits as ONNX Runtime in-process, fix the .NET tokenizer drift, then measure what the move costs.
-

Indexing JSON in SQL Server 2025: Typed Keys, Real Plans, Write Costs
A computed-column index and the new JSON index both turn a full scan into a few reads, but each stores its own meaning of a value and makes every update and rebuild pay. Measured on SQL Server 2025.
-

Upgrade the AI Stack Without Changing What the Agent Does
Move a .NET agent from Semantic Kernel to Agent Framework in measured steps: a behaviour matrix, a library tracker, a safe cutover and Copilot Studio as a contract.
-

Reservation Confirmed or Work Accepted: What 201 and 202 Promise
Two ASP.NET Core designs on SQL Server, measured and broken on purpose: what 201 and 202 promise, how clients must retry, and which faults turn a 202 into a lie.
-

Trace One Order Across HTTP, a Queue and Retries in .NET
Make an Aspire service explain itself before the first incident: carry trace context through RabbitMQ, keep failed retries visible, and know what survives when traces are sampled out.
-

RAG in .NET, Part 3: Verify the Answer, Not the Citation
An exact citation can carry a wrong unit, property, exception or revision. Pin claims to bytes and dates, check numbers, scope and negation in C#, and report quality per question type.
-

The AI Draft Passed Its Checks. Now Make the Product Decision
A schema check passes an unsupported AI judgment. Read one feature as engineer, founder and user, with runnable C#, overreliance research and a decision you can reverse.
-

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.
-

AI Made Drafting Faster. Where Did the Saved Time Actually Go?
Follow one team's saved drafting time into the review queue, coordination, rules that skip review and the people whose queue software sets, then decide where it should go.
-

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.
-

Telemetry Event Formats: Units, Versions, Bytes and CPU in .NET
One latency sample in five encodings, byte by byte: why tolerant readers turn 1.5 ms into 1.5 s, and what JSON, Protobuf, MessagePack and OTLP cost on .NET 9.
-

RAG in .NET, Part 2: Retrieve What the Caller May Use
Filter by tenant, grant and the revision in force before the top-k cut, measure what retrieval without it leaks, then tell a missing passage from an ignored one in C#.
-

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.
-

Who Owns the Design When AI Is on the Team? Review, Records, Repair
An AI-written cleanup patch passes four checks and deletes pinned files; the rule lived in an old chat. What review must check, where decisions live and how to assign ownership.
-

Refactor a Pricing Function Without Rewriting Its Rules
Pin a small C# pricing function with hand-calculated and property-based tests, refactor it in IDE steps that stay green, make a one-line change and prove the tests catch real mistakes.
-

The Observer Effect: What .NET Telemetry Costs Before Sampling
A sampled-out span can still build its payload, and a stalled exporter silently drops spans. Measure both with OpenTelemetry .NET and add the guards and counters that fix them.
-

Moving a Million Rows Through EF Core Without Losing or Repeating One
A million rows through an EF Core 10 export and a concurrent consumer, killed at the worst moments: what tracking costs, which keyset is fast, and the checks totals never run.
-

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.
-

What AI Work Really Costs: Failed Attempts, Review and the Azure Bill
Count every attempt, keep missing usage unknown and divide by accepted answers. A .NET cost ledger shows when review, not tokens, decides which model is cheaper.
-

Parsing TCP Frames in .NET: Cursors, Backpressure and Buffer Lifetimes
Build a framed PipeReader loop that survives split headers, see how a Pipe lays out segments and counts backpressure, and measure when copying, borrowing or flattening a payload wins.
No articles match. Change a filter or clear the search.