I’ve written about a bunch of different things here. If you’re looking for a quick sampling, maybe try what I think are my best posts.

If you like, you can subscribe to the RSS feed.

Combining simple sliders to form visemes

Emergent behavior from simple rules

Analogies from lower dimensions

Layers of beats

My new favorite box modeling technique

Calculating the extents of cubic curves

An informal formal systems talk

Inventing an automated spoken language

Basic auth becomes basically everything

A simple extended study program

Building a simple road map route finder

Voting in a context where you can't vote for yourself

How likely is the winner of the first game to win the series?

Playing with partially-shared records

Learning how to digitally sculpt 3d humans

Programmatically adding assets to a level

For solo jazz piano

My talk from Haskell Talks at Mercury 2022

More sheet music transcription

An infinite source of numbers

My experience transcribing sheet music by ear

Stealing syntax...somewhat

Picking apart types and values

Shortcuts, inspiration-inducing ideas, and more

Code speedups and unlocking creativity

Recipes for reordering arguments

An unusual programming language

Adding dark mode wasn't that bad

And why you might want to

Excellence through focus, or linkages?

What I've listened to

Why do the top couple YouTube covers of "Numb" by Linkin Park sound strange?

Type-level functions to count possible terms

Structures, strictness, and ST

How can we shrink a range given additional constraints?

A frivolous fun fact

Constructing dice from other dice

A Template Haskell Adventure

Something to watch for while using record updating syntax

Supershuffling sequences

The need for going beyond propositional logic to capture causal structure

Learning to lookup

Thoughts on sneaking proofs into hidden layers

A straightforward design in Rust

Quick reflections on designing a wrapper library for ease of use

Responses to a few of Nagel's Questions

A near-minimal example

Nicely-typed lightweight database-backed APIs on the cheap

The quick Monte Carlo approach to a permutation problem

Reinforcement learning implementation in PyTorch

Algebraic closure and structure complexity

On the emotional content of music

Are riskier choices freer?

How to defeat any moral system and still learn nothing

Translations from pure SQL

How to count what we can't see

A numerical anumerical

How various languages apply one argument at a time

Another reason to not treat nulls like values

A critique, a retrospective, an experience

Moving new-ish programmers towards more readable code

The simple word reduction algorithm behind generating free groups on any set

Using networks to uncover obscure dataset shapes

Thinking in infinite distributions

An kid's introduction to value theory

Handling boundaries with values and types

It's good to solidify work, but not prematurely

Training a convolutional neural network on the Chars74K dataset

Solving parity problems with recurrent neural networks

Dedication-constrained problems

A lot of simple math describing qubits

Some observations about examples in Type-Driven Development with Idris

A simple table for calculating dice roll chances

Managing a list of uncertain events

Partially applied higher-order functions can replace some macros

An inductive counting problem

Generating magic squares with backtracking, in Rust

Implementing a super-simple stack-based language

Representational equality, identity functors, and the hashdot operator

A slew of national parks

It's more complex than it seems

Once more: the way to get good is to practice

Implementing basic Haskell lenses in twenty exercises

Boundaries and mysteries

Heatmapping channel usage over time

Playing with a simple genetic algorithm

Definitional flavors of the gamma function

Introductory insight into incentives

Building Android, iOS, and web apps with shared front-end logic

Order and chaos at different structural scales

Naturally even or odd

Achieving arbitrary approximation

No iteration!

Understanding execution is exciting

Confusing code and alphabetic enumeration

Ways to handle nonexistent values

Generated and human-edited music

How to be safer with next to no effort

Ways to turn things into other things

Playing with fun-to-visualize mathematical structures

Being bad at something never felt this good

Non-primitive-recursive functions and fork bombs

Calculating traffic loads

Another horribly abused phrase

Interpolation in its finest forms

Commands that improve your ghci experience

Light filters aren't spooky objects from beyond classical physics

Type-level Peano exponentiation comes to the rescue

You can have all three of C, A, and P

Trying to gain intuition for what happens at high speed

A beginner's guide to the ways Haskell helps us avoid errors

Generality, specificity, and their levels of precision

On being underpinned by a different kind of machine

An eschatological exploration

Remembering the conditions where it doesn't hold

A whirlwind tour through one of the conceptually simplest techniques for better reasoning

Bouncing around the circle of fifths

Mining the C code for interesting tidbits

Translating from MetaLua

Building up some intuition

Differences in some of my favorite sports, at scale

Infinite recursion defeats the type system once again!

How sum types help us avoid bugs

Abusing pattern matching for the greater good

Why these posts exist