Here’s a list of everything I’ve published on this site so far.

Find anything you like? Let me know!

Git config management

In which we dive into git config management with a short overview of the format, and of where git searches for config files by default. We look at how to set values, unsetting them, inspecting them, and how to list all your config values. Plus: a neat trick to debug config collisions!

Commit message templates

In which we take a closer look at using commit message templates to increase our productivity by decreasing the mental overhead required to write a message. We look at how to set up templates, how to unset them, and a couple of ideas on what to put in them.

Rebasing off a repo root

In which we have the briefest of looks at how you can rebase off the root of a git repository, allowing us to pick, squash, and reword each and every commit in the repository's entire history.

Automate your commit messages

In which we look at how we can use git hooks to automatically fill in certain bits of the commit message for use based on the state of the repository and our current branch. Also: A tiny look at differences between BSD and GNU sed.

Change your git comment character

In which we look at how we can change our comment characters for git, allowing us to start commit, tag, and any other messages with any character we might fancy, including hashes.

Modularizing your git config with conditional includes

In which we figure out how to conditionally change our git configurations depending on what directory we're working in, saving us from having to go back and rewrite commits to change the author.

Let's read: Haskell Programming from First Principles, pt V

In which we look at type constraints and how they relate to typeclasses, currying and partial application, and polymorphism, both parametric and ad-hoc and how we use it in Haskell.

Let's read: Haskell Programming from First Principles, pt IV

In which we take a look at some basic data types in Haskell, such as numeric types, tuples, and lists. We also look at data declarations, type and data constructors, and if-expressions. This one's quite the mouthful, so grab some supplies and come explore!

Let's read: Haskell Programming from First Principles, pt III

In which we learn about how strings are represented in Haskell, start exploring how we work with lists, look at a surprise operator and talk briefly about total vs partial functions.

Let's read: Haskell Programming from First Principles, pt II

In which we look at basic Haskell syntax, are pleasantly surprised at compiler type inference, and learn about operators and variable assignment. We also look at some scary terms like 'weak head normal form'.

Building a custom NixOS installer

In which we look at how to create custom installers for NixOS, useful for cases where you need or want certain packages available in the installer and where you don't have internet access. A short introduction that gives you pretty much all you'd need.

Emacs, VSCode, and me

In which a close friend gives me some dubious advice and I fall in love with a text editor. Looking at it in retrospect, how does Emacs compare to VSCode, and, if I'd known then what I know now, would I do it again?

QWERTY to Dvorak

In which I look back upon the last two years and see whether learning the Dvorak layout was worth it or not. I discuss the benefits and the drawbacks, whether I think it was worth it and if I'd recommend it, and give a few tips to anyone else looking to do the same.

Let's read: Haskell Programming from First Principles, pt I

In which I finally find the time to dive into learning Haskell from first principles. Turns out 'first principles' mean understanding the mathematical underpinnings of the language before I ever get to touch (or even see) any code.

Command Line Control: awk

In which I learn a whole new language just to be able to kill applications with a single command. A basic introduction to the awk command and the AWK language that powers it; covering how it works, some language built-ins, and a few examples to get the creative juices flowing.

Hakyll CI builds in one fifth of the time

In which I finally manage to bring the deployment time of this site under control. We look at how Stack and Nix interact, what consequences having a completely isolated build environment might have, and how you might work around issues that arise from this.

xargs and the unruly tags

In which my CI/CD pipeline gets stuck in a recursive loop and I learn how to use xargs and how to delete remote git tags. If you've seen xargs in the wild, but never quite understood what it does: This one's for you!

Docking pains

In which I install Docker, fumble with user groups, realize my root partition is running out of space, and spend far too much time on something I expected to be a simple matter.

Hello, World!

In which I introduce my new blog to the world and give a brief overview of what goes into making it, including configuring Hakyll, Netlify, and GitLab to do my bidding and writing little Python scripts to automate the timestamp process.