Comments by "Anony Mousse" (@anon_y_mousse) on "Rust Is Going To Destroy The Linux Kernel!!!" video.

I found this somewhere else and am going to partially quote it here because it was fairly well written and I agree: /* I think many people who still use C do so for the same very simple reason I do: it works, has a reasonable community (many libraries) and, most importantly, code written today has a high chance of continuing to work unmodified far into the future. C is the only language which delivers all three... No matter what I find exactly no enjoyment being on a permanent treadmill having to jiffy my code around so that it works again with whatever "awesomeness" the language designers decided to change in the last few months or, even worse, to find that the language has been abandoned and now my code needs a full rewrite in something else. Is this really so bad ? No, C programmers are not degenerate psychologically challenged moronic narcissists who work day and night just to deliver security issues and bugs to you. Could we be civil and stop looking down on people who code in C, please ? */
6
I would strongly encourage people to not group C and C++ as though they were the same language. Coincidentally, there was an esoteric language that someone created some years back named C\C++. It looked nothing like either, but if you can get a search engine to work with those characters you'll get a good laugh.
5
@BrodieRobertson It'll still update faster than is reasonable for both security and safety's sake. Rust developers will make sure of that.
3
Except that C and C++ are not the same language and C++ was already rejected in the kernel. I think Rust should be rejected as well, but for somewhat different reasons.
3
Ideally, programmers in general should always code as though they're writing in a giant unsafe block. Carelessness begets errors, and more programmers mean more errors, which eventually will lead to uncaught errors, which have the potential at kernel level to kill someone. I'm sure someone will dispute this, but there are medical devices which use Linux, as well as transportation infrastructure and even lowly cars.
2
@jnx4803 No proper hardware support? It runs on more hardware than either Windows or MacOS. Just because it takes longer to support newer hardware doesn't mean anything other than the hardware manufacturers don't support Linux. Truthfully, they should be open sourcing whatever drivers they create and writing open specifications so that those on other systems can write their own drivers that work perfectly. And you realize that millions of developers work on Linux, not just the kernel, but for hundreds of thousands of pieces of software. Different people have different priorities as per the project they're working on. Not every Linux developer can work on writing drivers, regardless of language it's written in.
2
@miguelguthridge The road to heck is paved with good intentions. Let's see how far that gets them.
2
@terrydaktyllus1320 I'm not sure which post you're responding to, but I agree with that. I do think that we shouldn't need a calming down time, though, and if the kernel just stuck with C we wouldn't. I think that thus far everything Rust promises to protect its users from are things that are actually easily accomplished in C if you know what you're doing, and I think that anyone writing for a kernel should know these things like the back of their hand. That not all of them do isn't really an argument for Rust but rather an argument to cut those that don't from the roster. I'm sure some millennial will be along to whine about gatekeeping, but sometimes it really is a good thing because this is software that gets used in medical devices and vehicles and the hardier that software is, the better.
2
@mskiptr If you're as old as I am, 10 years isn't that much, but 3 years is still too fast. Back when c99 came out a lot of developers groused about how it would kill the language and how no compiler could keep up before the next standard was released and a host of other apocalyptic nonsense. Well, they were mostly wrong, but there were some things which actually didn't get fully implemented in every compiler until the next standard. And at that time scale, while that's certainly taking too long, it should put it into perspective that 3 years definitely isn't enough time. Everything I'm seeing shows me that this language is being rushed out of the gate, ready or not, and I don't get why there's so much fanaticism. People need to slow down, a lot.
2
I've not heard of Rust doing any JIT, and I hope it doesn't, but that is a good argument against Java as a kernel language. Although, at least one kernel did exist that used Java, and it likely no longer exists anywhere.
2
@lycanthoss JIT isn't solely for interpreted languages either.
2
Well, I'll say one final thing before I go eat, Rust won't destroy the kernel, but it may destroy the community.
2
@FatherlyFox This is why Rust developers decided to leverage LLVM, because all the code was already written to do that, in C. The same is true for all of those compiler targets for C. It was already written years ago, in C, so you wouldn't have to write it again today. They say why reinvent the wheel, and obviously the answer is to have something better, but what about when what you have is already the best? Why rewrite the wheel when it already does everything it needs to do in the most optimal way?
1
@jnx4803 You clearly didn't read everything I wrote. Some arbitrary piece of hardware that you use is utterly inconsequential to what I said. Not every developer who works on a given system will work on every part of that system. Not every developer who has worked on that system still works on that system. You're equating pieces of hardware you use that didn't work for you when you tried Linux out with the entire ecosystem being garbage. That's such a narcissistic attitude to take. And to add to what I said earlier, go install Windows 10 on a 1980's era computer and tell me how that works out for you. Go install Windows on a router or some obscure piece of equipment that runs Linux perfectly.
1
@mskiptr Okay, first of all, ISO is the standards body, so those are all ISO C, but to be honest, that's once a decade or so change versus every three years. That's called stability versus instability.
1
@memk Most C programmers I know aren't toxic, and those that get angry about this are rightfully so because most Rustaceans are ultra toxic pieces of garbage. Your language of choice isn't some miracle cure for bad programming, but nearly the entire lot of you claim it is. And no, C isn't the best language either, it's just better than Rust.
1
@miguelguthridge In what way are their approaches similar?
1
@alenasenie6928 Generally, static analyzers are good enough that we don't need the potential benefits of JIT in pretty much any language except those which are very sloppily written. Which tends to be things like JavaScript. There are more languages which could benefit of course, due to sloppily written code, but they're a lot harder to write from scratch for whatever language you might want to use them with than just using the pre-existing tools and making the code better. JavaScript has it in part because it's always needed it due to people who aren't programmers thinking they could write code. Which is why most of the internet is slow and bloated. Python should probably have one, but I think that ship has sailed.
1
@anonymousalexander6005 That's an elitist attitude.
1
@diadetediotedio6918 Incorrect. The idea that C shouldn't be used because of a flawed theory that Rust will solve all of our problems is what is elitist.
1
@diadetediotedio6918 The elitism comes from the suggestion that it increases safety and that you're somehow lesser by not using it. Rust does not actually increase safety, it decreases knowledge required to complete several tasks, which in fact increases the danger as you'll have less knowledgeable people, such as yourself, using it.
1
@diadetediotedio6918 And yet 99% of Rustaceans I interact with do consider you inferior if you don't use Rust, and often tell you so. It's not elitism to want people to be better programmers, especially if they contribute code to a project that will be used in life and death scenarios such as medical devices and vehicles, which Linux is. It's also not equivalent with safety belts as someone else can cause the accident and there's literally nothing you can do to mitigate that short of staying home, and even then someone could come crashing into your home. In this case writing good code that doesn't suffer from safety problems is entirely within your grasp, regardless of which language you write it in. A language which has proponents constantly saying it's safer will give many people a false sense of security which will lead to bad code being written and bad things will happen. If instead of lying to newbies we told them the truth, they'd be as careful as they need to be.
1
@diadetediotedio6918 I'll have to start keeping a file then, because I keep seeing this toxic behavior, including from yourself on several occasions. Being a better programmer is only partly based in knowledge, a great deal comes from intelligence. If a person isn't intelligent enough to be in this profession, we shouldn't gloss over major details and expect them to do well or forget that results do matter. I don't care if someone wants to whine about gatekeeping, technical fields require it to keep the world from imploding. I wouldn't want a bridge designer who had no understanding of physics, and I don't want the politicians we have now who have no understanding of material degradation. Real people have died as a result of incompetence, in many fields. Making mistakes more difficult is a step in the right direction, but unfortunately, the methodology chosen was several steps in the wrong direction and the behavior from the community at large is several more. As for C++ programmers, I dislike most of them because they are elitist A-holes. They often look down on everybody. I have seen some negative behavior from fellow C coders, but it's mostly a reaction to the outright toxic behavior from the overwhelming majority of Rustaceans.
1
@alenasenie6928 I disagree. The alternatives to the semi-colon are either to terminate at the end of the line or use indentation to determine scope, and both suck donkey dong. If you need a long line that won't fit on your screen you shouldn't have to contort yourself to fit it. Pythonistas tried to tell us that using invisible characters as scope selectors would be the best and Python has repeatedly proven it doesn't work in wide scale use. And given that most programmers these days are hyper verbose with their naming conventions, making most things look like Java, using the end of the line would require either a very small eyeball murdering font or some special character or editor to wrap lines cleanly. And you can bet that either editor or character would cause division.
1
@Sekhatt In other words, it's been released before it's ready and all the garbage to prevent conflicts is copium by bad developers who jumped the gun. That's just going to hurt it in the long run and make it a worse language than it already was.
1
@Sekhatt It makes the language worse when it's the standard libraries and they aren't fully finalized. The argument I keep hearing is that you can just select the version you want to use, and absent any security flaws it'll just work. That's fine, but then you have to support every version between there and now, and someone can get trapped in that older knowledge of how to do things. It fragments the user base and their experience with debugging. If the user decides they want to update with everyone else then they have to go back and update their code and they never should have needed to do that. But what's more, if everyone does update their code, then you're lugging along dead weight. If they decide to lop it off in the future then they've broken whatever old code used it anyway. Creating their own ecosystem also means it'll be harder for that old code to support itself too.
1