llimllib's notes

Unicode's Transliteration Rules Are Turing-Complete

2026-07-09T11:32:52.794Z

Lovely little article where Nicolas Seriot shows how you can use Unicode's rewrite rules, which are intended for converting characters from one language to another, to execute arbitrary programs.

via bsky

World Cup Visualizations

2026-07-08T19:40:47.683Z

https://wc26.bogachev.fr/index.html

For an example from a spectacular game, check out the Argentina vs Egypt match

By Alevandre Bogachev, via Francis Gagnon

statistics that live in your SQL

2026-06-24T12:57:42.693Z

https://kolistat.com/blog/the-stats-duck-v0-6-0/

Announcement of a really neat duckdb extension called the-stats-duck (KoliStat/the-stats-duck) which puts statistical functions inside duckDB.

It then goes on to add some visualization in duckdb sql, by serializing out to vega-lite format, á la ggsql (which the author calls out on news.yc as a direct inspiration)

My favorite bit is the function meta() as a table-valued function, allowing you to select from it:

SELECT
  column_name, kind, n_missing , n_distinct, mean, median, stddev, top
FROM meta('penguins');

I don't use R, but I think that's basically the same as its summary() function.

It also builds in LOESS regression and embeds an R-like specification language for it:

SELECT *
FROM lm_summary(
  'penguins'
  , formula := 'body_mass_g ~ flipper_length_mm + bill_length_mm'
);

Also, neat job building the demo into WASM and serving it as part of the page, strong work.

Parse, don't validate — In a Language That Doesn't Want You To

2026-06-30T13:23:37.073Z

https://cekrem.github.io/posts/parse-dont-validate-typescript/

A practical exercise walking through how to "Parse, don't validate" in plain typescript. I did not know about the "brand" technique, so that was neat to learn.

I generally like to do a light version of this, but I also often find it frustrating and brittle when people go down the FP-style "All Information Must Be Encoded in the Type System" rabbit hole.

When it comes down to it, I'm a caveman who prefers to bash rocks instead of teach math

(One note: I suffered terribly at one job that had extensive Zod types with the slow compilation time they caused. "Parse, don't validate" isn't free, and shouldn't be treated as such. This does not mean you should not use it, just that one needs to properly weigh the costs, and that it can often be difficult to do so ahead of time)

Prism - An Impure Functional Language With Typed Effects

2026-06-30T12:08:05.81Z

This is Prism, a proof of concept functional compiler I've been working on for the last three years, built around modeling effects with modern types inspired by the intellectual lineage of OCaml 5, Haskell and Koka. The big idea of the last five or six years of functional programming is that effects are real, effects are fine, and the interesting question is not how to avoid them but how to put them in the type system and then optimize them until they cost nothing.

Stephen Diehl

This seems like basically a way to write Haskell-ish functional code, but avoid the monadic morass that can result.

It's a neat-looking language that lets you avoid types a lot more often than similar languages, apparently by including "effects" in the type system (warning: I'm way out over my skis talking about this topic)

I've stopped worrying that I'll ever need to use a functional programming language "for real" in my career, but this one seems different and neat.

https://github.com/sdiehl/prism

The interpreter sits at the bottom of a proof chain whose top is Lean 4

Very cool! Lean is something I've played with, enough to get through a bit of The Natural Number Game, but this is a whole other level I can't even comprehend.

via mjd

A data-driven normal for the Spain temperature chart

2026-06-24T13:10:35.97Z

https://dominicroye.github.io/blog/spain-temperature-normals-openmeteo/

The author goes through his many choices for building the above chart, and gives the code and shows how they gathered the data for it.

Thoughtful and thorough.

The Coming Loop

2026-06-23T13:21:38.669Z

Present-day models tend to produce code that is too defensive, too complex, too local in its reasoning. They avoid strong invariants. They add fallbacks instead of making bad states impossible. They duplicate code, invent bad abstractions, and paper over unclear design with more machinery. Worse though: I so far see very little progress of this improving. If anything, on that front it feels to me that we might even be making steps in the wrong direction. At least for my taste, present-day hands-off harnesses like Claude Code with ultracode produce worse code than what we were producing last autumn. That’s because Claude Code, with Fable for instance will be working uninterrupted on a problem for thirty minutes or more, when previously the process would have been much more human in the loop.

Furthermore it’s well understood that models tend to observe some local failure and add a local defense. Karpathy mentioned how they are “mortally terrified of exceptions”. In systems with important invariants, especially persisted data formats or core infrastructure, the right fix is not “handle every malformed case.” The right fix is to make the malformed case unrepresentable or impossible to write in the first place. Yet even with a lot of manual steering, that type of code does not come out of LLMs naturally, and even if the code comes out naturally like that, they will still attempt to handle now impossible errors.

Armin Ronacher

This has been my experience as well. I prefer using pi in large part because it doesn't hide those loops from you, so I at least more often notice when the machine is doing something stupid, or doing something local that ought to be global.

The whole piece is well worth reading, as you might guess from my long pull quote.

The scariest part to me is that we become dependent on these new machines in new ways. Software has always depended on tools. I remember the time when I had to pay for compilers. These new tools are a flashback to times where creating software came with real costs. But now it’s no longer a one-time payment, it’s a constant dependency. Not just a dependency on a filled wallet, but also a cognitive dependency.

This is also my #1 fear

XML and JSON in 2026

2026-06-19T14:04:52.169Z

Irrespective of the current uptake, and seen as an experiment, XML has been a success. It proved that:

You can have a data interchange format that is radically independent of your computer architecture, operating system, programming language, and application.

The only sane text standard for modern computing is Unicode, which in practice is affordable and reasonably straightforward to use.

Prior to 1996, neither of these things were widely believed. The only “interoperable” data format was ASN.1, which is horrible and lacked quality software support. The resistance to Unicode was significant and widespread, and adoption was disappointing. Today, #1 and #2 above are the (low) bar to entry for any data packaging technology.

Tim Bray

How's Linear so fast?

2026-06-08T01:41:20.781Z

https://performance.dev/how-is-linear-so-fast-a-technical-breakdown

They use a sync engine such that user changes are optimistically applied
They carefully load only the JS/CSS that is required at the start, and preload as much as possible
They chunk the application very granularly, and use a service worker to preload chunks

This made me interested in how their sync engine works, so I'm watching this talk:

I've previously mentioned electric, which implements a sync engine with CRDTs
I've previously mentioned Replicache in Offline-First Landscape and Real-time Collaboration with replicache and fly-replay
- a news.yc commenter points to this doc about how replicache works
- zero, who I guess are the company that supports replicache, have this doc which points to alternatives to it
news.yc points to this reverse-engineering of the linear sync engine

Thoughts on starting new projects with LLM agents

2026-06-07T15:29:24.348Z

https://eli.thegreenplace.net/2026/thoughts-on-starting-new-projects-with-llm-agents/

Eli shares his thoughts on starting new projects with LLMs.

Many of his preferences align with mine; especially around the importance of developing a test suite that actually works. Agents are happy to give themselves huge and useless test suites if you let them test themselves.

One thing he didn't mention is static tooling - I try to load up my LLM-using projects with every possible static tooling to improve the code the LLM writes. In Go, I use golangci-lint with extra tools enabled (ex). In python, I use ruff and ty, and in typescript I use typescript-go and biome (though oxlint seems to be gaining popularity; I've not tried it but should).

But it happened

2026-05-30T02:39:09.133Z

Why doesn't [Eric Schmidt] see that the thing that people are afraid of with artificial intelligence is not just technology in the abstract. It's that they saw what Eric Schmidt and his cohort of Silicon Valley decision makers did the last time they were given a new technology to guide. They saw them build the dark pattern version of it. They lived it. And now they are terrified that they're going to do the same dark pattern thing on top of the next new technology.

Casey Muratori in a video breaking down Eric Schmidt's commencement speech to the University of Arizona, bringing in context from the first part to consder more deeply why the audience might have been boing him in the second part when he brought up AI.

via lobste.rs, which links this transcript if you'd rather read.

I find AI a really useful and exciting technology for me, personally, but I share significant fears about where the people in control of it (for whom, it should be noted, I could be broadly said to work) will drive it.

Decyphering the Business Card Raytracer

2026-05-28T13:25:25.919Z

https://fabiensanglard.net/rayTracing_back_of_business_card/

Fabien breaks down how a lovely short program works

C isn't a programming language

2026-05-28T12:50:15.698Z

My problem is that C was elevated to a role of prestige and power, its reign so absolute and eternal that it has completely distorted the way we speak to each other. Rust and Swift cannot simply speak their native and comfortable tongues – they must instead wrap themselves in a grotesque simulacra of C’s skin and make their flesh undulate in the same ways it does.

C is the lingua franca of programming. We must all speak C, and therefore C is not just a programming language anymore – it’s a protocol that every general-purpose programming language needs to speak.

Aria Desires

demoscapes

2026-05-26T01:46:34.414Z

https://demoscapes.org/

Very cool interactive visualizations of a variety of statistics.

In this graph, the two dark blue smudges, with my mouse pointer on the second one, indicate excess male mortality in world wars I and II.

There are many more statistics available, and from many different countries' data.

via bsky, where Saloni Dattani provides this interesting annotated version

50 hours to draw some lines

2026-05-26T01:41:37.597Z

https://www.dougmacdowell.com/50-hours-to-draw-some-lines.html

The author talks about their process for learning some basic drafting techniques, culminating in this hand-drawn graph:

A very cool dive into how to accomplish it, an interesting look into how much effort these scientific diagrams must have taken int he past, and a good chance to question how and why we spend our effort.

via news.yc