Why do developers hate Rust?
ฝัง
- เผยแพร่เมื่อ 16 พ.ค. 2024
- 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: letsgetrusty.com/cheatsheet - วิทยาศาสตร์และเทคโนโลยี
![[Live สด] การออกรางวัลสลากกินแบ่งรัฐบาล งวดวันที่ 16 พฤษภาคม 2567](http://i.ytimg.com/vi/3RndUC0cyV8/mqdefault.jpg)
📝Get your *FREE Rust cheat sheet* :
letsgetrusty.com/cheatsheet
Богдан здаров, часом ща не приехал погостить на родину?:)
@@sergeydev8273 "too woke" - это он точно подметил
There are more jobs where you talk about Rust than there are jobs where you program in Rust.
Yeah, sadly when I write something in rust it just works and no one needs me to put out fires constantly. So I am just talking how great it is.
@@OrbitalCookie Sadly you'll never get back that time you wasted learning Rust 😂
It's not that difficult to learn imo. It's just different. @@jazzycoder
Sounds ideal
Sounds like a bubble.
I think Rust's biggest mistake was not calling their objects "Buckets" Then they could appropriately be called "Rust Buckets".
but crate goes well with cargo
Missed opportunity indeed 😅
The hostname of my development machine is "Rusty-Bucket". Maybe I should put it in a bay?
Sounds like something a character from Monty Python could say
@@RenderingUserYou can always say "Rust cargo" or "Rust crate".
Who said that crates are not made of metal and cargo can't be of metal parts?
2. Comparing a weakly, dynamically typed language's syntax to a statically typed language is unfair. The latter will always be more verbose.
Counterpoint: Haskell. Haskell's declaration of map is literally
map _ [] = []
map f (x:xs) = f x : map f xs
(I wrote it off the top of my head, but then checked and the official implementation is 100% identical)
It can't be less verbose than than.
Recursion everywhere ❤
@@vytah True - but although Haskell is statically typed, it's also strongly typed, not weakly.
@@tobiasvl Haskell is strongly statically typed.
@@vytahReal programs in Haskell have type signatures for all top level functions and often inside functions for the sake of documentation and correctness. All the user defined data types often consist of smaller type helpers and other types too (e. g. newtype definitions). All this is usually not present in the programs on dynamic typed languages.
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.
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.
When rust is better it's serious, but when it's criticised it's "oh skill issue, whatever, your lang unsafe"
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
Compare to big js project linting time it's not to much difference
@@user-hy5cx9iu3l nah..its not comparable. Compile times of a big rust project and the lint time for a big js project cannot be compared...rust still losses. The compilation time thing is a big issue and will always be a shock unless its fixed
Incremental builds during development are pretty good, imo. Often with Rust, people don't treat it as a systems programming language, and compare it to non-systems languages, like Go.
Its one long compile the first time you start a large Project. Every compile after that will be fast. If you dont spend all day changing your depndencys, you wont notice the compile times.
@@nsubugakasozi7101 you just haven't seen big js projects
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.
Huh? Why do you want to depend on some third party code for something as basic and fundamental as graphics? Build your own. Regardless of the language.
One only has one life 🙄
@@vitalyl1327 Yeah sure, graphics can be basic, just like an AI can be as simple as a goomba from mario that only walks left and right. you're definitely not writing your own graphics lib / gui toolkit that is cross platform across mac, linux, windows. doesn't even make sense.
@@dany5ful have you seen the Dear I'm Gui library? A perfect example how easily a cross-platform GUI can be written. Look at it, understand it, then write your own.
Have you tried Iced for the GUI? It's being used to create an entirely new desktop environment, Cosmic.
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.
Ruby is an elegant language. So it's good to ask you: As beginners, we run away from Rust because we hear about it's difficulty? What do you think beginners should do in the first 3 months to keep cracking this difficulty?
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.
You and me both. Believe me, the worst kind of "magic" that can be on programming is the one that the developer has little control / information on how it works.
those two things have nothing in common. A language can be simple and have compile-time checks.
@@hwstar9416 Or complex and needs more of them aka C++.
@@hwstar9416 that's not quite true. With simplicity comes ambiguity, sure there can be compile time checks but there are still much more assumptions being made by the compiler. (Proper testing can mitigate this concern however)
@@boycefenn "With simplicity comes ambiguity" I'm sorry what? I think you're confusing different ideas with each other.
"there are still much more assumptions being made by the compiler" What do you even mean by this?
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.
Yeah, but that’s kinda by design
Rust has a lot of its own design features to force you to make safer code. Obviously, having concepts that basically no other programming language has and don’t directly translate into compiled code does make it a lot harder
@@palmberry5576 It doesn't help that a lot of times those features are enforced needlessly. If I already checked this object for safety, the last thing I want to see from the compiler is telling me I am not allowed to do it because it's "unsafe".
Have you noticed almost every, if not all, beginning Rust tutorials use the macro ‘println!()’ vs ´print!()’.
Because you can’t simply write:
print!(“What’s your name? “);
let mut name = String::new();
stdin().read_line(&mut name).expect(“Failed”);
You have to flush the buffer. 😮
print!(“What’s your name? “);
stdout().flush().unwrap();
let mut name = String::new();
stdin().read_line(&mut name).expect(“Failed”);
It depends where you are coming from - if you have experience with functional programming and C++ Rust will be also easy (it was for me at least).
@@GaryChike Well, that's standard in system programming. In C/C++ you have to do the same - stdin/stdout/stderr are buffered, doesn't matter if you use fprintf or C++ streams. You can also disable buffering if you need to.
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.
Does anybody actually say that? I've been programming in Rust for about 6 years, and I don't think I'm an expert yet. But to be fair, people certainly overestimate the difficulty. The classic "fighting the borrow checker" is weird, because you get the hang of it fairly quickly. All you need to know is who owns the data, and that you can only mutate in a single place.
@@tinrabI'm working with Rust for quite some time and I think it's freaking hard to learn. The borrow checker is only the first hurdle.
"The function exists on type X but the trait bounds are not satisfied" 😭 just one example.
Rust is praised for it's great error messages, but they only make sence once you understand why your code should be written differently.
I still love Rust and I'm productive, but it's a painful journey. I think the pain pays off, but it's pain nonetheless 😉
@@tinrab Borrow checker is the simplest to grasp imo. But there is also the type system, lifetimes, the way macros are...
@@gzoechi Oh, that would mean that the function exists, but only on a trait, so you need to implement it. But yeah, it's hard.
@@tinrab I know what it means, but not how to figure out what trait is not implemented. It's easy for my own types and traits, but hard to figure out if it's from dependencies.
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.
That's basically the kind of code I mostly write for work as well, with also often having to provide a GUI of some sort from the get go, plus an integration with external formats and/or applications.
I normally used C++ and I know enough about it and the ecosystem to not be in pain all the time, but in reality writing C++ feels like walking in deep mud with slippers with no end in sight, a horrible unrewarding experience.
I tried Python for the prototyping stage, but it just doesnt make sense in most cases because I'll always have to rewrite in a serious language anyway for a plethora of reasons so might as well not waste my time and use it from the start.
I tried Zig, but it's way too unstable and unfinished at the moment, I can't afford having to deal with constant changes to the build system, standard library, etc. Also, it's not the most convenient language for shitting out code that you don't really care that much about. It's great for achieving very particular things in a very particular way. Great for when you want it, pain otherwise. Also, it's extremelly niche and has basically no documentation or resources for non turbonerds to learn, so good luck pitching it to your coworkers and boss.
Rust has so far been a hit. It has nice tooling, superb documentation with lots of examples, lots of crates for doing various things, and I find the iterator adapters and various other functional aspects in particular to be a huge convenience for the type of domain code I write. Sure, it is quite hard to learn fully, especially for a newbie, though not anywhere near C++ level of hard, not even close. The difference being that there is a sense of reason and intentional, consistent design all throughout, so lots of things fall into place when you come to understand certain key aspects of the language. Sure, some things tend to be more verbose and inconvenient to write than I'd like, but with all the other positives considered it's still come out on top for me.
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.
He probably is failing to take advantage of what could be done at compile time to improve reliability and productivity. But real engineers are used to not having their hands held, without people dying. They distrust abstractions they have not traced to the roots. A convenient abstraction is an extra burden when you accept that responsibility. And they hate modern products made by non-engineers who can't be bothered.
@@sciptick Aren't compiler flags "compile time"? I'm confused...
Barring that, I think you've got a point. I did notice a strong through-line with him... about how "you should know how things work" and that "if you do - you won't need all this obscurantist fluff to make them work".
The more I think about it, the more I tend to agree. But I also acknowledge that most domains have their quirks some of which make knowing what's actually going on almost superfluous to the task at hand... :|
Not everything is a spaceship, a high-speed train torque control system, or a military communication encryption unit... some things are just non-critical software someone uses to draw funny pictures...
Yeah, I don't have the same experience as he does, but I came to the same conclusion. It doesn't seem like Rust is capable of resolving an actual existing problem without creating many others and multiple roadblocks for you.
@@Leonhart_93 My follow-up after a bunch of fooling around and finishing a test project is "It depends", but I think I'm starting to get where he's coming from.
@@arcuscerebellumus8797: "It depends" is probably the right stance. After the few times I've poked at Rust, my opinion was that it should be considered for things like avionics, and Linux, and maybe nuclear power plants, but I also started poking at writing my own language because I just couldn't agree that the language was actually good. It almost seems bad in a less severe form of how C++ is bad... or maybe not even less bad, but instead slightly differently bad. It's like the designers thought of a few nice _pieces,_ but didn't consider the larger language surrounding them.
And for the life of me, I have no idea why they haven't made compilation a two-stage process so that precompiled libraries and object files can exist. It should be fully possible to output borrow-checking and similar info so that language guarantees can be completed at link time.
Where is "slow compile times" on that list?
Surprisingly, not there
Well, actually, C++ has a similar problem. There is a cppcon talk of Chandler Charruth about the cost of C++ abstractions here on YT, and one of the currencies you are paying for using them is "compile time". Which in C++ is mostly due to all that template stuff, in Rust it is mostly due to delivering libraries as source code. There is big room for improvement here on the Rust side. The other weak point of Rust is C/C++-interoperability. There's cbindgen to get access to C functions and data structures and use them in Rust code or exporting Rust code to C, but there is nothing allowing for the usage of C++ code in Rust. That's why Rust isn't the best candidate for a successor to C++.
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"
Agree
It'll stick around, but I don't think it'll be the final C or C++ killer. It'll probably always be in second or third place for low-level systems languages.
One day Rust will be as perfect as Dreamberd.
And then we'll wake up
Even using brainfuck as a joke programming language is funnier than dreambird
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.
More or less direct comparison is with Ada
Yeah I remember when I programmed trading bots as a hobby in JS and the bots would crash randomly every 1 or 2 months.
And when I joined a new job, I noticed their JS microservices would crash due to running out of memory and the team's solution was to increase the server memory every time.
Those experiences got me in interested in learning Rust.
In Java and Typescript you don't Need to compile to know everything works.
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.
So here's the thing I think happens with things like Rust, and say... Linux (probably other things too?) ... Godot - They are complicated and don't work the way you expect out the box, so people spend a bunch of sunken time trying to make them work, trying all sorts of different things, reading docs, trying to understand from the mindset of the creators ... that you can eventually develop a sort of stockholm syndrom or sunken cost fallicy, where people just start to obsess over the thing and get into arguments over minutia with others in the community, forms a sort of cult, where these videos are the cult leaders.
There are definitely other REALLY GOOD tools out there, that get the job done, are not surprising, are even pleasing to use, but since they aren't complicated and confusing, don't get nearly as much air time because there's not nearly as much to talk about - "It does the thing without issue" is not as interesting or mind snaring
@tomasbanzas2431 : I would have written this myself if my english had been better 🙂
it's a mentallity thing. i don't feel like going in to politics - but have you ever looked at their profiles? hell- their github's even, there's a reason why there's 15 different "problems" that nobody else ever heard about.
There's a reason why so many have 20 different flags in their bio's.
It's not cause it makes them better team-players, and it's not cause it makes them office compatible.
I thought being an embedded engineer made me the worst sack of ass on the office floor. But i'm starting to doupt that title should go to the mentally distraught smelly there in the corner.
The language won't be mature until people are allowed to complain without waffling.
I agree: I only searched about Rust on Android, not about dislikes; it’s YT that recommended that to me (I should have known better).
The 1st video on the dislike topic was a parody, so actually meant to praise Rust. And now this one; second red flag IMO.
The last time I experimented, Rust was still developed in OCaml.
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.
Yeah that's stupid. When I already checked if the object is ok before use it, the last thing I want from the compiler is for it to tell me that I can do something with that object because "it's unsafe".
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.
Yeah, that's how every good business decision will look like. Ultimately this will be why Rust will never see large adoption.
Rust looks to me like Swift done the hard way.
I'm actually wondering if it would be possible to create a language that starts out like Swift, easy and relatively safe, and which can get progressively safer if you opt into that.
For example, the reason Rust needs all that borrow checking, is because almost all variables in Rust are by default passed by reference, because of course that's faster than copying by default, which is what Swift does. But what if you'd start out with a copying-by-default model, because that's much simpler to work with, but you can opt into a passing-by-reference model whenever you want to make your code safer?
let str1 = "This string constant will be copied by default"
var str2 = "This string as well, but this variable is mutable"
let ref str3 = "This string constant will be passed by reference, ownership and borrowing rules apply"
var ref str4 = "Same for this mutable string"
Or something like that.
@@EvertvanBrusselyou can pass both by reference and by value in Swift.
@@EvertvanBrussel wdym rust is pass by value by default. To pass by reference, you need to use & or &mut (or unsafe)
@@SilisAlin Yes I know, but then Swift does not apply the ownership and borrowing rules of Rust in those scenarios. Swift relies on ARC, which works well enough in most situations, but is not as safe as Rust's rules for references. For example, in Swift it's still way too easy to create circular references that then never get deallocated.
@@yuitachibana8829 If I understand correctly, in Rust when you pass a variable, in most cases, you're either transferring ownership of the value or you're lending / borrowing a reference. Both of those I would say is "pass by reference", since "pass by value" usually means to copy the value. And as far as I know, copying is not the default behavior in Rust except maybe for super simple types like integers. In Swift, structs are passed by value, meaning that they are copied by default.
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.
40+ years in java, can confirm
Amateurs
@@Hello-fu5wdThat's impressive, given that Java 1.0 came out only 38 years ago. Was it even called Java at the time?
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.
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".
Elixir for most of your codebase and Rust for performance critical components is definitely the best option
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'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.
The biggest red flag is when you can do something faster in assembly than in a supposedly higher level abstractisation. The whole point of not doing assembly is that it's slower.
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! 🙂
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.
Re: point 2
This is still more complicated than Java which is also statically typed. What is the benefit?
If Nim had a little hype around it, it would steal Rust's shine away.
true and real
You wish.
Is Nim implementing 'Ownership and Borrowing' constructs? I know D is implementing it. I do like both Nim and D.
@@GaryChike not a borrow checker, but look at the move semantics in the docs (=sink, =copy, =WasMoved) which accomplish similar things, but a borrow checker with their memory management model would be redundant
@@sp.n7401 Excellent to hear!
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.
Why do all the Rust developers just push this "safety" "safety" wherever they go? What are you all so afraid of? It's not like Rust makes memory errors impossible, in complex projects they are still very possible, it just cuts down the usual basic ones. Which is not good enough for the price you pay in obscurity of implementation. At least C++ let's me implement anything I envision.
For the start, I just think you are taking generic haters so much seriously, and this is dangerous.
But good video nonetheless
Hater
"hate" because this language is pushed and promoited like u must learn it... or u have no job in the future or smt..
and so many junior or self-learners think they can learn Rust... meanwhile they should actually go to universdity for 4 years and learn Computer Science ,
Learning rust when you dont understand how CPU works, how to read and write binary and how lower level stuff works and computers and OS in general... is pretty dumb to me.
What the hell arte you doing with ur baasic rust knowledge? No company would hire you, Rust is not used for trivial things like web, crud api
one problem with rust and learning is also t hey want to sound different for the sake of being different, they rename concepts
they call data structures compound types? why?
languagesa should stop renaming things, it just confuses people
Rust Foundation drama itself showed what thy are... Rust will have same fate as Haskell... obscurity because of elitism and snobism
"my program is bettter than yours,becvause im using rtust" ,
if rust would be so good as they claim, every single company would be using it
im neutral about rust, it looks nice @ hello world level...
but when look some larger codebases, its very terse and unreadable
I'd rather use Crystal , if it would be more mature language
"most loved language" is a myth , taking stackoverflow survey seriously is illogical
it's very small demographic, mostly americans and old guard... and certain type of toxic people
dont people know how toxic stackoverflow is?
all the countries in the world actually have different languages wich are most used and loved
for example in Estonia python is almost not used at all , but Kotlin, Php, JS , C# gets heavy use. Now some Elixir as well and Go
Literally have seen ZERO Rust jobs in this country.
Basicly all the large companies use Kotlin/Elixir or C,C++
@@JorgetePanete and that works just fine until you have to define 1000 trait bounds to T just to get it working the way you want. Imagine you have 100 different types that need those trait bounds and you have a boilerplate nightmare
@@Microphunktv-jb3kj Sir, this is Wendy's.
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.
Vast array of files and directories? It's literally just `Cargo.toml` (Rust's equivalent to `Makefile`), and a `src` directory containing a `main.rs` containing your `main()`. Sure, it also initializes a Git repository for you by default, but you can opt out of that with `--vcs none`.
Maybe just use rustc is you just want to compile a single file? You are doing the equivalent of creating an entire CMake project, with a src dir, setting up vspkg, etc and then whine that is is not the same as just calling gcc.
@@Giga4ever All the dependencies you're likely to want (especially with Rust's non-batteries-included standard library) assume use of Cargo. That's why rust-script exists and there's experimental RFC 3424 to explore the design space for supporting something similar directly. Invoking `rustc` directly is meant for implementing Rust support in build systems like Bazel. It's what Git calls a plumbing command, as opposed to a porcelain command.
@@Giga4everThat didn't work when I tried it. It was a long time ago, so things may have got better. I don't have lots of free time to keep plugging at it until it gets better. Zig was nice, easy and quick right out of the box and so I was able to be productive with it in a few days of practice and getting fluency in the language. However 35 years of writing C and almost as much writing python, I don't really need to be nannied with new languages. I can get my work done.
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 ;-)
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
Curious what you mean by "private inheritance as composition" as an issue? Also, yeah, lack of variadic generics is a nightmare atm (have to do annoying macro stuff). Another problem with Rust atm is that constructors return the value. Compare this to C++ which constructs using a pointer to the class. This makes in-place construction (almost) impossible in Rust.
@@vitulus_ C++ frequently uses a composition pattern like, struct person {string name;}; struct student : private person { grade gpa; }; this is not a polymorphism, but it allows easy auto implementation of traits, serialisation, CRTP etc possible.
Macros are pretty much the only really good thing in Rust.
@@vitalyl1327: Not a fan of Rust macros. The ability to add arbitrary syntax is something that languages should usually avoid, not support.
@@absalomdraconis if you think so, you do not understand programming at all. Meta-languages are infinitely (literally, no exaggerations here) more powerful than the fixed languages.
You have Zig, a beautiful optimazation between human factors and machine factors.
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.
Do you use `use` statements enough?
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.
muh freed pointers!
I agree. And when you use unsafe to try to tell the compiler you know what you’re doing, the compiler tells you “you might know what’s going on in c, but you don’t know my rules.” So you end up getting a situation where you write it exactly like you would c, but it’s truly undefined in rust. So annoying. As someone who’s using rust actively for a largish project now, I can say I just don’t love it
This is one of the key things that always bothered me with Rust, The fact that it will warn me if I don't use a certain case type while writing out variables or whatever is frustrating.
@@MasterBroNetwork I don't use Rust yet, but maybe rustfmt helps to format everything in one go
@@JorgetePanete That's just it, I have my style for variable casing or whatever and I do not want to conform to Rust's style so the fact that it complains for me not using a certain style is infuriating.
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.
People who talk about rust like it invented type safety or something act like the only other two programming languages are JavaScript and c.
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_
I like the C++ way, just give me complete control, and it will be my responsibility. At most I will allow it to warn me about it and then shut up.
@@Leonhart_93 The more experience you get, the more you will understand that you are not as skilled as you think you are.
@@Giga4ever The more experience you get, the more you get annoyed when a compiler says "you can't do things your way, you have to do it my way".
When I tried Rust I was always like "you don't get to decide, just shut up and let me do what I want". It was seriously annoying. Those that life Rust are into being told what to do at every step.
When evangelists do not understand why they are not the biggest...
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.
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'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.
It does sound like Rust is a poor match for the type of development you need to do.
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.
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 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.
Those who seek a job as a "programmer in a language X" are either very junior, or simply delusional.
@@vitalyl1327 I may be delusional. Definitely not junior. 30+ years at this. I get satisfaction from writing very high performance and high quality code. I can't do that with just any random language. You sound like the kind of programmer that is much more concerned about the problem to be solved. I am concerned about it being solved well. FYI - I currently write code in FP focused Scala.
I'm liking it more because of its strict typing. I came from TypeScript and I'm fairly a newbie in programming as a whole. I don't know much about how its async operations work unlike in JavaScript though. What I don't like about it is that they use tokio, a library, for async.
@@DCameronMauch there is no such a thing as a general purpose language. If you're a "programmer in X language", you're limited by definition. If you're a generalist engineer, you will use whatever language is the best for this particular problem. Or you'll build a domain-specific language for this problem.
Just imagine saying that you're a rice cook, or a screwdriver engineer.
@@vitalyl1327 Rust seems like a general purpose language to me. I am sure I can solve like > 90% of the problems out there using it.
"There are programming languages that people complain about, then there are programming languages that no one writes in." _whoever, I forgot
Bjarne Stroustrup (defending C++)
The guy who created the greatest language we have.
@@indiesigi7807 nope, just sh@tty useless abstractions over C
@@indiesigi7807greatest by what criteria?
Its main benefit is, that it's so low level you can do anything Assembly can. There also is no language with more footguns.
@@gzoechi I enjoy it.
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.
No pun intended, but if you look into Rust as a Python dev, you are looking into your car's engine as a car's owner - you will have no clue, what is going on there. As C is, what makes Python going (i.e. the interpreting engine of Python is build with), and Rust is a more demanding (but also more reliable and more powerful) version of C.
Now, I've been around in the programmer scene since the early 80s. My first programming language was BASIC, and when Pascal and C came around, my first stumble was "wait, what, no line numbers to GOTO or GOSUB?". It was a culture shock. Python and Javascript are the BASIC languages of the 21th century, the journey toward writing programs can only start there. If you can get your job done by writing Python scripts only, be happy and do not worry about not understanding Rust.
Yeah, I believe, Nim is a better alternative, especially for Python devs - you get very safe and fast language without the borrow checker restrains and a Python-esque syntax as a bonus.
@olafschluter706 The more accurate analogy is that you are looking at a niche product's engine, while every other engine in the world has a different design.
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!
Rust is an overengineered Turbo Pascal clone.
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.
Tell me you never read documentation without telling me you never read documentation
@@gato-rs That's not nice. People have their own methods of helping them learn. No reason to believe they don't read documentation because of that.
@@vitulus_ "The biggest issues i have found is with code samples and tutorials that haven't been updated to reflect changes to the crate." That leaves it clear
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.
Thanks, I just knew they gamed that survey data, considering Rust is barely used for any serious real world applications.
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
I'll tell you the only reason I ever feel "hate" towards Rust, and it's people propagandizing it and acting so sanctimonious about how immature and inferior every other languages supposedly is.
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
It is true, but it's also the case for the opposite, people cannot say it will be harder to maintain without having done it in bigger projects with a team.
Only lang-specialized professional devs can refactor and maintain code so I don't know why you're thinking he's wrong
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.
I did a brief stint writing Go. I hated it. Too overly simplistic and unexpressive language for my taste. Things I can write in a single line of Scala takes like 50 in Go. Anyways, just having that on my resume, I get contacted all the time about Go jobs.
Zig isn't even at 1.0 so there aren't going to be serious jobs for a long time. It is a fun language though.
I think you will see jobs for Go in web development.
@@DCameronMauchthat's my big problem with go, for something that sells itself as easy to understand. It's really frustrating having to read a novel to figure out one function. Yes, each of the lines are trivial, but there are a billion lines that in most other modern languages wouldn't need to be there.
@@ngin6917 go syntax can be verbose. however you can do stuff with go that you just can't do with any other major language. the concurency primitives and support in the runtime are revolutionary.
If a five-year-old can learn and program in golang, it is a strength rather than a weakness.
Thoughts on Nim? Also memory safe, statically typed compiled.
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.
I don't even know why people compare Go and Rust, they belong to niches that do not overlap. There is a garbage collector in Go, it cannot even be considered for the use in the same domains where Rust or C++ can be useful.
I don’t think “it takes longer to write” should be a problem, but if it is then it is definitely not the right language for problem at hand.
@@vitalyl1327 thats why they get compared. Do you want an easy language that does stuff for you but lacks efficiency (that many will not actually benefit from)? or flexibility to get granular?
also they are both somewhat young languages, were c c++ are both older.
why do we compare but to point out the differences?
@@Chimperly this is not a question about languages, it is a question about problem domains. Does your problem require a predictable language? If the answer is yes, all those toys like Go, Java, C#, Haskell, etc. go out of window and you're left to chose from the real languaves.
@@vitalyl1327 does your problem require concurrency? looks like it's go then ...
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.
You mean he has &rust in his name
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
anyone know if there is database support for teradata and microsoft sql server?
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.
Worst part about writing rust is you constantly have to interact with people that have bright unnatural hair colors and furry github profile pictures.
Finally someone says what I was thinking lmao. The community for Rust is garbage.
Why is this like, bad?
@@edwin5145 it's "bad" because @porkfatrules is sch1zophrenically engaged in the culture wars and thus is constantly looking for a weaker scapegoat to blame his problems on
@@edwin5145 Not bad. Totally cool if you're into it. But I feel too humiliated when I'm getting talk down to by someone's fursona for not fully understanding the intricacies of the borrow checker.
@@porkfatrules yeah but that's shitty behaviour in general for sure. Sorry you experience that.
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.
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
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.
Thank you for your videos! Nice new hair btw🌚
A callback is literally just a function passed as an argument to another function. Callback IS the input type.
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 think the main issue with Rust in the domain C++ is applied is its poor C++ interoperability. If you are working in a C++ eco-system, then you want something that can seamlessly use what is already there. And C++ struggles really hard to find a successor language and - since the recent Cybersecurity Report to the US government discouraging the use of C and C++ - is in dire need to have one. AFAIK the first new programming language with C++ interoperability in production quality is Swift (and only since recently, C++ interoperability has been introduced with Swift 5.9).
Don't do it, you will be shooting yourself in the foot when Rust fails to get the right adoption. Just become even better at C++, learn some advanced applications for it, like drivers for low level hardware.
@@Leonhart_93 In my experience if we're talking about drivers it's C++11 tops in production and more often C++03 or plain old C.
Newer C++ standards adoption is also pretty low. I personally faced C++17 (C++20 at best for some open source development like envoy proxy).
And even with all goods of C++17 it's the gun pointed to your leg in the first place and programming language only after.
@@LiveseyMD Slow adoption of newer features is indeed an issue for mature projects, but due to the nature of the language it's not that limiting. Hell, people still build and maintain performant systems using C, which barely changed at all over the years.
But I think that is exactly why C/C++ will always find purchase, while Rust does far far too many abstractions and forces too many liming factors to be universally useful. For example game dev, some required things are just unwieldy in Rust.
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.
there are tricks to get rust down to the size of C, that's not the biggest problem.
But in small embedded code, you'll end up with unsafe code everywhere, so you might be better off with c or zig.
you can strip the debugging symbols out. that accounts for a lot of bloat. embedded zig would be awesome, though.
You can use no_std and end up with 15kb in Rust.
@@Giga4ever yes, but in C and C++ I do use std
"you can't even write a linked list without having a mental breakdown"
pub struct Node {
value: T,
next: Option,
}
Great now make it doubly linked
@@salvoilmios Double linked list has runtime invariants, that are not easily representable with the Rust's type system, that's why it feels so verbose.
But in C you just completely ignore the invariants and pretend that the program you just have written actually works.
@@salvoilmios
Just use a couple Rc's and you're done.
In all seriousness, these things are only difficult in Rust because Rust developers try to make them better than they are in other programming languages. It doesn't take much to get JavaScript-level performance using Rc's or C++ levels of safety using raw pointers. The issue only starts when you want to surpass that.
No Box for the value?
@@bryandata6658 No need to box T here, Node completely owns it and will be allocated in heap, since the previous Node boxes it.
7:16 - C++ also has a lot of string and string like types.
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
Coming from a Java background I find the syntax reasonable, except for lifetimes of course
I guess most people who have problems with Rust's syntax don't have a proper formal background in Computer Science or Computer Engineering and just code in languages like JS or Python
@@riccardosagramoni8016 No, I have all of that, I just hate that it tells me what to do even when I took all the right precautions to make sure there is no way I created a memory issue.
@@Leonhart_93 Are you really sure about "taking all the right precautions" in 30, 50, 100... thousands of lines project? I don't think so. We have computers to think about "taking right precautions". I feel just safer when I know that I possibly can't create a memory unsafe code. We are people, and we make these kinds of mistakes. And I don't want for sure my code to fuck up in production because I was too confident in my rightness.
@@rastr__9042 Safe, safe, safe. I never felt unsafe, if I made a mistake then it was my fault and then I strived to make it better. That's how people wrote code for like 80y now and it doesn't seem like it slowed down our progress in any way.
But forced restrictions at every step, even when they are not required, is not the way to go.
"I'm not going to sit here and tell you you should use Rust for every single use case, even though that's absolutely true." Not cultish at all.
programming in rust is like driving a car with square tires...
The problem is that there is no need to make a programming language that difficult. It is true that there are things that are done for certain benefits. But it is evident that the creators did not have enough creativity to make it easier to use or learn. For a programming language to be good, it doesn't have to be difficult. Hard to learn means that the creators don't care about the community, they just want you to conform and only care about their needs. Whoever makes a language for an entire community makes it simple. so that there are many people who use it and use it well.
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,
Coming from C++ the Rust syntax feels really nice and clean I gues that's perspective for ya.
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.
I have been learning Rust for last 1.5 months. There are some challenges, which I faced, but its OK because thats what learning other languages I have faced. Coming from Java background, it was easy to understand Rust.
Only big issue is Lifetimes thing, but there compiler or RustRover helps me, but I need to myself get an proper understanding of it.
I have solved some problems on Arrays and Strings, as part of practise and getting familiarity with Rust, and it was different experience but nice too! I wrote code in Java, Kotlin and Rust for those practise problems, and it was amazing to see how beautifully the code works in 3 different languages.
I think Rust deserves more serious attention, and lots of practise, to master the concepts, get familiarize with methods of various collections, arrays, strings, etc. Once that is done, we can do lot of things with Rust!!!
I am Proud to be a RUSTACEAN!!!!
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)
thats just like how rust is...
nothing to love there, unreadable
i like Crystal , C-native bindings
if the language would be more mature, i wouldnt be afgraiud to use it ; ) in production
Its basicly what typescript is to JS , Crystal syntax is almost identical to Ruby but has c speeds and statically typed
@@Microphunktv-jb3kj I came from a C++ world and rust is literally a godsent in that direction.
or rather a better replacement for shit that needs to be secure / hard to crash.
So, in that regard i still love rust.
Never tried crystal, did try ruby; didn't like it.
But tried Elixir and it was really fun to work with
Read more Rust code. Read lots of other people's code. You can also request a code review on r/rust.
You're not writing unreadable code, that's just rust code
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
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.
I learn html css and javascript no job experience if i learn rust can i get a job in rust or not
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.
what does your company have against an open-source project?
@@EdouardTavinor against Google you mean. Yeah we don’t trust big tech with anything, they always exploit the general public. I won’t have anything to do with them.
Uh what the hell? Rust has memory leaks too.
no language is invulnerable to "memory leaks" even python can also leak
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.
But they use them in OS, I think you don't need to go from one extreme (TS) to another (rust)
Who said going extremes? I just said that based on what I worked with, I will always prefer Rust over other languages.
@@takahashinji5286 rust and ts are extremes in backend
Why even bring up Zig, when it didn't even hit version 1 yet?
Bun and tigerbeetle are written by zig, and Uber is using zig already. So, it's not wonder that people bring up zig
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...
Never met a client who cared about which language you are writing the software in that he wants. The thing they want to know is how much and when - how much will the development cost and when one can deliver.
I like Rust but I like C more even though I know it is a worse language in terms of safety and even features one reason why I think people hate rust is because they like some languages like I love C and then if someone says rust is better it kinda demotivates you and you start hating your preferred language because it its worse than rust but you also hate rust because it made you hate your preferred language but that just my opinion
7:42 "Don't blame a perfectly designed language on a skill issue" is certainly one of the statements of all time
(Edit: for context, he says "jokes aside" like 3 seconds later, of course Rust is not a perfectly designed language lmao)
a perfectly designed language🤡and then you try async Rust. Bro just can't keep Rust propaganda from spitting out of his mouth. I doubt he has any technical expertise aside from being a tech content creator to begin with
@@rw_panic0_0 I think async is pretty good. What does it look like in other systems programming languages? We'll see how Zig turns out. You have async/await, where `await` is a suffix call, which means you can have chaining. The hard part comes with pinning, but I almost never have to write that. Streams are also great. Recently I've been using `async-stream` create, which allows creating streams with imperative code and using `yield` keyword, just like "generators."
>perfectly designed language
Rust is many things but "perfectly designed"
It's *almost* perfect.
@@rw_panic0_0 Whats are your Problems with async Rust? Its very performant and easy to write once you have some experience.
At 7:40, you mention about skill issue. IMHO, I think it's not the skill issue, It's more of -- Wasting more time learning a programming language than giving more time to write big software's.
If a programming language itself is giving more headache that actually focusing on writing software, there seems to be an issue with the language and needs to update itself. I'm not a Go dev btw. I write programs in C++ and Python.
You nailed it. This is the reason why it will never become as widespread as C++. The language should just allow you to solve a problem, instead of becoming a problem to solve.
You need to update the title on your site, it says cheet sheet
"Developers have to dig into documentation" 😂
I doubt that. They add a console.log() and look at the output.
Sometimes people can not acknowledge that something newer is better when they have worked with something older for longer.
Amen.
More often I've witnessed the opposite, with people thinking that newer is better than older (e.g. the newest Electron-based framework is surely better than the older smaller faster thing...). People accept new things just fine when those new things fix the problems they had with the old things, rather than just solve old problems they didn't have to begin with while introducing new problems they didn't use to have.
If 20years experience with c++ equals 10years with rust and you have the c++ experience, then you might be 40-50 years old and retire before rust even squares
I'm a developer with autism. Rust is neat and the safety features are pretty cool but it doesn't satisfy my curiosity like C does. If anything, Rust doesn't even compete with C but complements it.
I think exactally like you