Everything I've made

Tame Configuration in ASP.NET Core with IValidateOptions

Silent misconfiguration is sneaky and expensive. Learn how to validate strongly typed settings in .NET using IValidateOptions, add cross property rules, inject services, support named options, and fail fast at startup with ValidateOnStart.

Virtual vs Override vs Partial in C# Explained with Small Runnable Examples

Virtual, override and partial are tiny C# keywords with huge impact on design. This post explains how they work, when to use them, and where bugs appear. Learn the difference between override and new, why sealed override matters, and how partial classes and partial methods keep generated and hand written code happy. Every section comes with short, runnable snippets and real project tips.

EF Core Query Performance Tips for Everyone

EF Core does not make queries fast by default. You do. This guide shows how to cut query time by fetching less with projection, turning on AsNoTracking for reads, avoiding N+1, choosing AsSplitQuery for big includes, paginating, indexing and compiling hot queries. Each concept comes with small runnable C# snippets and clear explanations so you can apply them today without rewriting your app.

Sealed by Default in .NET: when it Shines and when it Bites

Sealed looks like a tiny keyword, but it carries serious weight in modern .NET. This post explains what sealed does at class and member level, why the JIT can make sealed code faster, when you should not seal, and how to keep code testable with interfaces. You will see small, runnable examples and practical patterns that balance performance, clarity, and flexibility.

Smarter Error Handling in C#: Try, Result and Fewer Tears

Exceptions are powerful for diagnostics but expensive in tight loops and high traffic code. This post explains what the runtime does when you throw, why that cost adds up, and when exceptions are the right tool. You will see small, runnable C# examples that model expected failures with Try, Result and tuples, plus a minimal API that returns HTTP results without throwing. We will also cover a micro tip for library authors to keep fast paths fast.

Stop Breaking Clocks in ASP.NET Core with UTC and TimeZoneInfo

Time bugs are sneaky and expensive, but they do not have to be. This post shows a practical UTC first approach for ASP.NET Core using DateTimeOffset and TimeZoneInfo. You will learn how to design your data model, return UTC from APIs, convert to a user’s local time, and avoid DST traps without hard coded offsets. We will also wrap conversions in a clean service and make time testable with TimeProvider.

From Layers to Slices: How I Ship Faster ASP.NET Core APIs

Your API should feel like a collection of small, focused stories, not a scavenger hunt through Services and Interfaces. This tutorial shows how to build a feature first Vertical Slice Architecture in ASP.NET Core using Minimal APIs, MediatR, and FluentValidation. You will see how commands and queries stay tidy, how validation runs before handlers, and how the folder structure reduces friction as your API count grows.

Stop Parallelizing Everything: A Practical Guide to Parallel.ForEach

Parallel.ForEach feels like a free speed boost, until it slows your app to a crawl. This post explains when parallel loops shine, when they backfire, and how to avoid the classic traps. You will see small runnable C# examples for CPU bound work, shared state pitfalls, and I/O scenarios. We will also cover safer async alternatives, thread local aggregation, and simple tuning with ParallelOptions. By the end, you will know how to pick the right approach and measure the impact with confidence.

EF Core Audit Logging with Interceptors that do not Clutter Your DbContext

Learn how to build a clean, production ready audit trail in EF Core that records who changed what and when without stuffing logic into your DbContext. We walk through a practical SaveChanges interceptor, compare it to overriding SaveChanges, and review trusted NuGet options. The post closes with performance and security practices that keep your database fast and your compliance officer calm.

How .NET 10 speeds up API validation without code changes

Model validation has been a reliable but costly part of every ASP.NET Core request. In .NET 10 and C# 14, validation gets faster through precomputed metadata, typed execution, and fewer allocations. This post explains what changed under the hood, shows small runnable examples, and includes a micro-benchmark you can adapt. You will also see how to write lean custom validators and pair validation with faster JSON parsing.

The Traps of Nullable<T> in C#: a Practical Guide with Tiny Examples

Nullable<T> is not a mini reference type and pretending it is will bite you. This guide walks through how nullable value types work at runtime, how boxing really behaves, and what operator lifting does. You will see small, runnable C# snippets that expose common traps and safe patterns. Learn how to handle equality, pattern matching, and generics without surprises.

Stop Guessing Types in C#: typeof, GetType and IsAssignableFrom Explained

Let's break down the real jobs of typeof, object.GetType and Type.IsAssignableFrom with small, runnable examples and a few nerdy references for fun.

Repository Pattern vs DbContext in Entity Framework Core

Tired of arguing about repositories in EF Core? This practical guide compares direct DbContext, thin repositories, and specification style queries with small, runnable C# examples. Learn when each option shines, what to avoid, and how to keep your code clean without hiding EF Core features.

C# 14's Unbound Generics in nameof Explained

C# 14 adds support for unbound generic types in nameof, so you can write nameof(Logger<>) and nameof(Dictionary<,>) without supplying throwaway type arguments. This post explains the syntax, shows practical examples for logs, exceptions, and attributes, and clarifies how nameof differs from typeof in this context.

Cleaner Joins in EF Core 10 with LeftJoin and RightJoin

EF Core 10 introduces LeftJoin and RightJoin to make outer joins readable and intuitive. This article shows how these methods translate to SQL, how to migrate from GroupJoin and DefaultIfEmpty, and how to handle nulls and filters without breaking semantics.

The Secret to Mastering Queue, Stack and Dictionary in C#!

EF Core soft deletes can be implemented with a nullable deletion timestamp, a save-changes interceptor, and global query filters.

Async Void in C#: The Trap Card You Keep Playing

The C# `init` accessor supports object initializers while preventing properties from being changed after initialization.

Fix Ambiguous Constructors in ASP.NET Dependency Injection!

Ambiguous ASP.NET Core dependency injection constructors can be resolved with an explicit constructor attribute, a factory, or keyed services.

Why Your OnModelCreating Is a Hot Mess (And How to Fix It)

Entity Framework Core configurations become cleaner and testable when persistence rules move into `IEntityTypeConfiguration` classes loaded through assembly scanning.

How Pattern Matching Saves Your Day!

ASP.NET Core exception handling progresses from built-in middleware and custom middleware to modular .NET 8 `IExceptionHandler` implementations registered in priority order.

Easy LINQ Tips Every Developer Should Know!

Practical LINQ techniques improve performance and readability by avoiding repeated work, unnecessary allocations, unstable pagination, and accidental client-side processing.

C# '== null': There's a Better Way!

The Peacock extension color-codes VS Code workspaces to distinguish projects, Live Share sessions, containers, WSL, and remote environments.

Dependency Injection Mistakes You Need to Avoid!

Five ASP.NET Core dependency injection failures cover missing registrations, circular dependencies, lifetime mismatches, ambiguous constructors, and scoped services used by background work.

Can One Letter Break Your App!?

Parameterizing Entity Framework queries can let EF reuse a compiled query shape and help the database reuse its query plan.

Stop Using == null: The Safer C# Pattern You Need Today!

C# inequality operators and `is not` pattern matching behave differently around constants, boxing, type checks, nulls, and overloaded operators.

ToLower is Killing your App Performance!

`Task.Wait` blocks its thread, while `await` releases that thread for other work until the operation completes.

Stop Using ToLower() for Comparisons! The Fast, Correct Way in C#

Make Entity Framework Faster with Parameterized Queries

Culture-sensitive lowercasing can break string comparisons, as demonstrated by the Turkish dotless i, while `OrdinalIgnoreCase` remains culture agnostic.

You Won't Believe The Hidden Dangers Of Lazy Loading

The REST Client VS Code extension sends REST and GraphQL requests from `.http` or `.rest` files with support for headers, bodies, variables, authentication, and request conversion.

Understand Retrieval Augmented Generation in Under 8 Minutes

You Won't Believe How EASY WinUI XAML Styling Can Be

What Is The BEST Windows UI Framework For Your Project

Supercharge Your WinForms Projects with .NET 9 Roslyn Analyzers

Windows Devs Rejoice! Building Local AI Just Got Easy!

What are Vector Databases and How Do They Give AI Superpowers?

How Do Machine Learning Models Actually Work?

The 7-Minute Guide to Understanding Artificial Intelligence

Building AI with .NET: ChatGPT 4o, Dall-E 3 & Whisper

A workplace ban on LINQ and unit tests prompts a critique of blanket restrictions, hard-coded SQL, and development rules rooted in past failures.

EF Core Queries Go BOOM!

Using an appropriate `StringComparison` avoids extra allocations and produces safer case-insensitive string comparisons.

IExceptionHandler Makes ASP.NET Exceptions Easy

.NET 8's `IExceptionHandler` supports centralized ASP.NET exception handling through built-in middleware and modular handlers for specific exception types.

Soft Deletes: The Upgrade Your EF Core Needs

The Bongo Cat VS Code extension adds an animated coding companion to the status bar.

Building Custom Middleware for ASP.NET Core

Queues, stacks, and dictionaries solve distinct C# collection problems involving fair ordering, last-in-first-out history, and fast typed lookups.

Slow Entity Framework Core queries? Let’s speed them up!

C# value types are passed by value, so assigning one variable to another creates a copy that can change independently.

Handle ASP.NET Core Exceptions Globally

C# pattern matching can compare a boxed runtime value with a constant even when equality operators reject the incompatible static types.

Don't Make These Entity Framework Core Mistakes

Five Entity Framework Core performance pitfalls cover unnecessary tracking, lazy loading, Cartesian explosion, buffering, and ineffective query caching.

Value Types in C#

Using `var` can reduce repetition and simplify refactoring, but descriptive names and team-wide consistency matter more than personal preference.

Reference Types in C#

C# reference types hold references to objects, so two variables can point to the same instance and observe the same changes.

The Best C# Collections Explained

C# 12 expands aliases to tuples, pointers, arrays, and most other types, helping shorten repeated or complex declarations.

Don't Make This Dependency Injection Mistake!

Injecting a shorter-lived service into a longer-lived one effectively extends the dependency's lifetime and creates invalid service designs.

C#: Class, Struct or Record - Which Should You Choose?

Classes, structs, records, and record structs are compared through reference versus value semantics, equality, mutability, and practical selection criteria.

String or string in C#?

C# `string` is an alias for `System.String`, making the choice primarily a matter of style and team consistency.

Should You be Using the var Keyword in C#?

Choosing among `IEnumerable`, `ICollection`, `IList`, and `IQueryable` depends on whether data needs iteration, mutation, positional access, or remote query processing.

What is the Record Type in C#?

Returning `Task` instead of `async void` keeps asynchronous work observable, testable, awaitable, and able to propagate exceptions correctly.

Stop Using the var Keyword!

Explicit C# types can reduce the mental effort of understanding inferred variables, while target-typed constructor syntax offers a concise compromise.

Stack vs. Heap in .NET

Git stash temporarily saves uncommitted changes, restores a clean working directory, and lets you reapply selected work later.

Should LINQ Be Banned from C#!?

Microsoft's AI Smart Components add clipboard-driven form filling, suggested combo-box options, and sentence autocomplete to .NET web interfaces.

Immutability in .NET just got a LOT easier

C# records provide value-based equality, concise declarations, useful printing, deconstruction, and immutable copying, while record structs offer value-type behavior.

You Should Probably Stop Using Task.Wait in C#

EF Core's `AsSplitQuery` avoids Cartesian explosion by loading sibling relationships with separate SQL queries and combining the results.

Should you await Inside Your C# Loops?

EF Core lazy loading can silently create N+1 database queries, while eager loading or targeted projections can retrieve data more efficiently.

I Tried Voice Coding, It Was A Disaster!

A voice-coding attempt gets tangled in repeated "delete word" commands while trying to produce an export, class, and stream.

It's ALWAYS CORS!!!!

A live debugging attempt moves from successful compilation to a failed fetch before identifying CORS as the culprit.

Should my Services be Transient, Scoped, or Singleton?

.NET dependency injection lifetimes are explained through transient, scoped, and singleton services, including the risks of mutable singletons and injecting shorter-lived dependencies into longer-lived services.

Why .NET AI Smart Components are game-changing

ASP.NET Core middleware processes requests in an ordered pipeline and can modify responses, short-circuit execution, or consume injected services.

How to Create a Custom HttpClient Logger (2024)

A custom `IHttpClientLogger` can replace verbose default HTTP client logs with focused request, response, and failure information.

Build Unity games in VS Code!

Microsoft's Unity extension brings C# tooling, IntelliCode support, and debugging to Visual Studio Code, with Unity package version 2.0.20 required for some setups.

What is Git Cherry-Pick?

Git cherry-pick applies a specific commit from another branch while preserving the rest of that branch's work.

Take Me Home VS Code

A Friday-evening developer lament captures a broken build, failing tests, and Visual Studio Code.

How to REALLY use git stash (save your work!)

Awaiting inside a loop runs operations sequentially, while collecting tasks and using `Task.WhenAll` enables concurrency when ordering is not required.

Edit GitHub Gists in VS Code!

The Gist extension creates public or private GitHub Gists from Visual Studio Code through the command palette.

Where's my code!?

The Peacock extension assigns colors to Visual Studio Code workspaces, with customizable targets and integrations for remote development and Live Share.

MVC vs. Minimal API vs. FastEndpoints - Which is Best for Your Project?

ASP.NET controllers, minimal APIs, and FastEndpoints offer different tradeoffs in organization, dependency injection, documentation, syntax, and built-in features.

What is git clean 🤯

`git clean` removes untracked files, with flags controlling forced deletion, untracked directories, and ignored files.

Are People Wrong About .NET?

Common startup objections to .NET are challenged through its cross-platform support, open-source ecosystem, deployment flexibility, performance, and modern tooling.

What is GitHub Gist?

GitHub Gists provide lightweight, version-controlled sharing for multiple public or private files without full repository features.

What IS git switch!?

`git switch` separates branch switching from `git checkout`, while `git restore` handles restoring paths from an index or tree.

Choosing Between Controllers and Minimal API for .NET APIs

.NET now offers several methods for creating APIs. Let's cover the pros & cons of building with Controllers, Minimal API, and more.

How has .NET not had this before!?

C# collection expressions simplify array and list creation, add spread syntax, and can support custom collection types through a builder attribute.

Better C# Anonymous Functions & Lambdas

A playful Blazor movie-trailer riff contrasts .NET web development with MVC, postbacks, state, JavaScript, and jQuery.

Alias any Type with C# 12

With C# 12, you can now alias type, including tuples, array, pointer, and unsafe types.

Alias Any Type in C# 12

C# pattern matching with `is null` and `is not null` avoids misleading results from overloaded equality operators.

Using Primary Constructors in C# 12 & .NET 8

C# 12 provides a new way to use constructors that can potentially save you time, but there are several things to watch out for.

C# Has New Primary Constructors

CodeSnap creates customizable, theme-aware screenshots of selected code directly inside VS Code.

Integrating a Notion Database with an Astro Site

My entire life is planned & documented in Notion. How can I pull that content into my Astro site so I don't have to duplicate it in content collections?

I Tried NeoVIM

A brief outtake cycles through wrong guesses before landing on a joke about leaving Visual Studio Code.

I Don't Hate YAML Anymore!

Red Hat's YAML extension helps Visual Studio Code detect structural, indentation, and type problems, with stronger validation when a schema is available.

Screenshot VS Code like a pro 📸

CodeSnap creates themed code screenshots directly inside Visual Studio Code with a live preview and selectable lines.

Bongo cat loves my code!

C# 12 primary constructors reduce boilerplate by exposing constructor parameters throughout a type, but introduce important rules around overloads, naming conflicts, and generated properties.

HTML in VS Code = Easy Mode

HTML Biscuits adds customizable annotations beside closing tags so deeply nested HTML is easier to navigate.

What if AI takes developer jobs!?

A brief comedy pitch invites singles to an OnlyFans featuring bald, bearded feet.

Stop misspelling code in VS Code!

C# 12 adds default parameter values and `params` support to anonymous functions and lambda expressions.

.NET Blazor movie trailer

Code Spell Checker finds spelling mistakes across documentation, comments, variables, and function names, including words embedded in camel case.

I’ve Never Built this for a Client

A developer with nearly 20 years of experience confesses that he has never built tic-tac-toe for a client, then detours into microphones, a back scratcher, and Vue.js.

How to Email Phone Call Transcripts with Twilio Studio and Pipedream

Learn how to build a workflow that allows people to call & leave a message that will automatically be transcribed and emailed, using Twilio Studio, Pipedream, and Deepgram.

Try Whisper: OpenAI's Speech Recognition Model in 1 Minute

Deepgram has made testing OpenAI's new open-sourced Whisper speech recognition model easy as copy and paste.

Creating Short URLs with Netlify Functions and FaunaDb

Personalized short URLs are cool. So I decided to see if I could use a serverless function to do it for me.

Making a Man: Lessons Learned from My Single Mother

Remembering the integrity and tenacity my mom displayed in her life and the lessons she worked to instill in me.

Updating Notion Cover Images with Pipedream and JavaScript

Using JavaScript and Pipedream to automate changing my Notion cover image each night.

Building 404 Pages That Bring Joy

How we transformed the bad experience of landing on a 404 page into an enjoyable experience with a game.

Building a Cross Platform NuGet Package

Learning to build a NuGet package by building a .NET SDK for the Deepgram API, while ensuring it's compatible with as many versions of the .NET Framework and as many platforms as possible.

Building a Discord Bot to Improve Inclusive Language

Building a Discord bot sounds like a fun and I couldn't think of a better first project than trying to make it a safer space for everyone.

Using Polywork to Break My Unconscious Biases

Polywork is an interesting new LinkedIn competitor. After joining, I wanted to ensure that my "bubble" included a diverse set of people. Here's how I did it.

Mastering CSV with VS Code

Rainbow CSV makes delimited files easier to inspect in VS Code through color-coded columns, validation, alignment, headers, and SQL-like RBQL queries.

VSCode's New YAML Support is AWESOME

Red Hat's YAML extension improves Visual Studio Code with validation, automatic indentation, schemas, autocomplete, and contextual hover information.

Spell Check in VS Code with Code Spell Checker

Code Spell Checker finds mistakes in documentation, comments, variables, and function names while supporting quick fixes, custom dictionaries, additional languages, and targeted exclusions.

Write Better TailwindCSS in VS Code

Using `StringComparison` avoids the allocations, cultural errors, and slower performance caused by converting strings with `ToUpper` or `ToLower` before comparison.

10 VS Code Extensions You Need Today

Let's talk about ten Visual Studio Code extensions that every developer, regardless of language or platform, can benefit from using today.

Navigate faster in VS Code with Footsteps

Footsteps highlights recently edited lines in Visual Studio Code and gradually fades older changes, making it easier to retrace work across files.

Lint Markdown in VS Code

MarkdownLint provides immediate formatting diagnostics, repository-level rules, IntelliSense-backed configuration, and automatic fixes in Visual Studio Code.

Screenshot your Code in VS Code

Value types and reference types differ in how they use the stack and heap in .NET.

Manage GitHub Pull Requests & Issues with VS Code

GitHub Pull Requests and Issues brings reviews, queries, local PR checkout, issue management, and TODO-to-issue workflows into Visual Studio Code.

Keep Track of VS Code Windows with Peacock

Entity Framework Core's `AsNoTracking` can accelerate read-only queries by avoiding the overhead of change tracking.

Write Code in Containers with VS Code and Remote Containers

Visual Studio Code's Remote Containers extension creates consistent, disposable development environments that can package SDKs, CLIs, extensions, ports, and setup commands with a project.

Work with Others Using Live Share in VS Code

Visual Studio Live Share supports remote pair programming, reviews, shared debugging, chat, and terminals without requiring collaborators to clone or configure the project.

Format Your Code in VS Code with Prettier

The Prettier extension integrates opinionated formatting into Visual Studio Code while respecting project configuration, local versions, and plugins.

What is GitHub Gist? (Explained)

GitHub Gists provide lightweight version-controlled storage for snippets, documents, data, multiple related files, embedded code, and simple web pages.

Manage GitHub Gists in VS Code

The Gist extension manages GitHub Gists inside Visual Studio Code, supporting authentication, creation, insertion into documents, and default privacy settings.

Testing APIs with REST Client in VS Code

The OpenAI .NET SDK 2.0 provides specialized clients for streaming chat, DALL-E image generation, and Whisper audio transcription.

Azure File Shares as Container Volume Mounts

Azure File Storage can provide persistent volume mounts for containerized apps running in Azure App Service through path mappings and Docker Compose.

Bracket Pair Colorizer 2 - VS Code Extension Highlight

Bracket Pair Colorizer 2 distinguishes nested brackets and parentheses with colors, highlights, and scope lines that can be extensively customized.

Choosing Between Blazor Server or WebAssembly

Building for the web using a language you're already comfortable with? Sounds like a great idea as long as it's easy to use and performs well for clients.

Building my Ultimate Rustic Developers Desk

I've always wanted to build a desk that fits me. So welcome to my journey to build my ultimate developer desk.

Live-Coding to Learn, Share and Encourage

A reflection on one year of coding live on Twitch to learn new technologies, share what I know, and encourage others to grow personally & professionally.

Using Apollo to Query GraphQL from Node.js

It's a common scenario—you built a quick prototype, it worked great, and now management wants it live yesterday. GraphQL can help get it out the door.

I See What You're Saying: Sentiment Analysis With OpenTok and Azure Face API

Building a multi-party video conference that allows us to analyze the sentiment of each participant based on their facial expression.

Using AutoMapper with ASP.NET Core 3

AutoMappers usage via dependency injection changed in ASP.NET Core 3. This post shows how to use the new implementation.

Adding HATEOAS to an ASP.NET Core API

RESTful APIs provide a great way to make our APIs easier for users to consume. How can we make discovering endpoints and capabilities easier?

Using Azure File Storage as Container Volume Mounts in App Services

How to mount Azure File Storage as a persistent volume in your multi-container App Services.

Environment Variables in Azure Functions with Key Vault

Using environment variables from Azure Key Vault is a little different for Functions than Web Applications. Here's how to get it working.

Using SQL Server in Docker containers for basic tasks

Don't want to install SQL instances on your personal or work machine? No problem, because you no longer need to. Let's learn how to spin up a Docker container and access it with SQL Management Studio.

Using a Code of Conduct and Contributing Guidelines in Public Repositories

Want people to contribute to your repositories? Then you need to make sure they know they're welcome and provide them with a clear path to get started.

Adding command aliases to Powershell

How much time could you save by shortening common commands and parameters using PowerShell aliases? The answer is a lot.

Current Twitch live-coding stream setup

I've started working a lot more at trying to get my setup just right so I could live code some personal projects and hopefully help others learn new technologies.

Communication between containers using docker compose in Windows

In production, our application on a Pi communicates with a Restful API that lives at our clients main office. However, while debugging we need to run them side-by-side. So, docker-compose to the rescue (I think.)

Setting up Raspberry Pi for use in kiosk mode with Chromium

Recently one of our clients approached us to develop an application that would run on a Raspberry Pi to use in kiosk's throughout their facilities. We ended up writing a web app in Angular that they would run via Chromium.

Automating release notes with GitHub, AppVeyor and Octopus Deploy

With multiple clients, projects, deadlines, release schedules running at once, it's hard to keep up with what features are being released in a build.

Girls Who Code

These days, the topic of women in technology is hot. As a dad of two daughters, I often think about what their futures hold. One thing I know, they belong here as much as any man.