will-keleher.com

Code review is more important than it used to be, which makes trunk-based development, a good diff viewer, LLM review, and opening code locally crucial

LLMs are great at generating code, but writing code helps me think and understand the system I'm building.

Between zsh's globbing, Bash's `shopt -s globstar`, and `fd`, you probably can avoid ever using `find`.

Regular expressions with word boundaries, pasting without formatting, and markdown format can occasionally save non-technical writers a teeny bit of work.

Detailed instructions to fix `echo`, abuse HEREDOCs, and use `say` in pipelines.

I'm surprised that MySQL isn't able to come up with a better query plan for queries like `SELECT * FROM X WHERE Y in (a, b) ORDER BY Z LIMIT 10` when there's an index on `(Y, Z)`.

For a query like `WHERE A = ?

TODOs are more useful when they have a consistent format!

A good chunk of the coding I've done has been munging data into appropriate shapes.

I found it striking how incapable every AI model I tried was of drawing a spider silhouette missing one leg.

The basics of good pedagogy—starting with learning goals and incorporating lots of practice—can improve internal company engineer training.

When I haven't tried something, it ends up being a huge barrier towards adding that tool to my toolbox.

Stubs that mutate objects are hard to maintain and can cause hard-to-debug problems for future engineers.

Git is flexible and powerful, but it takes a lot of commands to do most workflows.

Complex numbers can represent vectors in Python in a way that arrays or tuples can't, and they lead to more natural way of structuring 2D data.

Automating things, even when it doesn't save time, is how you learn the skills to automate the things that will.

When writing backend tests, the database is an integral part of what we'd like to test.

Python is a great fit for Advent of Code style problems.

Thinking of B-trees and B+-trees as sorted arrays can help you reason about indexes and performance.

By auto-generating JSDoc comments on a fixture IDs file, we were able to make our fixture code simpler to work with.

If you have a process ID, you can look at what files/ports a process has open, see details about how the process was started, trace it to see what work it's doing, or wait for it to complete its work.

Understanding why `zip(*[iter(s)]*n)` chunks an input `s` into `n` chunks is a good excuse to explore iterators, iterable unpacking, list multiplication, and the zip function.

Containers serving production traffic can sometimes get into bad states that they can't recover from.

How I set up image previews for some posts on this site using automated screenshots.

MySQL 5.7 makes getting a list of numbers pretty tricky, so solutions to FizzBuzz are a fun chance to explore MySQL techniques like session variables, stored routines, and cross-joined views.

How to start an async storage context early in your middleware stack and set up counters to track down problem routes.

Large analytics SQL queries can be unmaintainable and hard to debug.

Being comfortable using shell tools to do large code migrations is a superpower.

Use of async functions in JS leads to consistent mistakes; these are the ones I see most often.

When we went remote, we needed to replace the in-office info-radiators that displayed info about the health of our system.

4 bash tricks I find myself using often that I wish I'd discovered sooner.

ClassDojo sends real traffic to canary containers to validate new builds and uses that as part of a system that safely deploys new code multiple times a day.

Node's AsyncLocalStorage can dramatically increase monolith legibility and improve performance.

understanding type inference, type narrowing, and structural typing is crucial to writing good TypeScript code.

HyperLogLogs leverage the power of hashing strings into random numbers to create remarkably accurate cardinality estimates.

Logs should be actionable and the default categories of FATAL, ERROR, WARN, INFO, and DEBUG aren't precise enough.