llimllib's notes

ear training

2026-06-12T14:35:02.244Z

https://tonedear.com/

A set of free ear training exercises

What canceled my go context

2026-04-06T12:59:38.799Z

https://rednafi.com/go/context-cancellation-cause/

Excellent article walking through one of the finer points of context usage: figuring out what cancelled your context.

Gives examples of how to make sure you can always figure it out.

brandur starts with the same context.WithTimeoutCause, but gives a different recipe, describing a function timeoututil.AttributedTimeout that takes a closure and handles context deadlines from within that closure

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

ty

2026-06-07T15:38:45.958Z

https://docs.astral.sh/ty/

An extremely fast Python type checker and language server, written in Rust.

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).

Ratboys on KEXP

2026-06-02T01:49:12.793Z

Their most recent album is really good, I've been listening to it a bunch.

I also haven't mentioned how much I've been listening to MJ Lenderman, who's got a similar sound and has played with Ratboys I think?

"Wristwatch" is the standout from his "Manning Fireworks", but I love a bunch of the songs

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

recharts

2026-05-19T18:19:50.901Z

https://recharts.github.io/
https://github.com/recharts/recharts/

A composable charting library built on React components

Built on top of SVG elements with a lightweight dependency on d3.js submodules.

Can We Retain the Benefits of Transitive Dependencies Without Undermining Security?

2026-05-19T02:50:11.599Z

let me outline where I would one day like our software to go. I would like to run software, built from multiple components (i.e. dependencies of some kind), in such a way that:

Components are isolated from each other as much as possible.

Each component only has the minimum permissions it needs.

For example, I don’t want my image decoding component to have network access, or the ability to access RAM with passwords in; but I do want my network downloading component to have network access, and I do want to be able to create a component that can manage and use passwords...

In other words, I want to split software up into mutually distrusting dynamic “cells”, like processes, but with the ability to communicate more easily, frequently, and cheaply. The communications between dynamic components would need to be tightly specified, and if a component fails to communicate in exactly the required way, other components should ignore all interactions.

Lawrence Tratt

yt-transcribe

2026-05-19T02:35:38.045Z

My script for using yt-dlp, ffmpeg, and mlx-whisper to create a transcript of a youtube talk

https://github.com/llimllib/yt-transcribe

Adaptive mode for yt-transcribe

2026-05-19T02:32:31.111Z

I added adaptive mode to yt-transcribe, my shell script for transcribing youtube talks: https://github.com/llimllib/yt-transcribe

Adaptive mode looks for scene changes, rather than just generating a thumbnail every N seconds. Here's an example, generating a transcript for Steve Klabnik's talk "Steel, Rust and Truth"

That talk motivated the work, as I wanted the script to capture all of the slides - it was hard to follow without that.

The actual change is here