Here you can find all my previous posts:

An Introduction to Type Level Programming

reading time: 109 minutes
Used judiciously, type level programming can let you write programs that are safer, more expressive, more flexible, and easier to maintain over the long term. Unfortunately, learning when and how to make effective use of type-level programming constructs can be difficult. In this post you'll learn how to apply many basic type-level programming concepts as you incrementally build a type-level theming system.

When you're finished with this article, you should come away with an idea of how to effectively use type classes, type families, GADTs, and haskell's Kind system to write better applications.

This article is based off of the ideas presented in my 2021-09-10 talk at the conference titled: Make It Purple! An Introduction to type-level programming.

The Fixed Point

reading time: 29 minutes
Haskell offers ample opportunities for ah ha! moments, where figuring out just how some function or feature works can unlock a whole new way of thinking about how you write programs. One great example of an ah-ha moment comes from when you can first start to understand fixed points, why you might want to use them, and how exactly they work in haskell. In this post, you'll work through the fixed point function in haskell, building several examples along the way. At the end of the post you'll come away with a deeper understanding of recursion and how haskell's lazy evaluation changes the way you can think about writing programs.

The Nixification of

reading time: 32 minutes
Nix is great for keeping your applications reproducible once you get them set up, but getting a project building with nix can be overwhelming for new nix users, especially when you run into a dreaded broken upstream dependency. In this article you'll learn how to create a hakyll blog that builds with nix, and in the process learn how to deal with broken upstream dependencies, and create nix overlays with custom patches.

Syntax Highlighting in Hakyll

reading time: 9 minutes
Hakyll popular among haskell developers for building websites and personal blogs, but building a code-heavy hakyll site can be tricky if you're not skilled at design (like me) since the default hakyll configuration doesn't come with support for syntax highlighting of code blocks. In this article you'll learn an easy way to get syntax highlighting for code in your hakyll blogs using pandoc.

Building A Todo List with Python and Flask

reading time: 31 minutes
The TODO List is the quintessential project for learning how to build web applications. It introduces you to important concepts like: How to build and deploy an application, how to handle CRUD operations, and how to deal with errors. TODO list applications are also prime examples of applications that you can build and add to to improve your skills in other areas over time. In this article you'll learn how to build a basic TODO application in Python using the Flask web framework.

Building Python Applications with Nix

reading time: 8 minutes
Package management in python is a problem with several competing solutions. Do you use virtual environments? pip? poetry? Each approach comes with their own benefits, but one universal drawback to these solutions is the python-specific nature of the tools. When your project comprises mutliple languages, or you want to integrate non-python tools into your workflow, you may wonder how to approach package management that can make use of native as well as python-specific tooling while giving you the guarantees of knowing you're going to get a reproducible set of pinned packages. Nix provides one way to manage python dependencies along side native dependencies. In this article you'll learn how to package python applications so they are reliable, reproducible, and ship with their own development environment using the nix tools and the nixpkgs ecosystem.