2025-06-26
Box combinators
mmapped.blog/posts/41-box-combinators.htmlIn functional programming,
combinator libraries refer to a design style that emphasizes bottom-up program construction.
Such libraries define a few core data types
and provide constructors—functions that create initial objects—and combinators—functions that build larger objects from smaller pieces.Combinators enable the programmer to use intuitive visual and spatial reasoning
that’s vastly more powerful than linear language processing.
As a result, solving problems with combinators feels like playing with lego pieces.
2025-06-18
You can use `fzf` to review git commits
jvns.ca/til/fzf-preview-git-commitsI just learned that
you can use it to review a git commit like this and I thought that was really
cool.
2025-05-30
The PGP Problem
www.latacora.com/blog/2019/07/16/the-pgp-problemWhy do people keep telling me to use PGP? The answer is that they shouldn’t be telling you that, because PGP is bad and needs to go away.
2025-05-15
Writing that changed how I think about PL
bernsteinbear.com/blog/pl-writingEvery so often I come across a paper, blog post, or (occasionally) video that completely changes how I think about a topic in programming languages and compilers. For some of these posts, I can’t even remember how I thought about the idea before reading it—it was that impactful.
2025-04-29
No-engine gamedev using Odin + Raylib
zylinski.se/posts/no-engine-gamedev-using-odin-and-raylibGames can be made in many different ways. Many games are made using big, general purpose game engines such as Unity and Godot. I enjoy using the Odin Programming Language combined with Raylib.
Odin is a C-like programming language and Raylib is library for drawing graphics, checking input and playing sounds. So it’s just a program that uses a simple library, no engine!
There are no objectively best ways to create games.
2025-01-09
if got, want: A Simple Way to Write Better Go Tests
mtlynch.io/if-got-want-improve-go-tests2024-12-17
GBA From Scratch With Ferris
lokathor.github.io/gba-from-scratch2024-11-04
Writing secure Go code
jarosz.dev/article/writing-secure-go-codeSecurity testing starts with understanding vulnerabilities. The CVE website lists known software flaws. The OWASP Top Ten highlights common weaknesses. With this knowledge, we can improve our Go development. This article shows how to put in place robust practices. They are to: fuzz inputs, verify dependencies, and use static analysis tools (SAST).
2024-09-16
Wayland: i3 to Sway migration
anarc.at/software/desktop/wayland2024-08-08
More than 200 orphaned Debian packages moved to git, 216 to go
www.hungry.com/~pere/blog/More_than_200_orphaned_Debian_packages_moved_to_git__216_to_go.html2024-06-28
Advanced Bash-Scripting Guide
tldp.org/LDP/abs/html/index.html2024-06-26
A reckless introduction to Hindley-Milner type inference
reasonableapproximation.net/2019/05/05/hindley-milner.html2024-06-24
Deriving Dependently-Typed OOP from First Principles -- Extended Version with Additional Appendices
arxiv.org/abs/2403.06707The expression problem describes how most types can easily be extended with new ways to produce the type or new ways to consume the type, but not both. When abstract syntax trees are defined as an algebraic data type, for example, they can easily be extended with new consumers, such as print or eval, but adding a new constructor requires the modification of all existing pattern matches. The expression problem is one way to elucidate the difference between functional or data-oriented programs (easily extendable by new consumers) and object-oriented programs (easily extendable by new producers). This difference between programs which are extensible by new producers or new consumers also exists for dependently typed programming, but with one core difference: Dependently-typed programming almost exclusively follows the functional programming model and not the object-oriented model, which leaves an interesting space in the programming language landscape unexplored. In this paper, we explore the field of dependently-typed object-oriented programming by deriving it from first principles using the principle of duality. That is, we do not extend an existing object-oriented formalism with dependent types in an ad-hoc fashion, but instead start from a familiar data-oriented language and derive its dual fragment by the systematic use of defunctionalization and refunctionalization. Our central contribution is a dependently typed calculus which contains two dual language fragments. We provide type- and semantics-preserving transformations between these two language fragments: defunctionalization and refunctionalization. We have implemented this language and these transformations and use this implementation to explain the various ways in which constructions in dependently typed programming can be explained as special instances of the phenomenon of duality.
2024-06-19
Pimalaya
pimalaya.orgOfficial website of the Pimalaya project.
2024-06-18
Comparing Objective Caml and Standard ML
adam.chlipala.net/mlcomp2024-06-17
How I learned Haskell in just 15 years - duckrabbit solutions
duckrabbit.tech/articles/learning-haskell.html2024-06-14
litterbox - IRC logger
git.causal.agency/litterbox/aboutpounce - IRC bouncer
git.causal.agency/pounce/about2024-06-13
Category Theory in Context
math.jhu.edu/~eriehl/context.pdf2024-06-12
My experience crafting an interpreter with Rust
ceronman.com/2021/07/22/my-experience-crafting-an-interpreter-with-rustLast year I finally decided to learn some Rust. The official book by Steve Klabnik and Carol Nichols is excellent, but even after reading it and working on some small code exercises, I felt that I …