miniblog.

One interesting consequence of the rise of LLMs: there's more demand for tools that handle untrusted input. Arbitrary HTML+JS can be safely run in a browser. Lean can check an arbitrary proof. Are there other tools in this family?

One interesting consequence of the rise of LLMs: there's more demand for tools that handle untrusted input. Arbitrary HTML+JS can be safely run in a browser. Lean can check an arbitrary proof. These work really well with an LLM that can be wrong, but sometimes gives exactly what you want. Are there other tools in this family?

I love how the CommonMark Spec has a test suite that's just a JSON array. It's really easy to test a library for compliance, and I've seen developers nerd-sniped into full compliance. https://spec.commonmark.org/0.31.2/spec.json

Learning software development through playing and contributing to a MUD:

It's really satisfying to use a profiler for the first time on a project. I always find a big performance win with only a small code change. It's never the code that I expected to be slow, however!

On thinking of books like software, treating them as evolving artifacts, and URLs versus paper book publishers:

I've released difftastic 0.62! In this release: * Updated parsers for Bash, C, C++, C#, CSS, Go, Haskell, HTML, Java, JavaScript, JSON, Julia, Lua, Objective-C, OCaml, PHP, Python, Ruby, Scala, TOML, TypeScript and XML. * Obligatory crash fixes.

I've been building an 'extract function' refactor feature. It's surprisingly nuanced. Where do you put the extracted function? Once you've done the static analysis, what order do you use for the parameters?

Some delightful examples of good compiler error messages in the latest Gleam release:

I really like pattern matching in Rust, but I find myself using it less and less. `if let` and `let ... else` require substantially less indentation, and I often use them for Option values. I don't miss this syntactic sugar in OCaml though. Maybe it's just because OCaml has a 2 space indent, unlike Rust's 4 space indent?

I'm playing with DOT output for debugging syntax trees from difftastic. Here's an F# snippet, the Debug representation, and the DOT rendered as an image. I'm pleased with the information density on the graphic, but we'll see how often I end up using it.

I'm implementing an interpreter, and wondering how often I should check for interruptions (e.g. Ctrl-C). I don't want to spend too much CPU time checking whether I've been interrupted, but I also want slow programs to stop promptly. It's tricky.

It took me way too long to realise that Arc<Mutex<T>> is basically a way to create multiple &mut T references (with runtime constraints). This means that you can use plain &T and &mut T in the vast majority of your code. Most code doesn't need to care there's a mutex.

It's incredibly hard to explain adversarial problems to users. I see gamers sincerely asking "why doesn't the publisher just fix the cheater problem?". This is exacerbated by the fact that sharing too many details of anticheat can make the problem worse.

I'd heard the conventional wisdom that UX research states that mice are more efficient than keyboards, but turns out there's virtually no research on this!