miniblog.

It's not easy to display a log file nicely in a browser. The file might be huge. Users expect to be able to link to lines. It might have colour or control codes. I've been pretty impressed with the GitHub actions UI, compared with other CI tools.

A 9V battery with wi-fi, so it can notify you when your smoke alarm is activated: https://getroost.com/product-battery.html I'm not sure I'd ever buy one, but it's an innovative way to build a noninvasive integration.

I have a couple of projects that have had a bunch of releases, but no v1.0 yet. In some respects a v0.33 release has more positive associations (a history of support and bugfixes) than a v1.0. I don't have a good solution.

Emergent behaviour of agents in early text adventure games (The Hobbit, released 1982): https://if50.substack.com/p/1982-the-hobbit

Languages with large ecosystems often develop interoperable languages. Scala, Clojure, F# and Typescript all benefit from compatible packages in the "primary" language. I think Rust will eventually see these too. What will they look

mrustc, the compiler for Rust written in C++, can now bootstrap rustc 1.39.0!

I've just added `and` to my toy lisp compiler: https://github.com/Wilfred/proper-compiler-hat/commit/af5c77e30ecbf4884e71c1177a086337aa74d237 It's just a plain function, not a macro or special form. Is that so bad? I've seen confusing uses of `and` with truthiness e.g. `(and maybe-nil (compute-default))` and I'd rather avoid that.

Thoughtful talk on the compile time, runtime and cognitive overhead of abstractions: https://www.youtube.com/watch?v=rHIkrotSwcc

Suffix syntax (e.g. foo.field or result_bar?) tend to provide a better IDE experience. Languages deliberately tailor features for this, e.g. Rust has .await. Is this a historical accident? I can certainly see how parsing unfinished suffix syntax is easier.

The optimal size for a hobby project seems to be medium. Big projects are more work to change. Little projects have too few opportunities for tinkering/minor refactoring.

C-Reduce has a fun concept of "interestingness", the predicate that you are trying to preserve whilst shrinking your program: https://embed.cs.utah.edu/creduce/using/ It's a great term: previously I've used the boring "property under test".

Have you ever wondered what happens if you hook up a lexer to a diff algorithm? I was feeling smart until I built it and saw the result. The longest common subsequence here is ( ) ( ) ; which is not terribly helpful. I'm going to have to look at proper tree diffing techniques.

When your codebase reaches a scale where you have bots automatically detecting and cleaning up dead code!

It feels really un-Emacsy (to me at least) to have a UI with different font sizes. It's totally supported, but it seem to run against the "everything is an interchangeable buffer of text" vibe.

Technical debt laundering: using a new feature as an excuse to do much-needed refactoring of your code.