📝Get your *FREE Rust cheat sheet* : letsgetrusty.com/cheatsheet

There are more jobs where you talk about Rust than there are jobs where you program in Rust.

I think Rust's biggest mistake was not calling their objects "Buckets" Then they could appropriately be called "Rust Buckets".

Long compile times in comparison to stuff like golang and typescript is the biggest surprise and cause of the hate. If you are coming from c++ to rust, you expect it...but from those languages to rust, its a shock

By learning Rust. I've started to think more about error checking and results in my C# code. It is making my programming better overall.

2. Comparing a weakly, dynamically typed language's syntax to a statically typed language is unfair. The latter will always be more verbose.

I think another part of it is certain ecosystem problems. I write in rust for hobbies because I really like the rust environment, but I have so much trouble writing graphical apps or games or anything user facing, because all the graphical stuff in Rust is still in its infancy. It's gotten a lot better with things like Slint, Dioxus, Bevy and the unofficial godot-rust, but these all have bugs or limitations that prevent them from being used for major projects. I do feel like we're on the right path, but I don't feel like there's a mature enough graphics ecosystem for most app developers to join Rust yet.

I've been learning Rust for a few months now (I'm a Ruby developer in my day job). On my hobby project, I fight the compiler a lot. On the other hand, when I'm done fighting with it, my code usually works.

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.

For non-trivial applications language simplicity is more of a liability than an asset. I'd much rather have the compiler discover problems in my code at build time than have my users find them at runtime.

I really really wanted Rust to be my goto general purpose language... While it does have quite a bit of built in little things that let you ignore good practices and write dirty fast prototype code, it doesn't excel at it compared to some other languages. I don't tend to build programs that already exist, which means a good chunk of what I do is prototyping and testing and throwing away code as I come up with better approaches. The trouble I have is that takes longer in Rust. However, once you know exactly what you are doing and you know the thing you are building will live on and be useful for quite a long time, that seems to be when you want to involve Rust as that seems to be where it shines. Unfortunately for me... that's just not where I tend to sit professionally so I barely get a chance to use Rust.

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.

One day Rust will be as perfect as Dreamberd.

Where is "slow compile times" on that list?

I have no previous experience with any "low level" programming language, but I have a bunch of people around me who do. One of them in particular sort of lives in his own professional bubble (mostly a branch of embedded, but where you also design the hardware from scratch), so he didn't even know rust existed, but he has the sort of foundation that makes choice of language "all but irrelevant" to the task... so I introduced him to Rust as an attempt of getting some useful tips. After some coersion, he even read The Book! He isn't impressed, to say the least. He said that 80% of problems Rust solves with its ownership and lifetime models are a question of setting a couple of compiler flags nowadays, and the rest is mitigated by having a general idea of hardware processes you invoke when running an application. I can't check that without spending like 40+ years in the industry like he did, so I just sort of present it like I received it. He showed me a bunch of stuff of his where he just implements ring buffers without even knowing beforehand what they will hold or any real way to check really or sets up a UDP without ANY abstraction just by raw-dogging some magical numbers that he just knows should be present on a struct... (I might be butchering terminology here, but you get the point, I hope) He says he HAS to do it because "that's how ALL hardware works under the hood" and Rust doesn't seem to give you the power to. All of his code would be inherently "unsafe" in Rust... I'm still giving it a shot, though. I'm not aiming for his particular domain and it feels like there's a bunch of bias going on, so I'd like to check things out before forming my own opinion.

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.

To me the annoying part is that Rust programmers cannot admit that the language is complex/difficult, and want to gaslight you into thinking that it's easy if you just learn a few principles and read the error messages.

I see no real use case in the enterprise software area for a programming language that is hard to learn, hard to write and... hard to read. This is crazy! Who will pay for that? Because it's hard in every aspect it will required just more time for development. Java beats it and JVM is fast enough for handling quite high work-load. That's all what we need.

With 5+ years of experience in BE Web Dev with Java/Kotlin/Scala and currently 2 years with Rust, I would never go back. It's so addictive language. Everything has its place, and once you compile it, you can be sure it will work perfectly. So much so that having 3 micro services written in Rust, working for more than 1 year, none of them had any runtime error.

Honestly the reason I dislike Rust is simply because I hate the holier than thou attitude that radiates off the language and everything related to it. the idea that "the compiler knows best" when you need to practically be a language maintainer to implement CS 101 data structures just convinces me that the entire language is insufferable and will be utter torture to write.

Rust looks to me like Swift done the hard way.

Instead of studying rust, I'll dive into computer architecture and organization, operating system principles, then C/C++. In my opinion, rust is just a "tech bubble"

Maybe you can compare c++ with rust. In term of compiling as shared object file rather than statically compile all functions into one binary file.

I was debating whether or not I should write my server in Rust or Elixir. Even though Rust has much better performance, Elixir has a ton of features that make concurrency much easier to build than Rust and its very stable. I'm also a lot more productive in Elixir than I am in Rust. I've settled on using Elixir for most of my server logic and implementing Rust for things like using database drivers, and anything else that requires high performance like training machine learning models. I'd rather deal with Rust when speed is my top priority. Id rather deal with other languages when productivity and language features take a higher priority. I would love to build everything in one language only but I've begrudgingly settled on "use the right tool for the job".

I tried it. The vast array of files and directories formed to compile a hello world program was frankly stupid. What's wrong with a single file compiled by a program to a single executable file? Also the super slow compile time. It took minutes to compile it. The syntax doesn't scare me, but the experience of programming with the rust compiler is not good.

I've tried Rust briefly. I can program in assembly easier than I can in Rust, and get the job done faster by far. Second, I have yet to figure out how to handle data encapsulation in a way that makes sense. Third, the borrow checker drove me freaking nuts.

Another point, hinted at but not stated explicitly in the video, is that Rust's borrow checker forces a whole different set of programming patterns than a programmer may like. Yes, this is by design: these patterns are more obviously memory safe (i.e. verifiably safe at compile-time) than their alternatives, and it's generally a good idea to learn them so you can apply them to your favorite non-Rust programming language. But very often, the other patterns are just as memory-safe, possibly even more appropriate under the circumstances, and yet the borrow checker gets overzealous and prevents their use.

Re: point 2 This is still more complicated than Java which is also statically typed. What is the benefit?

issues with rust that i find from c++ background are absence of variadic template, private inheritance as composition, overuse of macros (which are hard to debug). Its best things are sane defaults, cargo and traits

Rust is something like my 25th+ language, so there are echoes of all kinds of things from other languages in my head all the time. The explicit lifetimes, even stronger type checking, etc. are hurdles for sure, but there's a lot you can *do* with Rust as you go along that journey. The ecosystem of crates is pretty amazing for a language this "new", and the examples you can look at are nearly endless. Don't get discouraged! 🙂

I want to try it but I don't have any projects that I could do in rust for work. I need a GUI framework to really want to get into it.

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.

I'm from java. 10+ years. I wrote a test in rust. I use testcontainers in it. I fill redis with some data, verify them. The test runs under 1 sec. The biggest relief in my life. No words to explain that. Now the tough part is to find a job.

I think the lack of jobs is a real issue. I have played with learning it a little bit. But my motivation is not very high, because it seems like the likelihood of getting a job, after significant effort, is not great. Doesn't seem like a great investment of time.

0:39 Actually the Typescript version of JS map() (also Select() in C# - an actual statically typed language) function is kinda in the same ballpark too

anyone know if there is database support for teradata and microsoft sql server?

I've been seeing a number of job opportunities for Rust. I haven't seen any for Zig or Go. But I might be looking for the jobs that wouldn't favor Zig or Go. Go was not made for 5-year-olds. But Scratch, on the other hand, was.

After being a Python dev for many years, trying to wrap one's mind around the Rust syntax is like getting hit in the head with a shovel.

Thoughts on Nim? Also memory safe, statically typed compiled.

I have been involved in computing since 1971. My first language was Algol 60, then Fortran, Algol 68, Cobol, Snobol, MIX, PDP-11 assembler. That was my first year at UK University. Since then there has been a new language sprung upon the poor programming masses by the purveyors of novelty. After so much practice I can learn a new language, but now in my '70s I am getting rather fed up with the quest for novelty. Most programming is not from afresh, but modifying and adapting code that already exists, and if it is in an unfamiliar language it is often a matter of guessing, or cutting and pasting - techniques that meaning-in-white-space languages like make and Python conspire to make this difficult. I want to spend my time programming, not learning to program.

If Nim had a little hype around it, it would steal Rust's shine away.

Rust honestly failed as low level language for me. It works okay if you treat it as high level language, but it's in weird limbo where it tries to be low-level, but doing anything low-level in it is PITA, and it has the feature creep of C++. Async is also complete mess. Final nail to the coffin was for me was that the cross-compiling and static linking story isn't very good, especially if some dep happens to use proc macros. Rust would be better language if its unsafe was actually more ergonomic, and had ability to tell borrow checker the state of things.

You have Zig, a beautiful optimazation between human factors and machine factors.

Ofc you have to study prop computer science, that goes for C also, a lot of people doesn't get how to use pointers correctly, let alone understand rust. I've worked with people who attended the "learn typescript in 3 months course" no previous or after knowledge of programming, the nightmares I have reading their code!

definitely see other people mentioning go more often as an abstract language with somewhat high performance. While rust may be more performant, it takes longer to write, businesses dont care about that. Also I dont think a lot of people REALLY know rust.

Of course you would say this, you have rust in your channel name and therefore must be an official part of the rust foundation because there's no way anyone else can have rust in their name, ownership of the word rust was moved so you get a compile error if you try to use the word rust in a sentence now.

I learn html css and javascript no job experience if i learn rust can i get a job in rust or not

things that would be tiny changes in C/C++ so often require big rewrites of program sections in Rust because introducing new (mutable) references is often illegal. Rust discourages fast development iterations, which is especially damadging when the product vision is not yet totally clear (which is why I can never see it take of for game development). I guess if you want to have super stable, perfomant stuff you rarely need to change, its awesome. But then you are probably a bank and boring af

I don't have fuzzy feeling when my Rust program finally compiles. I have a feeling of wasted time that I spent 10x more time on coding in comparison to similar program in Go.

"you can't even write a linked list without having a mental breakdown" pub struct Node { value: T, next: Option, }

Why even bring up Zig, when it didn't even hit version 1 yet?

Personally, I’ve put rust on a shelf and chosen golang because of job opportunities. Like in a common joke “there are no junior rust developers”. Rust is mostly used in cases when other tools are not sufficient to accomplish a task, that is, by experienced developers, not newbies like me.

I dont hate rust. But i suck at it, I can write it, i can read it. But everytime i write rust, its not clean code and its always really ugly or hard to read or ugly to handle errors or map errors (even with anyhow/thiserror)

I went from C to Rust, and the main problem I had with it was the forced paradigms. It doesn't let you code the way you want to code. You can't write intuitively. It forces you to do things that feel gross and unintuitive, because it doesn't trust you. I just don't want to work like that.

03:24 how zig c++ compatibility without figuring out mangled function names?

The code wars, its always interesting to see nerds fighting on this, but in the end the use depends on the client and their needs. many corporate clients are slow after investing thousands on things like C# to just jump to the next hype, for example rust

For the start, I just think you are taking generic haters so much seriously, and this is dangerous.

Coming from a Java background I find the syntax reasonable, except for lifetimes of course

1:22 This is really a non issue with a TypeScript extension for JS files, but it should be part of the language and accessible in V8.

The map function in js is really Array.prototype.map(callback) which is also very weird

Using an ai tool with rust makes picking up the language a lot easier. The biggest issues i have found is with code samples and tutorials that haven't been updated to reflect changes to the crate.

My biggest problem with Rust syntax is the ergonomics. I start to feel physical discomfort typing Rust far sooner than any other language I use. The double colon is probably the worst offender.

What I always say, do not ask to make naively simple something that is required by force to be relatively complex for safety sake. Just like a airplane cockpit, which, at first sight look needlesly complex, but as you understand it deeper, it has to be like that, but it depends o you how to mentally adapt to it... And in fact, it gives you all what it can offer for you to be comfortable and confident.

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 tried to use Rust in embedded project as "replacement of C" and the size of hello binary in C is 16Kb, the size of Rust hello binary is 3,7Mb (350Kb after strip which is still more than 20x bigger than C). Also if you use it in RTOS like Nuttx you should run it without fn main... So I think Rust is pretty good language but there is lot of hype about it. There are some cool small utils like `ripgrep`, `eza`, `bat` and others but the serious projects like `Servo` where perfomance and safety is very important still unstable for many years.

The worst and most ironic thing about Rust is what he said at the end "If you think Rust is bad it is a skill issue". This is literally the reply to every single negative comment about Rust. The fun thing is that the Rust cult seems to overlook the fact that every single thing Rust claims to fix from other languages like C is just Rust people having skill issues in C. Rusty - "You can't access memory after it is deallocated" C programmer - "Sounds like a skill issue" Rusty - "Rust will never segfault" C programmer - "Sounds like a skill issue" My friend has written ASM and C for 25 years in extremely critical systems and all he has gotten from the company forcing him to switch to Rust is that he is about 25 - 50% less efficient depending on the project. Rust is a great academic exercise it should just never have left the lab ;-)

I do like Rust and there are some good jobs out there (high paid too). If I was to find criticism with it, it would be around the syntax as sometimes it's not obvious what's going on and that to me is a serious drawback. I need to find time to learn because I know it'll be worth it in the long run...

7:16 - C++ also has a lot of string and string like types.

Thank you for your videos! Nice new hair btw🌚

JavaScript is easy to break, so it should be explicit and we need memory safety. Without memory safety you get memory leaks which means hackers can get right in rendering your JavaScript to garbage status. At my company all we use is rust-lang, c++ on the front end but rust-lang wraps around all of that to protect it. C++ & C have memory vulnerabilities. I’ll never use Go since Google’s involved and that’s a no go for our company.

hyper or not easy or hard. only matter is performance. imagine stay in Lunar base and the door dont open. or imagine stay in dive in atlantic and door dont close. for me defnetly is the languge to go for. before C++ this is the next step. I would like to know if can make IA with this language. because after compile he can upgrade with more information? ohh ok i think i respond my self and compare it with a database. main program is stable and no change if no needed. but the database can change and be accesed by the main already compiled program. it can work like that?

You need to update the title on your site, it says cheet sheet

Be careful when you guys say "it's easier to refactor and maintain" etc. Unless you are a professional Rust dev in a team, you probably have no idea if it's true in real scenarios. That's why people call for propaganda sometimes. Every tech is amazing when you only use it alone, on a side project i guess

I honestly hate the "most loved" survey from SO. It's very disingenuous. All they ask is if you've used a language in the past year, and if you look forward to using it next year. If you answer yes to both, you're considered to love that language. Considering the questions asked, to say I love language XYZ is very strong to say the least.

This was a much needed video. Rust is over hyped but has special uses cases, especially in large application and companies. The code base is very large due to boiler plate aka guard rails in the program. I was planning to learn rust but gave up after reading many reddit posts. I have gone with go and mojo

People who talk about rust like it invented type safety or something act like the only other two programming languages are JavaScript and c.

"Developers have to dig into documentation" 😂 I doubt that. They add a console.log() and look at the output.

Worst part about writing rust is you constantly have to interact with people that have bright unnatural hair colors and furry github profile pictures.

I like bash and zsh a whole lot because while these are the polar opposites of rust, they are the quickest for automation. Why write more when you can write less and get the same job done? I prefer rust for more complex applications (most of what I write), but shell languages are amazing. I will admit that zsh's expansions are extremely hard to understand unless you have a lot of experience.

The example of the map method reveals bad faith used in arguments to destroy such a (beautiful) language (speaking about the syntax). Such a method, as plethora of them in std, does have a complex signature, blending most of Rust complicated mechanisms, but as a beginner, most of them can be used without knowing a thing about what it uses. As an example, for map, you don't have to understand what the Map iter is, how lifetimes are handled in closures. That argument is not valid to me. Actually, the whole argument about Rust having difficult-to-master features and syntax doesn't stand: it is a systems language, which means it doesn't fit with people in their first steps of learning programming. That's its essence, not a fault.

Am learning Rust, but eyeing Odin Lang

"There are programming languages that people complain about, then there are programming languages that no one writes in." _whoever, I forgot

about once a year i decide to have a look at rust. then i spend a week trying to write small code snippets and end up giving up and moving back to another language. i'm quite happy with the concepts behind rust. it's just a huge effort to convince the rust compiler that i know what i'm doing. i think rust has some good ideas in it (though it isn't as revolutionary as go). i however do not gel with its syntax.

dang one time i tried rust. the next morning i had a headache

The problem with Rust is that they try to reinvent each term. Most of the time you try to rewire your brain to understand that a crate is a library, or what is an arm or a trait.

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,

I think genetics with primitives are really really bad in rust. I’ve struggled with it twice now, once in a linear algebra library, and now again in a vm. I have tons of boilerplate to get basic ops, and of course those ops panic at runtime, so I have to then add safe versions of those to the generic type, then of course to work with all types of inputs, I need conversions between T and u32, and it just quickly becomes a nightmare to manage

that string meme image at 7:15 is exactly what strings in C++ are like, so really no actual difference there.

When evangelists do not understand why they are not the biggest...

No one writes vanilla JS though; TypeScript can be just as explicit without timelines

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.

Rust is powerful, it's not easy for people do interpreted language, people do interpreted language needs less thinking, it's straight forward, those compiled language is very hard to think , you need to dedicate for 2-3 years to master it. You can make anything with compiled language it's the fact

Its been 4 months since i started learning rust and i hate it very much , i hated everything works from 1st time without crashes. I hated there is always something telling me you should handle this option value whats wrong with nulls. I hate the community that always help me they should just leave me alone 😭. I also hate how fast it is, how i will i get paid for optimizations? Lastly rust introduced me to embedded systems and Game development while im a web developer

Virgin Rust dev: Pleeease, I need you to compile my pwogwam 😭 Rust compiler: Noooooo !!!! You didn't respect the owner ship !!!! Meanwhile: Chad c++ dev: Trust me bro, this float is now a pointer to a function. Chad C++ compiler: Yes, Master. _Segfault_

7:16 This is the point I started to have problems with Rust. and it make code too much verbose. and too much boilerplates + if let block hells like an arrow, I agree that it makes safe in types and memory but ironically it puts business logic away from "safe". there is a boilerplate on the threads(not only creating the threads, but also copying the values is not easy). and I recently was surprised on 'let mut'. it is a basic keywords, and if you say 'let' it guarantees the value(and the value inside the structure, even list, map) would not be changed. but actually not, you can change with RefCell and something. I was very surprised when the "magic" happens inside. I believe and I can see Rust is getting better and better. but for now, using Rust seems like I make a sand castle by moving a grain of sand at a time.

Rusts syntax interestingly wasn't that much of a problem for me, but more its compiler and tool ecosystem. It's hard to install in windows and for me basically impossible if you want to set custom directories and already have a C compiler. It just always conflicted with another compiler or something.

I love how some people badmouth Rust, while corps like MS and even Linux adopt it like "welp, why not?" On my side I will always choose Rust, mostly for the backend dev, over other languages like TS.

My annoyance with Rust is due to the armies of Rust developers trying to push C++ out of existence. It was refreshing that you made a point of _not_ doing that.

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

Most liked and most hated often go hand in hand, it has to be big enough to get on peoples radar and polarizing enough to get strong opinions - good or bad.