All Blog Posts


Introduction to Cancellation in .NET
As software development evolves and adopts asynchronous paradigms, the need for cancellation support in applications has become more prevalent. In this post, we will learn about the core concepts in regards to cancellation in .NET code. This post will provide a solid foundation for continued learning on the concept of cancellation. Let's dive in!
Wednesday, August 10, 2022
#dev
#introduction
#dotnet
#csharp

Announcing the Ability to Like Posts
Up to this point, there has been no way to interact with the posts that I publish on this blog. The most recent release changes that. Readers can now like posts after reading them. In this post, we'll be discussing the feature, the high-level implementation, and how it could evolve in the future. Let's dive in!
Sunday, July 31, 2022
#introduction
#dev
#learning

My Software Development Podcast Lineup (2022)
Over the years podcasts have become integral to my daily routine. In this post, I'll provide an update on my current (2022) podcast lineup along with some details about why I find each podcast interesting or useful. Let's dive in!
Saturday, July 23, 2022
#dev
#learning
#growth

Effective Data Fetching with React and SWR
Retrieving data is typically a straightforward task. Retrieving data in the most efficient manner can be more complex. This post will dive into how SWR can simplify the process of fetching data while also solving potentially complex problems like performance, caching, data store mutation, and more. Let's dive in!
Monday, July 11, 2022
#web
#dev
#react

Reflections on Time Management
The ability to effectively manage our time as software engineers can feel like a superpower. In this post, I am going to share my current time management strategy and go into a bit of depth on how I think it has benefited me throughout my career. My hope is to provide some insight into ideas you can try to improve your time management or to reinforce strategies that you are already implementing. Let's dive in!
Thursday, June 30, 2022
#dev
#growth
#learning

Representing Logic Gates as Boolean Functions
Boolean functions and logic gates are at the heart of everything we do as software engineers. While it may not always be obvious or apparent, boolean expressions or the result of combining them form the building blocks for much of what we see and use today in technology. In this post, we'll be looking at how we can go from elementary logic gate definitions to boolean functions based on a few principles.
Wednesday, June 22, 2022
#dev
#learning

Merging Objects in TypeScript (and JavaScript)
Merging two objects seems like it should be a trivial problem to solve at face value. Unfortunately, as we'll see in this post, the problem isn't as straightforward as some may think. In this post, we'll be looking at the options available for merging objects in TypeScript (the options discussed will work just as well with JavaScript).
Saturday, June 11, 2022
#javascript
#typescript
#learning

Scaffolding XML Comments with Extended Properties in EF Core 6
SQL Server has a feature called extended properties which can be used to add metadata to databases, schemas, tables, and columns. In this post, we are going to see how to use the extended property metadata to automatically generate corresponding XML comments on our scaffolded entities in EF Core 6.
Saturday, May 28, 2022
#dev
#dotnet
#efcore
#sql
#csharp

Creating a Daily Init Script
In this post, we're going to explore the concept of a daily init script. The goal of this script is to open all of the necessary applications and tools that we use on a daily basis. This allows us to be productive by default instead of having to make separate decisions about what tools we need to accomplish a given task. I've been using some form of an init script for a few years now and I hope to share why I find it so useful.
Friday, May 20, 2022
#dev
#tools

Working with Related Data in EF Core 6
I think that one of the most convenient features of ORMs like Entity Framework is the ability to reference related data via properties on an object or entity. In this post, we'll be looking at a few different ways to load related data in EF Core 6.
Wednesday, May 11, 2022
#csharp
#dotnet
#efcore
#database

Writing C# in Neovim
In this post, we'll be looking at how to set up our development environment to effectively write C# in Neovim. We'll also be looking a little more in-depth specifically at the tooling in Neovim that makes this all possible.
Thursday, April 28, 2022
#learning
#dotnet
#csharp
#neovim

Function Overloading in TypeScript
While learning about TypeScript I came across function overloading. The way it works in TypeScript seemed different than what I was used to in languages like C# and Java. In this post, we'll be learning about overloading functions in TypeScript and potential alternatives that are better suited to certain situations.
Tuesday, April 19, 2022
#dev
#learning
#typescript

When to Use React.useRef
The introduction of hooks a couple of years ago (version 16.8) introduced a massive paradigm shift in the world of React. Hooks allow developers to "hook" into state and component lifecycles without the use of classes! In this post, we're going to look at the useRef hook, how it works, and why we should use it.
Sunday, April 10, 2022
#web
#dev
#javascript
#typescript
#react

Learning TypeScript: Utility Types
One of the things that I've enjoyed the most while learning TypeScript is the language's flexibility when working with types. I think that Utility Types are great examples of that flexibility. In this post, we'll be looking at the main kinds of utility types available and also how we can use them to improve our code.
Wednesday, March 30, 2022
#learning
#typescript
#dev

Learning TypeScript: Literal Types
In this post, we'll be looking at literal types, what they are, and how we can potentially use them in our code day to day. Coming from a language like C# where there isn't really an equivalent to literal types I find them to be quite interesting and I hope you will too. Let's dive in!
Saturday, March 19, 2022
#learning
#typescript
#dev

Reasons to Use C# Record Types
Prior to C# 9 classes were the defacto option for creating reference types in C#, but now we have records. In this post, we'll be going over a few details about C# records and also the benefits that I believe they can provide over using classes (in some scenarios).
Wednesday, March 9, 2022
#dev
#dotnet
#csharp

What is SQL Index Fragmentation?
SQL indexes are an important part of every database, but they don't come without requiring some regular maintenance. In this post, we'll be looking at SQL index fragmentation in the context of Microsoft's SQL Server and how it can affect our database performance.
Saturday, February 26, 2022
#dev
#database
#sql
#learning

Learning TypeScript: Conditional Types
Conditional Types in TypeScript may not be a language feature used day to day by most developers, but as I was reading the TypeScript Handbook I found the concept interesting and decided to dig a little deeper. In this post, we'll take a high-level look at the concept of conditional types and how they can be leveraged in our code.
Saturday, February 19, 2022
#dev
#learning
#typescript

Learning TypeScript: Narrowing Types
Often times the TypeScript compiler knows more about our own code than we do. However, there are occasions when that's not the case, which is where type narrowing comes in. In this post, we'll take a look at the different options available for narrowing types in our TypeScript code.
Thursday, February 10, 2022
#web
#learning
#typescript
#dev

Working With JSON in Postgres 14
Postgres has had native JSON support for almost 10 years (since version 9.2). In September 2021 Postgres 14 was released and it included some great features that improve our experience greatly when working with JSON data. In this post, we'll be diving into the new JSON features in Postgres 14 to see how we can leverage them in our day-to-day.
Thursday, January 27, 2022
#dev
#json
#postgres
#database
#sql

Learning T-SQL Window Functions
Being able to query and manipulate data effectively is a valuable skill for any software engineer to have in their toolbelt. In this post, we're going to take a look at Window Functions and the functionality they provide. Although this post is going to focus on using window functions with T-SQL, it's important to note that window functions are part of the ANSI SQL standard and are available in other SQL database implementations.
Wednesday, January 19, 2022
#dev
#database
#sql

Know Your Tools: Oh My Zsh and Git
As developers, we are exposed to many tools. How we learn and use those tools can make a big difference in our productivity and happiness. In this post, we'll be looking at the git plugin for Oh My Zsh and how it can be leveraged to increase our productivity using Git in the terminal.
Thursday, January 6, 2022
#dev
#learning
#git
#tools

What I've Learned in a Year of Blogging
In January 2021 I created this blog without any expectations of what would come of it. I had a plan but wasn't sure I'd be able to execute it. In this post, I'll take a moment to reflect and look back at this year going over what I've learned, what went well, and what didn't go so well, as well as take a look ahead at next year to see how I can improve.
Tuesday, December 28, 2021
#review
#learning
#growth

Learning When to Cut the Thread
As software engineers, we frequently tackle complex problems in code. The source of a problem's complexity may be from the problem itself, from the code's architecture, or from something else entirely. In this post, we're going to compare writing code to pulling on a loose thread from a piece of clothing. There comes a time when writing software that we need to know when to "cut the thread" or we'll risk the whole thing unraveling.
Tuesday, December 14, 2021
#dev
#learning
#growth

Working With Null in C#
As software developers, we are bound to encounter scenarios where our code behaves in unexpected ways. Some of those unexpected behaviors could be caused by null object references. In this post, we're going to take a look at the different language constructs that C# provides for working with null. My goal is to provide information that leads to more tidy code and fewer bugs.
Monday, November 29, 2021
#dev
#learning
#dotnet
#csharp

Formatting C# Code with EditorConfig
Code style and formatting can be polarizing, to say the least. One way to remove subjectivity about code style preferences within a codebase is to enforce specific rules. In this post we're going to talk about how using the EditorConfig file standard can help provide consistent styles throughout a codebase.
Monday, November 15, 2021
#dotnet
#csharp
#dev

Running SQL Server on Linux with Docker
Since its creation SQL Server has been synonymous with Microsoft and Windows, but this all changed with SQL Server 2016. SQL Server is no longer just a database for Windows and in this post, we'll be going over the steps to get Microsoft SQL Server running on Linux in a Docker container using Docker Compose.
Thursday, October 28, 2021
#sql
#database
#linux
#docker
#containers

Introduction to HTTP OPTIONS Method
If you've ever looked at the Network tab in the Browser Dev Tools, you may have noticed a lot of OPTIONS requests being sent to the server. Oftentimes these requests are not being made from our code, but made by the browser. In this post, we'll be covering the purpose that the HTTP OPTIONS method serves in our web applications.
Thursday, October 14, 2021
#dev
#web

Rebase Git Branches Interactively
Git's rebase functionality could be one of the most polarizing features of the ubiquitous version control system. Some have horror stories of rebasing branches, while others use it whenever possible. In this post, we'll be touching on the interactive rebase feature which can reduce a lot of the anxiety around rebasing Git branches.
Thursday, September 30, 2021
#dev
#git

How to Use C#'s Parallel.ForEach
There are certain operations performed in code that lend themselves to being executed in parallel. Some might even call these tasks "embarrassingly parallel". In this post we'll be going over how we can use C#'s Parallel.ForEach to iterate over collections in parallel.
Wednesday, September 15, 2021
#dev
#introduction
#dotnet
#parallel
#csharp

How To Uninstall tSQLt From SQL Server
If you've used the SQL unit testing framework tSQLt before you may have come across the need to uninstall it from a database. There are a couple of ways you could go about this, but we'll look at the quickest method.
Friday, August 27, 2021
#sql
#database
#dev

Parsing Image Metadata with C# and ImageSharp
Recently I've been using C# and ImageSharp to work with images in code. In this post we'll be taking a look at how we can read and write IPTC Metadata properties for a given image.
Sunday, August 15, 2021
#dev
#dotnet
#csharp

Scraping HTML with Selenium and C#
In this post, we'll be going over how we can use Selenium WebDriver and C# to scrape HTML from websites. I recently started working on a personal project that I plan to use for gathering English Premier League player statistics for my fantasy team. I had a fun time getting Selenium set up and working so I thought I'd share.
Wednesday, July 28, 2021
#web
#dev
#dotnet
#csharp
#selenium
#scraping

Introduction to SQL Indexes
For most of my career I've known the general purpose of an SQL (read S-Q-L) index, but I've never taken the time to dig a little deeper to understand more until recently. In this post we'll be taking a look at SQL indexes from a high level, as well as how they can be used effectively (and not so effectively) to impact the performance of SQL operations.
Sunday, July 18, 2021
#introduction
#sql
#database
#learning

How Podcasts Helped Me Grow as a Developer
Podcasts have become very popular over the years and you can almost guarantee that there is a podcast available for any of your personal interests. In this post, I'll describe how I believe podcasts have helped me grow as a developer. We'll also take a look at some of my favorite podcasts and discuss a little bit of what they're about and why I enjoy them so much.
Tuesday, June 22, 2021
#growth
#dev
#learning

Asynchronous C#: Below the Surface
In my last two posts, we've covered C#'s async programming model and also using async/await for asynchronous execution. In the final post of this series on async programming in C#, we're going to take a look behind the scenes at all the work the compiler does for us to make code execute asynchronously. Let's dive in!
Friday, June 4, 2021
#dev
#dotnet
#csharp

Using Async and Await in C#
Async and Await are important keywords in C#. In this post, we'll be looking into how we can use `async` and `await` to write asynchronous code in the same manner that we write synchronous code. For a higher-level look at asynchronous programming in C# check out my previous post where we discussed the Task-based Asynchronous Programming pattern and more!
Sunday, May 16, 2021
#dev
#dotnet
#csharp

Asynchronous Programming in C# - Part 1
Writing code is hard. Writing asynchronous code is even harder. Luckily C# provides us with the `async` and `await` keywords to make asynchronous programming a little easier. This is the first of a series of posts in which I'll be going over writing asynchronous code in C# as well as a bit into the internals of how it works under the hood.
Sunday, May 2, 2021
#csharp
#dotnet
#introduction
#dev

Creating Your Own Framework for Learning
As software engineers, we are constantly learning in order to grow and stay relevant. I've found that trying to learn something new without a plan is difficult. This is why I created a framework for learning, which is what I'll be covering in this post.
Thursday, April 15, 2021
#dev
#learning
#growth

Selenian. A Minimal Dark Theme for Visual Studio Code.
There are many great themes available for Visual Studio Code, but I'm definitely the type of person who enjoys tailoring my development environment to my specific needs. So I created my own theme called Selenian.
Monday, April 5, 2021
#dev

Updating JSON Data in PostgreSQL
If you're storing JSON data in Postgres, you'll eventually need to update it. In this post, we'll talk about a couple of functions that can be used to update JSON data.
Saturday, March 20, 2021
#dev
#postgres
#database

EF Core and Client Evaluation
Entity Framework Core is an amazing tool for interacting with databases of all kinds, but it doesn't come without potential pitfalls that can impact performance if you're not careful.
Sunday, March 7, 2021
#dev
#database
#dotnet
#efcore

Querying JSON Data in PostgreSQL
Storing JSON provides flexibility, but can add complexity. Let's take a look at how we can store and query this data in PostgreSQL.
Friday, February 12, 2021
#dev
#json
#postgres
#database

Behind the Scenes of Making my Blog
The number of options for setting up a blog can be overwhelming. Let's take a look at what worked well for my goals and expectations.
Thursday, February 4, 2021
#dev
#web

JWTs: A Peek Under the Hood
JWTs are used heavily in front and back end development. Let's open the hood to see how they're put together.
Tuesday, January 26, 2021
#dev
#web
#json
#introduction

Hello, World!
The proverbial "hello, world" blog post introducing myself to the interwebs.
Wednesday, January 20, 2021
#dev
#beginnings