Wikipedia seems to do a decent enough job defining it:

Authoritarianism is a political system characterized by the rejection of political plurality, the use of strong central power to preserve the political status quo, and reductions in democracy, separation of powers, civil liberties, and the rule of law.

But basically, my point is:

• If your government represents the people, then it is possible for your people to elect authoritarianism, especially if they are unhappy, like the meme describes, and/or when there’s foreign nations trying to destabilize the system.
• If your government does not represent the people, then it is likely to devolve into authoritarianism on its own, because individuals or individual groups will want to assume all power and limit the rights of others.

Basically, my opinion is that politics is a constant work in progress, no matter the political system.

Both of you could’ve simply named the political system that you think is magically immune to being overthrown, while somehow not being authoritarianism itself.

You don’t enjoy people talking on your social media, do you?

Ah yeah, I was thinking of the “Caused by” shenanigans, which it prints in addition to the stacktrace.

Pretty sure that’s every political system, unfortunately…

Other useful Debug implementations:

• PathBuf and Path will give you the path with quotes and I believe, it escapes any non-UTF8 characters.
• std::time::Duration will give you reasonably formatted output, like Duration::from_millis(54321) will format as 54.321s, whereas Duration::from_millis(321) will format as 321ms. Not appropriate for every situation, but works pretty well for logging.

Was recently thinking this might happen to Pinterest, too. Their webpage was never great, with how it tried to prevent you from downloading images, when that was literally the only reason I would ever visit. But at least, they did have a big database of images and a decent algorithm for detecting visual similarity.

And well, they have an even bigger database of images now, but the majority of it is not worth looking at, because the images are not real. I don’t bother visiting anymore, because you can’t find anything worthwhile on there anymore.

They did announce going all-in on AI at some point, but I don’t know, if they actually decided to generate images themselves. That seems almost too stupid.
Could be that they have some financial incentives for folks posting and that alone lead to tons of AI-generated uploads. I don’t actually know how Pinterest was supposed to work…

Well, even before those, there were machines which wouldn’t spin the can. It would just conveyor-belt it under the sensor, not find a barcode and then conveyor-belt it back out, until you turned it the right way around…

These machines used to require you to put the barcode into the right position. Maybe they’re still used to those machines and therefore look for the barcode on each container?

Well, bullet bras were a thing for quite a while, too:

Well, their main problem is attention. And we are looking at a news article right now.

Oh man, I don’t want to get deep into all the politics involved, but man, this reads like complete non-sense:

The outage comes following Iranian attacks on the UAE as retaliation for US and Israeli strikes on Iran.

If they did specifically target US corporations in UAE, that would make some amount of sense as direct retaliation.
I guess, you can also attack UAE and hope that they pressure the US to stop invading.
But in any case, this seems like a really good way to drag more nations into the conflict, or at least to force them to become active, which is not in the interest of Iran.

I can understand the sentiment and would 100% agree for programming languages.
But personally I actually like that it encourages a flat structure, because you do not want to be yakshaving the structure of your config file. Too much nesting means you will sooner or later run into configuration keys being nested under the wrong category, because your project context changed over time.

And well, as I’ve argued in a few other comments already, I think non-techie users have a disproportionally simpler time when no nesting is used. They understand the concept of a heading and then just adding a line underneath the appropriate heading is really intuitive.
You can just tell them to add the line certificate="/tmp/cert.crt" under [network.tls] and they will find a line in their config file which actually reads [network.tls] and they can just paste that line as-is.

With nesting, they’d need to add it under here:

network: {
    tls: {
        certificate: "/tmp/cert.crt"
    }
}

Which means:

• You need some awkward explanation where they should nest it, or an explanation that e.g. “network.tls” translates to nesting.
• They will ask whether they should indent the line you sent them.
• Well, and it’s also surprisingly difficult to explain between which braces they should put the text, and that’s at the end of the braces, but not after the braces etc., if you’re talking to them on a call.

It’s not even that I’m completely enamored with TOML, but this aspect is certainly growing on me…

VSCode is Electron, i.e. a webpage, so it’s not hugely surprising that they opted for the natively supported JavaScript Object Notation. And also shows that they don’t care for using the right tool for the job to begin with.

Personally, I much prefer TOML over YAML, because it does not have significant whitespace, and because you can read the spec in a reasonable amount of time. It just has so much less complexity, while still covering the vast majority of use-cases perfectly well.

Well, TOML is essentially just an extension of the INI format (which helped its adoption quite a bit, since you could just fork INI parsers for all kinds of programming languages).

And then, yeah, flattening everything is kind of baked into INI, where it arguably made more sense.
Although, I do also feel like non-techies fare better with flat files, since they don’t have to understand where into the structure they have to insert the value. They just need find the right “heading” to put the line under, which is something they’re familiar with.

They serve largely different use-cases. JSON is good for serializing data. TOML is good for configuration.

One thing that will become important pretty quick if you continue making these scripts is that it’s almost always better to wrap your variables in quotes - so it becomes yt-dlp -x “$a”.

Oh man, this reminds me of the joke that any program that’s more complex than Hello World has bugs – and folks still don’t even agree how to spell “Hello, World!”.

Of course, Bash is a particular minefield in this regard…

Oh boy, feature freeze for Ubuntu 26.04 is on Thursday. Hopefully, they still include this update.

My work laptop unfortunately comes with Kubuntu LTS and I desperately want the virtual-desktops-only-on-the-primary-screen feature on there. Currently, I’m the guy that actively disables all but one screen, because my workflow does not work at all with the secondary screen switching in sync with the primary screen.

I’m open for counterarguments, but I always felt this was a silly way of looking at things. You cannot measure stuff at the quantum level without significantly altering what you measured. (You can never measure without altering what you measured, since we typically blast stuff with photons from a light source to be able to look at it, but for stuff that’s significantly larger than photons, the photons are rather insignificant.)

As such, you can look at measuring quanta in two ways:

1. Either the quantum had the state that you end up measuring all along. It is only “undetermined”, because strictly nothing can measure it before you do that first measurement.
2. Or you can declare it to have some magical “superposition”, from which it jumps into an actual state in the instant that you do the measurement.

Well, and isn’t quantum entanglement evidence for 1.? You entangle these quanta, then you measure one of them. At this point, you already know what the other one will give as a result for its measurement, even though you have not measured/altered it yet.
You can do the measurement quite a bit later and still get the result that you deduced from measuring the entangled quantum. (So long as nothing else altered the property you want to measure, of course…)

The analogy that makes most sense to me so far, is this:
You rip a photograph in half and put both halves into envelopes. Now you send one of the envelopes to your friend in Australia. You open the other envelope. Boom! Instantaneous knowledge of what’s in the envelope in Australia. Faster than light!!!

In quantum terms, you “rip a photograph in half” by somehow producing two quanta, which are known to have correlated properties. For example, you can produce two quanta, where one has a positive spin and the other a negative spin, and you know those to be equally strong. If you now measure the spin of the first quantum, you know that the other has the opposite spin.