blog
Python Is Truly Dynamically Typed
Array Offsets from Indices Are Multibase Digits
Universally Quantified Types Are Not Templates
Performance of Sharing
Matching R's Performance Takes Nothing Special
A Proper X86 Assembler in Haskell Using the Escardó-Oliva Functional
Lessons from Arthur Whitney's Style
Strides Are Scans
C Is Not Suited to SIMD
QuickCheck With Shape Types
Performance of High-level Languages
Softmax in Apple As an Example of Explicit Rank
Optimizing Array Code With Inferred Type Information
Streaming Compression/decompression in Haskell via Laziness
Lessons from Writing an Array Compiler II
Statically Typed Interactive Array Languages: a Manifesto
Testing Is Orthogonal to Correctness
Functional Compilers That Stand Toe-to-toe With C's Object Files: a Manifesto
Extracting Compiler Version from Compiled Binaries Using Jacinda
Three Languages
Better Vim Tags With Jacinda
Theorems vs. Algorithms
Laziness, A.k.a. Computer Science
Unix As an IDE II
The Unix Command-line As an IDE
Utility of AWK
All Programming Languages Should Have Linear Types
Sed Examples in Jacinda
Num Instances for ASTs
Linear Types for Manipulating Expressions in the Lambda Calculus
Linear Effects Handling
C Converges to Intuitionistic Logic
Logic Programming Doesn't Work in the Real World
Egison's Pattern-matching via Logic Programming
Lessons from Writing an Array Language Compiler
Laconic Haskell
Compiling Functions to Jumps
Basic Blocks À La Appel
Elliptic Fourier Series in Apple
Rosetta
Follow-up: Typed Elliptic Fourier Series
Infelicities With Traditional Compiler Architecture on X86
Calling System Functions in a JIT
Row Types in Haskell
Typing APL: Elliptic Fourier Series As an Example
The Moral Imperative to Type Imperative Languages With Linear Logic
APL Is Truly Different
Don't Bother With LLVM for Hobby Compilers
Imitating Cloc With Jacinda
Names in Haskell Compilers
Finding Cruft in Patches With Jacinda
Generating Other-extensions for Cabal Files
Transparent Programming
For Loops Considered Harmful
Awk, Mawk, Gawk Performance
Deduplication on the Command Line
Generating Vim Tags With Jacinda
Unix Meets APL
Processing Compiler Errors in Jacinda
Q Performance for Data Science
The !-modality Is a Comonad
Linting for Concatenative Programming
The Interesting Part of Monadic Effects
Compiler Technologies behind Logics
Shoelace Iteration
Adequate J Matrix Performance
Dimension Is a Functor
Artisanal Neural Networks
Tricks for Compilers in Haskell
A Gloss for Linear Logic
Laconic J
Compiler Performance in Haskell
Keto Is Terrible for Weight Loss
Strict Data Structures Do Not Improve Performance
Lazy Streaming With a C API
Type-safe Pointers in ATS
ATS As a Systems Programming Language
Development Tools for Haskell
Using Templates in ATS
For Loops and GCC vs. Hand-optimized Rust
Performant Perceptual Hashing Using HIP and Repa
Computer Science Is a Superset of Mathematics
Compiler Optimizations for Functional Languages
A Case Study in Dhall for Package Configuration
There Are Two Monadic Zygomorphisms
Termination Checking Is Theorem Proving
Projective Programming
Performance Implications of FP in ATS
Variations on a Theme II
Curry vs Uncurry on Hackage
Polyglot Is the Fastest Code-counting Tool Available
Benchmarking the Edit Distance
Edit Distance in ATS
Benchmarking Code Produced by Different Versions of GHC
Uncanny Haskell
A Look at the Packages on Hackage
An Old English Name Generator in Madlang
Mendler-style Catamorphisms
Co-(Elgot Algebra)s in the Wild
Using ATS Libraries in Haskell
Cross-compiling ATS
Some Examples and Non-examples of Monads
ATS in Haskell Packages
Using Dhall in ATS
Calling Haskell from ATS
Rewriting the Coreutils in ATS
Fast Directory Traversals in Rust
Euler's Totient Function in ATS
Speeding up Math With ATS
Permutations in Idris
Advanced Control Flow
Rewrite It in ATS
Reading a File in ATS
Using Haskell on the Frontend
Linear Types in ATS
Practical ATS
Where Imperative Languages Fail
The Right Tool for the Job
Matrix Algebra in Idris
Xiphophyllous Trees
Computing Catalan Numbers Using Dynamorphisms
Functional Pearl: Integer Partitions and QuickCheck
Variations on a Theme
Performant Elgot Algebras
Why Lenses Work
Computing Continued Fractions With Apomorphisms
Computing Compactness of Congressional Districts