It’s a survival crafting game where players help each other survive the world with mutual cooperation, kind words and absolutely no Nazi or racist behaviour.
ABSOLUTELY no racism, whatsoever
And no bee grenades
Actually it’s a low budget western movie starring Alec Baldwin that resulted in the tragic killing of cinematographer Halyna Hutchins due to inadequate safety practices on set.
rust fixes all evey issue possible wife left rust kids get F in school teach them rust buffer overflow rust cant figure out nixos rust
Rust is both a nice programming language, and an obnoxious social movement made of a small minority of Rust programmers who are very loud
small minority of Rust programmers who are very loud
They also list “written in Rust” as the primary feature of software they write, even though the majority of users don’t care as long as it works properly.
It matters to potential contributors. It’s also a floating signifier for a lot of things.
The majority of users aren’t contributors though. It’s fine to mention it in contributor documentation but I find it weird to advertise it as an end-user feature given most apps written in other languages don’t do this.
It’s also a floating signifier for a lot of things.
Like what?
A program being written in rust itself doesn’t guarantee anything, but it tells you what you’ll probably find:
- Utf-8 support
- No shenanigans with installations, dynamic libraries and such. Just download and execute.
- Multi-platform support
- Low resource usage.
- semver.
- Compile with just 1 command if you want to.
- MIT/apache2 license.
- No memory leaks.
- If it crashes, at least it will probably log out something more helpful than “SEGFAULT”.
Many of those are highly positive to the end consumer.
who are very loud
Most of the “should we or should we not” discourses/dramas I’ve read about were initiated or escalated by the anti-Rust crowd. They seem to be a lot more vocal (not to mention impolite) about their opinions than actual Rust developers.
Specifically in the Linux kernel, the 2 big reasons to use it are memory safety (huuuuggee benefit) and that a lot of younger devs like it and thus it will attract their contributions.
The only reasons I can think of to not use it are that some people want their own toolchain and having multiple languages in the kernel adds complication. But tbh, none of that justifies banning Rust stuff that realistically wouldn’t have been written at all if C were the only option.
And then there’s the people who show up in Phoronix, HN, Reddit, and YouTube comments saying Rust is over-hyped without showing why it’s unfit for purpose and also trying to dictate what someone does with their own project. Perhaps it’s something to do with the representation of queer people and other minorities in the Rust community, because otherwise I do not understand why people would be sooo passionate in hating the Rust community like the group I described above is.
a lot of younger devs like it and thus it will attract their contributions.
You get it! That is probably the biggest “soft” factor for why I want to see Rust proliferate. Nobody wants to learn C! It’s an ancient, cumbersome language that is difficult to use in a secure way. I’ve been both a student and an employee at a university with many programming-related classes, and beyond the absolute basics of memory management, nobody does anything in C, or even C++. It’s almost always C#, Java, Javascript, or Python. No Rust yet because most of our teachers are also geriatrics.
Linux (and FOSS in general) has an age issue. Prolific older developers are leaving their projects or transitioning to less code-focused tasks, and the ranks are not being filled. Prospective young developers simply bounce off projects because of steep entry requirements, and the active resistance of anti-Rust evangelists (the likes of Christoph Hellwig for example) doesn’t help either.
having multiple languages in the kernel adds complication.
which is why we should simply rewrite the whole kernel in rust. boom problem fixed 😎 /j
That’s rather rude and untrue … the programming language isn’t at all nice! /s
ducks and runs away
oh I don’t consider them obnoxious. I’m from Python-land, they’ve been saving our asses with good tooling lol. the quality of output from the rust ecosystem speaks for itself
uv <3
Iron Oxide. Everyone else is wrong.
No. OP meant to type crust which is an inedible handle for pizza. I will die on this hill.
Get extra sauce. The whole point of bread is to carry sauce.
This guy fucks. Although, if I’m gonna put sauce on it, what’s a little more cheese?
The amount of inedible is dependent on the amount of hungry
I can agree with that, and the quality of the handle of course.
i’ll always eat that part unless i’m extremely full
you meant to say incredible instead of inedible, since it’s the best part of the pizza, with the best taste
ITS JUST BREAD
exactly, bread is vrry eddble by itsssself
Idk about that fryman
pepple hav been doing it for thousands of yyeeers
why eat pizza if you like plain bread more?
pizza is mrre crrrsty
Ferrous oxide innit?
Wustite, ferrous oxide, is black. FeO.
Typical rust, usually found as hematite, is Fe2O3 and is red/brown. Also an iron oxide.
Magnetite is also another black iron oxide, Fe3O4.
There are quite a few other flavors of iron and oxygen too.
Ooh, cool! TIL
flavors of iron
Yum yum
Just like grandma supernova used to make
It’s a multiplayer survival game in the vein of Minecraft.
That’s a nice way to put it. I call it more of a Noob Murder Simulator
a low level language that has really nice features when compared to c and c++, but honestly i find it difficult to read. probably my lack of experience with it, tho.
Golang is better for many things
Golang is almost never the best choice
Rust has readability issues
Golang isn’t perfect but it does improve readability thus maintainably.
I’m not saying Rust is better for all applications, but IMO Golang has a pretty bad readability due to the “simplicity” they keep adhering to. Heck, even their generics support is still pretty terrible, and that’s a fundamental feature for properly readable code.
If you’re dealing with backend stuff
The very fast map in Call of Duty.
“1v1 me on Rust bro”
Ah those were the days
Does COD still have that map? The last time I played it was in MW2 on the Xbox 360.
As far as I know yes, I watched some videos where people were talking about the newest MW version and they showed that map, that’s how I remembered :D
Programming language like many others It has some fancy borrow checker that makes memory usage get statically analyzed by the compiler, so you dont have to manually manage memory, and the program won’t need a garbage collector
so you dont have to manually manage memory
Not sure how this got upvoted with this glaring mistake. You have to manage memory. The point is that the compiler catches it if you make a memory management mistake, making things like data races, uses after frees, etc. literally impossible (short of intentionally using the
unsafetag).I think it’s debatable whether RAII should be called “memory management”. Whether dealing with Rust or modern C++, you don’t need to “manage” the memory beyond specifying a container that will determine its lifecycle behavior, and then you just let it drop.
You could certainly choose to manage it more granularly than that in Rust or C++, but in the vast majority of cases that would be considered bad practice.
That’s a qualitatively different user experience than C or pre-2011 boostless C++ where you actually need to explicitly delete all your heap allocations and manually keep track of which pointers are still valid. Lumping both under “memory management” makes the term so broad that it almost loses its significance.
Yeah, as I understand, in the terms of language design theory, it is technically still “manual memory management”. But since you don’t end up writing
malloc()andfree(), many refer to it as “semi-automatic” instead, which certainly feels more accurate.
step one get hrt prescription
step two learn rust
step three buy socks
you forgot the cage.
What, no, socks are step one, while you’re waiting for your prescription.
Rust is iron oxide, mostly used to make thermite
HOW IS THIS THE ONLY MENTION OF THE FUNGUS!?
I know, right? It turns up on the sorrel in my garden every year
Actual answer:
Rust is a relatively new programming language. Similar to C or C++ it compiles directly into executable binary code so it can be used for bare metal or low level operating system programming. It is thus relevant to Linux kernel development as things like drivers can and are being developed in Rust.
Compare this to the likes of Java or C# which get compiled to bytecode or a kind of pseudo machine code that gets run in a virtual machine, which has advantages for application development, or something like Python which is interpreted (or just-in-time compiled) at run-time, useful as an end user scripting language.
Rust is designed from the ground up to tackle some modern problems, a key one being memory safety. It’s a lot more paranoid about memory allocation and access and it’s structured around this. Older languages like C allow the programmer a lot more absolute control over the hardware, which effectively means the C programmer has a lot more footguns in his toolbox. Theoretically, Rust offers fewer opportunities for the developer to shoot himself in the foot.
Rust also comes with some really cool tooling. Compiler errors usually point straight at the problem and say something like “Shouldn’t there be a colon here?” The build system, called Cargo, is really slick in a lot of ways, handling linking, compiling, even library package management in a very automatic fashion. It’s real slick to work with.
As with anything, fans of the language can be a bit much; they stereotypically suggest rewriting everything under the sun in Rust whether it makes sense or not, and this includes the Linux kernel, which has caused some friction in the community; Linux contributors are often very accustomed to C and some don’t want to deal with anything else.
I’m convinced MS is funding the rust foundation only so that the rust kernel rewrite will fracture the Linux ecosystem and weaken it’s overall standing.
the fact that any rust community I’ve had the displeasure of working with is toxic as fuck only fuels my theory that MS wants it as inhospitable as possible to keep existing kernel devs “in their lane”.
it’s really not a bad language, but the devs… ohhh boy…
Windows already has Rust in their kernel
I like the description by a Finn who said: Rust is like a car with automatic, while in C (or Zig) you need to change the gears. In Rust you literally follow the compiler, which allows many young developers to program at low level, while C demands more time to avoid bugs. It is up to each person what he/she prefers. I would prefer to control myself the stuff and learn the in and outs of memory management.
I like the description by a Finn who said: Rust is like a car with automatic, while in C (or Zig) you need to change the gears.
I don’t think this metaphor is correct. The automatic gear’s analogy would be the Garbage Collector, which almost every mainstream language has. Rust’s memory management, in comparison, is still manual. Maybe not as manual as C or Zig - but I’d say about as manual as C++. The difference is not that it has some weird gear-changing (memory cleanup) scheme that does not require human intervention - it’s that it yells at you when you don’t do the regular gear changing (memory management) properly.
It’s fair to want to learn (and it’s certainly a good skill to have), but the question is what you’d rather see in a large, production environment. Guard rails are usually there for a reason. As for the control: you actually can program memory-unsafe (and in kernel development you often have to!) in Rust. The difference is that in Rust it’s explicitly marked by an unsafe block:
unsafe { ... }That way you get the same, fine-grained control over low-level processes, but someone else reading your code can at a glace spot where potential memory bugs may be.
In the end, languages are a tool. Especially for personal projects, everyone should just go with what’s fun to them. I personally think it makes sense, logistically, to slowly transition legacy C-based projects to Rust, because it makes onboarding new developers easier, while keeping the same memory safety that requires years of experience otherwise, basically for free. But there’s really no rush to rewrite anything that’s working well in Rust
The sound bite I heard was “the unsafe keyword makes memory bugs greppable.”
Alas, when there is no difference between unsafe wrapper in Rust and C, then why learning Rust, if one wants to go for managing the memory manually? Especially when considering the complex way of coding in Rust? Another problem: going the easy way and forgetting the tricky parts - if Rust allows for unsafe code, but it is safer to put it into a « safe » mode, so why I need to take the burden and deal with unsafe code? This will evidently lead to the situation that less and less unsafe blocks will be used, which finally leads to a situation where the programmer forgets the in and outs of manual memory management. You can see it as the principal aim of writing memory safe code, but to me it is also a way of « delearning » by learning. I see here the reason why so many young programmers are opting for Rust, because manually managing the memory in larger projects like in C is a question of knowledge and experience which does not come in one day. I also doubt that following just the compiler is a good approach. I agree totally with your last points though! Coding should mean to have fun and be the same time mentally challenged due to complex algorithms or demand for better code in general.
The difference is, you put up a sign “here be dragons” with unsafe. Certain operations break the garanties of rust, like pointer operations and Cells. So now you need to write a wrapper which upholds checks that they are not violated. If it breaks, you just need to check your unsafe code, instead of everything. Now only one person needs to deal with unsafe for everyone in a team to benefit.
Memory safety isn’t a skill issue. There is a reason they happen in all big projects like android or chrome and only reduced when introducing safe languages.
I’d rather have a compiler that tells me why my code was refused than a compiler which prints 100 lines of templates. Or a compiler, which tells me a pointer/reference is null instead of a compiler that knows, but it’s UB-NDR so it isn’t snitching. If the compiler tells me, hey here you could have a race condition, it’s one less bug I have to find with a debugger. A compiler that complains about uninitiated variables, instead of a compiler that gives me potluck as content.
Thank you for your explanation and I understand it well, as well the advantage to find bugs quicker (which however does not mean that a safe code cannot be also a bad code). However, I do think that writing safe code without being guided by a compiler is indeed a skill. And the question how safe the code written with the help of the compiler will be is another interesting one. Perhaps we will find out in the future.
In my opinion, Rust is a language dictated by the compiler rather than one that allows you to use your brain, knowledge, and skills to deepen your understanding. Rust is essentially a programming language with training wheels. Unfortunately, the preference to finish tasks quickly is nowadays the mainstream. The understanding of the deeper stuff falls behind.
A related example from real life: bike tyres that have a flat. Less and less people can change the tyres on their own, and even do not understand the construction and characteristics of different tyres, only believing what the vendor in the shop is telling them. Bad surprises then happen.
This, to me, seems like the standardization vs optimization argument. So much of the tech world could be optimized like crazy, but the more complex it gets, the hard it is to communicate with others and keep things consistent. This complexity actually hinders production overall. Standardization, even if it’s not the most optimized, allows us to create vastly more complex and reliable systems because we can ensure we are all on the same page. Even if that standardization isn’t the best way to do it. I mean, if you want to talk about absolute control over your code, why don’t you write in assembly? Are all programming languages not virtually assembly with training wheels?
Writing in code that is not memory safe is going to mean you are substantially more likely to have mistakes that lead both to user annoyance and straight up security vulnerabilities. Having applications written in a memory safe languages, especially when worked on by large swaths of people, is absolutely the best route. It provides a secure standard way to write memory safe code. This will reduce security vulnerabilities, decrease program crashes, and allow for more efficient developers.
Changing a bike tire is something for a single person, maybe two at most. Writing code is often a team effort. And the more people that are involved, the more likely mistakes are going to happen. People absolutely can still learn the complexities, and still choose to use Rust because honestly, it’s the smart thing to do. And it doesn’t need to be rust. Any memory safe language would accomplish the same goal.
Yes, writing safe code is a skill. But for most skills you need someone to teach you. My suggestion is, think about it differently:
The compiler isn’t training wheels, but rather a senior dev, that quickly looks over your shoulder and tells you, hey you might have missed something here. You can at any point tell them, trust me bro for this part. They need at some points a comment in the form of lifetime annotations. They are pretty good, but not perfect.
To pick up your example. They don’t tell you, you need a new wheel. They tell you, you’re bike has disc brakes, but your new wheel is missing the disk. When you later hit a wall, because you couldn’t break, you can check where you just said trust me.
I have seen this somewhere else before, but I am unsure where
Lemmy’s backend is written primarily(entirely?) in Rust
It’s also what this beautiful thing is written in
Dude, that’s just English.
It’s a 2025 movie, starring Alec Baldwin, that gained notoriety in 2021, when a cinematographer was accidentally killed by a live round fired from a prop-revolver that Alex Baldwin was using.
How is it a prop if it can fire a real bullet?
Because a real gun is a prop gun if it’s being used as a prop.
It’s not the gun that was the issue, it was the fact that there was live ammunition on the set at all.
