Technical Notes From The Hot Path
C#, .NET, memory, performance, and the engineering details that make software feel fast.Forging a Distributed Job Engine on MQTT 5.0: Bitmask Cron, Source Generators, and LWT Crash Recovery
How I built Beskar.Jobs—a low-allocation, transport-agnostic distributed background job scheduler and worker engine layered natively on MQTT 5.0 RPC, hardware-intrinsic bitmask Cron evaluation, and Roslyn source generators.
Synthetic Complexity: Why High-Output AI Code Feels Like Cognitive Sludge
High-output agentic AI creates an illusion of velocity while transferring an unsustainable cognitive tax onto reviewers. Here is how synthetic bloat decays software craft.
How to stay a good software engineer despite AI
Preserving the art of sustainable software craftsmanship: building robust, lasting systems rather than succumbing to the cycle of throwaway code
This Is the Way: Low-Allocation Request-Response in MQTT 5.0
An in-depth look at how we implemented low-allocation bidirectional RPC over MQTT 5.0 in Beskar.Networking, utilizing Response Topics, Correlation Data, and asynchronous Task Completion Sources.
Resiliency in the Chaos: Source-Generated Framing and Auto-Reconnecting Client-Server Pipelines
How I built a highly resilient, transport-agnostic client-server framework with source-generated framing, custom event pipelines, and verified it using a custom-built network Chaos Simulator.
Allocations on the Wire: Building a Low-Allocation MQTT Broker with Trie Routing and .NET 10
An inside look at building the protocol layer for Beskar.Networking, covering UTF-8 based topic trie routing, alternate dictionary lookups, QoS tracking, and pooled connection systems.
ValueTask Deoptimization in .NET 11: How Runtime-Async Turns a Performance Trick into a Bottleneck
An in-depth technical analysis of why the classic synchronous-path ValueTask optimization backfires under the new experimental .NET 11 Runtime Async compilation model.
Writing a Zero-Allocation Source Generator: Roslyn, Cache-Safe Nodes, and Ref Struct Builders
A deep-dive guide to writing high-performance Roslyn Incremental Source Generators using cache-friendly syntax nodes, SequenceArray for zero-boilerplate pipeline caching, and CodeTextWriter.
Refactoring to Spans: Making Old, Allocation-Heavy C# APIs Zero-Alloc
A practical guide to refactoring legacy, allocation-heavy C# string parsing, binary decoding, and string formatting APIs into high-performance, zero-allocation span-based code.
Sockets on a Pipeline: Low-Allocation Networking with Beskar.Memory
An in-depth technical guide to building an ultra-fast TCP socket transport using System.IO.Pipelines, SocketAsyncEventArgs, and Beskar.Memory pools.
The Journey to Native Markdown: Frontmatter, Slugs, and Code Interceptors
A deep-dive article detailing the transition from expensive string post-processing to zero-allocation native features in Beskar.Markdown.
How Beskar.Markdown stays low on memory and still fast
A code-focused article about the design choices behind Beskar.Markdown: spans, compact nodes, pooled buffers, single-pass parsing, contextual rendering, and honest benchmark tradeoffs.
Span<T> in C#: stop allocating for work you can borrow
A practical introduction to Span<T>, ReadOnlySpan<T>, Memory<T>, and pooled buffers for low-allocation C# code.
C# 14 extension members: APIs that feel like they belonged there
A practical look at C# 14 extension blocks, extension properties, static extension members, operators, and why they are useful for low-allocation fluent APIs.