All Posts

• A Zero Downtime Migration to Time-Partitioned Tables in Postgres — A crosspost from our engineering blog at work, in which I describe how we managed to migrate databases receiving millions of writes per day to time-partitioned tables without incurring any downtime or performance degradations.
• Amtrak Tips — A collection of tips and tricks for riding Amtrak
• TIL: use svn to download subdirectory of GitHub repo — Today I learned this one weird trick to download a single subdirectory from a github repo, without needing to add the repo as a remote, do a spare checkout, or any of the other typical workarounds.
• A NixOS Christmas Story — A quick story of how NixOS saved Christmas
• Installing a Specific Version of a Package with Nix — A common question when starting out with nix is "how do I install some particular version of some package?" This is not only a surprisingly complicated problem to solve for new nix users, but also a surprisingly difficult question to find answers to on your search engine of choice. Here, I'm going to cover a few different ways of installing a particular package version using nix, highlighting the pros and cons of each. I'll be focusing on _declarative_ nix configuration, with the nix repository pinned to a particular version using either the older [niv] or the newer [flakes]. The examples I show will be for installing a package into a development environment. See my other post [here][nixifying the blog] for instructions on how to set up a basic dev environment. I'll cover some basic setup again here, but see that post for rationale and discussion.
• A Year (and Change) of Rust — Looking back on over a year of writing Rust professionally. What were my early concerns, and how did they play out? How do I feel about the language now? What do I like and dislike about it?
• Set Your Upstream to the True Upstream — One of the great things about Magit is that, through using it, I wind up learning new things about git itself. One of those things is the capacity of git to work with two remote targets, the upstream and the push target. Using separate targets is easy and natural in Magit, but it's also not difficult to bring this workflow into your command-line-driven git experience.
• Introspecting Emacs Packages — As your emacs configuration gets more and more complicated, it can be non-obvious which of many installed packages (or even built-in emacs functionality) is being called at any given time. Here, we discuss some ways of figuring that out, with a mildly deep dive into exploring which functions are called via the profiler. Somebody on the Internet asked how to figure out which functionality is coming from which package in emacs, and I went classically overboard in responding, so I figured I'd turn the response into a post.
• 2021: A Year in Review — 2021 was quite a year. From a global perspective it was difficult, to say the least. For me personally, it was a year of significant change, with much of that change being positive, thankfully. In this post, I'll take a look back at the major developments in my life over the course of 2021.
• What I Learned at Bestow — An overview of lessons learned from my time at Bestow, both technical and cultural.
• Thoughts on "Maybe Not" — A friend sent me Hickey's talk, "Maybe Not," which discusses some of the design constraints and decisions around optionality in ClojureSpec. Like pretty much all of his talks, it was really thought provoking. Here I discuss my thoughts on it, including whether and how it applies to types in systems programming languages like Rust, how it relates to higher-kinded types in languages like TypeScript and Haskell, and how it could serve as a model for other languages.
• Nixifying the Blog — I added nix support for the blog's development environment, including support for both the upcoming flakes feature and current/legacy nix. Here we dive into why it's neat and how it was done.
• Moving to GitLab — I decided to move my blog to GitLab, both for the source and for hosting (via GitLab pages). This post goes into the rationale and process behind that decision.
• Rust to Webassembly to JavaScript — Cross-posting a post I did for our blog at work walking through the process of compiling a Rust project to webassembly such that it can be made available in a variety of JavaScript contexts, including both node and the browser, with an associated example repository.
• Selected Reads (2020-09-27) — It’s been a minute since I put out a list of selected reads, which means we’ve got quite a few today. Lots of Rust, as usual, but also some politics, an article on VSCode, and another Bret Devereux post on academics.
• RustConf 2020 — Rust has been the world's most-loved programming language for five years running. That's a remarkable feat, especially for a language that, particularly back in 2015, was barely even a blip on the list of most-used languages. That fact that so many people who used Rust wanted to keep working with it was one of the main things that made me want to try it out, leading it to become my most-loved programming language too. This was my first year attending RustConf, albeit virtually. Thanks to the conference, for the first time I feel like I really understand what has led to Rust being not only a great language, but a lovable one. I came away from the conference more bullish than ever that Rust adoption will continue to grow in every space where anyone chances to use it. In this post, I'll talk about some of the things that really stood out to me as highlighting what makes Rust special, along with some of the reasons why I think Rust is poised to grow substantially even outside of its originally-intended niche of systems programming.
• Extending Rust Builtins: Adding an Iterator Method — Rust's trait system makes it easy to add functionality to existing types. Here we explore extending Iterators with a new method, so that we can use our new method in Iterator chains just like .filter(), .map(), or .take().
• Selected Reads (2020-09-07) — From fancy Rust libraries and applications for working with the command line to deep dives into the role of Greek tragedy in driving psychological catharsis to meditations on the relationship between chess and philosophy, this selection of reads covers a pretty broad range of topics.
• Selected Reads (2020-08-22) — It’s been a wild ride this week, with RustConf and the Democratic National Convention generating a significant amount of interesting content to digest, along with the usual steady trickle of interesting reads.
• Why Are We So Eager to Break Things? — An exploration of some of the ways we intentionally or unintentionally make extra work and churn for our colleagues, how we justify it to ourselves, and how we can avoid it.
• Communication, Education, and Engineering — Communication is fundamental to the success of an engineering organization, and communication as a core value must be actively promoted in order for the organization to be successful. Most of our necessary communication is either for purposes of learning or education, and it should be expected that leadership roles involve a substantial amount of educational communication. We must therefore be explicit in our expectations and hiring that good communication is just as important as technical ability. To ensure we can evaluate these expectations for current and future employees, we must codify what we mean by good communication and ensure that we take steps to share and enforce that vision.
• Make and Makefiles are Awesome — Make and its associated Makefiles have been around forever, and have gotten a bit of a bad rap due to people encountering and writing arcane, poorly documented examples. However, learning to use Make effectively can provide a significant benefit to modern software projects, enabling intelligent ordering and dependency management for common tasks that would be a nightmare to implement from scratch. In this article we'll cover the basics of Makefiles and how they can be useful in the context of a modern scripting language like JavaScript or Python.
• Creating an RSS (Atom) Feed — creating an RSS (Atom) feed from scratch
• Adding Support for Tags: Part 4 — actually generating tag content
• Adding Support for Tags: Part 3 — finishing up refactoring
• Adding Support for Tags: Part 2 — collecting tags and posts into a nice HashMap
• Adding Support for Tags: Part 1 — refactoring header parsing in preparation for tag support
• Why Bother? — Why bother having a custom blog at all?
• Boil Water Notice - Tips and Tricks — lessons from growing up on the Gulf Coast
• Stacking Calls to pytest's Parametrize — how to compose parametrizations for combinatoric testing
• GCC on Fedora 12(!) — getting a compiler to run on a very old system