D seems unlikely to get a renaissance. These days languages are facing much stiffer competition, and D has never solved its fundamental problems:

It is a rudderless language, that struggles with fragmentation due to the hype-driven addition of half-baked and mutually incompatible paradigms, with a leadership that keeps driving away contributors.

I can’t see how any of this could change while Walter Bright is still in charge, but I also don’t see how the language could survive him stepping down as BDFL

Edit: Battlefield 5 is listed as “SILVER”, but reading the comments on ProtonDB it is unplayable in practice

I took a look out of curiosity. These are the current top 20 games on SteamCharts.com, excluding a GTA V mod and Wallpaper engine and their ProtonDB rating:

1. Counter-Strike 2 [GOLD]
2. PUBG: BATTLEGROUNDS [BORKED]
3. Dota 2 [GOLD]
4. TBH: Task Bar Hero [GOLD]
5. Apex Legends™ [SILVER]
6. Path of Exile 2 [PLATINUM]
7. Bongo Cat [BORKED]
8. Rust [SILVER]
9. Slay the Spire 2 [PLATINUM]
10. Delta Force [BRONZE]
11. Don’t Starve Together [PLATINUM]
12. EA SPORTS FC™ 26 [BORKED]
13. Dead by Daylight [GOLD]
14. Warframe [GOLD]
15. Grand Theft Auto V Legacy [GOLD]
16. Stardew Valley [PLATINUM]
17. Forza Horizon 6 [GOLD]
18. Grand Theft Auto V Enhanced [GOLD]
19. Destiny 2 [BORKED]
20. Overwatch [PLATINUM]

As you can see, only 4 of these are unplayable (“borked”), and 1 has a “bronze” rating. So the majority of the currently top-played games are playable on Linux.

Though Obviously that doesn’t help you, if the game(s) you want to play aren’t playable on Linux

I’m not saying that doing your own encryption is a bad thing, but them recommending it runs directly counter to OP’s other stated goals

An ID is needed to determine if the content exists and a key is needed to decrypt it.

Somebody making a report that there is illegal content in OP’s server, but provides neither an ID nor a key, quickly ceases to be actionable. At a minimum you need the reporter to provide upload IDs.

But even if the reporter supplies the IDs, the report may not be actionable by your standard: The uploader can easily encrypt the uploaded data, as OP themself recommends.

So OP needs a policy on what to do when they cannot inspect the content of a reported upload, regardless of wherever or not their service provides E2EE

That’s not what OP said they wanted:

I want to be able to remove illegal uploads when they get reported

Besides, OP’s own advice to upload manually encrypted files runs directly counter to this

Exactly. That’s why I don’t understand the reasons OP is giving for not having E2EE

it is not end to end encrypted. The server can read what is stored, on purpose.

I want to be able to remove illegal uploads when they get reported, child sexual abuse material above all. A server that cannot see its own contents cannot act on those reports, and I am not willing to run one that cannot.

How would end-to-end encryption prevent you from taking down content that gets reported? Uploads must have an associated ID, in addition to the key needed to decrypt the data, that people could report and that you could then use to identify what data to remove. Because otherwise, how could the server determine what data to deliver to a user who wants to download files that have previously been uploaded to your service.

Surely your strategy for dealing with this kind of thing doesn’t involve manually reviewing every file that has been uploaded to your server, or even just the subset of files that get reported. If it does, then people uploading manually encrypted files, as you suggest they do, would be as big an impediment to you taking down illegal content as automatic end-to-end encryption

You probably could implement some workarounds in the compiler, though the linked Oodle blog-post does a good job of explaining why that isn’t feasible in this particular case:

The bug is not a flaw in the CPU logic as such, but rather the result of the CPU physically degrading due to design flaws. And for whatever reason, that degradation most frequently manifested as the mov instruction occasionally doing the wrong thing. Though the blog-post also makes it clear that this is not the only issue resulting from this degradation.

Moreover, the mov instruction is a very common instruction, so a general workaround for this problem would affect large parts of the resulting programs. For example, the 1-line function that Godbolt uses as its example code results in 3 mov instructions when compiled without optimizations:

int square(int num) {
    return num * num;
}

becomes

"square(int)":
        push    rbp
        mov     rbp, rsp
        mov     DWORD PTR [rbp-4], edi
        mov     eax, DWORD PTR [rbp-4]
        imul    eax, eax
        pop     rbp
        ret

How so?

This is probably not worth losing sleep over. OpenAI are not the only Platinum Member, nor the biggest contributor to the Rust Foundation. Microsoft and Google have both contributed at least $1 million each, going by previous press releases. See here for a list of the foundation members

Which is not much different from the disclaimer about GURU, though GURU does a much better job at explaining the risks involved in using it:

Disclaimer

Please note that the GURU project is maintained and reviewed entirely by Gentoo users. It is only subject to minimal supervision from individual Gentoo developers, and is not supported by projects such as Gentoo Security. While our Trusted Contributors do their best to keep GURU safe, it is possible for it to contain vulnerable, badly broken or even malicious software. You are using it on your own responsibility.

The AUR domain is aur.archlinux.org and it is linked from the menu-bar on archlinux.org. If AUR is not official, then the Arch sure is sending mixed signals to its users

AUR is not unique in being a user repository, but it seems somewhat unique in having basically zero oversight. Which is a bad idea for reasons that should be painfully obvious by now.

For comparison, Gentoo’s GURU repository allows everyone to submit packages, but limits the ability to accept these submissions to a subset of trusted users

I wonder percentage of Arch users are actually capable of verifying that an AUR package is safe to install. I doubt that the number is very high, especially with the growing popularity of the distro

Once you’ve learned it, Rust is just a very nice compiled language to work with.

You get higher level constructs than in C++, a language without a billion weird edge cases, a modern package manager, and much more. In my experience, my code written in Rust is more likely to work as intended, both because of the stricter compile-time checks, but also because language features like sum types make it easier to check the core logic at compile time.

I work in both C++ and Rust, among other languages, but these days I never reach for C++ for a new project

It’s not strictly speaking a bug, but the behavior of Advance is a bit confusing. Based on how you use it in the code snippets, I would suggest changing it to

private void Advance() {
    current++;
}

So that it only does what it says, and then changing the place where you read the next char to

char c = Peek();
Advance();

Alternatively, you could rename it to something like ReadChar, which more closely matches its current behavior, since a read is expected to return the data (character) at the current position, and then advance the position

That is the case. But if you are at a *, then the original while statement reads while (false && …) { and immediately breaks. The remaining checks are not evaluated, since they cannot affect the outcome when the first check fails

The problem is fairly simple:

		while (Peek() != '*' && PeekAhead() != '/' && !IsAtEnd()) {

You are breaking the loop if either the current character is a * or if the next character is a /. In other words, you don’t require the full */ token.

Instead, you’ll want something like

		while ((Peek() != '*' || PeekAhead() != '/') && !IsAtEnd()) {

Those people are wrong. The 3.4.3 release passes all the integration tests in the 3.4.1 release’s test-suite, which is the last release without LLM code. You can easily test this yourself