An “exponential drop” would be a drop that follow an exponential curve, but this doesn’t. What you mean is a “drop in the exponent”, which however doesn’t sound as nice.

and not an exponential speed-up (O(2^n) to O(n): exponential to linear)

Note that you can also have an exponential speed-up when going from O(n) (or O(n^2) or other polynomial complexities) to O(log n). Of course that didn’t happen in this case.

Just because it is technically cross platform doesn’t make something efficient.

If you want performance you’ll surely won’t go with cross platform. The more general something is the less efficient it is.

Linus got it right, it’s just that other userspace fundamental utilities didn’t.

Even in english this isn’t true, for example dots can appear inside a sentence for multiple reasons (a decimal number, an abbreviation, a quotation, three dots, etc, etc), which would make you split it into more than one piece.

I hate all the cruft in my home directory, but I also hate when stuff suddently stop working after an update, or when all the documentation online talks about something that doesn’t work on my system or is not there anymore. Developers are the ones that will have to deal with people with these issues, so I can see why they are reluctant to implement the naive solutions that some ask for.

Not sure if Discord is the best example here, as it didn’t support the screen capture portal for a very long time.

If you distribute your app via Flatpak, what benefit is there over “disk space” (irrelevant for all but embedded devices)

Everyone always focuses on disk space, but IMO the real issue is download size, especially when you update a bunch of flatpaks together.

I still prefer the upstream flatpaks over Fedora’s though.

Well, but then you’re basically just pushing the mutability onto the container

That’s the point, when programming with immutable structures you always pass the mutability onto the enclosing structure.

It’s a good strategy at times though. Like say you’re working in a language where strings are immutable and you want a string you can change. You can wrap it in a list along the lines s=['foo'] and pass references to the list around instead. Then if you go s[0]='bar' at some point, all the references will now see ['bar'] instead.

A list is an antipattern here IMO. Just wrap it in some dedicated object (see e.g. Java’s StringBuilder).

What you need here is not the stability in memory (i.e. of pointers, which you lose when you recreate an object) but instead just the stability of an identifier (e.g. the index into a list).

FYI there is an open source reimplementation of Flash from scratch called Ruffle that should solve all the security issues that Flash had. It runs on WASM so it’s compatible with modern browsers. The New York Times is using it to bring back some old interactive/animated pages that relied on Flash.

50 years ago people thought everyone would be able to program using BASIC, now you think everyone will be able to program using AI. It seems nothing has changed in 50 years.

banning patients

Did you mean patents?

If you think this is normal then imagine what other people think of the linux community though!

But here’s the issue: the parent comment didn’t even provide reasons why they think Windows sucks or examples/episodes where this was a problem for them. It adds nothing to the discussion, just free hate.

Zig is “c”, but modern and safe.

Zig is safer than C, but not on a level that is comparable to Rust, so it lacks its biggest selling point. Unfortunately just being a more modern language is not enough to sell it.

So imagine if trying to fit in a C-like cousin failed

C++ was not added to Linux because Linus Torvalds thought it was an horrible language, not because it was not possible to integrate in the kernel.

It also seems to require a GC though…

newxml is GC only, for simplicity sake.

Pointers are not guaranteed to be safe

So I guess they are forbidden in @safe mode?

but it’s being replaced by something else instead

Do you know what is the replacement? I tried looking up DIP1000 but it only says “superceded” without mentioning by what.

This makes me wonder how ready D is for someone that wants to extensively use @safe though.

For local variables, one should use pointers, otherwise ref does references that are guaranteed to be valid to their lifetime, and thus have said limitations.

Should I take this to mean that pointers instead are not guaranteed to be valid, and thus are not memory safe?

Note that Rust does not “solve” memory management for you, it just checks whether yours is memory safe. Initially you might rely on the borrow checker for those checks, but as you become more and more used to Rust you’ll start to anticipate it and write code that already safisfies it. So ultimately you’ll still learn how to safely deal with memory management, just in a different way.

Rust for Linux used to be developed in parallel to the mainline Linux before Linus Torvalds merged support in the main tree.