- cross-posted to:
- hackernews@lemmy.smeargle.fans
- cross-posted to:
- hackernews@lemmy.smeargle.fans
Enter Maestro, a unix-like monolithic kernel that aims to be compatible with Linux in order to ensure wide compatibility. Interestingly, it is written in Rust. It includes Solfége, a boot system and daemon manager, maestro-utils, which is a collection of system utility commands, and blimp, a package manager. According to Luc, it’s creator, the following third-party software has been tested and is working on the OS: musl (C standard library), bash, Some GNU coreutils commands such as ls, cat, mkdir, rm, rmdir, uname, whoami, etc… neofetch (a patched version, since the original neofetch does not know about the OS). If you want to test it out, fire up a VM with at least 1 GB of ram.
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.
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?
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.
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.
I’ve had the privilege of switching from C++ to Rust almost completely in my professional work. I can tell you in no uncertain terms, the language itself makes an enormous difference.
When I was doing highly concurrent multi-threaded programming in C++, I would sometimes have to waste entire weeks hunting down subtle data race bugs, despite the fact that I have a solid understanding of concurrency and multithreading. In some cases the bugs would originate in third party libraries that I was using, even though those libraries came from credible sources like Microsoft, Google, and GNU.
Switching to Rust, those bugs are gone. By the time my code compiles there’s at 95% chance that it will work exactly the way it’s intended to without any debugging. The remaining 5% is silly little logic accidents like saying
if condition { ... }when I meant to sayif !condition { ... }and those bugs are trivially caught by writing a few simple unit tests (and Rust also makes it easier to write unit tests than any other language I know of).When I see my colleagues struggle with debugging problems in their JavaScript, Python, or C++ code, almost every time it turns out to be something that would’ve been trivially caught by the Rust compiler.
By no means does using Rust guarantee that your code will be completely bug free. But the language alone gets you so close to that goal that it hardly takes any special effort beyond compiling to get all the way there.
I think this is a huge reason that the ecosystem grows as quickly as it does: it’s so easy to write code that you can feel confident enough about to publish for anyone to use that many people go ahead and do that, and others feel confident using the work of others because the compiler does so much to ensure quality. It creates a virtuous cycle where people can develop faster by taking advantage of other people’s efforts and then release their own effort back into the community.
Yeah the syntax is pretty far from more established languages, which is why I prefer C++ when I use it.
Imo rust won’t replace cpp without true Oop so I might just make my own objective rust and piss off Oop haters
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.
The parent post was edited, wasn’t it? I replied something to it, but the mentions of OOP have been removed. Am I going crazy? 🤪
That’s why you always quote what you’re replying to.
And I’m confused why I got two comments going into the OOP tangent, when I made no mention about it at all.
Apologies!
No worries! I love conversations bashing on 00s-style OOP principles.
What is true OOP?
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.