Mechanized type inference for record concatenation
Type inference algorithm for biased record concatenation
Haskell for all
A blog about Haskell and functional programming.
Latest posts
Record type inference for dummies
Gentle tour of type inference for records
Ergonomic overrides for Nixpkgs
Announcement post for the override-utils Nix package
Type out the code
Freecoding improves broader programming proficiency
A bidirectional typechecking puzzle
Type inference challenges for real-world JSON
A sufficiently detailed spec is code
Specifications do not address the limitations of agentic coding
Browse code by meaning
Navigate a repository using topic modeling
Beyond agentic coding
AI dev tooling can do better than chat interfaces
My experience with vibe coding
Vibe coding isn't a silver bullet
Type-safe eval in Grace
The case for principled eval support
Chat is the least interesting interface to LLMs
Structured inputs and outputs work work better than prose
Prompting 101: Show, don’t tell
Improve your prompts with better examples rather than better instructions
Nix Steering Committee vote of no confidence
Post-mortem on the Nix Steering Committee's recent vote of no confidence
Steering Committee Retrospective
A Nix Steering Committee member's critique of the Steering Committee's effectiveness
Datatype unification using Monoids
How to infer the types of plain data, including unification
Prompt chaining reimagined with type inference
Using bidirectional type inference to infer JSON schemas for prompts with structured outputs
The Haskell inlining and specialization FAQ
Answers to common Haskell questions related to inlining and specialization
Firewall rules: not as secure as you think
A post outlining tricks for firewall privilege escalation
Software engineers are not (and should not be) technicians
Why predictable development work is a red flag
Quality and productivity are not necessarily mutually exclusive
A focus can quality can sometimes immediately boost productivity
My spiciest take on tech hiring
Why streamlined interview processes are better
Prefer do notation over Applicative operators when assembling records
A post explaining the advantages of do notation and RecordWildCards over Applicative operators
All error messages are necessarily bad to some degree
An explanation of the selection bias that leads to poor error messages
The siren song of domain-specific languages
The pitfalls software engineers encounter when creating domain-specific languages for less technical users
Unification-free ("keyword") type checking
A type checking proposal that doesn't employ unification variables.
A GHC plugin for OpenTelemetry build metrics
An announcement post for the opentelemetry-plugin Haskell package
My views on NeoHaskell
A rundown and critique of the NeoHaskell project
GHC plugin for HLint
An announcement post for a maintained GHC plugin for HLint
Ergonomic newtypes for Haskell strings and numbers
A trick to elide newtypes around Haskell strings and numbers
The "open source native" principle for software design
Design proprietary software as if it were open source software
terraform-nixos-ng: Modern terraform support for NixOS
Announcement post for improved terraform bindings for NixOS
Announcing nixos-rebuild: a "new" deployment tool for NixOS
A post explaining how nixos-rebuild is a cross-platform tool that can deploy remote NixOS systems
Nixpkgs support for Linux builders running on macOS
Blog post contextualizing recent work to upstream Linux builders for macOS
Nixpkgs support for incremental Haskell builds
A post explaining the design behind a new Nixpkgs feature for building Haskell packages incrementally
How to correctly cache build-time dependencies using Nix
A guide to uploading Nix dependencies to a cache efficiently and reliably
What does "isomorphic" mean (in Haskell)
An explanation of isomorphisms in the context of the Haskell programming language
nix-serve-ng: A faster, more reliable, drop-in replacement for nix-serve
An announcement post for a Haskell rewrite of nix-serve named nix-serve-ng
Stop calling everything "Nix"
Explanation of the Nix ecosystem's abstraction layers
Incrementally package a Haskell program using Nix
A tour of progressively more robust ways to package a Haskell file using Nix
defaultable-map: An Applicative wrapper for Maps
An announcement post for a Haskell package for default-valued Maps
The appeal of bidirectional type-checking
A post explaining why bidirectional type-checking is popular within the programming language theory community
Generate web forms from pure functions
Announce post for the Grace browser, which translates functional code to interactive HTML
The golden rule of software distributions
A description of an architectural pattern commonly found in many software distributions
Why does Haskell's take function accept insufficient elements?
A blog post that is a long-form answer to a question originally asked on Reddit
Introductory resources to type theory for language implementers
A post touring resources you can use to learn how to implement a type checker or type inference algorithm
Modeling PlusCal in Haskell using Cartesian products of NFAs
This post introduces a Haskell eDSL implementing a subset of PlusCal along with a tour of the implementation
The hard part of type-checking Nix
An survey on the challenges designing a type system for Nix
Applicatives should usually implement Semigroup and Monoid
A post that explains why and when Applicative type constructors should provide lifted Semigroup and Monoid instances
What is a monad morphism (in Haskell)?
An educational post explaining monad morphisms and their laws
Nixpkgs overlays are monoids
Not even Nixpkgs abstractions are safe from category theory