Unformed Delta - inkhaven

Inkhaven is two events stabled into one

Thu, 30 Apr 2026 23:25:00 +0000

More to add here later + some editing, but the Closing Ceremony is about to start, so I’m going ahead and publishing this in its unfinished state for now!

Inkhaven is at least two different events stapled into one.

Commitment Mechanism

Publish a post every day or perish.

This is what attracted me to Inkhaven. I did The 6% Club to try to kick start a blogging habit, breaking through my fear of publishing. It kind of worked, but I still wasn’t able to publish the “harder pieces” I wanted to, and only published irregularly.

It worked, but not in the way that I expected. When I managed to publish before, I usually would sit down for a few hours, and end up with a finished post. For the posts I never ended up getting to, I assumed that my problem was just lack of motivation. With a hard deadline, I was certain I’d find the motivation to just grind out the harder posts.

Early on in Inkhaven I tried this, but either ended up failing and needing to pivot, or publishing an imperfect version of the idea inside of my head.

At first this made me feel like a failure. But over the course of the month, I found time to continue to revisit the same ideas.

Some of the ideas ended up eluding me the entire month¹. Other ideas just took longer than I expected². And sometimes I managed to publish a follow up that more clearly expressed the idea³. Publishing even something mediocre about the ideas I care about it easier to come back to them.

The most valuable lesson for me from the commitment mechanism was the value of setting aside time to write. Though I still get writers block for specific ideas, I find it a lot easier to sit down with the intention to write. And doing that helps me think about and research my more difficult ideas.

Writing Residency

Mentorship opportunities from celebrated writers, craft-honing workshops, and professional feedback.

Inkhaven provides an all you can eat buffet of feedback and workshops. This was strongly in tension with the daily publishing requirement for me. While the daily commitment mechanism was helping me overcome my perfectionism, the focus on better writing

Much more so than the previous cohort, it was very common for residents to publish at the last minute. I only managed to publish 5 posts before 6pm, and 9 before 10pm⁴.

Because I was consistently cutting it close, I was rarely in a position to get feedback on my posts before publishing them. When I did manage to, it helped me improve the quality of my posts or at least made me feel better about publishing.

I was also able to get feedback after publishing, but doing so usually felt less meaningful than getting it ahead of time. Because of the daily publishing requirement, it felt hard to justify going back and improving pieces that I had already published. I still found it useful to think about for my future writing. Plus, maybe I’ll go back and improve the pieces using the feedback after Inkhaven.

The workshops were lower friction, and I found them a useful distraction when I was having trouble focusing on writing.

I want to shout out Justis Mills for reading most of the blog posts for over half of the residents and giving higher level feedback on “Blog Gestalt”. I found this really useful for thinking about what direction I want to take my writing in the future.

I aspire to make UnformedDelta a public archive of my notes similar https://gwern.net. With Gwern’s encouragement, I managed to publish ~50 of my existing unrefined notes in addition to my daily posts in the latter half of this month, while overcoming my perfectionism that was holding me back from publishing them.

Community

I don’t have anything fancy sounding to put here.

There’s also kind of a 3rd event. Inkhaven is meetup of particularly writing oriented rationalist-adjacent writers.

I’m proud to have organized an evening playing board games, an outing to see Project Hail Mary, and a trip into the city to try Wildtype Salmon.

After failing to write “Code is communication”, I refined my thesis to “Code that is grown” but even after writing and trying to express my thoughts for hours I still wasn’t able to publish by the end of the month. (Stay tuned, I still want to write this post Inkhaven.) ↩
My article comparing WaniKani and jpdb.io which broke my The 6% Club publishing streak in September turned into a 3 article series: ↩
In some the introduction I wrote for programming language features (and optimizations) is follow up to an expressive programming language, more clearly expressing why I care about expressivity of programming languages. This still isn’t perfect but designing my ideal programming language is a big project. ↩
11 posts after 11:30pm, and 5 posts after 11:45pm, ouch! ↩

Why I'm building my own knowledge management system

Thu, 30 Apr 2026 06:50:00 +0000

File systems are the default categorization system for personal information on a computer. They make it easy to store files, notes, repositories, or whatever in hierarchies.

But hierarchies are limiting. A file can only exist at a single path¹.

Information in our minds doesn’t work like this. When speaking we reference the same entity in lots of different ways. Whether I have a layover in “San Francisco”, am going to “the airport” to fly home, or am entering “SFO” on Google Flights to book a ticket, I’m referencing the same entity.

Symlinks try to achieve this, but are fragile. If the original copy moves the symlink breaks and it is often isn’t easy to find the original copy.

Hardlinks are closer you map multiple paths to the same underlying data. However, hardlinks suffer from challenging edge cases, and generally don’t support directories.

The internet promised to solve this problem. Hyperlinks let people reference and categorize things however they want, right?

Take YouTube for example. It’s trivial to create a playlist of videos. If you want to categorize your playlists into a hierarchy, YouTube won’t let you do that, you just need to save them into a folder of bookmarks, or as links in a note.

Personal knowledge management tools like Notion, Obsidian, Logseq, or Roam Research attempt to make keeping bookmarks, links, notes, and research easier. These are great, I use my Zettelkasten of markdown notes with Obsidian sometimes².

These systems make me sad that I can’t associate metadata with arbitrary data — YouTube videos, Wikipedia articles, songs, and so on. Often they support fancier features like canvases, PDF clippings, and even database like rows, once you leave the domain of markdown, metadata starts being stored in private formats.

But I find it too risky to invest heavily into these systems, because building or maintaining a replacement that supports whatever custom features I use would be non-trivial.

What I really want is a personal ontology that operates like Wikidata. I hope that Web3 (not the crypto kind) projects like Solid are steps in this direction, but they’re still very immature, and I don’t want to couple myself to shifting standards.

Pretty much the only satisfying option seems to be building it from scratch myself.

When I was ~10 I remember my uncle asking me how I thought my brain worked. I described it as a point of light bouncing around a network of memories.

I’m hoping that someday I can bring that network of connections into the real world and interact with my computer the same way I interact with my mind.

I want to build a system in which my mind can wander safely to the information it wants, while knowing that it contains only information that I put or chose to be there. Perhaps someday I will achieve this dream.

↩
In practice, I mostly edit my notes using Neovim with custom language server for completion, transclusion, and jumping to links. ↩

For even a bad pause

Wed, 29 Apr 2026 06:51:00 +0000

Even a global treaty pausing all new training of frontier AI models, would leave a lot of room for existing models to continue to disrupt.

Our existing workflows weren’t designed with AI agents in mind and there’s abundant low hanging fruit for optimization. Every time I use Codex or Claude Code, I learn something new, and there’s plenty of things I just don’t have time to try.

Beyond code there’s plenty of other domains. Claude Cowork, the 10 folders of markdown files that caused the SaaSpocalypse, Claude Design, and more aren’t new models, they’re just harnesses for making it easier to work with existing ones.

What will be the impact on the economy once even our existing systems are widely adopted?

There’s a bunch of good things that we get for free by pausing AI progress.

The technology as it exists today would diffuse. The public lags behind what those of us interested in AI see.

More election cycles gives more opportunity for more informed and reasonable lawmakers to be elected. It also gives us room to negotiate and dream up better AI policies.

Nothing about pausing means AI safety research needs to stop. Who knows what novel problems or breakthroughs we might find in the next years?

Bernie Sanders and Alexandria Ocasio-Cortez’ AI Data Center Moratorium Act is just 1853 words — well worth reading all of.

Half of the bill is a sizzle reel of quotes from experts and industry leaders. The functional section of the bill is tiny:

154 words define “Artificial Intelligence Data Center”
287 words set the terms of the moratorium: no new AI data centers until AI is safe and built to be mutually beneficial for all Americans
275 words requisition various reports, and give the Secretary of Energy the power to verify that the moratorium is being followed
161 words ban the export of chips to countries not implementing similar measures

It’s a far cry from a global treaty. But it takes action now buying time and leverage to get a more comprehensive treaty implemented.

The bill cedes our largest advantage to China. Chinese models are only 3-9 months behind the US frontier, slowing down puts us at risk of losing the frontier.

This is costly, but perhaps might also serve as a signal. How can we better demonstrate our commitment to AI safety?

AI labs have frequently say that they want AI regulation. I also look at this bill as an invitation to the labs: help us figure out how to make AI mutually beneficial for society, and then you can go on building the data centers you want.

My largest quibble is with some of the most concrete details. To me one of the benefits of a sloppy pause are that it gives us time to contemplate what better legislation might look like. Enforcing that AI data center development be done with union labor while nice, seems far from necessary and I’d prefer a bill with less provisions about what is necessary to end the moratorium.

I’m confident that If Anyone Builds It, Everyone Dies. Will we be able to stop, or are the rewards from training better and better AI models too tempting? How long would it take us to stop even if policy makers unanimously agreed that we should?

Perhaps we should slow down as much as we can now.

First impressions of Lean

Tue, 28 Apr 2026 06:49:00 +0000

Since reading a perfectable programming language I started getting the itch to try actual dependently typed programming languages again.

Haskell is my favorite programming language because it provides one of the strongest type system but my most common frustrations in Haskell are from not having access to stronger types. Dependent types in Haskell are an active research project, but still far away. So when I’ve wanted more power I’ve had to make do with Coq (now Roqc) plus a little bit of dabbling in Idris and Agda.

In my usual fashion, I dove right in without reading the tutorial, hoping my experience with similar languages would take me far enough.

First steps

I started out by just typing out some definitions.

def x : Int := 1
def y : Type := Int
def z : x := 1

I was surprised that the last example failed to compile:

▼ 2:14-2:15: error: failed to synthesize instance of type class OfNat x 1 numerals are polymorphic in Lean, but the numeral 1 cannot be used in a context where the expected type is x due to the absence of the instance above

This was fixable by using:

def y : x := (1 : Int)

I had a bit of trouble figuring out that Eq.refl needed an argument, but nicely _ allows inferring the type:

def x : Type := Int
def y : Int := 1
def z : x = Int := Eq.refl _

Of course, I later discovered that there’s a rfl tactic that allows avoiding this boilerplate.

I also ran into some other surprising sharp edges:

def decrement : Nat -> Nat
  | 0 => n
  | 1 + n => n

Doesn’t compile but this does:

def decrement : Nat -> Nat
  | 0 => n
  | n + 1 => n

It’s cool that it’s possible to pattern match on syntax like this, but it’s annoying that it’s a bit inconsistent.

Lambda Calculus Confluence

Basic syntax out of the way, I started implanting the simply typed lambda calculus.

Debrujin indexes:

inductive Term where
  | var : Nat -> Term
  | lam : Term -> Term
  | app : Term -> Term -> Term

Of course, I can’t implement a full interpreter because I can’t solve the halting problem, so I implement single step semantics:

def step_cbn (t : Term) : Maybe Term :=
  match t with
  | Term.lam _ => Maybe.nothing
  | Term.var _ => Maybe.nothing
  | Term.app (Term.lam body) t2 =>
      Maybe.just $ shift_down 0 (subst 0 (shift 1 0 t2) body)
  | Term.app t1 t2 => match step_cbn t1 with
    | Maybe.just t1' => Maybe.just $ Term.app t1' t2
    | Maybe.nothing => match step_cbn t2 with
      | Maybe.nothing => Maybe.nothing
      | Maybe.just t2' => Maybe.just $ Term.app t1 t2'

There’s several different evaluation orders for the simply typed lambda calculus. I recall that Church-Rosser theorem proves that when a term converges, it always converges to the same term regardless of evaluation order.

inductive ConvergesCBN : Term -> Term -> Type where
  | value : step_cbn v = Maybe.nothing -> ConvergesCBN v v
  | step  : step_cbn e = Maybe.just e' -> ConvergesCBN e' v -> ConvergesCBN e v

inductive ConvergesCBV : Term -> Term -> Type where
  | value : step_cbv v = Maybe.nothing -> ConvergesCBV v v
  | step : step_cbv e = Maybe.just e' -> ConvergesCBV e' v -> ConvergesCBV e v

noncomputable def cbv_implies_cbn_convergence :
  ConvergesCBV e v -> ConvergesCBN e v := sorry

I didn’t end up making that much progress. I also tried big step semantics, but that ended up not being much easier, and after Codex and Claude found several holes in my definitions, that made the theorem unprovable as stated, I gave up.

Ecosystem

Lean’s ecosystem still feels fairly immature.

parser libraries: I use megaparsec/attoparsec in Haskell
- fgdorais/lean4-parser: this provides decent parser combinators, but none of the fancier recovery or error handling offered by megaparsec.
C bindings are possible, but you’ll likely need to implement them yourself
effects: monad transformers are the default way of representing effects; usable, but a far cry from Haskell’s wide variety
tooling quite good, lean --server provides top good tooling even in Neovim. I appreciated this compared with using

A meetup

People writing Lean seem to be very dedicated to verifying things for verifications sake. I love that. I think this is the standard for what should be demanded of our libraries and tools.

I’m curious to try diving into metaprogramming, which I hear is pretty good, but that’ll have to wait for another day.

7 Haskell effect systems

Mon, 27 Apr 2026 06:40:00 +0000

An overview of Haskell’s effect systems that I’ve used.

This was written pretty hastily for Inkhaven. I hope to return to this and add more details later.

IO

The simplest “effect system” in Haskell that has been around since the beginning. As an effect system, this just divides functions into pure and impure.

This has a little bit of a special status because Haskell’s main function is declared main :: IO (), meaning that all other effect systems must eventually delegate to IO.

mtl

Monad transformers allow extending a monad with extra capabilities. This allows creating large stacks of monad transformers with a bunch of different effects, e.g. StateT AppState (ExceptT AppError (ReaderT Configuration IO a)).

This quickly gets unwieldy because effects from lower layers need to be lifted through the upper layers.

mtl adds type classes for common kinds of effects, e.g. MonadState, MonadError, MonadReader which can be implemented generically to avoid needing to lift through monad transformers.

As an added benefit this also makes it easier to test functions. A function requiring only MonadState can just as easily be implemented using a pure function.

The worst part about mtl is that declaring new effects requires implementing every relevant type class when declaring a new effect. Conversely, implementing a new type class requires adding an implementation for every relevant monad transformer.

This is called the \(n^2\) instances problem. It’s possible to work around this for the most part with Haskell: the OVERLAPPABLE MonadTrans instance pattern, but it still requires more boilerplate than other effect systems we will see.

ReaderT IO / unliftio

ReaderT IO makes the observation that most custom effects can easily be represented by IO anyways.

Instead of implementing MonadState with StateT it can just as easily be implemented by manipulating an IORef in IO. Why use separate exceptions from ExceptT when IO exceptions can achieve the same purpose?

Because extra parameters are still annoying to pass around, it’s common to still use the ReaderT type to remove boilerplate associated with passing them.

Finally, unliftio makes it easier to express higher order operations like bracket. Because ReaderT isn’t stateful it’s possible to “unlift” it, which makes it possible to represent more generic error handling operations.

It remains a little bit hard to define custom effects and reinterpret them flexibly with this approach. To implement a pure version of an effect, you still often end up stuck with the complexity of monad transformer stacks and the \(n^2\) instances problem.

polysemy

Algebraic effect systems attempt to get rid of the boilerplate involved in defining custom type classes for effects once and for all. They also try to implement fancier algebraic effect patterns.

Based on the weaving pattern introduced by Effect Handler’s in Scope, this library is based on free monads, keeping track of an open union of capabilities.

fused-effects

fused-effects is pretty much like polysemy but uses type classes instead of an open union. This provides a bit more efficiency at runtime trading off for greater boilerplate.

in-other-words

in-other-words is the most creative effect system I’ve seen so far. It provides a really ergonomic interface by providing granular primitive effects that encapsulate higher order effect patterns. User defined effects can be translated into these effects, which makes gets rid of some of the complexity imposed by polysemy and fused-effect’s weaving pattern.

In practice its biggest flaw is its lack of documentation, and the raw complexity of the effects it offers. Some of its effects are extremely general, and reasoning through how they can be instantiated into something useful is really hard.

effectful

Effectful is the application of ReaderT IO / unliftio’s lessons to algebraic effect systems. It implements everything in terms of IO, but wraps it up in a neat interface that makes it easier to work with.

It’s also able to provide a reasonably safe pure interface.

This is currently my favorite effect system for new projects.

500mg Niacin

Sun, 26 Apr 2026 03:38:00 +0000

Experience: Temp full body sunburn

“flushing”

Niacin is a B-vitamin. Sunburn effects lasts 30-60 mins.

You will feel: warm, cozy, itchy.

you’re not having an allergic reaction it’s supposed to be like that

-Handwritten on 500mg Niacin bottle at Lighthaven

I recommend it.

It didn’t feel like a sunburn to me. You know the feeling of a limb falling asleep? It was like that but only 20% as strong, and a full body experience.

Taking it was unexpectedly mindful. I was afraid it would be unpleasant enough to incapacitate me, but to the contrary, it connected me to my bodily sensations.

As I edit this post, I just took another.

One tip: no matter how itchy you get, resist itching.

Disclaimer: This is not medical advice. Read the label and exercise appropriate caution.

Experience Log

19:04 took 500mg capsule of Niacin

19:09 maybe barely starting to feel sore

19:12 feeling a mild warmth in my stomach, right where the esophagus connects, soreness is definitely a symptom and starting to intensify

19:16 a bruise on my shoulder from a few weeks ago is throbbing, very similar sensation to getting a shot

19:18 I’m noticing pain in my lower back that I wasn’t noticing earlier, I’m starting to feel more alert

19:19 I’m going to drink some Rooibos tea

19:20 the pain in my stomach has become a bit sharper, it reminds me a little bit of the feeling of a whole Cheez-It going down my esophagus, but in my whole stomach

19:20 I’m starting to be aware of pain in my upper thigh, just a little bit of tingling

19:21 I’m noticing that my hands are a bit sore while I’m typing

19:21 I’m feeling a tingly itchy sensation first on the back of my neck, and now on the front of my chest

19:22 I also am starting to feel the itchy sensation on the top of my hands

19:22 my foot is throbbing a little bit, kind of like I pulled a muscle

19:22 I’m noticing that my eye muscle is just a bit sandy, and starting to be a bit itchy

19:23 Soreness has extended into my fingertips

19:25 my hands are definitely a bit sore, as though I typed for a long time already

19:26 Rooibos tea again. Drinking doesn’t really feel any different

19:29 I’m feeling quite itchy all over my face, even inside of my nostrils

19:32 I’m starting to notice that my body kind of feels a bit like after constricting blood flow (“fell asleep”), particularly noticing this sensation in my upper left thigh and around my elbows

19:33 Swallowing is starting to be a little bit more noticeable, my throat feeling a bit more bloated

19:33 My left foot is continuing to throb a little bit more

19:34 I’m noticing my tailbone a bit more

19:34 I feel a little bit lighter, and picking up my mug feels a little bit more ethereal

19:35 I’m just starting to notice itchiness on my collarbone, itchiness on my hands feels more intense

19:36 Noticing itchiness inside of my ear for the first time

19:36 My right index finger is pretty itchy

19:37 I finished my Rooibos tea

19:38 My ears tearing up a bit

19:38 I’m pretty itchy under my right arm pit

19:38 My left eye that was previously feeling sandy is now particularly itchy, and starting to water

19:39 My right eye is also watering, it feels like I’ve been using it for a long time

19:39 Inside my left elbow is now particularly itchy

19:40 My muscles are starting to feel a bit sore all over the place

19:41 My right cheek is also feeling pretty tingly now

19:41 I’m noticing tingling around the crown of my head

19:41 My heartbeat is more noticeable

19:42 The top of my head is now on fire with tingling, my hands are feeling very similar

19:42 I can feel my neck muscles when I move them, my neck is starting to tingle quite strongly

19:42 My heartbeat in my neck has fairly high intensity, and the tingling now feels more like fire

19:43 I’m starting to get quite warm, especially on the back of my hands, my ears, and the back of my neck for now

19:46 I feel like my body is humming

19:47 My upper arms are also starting to feel quite warm

19:47 All over itchiness has given way to buzzing/tingling/burning

19:47 My hands are noticeably redder

19:47 I’m feeling some pressure inside of my ear canal like changing altitude

19:48 My calves feel cooler than usual, but it’s possible that it is just because the rest of my body is flushed

19:53 I got up and walked around a bit while trying to convince people to take Niacin, when sitting down I noticed tingles in my upper thigh

19:53 My body is pretty much completely warm now, in a ring around my lungs

19:54 Redness still hasn’t spread too far past my wrists

19:57 I now feel like I need to move around to feel the Niacin

19:57 My eyelids feel a little bit sandy, closing my eyes feels little bit like it does when I have red-eye or my eyes are particularly dry after watching TV for a long time

19:58 Tingling now only really happens when I move around, just a little bit of tingles wherever I move something

19:59 The Niacin is now feeling very normal, maybe just a bit of tingling

20:02 I feel warmth in my stomach in particular again

20:02 Noticing pressure in my ears

20:16 I’m starting to get a bit of chills because my body is changing in temperature

20:19 My skin feels slightly flaky or something when I touch it, I can imagine how itching could quickly intensify the experience and make it much more unpleasant

20:20 My stomach is starting to feel a bit sore, my eyes are watering again

20:22 My eyelids definitely still a bit heavy

20:27 Starting to feel chills all over as the Niacin wears out

20:28 Noticing the tiniest bit of a headache in my right temple

20:32 I still get a little bit light headed and tingly, and a bit stomach achy, starting to feel fairly cool, some amount of cold chills are happening all over my body

20:34 I feel like the symptoms are pretty much all over, just some chills, and a tiny amount of tingles in my belly and tops of my feet + when I move around vigorously

20:44 Symptoms are almost completely gone by now, only a little bit of warmth in my stomach left

20:55 I still feel a little bit light headed as an aftereffect

21:31 My only noticeable symptom at this point is a little bit of a stomach warmth and a little bit of soreness

21:40 I still feel a little light headed especially when I walk around

I don't want your skills

Sat, 25 Apr 2026 04:03:00 +0000

I often notice people advertising their custom skills as a solution to your agentic programming problems. They’ll provide you some genuinely useful advice, then cap it off by offering you skills that operationalizes their advice.

I found the failure modes and tips identified in Software Fundamentals Matter More Than Ever insightful. I never thought about having a glossary of shared vocabulary to make communication with AI agents more effective. AI agents outrunning their headlights by doing way too much autonomously provides metaphor for my common experience of having AI agents do underspecified work. Focusing on building deeper modules with a lot of functionality hiding behind a small interface, is a pattern I’ve been thinking around, but haven’t yet been able to put words to.

But following the insight with skills that will “solve” the problem for you, is the equivalent to giving a tutorial on how to implement nanoGPT and then capping it off by saying: but you can just use https://chatgpt.com¹.

Yes, it does seem helpful to have my AI agent /grill-me — asking detailed questions instead of providing corrections to plans reflecting a fundamental misunderstanding of the problem over and over again. Of course, I’d love to /improve-codebase-architecture modularizing my codebase. But running a skill won’t help you understand how it works.

These skills probably work in simpler codebases. But simpler codebases are also the best environment to understand the principles behind the skills and learn how to build them yourself. And without understanding the principles, you won’t necessarily understand that or how the skill failed in a more complex codebase.

I’ve noticed this pattern before in discussions with other engineers. I explained to another engineer: just giving Claude Sonnet 4.5 our feature flag documentation plus a list of files that needed to modify was enough for it to make the changes fully autonomously. They responded by asking if I could package that up into an /add-feature-flag skill.

I didn’t see the point. The skill would just be 1-2 sentences of text and a list of files that needed to be modified in order to make changes to the feature flags. The skill would encapsulate nothing but the fact that this task was now easy to automate.

My recommendation is to engage with content that offers you skills, but try to learn the principles behind the skills instead of using the skills themselves. Try to prompt your AI agent to solve the problem yourself.

Doing this, I’ve found that after a while, I want to abstract my prompt into my own skill.

I remember reading an article about adding comments to plan documents inline, instead addressing them one by one in Claude Code’s prompt. I liked this technique and after trying it, ended up building produced this skill. Though I’ve provided a link, I recommend not clicking it.

Downloading skills won’t make you a good AI engineer. Understanding why they work and operationalizing the principles behind them will.

Andrey Karpathy does not do this. ↩

programming language features (and optimizations)

Fri, 24 Apr 2026 00:12:00 +0000

My dream programming language would be able to express the syntax and semantics of every other programming language idiomatically. In this framing a good programming language would have few builtins¹ but would still be able to manifest many more specific features as library definitions.

I take a very general view of features. Optimizations are included in this list because in order practically exploit the fact that one programming can express the semantics of another, it must be able to match its performance². Thus optimizations are more or less “features” for a programming language; they help determine what the programming language can practically be used for.

Maximizing which features are expressible as part of the standard library, maximizes what users are able to rewrite. If users don’t like the features the language provides in its standard library they can write their own. Such a language is maximally flexible for users.

Of course, actually using custom built features comes at the expense of interoperability with the broader ecosystem. But I think it is better to give users the choice of what they need to interoperate with, rather than artificially restricting it to guarantee good interoperability³.

With a sufficient floor of metaprogramming capabilities, any feature could be implemented as a builtin or as part of the standard library. I collect this list so that I can sort/consider which features are more primitive and which are the most useful to be able to reprogram. Each programming language features thus becomes both a test and an axiom for programming language expressivity.

Meta note: I went through and made a bunch of these notes public. There’s still a lot of links that aren’t public. A lot of the pages themselves are stubs and have highly varying levels of research/detail/revision put into them.

meta programming

Features enabling and enabled by metaprogramming. In some sense these are the most important because they’re what enables implementing features in terms of each other. I’m also interested in evaluating which of these features are the most irreducible.

Features providing metaprogramming ability:

Features implementable by metaprogramming:

embedded query languages, e.g. LINQ
EDSLs in general get better as metaprogramming is better supported by a programming language

Features kind of like metaprogramming in terms of the expressiveness they provide:

working with (generally monadic) effects

This category encapsulates language features that make working with effects easier:

do notation
monad extraction
idiom brackets
lifted versions of boolean operators
dedicated syntax for specific effects
pattern match failures are an effect / parsers via pattern matching
the runtime system should be deeply tied to effect system
Implicit Conversions Between Effects
See also: Effects

working with coeffects

method (/with) notation: relatively undeveloped, but interesting
coeffects can act as interpreters for effects: vague but interesting, method notation has some extra ideas for this
See also: coeffects / consumer effects

concurrency / distributed programming

Working with data

pattern matching:

Accessors / key paths / lenses:

generic/uniform syntax for arbitrary n-functors/lenses

optimizations

evaluation order

types

Primitive types:

basic types: closed vs open types
- structs/record types
- row types (i.e. extensible records)
- coproducts / variants / enums
- polymorphic variants
- recursive (µ) types
- nominative (ν) types
- algebraic data types
dependent types:
- dependent product
- dependent sum
- interval / cubic type theory / univalence
- cumulative universes
linear types

Broader concepts:

type inference (+ list of methods) / elaboration
completeness checking
subtypes / subtyping
structural types
gradual typing / migratory typing
pure functions, mutability
- ST monad

Weird/highly non-standard stuff:

dual type operator
co-completeness checking
self types
Lambda with receiver
probably not practical or interesting: representing types as just namespaces

typeclasses / traits

Typeclass features:

standard library

The main purpose of a standard library is to define the shared vocabulary that all programs can coordinate around. Because more primitive features are implemented as part of the “standard library”, it places an even larger burden on the design of its standard library.

Properties the standard library should have:

layers of primitiveness: that allow giving up progressive amounts of interoperability for the ability to redefine larger parts of the language
facilitate migrations between standard library types to make the decision to include/not-include various things as unimpactful as possible

Must haves:

type safe dates/times/durations
OSString type
theorem proving:
- explicitly unordered containers

Things to consider adding to a type class hierarchy beyond what Haskell has:

modules / scoping

lifetimes / scoping

RAII
defer statement
deconstructors / deinitializers
lifetime annotations ala rust
borrow checker
move semantics (e.g. consume in Swift)

control flow

implementing control flow as library functions
loops:
- for loops
- foreach loops
- while loop
- until loop
- do while loop
- unconditional forever loop
- do while with block loop
if statements
switch / case analysis statements
allowing statements to be used as expressions
defer statement
try { … } catch { … }

Dis-preferred:

code location / relocating code

removing indentation from nested code structures
unit tests can be co-located with code
get calling function location
defer statement is useful for putting de-initialization next to initialization logic

testing

unit tests can be co-located with code
inspection testing
unit tests can be discovered at compile time / in the IDE without necessarily running arbitrary code

My Neovim configuration

Thu, 23 Apr 2026 06:02:00 +0000

I use Neovim for 95%+ of my writing, both prose and code. I originally picked Vim over Emacs because I liked its modal text editing. Over the following years I’ve honed it to my preferences, building up over ~4000 lines of configuration. I’ve flirted with switching to Emacs with evil-mode for a better plugin ecosystem, but Vim is too deeply engraved in my muscle memory to move away from.

Lua vs Vimscript

I don’t have a strong preference for Lua/Vimscript. Historically, Vimscript was the only language for configuring Vim¹ . I generally assume that I will always use Neovim nowadays. Neovim makes Lua a first class language for configuring Vim. In fact, in addition to bridging all of Vim’s APIs to Lua, new APIs (such as vim.lsp) are often only offered through Lua.

Rewriting all of my configuration in Lua just to lose support for Vim completely seems like a waste of time, so I still keep a lot of my configuration in Vimscript. I tend to prefer Vimscript’s syntax for mappings and autocommands to Lua’s anyways. Lua’s feels a little bit too verbose, and is harder to understand quickly in my opinion.

Neovim makes it very easy to mix Lua and Vimscript, which makes it possible to maintain interoperability even while maintaining configuration in both.

Escape key

Because the escape key is far in the top left corner of modern keyboards, mapping jj or jk to escape in insert mode is fairly common. I used to do this. At some point I learned that Vim and most Vim plugins for other text editors treat <C-[> as escape. Rebinding caps lock to control system wide, made it possible to press <C-[> with my two pinkies simultaneously. An escape key mapping was previously the only configuration I truly couldn’t do without so this has the added benefit of letting me use Vim-mode plugins in other editors (or Vim itself through SSH) well enough without needing to configure them.

Modularization

Because my config has grown quite large, I need to keep it modularized for it to stay maintainable.

Mostly I rely on the runtime directory structure which allows loading a lot of files flexibly:

init.vim has logic that needs to run before other configuration, plus a bunch of stuff that I’ve been too lazy to move elsewhere
plugins.vim is sourced from init.vim and loads plugins. I have this separated out because I use a lot of plugins
ftsyntax directories for autocommands improving file type detection, or adding new
ftplugin/after directories house language specific configuration to prevent needing to define autocommands for them
autoload directories store “library” functions that I use from other pieces of my configuration
lua/my modules serve the same purpose, but for Lua code
plugin directories for configuration insensitive to loading order

Plugins

I still use vim-plug to manage my plugins because it works well enough, and well written plugins lazy load by design, thus not requiring anything fancier.

I’m a heavy plugin user so I’ll only go through my favorite plugins. The most notable category is plugins that add generic cross language features to the editor without conflicting with default keybindings:

tpope/vim-repeat makes it possible to use . with custom actions provided by other plugins. This should really just be a built in Vim feature.
tpope/vim-sleuth makes indentation behave sanely by default.
tpope/vim-surround adds a truly essential ys/cs/ds text editing verbs for adding/changing/deleting surrounding text
tommcdo/vim-exchange provides a very useful cx text editing verb for swapping text
wellle/targets.vim adds extra text objects (e.g. for function arguments) and makes existing text objects more flexible (e.g. selecting the next instance of a text object if you aren’t already inside of it)

I use overcache/NeoSolarized for my color scheme because it’s the most modern true color Solarized color scheme that I could find. I use nvim-lualine/lualine + nvim-tree/nvim-web-devicons to make the UI a bit prettier.

For more IDE like features, I mostly rely on language servers, but some extra support is provided by plugins.

hrsh7th/nvim-cmp for autocomplete though I’m considering switching off this because it is now unmaintained
LuaSnip for snippets

Other than that, there’s pretty much just a bunch of syntax plugins.

I’ve also factored bits of my config as plugins (e.g. vim-magic-link-paste) plus a syntax plugin for moss-lang. A way to keep it easy to edit these even though they are no longer in my dotfiles repo is to branch on whether the repository exists on my computer:

if isdirectory($HOME.'/src/vim-magic-link-paste')
  Plug $HOME.'/src/vim-magic-link-paste'
else
  Plug 'lehmacdj/vim-magic-link-paste'
endif

This way, vim-plug won’t clone them, and I can edit the source and have it stay up to date automatically.

Making changes to configuration

I find being able to quickly navigate to a specific bit of configuration that I want to tweak important so that I’m able to fix problems / add new configuration without breaking my flow.

I use mappings that open up a configuration file in a split:

" Edit vimrc
nnoremap <Leader>ev <Cmd>split $MYVIMRC<CR>
" Edit plugins
nnoremap <Leader>ep <Cmd>split $VIMHOME/plugins.vim<CR>

My favorite is my one for editing language specific tweaks, it directly opens up the appropriate file for the current file type:

" Edit filetype file
nnoremap <expr> <Leader>ef '<Cmd>split '.$VIMHOME.'/after/ftplugin/'.&filetype.'.vim<CR>'

Language specific tweaks

I most frequently edit my language specific configuration when I’m learning a language, or using a language I haven’t edited in a while. Most commonly, language specific configuration is overrides for my global vim config like not converting tabs into spaces for Makefile or setting up soft wrapping for Markdown. I also include custom keybindings that are only relevant for particular file types, like publishing a note from my wiki.

Wiki specific stuff

For my notes specifically I have a custom language server that I use providing autocomplete + title transclusion from random ids + go to definition for navigating between notes. I rely heavily on conceal to keep markdown syntax hidden while reading notes in Neovim.

There also were remote plugins. But they require installing language runtimes, and have a more limited API than exposed through Vimscript. ↩

Metadata patterns not accounted for by music apps

Wed, 22 Apr 2026 06:34:00 +0000

I hesitated a lot when first getting into anime idol music. I was definitely a little self-conscious that the album art can get fairly suggestive.

13+ album art with characters wearing swimsuits

But more importantly I feared its complexity would render my music cluttered and unnavigable. I mostly engaged with my music navigationally as opposed to searching. I liked to select a genre, an artist within that genre, and then pick out an album within that genre to listen to. Instead of staring at an empty search field, wanting music for focusing, I could pick Soundtrack, evaluating that Joe Hisaishi (i.e. Ghibli Soundtracks) was chiller than John Williams (Star Wars), then Spirited Away, deciding Princess Mononoke was too gloomy and I needed a little more whimsy.

Idol music would seriously upset this balance. Many tracks were only available as singles, and — GASP — would need to learn to organize my music into playlists. But as listening to nightcore music on YouTube transitioned into watching Love Live! Sunshine’s Aqours’ lyrics videos, eventually I decided that the sanctity of my navigable music library would need to be broken, and started adding μ’s and Aqours music to my music library.

When I got tired of manually importing metadata I discovered beets, a command line tool that automatically tags music with MusicBrainz metadata. This kept my music organized, but once I was listening to a huge number of artists and franchises¹, navigability in my music player started to break down, none the less.

None of these matter when listening to an algorithm generated playlist on Spotify or YouTube Music. But regardless, I still have a strong desire to navigate — I think it helps me feel more intentional about my music listening.

Classical music once had a lot of similar problems, e.g. the same piece but separate recordings different orchestras/conductors. Eventually, Apple implemented better navigability through specialized services like Apple Music Classical.

These are the metadata patterns I want custom support for when Claude is able to build me a custom music app.

Character vs Voice actor

Each character is portrayed by a voice actor. Voice actors often also publish music as themselves, and sometimes the same voice actor portrays multiple characters². If I want to listen to music by a particular singer because I like their voice, I’d love to be able to jump to all of the music by the voice actor. YouTube Music/Spotify usually doesn’t even show the voice actor (it depends on the franchise).

Deep hierarchies

Because idol anime franchises are primarily a vehicle for selling merchandise for a huge number of characters, they end up with tons of characters sorted into different units (groups of characters that perform together). Idolm@ster is a particularly illustrative franchise³: it contains at least 8 sub-franchises, of which Idolm@ster Shiny Colors contains 8 units, of which Noctchill contains 4 members.

Overlapping hierarchies

Groups aren’t even static a lot of the time. In Idolm@ster Million Live, pretty much every new single features a never-seen-before unit. Fortunately, when credited as artist these units usually include list of their members, which makes it possible to find songs containing a particular character through search.

So fans are confident their favorite character will get a new song eventually, albums/singles are often sorted into series⁴. I often wish I could navigate between albums in the series while listening to music.

Tracks you typically don’t want to listen to

Albums often bundle tracks that don’t make to listen to typically. Most albums include karaoke tracks without vocals, plus there’s often also drama tracks with character story. These are sometimes interesting to listen to, but I don’t typically want my music listening to be interrupted by a podcast.

Beyond that there’s often variants of the same song: solo versions, short versions (i.e. ~1:30 versions used in rhythm games), and live recordings. MusicBrainz’s data model actually works fairly well for variants, linking recordings to a single song, but I haven’t found a music app that allows navigating these relationships.

Music apps aren’t able to filter these out for general listening, but still expose them when desired.

nayuta, Idolm@ster, Love Live!, Project SEKAI (especially More More Jump! and Nightcord at 25:00) are my favorites. I’ve even gone to a couple of live shows in Japan. ↩
Ruby Kurosawa and Airi Momoi’s voice actor are both Ai Furihata. ↩
https://project-imas.wiki is organizes all this complexity neatly. ↩
For example there are 7 albums in THE IDOLM@STER SHINY COLORS “CANVAS” series (just numbered 01 through 07). ↩