We still think of apps and websites separately. I've only ever added one website to my home screen.

I'm not if this is due to limited support, or just users not thinking about websites as 'installable'.

Another kernel written in Rust!


Rust tooling/docs must be making operating system development more accessible, as there is an impressive number of these projects.

Measuring the effectiveness of debug info in gcc and clang by comparing how often a variable is known to be defined vs how often you can access it:


Sometimes metaprogramming (macros etc) is a useful technique for refactoring, simply because you can try and then discard different designs: blog.metaobject.com/2018/11/re

(I've certainly written then thrown away macros when writing Lisp!)

The Web Design Museum is a fascinating set of screenshots of early websites:


The esoteric language BF was designed to be a language where you could write a very small compiler. Self-hosting BF is significantly harder though.

If we designed languages to minimise total LOC for a project plus its compiler, what would end up with?

When your blog is already hosted by GitHub, you can even have your comment backend on GitHub too! utteranc.es/

(I've decided to trial it on my blog: wilfred.me.uk/)

Persisting editor and mental state across debugging sessions is really hard. It's often easier to have a single, longer debugging session.

Ever wondered what the (interactive) function does at the C level of Emacs? It's just been ported in Remacs! github.com/Wilfred/remacs/pull

It's easy to use lots of different versions of Rust nightly. Remacs requires a specific version. The autogen.sh scripts are admirably defensive, to help you get on the right version!

I'm not sure about teaching OO in terms of shape hierarchies or animal species hierarchies. It might help intuition, but doesn't reflect typical usage IME.

If you did model animals in an OO style, you'd be more likely to have base classes or interfaces like IFarmable, IHuntable.

the internet depends on people like this

My most memorable example is CSS.

Specificity, box model, browser differences, and a unique set of debugging tools. A lot of dev experience isn't relevant. It's hard.

As a backend dev it was very tempting to ignore CSS. It's proved to be very handy since: the web is everywhere.

jq also fits in this category for me. I encounter large JSON blobs regularly.

jq has its own unique syntax to learn, and a notion of a stream of JSON values.

Every time I learn a little more, I find it easier to slice and understand JSON data!

I've encountered it a few times.

Learning bash had all sorts of pitfalls. Writing `X = 1` rather than `X=1`. Default values with `${foo:-bar}`. Ignoring errors with `|| :` or catching them with `set -e` and pipefail.

Bash is so ubiquitous that this knowledge has been valuable.

There are technologies that are arcane, time consuming to learn, but extremely helpful to know.

Have you encountered any that fit these criteria?

The latest Read Eval Print Love discusses rules engines!


I'm also interested to learn that Clojure has a unification library in its stdlib.

There's a seedy underbelly of refactoring tools that work most of the time.

For example, grep and sed can perform function renaming. For a small codebase, this works well (you can test or eyeball the result).

Ideally we'd only use fully correct tools, but simplicity often wins.

Mid stack inlining in Go: go.googlesource.com/proposal/+

(Interesting implementation details: the inliner is AST based, how to preserve existing stack reflection APIs, and how to show good tracebacks.)

Show more

Follow friends and discover new ones. Publish anything you want: links, pictures, text, video. This server is run by the main developers of the Mastodon project. Everyone is welcome as long as you follow our code of conduct!