Possibly sacrilegious question, but what difference does it make here? The JavaScript that’s delivered to users is essentially a binary, and the source code to compile that binary is available. That’s how it’s done in other software, too.

And with PeerTube being under the AGPLv3, this also holds even when someone modifies the version of PeerTube that they host, as they have to make those changes available.

Are those written in React?

That’s probably because the term “centrist” is completely useless. Humanity doesn’t even agree on a definition of “left” and “right”. So, you can’t make it your political identity that you’re in the middle. In the middle of what?

I mean, are we sure the font used in that screenshot isn’t monospace?
If you compare the two lines after the first comment, the columns seem to align quite well (though I cannot read some of that)…

Can’t say I would know whether my blue connectors actually go fast…

Another fun USB discovery I recently made: For some reason, my USB headset doesn’t work when I plug it into my laptop …except when I plug it into one particular USB port. There it works reliably. I have no idea how or why.

Interesting analysis, but the conclusion is a bit contrived. People often prefer type safety over performance. When it doesn’t impact type safety, they still prefer better performance over worse performance. That’s not a contradiction.

You could argue that introducing the EnumSet-type isn’t worth it for that, but I don’t really see a disadvantage from having it.
Those who know about EnumSet, can use it. Those who don’t know it, can continue to use HashSet. And if you don’t know about EnumSet, but find one in a code base, it’s not hard to guess what it does…

Interesting. The whole async-await stuff has always been a bit risky to me (in any language), because yeah, as soon as you start introducing it, it spreads through your code base limitlessly.
This effort won’t yet quite fix that, but it will at least stop it from spreading under certain circumstances.

I often like to use the actor pattern, which gives you relatively nice asynchronous code without language-level support, and well, that too spreads over your code base, but it spreads differently.
It requires core components to be turned into actors and communication between them needs to be done with messages instead of method calls, but on the plus side, within those actors, you write synchronous code, so utility functions and such don’t need to know about this async-vs-sync problem.

So far, it always felt like this was just the better solution, if you were willing to pull through with the whole message-based communication. But yeah, I’m curious to see what the Rust team comes up with. If they can ‘fix’ async-await enough, maybe that’s worth another look.

This is why I’m not particularly excited about hugely interconnected and self-driving cars. This insecure shit stops being funny once it’s accelerating towards you.

The AI uses natural language processing to “understand” the text explanation behind each error codes, said the engineer.

I mean, I’m glad it’s not just some dumb if-else chain, or even just basic circuitry, that’s being sold as “AI” here.

But at the same time: How did we get to a point where this is the best solution?

Oh, I can see that scenario. Mine was a rhetoric question, as I’ve been working in the data-shipping field for the past few years.

Thing is, if there’s a thousand power stations, there may well be a thousand different implementations + error codes, because for decades there was no need for a common method of error reporting.

The only common interface was humans. That’s why all of these implementations describe errors in human-readable text. And I would bet a lot of money that they’ve already had to extraxt those error codes from text logs.

Writing them out in e.g. a standardized JSON format, requires standardization efforts, which no one is going to push for while individually building these power stations.

That’s how you end up with a huge mess of different errors and differently described+formatted error codes, which only a human or human-imitating AI can attempt to read.

I mean, there’s definitely things they could have done that are less artificially intelligent, like keyword matching or even just counting how many error codes a power station produces. And I’m not sure you necessarily want a blackbox-AI deciding what gets power and what not. But realistically, companies around the planet will adopt similar approaches.