Small Programming Tricks · will keleher

writing
all posts
about.md
rss.xml

Small Programming Tricks
Day to day, I think a surprising amount of engineering productivity comes from small nuggets of knowledge: being aware that a language feature exists; knowing that an unexplained tcp delay is probably related to the TCP_NO_DELAY setting and Nagle’s algorithm; knowing the right git incantation to get out of a pickle; or knowing a trick with sed to rewrite a file.
In one sense, this is self-evident: anything you know is going to be made up of smaller pieces of knowledge. Of course those smaller pieces of knowledge matter.
But I think there are some nuggets of knowledge that are particularly valuable and don’t require a lot of supporting mental infrastructure. You don’t need to know any python to use python3 -m http.server to start a simple server in a directory, but it might still make your work marginally easier. Let me share a few examples:

You probably know that ctrl + r allows searching your terminal’s command history, but if you install fzf, you can set it up so that ctrl + r does a fuzzy search. If you want even more power, atuin replaces your shell history with a searchable SQLite database. per-directory-history lets you switch back and forth between searching for commands that have been run in a specific directory or searching all previous commands. Finally, you can configure how much history to store: stackoverflow question.
You can SELECT without a FROM. This can be useful for testing out how a function in your database actually works or reminding yourself how SELECT TRUE <> NULL works.1
PostgresSQL and MySQL both support explain analyze which will actually run the query you’re trying to optimize and give you a ton more information about its performance.
In regular expressions, \b, the word boundary assertion, makes it easy to look for the beginnings or ends of words.
You can use logarithms with metrics to get a sense of the distribution of values for a field you’re interested in:
const bucket = Math.floor(Math.log10(userInGroupCount))
metrics.increment("my_metric", { bucket });

Modern JS now supports Array.flatMap, Object.entries, and Promise.withResolvers.
In NodeJS, you can keep a connection open to an external resource by creating an https.Agent and then providing it to your http requests: fetch(url, {method, agent}). This can have a dramatic impact on latency.
git log -S pattern (”git pickaxe”) can give you all commits that added or removed a string in a codebase. It’s amazingly useful especially with older codebases! (git log -G pattern is similar, but will also show when that line was moved)
Similar to cd -, you can use git checkout - to check out your previous HEAD.
You probably don’t need find. A lot of find commands can be replaced with globs like **/*.md. Most shells support this out of the box, but with bash, you need to turn this on with shopt -s globstar.
In a similar vein, most folks will probably want to use rg (ripgrep) rather than grep, ack, or ag.
zsh’s advanced autocompletion features aren’t turned on by default:
if type brew &>/dev/null; then
FPATH="$(brew --prefix)/share/zsh/site-functions:${FPATH}"
fi
autoload -Uz compinit
compinit

You might have already known all of these things! Or you might work in a domain that makes all of these little tricks totally useless. Even if this particular set of tricks isn’t useful for you, I bet you have your own stash of tricks that you’ve accumulated over the years that makes your work easier.
At a company, I think even more knowledge tends to be this sort of small high-leverage nugget:

To debug $PROBLEM, use $DATA_SOURCE.
$PERSON knows a ton about $AREA and they’re happy to help if you get stuck
There are good docs about $HARD_THING $OVER_HERE.
When $THING happens, it means we should manually scale out.
To do a rolling restart of a service, run $THIS_COMMAND.
This $UTIL makes $THAT_PROBLEM easy to script.

At a previous company, I shared a trick on slack every day with the engineering team, both technical and company-specific, and folks found them pretty useful. Even if you knew 9/10 tricks, that 10th doc or technique might save you some time! And one trick per day was the right number to avoid overwhelming people with knowledge, and it could occasionally spark useful discussion. If you’re a more senior engineer at your company, you might think about doing something similar.

I think I first saw this technique on Julia Evan’s blog, and I think her writing often perfectly encapsulates the idea behind this post: "small bits of knowledge are powerful! and fun! and approachable!!" ↩︎

The author posits that a significant amount of engineering productivity stems from acquiring small nuggets of knowledge. These pieces of information, ranging from knowing an obscure language feature to understanding specific system behaviors, are valuable because they offer shortcuts that do not require extensive mental infrastructure. The text provides numerous examples of such highly useful tricks across various domains.

In the realm of command-line tools and shell interaction, the author highlights enhancements available through tools like fzf, which can extend the functionality of ctrl+r history search into a fuzzy search mechanism. Further customization, such as using atuin to replace shell history with a searchable SQLite database and using per-directory-history to manage command history context, are cited as examples of leveraging existing tools for greater efficiency. Specific SQL knowledge is also emphasized, noting that SELECT without a FROM clause can be useful for testing relational logic, such as verifying the behavior of operators like SELECT TRUE <> NULL. For database optimization, the availability of explain analyze in systems like PostgresSQL and MySQL is presented as a resource that provides substantial performance information regarding a query.

In programming and data manipulation, the text points to specific syntactic and functional additions that simplify tasks. Regular expressions benefit from the word boundary assertion, \b, which simplifies pattern matching around word beginnings or endings. Modern JavaScript features such as Array.flatMap, Object.entries, and Promise.withResolvers are noted as recent advancements. In Node.js development, managing external resource connections can be improved by using an https.Agent with http requests, which can significantly impact latency. Git possesses powerful commands like git log -S pattern, which can track changes by examining commits that added or removed a specific string within a codebase, and git checkout - to easily revert to previous HEAD states. Furthermore, the suggestion is made that find commands can often be replaced by shell globs, such as **/*.md, with bash requiring shopt -s globstar to enable this functionality. The substitution of general grep utilities with ripgrep (rg) is also recommended. Finally, setting up advanced zsh autocompletion, including configuring paths via brew and initializing completion functions, is suggested for power users.

Beyond specific technical commands, the author argues that high-leverage knowledge in a company setting often takes the form of relational insights rather than just technical commands. This includes knowing how to debug a problem by referencing the relevant data source, recognizing that a specific person possesses expertise in a certain area, knowing where to find good documentation for a complex topic, understanding that a system state implies a need for manual scaling out, knowing the command for rolling service restarts, and recognizing utilities that can simplify scripting. The underlying philosophy is that acquiring these small, context-specific pieces of knowledge—both technical and organizational—can be powerful, fun, and approachable.