I mean, I’m not sure, what type of responses you expect, but I do always chuckle when someone posts here with “Not sure if autism” and then you open the post and it’s just a huge wall of text. Obviously not enough for a diagnosis, or even just telling whether someone really is on the spectrum, but it is quite a common sight.

What you actually wrote doesn’t sound of place either. Feeling like you don’t fit in and the whole depression thing isn’t inherent to the autistic experience, but still quite common, because others will view us as different or weird.

You could try out hobbies that tend to attract neurodivergent folks, like for example chess, board games, technology and books. Maybe you’ll find a sense of belonging there…

What I always find frustrating about that, is that even a colleague with much more Bash experience than me, will ask me what those options are, if I slap a set -euo pipefail or similar into there.

I guess, I could prepare a snippet like in the article with proper comments instead:

set -e # exit on error
set -u # exit on unset variable
set -o pipefail # exit on errors in pipes

Maybe with the whole trapping thing, too.

But yeah, will have to remember to use that. Most Bash scripts start out as just quickly trying something out, so it’s easy to forget setting the proper options…

I don’t have the Bash experience to argue against that, but from a general programming experience, I want things to crash as loudly as possible when anything unexpected happens. Otherwise, you might never spot it failing.

Well, and nevermind that it could genuinely break things, if an intermediate step fails, but it continues running.

Huh, so if you don’t opt for these more specific number types, then your program will explode sooner or later, depending on the architecture it’s being run on…?

I guess, times were different back when C got created, with register size still much more in flux. But yeah, from today’s perspective, that seems terrifying. 😅

What really frustrates me about that, is that someone put in a lot of effort to be able to write these things out using proper words, but it still isn’t really more readable.

Like, sure, unsigned is very obvious. But short, int, long and long long don’t really tell you anything except “this can fit more or less data”. That same concept can be expressed with a growing number, i.e. i16, i32 and i64.

And when someone actually needs to know how much data fits into each type, well, then the latter approach is just better, because it tells you right on the tin.

Oh man, a zero byte long unsigned integer? Lots of languages represent it as an empty tuple these days (the “unit” type), but from quickly scanning the documentation, it looks like HolyC doesn’t support tuples, so I guess you gotta get creative…

Man, I understand that it’s trying to give tips, but this really comes off as condescending. “Just create these three pieces of complex, non-obvious documentation and ensure you have highly automated specification and code quality checks.”

I also have to say, if you expect maintainers to be experts in how to correctly prompt LLMs, and expect them to be hot for reviewing/rewriting generated code, then they might as well prompt the LLMs themselves.
Sure, there may be extra effort involved by outside contributors – may, because they do attract folks who have no interest in putting in any effort – but is that really worth the overhead of having to communicate with the LLM through a middleman?

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.

I think, the problem is that management wants the expert humans to use the non-expert tools, because they’re non-experts and don’t recognize that it’s slower for experts. There’s also the idea that experts can be more efficient with these tools, because they can correct dumb shit the non-expert tool does.

But yeah, it just feels ridiculous. I need to think about the problem to apply my expertise. The thinking happens as I’m coding. If I’m supposed to not code and rather just have the coding be done by someone/-thing else, then the thinking does not occur and my expertise cannot guarantee for anything.
No, I cannot just do the thinking as I’m doing the review. That’s significantly more time-consuming than coding it myself.

Capsaicin (the chemical that causes the heat sensation in chilis) is soluble in oil, so it can definitely play a role.

In my experience with maths, there’s a whole bunch of different conventions all over the place, so it might’ve genuinely been how they were taught, even if you were taught differently…

Oh yeah, that was my assumption, for sure, too. I was just playing devil’s advocate for the trenchcoat theory, because it’s funny.

I mean, probably happens a lot that the bones of different dinosaurs end up next to each other.

Would it happen for every T-Rex fossil in the same way? Well, less likely…

Really my biggest frustration is that it isn’t transparent what’s generated and what’s not. If a human wrote the code, then I want to teach them, especially if there’s glaring logic issues in the code.

But at the same time, the most likely cause for glaring logic issues, is if they generated the code. And then it’s just a complete fucking waste of my time to try to teach them.

Also has to be said that KDE on those slower-moving distros is actually buggier than on up-to-date distros. I have to use Kubuntu LTS at work and it has so many more glitches and crashes compared to openSUSE Tumbleweed and NixOS on my personal laptop.

I get asked to relatively often at dayjob, but I keep telling them that we can’t do that…

Yeah, and you don’t have to know which fork to choose. Only the compatible fork will show up in the search.

(I was going to recommend that, but had something in the back of head, that you needed a manual step to enable the configuration. But I just saw that this is described in the Plasma 5 version, not the Plasma 6 fork, so I guess, it’s not necessary anymore…)

It is the first one, yes. Just the normal keyboard shortcut settings. And all the Krohnkite shortcuts are prefixed with “Krohnkite”, so you can find them easily.

I believe, that’s something which became impossible with Wayland?

But it wasn’t very good under X11 either. Even back then, it was much less clunky to use the various KWin scripts, which offer tiling. Well, and by now Plasma has built-in semi-automatic tiling, which those scripts basically just configure, so they do now feel quite smooth.