miniblog.

Most of the gradual type systems I've seen are targetting existing languages: you want to interact with existing libraries that don't have type annotations. Are there many greenfield languages with gradual types? It's a useful technique in other cases, such as refactoring.

I *love* that GitHub's Ctrl-F search still gives you the option of going back to the browser text search! It's reasonable to override Ctrl-F in a website, but sometimes you really do want the normal browser tooling.

Programming languages aren't sports teams: you don't have to choose one to root for! They're more like music genres, you can enjoy more than one. I avoid language stickers for this reason. I don't want my identity to be "I'm an X programmer".

I've released difftastic 0.40! In this release: * Faster, more efficient diffing courtesy of QuarticCat :) * `--list-languages` is now more helpful * Better support for older distros

It's weird that some language communities have a thriving wiki, and others simply do not. It doesn't seem to relate to community size, nor docs quality (e.g. the Emacs manual is great), nor the age of the language.

I don't care what your project's test coverage is, but the fact that you're measuring it is a great sign.

Discoverability on Mastodon is hard: I find myself using hashtags more to discover people. I'm not aware of any suggestion tools here ("you follow A and B, you might want to follow C"). I'm getting a stream of new followers, which is a great way of finding people, but some users have no toots at all yet.

I suspect every programming language eventually becomes dated. As soon as you commit to 1.0, you will have design decisions that (with hindsight) are mistakes, and you can't fix them. Design best practices change over time too. Immutability is a more common default now.

Too many new languages describe themselves as "clear syntax" or "strong types". These features aren't very interesting, and are often subjective. It's better to say what's unique, e.g. "a PL for IoT on boomerangs" would certainly be interesting!

Lisp is the only language I've seen where it's idiomatic to have some locals scoped to the *middle* of a function. It's a consequence of let blocks. It's neat, but I rarely miss it elsewhere. I'm happy with "scoped from here to the end of the block" in e.g. C or Rust.

Using Miri, the Rust interpreter, as a profiler to find bottlenecks: https://medium.com/source-and-buggy/data-driven-performance-optimization-with-rust-and-miri-70cb6dde0d35

On the challenge of measuring spam prevalence externally, because historical data tends to be cleaner:

I've released difftastic 0.39! In this release: * Erlang support! * Added `--check-only` and `--exit-code`, making difftastic useful in shell scripts * Fixed some nasty display and file detection bugs

One nice property of key-value punning is how it reduces the risk of accidental reordering. Point { x, y, z } is less verbose than Point { x: x, y: y, z: z } and less error-prone than Point(x, y, z).

I'm slightly surprised that Rust has implemented the Default trait for booleans: https://doc.rust-lang.org/src/core/default.rs.html#205 The default is false, but it feels very arbitrary. Maybe it makes more sense next to integers, where the default value is 0.