Why do developers hate Rust?
Discover the truth behind developers’ mixed feelings towards Rust in our latest video. Dive into the complexities of this powerful programming language and uncover the reasons behind the love-hate relationship.
Free Rust cheat sheet: https://letsgetrusty.com/cheatsheet
by Let’s Get Rusty
linux foundation
📝Get your FREE Rust cheat sheet :
https://letsgetrusty.com/cheatsheet
When it comes to verbosity of syntax, you're not fair by comparing rust to js. A fair comparison would be between rust and typescript, which addresses elegantly the strong typing.
Whenever I see Rust mentioned, most of the time it's the toxic part of the community: bullying Rust devs for `unsafe` code, bullying devs for not using Rust, hostile rewrites, vandalising wikipedia. It seems like some portion of rustaceans are edgy teens from 4chan. Not the people I would like to hang out with.
Yes. No. No. No. No.
I hate Rust because the language contract itself is not consistent. It feels like a different author on a different team in a different decade wrote each core module of Rust. So even after learning Rust, and getting pretty good at… I still have to read the docs to do extremely basic tasks.
you should use the right tool for the job and that tool is Rust.
Obvious click-bait lying title card. So long as this is how the most vocal proponents of rust behave, it will continue to have an adoption problem. At least YT has a working blacklist still.
Rust assumes you have a masters degree in programming language theory. Not all developers are like that. Especially systems programmers.
I write in Rust, btw
Why even bring up Zig, when it didn't even hit version 1 yet?
I hate about rust that rust fans will take a video about how and why people hate rust and make it propaganda for rust. You can't just enumerate things people don't like, you want to still enumerate why Rust is so good. I have seen this in fans of other languages, but with rust is taken to another level. This video is "why do developers hate Rust?" and less than 1/3 of the video is about why people don't like rust.
What's about Zed Code editor which written in Rust, But it is only on Mac, they will build windows and linux soon 🙄
Will Rust run on my 486 ? 🤔
As a long time programmer, go drives me insane because it refuses to implement basic constructs and syntactic sugar.
The only bit of syntactic sugar I feel Rust lacks is the ternary operator.
Now I have read a lot of comments and got the impression: not everyone looking at Rust is understanding, what it is good for, and for a reason. It isn't simply the application domain they are using programming languages in. You cannot program an operating system in Python – but you may be very successful in its application to data mining or machine learning and whatnot. Rust is a system programming domain language, that is the domain where operating systems, device drivers, embedded systems, compilers and interpreters for other languages are programmed – up to and including Python and Javascript. You may apply Rust for a web service backend in the Cloud and benefit by having a both CPU- and memory-efficient backend with small usage bills. But it is not (yet) suitable to build an App on a smartphone (although it is possible) or a single-page app for an internet browser (where Javascript still rules and Web-Assembly may be the future). The application domain of Rust has been traditionally the application domain of C and C++. Those are the competitors. For all other application domains, C, C++ and now Rust are just enablers delivering e.g. the Java Virtual Machine or the Python interpreter or node.js or the compilers for Swift or Go. Things like C#, Java, Kotlin, Swift, Objective-C, Go are "in between". They, along with the frameworks supporting them, are applicable to various domains (client and server), but none of them are the goto-languages to program the fundament they run on.
Now, C/C++ jobs are abundant, if Rust is in the same domain, why aren't there more job opportunities? Rust has weaknesses, and one of it is its lack of C++-interoperability. It is not that hard to combine Rust with C code, but C++ is a different story. Unless that interoperability gets improved, C++ developing teams can't benefit of Rust that much. They need to continue to use their C++ code, and Rust doesn't offer the ability to do it (for the time being the only way is to create C wrappers around C++ code and use those wrappers in Rust). Once that's resolved, I expect Rust a big future.
My stance on Rust: We should have thought and learned about ownership, mutability, borrowing and moving values and references, when we were programming in C, but didn't. Now comes the punishment 🙂 Learning Rust is the most challenging learning experience I had in my professional life when learning new programming languages, but I haven't yet looked into functional programming at all, which I expect to be even more challenging (at least to me having done OOP for decades now). But as usual, with exercise comes skill. It may take a bit longer to get used to Rust, but it happens nevertheless. Why I like Rust? As I know that every rust code that is accepted by the compiler has about 75% less bugs in it then if I had done it in C or C++. That's worth the effort. I have the efficiency of C and C++, but unprecedented safety and assured correctness in the system programming domain. No write-aliasing into immutable data, no options for spooky action at a distance, no dangling references, no use-after-free, double-free, write or read outside a data structure, and thread-safe code by default. And the promise of "zero cost abstractions" is more often kept in Rust than it is in C++. Still not perfect, and as in C++ you need measurement to decide which implementation of an algorithm is the fastest or most efficient or most memory saving or whatever, but more often than not the use of Rust's abstractions won't get punished, and you get the benefit of more readable and concise code for free. Which is not the case in C++, despite all the effort in the language design trying to achieve it. And another benefit for the ever so curious: you will get used to some functional programming patterns while using Rust, which enables more of those than any other programming language not specifically designed for functional programming. And, last, but not least: the documentation is excellent. And unlike C++ what's documented is there and can be used. C++ suffers a lot from toolchains adopting new C++ standards very slowly. Being the only programming language with an ISO standard doesn't help that much, if your toolchain does not support it. And cargo is the better build tool than CMake, that's for sure. And you can write your test code into the same translation unit as the thing to be tested, which encourages to write those tests – we never did that with C code, did we? BTW: writing tests is boring, but Github Copilot is surprisingly good at writing tests. Let the bots do the boring stuff. Stupids do not get bored that easily.
P.S: maybe I overheard the "double", but a linked list isn't a Rust challenge, the double-linked-list is, and the implementation in std:: uses unsafe code blocks and classical C pointer manipulation to get the job done. Doing it without unsafe code blocks is possible, and will teach you a lot about "interior mutability" and the smart Rust pointers supporting that, but it's not worth the effort: you won't get the performance of the std-implementation then. But while learning Rust you will get used to reason about your code, and to identify opportunities to stay safe while going "unsafe". That being said, a double-linked-list isn't that often the right choice to structure data. Suggested read: "Learning Rust With Entirely Too Many Linked Lists" https://rust-unofficial.github.io/too-many-lists/
I clicked on this video thinking it was abbout rust the game
i dont think rust is difficult, it is rather making it difficult for the programmer.. rust is like a strict warden coming behind you and every step, restricting you to do stuff in an easy way, and keep telling you to do simple stuff in a hard way, because he is afraid that you are going to break something
Rust the language what did "MOVE" by default. Wtf was in the head who did that. "Consistent" the word but not about rust.
"Don't blame a perfectly designed language on a skill issue"
Based.
I hate rust because it doesn't have goto and still claims to be "zero cost". I also hate modern C++ because it apparently forbids you from gotoing over a variable declaration, but good thing you can disable that nonsense in visual studio options.
I learn html css and javascript no job experience if i learn rust can i get a job in rust or not
You have Zig, a beautiful optimazation between human factors and machine factors.
Most people I know who dislike rust just hate it for the sake of hating it or they've seen the meme of "let's rewrite it in rust". They don't have to use rust if they don't like it. C++ is still very fine. I still use node or python for simple scripts here and there. I just prefer rust for any real project I'm gonna be working on on my own. Even if rust didn't have the safety aspect, I would still prefer its syntax and tooling to other languages I've used. Plus, to me, being verbose is a good thing. I like being very specific about what is going on with types and even in python i end up type hinting everything anyways.
Just saying, go has been a much better experience for me but I’m trying to make a game. Rust and game dev don’t get along nearly as well as people claim for LEARNING game dev. Maybe it’s great if you already know everything you want to try to do
Damn C++ has better syntax than Rust.
Typescript and Go just superior. When you really need that performance then you need rust. And thats a misconception that for high level languages you don't need to use your knowledge about how memory and cpus working, cache locality is important for performance.
complexity sucks
Zig seems great ngl.
1:21 So, that's where already working with C++ comes in.
>"favors explicitness"
>also silently changes the size of integers based which function they get passed to hundreds of lines later (rather than actual first usage, which is arithmetic)
>compiles without warnings
>crashes at runtime
LOL
"Let's take a look at the map function… […] You have to dig into the documentation" (regarding JS) – No, both are true. You need to look at the documentation in both Rust and JS here. Rust will tell you at compile time your map invocation isn't right, but JS will also tell you, just only at runtime.
"It'll work how you expect it at runtime" (regarding Rust) – no, this isn't true either. You can still have memory leaks in Rust, you can still have logic errors in Rust, and worst of all, async Rust completely throws "expectations" out the window.
Otherwise, everything else is well said. I used Rust professionally for 3 years but gave up on it as a hobbyist language because the tech stack is way, way too complicated. I would rather use languages that have specifications and many implementations than a single language that takes billion dollar corporations to maintain. I think people forget that the entire Rust team is essentially owned by Amazon.
Z** seems to have blocked me from submitting issue reports, some time after identifying a problem with their Hello World demo and suggesting a Docker image. That was a uniquely bad developer experience with the lamguage. The difference in tone in those discussions and Rust discussions has been night and day.
I've seen a lot of neat arguments in support of Rust, but the paradiym shift is just a little too much for me – it forces me to think long and hard about every single line of code I write, which makes prototyping just impractical time wise. I want to write something fast and have it work (to get my ideas out), then after have a linter tell me how I can make it correct. During development, code is constantly changing and shifting – constantly putting in the extra effort beforehand unnecessarily spikes development time.
As someone who's listened to plenty of Javascript hatred over time, I'm less interested in YouTube and Reddit comments about a language and much more about what the language can do, and Rust feels very powerful from my limited use of it.
Rust is great, but it's priority for safety, sometimes walk on my nerves. Sometimes I need to write unsafe code, but it's not that easy.
For ex, I need a static HashMap. It's gonna be shared, but race condition is not important at all. The compiler won't let you do this so easy.
Rust is Haskell for developers.
I like both, Zig and Rust.
My main reason for hating rust is honestly its community. The language itself is mediocre. It has some nice ideas, but is nothing beyond something you play around for an afternoon with. The community, however, hypes it up to be the "next big thing", which it is absolutely not cut out to be. It is needlessly complicated, and it feels like showing a broken sword through your chest fighting the borrow checker just because rust is cannot for the life of me statically analyze at all. Rustaceans might chop this up to skill-issue, but that's a complete joke. You cannot claim skill-issue when rust's core goal (guaranteeing memory safety) is 100% a skill-issue, and it doesn't even deliver on that (rust leaks memory and considers that "memory safe"). The false promises don't stop there. As a big fan of functional languages (Haskell, Roc, OCaml, etc.), I was promised a functional experience with the performance of C. That is miles from what rust is. It is at most a C++ clone that masquerades as a functional language. Most parts of functional programming (brevity, declarativeness, affinity for recursion, ability to reason about code abstractly, statelessness, "turtles all the way down", etc.) almost completely get thrown out the window. Most of them, while possible, completely ruin your performance, because rustc does barely any static analysis and code transformations beyond the borrow checker and expects LLVM to do the heavy lifting.
Considering how mediocre and sold and false promises rust is, I find it a shame, that rust is forced into the position of "the next big language", while there are languages that achieve the same while being actually good.
Firstly, Swift must be named here. It is exactly as memory safe as rust, but about a gazillion times nicer to work with while not sacrificing performance.
Secondly, Dlang exists. I don't quite know why Dlang is so slept on. It's older than both swift and rust, and does basically everything that is nice about rust. It is starting to show its age though…
The fact that this video did not really address any real criticism of rust beyond either "no that's not a problem, you're wrong" or "that's just a skill-issue" is a prime example of why I dislike the rust community,
Languages that are better than rust if you care about performance:
C, Zig, Dlang, Mojo, Swift
Languages that are better than rust if you care about safety:
Dlang, Mojo, Roc, OCaml, Haskell, Go, Swift
Languages that are better than rust if you want something that is pleasant to write:
Dlang, Mojo, Roc, OCaml, Haskell, Go, Zig, C#, Java, Kotlin, Python, Uiua, APL, C, Swift, etc.
Languages that are all three:
Dlang, Mojo, Swift
There is no reason to use rust.
you look baked
As a Rust & Zig developer, i think the example of the use-after-free is a bit… unfair.
It's not common to just clean up memory without using defer in any shape way for form.
You have the power to do so, but it more than likely is always an error and it will stand out as "fishy" code.
Also… Code that compiled and ran fine yesterday produces 5 pages of error messages today. BTW. It always suprises me how little love D receives. IMO, it is what C++ should have been from the beginning.
One of the biggest issues I have with Rust is that it's virtually impossible to "pick up and explore". A lot of "modern" languages are reasonably straightforward to the point where you need to learn very little syntax and can get started fairly well. For example, if you've never programmed Python in your life and come from Java, then picking up Python will be relatively easy.
But Rust requires you to learn so much before you can do anything, that a lot of developers will just say "screw it" and pick a different language.
As a full time C++ developer, I want to migrate to Rust. And unfortunately in our country there are no much opportunities to do that shift.
I was looking for Rust jobs recently on LinkedIn, remote jobs in Germany, and I found like 2-3 real Rust jobs that aren't crypto blockchain stuff, or that aren't only like 15% Rust. It's really not great out there, but hopefully it changes in a couple of years.