archive

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

Find anything you like? Let me know!

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.