News for hackers. Stuff that matters.
Re:A four year plan for async Rust by inamberclad on Tuesday November 07, 2023 @11:38AM (#38178988)
Async is a huge wart and I try and avoid it wherever possible. It's simply not useful in a lot of cases that I encounter. However, if a library uses async, you have little choice but to make your whole project async. This adds to its horrible reputation.
Re:A four year plan for async Rust by the__alchemist on Tuesday November 07, 2023 @11:47AM (#38179137)
I'm with you. I feel like an outcast in the Rust OSS embedded circles when I bring this up. They are heavily into async/embassy.
Re:A four year plan for async Rust by dgacmu on Tuesday November 07, 2023 @12:09PM (#38179531)
I'm curious why you don't like it for embedded - embassy has been an absolute delight for me thus far, and my primary complaint about it is just that it doesn't have the breadth of hardware support (yet?). It's been the thing that has redeemed Rust async for me, as otherwise, I tend to find the tension the author notes frustrating as well.
Re:A four year plan for async Rust by steveklabnik on Tuesday November 07, 2023 @12:12PM (#38179587)
I am pro async Rust, but we don't use async in our embedded projects at Oxide. This is because of specific design constraints and goals: https://hubris.oxide.computer/reference/#_why_synchronous

That being said, I am also a fan of embassy when you have different design constraints and goals, and consider the fact that is is able to exist and be successful is a massive testament to the design of async Rust.

(We also use async Rust heavily further up the stack, and have some issues with it, but they tend to be disjoint from the way that this is talked about online.)

Re:A four year plan for async Rust by dgacmu on Tuesday November 07, 2023 @12:46PM (#38180142)
Oddly, I agree with you - but I think I may be approaching it differently. I use async as a mechanism to be able to have clearly-defined "tasks" in an embedded context, where tasks have straight-line code that handles something. I have most of the interaction between tasks be synchronous; in the case of embassy, the thing it brings is that it manages that otherwise-spaghetti-feeling mix of state machines in an easy-to-read kind of way.

Example from a current side project, since it's not work-encumbered: A wifi-enabled clock light for my 5yo. It has a task that sits there and every hour pings an SNTP server, updating a (mutex-protected) global with the time state. It has another task that listens for a telnet session for various control signals - which also updates a mutex-protected global config state. And it has a task that spins doing LED effects.

With embassy/async, I can write each of those as a separate task, without paying much attention to what gets invoked by interrupt handlers.

(This particular one is an rp2040, but I use it on stm-based systems as well).

I feel like this is kind of analogous to the discussion of threads-vs-events as a mechanism for structuring code vs. threads as a mechanism for achieving parallelism. :-)

Edited to add: Or, perhaps an alternative view of what I'm doing is that I'm using the embassy runtime as a really lightweight alternative to an RTOS, since I mostly haven't met an RTOS I don't want to throw across the room. An argument against what I'm saying here is, "well, use Hubris as your embedded OS and then you can have tasks and they can be synchronous" - which seems entirely fair.

Re:A four year plan for async Rust by steveklabnik on Tuesday November 07, 2023 @12:59PM (#38180366)
> I use async as a mechanism to be able to have clearly-defined "tasks" in an embedded context

This is also a good design! The primary designer of Hubris also has a project that works like this: https://github.com/cbiffle/lilos

Re:A four year plan for async Rust by the__alchemist on Tuesday November 07, 2023 @12:13PM (#38179599)
What I like about Embassy is the Metapac, and less reliance on generics and typestates than predecessors.

My complaint is I don't find the async ergonomics intuitive; it feels like a layer of misdirection. And, the viral character.

Re:A four year plan for async Rust by littlestymaar on Tuesday November 07, 2023 @11:47AM (#38179141)
> However, if a library uses async, you have little choice but to make your whole project async. This adds to its horrible reputation.

No. You look what executor your dependency is using (most likely tokio) you add it to your cargo.toml (at zero cost, since it's already there in your dep) and then you wrap the async library calls in `block_on` and call it a day. You don't need to change a single other line in your project.

Re:A four year plan for async Rust by couchand on Tuesday November 07, 2023 @11:52AM (#38179215)
You breeze over the dependency weight by abusing "zero cost" to mean "sunk cost". They're not the same!
Re:A four year plan for async Rust by littlestymaar on Tuesday November 07, 2023 @12:54PM (#38180275)
They are. If you're using a dependency you're using your dependency dependencies, there's no way around it.

If it matters to you, you don't have the same priority as your dependency's author anyway and probably shouldn't be using it in the first place, and it has nothing to do with async.

Re:A four year plan for async Rust by pm215 on Tuesday November 07, 2023 @11:53AM (#38179227)
This was not my experience. I had a working program that used the reqwest crate for a very basic synchronous-is-fine "just give me the contents of this web page" function. When I tried upgrading it to a newer reqwest that had decided async was the way to go, I found that that nice easy to use synchronous function had simply disappeared entirely, and I seemed to have to figure out async in order to use the library now. Luckily it was only a toy project so I just left it at the older version of the library. But as my first exposure to "async" as a rust feature it was a pretty off-putting one.
Re:A four year plan for async Rust by pdw on Tuesday November 07, 2023 @12:01PM (#38179378)
For reqwest, using the feature "blocking" will enable the reqwest::blocking API.
Re:A four year plan for async Rust by theossuary on Tuesday November 07, 2023 @12:02PM (#38179395)
Reqwest still has a block client available [1]. I assume you upgraded across a major version, and are mad that there were backwards breaking changes? Don't do that if you don't want to update your code to account for changes in the dependency.

[1]: https://docs.rs/reqwest/latest/reqwest/blocking/index.html

Re:A four year plan for async Rust by wongarsu on Tuesday November 07, 2023 @11:49AM (#38179165)
Another viable strategy is to start a single-threaded tokio executor and treat it like another thread that you communicate with over (flume) channels.
Re:A four year plan for async Rust by littlestymaar on Tuesday November 07, 2023 @11:52AM (#38179207)
Yes this works too. People complaining about async being contaminant are often so much prejudiced against it that that haven't even tried to understand the basics.
Re:A four year plan for async Rust by dymk on Tuesday November 07, 2023 @11:54AM (#38179256)
I have plenty of gripes about async in rust, but one of the things it's surprisingly good at is isolation of async runtimes. There's no reason you can't have multiple tokio runtimes, or transient runtimes, in your application.

Now if only the other warts were fixed, like the particularly poor compiler errors when there's an issue within an async function...

Re:A four year plan for async Rust by tuetuopay on Tuesday November 07, 2023 @12:25PM (#38179798)
Yup. I was blown away when I spun up five different tokio runtimes in the same app all communicating through channels. I expected at least the tokio-aware channels to be problematic but not in the slightest. It's now humming in prod doing its business. Once you get the basics, it's quite easy to lego stuff out and get the best of both worlds.
Re:A four year plan for async Rust by LtWorf on Tuesday November 07, 2023 @01:07PM (#38180466)
Having written an async library (as in, the non-blocking stuff and state, that to the caller looks like async)... Understanding it isn't the easiest.
Re:A four year plan for async Rust by mplanchard on Tuesday November 07, 2023 @01:21PM (#38180686)
Yeah writing the underlying machinery is definitely much more complicated! Most users of async libraries don't need to worry about this though
Re:A four year plan for async Rust by echelon on Tuesday November 07, 2023 @11:48AM (#38179146)
What on earth are you talking about? Async is amazing. Super fast servers in Actix with multiple DB connectors performing simultaneous queries is super easy to set up.

So many people complain about Rust being hard. What on earth are you people on about? This isn't at all a hard language.

I'm so sick of this "async is hard" / "Rust is hard" meme. No, it isn't.

Maybe it's inconvenient if you're used to slapping packages together and calling it a day. But I don't think the majority of us do work like that.

And it's not hard.

Re:A four year plan for async Rust by seanw444 on Tuesday November 07, 2023 @11:53AM (#38179218)
The point can be made equally well without the elitist condescension.
Re:A four year plan for async Rust by echelon on Tuesday November 07, 2023 @11:56AM (#38179289)
It's not elitist.

I'm sick of people perpetuating this about the Rust ecosystem. It's not a month that goes by that there isn't some article badmouthing the language and its features.

Stop it.

We want our language to gain support in enterprise so we can get paid to write it as our day job. These articles are not helping.

Re:A four year plan for async Rust by kelnos on Tuesday November 07, 2023 @12:41PM (#38180039)
[delayed]
Re:A four year plan for async Rust by dymk on Tuesday November 07, 2023 @12:01PM (#38179376)
This article is by a Rust contributor. I'm sure they want to see Rust be more widely adopted as well. Async is pretty great, but it's not perfect, and in some situations its shortcomings cannot be worked around easily.
Re:A four year plan for async Rust by withoutboats3 on Tuesday November 07, 2023 @12:10PM (#38179547)
I think the comment this person was responding to is completely off topic for my blog post, and extremely shallow. I share the person you're responding to's frustration with how async Rust is talked about on Hacker News.
Re:A four year plan for async Rust by mplanchard on Tuesday November 07, 2023 @12:45PM (#38180126)
I also agree with echelon, and I've been working with async rust daily for two and a half years. It was a bit painful before tokio 1.0, but by and large it's consistently great to work with, especially now. My only complaints remain having to restructure closure-based code into loops and occasional weird lifetime issues caused by the `#[async_trait]` macro, but hopefully the latter will go away with stabilization of `async_trait`.

The amount of "async rust is impossible to use," "async rust is fundamentally broken," etc. commentary that comes up on HN is absurd. I have trouble squaring my own experience with it, and it makes me think people are either complaining just to complain or that they haven't worked with it in anything other than toy contexts. I have a hard time imagining how difficult it would be to maintain our ~100k line rust codebase (http proxy that processes requests & responses, makes DB queries, and makes http requests to other services) and keep any kind of predictable performance by spawning threads, using channels, etc.

Like, not trying to be elitist, but I feel like people are missing the benefits for the sake of piling on or something.

Re:A four year plan for async Rust by FencePost12 on Tuesday November 07, 2023 @12:07PM (#38179483)
Choosing a technology because it’s what you want to work in is never proper engineering for non-college projects. Choose the best technology to…you know…create a quality product for your customer. You can get paid that way too.
Re:A four year plan for async Rust by CyberDildonics on Tuesday November 07, 2023 @12:06PM (#38179472)
Your comments boil down to "I think rust is easy, stop giving your opinions that don't agree".

You didn't make any arguments here at all. You can check my other comment for detailed reasons why async in a language is not a good approach to concurrency. The overview is that is just isn't a holistic solution and the only time it will solve someone's problem is if they have extremely simple concurrency needs in the first place and those never scale or change.

Re:A four year plan for async Rust by insanitybit on Tuesday November 07, 2023 @12:21PM (#38179733)
The way I see their comment, and they'll have to forgive me if I'm wrong, is that the "async is bad" posts are generally not great.

a) They often focus on problems that, at least for me (and many others) are not significant. For example, acting like writing "+ Send + Sync + 'static" is causing your hands to seize in pain. Or they ignore that you can "block_on" a future.

b) They're then often interpreted by people who have very little context on async or rust at all. Look at the initial comment of "Async is a wart", it's idiotic. Look at how stupid the comments section is, how people are not talking about literally anything that boats wrote.

c) They make propositions that aren't very helpful. They mostly say "it was a mistake!" or "we don't need multithreading" or "we want TPC".

Contrast with Boats' post, which is far more contextual, far more historical, and proposes actual solutions and future work to be done.

It's quite frustrating to see the same sorts of complaints over and over again, especially when they're often not super great complaints to begin with.

Re:A four year plan for async Rust by CyberDildonics on Tuesday November 07, 2023 @12:34PM (#38179949)
I don't think that's what they are saying, I think that's what you're saying. I would be frustrated by that too, but I don't see any of that here.
Re:A four year plan for async Rust by insanitybit on Tuesday November 07, 2023 @12:37PM (#38179987)
Well they're responding to someone saying "Async is a wart".
Re:A four year plan for async Rust by starcraft2wol on Tuesday November 07, 2023 @11:53AM (#38179223)
The entire unix operating system is designed so that you can write sequential code. It abstracts concurrency away. It’s incredible.
Re:A four year plan for async Rust by gwbas1c on Tuesday November 07, 2023 @02:12PM (#38181375)
The point of async is to move concurrency from the OS into the process.

The specific issue is the context switch. The compiler, with async is able to be much more performant than the context switch that the OS provides.

Depending on the kind of application you're writing, this is either splitting hairs or very, very important. Applications that handle many (hundreds, 1000s,) of concurrent IO will have a noticeable performance improvement using async versus the OS's context switching.

But, there's a more important thing to consider: "async" in a programming language communicates that a method can block. It allows the caller to start the call and do something while it's waiting for the result, without needing to get into the weeds of threading. Purely relying on the OS for context switching means that it's hard to know what methods block.

Re:A four year plan for async Rust by starcraft2wol on Tuesday November 07, 2023 @02:39PM (#38181727)
I agree with most of this.

> without needing to get into the weeds of threading

A thread is the exact concept needed to describe that and preserve “if else then” sequential code.

> 1000s of threads

Linux handles thousands of threads just fine. If you’re using a scripting language like python, context switching is the least of your performance concerns.

Re:A four year plan for async Rust by gwbas1c on Tuesday November 07, 2023 @03:11PM (#38182122)
> A thread is the exact concept needed to describe that and preserve “if else then” sequential code.

I suggest looking at C# and Javascript that implement async very, very well.

The difference is that with conventional threading semantics, when you join a thread, it doesn't return a result. You still need to write some kind of "thing" to get your result from the subthread to whatever's waiting on it. (C# also provides a less-well-known BeginInvoke mechanism which is somewhat cleaner than join.)

In contrast, the promise (Javascript) or task (C#) has a result. Instead of joining a thread, the await keyword gets the result, just like calling a method.

> Linux handles thousands of threads just fine.

Yes... And no...

It doesn't matter what OS you're on, each thread needs its own allocated stack space and has the overhead of context switching. "async" optimizes that by putting data that would normally go into many different stack spaces into the heap and jumping around among concurrent operations without the context switch.

Again, depending on what you're doing, that's either splitting hairs, or really making a tangible improvement. But you can't argue that more allocated stacks, and more context switches, is faster than doing it in process. At that point you're arguing with fact.

Re:A four year plan for async Rust by gwbas1c on Tuesday November 07, 2023 @05:39PM (#38184054)
Too late to edit: I should also point out that Rust has the same issue with joining a thread: It doesn't give you the result of the function; unlike awaiting on a promise.

(I really struggled with async rust, so I'll admit that I don't remember the name of the type that represents the promise.)

Re:A four year plan for async Rust by starcraft2wol on Tuesday November 07, 2023 @09:09PM (#38185893)
> C#/JavaScript

I am familiar with how these are implemented. My opinion is the same. Yes you can implement slightly lighter weight threads in a language itself.

> It doesn't matter what OS you're on, each thread needs its own allocated stack space and has the overhead of context switching

This is a quantitative question. I know what it does, the question is how much slower it is than whatever async construct you want to use.

Re:A four year plan for async Rust by returningfory2 on Tuesday November 07, 2023 @03:08PM (#38182082)
Just a note that it seems many people think the main problem isn't the context switch. Rather, Linux by default allocates a very large stack to every thread, and thus many threads lead to high memory usage. Async makes this better.

See e.g. this recent clip from one of the engineers on Project Loom in which they argue that the context switch is relatively low overhead: https://youtu.be/07V08SB1l8c?si=i0v9w90Kb_M0I4gP&t=966

Re:A four year plan for async Rust by gwbas1c on Tuesday November 07, 2023 @03:12PM (#38182134)
At least on Windows I've reconfigured the stack space. (I had to run an experiment that required a lot of threads.)

Is this something that's hard to do on Linux?

Re:A four year plan for async Rust by steveklabnik on Tuesday November 07, 2023 @04:29PM (#38183120)
It's the same, but this issue gets to one of the hearts here:

Both of these APIs are set by you, the user. You can choose how big to set your stack size, it's true. However, what value do you actually set? Too high, and you're still using too much memory, though admittedly less. Too low, and you either need to accept death by stack overflow, or runtime detect this case and fix things up.

With async/await in Rust, the compiler can statically see how large the stack size needs to be. Each "thread" will have a perfectly sized stack. No user intervention required, no fiddling with settings.

Re:A four year plan for async Rust by 10000truths on Tuesday November 07, 2023 @11:09PM (#38186672)
> Both of these APIs are set by you, the user. You can choose how big to set your stack size, it's true. However, what value do you actually set? Too high, and you're still using too much memory, though admittedly less. Too low, and you either need to accept death by stack overflow, or runtime detect this case and fix things up.

This is a solved problem - it's "just" the longest path in a call graph where each node is weighted by its function's stack frame size.

> With async/await in Rust, the compiler can statically see how large the stack size needs to be. Each "thread" will have a perfectly sized stack. No user intervention required, no fiddling with settings.

There is nothing stopping a compiler from doing the exact same analysis for a sync function at compile time (barring exceptions like varargs or deliberate recursion). They just... haven't, for some reason. It's a shame that it took until Zig for it to be addressed.

Re:A four year plan for async Rust by MrBuddyCasino on Tuesday November 07, 2023 @04:11PM (#38182899)
The stack memory won’t actually be physically allocated upfront - like all user space memory it is virtual.
Re:A four year plan for async Rust by withoutboats3 on Tuesday November 07, 2023 @11:53AM (#38179237)
What Rust libraries use async that you think should not? I can think of one, but otherwise every library I've encountered uses async because its intended for the kind of networking service that benefits from using non-blocking IO.
Re:A four year plan for async Rust by sapiogram on Tuesday November 07, 2023 @12:14PM (#38179619)
I had an absolutely awful experience when I tried using Sqlite through the sqlx crate. The work was mostly cpu-bound, but I didn't mind blocking the event loop for a few seconds here and there, so I thought I would just run it on Tokio's worker threads. Big mistake, I ended up getting extremely low CPU utilization due to a quirk (Or less charitably, a bug) in Tokio's scheduler.

I eventually rewrote the whole thing with rusqlite, but apart from being non-async, I found the API much less ergonomic to work with. But at least Rayon worked exactly as I expected.

Re:A four year plan for async Rust by couchand on Tuesday November 07, 2023 @11:55AM (#38179272)
Just because it's a network request doesn't mean it benefits from using async.

EDIT: to add a specific example, postgres. I understand from sfackler's perspective why it makes sense to maintain just an async library and a sync wrapper around it. But from the user's perspective there'a absolutely no reason that all of tokio should be required to talk to their db.

Re:A four year plan for async Rust by mplanchard on Tuesday November 07, 2023 @12:37PM (#38179984)
Nothing is stopping anyone from writing DB drivers that don't require async. If there's as much of a market for it as threads like this suggest, it seems like it would be a fairly popular project.
Re:A four year plan for async Rust by geodel on Tuesday November 07, 2023 @01:55PM (#38181157)
Huh, thats rather odd argument. It is like saying no one is stopping anyone to write new low level, memory-safe programing language, that won't have Rust style async system. If there is real market demand it could fairly popular project.

DB drivers, http servers, runtimes and so many other complex components are preferences of high skilled developers and not some objective market choices. Once its developed most application developers have to use it however user unfriendly it maybe.

Re:A four year plan for async Rust by mplanchard on Tuesday November 07, 2023 @07:05PM (#38184968)
One thing about Rust is that it's a fairly young language. We've had to implement a number of things ourselves that we wouldn't have had to implement in other languages.

If there's not enough community interest for there to already exist a solution for your problem, you really only have three options: write it yourself (including opening a PR to add it to an existing implementation), pay someone to write it, or switch languages. If none of these are options, you're just out of luck, and complaining about it is unlikely to do any good. I'm not saying you can't complain of course, but I am saying that you're more likely to get what you want via another path.

But regardless, I don't think it's an odd argument. Indeed, no one is stopping anyone from writing a new, low-level, memory-safe programming language! That's why Rust exists! Turns out the market was huge! Writing a new one now would be easier because of all the great ideas that Rust helped to prove work at scale. We're seeing this already with the success of languages like Zig, which makes different tradeoffs than Rust did and seems to be finding success in slightly different niches.

And sort of disproving your point, we use postgres, and I can think of three different implementations of postgres drivers offhand (sqlx, tokio-postgres, and diesel). I'll also note that the author of tokio-postgres also publishes https://docs.rs/postgres/latest/postgres/, which is not async! It's impressive how many options we have for such a complex thing in such a young ecosystem.

Re:A four year plan for async Rust by couchand on Tuesday November 07, 2023 @09:19PM (#38185961)
postgres is a wrapper around block-on(tokio-postgres).
Re:A four year plan for async Rust by withoutboats3 on Tuesday November 07, 2023 @12:07PM (#38179487)
As a user who has maintained network services that communicate with Postgres, I'm very glad that sfackler's postgres library doesn't perform blocking IO calls, as that would make it unfit for purpose for me.
Re:A four year plan for async Rust by couchand on Tuesday November 07, 2023 @12:28PM (#38179852)
Maybe you misunderstand me. I'm not saying there shouldn't be a non-blocking version. I'm saying async is not a silver bullet. Some programs/teams/environments have different constraints than you.

Would you also advocate for the kernel to deprecate blocking i/o?

Re:A four year plan for async Rust by withoutboats3 on Tuesday November 07, 2023 @01:11PM (#38180523)
Obviously, it'd be better for someone who wants to talk to postgres and doesn't need non-blocking IO if a version based on blocking IO existed. But what is your grand point? It's not some conspiracy that libraries for network services use async/await: they most often do it because their maintainers need to use async/await in the work that pays for them to provide this open source library free of charge to you.

And all you need to do to not deal with async is wrap it in one of the many different block_on implementations. Yes, that's less ideal than not having to pull in these dependencies; if avoiding those dependencies is mission critical for you, maybe yours could be the enterprise that pays for the blocking IO postgres library.

Re:A four year plan for async Rust by chlorion on Tuesday November 07, 2023 @01:42PM (#38180977)
"async" and threads are not the only options for concurrent IO.

I've never saw anyone discuss using poll(2) style concurrency here which is interesting but also kind of sad.

With the mio crate for example, it uses the operating systems "select/poll" interface. On Linix this is epoll(7), but other OSes have their own interface.

"poll" style concurrency is a lot less complicated for me. The general idea is to register IO handles such as sockets into a data structure and pass it into the kernel. The kernel will emit events whenever a handle is ready to do something. There is the option to go to sleep and block until one of the handles are ready but it's not required.

"async" is an abstraction on top of this. The async runtime is handling the event loop and other stuff for you which is very useful but also a little bit complicated.

I am not in any way against "async" style concurrency but I think a lot of libraries could avoid pulling in a runtime and still be concurrent.

Re:A four year plan for async Rust by insanitybit on Tuesday November 07, 2023 @01:56PM (#38181165)
"mio" was the game in town for years and it was definitely not ideal at all, it was promising but very low level and most people didn't use it if they could help it. People wanted async/await.
Re:A four year plan for async Rust by bryanlarsen on Tuesday November 07, 2023 @02:11PM (#38181355)
Several of my rust programs use tokio's select! macro as their main loop. I really like that pattern.
Re:A four year plan for async Rust by the__alchemist on Tuesday November 07, 2023 @11:57AM (#38179305)
> the kind of ... service that benefits from using non-blocking IO.

Async, in the sense from the article, and non-blocking aren't synonyms. Not using Async doesn't imply blocking.

Re:A four year plan for async Rust by withoutboats3 on Tuesday November 07, 2023 @12:00PM (#38179356)
What Rust libraries use non-blocking IO without using async syntax? I don't know of any. This interpretation of the request is new to me: I've exclusively heard complaints about libraries using async from people who want to use blocking IO.

(Also, in case it isn't obvious: I wrote the article in question.)

Re:A four year plan for async Rust by the__alchemist on Tuesday November 07, 2023 @12:05PM (#38179460)
I usually do non-blocking ops with hardware interrupts, DMA, distributed computing (over CAN etc), and multiple cores. For GPOS/Desktop PCs, threads, SIMD (GPU or CPU etc) are effective.

More generally than the concurrency operations I described, are any sort of event-loop or state machine, of which Async is one example.

Re:A four year plan for async Rust by dpc_01234 on Tuesday November 07, 2023 @01:23PM (#38180721)
Example from the recent past: I wanted a quick Rust code to stream s3 object, uncompress with zstd and untar the content to a directory. aws-sdk-s3 supports only async (tokio), tar crate only blocking, async-tar only async-std, async-compression only tokio. Hard to paper over it with `block_on` because of the streaming part. I don't remember what I actually did, but it doesn't matter - having to come up with a magic working combination is exactly the pain.

I just wish everything would at least still support blocking IO as a common denominator, so there's at least a baseline that is known to be possible. 99% of percent of the time I do not need benefits of async, because I write small software for relatively small, but still real use-cases. And using Rust ecosystem was easier just a few years ago than it is now for these use-cases, as blocking Rust was not yet relegated to be a second class citizen, replaced by an immature and fractured async.

Re:A four year plan for async Rust by insanitybit on Tuesday November 07, 2023 @01:44PM (#38181011)
> And using Rust ecosystem was easier just a few years ago than it is now for these use-cases

I used to write Rust web services (professionally) before async and it was definitely not easier for me. It was way harder. I'd end up with accidental hanging because some socket didn't have a timeout set on it properly, it was extremely leaky (why the hell am I talking to raw socket APIs just so that I can read from S3?), and it sucked compared to async. We've had radically different experiences, somehow.

Re:A four year plan for async Rust by dpc_01234 on Tuesday November 07, 2023 @05:24PM (#38183853)
> why the hell am I talking to raw socket APIs just so that I can read from S3

I don't know. https://doc.rust-lang.org/std/net/struct.TcpStream.html#meth... etc. were there for a while. Though I think that deadline-based timeouts would be way better to have. https://www.reddit.com/r/rust/comments/8b5krv/the_case_for_d... . Probably could be built around existing primitives. These things were never built/popularized because the community just jumped on async like some silver bullet.

I agree that building heavy duty networked services got easier with async, but at an expense of fracturing the ecosystem and dragging everything else into an MVP feature, which made things worse (at least in some respect) for other things. I personally don't do much web servers, and when I do I can just spawn lots of threads, terminate TLS with nginx anyway.

Again, I don't mind async on its own. I think it's great for what it is, and is useful when it's useful. But for decades tons of the web was built in Java, Python, RoR without async IO and it worked just fine. And I didn't have to play IO-type sudoku, and could expect that the most basic, native blocking IO is well supported, and not just an afterthought/wrapper.

Re:A four year plan for async Rust by dymk on Tuesday November 07, 2023 @11:56AM (#38179290)
> However, if a library uses async, you have little choice but to make your whole project async.

This isn't true. I'm writing an application right now that is mostly sync, but has a small amount of async code in it. It's easy to spin up a tokio runtime which can run inline on the current thread. Then use it to evaluate a Future.

    tokio::runtime::Builder::new_current_thread().enable_all().build().unwrap().block_on(async {
        println!("I'm async!");
    });
Re:A four year plan for async Rust by killercup on Tuesday November 07, 2023 @12:05PM (#38179447)
Because this code block looks quite complex, I want to add that it can also be just

    smol::block_on(async {
        println!("I'm async!");
    });
(I thought tokio had a helper like this too but could only find `tokio::runtime::Runtime::new().unwrap().block_on(async { println!("I'm async!"); });`.)
Re:A four year plan for async Rust by cedws on Tuesday November 07, 2023 @12:29PM (#38179861)
Needing a helper library for something as simple as async so you don't go mental is really not good enough. I see the same thing with error handling - every Rust project I see imports a helper because it's too clunky otherwise.
Re:A four year plan for async Rust by mplanchard on Tuesday November 07, 2023 @12:34PM (#38179950)
If you don't want to pull in a helper library to run async code in a sync context, then why pull in an async library at all?

Rust is not a batteries-included language like Python. There are lots of libraries that are very commonly used in most projects (serde, thiserror, and itertools are in almost all of mine), but this is a conscious choice. They say in Python that the stdlib is where projects go to die. I'd rather have the flexiblity of choosing my dependencies, even for stuff I have to use in every project.

Re:A four year plan for async Rust by Elinvynia on Tuesday November 07, 2023 @01:26PM (#38180760)
The problem is that a large number of popular libraries has converted to async, 95+% of them to Tokio.

So you are stuck with smaller, less battle tested products if you'd rather not pull in 100+ crates of dependencies that are doing nothing but inflating the build times and file sizes (for your particular usecase).

Example: reqwest vs ureq

Re:A four year plan for async Rust by insanitybit on Tuesday November 07, 2023 @01:52PM (#38181120)
OK, but like, can we just be honest then that the problem here is that your build times go up? People act like it's an insurmountable problem rather than just a trivial trade-off where, yes, your build times will go up because of some extra dependencies on an async runtime.

Increased build times are not great but holy shit the way people talk you'd never know that that's the actual trade-off here, an extra 3 seconds on a clean build.

Re:A four year plan for async Rust by qup on Tuesday November 07, 2023 @05:24PM (#38183861)
Adding dependencies is not easy in some organizations. You have to trust them, in addition to waiting 3 seconds to compile them.
Re:A four year plan for async Rust by insanitybit on Tuesday November 07, 2023 @05:30PM (#38183935)
OK, in some niche scenarios I can see the cost being larger, but I think this is totally overstated.
Re:A four year plan for async Rust by dymk on Tuesday November 07, 2023 @12:38PM (#38180006)
Then use the code I posted if you don't want a helper library. Or just wrap it in your own function if it's too complex for your tastes.
Re:A four year plan for async Rust by bryanlarsen on Tuesday November 07, 2023 @01:09PM (#38180501)
Usually you're reaching for block_on because a library you want to use is async. Almost certainly the library you're using will have already be depending on an async library, so by pulling it in yourself you're not adding additional dependencies.
Re:A four year plan for async Rust by kingofthehill98 on Tuesday November 07, 2023 @12:27PM (#38179831)
Every day we stray further from god.
Re:A four year plan for async Rust by gnulinux on Tuesday November 07, 2023 @05:04PM (#38183597)
This is the kind of thing you write once to abstract out async things in a function and call it a day. It really isn't that bad. Besides you can just use:

    smol::block_on(async {
        println!("I'm async!");
    });
if smol is an option.
Re:A four year plan for async Rust by wavemode on Tuesday November 07, 2023 @12:48PM (#38180177)
The complexity of this code snippet almost seems satirical (though I do get the point you're making, and agree with you).
Re:A four year plan for async Rust by dymk on Tuesday November 07, 2023 @12:53PM (#38180257)
On one hand, I agree that on the surface, this looks complex, if you don't read it.

But on the other hand, just read the code. It's not complex.

You drill down into a tokio namespace. You make a builder object. You unwrap it. This is idiomatic Rust. It's verbose, but explicit is better than vague. There's no conditional logic. There's no weird type-fu. No macros. There's not even any parameters to supply, other than the Future to block on.

It's trivial to write a wrapper to go from chained methods a helper call.

Re:A four year plan for async Rust by lenkite on Thursday November 09, 2023 @02:53AM (#38202251)
The next time a Rust fan pokes fun about Java's verbosity, I am copy-pasting that.
Re:A four year plan for async Rust by mplanchard on Tuesday November 07, 2023 @12:58PM (#38180362)
Just noting for other readers that, while killercup posted another option using `smol`, this seems to me to be in line with Rust's philosophy of explicitness, which is something I really appreciate about the language:

- create a builder

- run on the current thread only

- enable all drivers

- create the instance

- ignore errors

- then call some blocking async code

Would look nicer if split out onto multiple lines I imagine:

    use tokio::runtime::Builder;

    let runtime = Builder::new_current_thread()
        .enable_all()
        .build()?;

    runtime.block_on(async { println!("I'm async!"); });
Re:A four year plan for async Rust by lucasyvas on Tuesday November 07, 2023 @11:59AM (#38179338)
This is consistent with the author's assessment - the incomplete implementation of async makes it very challenging to advocate for, despite the fact that it was the only logical choice given Rust's design goals.

I will say that the notion that you must make your whole project async is largely true (except that you can block on futures with all runtimes), but this is more symptomatic of the fact that Rust has hitched its horse to two wagons that don't have clean overlap. It is effectively two languages trying to converge in the middle.

It's equally desired at "web server and above" and "operating system and below", which probably makes it one of the hardest languages on the planet to design (lets not forget it deliberately has no runtime, which makes things even more difficult). Whether or not this is a good idea remains to be seen over time, but they are in largely uncharted territory so I'm prepared to give them some slack on it while they figure it out.

That said, holy has it taken such a long time to round out the async story to make it feel better. I don't blame users not wanting to wait it out because it has felt like an eternity.

Re:A four year plan for async Rust by Verdex on Tuesday November 07, 2023 @12:10PM (#38179544)
> It's equally desired at "web server and above" and "operating system and below", which probably makes it one of the hardest languages on the planet to design.

My theory as to why C++ has become as a problematic language as it has is because it is able to do it all. And "all" doesn't fit nicely into a single package or paradigm.

I don't like async (in any language), so your post immediately piqued my interest. I'm not that interested in 'webserver and above' so of course that would be where people find async useful.

It is possible that there is no way to unify these two domains into a single language (at least without becoming c++). Although, then again, it might be that if you think about it long enough then the unification mechanism becomes apparent.

Re:A four year plan for async Rust by samus on Tuesday November 07, 2023 @12:22PM (#38179749)
The problem with C++ is that every feature

- attempts to solve too many problems,

- has significant papercuts that have to be considered,

- has significant runtime cost,

- interacts poorly with other features, or at least leaves significant edge cases open,

- has non-uniform compiler support (although in OSS land only GCC and LLVM matter), and

- creates arcane error messages that are anything but fun to analyze. Especially when templates are involved.

Above everything the fundamental problem that the unsafe parts of C are everywhere, and to master C++ you have to become really proficient at diagnosing problems with them because you will run into them. Only then can you start thinking about fun things like software architecture. Always use a linter/static analyzer.

Re:A four year plan for async Rust by kroltan on Tuesday November 07, 2023 @12:40PM (#38180037)
That list of bullet points (except the compiler one) is also applicable to the whole async ecosystem in Rust :)
Re:A four year plan for async Rust by samus on Tuesday November 07, 2023 @12:52PM (#38180249)
I for sure hope that Rust gets at least the safety aspect right :) I could endure a lot of suffering if I knew that concern to be taken care of.
Re:A four year plan for async Rust by mplanchard on Tuesday November 07, 2023 @01:17PM (#38180623)
Agree on papercuts and interaction with other features to some degree. Absolutely disagree on runtime cost. The design of async has as minimal a runtime cost as seems theoretically possible, and avoids a lot of the runtime cost of async in other languages. It's really an impressive engineering feat given the constraints and I think there's a real case for it being a "zero-cost" abstraction (i.e. you couldn't implement a faster version by hand).

IME the bad compiler messages tend to come more often from the `async-trait` macro than from anything fundamental to asyc itself. Hoping the stabilization of async-trait helps with that. Backtraces with async are definitely a bit nasty though.

Re:A four year plan for async Rust by Kranar on Tuesday November 07, 2023 @01:10PM (#38180520)
Don't forget that C++ features are also often rolled out before anyone even really understands them, and then after they are rolled out people find all kinds of footguns and issues with them.

The C++ committee basically evaluates features almost entirely in the abstract, writing papers and discussing privately among a small group of people about things instead of working on proof of concept implementations, getting actual real world feedback on it, or having something along the lines of Rust's nightly where experimental features can be tried out.

Re:A four year plan for async Rust by jcranmer on Tuesday November 07, 2023 @02:07PM (#38181299)
> The C++ committee basically evaluates features almost entirely in the abstract, writing papers and discussing privately among a small group of people about things instead of working on proof of concept implementations, getting actual real world feedback on it, or having something along the lines of Rust's nightly where experimental features can be tried out.

Sitting on the C++ committee, we actually demand a lot of proof-of-concept implementation of proposals before they'll be accepted.

Re:A four year plan for async Rust by munificent on Tuesday November 07, 2023 @12:36PM (#38179975)
Agreed. The classic claim about C++ is that everyone wants to remove half of its features, but no one can agree on which half.
Re:A four year plan for async Rust by zozbot234 on Tuesday November 07, 2023 @12:16PM (#38179652)
C++ is problematic in that it's a memory-unsafe language with a lot of cruft dating back to the 1980s. Its generality has made it more not less successful, since that makes it a lot easier to reuse library and support code across domains.
Re:A four year plan for async Rust by kllrnohj on Tuesday November 07, 2023 @01:16PM (#38180602)
I think async is still in the more just trendy camp than being a proven asset. After all, thread per connection is perfectly viable for the vast majority of servers. Most people aren't re-writing NGINX, after all (hopefully...).

It's a shame Rust let itself be distracted by it instead of focusing on refining its strengths and developer experience

Re:A four year plan for async Rust by riku_iki on Tuesday November 07, 2023 @07:19PM (#38185080)
> Most people aren't re-writing NGINX, after all (hopefully...).

those people probably may use another language (java, go, c#) if absolute performance is not critical for them.

Re:A four year plan for async Rust by kllrnohj on Thursday November 09, 2023 @08:46PM (#38214059)
That's a false equivalence. I can have a performance limited server that is not limited on concurrent connection count in which case thread-per-connect is both simpler and scales great compared to async. async doesn't optimize performance in general rather it optimizes for number of open concurrent connections specifically. Which primarily only helps if you aren't doing much of anything in terms of compute per connection.
Re:A four year plan for async Rust by CyberDildonics on Tuesday November 07, 2023 @12:00PM (#38179346)
You are absolutely right.

Integrating 'async' into a language is not a good approach to concurrency. If you want to run a single function on a different thread it can work. If you want something to run after that, that can work out.

Once you go beyond that, you are building a graph with very crude tools. Then you have lots of problems, including how you handle packaging dependencies when something you want to run depends on data coming from multiple other async sources.

Treating this as a language issue and not a library and tools issue is a huge mistake. Another reason is exactly what you outlined - libraries getting infected with a languages half baked concurrency solution instead of doing what they are supposed to while the user can fit them in where they want.

What actually works is graphs that handle dependencies and data structures for synchronization, but ultimately those need to be done well too.

Re:A four year plan for async Rust by orcy on Tuesday November 07, 2023 @12:06PM (#38179474)
I am in doubts about async too. For better understanding I have implemented my own executor and io library (even with some tricky async destruction) and I am not quite happy with it. The problem is that in rust there are no other good methods to write safe async code, are there? My impression that borrow checker forbids lots of patterns I know from other language.
Re:A four year plan for async Rust by no_wizard on Tuesday November 07, 2023 @12:15PM (#38179625)
I will forever argue that things like goroutines and the Java Loom Project are proving that it is long term more successful than making an explicit async keyword / operation that has its own semantics when invoked, because it won't dictate your code and cause the color function problem to exist.

I'd love to see this in Rust, and I know that it initially had something like this, perhaps its not a bad idea for someone to take a second look at this now that more time has passed.

EDIT: to be clear, that is not me saying we need goroutines or we need a Java Loom equivalent in Rust, simply, the DX of these two examples are far superior to the DX of async Rust today, in my opinion

Re:A four year plan for async Rust by withoutboats3 on Tuesday November 07, 2023 @12:16PM (#38179640)
This was the subject of my previous post: https://without.boats/blog/why-async-rust/
Re:A four year plan for async Rust by insanitybit on Tuesday November 07, 2023 @12:17PM (#38179659)
How can you argue that? Loom is extremely early, it's not proving anything.

And Java/Goroutines don't have a keyword because they do things implicitly, they have heavy preemptive runtimes.

Re:A four year plan for async Rust by no_wizard on Tuesday November 07, 2023 @12:24PM (#38179784)
Thats red herring IMO. Sure, they're GC'd languages, but that does not preclude the fact that both of these approaches from a DX perspective are easier to work with, and that matters in language design.

I didn't say we need goroutines or we need Loom style asynchronous primitives I am however pointing out, that they did a really good job of making async approachable and feel like you're writing the same code as you would in a traditional synchronous model. Thats the real win.

Its not an easy problem to solve, to be absolutely clear, but its a worthy goal, and if that means it adds marginal overhead initially I think its worth the tradeoff (esp. if you can do something similar to how you can use Rust in a `no-std` build, you could do one without a `async runtime` build, spitballing off the top of my head)

Another problem is that generally speaking, async is de facto used a 3rd party lib, and it really should be a first party primitive that everyone feels comfortable using.

To me, this is what matters

Re:A four year plan for async Rust by insanitybit on Tuesday November 07, 2023 @12:30PM (#38179871)
> I didn't say we need goroutines or we need Loom style asynchronous primitives I am however pointing out, that they did a really good job of making async approachable and feel like you're writing the same code as you would in a traditional synchronous model.

You created a dichotomy - languages with a native construct for async versus languages that provide this as libraries. But that dichotomy does not exist - both language have native concurrency support through their runtime. That was what I was pushing back against.

> async is de facto used a 3rd party lib, and it really should be a first party primitive that everyone feels comfortable using.

I think this really remains to be seen. Rust has always had a "just pull in a crate" mentality and a "be very conservative about what's in std" approach, and I think the community is overwhelmingly in favor of that. Any major stdlib changes should be taken pretty seriously.

Re:A four year plan for async Rust by no_wizard on Tuesday November 07, 2023 @12:44PM (#38180090)
I agree, it should be taken really seriously.

I think 4 years worth of a feature being out in the wild and in use is enough time to start having conversations about what went well and what didn't and how to address that. Its very clear to me, at least, that async in Rust is becoming more and more dependent on tokio. Most of the major async supporting crates support tokio and/or only leverage tokio. Just a cursory glance at the crates registry supports this much.

I'm not against a "pull in a crate" mentality mind you (though, careful what you wish for here, see: NPM / Node ecosystem) however, it is worth identifying when something is becoming / has become / is considered to be such a core feature of the ecosystem that it would benefit greatly from stdlib support, and I think this fits that definition based on the evidence I've seen, at least. Though I realize others may not share this sentiment, I think its a viewpoint that has evidentiary backing (see all the talk about async Rust in the communicate, issues etc surrounding it. Its already a pretty big buzz topic relative to other things surrounding the language)

All this is to say, maybe its time to seriously start thinking about what first party support will look if we bring in a first party async / non-blocking I/O platform into the stdlib

Re:A four year plan for async Rust by insanitybit on Tuesday November 07, 2023 @12:57PM (#38180338)
> careful what you wish for here, see: NPM / Node ecosystem)

Just to be clear, I think the NPM ecosystem is generally great and a massive success. People totally overblow the issues, and none of them are actually because of a small std library or due to the ease of install/publish.

> however, it is worth identifying when something is becoming / has become / is considered to be such a core feature of the ecosystem that it would benefit greatly from stdlib support,

I agree, and I think that there are a few places with regards to async that could work well here. Maybe some kind of Executor trait (hard, but maybe possible?), probably `std::block_on`.

> see all the talk about async Rust in the communicate,

FWIW I think the majority of people are just happily doing async work in Rust and don't get too involved in the discussions. I'm one of those people, except I'm also an internet addict on extended PTO so here I am.

> All this is to say, maybe its time to seriously start thinking about what first party support will look if we bring in a first party async / non-blocking I/O platform into the stdlib

I agree, I think some of this is best done in the language but some should be in std. No question.

Re:A four year plan for async Rust by steveklabnik on Tuesday November 07, 2023 @12:29PM (#38179869)
> both of these approaches from a DX perspective are easier to work with, and that matters in language design.

While you are right that DX matters, DX is not the only thing that exists. Design is about balancing constraints and tradeoffs. Rust has other design commitments that preclude using this design, before you even get to DX questions.

(Furthermore not everyone agrees that these things are clearly better from a DX perspective, as DX is a subjective topic.)

Re:A four year plan for async Rust by no_wizard on Tuesday November 07, 2023 @12:54PM (#38180277)
I agree, there's questions that need to be answered, and I don't know that I even have answers to give to them.

I will say, that its clear, to me and a good portion of Rust users, that async in Rust needs DX improvements. Its one of the top features of the language that is used alot and people struggle with often[0]

[0]: To be fair, async in any language trips up developers pretty often, though I think Rust can give someone a particularly bad time. Granted, I have not compared it to C / C++ as I don't do any development in either language currently

Re:A four year plan for async Rust by steveklabnik on Tuesday November 07, 2023 @01:08PM (#38180496)
> I don't know that I even have answers to give to them.

To be honest, this is why this discussion always gets frustrating: people demand change that is impossible, and then when pushed for how to accomplish the impossible, they throw up their hands. I do not think you or anyone else is doing it maliciously, but for some reason, on this specific topic, it happens endlessly.

Re:A four year plan for async Rust by no_wizard on Tuesday November 07, 2023 @01:23PM (#38180718)
My best shot at this is something akin to a runtime built-in to the stdlib that can be opted out, similar to how you can build something with `no-std` so there is no reliance on `libstd`. Perhaps this is a great place where you drop into more "raw" async programming using the async / await primitives. You lose DX sugar but slim out the runtime for embedded work.

Ideally, the runtime could handle anything written using lower level primitives as to not completely kneecap libraries that need to work with `no-async-runtime` (or whatever you want to call it).

This would at least alleviate a common concern I hear around this, which is runtime bloat.

That seems like a step in the right direction to integrate a unified async runtime with an alternative / better syntax[0]

[0]: I want to note, that C# is the only language I ever worked in that supported async in two constructs. There is the traditional async / await, which is by far the most common. Before that though, there was event driven async programming (with support for background workers and other async features) and that is also still supported, and they can interop with each other (with some caveats)

Re:A four year plan for async Rust by steveklabnik on Tuesday November 07, 2023 @01:29PM (#38180807)
The only thing this would change is not needing to "cargo add smol" which already exists as a smaller runtime if you need it. That wouldn't solve the fact that a large part of the ecosystem would still need the features of Tokio, and would still use them. So you still have interoperability problems, until figuring out how to make runtimes swappable, and that is open-ended work. (and also assumes that smol's particular choices are correct for this, and that everyone maintaining the stdlib agrees that they are, and that the folks on the libs team are willing to step up and start maintaining an entire async runtime, etc etc etc)
Re:A four year plan for async Rust by zozbot234 on Tuesday November 07, 2023 @12:20PM (#38179715)
Goroutines and the Java Loom are just fibers. They're like a super clunky mix of async-like and thread-like features, though sometimes there are reasons to use them. (For example, stackful fibers might enable cleaner interactions with OS facilities or outside library code.) Rust makes it real easy to just use threads if that's what you prefer.
Re:A four year plan for async Rust by jayd16 on Tuesday November 07, 2023 @12:23PM (#38179758)
Async handles thread contexts better. Maybe I'm out of the loop but implicit blocking patterns haven't taken over gui programming just yet.
Re:A four year plan for async Rust by samus on Tuesday November 07, 2023 @12:49PM (#38180198)
Loom is very new, and Java on the desktop is almost dead. Even though virtual threads could be useful for GUI programming, I don't expect significant innovation in that area. But the upcoming Structured Concurrency[0] and Scoped Values[1] JEPs make things hopefully easier.

[0]: https://openjdk.org/jeps/462

[1]: https://openjdk.org/jeps/446

Re:A four year plan for async Rust by jayd16 on Tuesday November 07, 2023 @12:55PM (#38180291)
Structured concurrency looks good but is it really better than async syntax?
Re:A four year plan for async Rust by samus on Tuesday November 07, 2023 @01:05PM (#38180453)
I have to admit that async syntax has a certain charm, as it has deep connections to iterators. (I have to program with Unity for my master thesis). But Structured Concurrency leverages well-known blocking syntax that doesn't require further explanation. It's not even specific to virtual threads.
Re:A four year plan for async Rust by jokethrowaway on Tuesday November 07, 2023 @12:24PM (#38179775)
Well, you can block on it if you want

That said, I disagree on the usefulness of async: in my experience it does the job and it's my default setup.

There's a complex project where I ended up just using threads because I needed to squeeze performance out but overall async is great for tasks, sequence of async operations.

Still, it had some rough edges: (it's been a while but) using Async Closures wasn't pleasant and I re architected my app to not use them as a result. There's an argument to be made for this change making my application easier to reason about - but overall it's poor language flexibility.

Re:A four year plan for async Rust by untitaker_ on Tuesday November 07, 2023 @12:24PM (#38179782)
This is a popular sentiment that I share to some degree, but I really wish we could just move on from this discussion. It happens in every post that is even just vaguely about Rust or async. It's like reading complaints about the GIL on a post that is loosely connected to Python! At some point it just gets boring.

"I will forever argue that [...]" -- Why are you forever arguing?

"I feel like I am alone with [...]" -- No, I read it every day on here.

Re:A four year plan for async Rust by no_wizard on Tuesday November 07, 2023 @12:45PM (#38180128)
to be honest, HN is one of the few venues where I think someone who is core to a project might actually see what is said about a language. I've tried getting involved in mailing lists and stuff, but they aren't often as welcoming to this discussion as one might assume.

My hope is that by raising these things on HN, someone will take notice in a different way and at least start considering / revisiting alternatives

Re:A four year plan for async Rust by untitaker_ on Tuesday November 07, 2023 @12:59PM (#38180372)
All of this would be correct in an alternative reality where everybody in the Rust community, including every person ever involved in the language's evolvement isn't aware of these complaints.
Re:A four year plan for async Rust by Kranar on Tuesday November 07, 2023 @01:19PM (#38180655)
Your comment is self defeating. The reason people are aware of these complaints is because they keep being brought up, over and over.

This is a serious wart on language design and while I can agree that it's likely too late to fix it for Rust, there is a kind of race among new languages to be a successor to C++ in many of the domains C++ is used in, and while I think Rust does hold a lead in that race, the race is not over.

A language that can provide an ergonomic solution to concurrency would absolutely provide a huge boost to any such language, and so to people in that space, listen to these complaints. Async/await is not a good solution to this problem.

You almost always hear people complaining about async/await in every language it's a part of but you rarely hear people complain about how Go manages concurrency.

Re:A four year plan for async Rust by nextaccountic on Tuesday November 07, 2023 @12:30PM (#38179872)
doesn't block_on work for you?
Re:A four year plan for async Rust by empath-nirvana on Tuesday November 07, 2023 @12:51PM (#38180220)
I genuinely don't understand the problems people have with async code... at least for anything involving http/api requests it's largely just a matter of decorating stuff with 'async/await'. It makes a few things difficult (iterators with futures, ugh), but mostly it's easy.
Re:A four year plan for async Rust by galangalalgol on Tuesday November 07, 2023 @02:07PM (#38181310)
Because rust is a systems language, it is common for people to use it for things that don't involve http or even networking in general. Alternatively, people often use it for wasm. Before async and specifically tokio, a much larger percentage of crates were usable by those people. This feels like something nice has been taken away or that our use case has been marginalized. The answer is to spend the time to create tokio and/or async free alternatives to these crates, but that was not expected to be necessary, so it also is added work. All of that is irritating, and the constant stream of "just accept it and get with the program. Stop complaining!" Is really quite infuriating. The fair answer is that rust should be what the majority of its users want/need it to be. But people who just need a back end language have a dozen or more good ones to choose from. People who need a systems language have far fewer choices, especially if you want memory safety, so having the aims of the language diverted from that end is irritating to say the least. I do suspect a fork to occur someday for those reasons, probably centered around the use in linux android or windows.