Rrir folks are to blame.

Real talk, this is another failing of the Rust community. Bamboozling people into thinking this is somehow a good idea to begin with.

Makes me believe most the devs that push this are juniors. A few seniors might give it a go but most know how god awful same language rebuilding is, let alone new-language building is

Just this fact makes me realize that most of those that use Rust and do that are completely green and inexperienced. Because otherwise they would know, re-writing any big thing without very good reasons more often than not ends in pain, new bugs and waste of time.

Is not it a mandatory rite of passage for any rust convert?

Trauma bonding is real

your probably js kiddo lol

Nah, they are a way more mature community than JS children’s playground. PHP, .NET, Java are the technologies that actually keep the world going and get shit done

====

@@kphaxx =====

This. It's basically like an RPG where you can choose your archetype. *The Profiler.* Wielding your GC language, concurrency and threading are easy and often quite performant since you can rely on your (bytecode) compiler and runtime crafted by the highly intelligent elders. As you start to optimize, you will learn to work around the GC in order to minimize allocations and cleanup, and deploy tests to guard yourself against race conditions. *The Debugger.* As a scholar of the arcane C++, concurrency and threading are easy with smart pointers and copies, albeit at the cost of performance. As you start to optimize, you will learn to tame race conditions, crashes, dangling threads and nasal demons summoned from the realm of undefined behaviour. *The Compiler.* Similar to _The Debugger_, concurrency and threading are easy using reference counting and cloning, at the cost of performance. As you start to optimize, you will learn the way of the borrow checker, using your knowledge of pinning and interior mutability to refine and refactor your programs until all errors are quenched and the raw performance of your code is unleashed. ----- Overall, they are fairly balanced. If anything, _The Compiler_ sucks at low to mid levels, while _The Debugger_ is prone to blow up himself and their whole party, specifically in its older edition versions... ...i'll see myself out.

This. It's a bit like RPG archetypes: *The Profiler.* Wielding your GC language, concurrency is easy and often quite performant since you can rely on the (bytecode-)compiler and runtime crafted by the highly intelligent elders. As you start to optimize, you will learn to work around the GC to minimize allocations and cleanups, and implement tests to protect against race conditions. *The Debugger.* As a scholar of the arcane C++, concurrency and threading are easy with smart pointers and copies, albeit at the cost of performance. As you start to optimize, you will learn to tame race conditions, crashes, dangling threads, and the nasal demons summoned from the realm of undefined behavior. *The Compiler.* As with The Debugger, concurrency and threading are easy using reference counting and cloning, at the cost of performance. As you start to optimize, you will learn the way of the borrow checker, using pinning and interior mutability to refine your programs until all compilation errors are vanquished and the raw performance of your code is unleashed. ...I'll see myself out.

I think async syntax may abstract a little too much for the beginner, which means there's a performance hit they may not be aware of. From what I recall, adding async basically turns your code into a state machine.

C# has you covered on both fronts… according to Microsoft at least

I'm happy how Java approached this. Just 1 line of config to enable virtual threads.

Did you ever learn any other language, for the sake of learning something outside your bubble, or nah? Or are you Java till you die?

Your code would work on like 3 billions devices!

My condolences

I can't do it. I don't even use open source applications built on java except intellij. I have PTSD and a phobia

Me too bro, me too

Sad but true

Well, it really depends on what your priority is. If you want to get something up and running quick, Rust is a terrible language. In fact, it could quite possibly be the worst language for that. Developing with Rust is slow. It writes safe, fast programs, but your code has to pass a lot of strict compiler checks.

@@taragnor I don't think it does. Javascript is the worst language ever invented as anything other than a joke and shouldn't be used for anything. There are other far more usable languages if you want something done quick.

@@isodoubIet Vanilla JS is terrible. Typescript is okay. It still has warts from JS (which sucks), but can do some of what Rust can, with a similar syntax for generics. You can even do some Rusty abstractions and code in Result and Option return types instead of relying on throwing. It's async is also relatively similar as well to Rust. Speed wise it's also not that bad for a scripting language. Python and Ruby are much slower. If the plan was to never port the system to Rust, I'd probably say they'd be better off choosing Go or C#, but the TS version is basically just a prototype design for an eventual switch to Rust. It's an okay choice. It's not the only choice, but I don't think it's awful.

@@taragnor TS is slightly harder to use incorrectly but it's still the same fundamentally borked technology. Getting the wrong answer faster is not an advantage. But all that aside, the guy didn't conclude "TS is better for developing a throwaway concept that I'll rewrite in a real language later". He concluded "TS is better _in general." This is a take so wild it has yet to be contacted by western civilization.

Most application are not demo code to not need generics or lifetimes.,

This ^

but when you try to build something atleast somewhat useful, you start to use frameworks and libraries, which are often over-engineered, so your code also get over-engineered pretty quickly

@@curio78 most applications are trivial and small. Huge projects are the few. A company may have a couple of big products or a platform, and 10 or more internal tools that are just forms or non-critical data processing apps. This "real apps are complex" is only true if you are making something actually complex (optimization of geometry for CNC machines or whatever), or the software changes for several years

Profound statement. Don't repeat yourself, unless you've got something important to say, then do that. Repeat yourself.

With a Swiss Army Knife™, you would be done in 18 weeks.

Well that's obviously a skill issue

​ @ProgrammingLearner-iy3ej Yes. People also don't write things directly into binary because of skill issues 😂

After that you get to be extremely skilled. So its probably worth it.

Swiss Army knife is the ultimate abstraction. It's like writing in Clojure.

bruhhhhh 💀💀🤣🤣🤣🤣

wow😂😂😂

Chill 😂

spot on

Except AWS and Lambda, all the webdev tooling, Qdrant (Twitter uses it), tikv (behind tidb), Dropbox, GitHub's search, Discord, Facebook's build system, and many more..

@@chockman3833 If only Assembly had automatic garbage collection. Why aren’t lifetimes handled automatically by x86? The syntax on these vtable allocations are just too much sometimes.

​@@houstonbova3136Assembly doesn't even handle the stack automatically lol I don't know if this is a genuine joke (I am assuming it was), but this is gold 😂😂

@@tablettablete186 Definitely a satirical interpretation of the video 😅

@@houstonbova3136 that’s exactly my point man!

@@houstonbova3136 Congrats, the joke was amazing 😅😅😅

It's at the bottom, because it's the foundation for all the prototype programs that are finalized in languages higher up...

They laugh at us, and say we're at the bottom of the pyramid. But then we hit them with blazingly fast libraries written in C for the small but performance-critical parts of the code, and we suddenly got the holy trinity of speed of development, runtime and readability where it matters. 🐍📈

White space is syntax snake :D

Python: at least it's not Ruby (even when Ruby has improved some 10x, if not 100x, since they rewrote their compiler/interpreter)

@@fg786 while using C

I don’t think that’s a fair comparison. The cattle prod stun would be panicking at runtime. Rust doesn’t even let you cross the door to take the breath outside. It’s much better to fail many times at compile time than to fail just one in production at runtime. Every one of those compile time errors would be a bug in a different (memory managed) language.

I like to think of rustc as Mr Miyagi. You'll be miserable for a bit but will come out better on the other side.

@@Turalcar Rust == Pai Mei

This is the most based explanation of Rust I've ever seen. I always said it feels like pulling your own teeth out, but I'm stealing this.

Web devs shouldn't be allowed to complain about any software when they don't even know how to use the tools they're paid to use. sincerely, anon

I think this applies on a higher level; don't complain about stuff until you're knowledgeable enough to understand the stuff.

@@Takyodor2 Yes, but that doesn't sound as good as a joke comment 😁

@@Takyodor2 Right? Primeagen once talked about how you get into someone else's code and you think "oh, this is crap." So you start to rewrite it and as you encounter all the edge cases, your code looks more and more like the code you thought was crap. lol

You comment deserves 1000.000 likes.

Agreed

Dude I've been using Rust for like 3 years straight, and I don't know what any of that stuff is in the beginning of your comment. What use case are you building for? What does it do? I find people use so much of Rust and I barely use any of it. Why don't you just throw everything complicated into an async thread and have it send messages back to the main thread and self terminate when done? All this pointer stuff I hear about sounds like trying to walk a tightrope. Maybe I'm an absolute moron and this is terrible, but I stopped learning Rust when I mastered handling everything async. I use it all the time, everywhere. Hundreds of threads at a time for each agent. Async threads starting and awaiting more async threads, on and on and on. Why not? I don't even recognize any of those pointer types. Honestly, I don't even know how a pointer differs from a variable name. I guess I'm a caveman, or cavecrab. I don't know, hitting everything with a club just works. Don't fix what ain't broke. My code runs faster than I need on 10 year old android devices I use for servers, so I've never looked into perf. There are so many rabbitholes in Rust, and I'm not scholarly enough to handle a lot of it, therefore, so much of it is just engaging. Sometimes I need something, and I go to The Book, and I return enlightened, but some stuff Rustaceans do regularly is just too much for little old me. Number types: I don't even use those different number types. Holy hell, why so many options? I want a number!!!!! I don't want to have to think about how big the number might get, and then select the right type - which I always have to look up because I didn't go to college and I refuse to memorize extremely random and long numbers that are related to the number (which is always a product of 2^x because computers) attached to either the letter "u" or letter "i" which for some wild reason link to two totally different, super random numbers (which are also always a product of 2^x because computers), and only one of them allows negative values because... drumroll, please... computers. I just want a number! How is that so much to ask for? The number types alone make me feel like I'm doing my taxes. I get triggered like Big Red when I see those types. There's "int"/"float" or (my favorite), straight up "num." Everything else is the damn computer's job! Am I a programmer or a mathematician? I failed Calc 1 four times, I came to programming because I thought I was safe from my one weakness. But that's my point. You know all this stuff about Rust, and you're probably better at it than me, but Rust is as hard as you make it. I feel like anyone complaining about Rust is trying to write Superman-Rust. I know a small sliver of Rust as well as I know my name, and that's all I've ever needed. I just can't comprehend people freaking out about using all this stuff. They're doing it to themselves. You can do so much with so little of Rust, and then you can improve pieces that are bad. I used to use Arc stuff for everything, but it got annoying, so I mastered multithreading or whatever it's called. Now I don't have to worry about all this locking insanity. There's so much in Rust. It's ridiculous to try to know even half of it. Last - but not least - I don't know a damn thing about lifetimes. I don't even know what they are. *mic drop*

I can't edit replies, so commenting again. Question: is it really that big of a impact to send the data as a message versus using those pointers? If so, what in the world are you building? Are you dealing with Google-level i/o?

This is a great explanation. As a n00b, thank you.

@@GrizikYugno-ku2zs Your point is extremely valid. You can avoid a lot of the complexity associated with the lower level abstractions that rust provides by using higher level abstractions. But these higher level abstractions are often built on top of the lower ones to offer the safety and efficiency you expect from rust. But as always in engineering everything comes with a tradeoff. if you've found a way to program that works for you, thats awesome man more power to you but also keep in mind there have to be those that build the use case specific abstractions for everyone else. I am very curious about your usecase for "just a number" because there could be several solutions to your problem. You strike me as a domain level problem solver.

wait until u get into hell with smart pointers.

I don't _love_ Rust, but I like it a lot more than C++. It also took me 6 months to get to grips with the borrow checker.. and even after that I scratched my head at some borrow checker corner cases. I think the language is somewhat unbalanced. Extremely verbose and explicit when it comes to integer arithmetic, for instance. Yet when it comes to references, it's all very implicit, and abstract. Zig has way more concrete terminology like "comptime". I think in that regard, Rust did miss the boat a little.

@@alwin5995 What "hell" are you speaking of? It's literally one of the easiest things in the language. Unsafe manual memory to interface with a C-FFI on the other hand is real hell, but needed.

Never mind the probable abuses of direct conversions that follow the original codes layout, but didn't take advantage of the right way to write rust

😂😂

He didn't want to spend 30 minutes understanding the where block. If he doesn't have 30 minutes to invest...

"WHY MY PROGRAM DOES NOT JUST COMPILE???"

Certainly

Finished rewatching that show this week. Didn't expect a BBC Merlin reference in a Prime comment section

Yup. ImageMagick always comes with a price. Of having to modify esoteric XML configuration files to be able to do anything useful.

The TLDR - pick the right language for the problem. Maybe you don’t need rust level performance.

i hard agree, I've been porting a lot of my company's internal tools made in python 2.7 to nip and ive never felt this good about my code lol, i could optimize the code off of my head and seeing it actually made me smile

skill issues exist, everyone has them. Let's all all help each other overcome them without being assholes

Its because Typescript is a bastard child of Javascript which is a broken language

Typescript is gold leaf applied to poop.

@@7th_CAV_Trooper 😂

Can you expand a little about your problems with TS? I do Angular in my day job, and I've been using my own Result type, and it has been alright. Not as nice as Rust's but better than throwing exceptions around.

That's bad, you shouldn't feel that way about getting errors. They are your friends, and the debugger is your friend also.

You took the words right out of my mouth.

"We don't do that here"

Lets go!

Obviously this video declines in quality around the 22:30 mark

That's true. By following that logic memory unsafety in C or C++ is also a skill issue so there is almost no reason to learn Rust in the first place. Instead you just can become better at C++ and learn how to write memory safe code.

@@bionic_batman That but unironically. Herb Sutter relates that Microsoft's experience with Rust has been that from C to C++ there's a large safety delta, and from C++ to Rust there's a small safety delta, and even that's largely because it's harder to commit code that doesn't compile than to commit code that fails a static analyzer.

taking years is an extreme exaggeration. 3-4 weeks is realistic for the average programmer. assuming they go through the book and actually commit themselves to learn it. that's still a lot compared to something like javascript though which is realistically probably around 2 weeks on average. you're not just picking up javascript with javascript. you have to learn all of the tooling and all of that. go is probably a week, although i learned go in a couple of days.

Laughs in Haskell. Also I have nothing but respect for Haskell, its practitioners, and its secret police force, and orgy initiations.

So culty I've never seen vlang dev 😂.

Or Gleam

Swift / iOS Dev is also cult like.. now that I think about it, all fanatics of a language normally trend towards their language… which is really the point.

@@sergiobost7434 isnt swift THE language for ios development. why would a maimstream language be cult-like?

This is why I like Primeagen. He fosters a friendly community.

@@7th_CAV_Trooper he is the chosen one! :D

@@antontsvil245 but I still don't feel like I can openly admit to being a C# enjoyer. Lol

Clearly a bot. Get bent buddy.

@@antontsvil245 did you say be nice and touch some grass

True. At some point _even Clippy_ recommends using aliases

I'm just sticking to doing enum powered state machines. It's more work, but it's very understandable.

Yeah it all feels very "work in progress", but I don't envy the ppl that work on trying to solve this. Rust has to type check, memory lifetime check, static dispatch for generics (and probably more) all at compile time, which is hard enough to do for strictly synchronous code. Imagine the nightmare trying to create a standard solution for all these constraints in an asynchronous context, whew

He was probably more familiar and proficient with TS at the moment of starting, what's wrong with that?

You have to start somewhere. And first versions are usually written in popular languages, not languages that are good for the job. Maybe Go would have been better for this. But the borrow checker witnesses are everywhere and ringing the door bell to talk about Rust.

​@@svuvicheverything. Chosing a platform based on familiarity instead of purely techical characteristics is a sign of incompetence.

​@@vitalyl1327choosing a platform you literally cannot use because it's technically superior is just as incompetent. Life is funny that way sometimes.

@@svuvich Do you know what 'algorithmic trading' is?

You're free to not use the old stuff. The footgun potential is WILDLY exaggerated.

Yeah, the fact that C++'s STL has this huge ball chain of forever backwards compatibility is what causes all those footguns, esoteric best practices, random terrible performance, and inconsistencies.

Yep, and safety is still opt-in. When you put me in charge, I'll just throw safety in the wind, and this will come back to bite me later. I'm a lot better of with Rust than even modern C++.

@@earx23 Unsafe code is just one aspect of "bad code". Rust won't prevent you from writing bad code. If you can't stop yourself from writing bad code, you need someone else to guide you until you can. Regardless of language.

Est 96 minutes? I'll read it at work...

Most articles criticizing Rust (including the one you mention) usually end up saying something along the lines of "C++ is better for my use case". That is a reasonable take. This article says instead "typescript is better (in general)", which is a troll take at best.

@@isodoubIet this article said Go is better, not typescript.

@@isodoubIet There are a lot of issues with that gamedev article. The most offensive part, in my opinion, is not talking about `wgpu`, `naga` or `egui` crates. But, other stuff like talking about the "orphan rule" is also weird. Or the mutability, which Bevy's ECS addresses.

@@tinrab Dunno about the rest but talking about the orphan rule is 100% on point and justified.

If you know where it were handled, you can easlity figure out where it came from, no ?

@@jonnyso1 Depending on the codebase it could be easy to figure out. But like he points out in the video, if you use "?" to bubble up errors a lot and have an app that does lots of file IO, and your app errors with "No such file or directory"... What file did it not find? what function returned the error? Obviously you can code around those issues, but it's not always straight forward and doesn't come out of the box really.

@@dork_side That's what I didn't get, you need to specify what type of error you're returning, you can't just use ? and it bubbles everything, if your function is returning an error, you know which error it is, its right there on the signature, no ? Or is it some anyhow thing ?

@@jonnyso1 that only works if your function only has one failure mode. If you use IO and some other fallible thing that returns another error type in one of your functions you either have to use anyhow, make a custom error type that wraps both, box dyn error, etc. Eventually you usually get to a point where you can easily bubble up many similar errors from a potentially large codebase and tracing them back to the origin can be hard. There are ways to solve that problem yourself, but I can see how this could be a pain point when you’re used to exception stack traces.

@@dork_side You simply write a custom error type and use "thiserror" (or similar) to compose said errors. After that knowing where your error comes from becomes dead simple.

Let's go

thats because the type system of rust isnt as robust as it seems on the surface, its not that Haskell is forgiving in the example youve given

Gleam is the best for making political statements on their main page, Rust comes close

@@meanmole3212 I just checked Gleam's homepage. So do you hate black people, hate trans people, or do you sympathize with Nazis? This is a pretty low bar for setting a community standard around decency.

​@@MrKlarthums Why does the page not say that white lives matter since whites are a global minority in the world and about to go extinct as a result of uneven birthrates and immigration to their home countries, and that black people commit disproportioned amount of violent crimes against whites? Deportation and closed borders matter! World peace and a home to live for all people of the world! Is that statement a problem with you, or with THEM? If so, it seems you hate white people and you sympathize with silent on-going genocide. That's pretty unfortunate since all I am suggesting is that we set a low bar community standards surrounded around decency for everyone to enjoy equally. If you think this is "trolling" or "yep, you are a nazi", then explain to me what in my statement was wrong or trolling?

​@@MrKlarthums Why does the page not say that v\/hite live5 m_4tter since whites are a global m1_nority in the world and about to go extinct as a result of uneven birthrates and 1mmigrati_on to their home countries, and that 8 l4ck people commit disproportioned amount of \/i0lent crimes against whites? D_3portati0n and closed borders matter! World peace and a home to live for all people of the world! Is that statement a problem with you, or with THEM? If so, it seems you hat_3 white people and you sympathize with silent g3n*cic|e. That's pretty unfortunate since all I am suggesting is that we set a low bar community standards surrounded around decency for everyone to enjoy equally. If you think I am trolling or the n-word, please correct me on what I said and correct my wrong statements. The numbers exist because of 1984 censorship.

It's Mojo baby, yeah

My favorite anecdote in terms of wow elitism is how at the end of Wrath with all the catchup mechanics the game was so accessible that everyone had amazing gear and everyone was "uh, i'm so great but all the noobs got my gear, so wish the game was harder" and Blizzard listened and in Cataclysm the same people whined that heroics are too hard.

I failed and switched to BeefLang. Never been happier (unironically)

Is that even possible?

@@tempname8263 I just opened the language website and there on the first page was a drop down with a bunch of examples. I have no idea why more languages don't do this.

@tempname8263 I just opened the language website and there on the first page was a drop down with a bunch of examples. I have no idea why more languages don't do this.

"BeefLang" I just opened the language website and there on the first page was a drop down with a bunch of examples. I have no idea why more languages don't do this.

Couldn't agree more. I always see that, they call Rust users cultists and than they engage in cultist behaviour about their favorite programming language, mostly Go and Zig.

idk where this "rust cultists" stereotype comes from. If you go on the biggest rust discord server and say "rust is better than c++" you will get checked and people will argue with you and call you out. I think they're just making stuff up...

eu encontrei vc dnv kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk

@@baconmanthelegend because C++ is better than Rust and I don't even like C++

41% of Rust devs abandon the language after 5-7 years (don't ask me how I know)

(That said, I don't have any more anecdotes for how the Rust community is compared to the others. So I defer to the bad experiences you seem to have had)

Rust people will be nice to you as long as you have a rainbow flag in your bio and at least one thread where you defend sex change surgery for children

You're not "safe" with rust that's just placebo

I “fixed” the finance crate to have a radically different design and fixed a bug. I deleted the documentation because it was outdated with the radically different design. Old design: put in a number (like 5) New Design: put in a duration (like 5 days) Apologies if I came across as unpleasant

OK if you need a part of your program to be performant and other part you don't worry too much about it then write the performant part in C and the rest in some GC language then link them together what's so hard about this

Yeah, really what GC-less languages give you is a much more predictable performance. The thing with GC is that you never know when the GC is going to kick in and create a slowdown in your code. In many cases though, the GC doesn't actually have that big of a performance hit, which is why it's not really a great idea to use a systems programming language like Rust for everything.

@@rusi6219 The thing is the GC isn't buying you as much as you think it is. The fact that the GC pervades the entire language design can in fact make things substantially worse. Compare for example C++ where closing a file stream is as easy as letting it go out of scope, versus something like C# where you need to be mindful of what's a "disposable" and place all such objects in a using block or try... finally. RAII languages like Rust or C++ understand that memory allocation is just one of the many types of resources a program needs to manage, and provide a general solution suitable for all of them. It's a simple solution, which only asks you to consider what objects own what and then you're set. Once you've internalized this way of thinking, GC languages just seem awkward and limiting. GC pressure is something you straight up _don't have to think about_ in C++ or Rust.

@rusi6219 The thing is the GC isn't buying you as much as you think it is. The fact that the GC pervades the entire language design can in fact make things substantially worse. Compare for example C++ where closing a file stream is as easy as letting it go out of scope, versus something like C# where you need to be mindful of what's a "disposable" and place all such objects in a using block or try... finally. RAII languages like Rust or C++ understand that memory allocation is just one of the many types of resources a program needs to manage, and provide a general solution suitable for all of them. It's a simple solution, which only asks you to consider what objects own what and then you're set. Once you've internalized this way of thinking, GC languages just seem awkward and limiting. GC pressure is something you straight up _don't have to think about_ in C++ or Rust.

​@@isodoubIetidk man I just write C and am content with my life 🤷🏻‍♂️

Isn't Zig a replacement for C?

​@@dwight4kye

How is it C replacement if C still a language to make OS. If you make OS then it is good for anything.

@@sillymesilly By replacement, I mean C was pretty much the only language used for systems programming until Rust came to be popular. I dont literally mean C will just go away and Rust will be the new defacto thing

@@sillymesilly Good point.

I just started learning Rust and I'm working on a very similar project as the article author - I've landed on channels for a lot of what I want to do within the system and so far, it's working well and is pretty straightforward and intuitive to write. Not having any issues that the OP had.

I was reading in detail through the official tokio tutorials recently and all I can say, is that if you use Pin and you are not absolutely sure why you have to reach for it, you will not finish your project well. Generally it should be possible to never touch Pin. And as far as I understand, the main reason to use it, is to save an async boundary manually, so it doesn't drop for example in a switch when something else finishes sooner, making it possible to re-pull later. It is a too-manual way to manage awaits. Like mutex, it exists only in case you really need it and you know what your are doing. Channels on individual spawns are the way to go.

@@TheNoirKamui I was going to say that but I think in that case he needed to anotate the type to satisfy the trait bounds in the function signature. Technically he didn't "use" pin, he just needed to say that his function would receive a closure that returns a Future. Really its not even that big of a deal, it looks wierd the first time you see it, but then you understand why and move on, OP was beeing very dramatica about it, maybe if the had taken the time to learn instead of asking chat GPT he might have handled it better.

​ @jonnyso1 You are absolutely right. Considering there was no async in rust just a few years ago, it is amazing that it works. But there are still small gaps with async. For example tokio::join! will let you run 2 async functions that cary a lock over .await giving you a deadlock. Doing the same in spawn gives correctly an error. I remember bringing that up in some tokio chatroom and being told that they wouldn't fix that because it is all as expected and restricting otherwise... I also heard some people criticize the push vs pull model of the polling mechanism... though I don't understand that enough to comment. And lastly, the problem of async runtime lockin, that you can't just transfer your code to another runtime... That you can't just use a crate written for another runtime than yours. Rust async... is in some way amazing and in other kinda... Feels like much more inteligent people than me should think about how to improve it. But there is definitely space for improvement.

Stop speaking in memes. It makes you look like your profile pic.

​@@someman7 you're boring

​@@CatFace8885 Chasing dopamine isn't good for you.

​@@CatFace8885you're childish

@@rusi6219 you're the one who clicked on a video from a guy who regularly makes deez nuts jokes, soooooooo

C++ is pretty chill tbh

How about the build system, docs system, package manager, modern features like streams, iterators, great macros? I think you're missing a lot.

​@@tinrabyou just want a language to do the work for you how about stop being lazy and do the work you're supposed to do

Why does Rust call structs enums? Are Rust people so skill issue ridden that they don't know what a struct is?

Blame the one who wrote the unreadable code, not the tool that was abused

He did this already. Search the you tubes

OP was probably not aware given his background

@@okseaj The mongodb crate he was using has a massive signpost on the docs about how the offer a convenient non-async api if you flip on a feature flag. If you cant read the docs for the crate that has been ruining you for the past 18 months, idk what to tell ya.

@@leeroyjenkins0 I think this is a problem for people who has worked exclusively (or for all intents and purposes) in a single threaded environment with promises/futures/coroutines. Managing your own thread pool where you post tasks and work to and from is absolutely trivial in C++ and it is even easier in Rust. If you need async IO, use C++ and the OS utilities (epoll, poll, select, io_uring) and real parallelism with multi threading. Not only will your code be much, much easier to read and reason about, you don't sacrifice any performance either. Because coroutines comes with overhead. I think you are right, too, that the appeal is that it "looks synchronous" (guess what, a thread pool where you post tasks and await on the promise also looks synchronous, because you need to collect/wait at some point). I don't see how introducing tokio and async for downloading a bunch of files (as an example) is *easier* than having a simple thread pool where you post a lambda that downloads a file and signals back when it's done. Because the thread pool will not leak into every corner of your application, it will have a crystal clear API-surface. This is not to say that coroutines or async/await shouldn't be used. It works *superb* in JavaScript/typescript land. And it has its use cases. But I argue that is 1 out of a 100 times, if even that.

@@leeroyjenkins0 right, but that's my thing; you can get `const result = read().wait();` using hand rolled thread pools where you post a task and get a future back that you wait on. What's also better about this approach is that the API-surface is crystal clear. This large, obstructive and intrusive system doesn't loom over your entire code base making it hard to reason about, while also making performance (probably) less good, seeing as how coroutines always comes with an overhead. Handrolling your own thread pool and using message passing is trivial in C++ even, it's even easier in Rust (using channels for instance). We have all the building blocks, mutexes, atomics. We have ways of signalling readyness on sinks/channels, using for instance operating system utilities like epoll, poll, select etc. Using these are also easy. And they don't come with the mental context that using something incredibly intrusive like Tokio comes with. But yeah, I think you're right the appeal comes with that it "looks synchronous" but as I said, using read().wait() on a thread pool future is *exactly* that same thing (std::future in c++, I don't know the name off the top of my head Rust, but technically a mpsc channel works just fine here). Add to that that debuggability is many times easier with multi threading than it is with coroutines. Many, many times easier.

Yeah but that's literally an issue every single language not named C/C++ has to deal with lol

@@Reydriel Guess its good I know C, everything else is half baked.

How many times have I heard "We chose Rust for it's safety/types, not for its performance!" on twitter and in different articles... Furthermore, Rust evangelists generally advise to use Rust for everything. At least that has been my experience. I am soo close to muting the word Rust on twitter because of how much I hear about it, wanna guess how many of them preface with "Only use this when you need absolute performance"? Correct. Zero.

@@secondson4536 I'm using rust in 100k lines codebase, and not for performance, but for correctness and I'm very happy with it. best decision I've made. He defintely had skill issues. I did have struggles in previous "side projects" trying to learn rust over around 2 years (was working in TS in my main job), only when I was confident with my skills did I start with a real project. He jumped straight in and got destroyed, and now blames the languages, yes, Rust learning curve is steep, nobody is denying that. if you want easier language go with Go. but don't blame your incompetence on the language.

Also so many people saying how Rust is great because of all of those features, which normally have nothing to do with its speed. Yet when it is critisized people like you show up defending bad parts of the language (that are omitted from those praising articles) with either skill issue argument or the "Well its speed is why it is like this". Here you don't get one of the main points of this article: nothing really told this person about those bad parts, as though they don't exist. This person, probably just like me, heard from every corner of programming fan infested internet about how Rust is great with approximately 0% of them mentioning parts where you might encounter some issues.

@@secondson4536 I mean if they read the book they would have realized that it wasn’t going to be as “easy” as they had hoped for. I don’t know a single person who doesn’t recommend the official book as a first learning resource. And I’ve know plenty of people who have struggled because they refused to read it. In no way am I saying that it’s a perfect language. I’m just saying that the complaints this particular guy is making are in complete antithesis to the objective of the language itself. So stop putting words in my mouth saying that I’m claiming things. I understand his points. I also understand that he completely missed the point of Rust and is now painting it as a problem that anyone who bothered to learn what Rust is about before refactoring their entire project in it would have understood.

@@secondson4536 The problem is that it is a skill issue. For beginners, I'd recommend building up your "repo of patterns" that you can introduce while coding. For example, knowing when to borrow or clone, what container type to use, how to work with features/streams/iterators in specific cases, ... The way I've learned it is by playing around with simple examples in a playground project.

People often forget that async in rust is still a work in progress and it certainly will be better in a few years

@@obamagaming3802 Is it really a work in progress? It has shipped in stable Rust long ago. Maybe, though, if you consider the different executors as “async Rust”.

Erlang even better. An Erlang dev told me this.

​@@obamagaming3802 It won't be. The fundamental guarantees of Rust as a language conflict with the async paradigm and result in the mess that is Rust's async. It would take a 2.0 with breaking changes that degrade the language in other domains to improve async. The async paradigm itself is terrible independent of language, but that's another topic beyond the scope of a yt comment. Rust is one of the best and most eloquent languages for parallelism provided you don't use async. It solves many, many problems that the other languages have and is a genuine force multiplier.

​@@7th_CAV_Trooper Green threads is not viable to a system language

trillions of dollars? sure buddy....

@@samuraijosh1595 in FX the two primary spot exchanges, EBS and Reuters, do anywhere from 50-80 billion on a normal day. Over the course of a year, you're in the trillions. Different story if you're talking equities which trades in the hundreds of millions.

@@samuraijosh1595 the two primary exchanges in FX, EBS and Reuters, do roughly 50-80 billion in spot volume daily. Over the course of the year, that is in the trillions. FX also trades primarily OTC, i.e. you're trading directly with a bank, not over the exchange.

"Average daily volume in total over-the-counter (OTC) foreign exchange instruments (including spot, outright forward, foreign exchange swap, and option transactions) was $1,021.0 billion in October 2023." - New York FED

This perfectly describes my issues with C++, raw memory access with (until recently) no automated managed memory because "it's something the devs should do" is utterly insane, and not a gotcha for a design flaw. To add to your point, the idea of "skill issue" implies that especially on a team, everyone is 10x devs with no human error and knows exactly what they are doing 100% of the time. Obviously that's not the case which is why most devs try to automate much of the work to avoid these issues (checkers, linters, static analysers, CI, etc)

@@itermercator114 "raw memory access with (until recently) no automated managed memory " How old are you? Automated memory management has been in C++ since Cfront.

@@itermercator114 " C++, raw memory access with (until recently) no automated managed memory" Destructors have been in the language since Cfront. Vector has been in the standard since C++98.

"raw memory access with (until recently) no automated managed memory " How old are you? Automated memory management has been in C++ since Cfront. Vector has been in the standard since 98.

yeah calling a language garbage with bad designs when after admitting you can't even properly structure error message is so weird . Rust is so great because it humbled many of these dudes with god complex thinking they actually know everything , a truly smart & humble person will sit down and learn these stuff instead of lashing out and insulting everyone and everything edit: typos

I went back to writing some Perl for some personal scripting tasks. I haven't found anything comparable as a utility scripting language.

It's a skill issue not on the users' part but on the part of whoever engineered that language, if that's the case that it's incredibly difficult to pick up. It's just bad engineering. You don't create an overly-complicated to use car then blame the customer when something doesn't work.

At some stock exchanges, everyone gets a fiber connection WITH THE SAME LENGTH AS EVERYONE ELSE. Just so everyone has the same latency to the server(s). It's just madness.

@@piff57paff I often feel like those resources could have been put to better use by doing, like, _anything else with them_

It's very hard to say anything in general about what the performance requirements for algo trading are like because every company is doing something slightly different. There are some companies doing the FPGA thing and worrying about speed of light delays, but there are also companies just running python. Jane Street famously runs OCaml (not super slow, but far from the fastest). There're probably extremely few people who can speak authoritatively about algo trading in general.

@@Takyodor2 Depends, do you want to have predictable prices at the gas station and grocery store? Do you want people to be able to afford to grow food? People think that some guy at work trading stocks on "hot tips" is somehow representative of the entire industry. People working there full time only make money by providing value to their customers.

@MaxHaydenChiz Buying groceries and growing crops worked fine for thousands of years before low-latency trading was invented. I wouldn't mind if stock trading disappeared as a whole, and companies could focus on providing good products instead of making the graph go up, but specifically low-latency trading is on a different level of unnecessary.

skill issue

I can confidently say that never while developing any of our core applications in C++ I felt the need to say "gee, this would be much easier with random pauses and if I didn't understand when resources would be deallocated". Not once.

Rust makes any project closed source.

@@bandito_801 Your whole life is a skill issue.