Here's a list of everything I've published on this site so far, ordered neatly in descending order. Just for you.

Bevy: getting started on NixOS

When trying to follow the Bevy getting started guide, I ran into some NixOS related issues. Here's what they were and what I had to do to fix them!

2020 wrap-up

In which I go back and look at the goals I set for myself in 2020 and assess whether I achieved them or not (spoiler: mostly didn't). I also outline my (lack of) plans for 2021.

Rust 2021

In which I talk about what features I want to see on the Rust roadmap in 2021. Const generics and generic associated types get honorable mentions, but my vote goes to nested OR-patterns and trait aliases.

Understanding lifetimes

In which we run into Rust's lifetimes. What are they? And maybe more importantly: WHY are they? Also, how do we work with them? We'll try and get a grip of the basics in this article.

Meet the borrow checker

In which we encounter the Rust borrow checker for the first time and try and understand just what it is. We also look at some solutions to common problems.

New domain:

In which I formally deprecate in favor of and urge any readers wishing to stay abreast of my writings to subscribe to the new RSS feed.

Notmuch: (un)tag outgoing mail

In which we explore the mysteries of notmuch tagging outbound mail as 'unread' and 'inbox' (as if we haven't just written and sent it *out*), and find a simple solution after more effort than we expected.

org-babel-load-file doesn't tangle correctly

The `org-babel-load-file` function to automatically tangle and load org files with emacs lisp in them has a quirk that sometimes causes some code blocks to not tangle properly. The solution is to use `emacs-lisp` instead of `elisp` for your code blocks.

70,000 words

In which I look back upon the last year and what I've achieved with the blog. Mostly a meta-post, there's a selection of statistics as well as some general thoughts on what it's been like to write every week for a year.

The results of splitting empty strings

In which we talk at length about string splitting in various languages and how to handle the cases where the string is empty or where the separator doesn't appear in the string. As an interesting side note, we also briefly explore what happens if you use an empty separator.

Save on typing and improve legibility with Rust's macros

I finally took the time to learn the very basics of Rust's declarative macros this past week and learned a lot. This post acts as a basic introduction to Rust macros as I understand them now.

Configuring Emacs with Org mode and literate programming

In which I share how I recently took my first steps into the world of literate programming via Emacs and Org mode. If you're looking for how to start configuring Emacs with Org mode or just a brief introduction to literate programming, this should be a good place to start.

Building a request inspector

In which I tell the story about how I barely managed to scrape together single-endpoint server in Rust. Far from a tutorial, this is more akin to a snapshot of how I've spent my weekend and a document to how I put things together when I don't know what I'm doing.

On null and undefined

Some thoughts on the difference between `null` and `undefined` in JavaScript and in JSON, and how that impacts their use. Also briefly discusses how this split is (or isn't) handled by a lot of server side languages that don't have the distinction between `null` and `undefined`.

Haskell's Maybe and Either types

In which we have an introductory glance at the Maybe and Either types in Haskell. An unusual entry in the series of reading Haskell Programming from First Principles, but an entry nonetheless.

On Generics and Associated Types

In which we look at traits using generic types (or type parameters) and traits with associated types in Rust. What is the difference and when does it make sense to use one over the other?

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

In which we read the 11th chapter of 'Haskell Programming from First Principles': Algebraic Data Types and discuss higher-kinded types, cardinality in relation to the type system, and how the function type is exponential. Pokémon make an appearance too!

Improve your workflow with Forge

In which I gush about my new favorite tool for working with GitLab: Magit Forge. Forge is an extension to the already extremely useful Magit, that integrates with the likes of GitHub and GitLab, letting you collaborate on issues and PRs without leaving Emacs.

Org mode: tasty tricks

In which we explore some of the most useful features of Emacs' Org mode, including custom TODO keywords, the agenda view, and capture templates. Name-drops literate programming for bonus points.

Nix: override packages with overlays

In which we take a first look at Nix overlays, a mechanism which allows you to override and modify the package sets, and at how we can use that to get more up-to-date versions of our tools.

Kubernetes first steps

In which provision my first managed Kubernetes cluster and suddenly find myself without any idea of what to do next. More navel gazing than usual, this post is largely about trying to find out what I want to do with this beast of a system.

Corecursion and anamorphisms

In which we explore the concepts of corecursion and anamorphisms. We look at what corecursion and anamorphisms are, relate them back to recursion and catamorphisms, and then have some fun with exploring different ways unfold numbers into different representations.

My first Emacs Lisp

In which I heed Reddit's advice and write my first set of Emacs Lisp functions to customize Emacs. Turns out it's not all black magic and witches' brew! In addition to looking at why I wrote the functions, we'll be analyzing what the different bits mean.

Tips and tricks for the fledgling Emacs user

In which I RTFM. It took about 18 months, but I finally decided to delve into the dark depths that is the Emacs manual, and I made it through alive. This document contains some of the things I learned along the way. Remember: I did this so you won't have to.

Use git to restore parts of a file

In which we look at restoring parts of a file to its original state (or at least to what state it had at the specified commit). A handy workflow trick that uses the new git subcommand 'restore'.


In which we look at the upcoming stable Rust feature 'slice_patterns' (due to stabilize in 1.42.0). We look at the syntax, subslice binding, and how you can match on either end of a slice.

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

In which we go deep on folding lists and uncover surprisingly large and important differences between folding right and folding left. We discuss laziness, infinite lists, and catamorphisms.

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

In which we take a deep dive into the world of lists by looking at list creation, list comprehension, and about spines and non-strict evaluation. As it turns out, this has some pretty interesting implications.

Goodbye 2019, Hello 2020

In which I look back upon the year that is about to close and look forward to the year at hand. This post is a summary of what I achieved in 2019 and a list of new goals I've set for myself for 2020.

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

In which we talk about recursion and play with bottoms. We look at defining functions in terms of themselves, applying a function an arbitrary number of times, and what base cases are.

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

In which we talk about function composition and pointfree style and cover the chapter definitions for chapter 7. Function composition is especially important and a cornerstone of Haskell programming, so make sure not to miss this one!

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

In which we look at higher order functions and guards. We look at what the definition of a higher order function is and look at some examples. We also look at guards; what they are, the syntax, and the importance of ordering.

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

In which we start looking at the 'More Functional Patterns' chapter of 'Programming Haskell From First Principles'. This time, we're looking at pattern matching and case expressions; what they are and how to use them.

Async Rust: async main

In which I expand a little bit upon async functionality in Rust, introducing attributes that allow you to run async functions in your main function.

Async Rust

In which we explore Rust's newly stabilized async/.await language feature by creating a simple, asynchronous application. We look at what you need to do asynchronous programming in Rust and how it differs from other languages. And we talk a little bit about Pokémon!

Command Line Control: dirname

In which we have a brief look at dirname, a utility that lets you get the containing directory of any path you send to it. Nothing groundbreaking, but just really nice to have.

Rust 2020

In which I respond to the recent call for blogs put out by the Rust core team and write down my wishes for Rust in 2020. Yup, GATs and const generics are there, but also slice patterns and a request for better documentation around async development.

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

In which we finally have a closer look at typeclasses and take some time to explore some of the most basic ones, how they work, and how we can use them.

Command Line Control: vipe

In which we discover a new command line tool, Vipe, and look at how we can use it to easily modify and apply Kubernetes objects across namespaces.

On differentiation

In which I talk about differentiation, clarifying some issues I've had with reading the course material for where I study and giving some examples of how I think it should be presented.

Add updated files only

In which we look at the much-overlooked option for git add: --update. This option lets you add any and all files as long as they are currently tracked by git, but will ignore any files that git isn't tracking.

A mentor's thoughts

In which I discuss my experiences as a mentor at Oslo Legal Hackathon 2019, what I learned about myself, and why I think it's something you should try.

Amending authors

In which we look at amending git commit authors, both the steps you need to take to change the last few commits (or all of them), and how we can create a one-liner that just magically takes care of it for us.

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.