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!
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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!
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.
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.
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.
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!
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.
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.
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.
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.
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.
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.
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.
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.
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!
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.
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.
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.
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.
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.
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.
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!
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.
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'.
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.
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?
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.
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.
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.
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.
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!
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.