bonzini

They definitely were used back in the day, now the x87 isn't used much at all.

Irregular spacing is a feature, not a bug, unless you're playing Schönberg and friends, because being able to quickly separate thirds, fourths and fifths is much more important than being able to grab octaves and even more important than identifying individual notes.

Your brain anyway doesn't have to work on "it's on a line therefore it's one of C D E F# G# A#", it very quickly learns to work on "it's on adjacent lines therefore it's a third apart" when you read sheet music. Two notes both on lines or both on spaces are part of a triad; "two notes very far apart, one on a line and one on a space" is almost always an octave, and you can grab that intuitively in standard music notation even without reading the two notes one by one; whereas smaller intervals are simply too far apart on isomorphic notation.

Same for understanding when your scale is changing or you're deviating from the normal fingerings (key signature vs. inline accidentals). And all this ignores the fact that G# and Ab aren't even played the same on some instruments, at least at an advanced level, and chromatic notation cannot capture that.

Because the two clefs are symmetrical around middle C. Line "6" of the bass clef is line "0" of the treble clef. They are not two different clefs, the are two halves of the same 11-line staff.

> some of the time I'd be thinking about start/stop times rather than durations

It's actually a combination of both. Bar lines give you a bigger multiple, beams give you a smaller one (typically 1/4 or 2/4). Only within each 1/4 or 2/4 do you have to think in deltas.

Sometimes you need G and the note to its right, so you want to call the latter a variation on A (A-flat). Sometimes you need A and the note to its left, so you want to call the latter a variation on G (G-sharp). They are the same note but they have a different function. It's not an idiosyncrasy, rather, when it works it's more efficient because it describes two things at the same time. It doesn't work perfectly for many cases: Misirlou, the Simpson's theme, anything in whole-tone or octatonic scale, but those are the exceptions in practice, just like some things compress better than others.

It is suboptimal even for the blues scale, but not too much and in fact that shows another benefit of giving two names to a note. The blues scale is mostly a variation on the pentatonic scale; the A#/Bb note in a minor E blues scale is used mostly as an intermediate note. So if you're going up to a B you can write that note A# because it is working like an A, while it you're going down to an A you will write it Bb because it is working like a B.

Likewise for chords. If I see E Ab B, E-A points me at a suspended chord, not a major chord, which would be wrong. Whereas if I see E G# B, it is clearly a triad.

It is not computable, because for high enough n you can't prove that you got the right integer.

And also you can prove that if a sequence a_n is always larger than BB(n) for some n, that sequence a_n is also not computable.

That is because if you could compute BB(n) for arbitrary n, you could run a Turing machine for BB(n)+1 steps and if it hasn't stopped yet then you know that the input corresponds to a machine that never halts. So it's impossible to compute BB(n) for arbitrary n, because doing so is equivalent to the halting problem.

Even for very small n you can create Turing machines where it's incredibly hard to prove that they halt: for n=25 you can create a Turing machine that stops only if the Goldbach conjecture is false. Though that isn't enough to prove it's not computable.

Not really: the program still needs to be fixed, but fixing the compiler ensures that this unsound behavior never happens again to anyone. So you have two bugs to solve (vs C++'s one bug) but then you kill an entire class of unsoundness bugs just by recompiling.

"q.0" is not really needed, it's a struct with unnamed fields. Here is the same with named fields:

  struct Q<T: 'static> { pub x: Option<T> }
  ...
  let l = String::new();
  let mut q = Q { x: None };
  q.x = Some(&l);