Eh, I’d argue that Java and C# are in the niche of having few features. While I don’t like this niche, Java having even less features makes it stand out more in this niche. If you’re looking for a language with more features than that, then there’s so many more feature-rich choices than C# that I just don’t feel like you’d choose C#, unless you want Java with integration into the Microsoft ecosystem.

Well, it certainly wouldn’t be the first time that I call some code unnecessarily hard to read and others call it pythonic.

I understand that truthiness has an advantage when you don’t have static types, because it deals somewhat reasonably with most types, and then that is why many experienced Python programmers tend to use it. But I maintain the position that it therefore necessarily also makes it harder to read the code, because you necessarily provide the reader with fewer hints as to what is actually in that variable. It is very much like code using lots of generics in statically typed code.

As for if Enum.empty?(var), I actually prefer that to checking the length. That syntax in particular, I find a bit too complex – my preferred version is if var.is_empty() – but I still think it makes it easier to read than a length check.
Of course, there’s the nuance that it’s more syntax to remember for actually writing the code. And in particular in dynamically typed languages, your editor may not be able to auto-complete that, so I can understand just not bothering with the extra syntax and doing len == 0 instead. It’s fine.

renaming symbols, presenting documentation, formatting files,

Yes, these are supported via the Language Server Protocol (LSP). I’ve mostly been using it with the Rust LSP server (rust-analyzer) and well, it typically works, but sometimes you have to tell it to restart the LSP server and stuff (which isn’t a huge ordeal, but don’t expect everything to always work as well as in a full-fledged IDE).
I believe, for formatting, there’s also some non-LSP support.

showing code diagnostics beyond syntax errors (for example code smells or so),

This is supported in principle via LSP, too, but it depends on the specific LSP server, how much info it provides. The Rust compiler gives out relatively much on its own, which is passed on by the LSP server, but you can apparently also configure it to use the linter on save.

have AI integration (explain this, rewrite this, replace this with prompt output, …),

Not out of the box. There’s a way to define “External Tools”, which basically allows you to run commands and pass arguments to them and then use their output. For example, you should be able to define an External Tool, where you can select some text, then press your keyboard shortcut for that tool, so it sends the selected text to that tool and then it takes the command output and inserts it instead of the selected text.
While this is a powerful concept, I don’t know, if you hit limitations at some point.

specific framework integrations (reactjs, django, actix, …),

Nope, except where this might be covered by LSP. But there’s no obvious way to just install additional plugins, for example. You get about thirty built-in plugins and that’s it.

and stuff like expanding macros in C/C++ and Rust?

Well, expanding macros is also possible with the Rust LSP server. Don’t know about other languages.

Yeah, my stance for both of those is the same: If the complexity aids you in communicating better, then use it. But if you’re using big words where small words would do, then you’re doing a disservice to your readers.

Yeah, I’m talking less deep than that. Plenty programming beginners will be reading Python code. And personally, I’m a fulltime software engineer, but just don’t do much Python, so while I had it in the back of my mind that Python does truthiness, I would have still thought that var must be a boolean, because it’s being negated. Obviously, a different variable name might’ve given me more of a clue, but it really doesn’t reduce mental complexity when I can’t be sure what’s actually in a variable.

You always want explicitness when programming. Not everyone reading your code will be deep into Python and relying on falsiness makes it harder to understand.

To perhaps lean more into why complex carbs are useful:

Your body can’t really not digest something you’ve eaten. Once it’s in your stomach, it will be broken down and gets put into your blood. With the simple carbs, you get a lot of blood sugar very quickly and your body then has to deal with that. It does so by producing insulin, which tells the rest of your body to take sugar out of the blood. It’s put into either a limited, temporary storage (glycogen) or, once that’s full, into more permanent storage (body fat).
Eating lots of sugar can also lead to your body producing too much insulin, which will cause too much sugar to be taken out of the blood, so you often have a high and then a crash/low after ingesting sugary foods.

Ideally, you want blood sugar to always stay at a reasonable level, where it can supply your brain and muscles, but where your body does not have to start storing lots of it. And that’s where complex carbs are neat, because they don’t get broken down all at once, when they’re in your stomach/intestines, meaning their sugar enters your blood at a more sustainable rate. By eating them instead of sugar, you’re less likely to put on fat and less likely to have a crash.

openSUSE has the best integration of KDE, but I wouldn’t expect to see issues like yours on any distro, really…

That’s not the actual title of the article…

Opposite of neurospicy. 🙃

Oh yeah, that for sure.

However, Codeberg seems to push for excluding proprietary software dependencies, which might limit the kinds of projects I can do.

Well, they ask for software projects to be themselves under a FOSS license. If you can isolate the proprietary dependencies, you could still open-source the code.

Of course, you could also consider using Codeberg for all your open-source projects and then self-host a Git server for your proprietary projects.

There’s also an official guide for this: https://git-scm.com/book/en/v2/Git-on-the-Server-The-Protocols

I’ve heard before that it can be more difficult for folks on the autism spectrum, because we perceive more of the details in each voice, so it’s more likely to overwhelm us.

But it certainly doesn’t have to be. Neuroboring folks also don’t find it helpful when two speak at the same time.

I mean, depends on the situation. Personally, I wouldn’t call it rude when someone kind of free-fire responds to a question they hear. In that case, best course of action is to just chuckle at them responding synchronously and ask for only one of them to speak at a time.

Yeah, good point. It also doesn’t update when the content of a file changes. So, in order to detect a change in a directory, you have to walk all the files and sub-directories and the directory itself to get the last-modified timestamp for each of them. Then determine the highest last-modified and compare it to what you measured in a previous run. If they differ, a change happened.

Yeah, I’m building more-or-less an alternative to make. Major difference is that I’m not using shell commands, but rather users will define their build code in Rust …because it’s intended to be a build tool for Rust applications (beyond what cargo does).

Thanks for the comment, though. So far, I haven’t limited inputs to just be files, so I don’t actually assume to have a last-modified timestamp. Rather, my assumption is that I can get some value which changes when the input changes. In the case of a file, that’s the last-modified timestamp, but theoretically, it could also be a hash. But that means I have to store these values to be able to detect a change. Being able to just say that one thing is newer than the other without storing anything, that is pretty cool and might be worth changing my assumption for.

I don’t think, inotify works for me, because I don’t have a continuously running process. My users rather just run some build command and then I go and check, if any input files changed since the last run.

Frankly, I would be surprised, if anything uses groff for displaying --help, unless it shows the man page for that.
The most basic implementation of --help is a manually formatted multi-line string written into the source code, which gets printed as-is.
For dynamic layouting, you do need more logic, but rendering it to groff source code first does not make that easier. For tabbing, you print an appropriate number of \t.

Oblivion Remexicoed.