The Curious Engineer

All blogs / Haskell

Haskell for all

haskellforall.com

A blog about Haskell and functional programming

HaskellFunctional / PL theoryAI / MLDev tools / editors / IDEs

’15’20’25
Posts
205 from 31 Dec 2011 to 2 Sep 2026
Posting
monthly (13 in the last year)
Kind
personal blog
Feed
https://haskellforall.com/rss.xml

2026 13

  1. Dependent if expressions without dependent types
  2. Mechanized type inference for record concatenation
  3. Record type inference for dummies
  4. Ergonomic overrides for Nixpkgs
  5. Type out the code
  6. A bidirectional typechecking puzzle
  7. A sufficiently detailed spec is code
  8. Browse code by meaning
  9. Beyond agentic coding
  10. My experience with vibe coding
  11. Type-safe eval in Grace
  12. Chat is the least interesting interface to LLMs
  13. Prompting 101: Show, don’t tell

2025 4

  1. Nix Steering Committee vote of no confidence
  2. Steering Committee Retrospective
  3. Datatype unification using Monoids
  4. Prompt chaining reimagined with type inference

2024 9

  1. The Haskell inlining and specialization FAQ
  2. Firewall rules: not as secure as you think
  3. Software engineers are not (and should not be) technicians
  4. Quality and productivity are not necessarily mutually exclusive
  5. My spiciest take on tech hiring
  6. Prefer do notation over Applicative operators when assembling records
  7. All error messages are necessarily bad to some degree
  8. The siren song of domain-specific languages
  9. Unification-free ("keyword") type checking

2023 7

  1. A GHC plugin for OpenTelemetry build metrics
  2. My views on NeoHaskell
  3. GHC plugin for HLint
  4. Ergonomic newtypes for Haskell strings and numbers
  5. The "open source native" principle for software design
  6. terraform-nixos-ng: Modern terraform support for NixOS
  7. Announcing nixos-rebuild: a "new" deployment tool for NixOS

2022 18

  1. Nixpkgs support for Linux builders running on macOS
  2. Nixpkgs support for incremental Haskell builds
  3. How to correctly cache build-time dependencies using Nix
  4. What does "isomorphic" mean (in Haskell)
  5. nix-serve-ng: A faster, more reliable, drop-in replacement for nix-serve
  6. Stop calling everything "Nix"
  7. Incrementally package a Haskell program using Nix
  8. defaultable-map: An Applicative wrapper for Maps
  9. The appeal of bidirectional type-checking
  10. Generate web forms from pure functions
  11. The golden rule of software distributions
  12. Why does Haskell's take function accept insufficient elements?
  13. Introductory resources to type theory for language implementers
  14. Modeling PlusCal in Haskell using Cartesian products of NFAs
  15. The hard part of type-checking Nix
  16. Applicatives should usually implement Semigroup and Monoid
  17. What is a monad morphism (in Haskell)?
  18. Nixpkgs overlays are monoids

2021 17

  1. Funding isn't the problem with open source
  2. Co-Applicative programming style
  3. Advice for aspiring bloggers
  4. The "return a command" trick
  5. Fall-from-Grace: A ready-to-fork functional programming language
  6. Optics are monoids
  7. Forward and reverse proxies explained
  8. Naming function arguments in Dhall
  9. Namespaced De Bruijn indices
  10. Probability for Slay the Spire fanatics
  11. Module organization guidelines for Haskell projects
  12. The trick to avoid deeply-nested error-handling code
  13. The end of history for programming
  14. How to replace Proxy with AllowAmbiguousTypes
  15. Folds are constructor substitution
  16. Dynamic type errors lack relevance
  17. The visitor pattern is essentially the same thing as Church encoding

2020 10

  1. Recruiting for diversity is not lowering the bar
  2. How to use NixOS for lightweight integration tests
  3. Pretty-print syntax trees with this one simple trick
  4. Why I prefer functional programming
  5. The golden rule of software quality
  6. Record constructors
  7. Blazing fast Fibonacci numbers using Monoids
  8. Dhall Survey Results (2019-2020)
  9. Why Dhall advertises the absence of Turing-completeness
  10. Dhall - Year in review (2019-2020)

2019 6

  1. Prefer to use fail for IO exceptions
  2. The CAP theorem for software engineering
  3. Release early and often
  4. Dhall Survey Results (2018-2019)
  5. Haskell command-line utility using GHC generics
  6. Dhall - Year in review (2018-2019)

2018 6

  1. Detailed walkthrough for a beginner Haskell program
  2. NixOS in production
  3. How I evaluate Haskell packages
  4. The wizard monoid
  5. Dhall Survey Results (2017-2018)
  6. Dhall - Year in review (2017-2018)

2017 12

  1. Compare Nix derivations using nix-diff
  2. Semantic integrity checks are the next generation of semantic versioning
  3. Advice for Haskell beginners
  4. Why do our programs need to read input and write output?
  5. Type-driven strictness
  6. Demystifying Haskell assignment
  7. Dhall is now a template engine
  8. Translating a C++ parser to Haskell
  9. Use Dhall to configure Bash programs
  10. The Curry-Howard correspondence between programs and proofs
  11. Program JSON and YAML with Dhall
  12. Typed Nix programming using Dhall

2016 11

  1. Dhall - A non-Turing-complete configuration language
  2. Electoral vote distributions are Monoids
  3. Auto-generate service API endpoints from records
  4. list-transformer - A beginner-friendly ListT
  5. A command-line benchmark tool
  6. Data is Code
  7. Worst practices should be hard
  8. LambdaConf should reconsider its policy
  9. Auto-generate a command line interface from a data type
  10. State of the Haskell Ecosystem - February 2016 Edition
  11. From mathematics to map-reduce

2015 17

  1. Compile-time memory safety using Liquid Haskell
  2. How to contribute to the Haskell ecosystem
  3. Interactive and composable charts
  4. Haskell-native spreadsheets
  5. Explicit is better than implicit
  6. Basic Haskell Examples
  7. Polymorphism for dummies
  8. How to make your Haskell code more readable to non-Haskell programmers
  9. State of the Haskell ecosystem - August 2015
  10. break-1.0.0: A small library for breaking from loops
  11. optional-args-1.0.0: Optional function arguments
  12. The internet of code
  13. Haskell content spinner
  14. Mathematical APIs
  15. Algebraic side effects
  16. Use Haskell for shell scripting
  17. total-1.0.0: Exhaustive pattern matching using traversals, prisms, and lenses

2014 18

  1. A very general API for relational joins
  2. How to build library-agnostic streaming sources
  3. How to desugar Haskell code
  4. Morte: an intermediate language for super-optimizing functional programs
  5. managed-1.0.0: A monad for managed resources
  6. Equational reasoning at scale
  7. Spreadsheet-like programming in Haskell
  8. Model-view-controller, Haskell-style
  9. How the continuation monad works
  10. Scalable program architectures
  11. Worst practices are viral for the wrong reasons
  12. Introductions to advanced Haskell topics
  13. How to model handles with pipes
  14. Reasoning about stream programming
  15. pipes-http-1.0: Streaming HTTP/HTTPS clients
  16. pipes-parse-3.0: Lens-based parsing
  17. Streaming logging
  18. Shortcut fusion for pipes

2013 26

  1. Equational reasoning
  2. Lift error handling with lens-like syntax
  3. Test stream programming using Haskell's `QuickCheck`
  4. An all-atom protein search engine powered by Haskell
  5. How to reimplement the conduit parsing API in 50 lines of pipes code
  6. Manual proofs for the `pipes` laws
  7. Perfect streaming using `pipes-bytestring`
  8. pipes-4.0: Simpler types and API
  9. foldl-1.0.0: Composable, streaming, and efficient left folds
  10. Composable streaming folds
  11. Sometimes less is more in language design
  12. Statements vs Expressions
  13. The Resource Monad
  14. From zero to cooperative threads in 33 lines of Haskell code
  15. pipes-concurrency-1.2.0: Behaviors and broadcasts
  16. pipes-parse-1.0.0: Pushback, delimited parsers, resumable parsing, and lenses
  17. pipes-3.3.0: Folds and uniting ListT with Proxy
  18. Program imperatively using Haskell lenses
  19. pipes and io-streams
  20. pipes-concurrency-1.0.0: Reactive programming
  21. Defaults
  22. pipes-3.2: ListT, Codensity, ArrowChoice, and performance
  23. mmorph-1.0.0: Monad morphisms
  24. Comonads are objects
  25. Introduction to Haskell IO
  26. pipes-safe-1.0 - Resource management and exception handling for pipes

2012 30

  1. The Continuation Monad
  2. pipes-3.0 - A simpler, unified API
  3. pipes-2.5: Faster and slimmer
  4. "Hello, core!"
  5. Parsing chemical substructures
  6. pipes-2.4: Proxy transformers, extra categories, utilities, and benchmarks
  7. The MonadTrans class is missing a method
  8. The functor design pattern
  9. Concurrency = Lists of Kleisli arrows
  10. pipes-2.3 - Bidirectional pipes
  11. The category design pattern
  12. Code Example #1
  13. Free monad transformers
  14. First-class modules without defaults
  15. Purify code using free monads
  16. Breaking from a loop
  17. errors-1.0: Simplified error handling
  18. pipes-2.1 and index-core-1.0 - Indexed types
  19. Gadts
  20. Why free monads matter
  21. Conduit bugs
  22. pipes 2.0 - Pipe Finalization
  23. Scrap your type classes
  24. Haskell for Purists - Pipe Finalization
  25. Haskell for Java Programmers - Serialization
  26. Haskell for Engineers - Unicode
  27. Haskell for mainstream programmers 28
  28. Haskell for Mainstream Programmers - State
  29. Haskell for Intermediate Programmers - Algebraic Data Types
  30. Haskell for C Programmers - For Loops

2011 1

  1. Haskell for Mainstream Programmers - Code reuse