The Curious Engineer

All blogs / Haskell

blog.vmchale.com

blog.vmchale.com

Programming

HaskellFunctional / PL theoryCompilersPerformance / optimization

’17’18’19’20’21’22’23’24’25’26
Posts
84 from 12 Sep 2017 to 14 Mar 2026
Posting
now and then (2 in the last year)
Kind
personal blog
Feed
http://blog.vmchale.com/rss

2026 2

  1. Fast Arcsine in Apple
  2. Doubly-linked Lists in Haskell

2025 6

  1. Python Is Truly Dynamically Typed
  2. Array Offsets from Indices Are Multibase Digits
  3. Universally Quantified Types Are Not Templates
  4. Performance of Sharing
  5. Matching R's Performance Takes Nothing Special
  6. A Proper X86 Assembler in Haskell Using the Escardó-Oliva Functional

2024 15

  1. Strides Are Scans
  2. QuickCheck With Shape Types
  3. Softmax in Apple As an Example of Explicit Rank
  4. Optimizing Array Code With Inferred Type Information
  5. Lessons from Writing an Array Compiler II
  6. Extracting Compiler Version from Compiled Binaries Using Jacinda
  7. Three Languages
  8. Better Vim Tags With Jacinda
  9. Laziness, A.k.a. Computer Science
  10. Unix As an IDE II
  11. The Unix Command-line As an IDE
  12. Utility of AWK
  13. Sed Examples in Jacinda
  14. Num Instances for ASTs
  15. Linear Types for Manipulating Expressions in the Lambda Calculus

2023 10

  1. Linear Effects Handling
  2. C Converges to Intuitionistic Logic
  3. Logic Programming Doesn't Work in the Real World
  4. Egison's Pattern-matching via Logic Programming
  5. Lessons from Writing an Array Language Compiler
  6. Compiling Functions to Jumps
  7. Basic Blocks À La Appel
  8. Elliptic Fourier Series in Apple
  9. Rosetta
  10. Follow-up: Typed Elliptic Fourier Series

2022 15

  1. Infelicities With Traditional Compiler Architecture on X86
  2. Calling System Functions in a JIT
  3. Row Types in Haskell
  4. Typing APL: Elliptic Fourier Series As an Example
  5. APL Is Truly Different
  6. Imitating Cloc With Jacinda
  7. Names in Haskell Compilers
  8. Finding Cruft in Patches With Jacinda
  9. Generating Other-extensions for Cabal Files
  10. Transparent Programming
  11. Awk, Mawk, Gawk Performance
  12. Deduplication on the Command Line
  13. Generating Vim Tags With Jacinda
  14. Unix Meets APL
  15. Processing Compiler Errors in Jacinda

2021 10

  1. The !-modality Is a Comonad
  2. Linting for Concatenative Programming
  3. The Interesting Part of Monadic Effects
  4. Compiler Technologies behind Logics
  5. Shoelace Iteration
  6. Adequate J Matrix Performance
  7. Dimension Is a Functor
  8. Artisanal Neural Networks
  9. Tricks for Compilers in Haskell
  10. Laconic J

2020 3

  1. Keto Is Terrible for Weight Loss
  2. Strict Data Structures Do Not Improve Performance
  3. Type-safe Pointers in ATS

2019 4

  1. Using Templates in ATS
  2. For Loops and GCC vs. Hand-optimized Rust
  3. Performant Perceptual Hashing Using HIP and Repa
  4. Computer Science Is a Superset of Mathematics

2018 13

  1. Projective Programming
  2. Curry vs Uncurry on Hackage
  3. Benchmarking the Edit Distance
  4. A Look at the Packages on Hackage
  5. An Old English Name Generator in Madlang
  6. Mendler-style Catamorphisms
  7. Co-(Elgot Algebra)s in the Wild
  8. Using ATS Libraries in Haskell
  9. Cross-compiling ATS
  10. Some Examples and Non-examples of Monads
  11. ATS in Haskell Packages
  12. Euler's Totient Function in ATS
  13. Speeding up Math With ATS

2017 6

  1. Advanced Control Flow
  2. Linear Types in ATS
  3. Matrix Algebra in Idris
  4. Computing Catalan Numbers Using Dynamorphisms
  5. Performant Elgot Algebras
  6. Computing Continued Fractions With Apomorphisms