It's not asserting corruption. they were the voluntary caretakers of a system designed to ensure their prosperity and they provided their time and energy so that the system would continue to do so.
Hopefully not much. I am just lamenting it is an extra dependency and chore we must carry and think about forever, and will have no official upstream support.
It's long been clear that there were fundamental implementation choices that mattered between async runtimes, but _nine_ design dimensions? Damn.
I think async is deceptive in that it seems like a self-contained and relatively straightforward aspect of a language. But there are many design choices to be made and they all have wide implications.
Plus I think the implications of many of these dimensions are not fully understood and that collectively we are still trying to understand how they are playing out in implementations. Add to this the subtle nature of some of the implications plus the combinations...
I think a good comparison is lexical vs dynamic scope in programming languages. This is a design dimension that was argued over for a decade or two in the early years of programming language design. It was only as time went by, and experience gained by working with concrete implementations that it became clear that lexical scoping should be the default choice and dynamic scoping should be restricted to various niches.
I felt like they were reaching deep to find dimensions. Whether a task runs autonomously or needs its parent to poll it (Rust) is a dimension but whether an autonomous running task can continue after being cancelled shouldn't be - if you go into that much detail you could probably find thousands of dimensions. If it's autonomous it can do whatever it wants to.
> whether an autonomous running task can continue after being cancelled shouldn't be
Idk, I think this might be quite important in servers, or any application where the running task might spawn subprocesses (can those continue autonomously?) or block on/use os resources
And either the runtime enforces it or it doesn't and just notifies you, but I think whether it notifies you once or continually is not a relevant dimension.
How does parallelism come into play for this conversation? Async/await is a concurrency construct. And Java’s virtual threads are also a concurrency construct. Neither of them have anything to do with parallelism. Or am I misunderstanding something?
I'd say Java's virtual threads are also a parallelism construct (at least in the performance sense, not logical guarantees), since they're scheduled on a pool.
reply