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.