That article has the vibe of being written by someone who just had a week of learning Rust and then gave up.

This is the type of guy that gets things done fast but never maintained his own code

Sometimes I'm so prepared for the rust analyzer to tell me how dumb and worthless I really am. I see the errors in the corner of my eye taunting me. They want me to give up. But then I finish some line and the warnings fall eerily silent. I nervously hit build. It works impeccably, no issues, it's fast, it's efficient, it's beautiful. Those are the moments.

I feel the "it works" factor is a massive positive for Rust in the embedded space. I abandonned C++ because Cargo & Cross "just works", rather than fighting with the build tooling to figure out how to get C++ libraries cross-compiling / cross-linking correctly.

"You should use a garbage-collected language just to get things out the door." Got it. LISP, HERE I COME, BABY!

5:10 The problem with MVPs is that they very easily and quickly become the production code. Once you get an MVP out, so do the requests for changes and improvements and additions. Before you know it, you have a full blown core system written in a scripting language. So do you choose what’s easiest or should you pick what you want to end up using?

Half the comments: "Well, that's just a skill issue, but not a problem if you *really* know rust". The other halt: "Screw c++, it's too complicated for me to learn"

I'm a 10+ year C++ dev and also a full stack JS dev. I could say the same against C++ compared to Js or python to an even bigger extent. Truth I pick the language that's the most adapted to your ecosystem

I found c++ really hard to master. I was insecure about where to start, what compiler package manger to use. Which courses or and tutorials to fallow. Learning rust on the other hand was straightforward because the ecosystem is not a old overgrown jungle and the rust book is an amazing starting point.

I totally agree with you assessment of Go. Tbh both Rust and C++ are overkill for a lot of case uses. C# gives you a lot of room for optimisation without writing unsafe code, should you need it, but you often don't. Personally I have this idea that functional-flavoured OOP languages are the best for getting stuff done quickly, because they let you translate algorithms into code very directly, but they aren't too strict when you've got to add in some imperative details or manipulate some state. So C#, TypeScript, Kotlin, Ruby, even more outright functional languages Scala and F#, are ideal to me.

Rust was never really intended for startups to ship products quickly, so these takes are kind of no-brainers.

Rust is "refactoring free", it is such a pleasure not to think about possible SEGSVs or UBs after you have performed a non-trivial refactoring over your codebase. Yes, there could be a ton of complaints from the compiler, but they are all explicit and familiar.

I still love C++, but the more I write in C, the more I realize that I like C more than C++. I still use C++'s super basic fundamentals like vectors and other earlier STL implementations just because they're really good, but a lot of the more super cutting edge stuff on C++ I just tune out generally.

Surprising that this article highlights the struggles of the borrow checker so much that it would wholly delay shipping a product. Like… it’s not THAT hard. Yeah the borrow check has kicked my sweet cheeks many a time, but has it delayed my dev speed or dev ex? Not as much as runtime errors in JS 😂😂

after 6 months of 'fighting w the borrow checker' i never fight with it anymore. I now know how to borrow and clone and i now know that strings are completely insane in rust and why (its worth it) and now i write rust as fast as i write js. actually even faster bc i dont need to do live tests to make sure features work. The compiler is like my test suite

Lets talk about shipping buffer overflows to users in record time...

The issue is, when you *_do_* make the product, how much technical debt do you want it to be? Rust turnaround times are slower, but the final products tend to be more well put together.

I disagree that you can't ship products quickly with Rust. Maybe 3 years ago, but the ecosystem is much more mature now. I recently rewrote an API layer in Axum (as an example) and it took no time at all.

I come from PHP. I currently work on a huge, 14 yo project, which started with some old PHP5 version. Was it quick to MVP back then, more that a decade ago? For sure. Is it a PITA to maintain now because it's spaghetti? Yup! I've recently had to rework some of the code because a new algorithm was required. The old one was already slow and had a tendency to eat up all the memory, and this new one would be even more taxing on the system, so I decided to just give Rust a try for this. The end result was: - A lot less code. Rust simply seems less "noisy" than PHP. There's a lot of ergonomic features to Rust that are not exactly absent in PHP, but just more hassle. Example: Cargo is just build-in, whereas Composer is a later and optional addition. That has many implications. Take namespacing as an example. Rust namespacing is fairly implicit and prevents you from making mistakes. PHP namespacing is much more explicit and provides several ways to make it break. You have to mention your namespace in composer.json and provide the path. The namespace declaration inside the file have to match the file path. Any mistake, and you're debugging why some component won't load. Cargo.toml just doesn't need to know about your internal namespaces. - Potentially as quick or even quicker to code. The type system and compiler feedback just makes mildly complicated things more likely to work in the first try. In PHP you have to rely of much more indirect feedback, unit-testing, static code analysis etc. - Stable. PHP has type safety now, but it's not anything resembling Rust. In PHP, with a big data set, the code would crash with some obscure edge case. - The release Docker-images is 1/50th in size. No, I'm not exaggerating. From >1GB to ~20MB. - A lot quicker. Like 10's or 100's of times quicker. I am perpetually amazed at how much quicker Rust is. - Doesn't run out of memory. A common annoyance with some of our algorithms was simply running out of memory. PHP is just a memory hog, Rust isn't. My most annoying example from PHP was I had to rewrite some component handling a big dataset because Doctrine (a PHP equivalent to Diesel) would not free up old records. I've yet to encounter such a problem with Rust. I've been a PHP-developer for more than two decades, but in a couple of weeks of Rust-programming, I have the feeling that PHP is just .... outdated. Currently, I'm not coding as fast in Rust than in PHP, but it really only feels like something I have to get used to. I also coded a bit of C++ back in computer science class, and I know that it has evolved too, but I have a very hard time imagining that C++ could be coded as fast and safe as Rust.

"Fighting with the borrow checker" = training your brain how to not make memory management mistakes.

I typically switch between C++ and Python depending on usages, thinking of learning golang and rust in that order, but these 2 alone already covers for quite a fair amount of use cases (for me at least)

Actually, you can totally make the application code simple in C++. You just need to make another complex layer and separate it from the "business logic".

I can move much more quickly in C++ than I can in Rust, but for this article it doesn't quite fit because C# iteration time is like years quicker than either of them. C# is just easy similar to how Go is, so I would put C++ in the Rust camp for this article's point

Writing an app in rust is easy just as easy as any other language if you know basic rust. Writing a well architected library in Rust can be challenging. But thats a skill issue. With basic rust knowledge I created a backend using tonic and a front end in leptos just in the same time it would take to do a java spring + react. When I wrote my first serial rpc comm async protocol... that was a completly different beast. But it was a skill issue. Writing that in any other language would be hard too. Maybe just a little harder in Rust.

I've been using primarily C++ over most other languages for years. Now, each and every language has its own pros and cons and C++ is no exception. So I'm going to try and propose this think piece without using my own preferences to any given specific language. I'm trying to do this in an unbiased manner. So here it goes... When you have production code that isn't necessarily used just in the business sectors of our current technological progress, but is used in critical systems where human life is at risk such as in a Nuclear Reactor, as in the Guidance System for Airplanes or Ocean Liners, as in Traffic Controllers for either Ordinary Highway Traffic or even for Railway Network Systems, or code bases that are within the medical community within advanced equipment such as MRI machines, Catscans, X Rays, and other diagnostic systems... My question then becomes Which Language are you going to Trust the Most to ensure the least amount of critical errors are present to prevent any kind of harm to human life or severe damage or destruction to any of these vital systems? I think this is more important than arguing over the semantics of a given language. And the answer or consideration of this question is where some languages do shine over others... Sure when a particular application has no direct influence on harming another person or potentially causing damages in the millions or even in the billions such as a piece of code to operate a remote control for a television, or a network piece of code for audio or video playback, or a piece of code to track recent sales then the language here doesn't really matter. Yet when you go beyond that and you are responsible for a code base that is used in critical systems such as a piece of code within an automobile that determines if it should apply the breaks or not, or to deploy the airbags, etc... which language are you going to trust? This is less commonly talked about in many circles when there's a debate between one language versus another... Let this sink in for a few moments!

I love all those programming languages, Rust, C++ and C# included! Still not having time to read all the good books I bought to learn it. It's more likely to Rust having a "version 2" than I effectively having time to learn it in order to do anything I wouldn't do in C++ or C#.

For game dev, the Bevy engine looks really really promising ngl

this article is literally just "rust doesn't pay my bills, therefore it's bad"

Actually a lot of people talk about the "rule of zero" in C++ nowadays. The idea is if you compose datatypes correctly, the automatically generated special functions will be right with no additional work.

After around a year of using Rust, I can say my productivity has actually improved over languages like C++ or C#. In those languages, I always feel the need to write utilities, I will get some obscure exception, or I worry too much about handling edge cases. In Rust, edge cases are wrapped in things like Result or Option, and are easily dealt with. Exceptions don't exist, only panics, which are either explicitly done through unwrap() or `Index`ing out of bounds (which is also prevented through get()), or by cases in which there is a bigger problem (out of memory). The only sort of utilities I need to write are math utilities for things like collision between two shapes or FPS-independent lerp. It's very clear and easy to learn how the compiler and projects work. Not to mention the tangibility and clarity of the language. Overall, Rust enabled me to get stuff done faster. I'm planning to go into cybersecurity and software engineering, and a safe, efficient language like Rust is perfect.

The first Rust compiler was written in Ocaml.

I think a big problem with C++ is that there isn't a 'standard' package manager. So in order to write you program you no only need to write C++ but also make, or figure out how to link all your shit together with bash (and if you are cross platform you need to replicate that exact behaviour with powershell or whatever). Yes I don't have to fight the borrow checker, but I have to write my own build system. Sure this is also a skill issue I guess but so is working with the rust compiler. Just different trade-offs. Also agree with the C# comparison, doesn't really make sense. You could compare any low level language to C# and make the same arguments. Apples and oranges.

With regards to shipping Rust being slow: You can ship fast with Rust! The company I work for (Shuttle) works with primarily Rust. The issue is that you have to actually become (moderately) good with Rust first. I've produced Axum APIs pretty quickly (spinning up a CRUD API with extras in about 5-10 mins, depending on what the extras are).

The safe programs that aren't demonstrably safe is rust category is quite small. More often it is that the person is writing unsafe code (or code that will later become unsafe) but haven't been bitten by it. If you want to get programs out fast, having them be demonstrably safe is good, since you can iterate faster and spend less time with avoidable bugs. It's the same with JavaScript developers who think it's such a hassle to write typeacript instead. They are used to writing unsafe code and either debugging the problems manually or just ignoring the edge problems entirely.

He mentions the game industry is still not using Rust. Rust is new and most gaming companies have gigantic codebases. No sane person would say "oh lets port everything to Rust". Meanwhile, you have Unreal using a complete custom flavor of C++, which essentially throws away std and stl because they want to make the code as safe as possible.

Somebody once told me "Go is so boring!", and I thought: "Yea, this could be my cup of tea! I have kids, and I need to get things done. I don't need creativity in my daily business..." 😀

C++ doesn’t fruck around.

I think it depends on what part of your overall code/data balance as to what you target were you really need max performance and use utility with the best code where you are not worried about large data volume slow management, javascript for html human interaction, java/etc. for basic logic, Rust/Go/C where moving large data as efficient as possible ....

I might as well ask! I’ve never written code ever, but decided at 57 I want to create a project on Kusama, which is all substrate from what I understand. Do I learn Rust? I’ve seen other videos of yours which have said use whatever language you are best at. So, since I don’t know ahoukd rust be the one? I’ve seen you mention GO, and said you dislike it but it’s fast and easy.

3:08.. One common pitfall with the borrow checker is iterating over a vec while trying to mutate it. I've had this a few times when I wish oh it'd be so nice to do that

The argument is silly. Rusts development time is a trade-off. You satisfy the borrow checker so you don't have to deal with bugs related to data races after. It's also extremely performant so odds are as soon as you finish it, it probably won't need much optimisation. I am a big fan of simple languages that let you get applications up quickly, but the argument for each can't be had in good faith without talking about the time savings rust brings once the program is developed.

When you're developing new features you can build up momentum and get a lot done and then when you've had a chance to stand back and look a the thing and see how it turned out, go back and refactor. Having to write it an idealised way every time can take all the momentum out of development and can make refactoring incrementally a pain in the ass.

"C++ and not fighting the language" never heard that before. Of course I was programming before even C++ 11 but I am sure there are many stupid issues with it still.

I think the issue with C++ is that it allows you to do so many things, that the chances of you doing it badly are high, hence the bad reputation, but you don't really have to use most of its features. You can write a full program without any OOP at all, which in my opinion is the biggest problem in most applications, regardless of the language.

You can always kick in a bit of unsafe, with a safe interface. Not a bad way to organize crazy low level stuff safely to a degree.

My problem with C++ is that i need some more time to get "meh" at rust than in C++, i need a lot more time to get "average" in rust than C++ but i need the same exact time to get good in either language. But if i get good in Rust i got 99% memory safety (unsafe in libs or own code, happens) a pretty dang good build tool, bundler, test framework and package manager and in C++ i am still one day of too little sleep away from building in a memory leak that noone notices in tests because it fucks you over when the server is running in production because it trashes a few Kibis per request.

i respect the rust project, and think it is a valid successor to c++ in many if not all areas because of its much better defaults, better safety, and integration of functional programming concepts (though i do have serious concerns about the foundation, lack of a standard, single compiler, etc.), but it is hilarious to me when the "just learn rust, skill issue" people complain about c++ complexity

How do you worki without mouse? Is it possible to swe yours setup nad how you used it?

Personally I do not enjoy rust I tried it for 3 projects and its just extremely restrictive even if the code I am trying to write is completely safe it won’t let me do it

My main language for the past 20 years has been C# and a little C++. I learned Rust back in 2019, so relatively new. Yet, in a recent project at work, I created a prototype for a service in 4 days of Rust, only to spen the next 2-3 weeks creating the same in C#. It was very difficult - not because of the language nor the features I used, but due to weird API choices by Microsoft, surprising exceptions etc. I actually prefer "fighting" a little, if it means I have to spend less time testing and debugging. And yes, there is a lot of stuff you don't have to test for when using Rust, simply due to the language and the library API's - which means you ONLY have to test your business logic.

After a small project in Rust a few months ago (excited as I was while learning it), I decided it was too much cognitive overhead to get into Rust again for an equally small project, and returned to F#. For small batch processes, the easiest choice is often the one with the most flexible or best-documented libraries. But I remain excited about Rust for web sites, web APIs, and WASM. I'm conflicted as to whether it's at the right level of abstraction for web applications and "business" apps; I feel like most of the "business logic" should be written in a somewhat higher-level language or representation (e.g. serialized to a graph database.)

I’ll be honest, I love rust and would say it’s one of my most comfortable language at this point, but when I want to play around and just make something casually I really enjoy C/C++.

this artcile must've been made specifically for prime

I think people who dislike rust and the borrow checker just have a completely wrong approach to the language as a whole. You dont fight with the borrow checker just because, you do so because it saves you time later down the road and it does so exponentially

I did not expect an etymology intro, but that was a lovely surprise

I kinda agree with the C# part. Been using that since 2002 and the ecosystem is important. Been working on writing apps with Axum, SQLX, etc. for a while now and it's really a lot more work to get everything going...

0:13, C++11 is the "must see" 1. From that, only minor good features have been made. C++20 is now a game-changer, but it's more related to high level features than performance or middle-to-low level functionalities. 0:38, oh... really nice to know that. 2:51, this is what I believe C++ is able to achieve. But that's not its default behavior. 1 should go (sometimes struggle) for it. 7:43, maybe because of its complexity, it feels solid among the complexity of a project. I was making 1 in 2 steps, the 2nd "as a superset" of the 1st. I basically inherited all the 1st step as basic classes for the 2nd. It worked amazingly! Of course I had to amplify things, but no extra problem was added by that. And the classes were organized by data, not so much by meaning. Even so, the whole previous meaning worked for the 2nd, and no performance penalty was added, beyond what was inevitable from more work to do. 9:40, delete all of them, letting the compiler pointing you the missing ones.

Lol the C# hate has to end, it could be Typescript

You know, after a while the borrow checker is not a hindrance, it becomes your friend. To be honest I even forget it is there

If the borrow checker slows down your work that much you can be pretty sure there are plenty of bugs in your code that simply go unnoticed in C++.

'100 Go Mistakes and How to Avoid Them'; and 'Let's Go' and 'Let's Go Further' are awesome books

I have the same feeling when writing go, it feels like programming in crayon but at the end I feel like "was that it?"

In regards to your Venn diagram of safe programs vs Rust, there should be at least a small amount for Rust programs which falls outside of all safe programs; just because it can save you from memory management errors (when you're not using "unsafe" to throw that away) doesn't mean that you are guaranteed safety in every case.

Funny enough, the borrow checker take is the exact complain people have typescript regardless TS is self is good enough or not. "I know what I'm doing, this type complain made not sense, it wouldn't be null or undefined, trust me bro" One month later, the same person come back and modify something, or data in upper chain changed, forgot all the check thing in his mind. production explodes. Think like an insurance, you pay (struggle with borrow checker or typescript) for something that you wish you will never need to use them.

The guy in chat at 2:36 literally got shut down like 2 seconds afterwards by ThePrimeagen himself. People are quick to judge. "Oh so he just creates a lot of runtime bugs lmao skill issue!!! xDDDD" oooor maybe shut up and learn what Rust's safety features actually do. Rust does not allow you to build all safe programs that can exist because Rust's safety rules make sure that all possible Rust programs are safe, which means that there are things that are unsafe in Rust but are actually 100% safe to do outside. Just, common sense, logic, reading the documentation and understanding how Rust works. Just all around just knowing how to be a good programmer and not making fun of others for not using your language of choice...

my take is that if don't know go or rust and have a week to learn either and build something you should probably go with go, however, if you master both, rust will be a lot more productive in my opinion.

Might try using some rust for DSP applications. Seems like its simple and fast enough to process complex live data at good rates.

I just had to learn some c++ since it is part of some libs in the project. All of a sudden, I have to learn variadric params, overloaded functions, and some crazy inheritance with friends and overrides where diagrams are needed to understand what is what. AAARRRGG

The use of the term “most businesses” tells you everything you need to know. Most businesses aren’t building products at a scale which requires the performance and efficiency of Rust. I can pay another $40 per month in IaaS costs to apologise for the difference between C# and Rust.

1:03 what's the test coverage on that rope matey?

Modules work with light cmake file edit I believe, but the ice's are common still.

Does C# run on Mainframe computers like C and C++ and Java?

In C++ without the borrow checker you either are only using single threading or it is very difficult to not introduce memory safety issues or you clone values everywhere. With more complex applications multithreading is basically a given, especially if you care about performance (which you usually do with C++ applications).

As a c++ dev I would like to see you spend some time in the language I think if you overcome the initial barrier you can start writing good c++. If you spend a little more time to learn templates it would be even better. You can't really do any fun stuff with web dev in c++, but you can make a game for example and I think you will appreciate the language more. Maybe try a quick project with SDL or SFML. I don't know how familiar are you with building c++ since it can be a little hard to get off the ground with libraries. In the end I just think that if you spend a little time learn it you will come to life the c++ ways. Great content, keep pumping it!

I spent more time in code reviews with the customer then I spent writing code a lot of the time. I suppose it doesn’t matter what language you use or whether it’s correct or not if you don’t have to review it in front of the client? But the client gets pretty pissed when you use something because it’s fast and you’re just pumping out code even though it’s wrong.

I stumbled upon this article and it was not really obvious to me upon reading it if author actually even knows the difference between C++ and C#. Whilst there is maybe one good point mentioned how C# can be good over Rust (garbage collection) there is not a single argument given how C++ is better over Rust apart from overly generalizations such as "ecosystem of libraries is better" with no examples how it actually is better and besides for C/C++ libraries that are important there often already exists Rust wrappers than actually make it easier to use such libraries in safer ways. Also one idea was mentioned that fixing bugs is somehow a productively spent time however fixing compiler error is not which is just absolutely wrong. Fixing bugs is not a productive way of spending time even if we do get paid for it.

To be honest, after many years of using Rust, I rarely end up in a fight with borrowck. I already know what doesn't work and how to write code that does. If the most straightforward/performant solution involves unsafe code, I first check to see if someone else has already done it. If not, I write it. Unsafe is not illegal.

"Why are you in such a hurry for your wrong answers anyway?" -- Attributed to Edgser Dijkstra

2:22 That's just not true. I almost never have borrow checker issues. Because most of the time, when I'm doing lifetime stuff, the design of my library/program is probably "wrong". So I just design my programs to never use explicit lifetimes most of the time.

As for the whole french latin religion thing, rilegare is still used In Italian. It means to bind/rebind but more commonly to tie like a rope or the binding of a book

Go is easy to set up now? When I was first trying it out, it was NOT fun to get it off the ground.

This guy is like the programming version of Dr Disrespect... Dr Disassembly 😂

Your go recomendation saved my company lol

@2:30 he's using some website to draw some, what site is that?

The comment about not spending your time fixing bugs or adding features but fighting the compiler is wrong. That time in Rust is an investment to avoid many classes of bugs that are footguns on C++ and C#

I don't fight the borrow checker since I started to learn the language. If the compiler says "no". I say "thank you! you are right! Let's fix this". Done

It's interesting how subjective the concept of "large project" is. To me 10k - 250k LoC is a medium-sized project.

This just seems like 2 arguments rolled into one. Ecosystem and (team) familiarity. Both are important when starting a new product or starting a team but neither are constant across teams or domains. C++ makes sense if you’re not doing web dev/APIs. Embedded, IoT, Games, Simulation and some other areas have the largest ecosystems in C++. Go, C#, Python not so much.

The C# standard library structure, documentation, etc is incredibly well written and everything just seems to make sense in how it's named, etc. I think it's weakness is Microsoft, not the language itself.

spending time debugging a problem is time that could have been used implementing features. spending time trying to understand cryptic code is time that could have been used to implement features.

I’m not a professional (for now), just enjoying watching the C++ vs rust wars 🍿 May the best language win ⚔️

rust is a language that is easy to get a project done, rather than easy to start with

Drogon seems interesting, code looks fairly simple, and its super fast (mayhaps the fastest)

Programmers and project managers with this sort of attitude are the reason why the cybersecurity industry needs to keep growing... The idea that the market will debug your code is true, but the market includes ransomware gangs who are very willing to put in more time then security auditors...

Stupid question, why wouldn't it be possible to implement a garbage collector in Rust to use in unsafe, that you can turn on and off? Wouldn't that fix all problems with Rust? Or is that technically impossible

All of his arguments are why I moved from C++ to python for business applications, the bias is pretty hard on him. Rust is great

but C++ is easy, you start with mostly C code, and add features as you see fit. most programs don't need a move-copy constructor, most programs don't need a && in them. the ones that will need them will use them. this is really why you mostly teach the c89 and c++98 for first time users and expand from there. sadly, c++ doesn't benefit from many of the expansions of later versions of c and they also have different standard libraries.

What development area, practice or job uses Rust? Serious question.

I've written code in C++ professionally for 10 years and hated every second of it.

When are the streams back?