Wow looks at that CUPS code and tell me with a straight face there aren’t 5 more.similar vulnerabilities waiting to be found…

Yeah this sort of stuff reads a lot like philosophy nonsense babble to me. I think maybe it isn’t nonsense like the philosophy stuff but it sure would be nice if they gave a few concrete examples to demonstrate that.

The Background link does make sense… but it also seems kind of trivial. Giving the idea of mapping programming language semantics to an existing domain like mathematics a complex name like “denotational semantics” just serves to make it harder to understand and more impenetrable.

Generally I think naming things should make them easier to understand, e.g. naming “a number that represents the address of another object” a “pointer” is great, because it literally is something that points to another thing.

Denotational semantics is a terrible terrible name. I’m not even sure it should have a name. Can we call it “mathematical semantics” (if you map to maths)?

(I may be totally wrong here because I’m not a denotational semantics expert, but I have at least tried to follow it before getting whacked in the face with a load of philosophy.)

Reminds me a lot of REST. The core idea of REST is very simple, but it’s also really hard to learn what that idea is because so much of it is hidden behind bullshit philosophy.

Actual blog post.

Great accomplishment. I think we all knew it must happen like this but it’s great to see real world results.

I think this is probably actually the most useful part of the post:

Increasing productivity: Safe Coding improves code correctness and developer productivity by shifting bug finding further left, before the code is even checked in. We see this shift showing up in important metrics such as rollback rates (emergency code revert due to an unanticipated bug). The Android team has observed that the rollback rate of Rust changes is less than half that of C++.

I think anyone writing Rust knows this but it’s quite hard to convince non-Rust developers that you will write fewer bugs in general (not just memory safety bugs) with Rust than with C++. It’s great to have a solid number to point to.