Ardalis.com on Ardalis (Steve Smith)

Claude Throttling and the Cloud

Tue, 07 Apr 2026 00:00:00 +0000

One of the foundational promises of cloud computing is elastic, near-infinite scalability. You pay for what you use, and when demand spikes, the cloud scales with you. It was supposed to be the end of capacity planning, the death of “we need to buy more servers” conversations. So why is Anthropic—one of the best-funded AI companies in the world, running on the infrastructure of Amazon and Google—throttling its users during peak hours?

Own What Makes You You

Mon, 06 Apr 2026 00:00:00 +0000

If you want to stand out, you need to have your own identity. This is true whether you’re talking about you, the person, individually, or your business. You can’t really have your own distinct identity if everything about you is just vanilla, off-the-shelf stuff that anyone else could easily do if they chose to do so. I’m mainly focusing on businesses and their branding and positioning here, but you’ll see parallels that apply to personal brands as well.

.NET Conf Most Popular Sessions Tool

Wed, 01 Apr 2026 16:47:18 -0400

DotNetConf (.NET Conf) is a long-running virtual conference hosted each November with the release of a new version of .NET. Its sessions are published to YouTube each year. What have been the top sessions each year? I wrote a tool to pull the stats year by year (since 2021) to see.

Also, why do I keep giving (updated) versions of the same session, Clean Architecture, each year (like last November as covered by Jeremy Sinclair)? There are some who have found it a bit… repetitive (though I do mix it up year to year):

AI Benefits - But at What Cost?

Thu, 19 Mar 2026 16:17:07 -0400

In 2026 we can all agree that AI and agentic development are certainly exciting topics which many see yielding great productivity gains. But as the investor-subsidized pricing of these services gives way to realistic and profitable business models, where will the real costs land?

As many businesses downsize staff or pause hiring to see how these new models and tools actually perform in the real world, the trillion dollar question is:

Use Asciinema and Powersession on Windows

Thu, 19 Mar 2026 11:31:56 -0400

Introduction

I recently became aware of Asciinema when I saw that the Aspire docs are using it to document installing their CLI. As someone who creates a lot of content (or used to, anyway) and docs, this seems like a really useful tool! But it doesn’t “just work” on Windows, so I figured I’d document how to get it working on Windows for future me.

Asciinema Itself

There are basically two parts to Asciinema:

Llms Need Mark as Answer

Fri, 13 Feb 2026 10:20:47 -0500

Introduction

Today’s LLMs have already ingested basically all of the publicly available information they can to build their models. In order to improve further, they’re going to need to seek out additional sources of information. One obvious such source is the countless interactions they have with their users, and while privacy concerns are certainly relevant here, for the purposes of this article I want to focus on another issue: quality signals. How will these LLMs know whether a given exchange led to a solution (defined however the user would define it)? Without this knowledge, there’s no way for LLMs to give more weight to answers that ultimately were fruitful over answers that were useless but the user gave up and ended the session.

2025 Year in Review

Mon, 09 Feb 2026 08:34:11 -0500

Better late than never, as I’m writing this in early February 2026…

First, here are a few links to past years in review:

Now on to the various categories…

Why a Free Market Fire Department System Beats the Archaic Public Model

Fri, 09 Jan 2026 09:00:00 -0500

By a devoted advocate for individual choice

Introduction: Fire Protection, Reimagined 🚒

In a nation that prizes personal responsibility, it’s time to ask whether a single, taxpayer-funded fire department model still serves us best. A market of competing fire protection providers would let every household choose the coverage, response times, and perks that match their unique risk profile and budget. What’s more, it would allow individuals and households to prioritize how they want to spend their money, rather than leaving it up to big government and its known inefficiencies. Let the invisible hand of the market sort out which fire departments offer the best value for their rates, and which properties people find worth protecting with fire extinguishing services.

Single File Test Suites in Dotnet Csharp

Tue, 02 Dec 2025 16:16:18 -0500

This article is part of the 2025 Advent of C# Code Calendar, which publishes 2 C# articles every day in December leading up to 25 December.

NOTE: Originally targeted xUnit v2; now updated to xUnit.v3.

Introduction

One of my favorite new features in .NET 10 is C# file-based apps (or file-based C# programs if you prefer). With this feature, we can create individual .cs files and then run them using dotnet run <file.cs>. On Unix OSes you can go even further and mark the files as executable and include a shebang (#!) directive as the first line to tell the OS what to run it with and then you can run the files directly without even calling dotnet run.

Use cd - in Powershell 7 to Return to Previous Directory

Tue, 02 Dec 2025 11:16:30 -0500

Introduction

A command that many shells have had forever and that PowerShell has had for a long time as well is ‘cd -’ which means “change directory to previous folder”. This means you could do something like this:

> cd c:\dev
c:\dev
> cd c:\temp
c:\temp
> cd -
c:\dev

This is quite handy in many situations. In particular, since I’ve modified my PowerShell Profile to NOT start in my users folder but instead to start in my c:\dev folder (from which I can easily get to any repo I may be working from), I very often find myself using cd - whenever I create a new terminal in the folder I want to be in such as when using VS Code.

How to Update .NET on Wsl or Ubuntu

Wed, 19 Nov 2025 09:37:56 -0500

Ever year or so, a new version of .NET ships, and I need to upgrade the .NET SDK version on my machines. Not just the Windows machines, but also the WSL Ubuntu bits that live on those same machines.

First, determine what version of dotnet you already have using this:

1
2

dotnet --version
> 10.0.100-rc.1.25451.107

Yep, I need to update that. But how? Surely there must be a simple way to do it using just the command line. If you just do a quick search for how to do this, you’ll find instructions like this:

Ardalis Fall 2025 Speaking Tour Review

Fri, 14 Nov 2025 00:00:00 +0000

The last two years, I’ve had the good fortune to be invited to the Netherlands for TechoramaNL, and I’ve been able to bring my wife and business partner Michelle and our twin boys along as well. It’s been fun and educational for all of us, so this year when there were opportunities to submit talks in Portugal that butted up against TechoramaNL on the calendar, we decided to go ahead and submit. Amazingly, my submissions were accepted to not one but two different Portugal events, and so the trip went from one week to three. And along the way, I also said yes to my good friends at DevIntersection who wanted me to present there (the week before we were to leave for Europe, in Florida). And when JetBrains asked if I could present at their DotNetDays event literally on the same day I was presenting in Florida for DevIntersection, I said “Why not?” and added that to the schedule as well.

The Ardalis Cli

Tue, 11 Nov 2025 17:03:42 -0500

Back in the .NET 10 Preview days, Andrew Lock wrote about running one-off dotnet tools with DNX. I decided to riff on that to create what was initially just a business card, but then I enhanced it with some additional functionality, making a full-blown Ardalis CLI tool, which mostly just gets you access to content from me in your terminal.

You can find the source for my ardalis command line interface as well as its listing on NuGet. You should review these before running commands on your machine to ensure the tool isn’t doing anything nefarious.

Use TimeSpan Or Specify Units In Duration Properties And Parameters

Thu, 06 Nov 2025 09:51:30 -0500

A special case of primitive obsession is the use of an int value to describe a span of time. You see this all the time in various APIs, and it’s a frequent source of bugs and confusion. Developers are forced to either guess or try to find the documentation that describes what units int timeout or int delay actually uses.

Having a retry delay of 1 millisecond instead of 1 second, for example, is a huge difference - that’s 1000x more load on your system! But so is having a timeout of 1000 seconds (nearly 17 minutes!) instead of 1000 milliseconds (1 second). Either way, it’s three orders of magnitude away from the expected and intended behavior, which can lead to production incidents and difficult-to-diagnose bugs.

Ardalis Fall 2025 Speaking Tour

Sat, 27 Sep 2025 00:00:00 +0000

I may have gone a bit overboard this year… I’ve scheduled myself for 5 developer conferences in 4 weeks during October 2025! If you’re interested in learning about Clean Architecture, SOLID principles, microservices, modular monoliths, and other software architecture best practices, here’s where you can find me speaking across three countries and online.

Whether you’re a.NET developer, software architect, or just passionate about writing better code, these sessions will cover practical techniques you can apply immediately to improve your applications.

How to Combine MP4 Files on Windows Using FFmpeg

Thu, 24 Jul 2025 00:00:00 +0000

Merging multiple MP4 files into one can be useful when working with ripped DVDs, split movie parts, or recorded gameplay. On Windows, the simplest and most flexible tool for this task is FFmpeg — a powerful open-source utility that can join, convert, and manipulate video files.

This guide walks you through installing FFmpeg, preparing your files, and performing a lossless merge (no quality loss).

1. Install FFmpeg with Winget

Windows 10/11 includes the winget package manager, which makes installing FFmpeg simple:

How to Install Nerd Fonts and Icons in PowerShell 7 on Windows 11

Tue, 22 Jul 2025 00:00:00 +0000

If you’re setting up a polished dev terminal experience with icons, custom fonts, and PowerShell 7 on Windows 11, here’s a step-by-step guide that actually works. We’ll install a Nerd Font, configure PowerShell 7 properly, and enable terminal icons in directory listings — all without pulling your hair out. If video is more your thing, check out my YouTube video on prettying up your terminal with terminal icons.

🚫 What Not to Do

Before we dive in, here are a few things that didn’t work and might trip you up:

GenAI is the new Offshoring

Fri, 06 Jun 2025 00:00:00 +0000

I originally posted this on LinkedIn / BlueSky but I’ve found that it’s nearly impossible to find (searching for “AI is the new offshoring” or"genAI is the new offshoring" both fail to find it) so I’m cross-posting here and adding a bit more context.

Twenty years ago, the internet and improved communications led to a massive push in US corporate enterprises to outsource IT and dev efforts to far less expensive offshore outfits staffed by eager but often inexperienced workers making pennies on the dollar compared to their US counterparts. Layoffs occurred in many orgs and whole departments moved offshore in some cases, and while there were success stories and many companies continue to leverage offshore talent, many (most in my experience but that’s probably biased by the ones coming to my company for help) later regretted the decision.

Managing GenAI Coding Risk Like an Investment

Thu, 05 Jun 2025 00:00:00 +0000

Generative AI tools have greatly improved in their ability to generate large amounts of code, quickly, to support software development tasks. They’re fast, confident, and in some cases even creative. But they’re also fallible, occasionally destructive, and always somewhat unpredictable.

If you’ve ever used GenAI to bang out a prototype in hours instead of days, you’ve seen the upside. If you’ve watched it delete critical files, misconfigure infrastructure, or hallucinate complex nonsense that passes code review but fails in production, you’ve felt the downside.

Ardalis Specification v9 Released

Thu, 13 Mar 2025 00:00:00 +0000

A new major version of the Ardalis Specification library has been released. This library is used to create and compose specifications for querying data from repositories. It’s a key part of the Ardalis Clean Architecture libraries and is used in many applications to help simplify querying logic and make it more testable. If your application suffers from LINQ pollution, with query logic spread through every part of it, this library may help.

2024 Year In Review

Wed, 26 Feb 2025 00:00:00 +0000

Better late than never, as I’m writing this in late February 2025…

First, here’s a few links to past years in review:

Now on to the various categories…

Blogging ✍️

Blogging continues its slide into obscurity. In 2024 I had just 18 new articles, which is down from 20 in 2023. I think part of the reason for this is that I’ve been focusing more on video content. I also tend to get more immediate feedback on video content, even though it’s more effort to create, and there are vanity metrics like YouTube subscribers which offer more of a dopamine hit than page views on a blog. In 2023 I had 20 articles so this is a slight decrease.

When QA Keeps Finding Bugs

Wed, 12 Feb 2025 00:00:00 +0000

A developer manager recently reached out with a concern: their new QA team member was finding too many bugs, leading to frustration among developers. Overall velocity of the dev team (in terms of features being shipped) was rapidly falling. The question was, how can they reduce the number of issues being kicked back from QA without discouraging the testers from doing their job well?

QA Isn’t the Problem

First and foremost, if QA is finding bugs, that means they’re doing their job well. The goal shouldn’t be to stop QA from finding bugs. The goal should be to reduce the number of bugs that reach QA in the first place. The real issue likely lies upstream in the development process.

Avoid Using C# Events in ASP.NET Core Applications

Sun, 15 Dec 2024 00:00:00 +0000

This post is part of the C# Advent Calendar 2024 - check out all of the C# articles from this year!

C# events are a powerful feature of the language, providing a simple mechanism for building publish-subscribe communication patterns. However, when used in ASP.NET Core applications, events can lead to subtle, hard-to-diagnose issues that can harm the reliability and scalability of your application. In this article, I’ll highlight the main issues with using C# events in ASP.NET Core and share better alternatives.

Interfaces Describe What - Implementations Describe How

Mon, 23 Sep 2024 00:00:00 +0000

When working with software development, especially in object-oriented or component-based systems, understanding the distinction between interfaces and implementations is crucial. The two terms often come up in conversations about architecture, design patterns, and coding best practices, but what do they really mean? In this post, we’ll break down the difference and why it matters.

YouTube

What is an Interface?

An interface in software development defines what a component or class can do. Think of it like a contract or a blueprint. It specifies the methods or behaviors that must be available without dictating how they should be carried out. (While default interface methods are a special case in modern languages like C#, they don’t change the fundamental role of interfaces as abstractions).

You Should Blog

Mon, 26 Aug 2024 00:00:00 +0000

As a software developer, you might spend most of your time immersed in code, solving problems, and building innovative solutions. But have you ever considered starting a blog? If you haven’t, let me give you some compelling reasons why you should. This is advice I frequently give to members of my developer group coaching program at devBetter.com.

Watch the Video

1. Sharpen Your Skills

One of the best ways to deepen your understanding of any topic is to teach it to others.

From Microservices to Modular Monoliths

Wed, 10 Jul 2024 00:00:00 +0000

What do you do when you find yourself in microservice hell? How do you keep the gains you (hopefully) made in breaking up your legacy ball of mud, without having to constantly contend with a massively distributed system? Migrate to a modular monolith.

Microservices

Microservices have been all the rage for the past several years. They offer a way to break up large, monolithic applications into smaller, more manageable pieces. This can make it easier to scale, deploy, and maintain your application. However, microservices come with their own set of challenges. They can be difficult to manage, especially as the number of services grows. They can also introduce latency and complexity into your system.

Modeling Navigation Properties Between Aggregates or Modules

Wed, 19 Jun 2024 00:00:00 +0000

One of the key challenges in developing a modular monolith is managing the communication between different modules, especially when it comes to handling data dependencies across module boundaries. Recently, I received an interesting question from one of the students of my modular monoliths course, which I thought others might appreciate.

Student Query

Modular Monolith course question (EFCore Navigation Properties)

Message: Hi Steve,

Just got done with your modular monoliths course and loved it. I have a question about how navigation properties work inside each module using EFCore.

Comparing Unit Testable Code with Maintainable Code

Wed, 12 Jun 2024 00:00:00 +0000

Writing maintainable code should be a goal in most software engineering projects. Although definitions and especially hard measurements of what maintainable means with regard to software may vary, it can be useful to compare maintainable code to the much more easily verified unit testability of that code.

Introduction

When discussing software quality, two important concepts often arise: unit testable code and maintainable code. While these concepts are distinct, they share many characteristics. This article explores the overlap between unit testable code and maintainable code in C#, highlighting how striving for one often leads to achieving the other.

Effectively Sharing Resources Between Modules in a Modular Monolith

Fri, 24 May 2024 00:00:00 +0000

Student Query

Hi Steve, I have another question for you after finishing the deep dive course. Let’s say that now I have multiple modules, each of them with IDs of other entities in their domain. I don’t want to serve data from module A in module B, so I just return the ID to the consumer and let them call module A with it. The problem is that following this pattern, the consumer could be forced to do a lot of calls just to jump between our domains. Could it make sense to implement an API Gateway? How could it be implemented in a modular monolith environment?

Clean Architecture Sucks

Thu, 23 May 2024 00:00:00 +0000

The other day I was participating in a conversation online in an architecture forum. One of the participants was complaining about the mess they were cleaning up from a team they’d joined. The team had, ostensibly, been following Clean Architecture, but the code they had produced was a mess. Their conclusion:

Clean Architecture sucks.

They led with:

Clean Architecture and its obsession with grouping things into technical concerns can quickly turn into a giant ball of mud as the ability to properly develop and maintain code in such a project style is directly dependent on the technical expertise and skill of each of the developers on the project.

Navigating the Edges of Technology in Software Development: Bleeding, Leading, Dull, and Rusting

Fri, 19 Apr 2024 00:00:00 +0000

In the fast-evolving world of software development, keeping pace with technology trends is both a necessity and a challenge. Companies and developers often find themselves making critical decisions about whether to adopt new technologies early (bleeding edge), wait until they mature (leading edge or cutting edge), or continue using older, more established technologies (what I’ll call the dull edge and rusting edge). Understanding the distinctions and implications of these choices can significantly impact both the development process and business outcomes.

Stop Debugging and Start Running in Visual Studio

Thu, 18 Apr 2024 00:00:00 +0000

NOTE: Watch the video above to see actual timings of starting with and without debugging. Vote for this feature request to make Run vs Debug more obvious in Visual Studio.. Thanks!

I work with a lot of different.NET developers as a trainer, architect, and consultant with NimblePros. One thing that I’m frequently pointing out to them is the difference in startup speed for their applications when launching from Visual Studio. Many, I would even say most,.NET developers have developed"muscle memory" of hitting F5 (or clicking the"Play" button) in order to launch their applications. And why not? This was the only toolbar button available for many years, and F5 is a simple enough key to remember, and is literally called"Start".

5 Rules for DTOs

Sat, 06 Apr 2024 00:00:00 +0000

If you don’t like reading, here’s my YouTube video with samples that covers why these 5 rules will help you write better DTOs:

What’s a DTO?

A DTO is a Data Transfer Object. Its job is to transfer data, and it can be used both to send data and to receive it. Often, data transferred will use different types (possibly even different programming languages and technology stacks) on each end of the transfer. The only thing you can count on transferring is the data - nothing else. Which leads to the first rule for DTOs.

An Active Local NuGet Server

Thu, 22 Feb 2024 00:00:00 +0000

As I’m writing this the Internet is out. When that happens, it makes it very difficult to work on development projects that have NuGet dependencies, especially when it comes to adding anything new to a project. A local NuGet server that kept up-to-date with my commonly used packages would be helpful right now.

NuGet already has a local NuGet cache. You’ll find it in your user profile folder. Here’s mine:

Introducing Modular Monoliths: The Goldilocks Architecture

Wed, 21 Feb 2024 00:00:00 +0000

In the world of software architecture, finding the perfect balance between complexity and simplicity can often feel like an elusive quest. Developers and architects are constantly navigating the spectrum between traditional monoliths, known for their simplicity but criticized for their scalability and maintainability issues, and microservices, praised for their scalability and flexibility but often complicated by their operational and developmental overhead. Enter the “Goldilocks” architecture: the Modular Monolith. This architecture promises to strike a balance that is"just right" for many applications, offering the simplicity of a monolith with the flexibility of microservices.

Hello, MongoDB - Getting Started with Mongo and dotnet 8

Thu, 15 Feb 2024 00:00:00 +0000

Integrating.NET Core with MongoDB in a Dockerized Environment

Hello, fellow developers! Whether you’re building a new project or integrating into an existing one, this guide is your starting point for a “hello world” level application in the.NET 8 plus MongoDB stack. Let’s get to it!

Prerequisites

Before we begin, ensure you have the following installed on your machine:

Docker -.NET SDK (I’m using dotnet 8)

Step 1: Dockerize MongoDB

First off, let’s get MongoDB up and running inside a Docker container. Just run this command (assuming you have docker installed and running)

Hello, Redis - Getting Started with Redis and dotnet 8

Sun, 11 Feb 2024 00:00:00 +0000

Integrating Redis Caching in.NET 8 Applications

Redis is an open-source, in-memory data structure store, used as a database, cache, and message broker. It’s known for its speed and flexibility, making it an excellent choice for caching in modern applications. In this article, we’ll explore how to use Redis for caching in a.NET 8 application, covering both setting up Redis using Docker on a Windows development machine and integrating it into your.NET application.

Solved! Visual Studio.http File Not Sending Authorization Header

Thu, 01 Feb 2024 00:00:00 +0000

I ran into a weird problem with how Visual Studio was sending API requests. I was trying to use a bearer token, and it worked fine in Swagger, but from an.http file the Authorization header was simply being ignored, resulting in a 401 Unauthorized.

The Problem

I’d built a simple ASP.NET Core webapi project using the default template. I was using the built-in support for.http files to execute requests against the project. I could register and log in successfully, but when it came time to hit an endpoint that required authentication, it would always result in a 401. The same token added to the same Authorization header worked just fine using Swagger/Swashbuckle in the browser.

Log Request Headers Middleware for ASP.NET Core

Wed, 31 Jan 2024 00:00:00 +0000

Recently I ran into a weird problem with how Visual Studio was sending API requests and I really wanted to see exactly what headers were being sent to my ASP.NET Core app. So I wrote this simple bit of middleware to do the job.

What is Middleware

If you’re not familiar with middleware, it’s a set of functions (“request delegates”) that are executed in a particular order as part of every request that is made to an ASP.NET Core application. It’s an example of the Chain of Responsibility design pattern. I talk about useful ways you can use the Chain of Responsibility pattern in this video.

2023 Year in Review

Tue, 23 Jan 2024 00:00:00 +0000

Now that CodeMash is over (I had a workshop and 2 talks, including a new one), I can focus enough to write up this review post. For those who care to see how things have progressed over the years, a brief history of similar such posts is listed below. If you want to write your own such article, I have a checklist linked at the bottom of the list.

Blogging

Last year I only added 20 articles to my blog (about 6 fewer than in 2022). That works out to 1-2 per month, though in reality there were a few months where I blogged a lot, and bunch where I… didn’t.

Scaling Your Software Team: Development vs. Hiring

Wed, 20 Dec 2023 00:00:00 +0000

Scaling up and scaling out, originally application terms, offer a fresh perspective on team development. In team contexts, scaling up involves enhancing existing members’ skills, offering depth and cost efficiency, whereas scaling out adds new members for diverse skills and increased capacity. The choice hinges on project needs and long-term goals, each strategy presenting distinct benefits and challenges.

Introduction

In the ever-evolving landscape of software development, team scalability is a critical factor for success. Two primary approaches dominate the scene: scaling up by developing individual team members, and scaling out through hiring additional team members. This article delves into the nuances of both strategies, highlighting their benefits, challenges, and suitability for different project demands.

How to Embed a YouTube Video in GitHub ReadMe Markdown

Thu, 23 Nov 2023 06:04:10 -0500

I keep wanting to do this and forgetting how, so I’m writing it down. Here’s how to embed a YouTube video in a GitHub ReadMe markdown file.

Thanks for this Stack Overflow answer for the tip.

Step 1: Get the YouTube Video ID

The YouTube video ID is the part of the URL after the v=. For example, in the URL [https://www.youtube.com/watch?v=dQw4w9WgXcQ](https://www.youtube.com/watch?v=dQw4w9WgXcQ), the video ID is dQw4w9WgXcQ. You’ll need that for the next step.

New Course - Refactoring to SOLID C# Code

Fri, 17 Nov 2023 06:04:10 -0500

I’m thrilled to announce the release of my latest Pluralsight course, Refactoring to SOLID C# Code. This course is designed for software developers, architects, and anyone interested in enhancing their coding skills, especially in the C# programming language.

Description

Legacy code is often difficult to maintain and extend. In this course, Refactoring to SOLID C# Code, you’ll learn to apply refactoring techniques guided by SOLID principles. First, you’ll explore a small application that wasn’t written to follow SOLID. Next, you’ll discover ways to improve the design using specific techniques. Finally, you’ll learn how to assess and test the resulting code. When you finish this course, you’ll have the skills and knowledge of refactoring and OO design principles needed to improve and maintain legacy.NET applications.

Understanding Migrations, Snapshots, and Synchronization in Entity Framework Core

Fri, 27 Oct 2023 04:34:00 -0400

Entity Framework Core: Understanding Migrations, Snapshots, and Synchronization

Entity Framework Core (EF Core) is a powerful tool for managing database schema migrations and synchronization in.NET projects. This article aims to explore the core components that EF Core uses to maintain this sync: migration files, model snapshots, and a special database table. We’ll also clarify the roles of .designer.cs and ModelSnapshot.cs files in migrations.

Models

One point of confusion I see a lot when discussing EF Core migrations is with “the model.” The model or"the current model" being referenced varies quite a bit with context. In one scenario, the"current model" is your C# code in its current most-recently-saved state. If you just added a property called Name to an entity class, you’re thinking that is your current model. But another version of the model is in a snapshot file, and that one is only updated when you create a migration. And another version of the model is in the/a database. And that one is only updated when you do a database update or deployment. So, keep in mind as you continue reading that there are always several different versions of your model that are in various states, and ultimately should be synchronized by the migration process.

Process Bloat: The Silent Killer of Developer Productivity

Tue, 24 Oct 2023 04:34:00 -0400

Introduction

In the exhilarating infancy stages of a software development project, teams are marked by agility, prompt decision-making, and a zest for delivering valuable features. Yet, as projects gain complexity and scale, many fall prey to a lesser-known but insidious anti-pattern: Process Bloat. This bureaucratic monster not only hampers innovation but becomes a silent killer of developer productivity.

Why Does Process Bloat Occur?

Initially, the integration of processes into a project aims to streamline operations, uphold quality standards, and minimize risks. However, these well-meant structures can evolve into debilitating Process Bloat. The factors leading to this are multiple:

Principles of Lean Software Development

Fri, 20 Oct 2023 00:00:00 +0000

Lean Software Development is an agile project management and product development framework that originated from Lean manufacturing principles. It focuses on delivering value to the customer by optimizing resources, workflows, and processes. Below is a breakdown of its core principles:

1. Eliminate Waste

The first principle of Lean Software Development is to eliminate waste, a concept borrowed from the Lean manufacturing world where it is known as “muda.” In software development, waste could be anything from writing unnecessary code to excessive meetings that don’t add value. The goal is to streamline the workflow by identifying and removing anything that doesn’t contribute to the end product or the customer’s needs.

Introduction to MassTransit: A Guide to Streamlined Messaging in C#

Thu, 28 Sep 2023 00:00:00 +0000

If you’re interested in building distributed, scalable, and robust applications in C#, you may have heard of MassTransit. This open-source messaging framework simplifies working with message brokers like RabbitMQ and Azure Service Bus, allowing you to focus more on business logic and less on infrastructure concerns.

What Is MassTransit?

MassTransit is a free, open-source distributed application framework for.NET. It’s a service bus for sending messages between different parts of your application, or even across different applications. With MassTransit, you can implement various messaging patterns such as publish/subscribe, request/response, and more, using a consistent and easy-to-understand API.

Trunk-Based Development vs. Long-Lived Feature Branches: Which One is Right for Your Software Team?

Thu, 14 Sep 2023 00:00:00 +0000

When it comes to effective software development strategies, two distinct approaches often lock horns: Trunk-Based Development and Long-Lived Feature Branches. Each has its unique merits and challenges, and knowing which one to adopt can significantly influence your project’s success. In this post, we’ll delve deep into the pros and cons of both approaches and even show you a C# example demonstrating how to safely integrate work-in-progress code into the mainline.

Building a Resilient Email Sending Method in.NET with SmtpClient, Retry Support, and the Outbox Pattern

Fri, 08 Sep 2023 00:00:00 +0000

Introduction

In the world of software applications, email sending functionalities are indispensable. From password resets to notifications, you can’t afford to let a hiccup in the network or an SMTP server issue derail you. So how do you ensure reliability in email operations? In this post, we’ll dive into creating a resilient email sending method in.NET using the SmtpClient class and incorporating retry logic. Plus, we’ll go a step further by discussing how to use the Outbox pattern to preserve email content in case of failures.

ASP.NET Core Clean Architecture Template v8 Released

Mon, 28 Aug 2023 00:00:00 +0000

I’ve just published a new version of my Clean Architecture Solution Template for ASP.NET Core applications. This is version 8 of the template, though to be clear it is still targeting the current version of.NET (.NET 7). I’ll create another update once.NET 8 ships in November 2023.

What’s New

This version introduces some pretty major changes, which I’ll highlight here. The biggest ones have to do with:

Streamlining the template so it has less code
Focusing on APIs (not razor pages or views)
Introducing a new UseCases project
Removing the SharedKernel project.

I’ve also added a separate sample application so users can see examples of how they might want to organize their code (without that necessarily being in the template’s output).