Commit Messages – the Easiest Documentation You’ll Ever Write

When it comes to writing documentation, nobody wants to do the job. And whatever documentation does get written is quickly outdated because nobody wants to update it, either.

The most accurate documentation of how a system works is the code itself, but even “self-documenting” code falls short of describing why it was written that way. The next best thing is that little bit of text that gets attached to every code change: the version control log message. Read more on Commit Messages – the Easiest Documentation You’ll Ever Write…

The Value of a Fresh Pair of Eyes

When you’re working on a piece of software for a long time, it can be easy to overlook poor architecture or an awkward UX. You may spend your day avoiding the dark corners of your app and choosing to forget that they even exist. Unfortunately, when this happens, the health of our codebase and application can suffer.

Recently, my project team gained a new member—a fresh set of eyes unfamiliar with our application’s design. This newness allowed them to notice inconsistencies and ask valuable questions about why we chose to architect our app as we had. Read more on The Value of a Fresh Pair of Eyes…

Bluetooth Mobile App Testing Checklist

Bluetooth is one of those technologies that seems like a very simple thing from the perspective of a user—you set it up once and forget about it. But in reality, there’s a lot of complexity hidden behind the scenes. As we all know, wherever there’s complexity, there’s more that can potentially go wrong. Read more on Bluetooth Mobile App Testing Checklist…

Four Steps for Inheriting a Codebase

In the last two years, I’ve worked on a few projects passed on to me by other teams. Inheriting an existing codebase can be a challenge, given you weren’t there when architectural decisions were made, you are less familiar with the project domain and client needs, and you are just new to the codebase.

Read more on Four Steps for Inheriting a Codebase…

My New 1st Principle of Programming – “Good Code Is Easy to Change”

Good code is easy to change.

I read that somewhere in the depths of the internet about a year ago, and it’s substantially affected the way I code. It’s a pretty simple statement at face value, but it takes on a new meaning when read in terms of equivalence:

Read more on My New 1st Principle of Programming – “Good Code Is Easy to Change”…

An Approach to Database Testing in .NET Core 2.1

I’ve been working on a REST API written in ASP.NET Core 2.1. Recently, our team wanted to write tests that exercised our business logic and also interacted with our database. I wasn’t able to find many examples of this online, so I was motivated to write this post and share our approach. Read more on An Approach to Database Testing in .NET Core 2.1…

Why You Should Avoid Writing Complex SQL Queries – and What to Do Instead

If you’ve worked with a piece of software that talks to a database, chances are you’ve come across a long SQL query. Slowly, your eyes glaze over as you attempt to reason through the many joins and subqueries, trying to figure out if this query is the source of the bug.

You debate between the different options. Should you hunt for the original creator of the query, or re-engineer the query yourself so you have a chance of understanding its hidden complexities? Read more on Why You Should Avoid Writing Complex SQL Queries – and What to Do Instead…

Getting into Test-Driven Development: Six Things a Developer Needs to Know

Having a hard time sorting through the vast array of books, talks, blog posts, contradictory advice, and academic writing about Test-Driven Development?

I’ve spent the last quarter wading through resources on TDD, and I’ve summarized the most important things any new TDD developer should know into these six areas. Read more on Getting into Test-Driven Development: Six Things a Developer Needs to Know…

A Case Against Dependencies

When you need to add a major bit of functionality to your system, what’s the first thing you do? Naturally, you start looking through whatever package repository is appropriate for a solution that fits. While there’s nothing inherently wrong with this, it’s important to think of the trade-offs made by adding external dependencies. Read more on A Case Against Dependencies…

Getting Ready to Break Everything (in 5 Easy Steps)

Every project eventually hits a point where a big change needs to be made, and it’s going to break everything. And you’re going to be the one stuck putting it back together.

Whether it’s a language or tool change that causes your application to no longer compile, a third-party SaaS service change that breaks features throughout your app, or just a big refactoring, eventually you’re going to have to bite off more than you can chew. After having been faced with situations like these many times, I’ve developed a coping strategy. Read more on Getting Ready to Break Everything (in 5 Easy Steps)…