Async Rust Is A Bad Language
Async Rust Is A Bad Language
bitbashing.io
Async Rust Is A Bad Language
24 comments
-
-
fn foo(＆big, ＆chungus)is out,
async fn foo(＆BIG_GLOBAL_STATIC_REF_OR_SIMILAR_HORROR, sendable_chungus.clone())is in.
Or maybe you know
fn foo(＆big, ＆chungus)is out
async fn foo(big, chungus) -> (big, chungus)is in
Or
async fn foo(big, chungus) { // ... tx.send((big, chungus)).await?; // ... }is in
Moving (movable/sendable) data is not limited by number or direction, you know. And that second one even makes use of them great Hoare channels! And gives us control on how long we hold on to data before sending it back (modified or not). But I digress. Let's go back to the important talking point that Hoare was right!
-
I think the point of the "BIG_GLOBAL_STATIC..." name is that global statics are bad, not that the syntax is ugly. That said, you're absolutely correct that combining channels with async code is the way to go.
-
I think the point of the “BIG_GLOBAL_STATIC…” name is that global statics are bad, not that the syntax is ugly.
Yes. And my point was that there is an obvious way of sharing data besides passing static-refs, cloning, and using
Arcs, which is moving data bidirectionally. That was conveniently, or ignorantly, glossed over by the coping gopher.
-
-
-
Interesting read but I don't agree that it's as bad as the author makes it sound. I'm also curious what an alternative would be, if you don't want a garbage collector?
In my personal experience, you don't run into all the Arc, Pin and 'static stuff that often. I would even say very rarely.
-
I agree, I've written a lot of async rust and it's rarely an issue for me. I have more issues with the generated futures and the traits they implement not matching what I need, meaning I often have to jump to manually created futures and pin-project (which isn't too bad tbh but far more work than writing with async/await).
-
-
Maybe it's just me, but isn't async programming a mess in all programming languages?
-
It's a joy to do async in go IMO
-
not really. first of all async in not the same as threading. And even then, while it makes parallel code easier to write (not easier to reason about), it still has the exact same footguns as anything else, as soon as you venture away from having only one consumer for every producer. Synchronization is still all on you
-
That's a whole different thing to me. That's not async, that's channels and multithreading.
I do that in Rust as well with mcsp channels and it's been fine.
It's the async/await bit that I find incredibly akward all the time.
-
To be fair, a lot of that is because the scheduler detects blocking IO and context switches.
Rust could get really far with Go-style channels.
-
-
-
It really is interesting how
asyncRust takes the shine off of Rust to such an extent. If good old stack based, single threaded Rust wasn’t so polished, I don’t think theasyncparts would stand out so much. Something that might help is to have some sort of benchmark showing thatArcing through anasyncproblem is still faster than typical GCed languages. -
Good read!
-
-
Zig's approach seems even more low-level and manual: https://ziglearn.org/chapter-5/
(In general, I think Rust and Zig both seem valuable, and I think it's a mistake to treat programming language success as a zero-sum game.)
-
Mf's have no sense of humor here..
Or.. at least MY sense of humor.
-
Also, my meme was based on https://kristoff.it/blog/zig-colorblind-async-await/ I didn't randomly pick zig.
-
24 comments
Async rust might suck, compared to async in higher level languages, but for someone comming from C, async rust simplifies a lot of stuff. It often feels like a lot of criticisms of rust boils down to the fact that rist was sold to both people using low and high level languages. I don't doubt that async rust is shit when all you want is a faster typescript.
Edit: I certainly also have my criticisms of rust and its async implementation, and I think some of the authors concerns are valid, it was just an observation about the tension between the needs of the two groups of users.