Programmers are hyped about Rust. It’s a programming language that has a legitimate chance to replace C and C++ for performance critical applications. So any new project in Rust increases the possibility of a future where C and C++ are programming languages of the past.
Comment on Maestro, a Linux compatible kernel written in Rust.
IrateAnteater@sh.itjust.works 5 months ago
Ok, I’m out of the loop and I’ve seen this often enough that I have to ask; why do people always bring up “written in rust”? No one points out that a given project is written in C++/C#/python/ruby etc, yet we keep seeing it for rust.
magic_lobster_party@kbin.social 5 months ago
FlorianSimon@sh.itjust.works 5 months ago
The absence of shitty OOP language features is not what’s holding Rust down, in my opinion. We’ve all seen the disastrous results of 00s-style OOP code in the real world. Java-style OOP is on the way out, thankfully.
I think the low adoption of Rust boils down to 2 things: 1 - The language is particularly hard to use. Not just because it is different, but the compiler is tough to beat. 2 - C and C++ are very entrenched at this point. This is the biggest hurdle.
I gotta say, from my personal point of view: the Rust community is incredibly zealous and hard-working. Something I have never seen for any other language. Everyday, you hear about somebody rewriting some huge piece of software in Rust. They might just succeed eventually, who knows?
5C5C5C@programming.dev 5 months ago
Whenever people complain that in Rust “the compiler is tough to beat”, the real problem is that individual’s mindset.
I had this problem as well when I first started playing with Rust. I thought I was very smart and that I know exactly what I’m doing when I’m programming, so if the compiler is complaining so much about my code, it’s just being a dumb jerk.
But if you stick with it instead of giving into your initial frustration, you’ll realize that the truth is the compiler is your friend and is saving you from innumerable subtle bugs that you’d be putting into your code if you were using any other language.
When you realize that the 1.5x time+effort you need to spend to satisfy the Rust compiler is saving you 5x-50x time+effort that you’d have to spend debugging your program if you had written it in any other language, you’ll come to appreciate the strictness of the compiler instead of resenting it.
There’s a reason us crustaceans are so zealous and the ecosystem is growing so rapidly, and it’s not because we’re super smart or have some unusually high work ethic. It’s because the language and the tooling is legitimately really good for producing high quality software at a rapid pace.
There’s going to be an inflection point where the people who keep dismissing Rust are going to be left behind by the entire tech industry because there’s no other language that allows an ordinary developer to produce as high quality software as quickly that can work across EVERY platform, including web (via compiling to web assembly). I won’t pretend I can predict exactly when that inflection point will happen, but it will definitely happen.
FlorianSimon@sh.itjust.works 5 months ago
I do realize that the compiler is being annoying for my own good, you’re preaching to the choir here. I’ve pestered about Rust being so unforgiving before, thought I was smarter than the compiler and realized the compiler was right, and been amazed.
In the grand scheme of things, though, I still think that this is slowing down adoption: trying the language is hard. Outside of the context of paid work which probably doesn’t use Rust, when you’re trying the language to work on small projects on which the 5x-50x figure probably doesn’t hold true because the project is too small, the safety benefits aren’t tangible, and writing the equivalent C++ will probably feel simpler.
To go back to the proficiency of the Rust programmers: you are entirely correct, I don’t think Rust programmers have a God-given hard work ethic that other programmers don’t.
Respectfully, though, I disagree with your statement that it’s something about the language that makes programmers THAT many times more prolific, but I can’t think of a solid explanation why at the moment.
catastrophicblues@lemmy.ca 5 months ago
Yeah the syntax is pretty far from more established languages, which is why I prefer C++ when I use it.
dewritoninja@pawb.social 5 months ago
Imo rust won’t replace cpp without true Oop so I might just make my own objective rust and piss off Oop haters
barsoap@lemm.ee 5 months ago
There has been no true OOP language since smalltalk, which btw wasn’t class-based.
In practical terms Rust has subtyping – barely, at least in technical terms the only thing that uses true subtyping is lifetimes. In practical terms you have qualified types (aka traits) supporting interface inheritance which is perfectly proper as everybody knows that you shouldn’t inherit implementation as the Liskov Substitution Principle is undecidable.
“Language X will fail because it’s not OO” what’s this, the early 00s? I thought we left that hype train behind.
FlorianSimon@sh.itjust.works 5 months ago
The parent post was edited, wasn’t it? I replied something to it, but the mentions of OOP have been removed. Am I goig crazy? 🤪
CosmicCleric@lemmy.world 5 months ago
That’s why you always quote what you’re replying to.
magic_lobster_party@kbin.social 5 months ago
And I’m confused why I got two comments going into the OOP tangent, when I made no mention about it at all.
callyral@pawb.social 5 months ago
What is true OOP?
HulkSmashBurgers@reddthat.com 5 months ago
I’ve never used rust but as you say it really does seem like a good successor to c/c++. It’s a modern, more memory safe programming language shat allows you to dig into the weeds if you need it.
devfuuu@lemmy.world [bot] 5 months ago
Because rust is the modern low level systems language, which means it gotta go fast without all the freaking problems of the only other real alternative so far that was C. The languages you list don’t even play in the same ballpark.
AnUnusualRelic@lemmy.world 5 months ago
But a kernel written in Perl would be a real achievement. Something in a whole different league.
cd_slash_rmrf@programming.dev 5 months ago
It definitely would be. Next time someone posts a kennel written in Perl I hope they specify that.
CapeWearingAeroplane@sopuli.xyz 5 months ago
Honest question from someone using C++, though not for systems- or embedded stuff, just for object oriented models that gotta go fast: Why is C++ not in the same ballpark, and not an alternative?
CaptDust@sh.itjust.works 5 months ago
Mentioning it’s written in rust should imply this code base will have secure concurrency, better memory handling, be easier to extend, while maintaining near C++ performance. None of these are guarantees, but considering so many rust projects are “C/C++ programs, rewritten” it seems worth calling out as a differential. The language benefits extending to the kernel make it an interesting project.
rickyrigatoni@lemm.ee 5 months ago
Yes they do? All the time? To the point where github has a bar on every project page showing what percentages of every project is written in which languages?
xantoxis@lemmy.world 5 months ago
If you want a real answer, it’s mostly advocacy, the same reason Linux enthusiasts show up to every negative-sounding Windows thread to tell you to install Linux instead. And if it is less obnoxious, it’s only because there’s fewer Rust enthusiasts.
There are, also, advantages to a Rust implementation that you can claim simply by virtue of something being implemented in Rust, as entire categories of problem that cause C projects to hemorrhage security vulnerabilities simply don’t exist for Rust.
But mostly it’s people wanting you to be excited about and interested in Rust.
IrateAnteater@sh.itjust.works 5 months ago
Is there something inherently safer with how rust does things, or is it just a case of it being new, so the vulnerabilities haven’t been found yet?
hperrin@lemmy.world 5 months ago
Yes. Unless you write code in an
unsafeblock, Rust will perform most aspects of memory allocation and management for you. It is memory safe and thread safe by default.C doesn’t have any of these safety checking features, so it would be equivalent to unsafe Rust, but all the time. It lets you do whatever you want with pointers for example, including making them point outside of the memory bounds. In program code, this will cause an illegal memory access exception, but in kernel code, all memory access is legal. Therefore, you could write a driver that accidentally overwrites the kernel’s own code in memory. That would likely cause a kernel panic and bring the whole system down. Whereas, in Rust, you can only do that within an
unsafecode block.wikibot@lemmy.world [bot] 5 months ago
Here’s the summary for the wikipedia article you mentioned in your comment:
Thread safety is a computer programming concept applicable to multi-threaded code. Thread-safe code only manipulates shared data structures in a manner that ensures that all threads behave properly and fulfill their design specifications without unintended interaction. There are various strategies for making thread-safe data structures.A program may execute code in several threads simultaneously in a shared address space where each of those threads has access to virtually all of the memory of every other thread. Thread safety is a property that allows code to run in multithreaded environments by re-establishing some of the correspondences between the actual flow of control and the text of the program, by means of synchronization.^article^ ^|^ ^about^
magic_lobster_party@kbin.social 5 months ago
Rust has many safeguards against some common errors that may cause security vulnerabilities. It’s by no means bulletproof against all vulnerabilities, but it’s something.
sentient_loom@sh.itjust.works 5 months ago
I only know the hype. But the hype says that Rust’s ownership system makes memory usage much safer by forcing the coder to deal with data. Your values will eventually go out of scope, and you have to dictate when that will happen or else it won’t compile.
…or something like that.
bacon_pdp@lemmy.world 5 months ago
Well rust has a borrow checker which does make some memory bugs harder to create but to say that rust solved any of the known open problems in computer security. The answer is clearly no. It just copied some good ideas from ocaml into C++ and got some good marketing.
borrow checkers also already exist for C/C++/etc [just most people don’t use them]
so, slightly safer defaults than C/C++ but doesn’t contain any new/unique security magic.
nickwitha_k@lemmy.sdf.org 5 months ago
I feel like this is an example of innovation vs invention. Rust did not invent borrow checking. It did, however, make the borrow checker an integral part of the language and compiler. Making memory safety the default behavior is innovative and makes it the path of least resistance.
Memory safety issues are responsible not just for crashes and perf degredation but are a significant attack vector for exploits. Making it harder to land there makes these exploitable conditions less common. The mechanism is not unique but its integral place in the language is.
AnUnusualRelic@lemmy.world 5 months ago
But it also has a cool name. You forgot to mention that very important aspect.