Ditch your (mut)ex, you deserve better
Mutexes are unreliable tools, let's explore better alternatives.
Chris Penner
Latest posts
Exploring Arrows for sequencing effects
Monads are one way to sequence effects, but they're not the only way!
Monads are too powerful: The Expressiveness Spectrum
Monads are a useful tool, but what costs do we pay for their expressive power?
You should add debug views to your DB
A nifty trick for debugging your tables easier.
Save memory and CPU with an interning cache
Weak Caching for Strong Apps
Using traversals to batch database queries
Techniques for lateralizing nested code
Building Industrial Strength Software without Unit Tests
Unit tests aren't the only way.
3 things other languages should steal from Unison
Some things other languages should steal from Unison
Building Type Search for Unison
Building an efficient and scalable type search for Unison
Simpler and safer API design using GADTs
Herein we look at how, for certain situations, GADTs can sometimes provide a cleaner approach than typeclasses.
Virtual Record Fields Using Lenses
Lenses are commonly used for getting and setting fields on records, but they're actually much more adaptable than that! This post dives into the idea of 'virtual fields' using optics.
Composable filters using Witherable optics
Discovering applications of filterable optics
Silly job interview questions in Haskell
Implementations of various silly job interview questions in Haskell
Generalizing 'jq' and Traversal Systems using optics and standard monads
We rebuild the core behaviour of 'jq' using standard Haskell combinators and optics
Intro to Kaleidoscopes: Optics for aggregating data through Applicatives
An introduction to kaleidoscopes
Algebraic lenses
A profunctor implementation of algebraic lenses
Advent of Optics: Day 4
Day 4 of Advent of Code solved with optics
Advent of Optics: Day 3
Day 3 of Advent of Code solved with optics
Advent of Optics: Day 2
Day two of Advent of Code solved with optics
Advent of Optics: Day 1
Day one of Advent of Code solved using optics
Beating C with 80 lines of Haskell: wc
An exploration into high-performance Haskell by cloning the wc utility
Optics + Regex: Greater than the sum of their parts
Optics + Regex: greater than the sum of their parts.
Slick 1.0 Release - Now with a quick and easy template!
Build a static site using Haskell, Shake and Pandoc!
Haskell IDE Support (hie-core lsp Sept. 2019)
Configuring editor support for Haskell (hie-core 2019)
Higher Kinded Option Parsing
Collecting options for your application from multiple sources using Higher Kinded Data
Mocking Effects using Constraints and Phantom Data Kinds
We learn a method to mock multiple effects when writing tests without an exponential explosion of instances.
Update Monads: Variation on State Monads
We explore the applications and implementation of a generalized version of Reader/Writer monads.
Typesafe Versioned APIs
Exploring writing multiple versions of your application in a typesafe way using data-kinds and functional dependencies
Monoidal Sorting
We explore a merge-sort monoid
A Practical Introduction to Finger Trees
How to use finger trees to solve problems by choosing the appropriate monoid measure.
Postman API Explorer: You've got mail!
A guide to using Postman for API exploration and testing
Query a Google Sheets Spreadsheet from BigQuery
A guide to using a google sheets spreadsheet as a BigQuery datasource
ASTs with Fix and Free
Using Fix and Free datatypes to represent compiler ASTs
MonadIO Considered Harmful
Avoid using IO or MonadIO directly
Type Tac Toe: Advanced Type Safety
Upgrading your type programming game
Conway's Game of Life using Representable and Comonads
Quick ~100 line implementation of Conway's game of life in Haskell
Radix Sort, Trie Trees, and Maps from Representable Functors
Representable Functors can be used to create Map-like data structures or perform Radix-like sorts.
Free and Forgetful Functors
Building adjunctions from Free and Forgetful Functors
Adjunctions and Battleship
Using Adjunctions and Representable to build a Battleship game
Zippers using Representable and Cofree
Using Representable and Cofree to build a zipper datatype
Shipping Haskell via Homebrew
How to set up your Haskell project to distribute via Homebrew
Kleisli Endomorphisms
Discovering an isomorphism between the Kleisli version of Endomorphisms to the mtl StateT transformer.
Tail Recursion In Python
Tail Recursion in python without introspection
The Interface We Need
Starting with the interface can make things easier for everyone
Let there be Truth
Let's re-visit truthy/falsy.
Autoenv Trick
Use Auto-env to streamline your workflow.
Semantic Versioning
Semantic versioning helps, use it!
BoxKite: Open-Sourced
I've open-sourced the code that I use to generate this blog.
Getting Schooled
When did schooling become more important than skill? Should we really be discriminating against people based on the school they went to?
Gem: Duckling
Check out the Duckling project