I don't support this idea of rewriting everything in Rust but the answer to your question should be fairly obvious. Rust that compiles will generally be stable assuming you don't do a bunch of unwraps and panics. C that compiles can seem fine until it isn't.
LLMs still aren't as good at detecting C memory management issues as an experienced developer. With Rust, that doesn't matter as much because generally the compiler will tell the LLM when it's wrong.
This is all well and good in theory, but the number of times I've seen tests that don't actually test what they say they're testing is hard to count. Yes even when you encourage the developers to ensure the test fails first and do TDD. Tests help you ship with confidence but there's usually at least a few that are just passing by pure luck.
So no, I wouldn't judge a rewrite as being equal just because it passes the tests. That said, I don't think that means you shouldn't do it. You just have to be pragmatic about it.
Except all major social media sites are also corporations with their own interests. I'd rather the business model of traditional media that rides on journalistic reputation to a recommendation feed where the only job of it is to keep you on the site, especially when said feed can easily be manipulated.
No media organisation is perfect but your description of social media as some nirvana of decentralised truth is very questionable.
For what it's worth, this is commonplace in Australia too. I feel like you're describing a general safe country thing. I've lived in Japan so I know it's probably one of the safest places in the world, but I feel like what this thread describes is more US/Canada/some Euro countries being particularly dangerous, and not Japan being uniquely safe.
I think the main reason more time might be spent thinking is because there's relatively less training data on Haskell out in the wild, meaning an agent may have to check back and forth with static analysis to figure out what's valid.
Compact syntax is generally only a good thing for LLMs because it saves context windows and tokens.
Plenty of valid reasons to pick C, memory safety isn't a reason to trade off all other possible benefits. One big reason is portability, you can't compile Rust for example for certain targets.
I mean, supply chain attacks are a thing that could have happened even in the earlier days. Linux almost got backdoored in 2003.
Also with the number of remote code execution exploits that have occurred in Web browsers over the years it's hard to know for sure if what you installed hasn't been hijacked unless you spent all your time on gnu.org
No, there was a big internal project (which they communicated publicly about - search for the blogs relating to it) to address it that involved roughly a year of effort from a big chunk of the developers.
You're assuming performance has been the core priority, or even a priority at all, and I think this is a bad assumption to make. I would estimate a much smaller number of people-months of work if I were you.
Dev users assume the only problem a product can solve is performance, when there is a lot more than that in reality.
As far as I'm aware it keeps a history of the frequency you visit each directory so yes it will select the one you've visited more often (assuming you don't always start at the base one and work your way down).
There's nothing inherent about C++ that makes it more suited than Rust for game engines though, Rust supports careful management of memory too. Of course, nothing besides inertia (i.e. Libs, existing code, etc.). And that of course is more than big enough of a reason to stick with it.
As far as I'm aware, Haskell's dependency system doesn't have a lock file. That's the key part to keeping things stable. Version pinning alone isn't enough.
That's literally the purpose of the lock file. The lock file locks the entire dependency tree. So unless you're bumping versions or you fail to save the lock file, the entire dependency tree's versions will remain the same.
>some subtle incompatible change
In statically typed languages this normally isn't an issue. Of course I'm aware that logic can also be changed, but in that case it's up to you to write appropriate tests (or just don't bump the versions of your libraries without a good reason).
Regarding remaining compatible, I would argue that this is why modern languages implement lock files and version pinning. If you don't like a particular change but need some extra functionality or a security fix you can fork the relevant libraries or extend the functionality with an extra self written library.
There's plenty of actual racism around, which of course I don't like, but most of this is limited to /b/ and /pol/ which are not representative of the entire site. They just happen to get in the spotlight more because of how controversial they can be.
A lot of people on 4chan view these boards as a sort of filter to scare away outsiders. The majority of the site isn't nearly that edgy and largely discuss the various relevant topics for each respective board.
LLMs still aren't as good at detecting C memory management issues as an experienced developer. With Rust, that doesn't matter as much because generally the compiler will tell the LLM when it's wrong.