arthurdenture

> Something that surprised me is that [1] is of a minor key, but the solfege marks are for the relative major

Major and minor keys use the same shapes / solfege system. The major scale is "fa, so, la, fa, so, la, mi, fa", while the minor scale uses the same syllables but starts on la. This means that the shapes always represent the same intervals (i.e. pattern of whole and half steps) whether a song is in a major or minor. It's hard to describe but makes sense when singing.

One limitation is that the shapes are really only useful for singing, not for instrumental music. They also would not be meaningful for music that switches keys or that isn't tonal (i.e. isn't in a particular key at all). So they are a very good fit for what you might think of as "church music" (at least written before the 20th century), but for other settings they would be either meaningless or a hindrance.

That's one reason shape notation never caught on; another reason is that the notation was introduced by publishers of American sacred music and not by, say, music conservatories.

Is it possible that many of those uses predate the current zoning? There are numerous buildings in Chicago that would not be permitted by their current zoning.

Extremely useful .gitconfig snippet:

  [alias]
   git = !sl

catches e.g. `git git status`, which I run shockingly often.

You're comparing regional rail terminal stations, which serve many lower-frequency lines, to subway platforms, which typically serve a single higher-frequency line. (2-10 minutes between trains.) That's the scenario where a mezzanine is less useful.

I completely agree with the more general point, that consuming external data requires a validation layer. But oh boy do I have feelings about class-validator.

Here's what it looks like to correctly annotate an array of objects with with class-validator and json-schema annotations:

  @ApiProperty({ type: Foo, isArray: true })
  @ValidateNested({ each: true })
  @Type(() => Foo)
  @IsArray()
  items: Foo[];

It's not just that you have to define everything in triplicate, it's that the failure mode for forgetting any of the above is to silently not validate your data. Unless you're very careful, you don't get the safety benefits that were the whole point of using class-validator in the first place.

If I were starting from scratch, I would instead consider either io-ts or a solution that involves a code generation step, where this entire category of risk is avoided.

The alternative would be to write a side effect inside your `render()` function, which is illegal -- it breaks the new Concurrent mode rendering, which can call render() speculatively.

I mean, I see why it's intuitively unappealing to you, but there are perfectly good reasons for the design.

Interactions can be extremely negative without making the news.