Why You Should Forget About Rust Forever.

WARNING: This is a click bait video with no useful information. Would be better if it was actually funny.

For those of you who aren't aware, Rust has a build system called Cargo where you can just type `cargo run` and run the code, no need for using rustc manually.

As soon as he said "javascript" I paused this video and started reading comments 😂

Bjarne Stroustrup once said, "There are only two kinds of languages: the ones people complain about and the ones nobody uses."

Comparing Rust to Javascript it’s like comparing a hammer to a wrench: different tools, different usages.

I would rate the contents of this video around a 2 out of 10. Explanation: Pros (Positive Points): Acknowledging Rust's Benefits: The video starts by acknowledging that Rust has innovative features, such as traits and generics, which contribute to its popularity. It also mentions that Rust is praised for memory safety and performance. Highlighting Learning Curve: The video correctly points out that Rust has a steep learning curve, especially for beginners or those coming from other languages like Python. It highlights that Rust introduces new concepts and rules that need to be understood and followed. Cons (Critical Points): Sarcasm and Negativity: The video begins with a somewhat sarcastic tone, which may not appeal to all viewers. Using phrases like "it doesn't have Alzheimer's" to describe memory safety might be seen as disrespectful. Inaccuracies and Incomplete Information: The speaker claims that Rust took over 15 minutes to install, which is an exaggerated claim. Rust installation is usually straightforward and doesn't take that long. Lack of Depth: The video discusses Rust's learning curve briefly but doesn't elaborate on why these concepts are important or how they contribute to Rust's strengths. Misleading Information: The video implies that Rust is prone to memory leaks, which is misleading. Rust's ownership and borrowing system is designed to prevent memory leaks. Mentioning "lazy Statics or Global variables" as causes of leaks lacks context and explanation. Lack of Nuanced Comparison: While discussing Rust's compile time, the video doesn't provide a balanced comparison with other languages or explain the trade-offs that the borrow checker brings in terms of safety and performance. Surface-Level Critique: The video provides only superficial critiques and doesn't delve into the reasons why Rust's unique features and safety mechanisms might outweigh its learning curve or compile-time issues. In summary, while the video touches on some valid points, it lacks depth, accuracy, and a balanced perspective. It leans more toward sarcasm and negativity, which might not be the most effective way to provide a fair evaluation of Rust as a programming language.

I'm learning rust as a pythonist and it's being pretty straightforward. As a programmer, you are very good at creating misleading information

"Rust doesn't have a run button" is an amazing statement. It's like "A downside of electric engines is that they don't have wheels". Yes, no language has a run button. Your IDE might have one, and Rust is perfectly fine with that. I have VSC set up with a run button.

So basically what I'm hearing is. Rust is bad because its not what I wanted it to be. Sounds about right

Right off the bat, I know this video looks like satire and I genuinely thought it was a joke, until I saw a comment saying "nice satire" and the reply was "What", as well as genuine, serious replies to some other comments that make me think this isn't actually a joke and is dead serious (and yes I know it was inspired by another video but that doesn't seem to be satire either from a brief first look), so here it goes: I got this video recommended to me and, while personally loving Rust, thought "Oh, a video about why Rust sucks, should be interesting" because I'm very much interested to see the viewpoints of others and downsides of Rust for people (and believe me, it has some downsides indeed). But this video actually disappointed me. And I don't think there was an intent to just make Rust seem worse than it actually is, I can't help but believe that either you deeply misunderstood the very basics of Rust - and many programming languages in general - (even as far as installing it and running the code) or were just lazy and didn't do proper research (which would explain a lot). To address your points in the video: 1. The installation: I don't understand how the installation took more than 15 minutes, it's a pretty simple .exe installer you have to run and follow a few basic prompts. It should be easy enough for the average user, let alone a programmer - who usually is more technical than an average user. 2. Not you criticising Rust, but something that you misunderstood: it's not praised for unique features like "traits and generics" - in fact, those are pretty common amongst programming languages. Rust is praised for its good type system, which includes those, safety and performance, as well as the tooling and ecosystem, but that's not all it has to offer. 3. The steep learning curve: I agree. That's a fair point and it can be jarring to learn Rust. Interstingly, Google recently made a blog post saying their programmers didn't take long to get accustomed to Rust: https://opensource.googleblog.com/2023/06/rust-fact-vs-fiction-5-insights-from-googles-rust-journey-2022.html. 4. The strict compiler: That's a feature. That's the point and how the safety works. Thing is, you either get the errors at run time or at compile time. Rust's compiler is actually really helpful and, while different from many languages, it's great to be confident in the code that you compile. That, of course, doesn't mean it prevents all errors, but it prevents a lot of errors and bugs due to its type system and compiler. Is it annoying to not be able to compile code accessing an inexistent field on an object, or to get null at runtime and wonder what is going on? (That's more of a typed vs untyped language comparison but the point still stands). 5. "But Rust doesn't have a run button". I'm sorry, I'm not trying to be negative but this is just baffling for many reasons. For one, not having a run button isn't anything negative, it's just a sign of a lack of experience. You'll find that 99% of the time you won't have a run button, nor do you need one. You could get one, but why the fuck does one need a run button to run their code? Is typing "go run" or "cargo run" or "python main.py" to run your code? That's such a shallow, stupid complaint. On top of that, you don't have to use rustc directly to compile it and run the binary. A BIG reason for loving Rust is the tooling and ecosystem. Cargo is actually great, and you can use "cargo build" or "cargo run" to directly run the code. The fact that you didn't know this just shows that you didn't bother finishing the FIRST chapter of the Rust book, which just sets you up. 6. Slow compile times. Yes, the compile times are slow, but it shouldn't be a big problem if you don't have a very large single crate project. That's a fair point though and you're not wrong. 7. The risk of memory leaks. First of all, Rust prevents memory leaks more than many other languages, that's the entire safety aspect that you don't seem to understand. You can get memory leaks in any language, including Rust, but it's just more difficult in Rust. You really don't seem to know what a memory leak is. Moreover, "lazy statics" are not a Rust feature, "lazy_static" is a crate that allows static initialisation at runtime, the point of statics is that the memory lives for the entirety of a program, by definition it's a memory leak. Also, global variables are NOT a Rust-specific feature and are present in many, if not most, programming languages. Rust actually doesn't actually really endorse global variables, but that's what lazy_static is for. It's recommended to use them sparingly though. I'm not trying to just criticise aimlessly, it's meant to be constructive, but I couldn't help but get annoyed by a part of it, and that is you giving bad explanations or wrong information on topics you don't seem to understand. Please take you time to actually understand something before making content trying to educate others, because you'll just be spreading misinformation. Some other feedback on the video: the auto generated captions are wrong sometimes, and the volume was a bit low.

Yet another person coming to Rust with expectation it is yet another langauge. What makes Rust "hard" it's that it makes you think differently from what you were used to. Which is how it fulfils its promises

I was hoping for a senior 50+ years old C dev but then I heard JavaScwipt. Hurting.

Rust is not tough to learn. The concepts may be unfamiliar to you.

Comparing JS to Rust , its like comparing a drunk man lying on the ground with a sober one.

The nice thing about rust is, once you get the code to compile, it's not very likely it will mess up.

Writing memory safe programs is hard. You can either get good at it through hundreds of hours of debugging, or by putting yourself through Rust's steeper learning curve. But there is always a price to pay. You're not getting a free lunch.

1. Don't use rustc directly. Use cargo 2. The borrow checker isn't the reason for the long compile times. You can run the borrow checker separately and compared to compile times it finishes rather quickly.

Bold young man is bold. Rust is intended to be an alternative or replacement for C++, not JavaScript necessarily.It's mostly for systems development, not cute webpages...The borrow checker exists to avoid other things that happened in languages like C/C++ when allocating memory dynamically, where the developer could forget to release/free the previously allocated memory. So of course there can be memory leaks, but the point is to make it harder for the developer to do so.

Even if this vid was a satire it would still be a garbage and worst spent time in my life.

I just listened up to the point where he complained about the compiler rejecting the program. Because that is exactly what I was looking for. I am tired of waiting three hours for a program to complete and then seeing it crash at the last minute due to a minor bug. This person probably never programmed anything that deals with large amounts of data.