Asynchrony is not concurrency

https://kristoff.it/blog/asynchrony-is-not-concurrency/

by kristoff_it • 1 year ago

311 216 1 year ago

kristoff.it

threatofrain3• 1 year ago

IMO the author is mixed up on his definitions for concurrency.

https://lamport.azurewebsites.net/pubs/time-clocks.pdf

tines3• 1 year ago

Can you explain more instead of linking a paper? I felt like the definitions were alright.

Asynchrony: the possibility for tasks to run out of order and still be correct.
Concurrency: the ability of a system to progress multiple tasks at a time, be it via parallelism or task switching.
Parallelism: the ability of a system to execute more than one task simultaneously at the physical level.

threatofrain3• 1 year ago

Concurrency is the property of a program to be divided into partially ordered or completely unordered units of execution. It does not describe how you actually end up executing the program in the end, such as if you wish to exploit these properties for parallel execution or task switching. Or maybe you're running on a single thread and not doing any task switching or parallelism.

For more I'd look up Rob Pike's discussions for Go concurrency.

andsoitis• 1 year ago

Asynchrony: the possibility for tasks to run out of order and still be correct.

Asynchrony is when things don't happen at the same time or in the same phase, i.e. is the opposite of Synchronous. It can describe a lack of coordination or concurrence in time, often with one event or process occurring independently of another.

The correctness statement is not helpful. When things happy asynchronously, you do not have guarantees about order, which may be relevant to "correctness of your program".

Lichtso3• 1 year ago

Concurrency is parallelism and/or asynchrony, simply the superset of the other two.

Asynchrony means things happen out of order, interleaved, interrupted, preempted, etc. but could still be just one thing at a time sequentially.

Parallelism means the physical time spent is less that the sum of the total time spent because things happen simultaneously.

jkcxn• 1 year ago

Not the OP, but in formal definitions like Communicating Sequential Processes, concurrency means the possibility for tasks to run out of order and still be correct, as long as other synchronisation events happen

ryandv5• 1 year ago

They're just different from what Lamport originally proposed. Asynchrony as given is roughly equivalent to Lamport's characterization of distributed systems as partially ordered, where some pairs of events can't be said to have occurred before or after one another.

One issue with the definition for concurrency given in the article would seem to be that no concurrent systems can deadlock, since as defined all concurrent systems can progress tasks. Lamport uses the word concurrency for something else: "Two events are concurrent if neither can causally affect the other."

Probably the notion of (a)causality is what the author was alluding to in the "Two files" example: saving two files where order does not matter. If the code had instead been "save file A; read contents of file A;" then, similarly to the client connect/server accept example, the "save" statement and the "read" statement would not be concurrent under Lamport's terminology, as the "save" causally affects the "read."

It's just that the causal relationship between two tasks is a different concept than how those tasks are composed together in a software model, which is a different concept from how those tasks are physically orchestrated on bare metal, and also different from the ordering of events..

amelius3• 1 year ago

Asynchrony: the possibility for tasks to run out of order and still be correct.

Can't we just call that "independent"?

ninetyninenine• 1 year ago

Doesn't multiple tasks at the same time make it simultaneous?

I think there needs to be a stricter definition here.

Concurrency is the ability of a system to chop a task into many tiny tasks. A side effect of this is that if the system chops all tasks into tiny tasks and runs them all in a sort of shuffled way it looks like parallelism.

sriram_malhar• 1 year ago

The phrase "multiple tasks at a time" is ill-defined, according to Lamport, because whose clock are you trusting.

For lamport concurrent does not mean what it means to us colloquially or informally (like, "meanwhile"). Concurrency in Lamport's formal definition is only about order. If one task is dependent or is affected by another, then the first is ordered after the second one. Otherwise, they are deemed to be "concurrent", even if one happens years later or before.

sapiogram• 1 year ago

This is why I've completely stopped using the term, literally everyone I talk to seems to have a different understanding. It no longer serves any purpose for communication.

carodgers• 1 year ago

The author is aware that definitions exist for the terms he uses in his blog post. He is proposing revised definitions. As long as he is precise with his new definitions, this is fine. It is left to the reader to decide whether to adopt them.

WhitneyLand• 1 year ago

He’s repurposing asynchrony that’s different from the way most literature and many developers use it, and that shift is doing rhetorical work to justify a particular Zig API split.

No thanks.

laserbeam4• 1 year ago

Keep in mind that you can’t really express half the concepts in lamport’s papers in most languages. You don’t really talk about total and partial clock ordering when starting a thread. You only really do it in TLA+ when designing a protocol.

That being said, I agree we don’t need a new term to express “Zig has a function in the async API that throws a compilation error when you run in a non-concurrent execution. Zig let’s you say that.” It’s fine to so that without proposing new theory.

ioasuncvinvaer• 1 year ago

Is there anything new in this article?

butterisgood4• 1 year ago

Perhaps not, but sometimes the description from a different angle helps somebody understand the concepts better.

I don't know how many "monad tutorials" I had to read before it all clicked, and whether it ever fully clicked!

gowld2• 1 year ago

Most gen ed articles on HN are not new ideas, just articles that could be pages from a textbook.

ltbarcly34• 1 year ago

The argument about concurrency != parallelism mentioned in this article as being "not useful" is often quoted and rarely a useful or informative, and it also fails to model actual systems with enough fidelity to even be true in practice.

Example: python allows concurrency but not parallelism. Well not really though, because there are lots of examples of parallelism in python. Numpy both releases the GIL and internally uses open-mp and other strategies to parallelize work. There are a thousand other examples, far too many nuances and examples to cover here, which is my point.

Example: gambit/mit-scheme allows parallelism via parallel execution. Well, kindof, but really it's more like python's multiprocess library pooling where it forks and then marshals the results back.

Besides this, often parallel execution is just a way to manage concurrent calls. Using threads to do http requests is a simple example, while the threads are able to execute in parallel (depending on a lot of details) they don't, they spend almost 100% of their time blocking on some socket.read() call. So is this parallelism or concurrency? It's what it is, it's threads mostly blocking on system calls, parallelism vs concurrency gives literally no insights or information here because it's a pointless distinction in practice.

What about using async calls to execute processes? Is that concurrency or parallelism? It's using concurrency to allow parallel work to be done. Again, it's both but not really and you just need to talk about it directly and not try to simplify it via some broken dichotomy that isn't even a dichotomy.

You really have to get into more details here, concurrency vs parallelism is the wrong way to think about it, doesn't cover the things that are actually important in an implementation, and is generally quoted by people who are trying to avoid details or seem smart in some online debate rather than genuinely problem solving.

throwawaymaths5• 1 year ago

edit: fixed by the author.

ltbarcly34• 1 year ago

yes I'm agreeing with the article completely

chowells2• 1 year ago

The difference is quite useful and informative. In fact, most places don't seem to state it strongly enough: Concurrency is a programming model. Parallelism is an execution model.

Concurrency is writing code with the appearance of multiple linear threads that can be interleaved. Notably, it's about writing code. Any concurrent system could be written as a state machine tracking everything at once. But that's really hard, so we define models that allow single-purpose chunks of linear code to interleave and then allow the language, libraries, and operating system to handle the details. Yes, even the operating system. How do you think multitasking worked before multi-core CPUs? The kernel had a fancy state machine tracking execution of multiple threads that were allowed to interleave. (It still does, really. Adding multiple cores only made it more complicated.)

Parallelism is running code on multiple execution units. That is execution. It doesn't matter how it was written; it matters how it executes. If what you're doing can make use of multiple execution units, it can be parallel.

Code can be concurrent without being parallel (see async/await in javascript). Code can be parallel without being concurrent (see data-parallel array programming). Code can be both, and often is intended to be. That's because they're describing entirely different things. There's no rule stating code must be one or the other.

ltbarcly34• 1 year ago

When you define some concepts, those definitions and concepts should help you better understand and simplify the descriptions of things. That's the point of definitions and terminology. You are not achieving this goal, quite the opposite in fact, your description is confusing and would never actually be useful in understanding, debugging, or writing software.

Stated another way: if we just didn't talk about concurrent vs parallel we would have exactly the same level of understanding of the actual details of what code is doing, and we would have exactly the same level of understanding about the theory of what is going on. It's trying to impose two categories that just don't cleanly line up with any real system, and it's trying to create definitions that just aren't natural in any real system.

Parallel vs concurrent is a bad and useless thing to talk about. It's a waste of time. It's much more useful to talk about what operations in a system can overlap each other in time and which operations cannot overlap each other in time. The ability to overlap in time might be due to technical limitations (python GIL), system limitations (single core processor) or it might be intentional (explicit locking), but that is the actual thing you need to understand, and parallel vs concurrent just gives absolutely no information or insights whatsoever.

Here's how I know I'm right about this: Take any actual existing software or programming language or library or whatever, and describe it as parallel or concurrent, and then give the extra details about it that isn't captured in "parallel" and "concurrent". Then go back and remove any mention of "parallel" and "concurrent" and you will see that everything you need to know is still there, removing those terms didn't actually remove any information content.

frollogaston2• 1 year ago

Async JS code is parallel too. For example, await Promise.all(...) will wait on multiple functions at once. The JS event loop is only going to interpret one statement at a time, but in the meantime, other parts of the computer (file handles, TCP/IP stack, maybe even GPU/CPU depending on the JS lib) are actually doing things fully in parallel. A more useful distinction would be, the JS interpreter is single-threaded while C code can be multithreaded.

I can't think of anything in practice that's concurrent but not parallel. Not even single-core CPU running 2 threads, since again they can be using other resources like disk in parallel, or even separate parts of the CPU itself via pipelining.

Retr0id3• 1 year ago

I don't get it - the "problem" with the client/server example in particular (which seems pivotal in the explanation). But I am also unfamiliar with zig, maybe that's a prerequisite. (I am however familiar with async, concurrency, and parallelism)

koakuma-chan• 1 year ago

Example 1

You can write to one file, wait, and then write to the second file.

Concurrency not required.

Example 2

You can NOT do Server.accept, wait, and then do Client.connect, because Server.accept would block forever.

Concurrency required.

tines3• 1 year ago

Oh, I see. The article is saying that async is required. I thought it was saying that parallelism is required. The way it's written makes it seem like there's a problem with the code sample, not that the code sample is correct.

jayd168• 1 year ago

But why is this a novel concept? The idea of starvation is well known and you don't need parallelism for it to effect you already. What does zig actually do to solve this?

Many other languages could already use async/await in a single threaded context with an extremely dumb scheduler that never switches but no one wants that.

I'm trying to understand but I need it spelled out why this is interesting.

danaugrs• 1 year ago

Excellent article. I'm looking forward to Zig's upcoming async I/O.

butterisgood4• 1 year ago

It's kind of true...

I can do a lot of things asynchronously. Like, I'm running the dishwasher AND the washing machine for laundry at the same time. I consider those things not occurring at "the same time" as they're independent of one another. If I stood and watched one finish before starting the other, they'd be a kind of synchronous situation.

But, I also "don't care". I think of things being organized concurrently by the fact that I've got an outermost orchestration of asynchronous tasks. There's a kind of governance of independent processes, and my outermost thread is what turns the asynchronous into the concurrent.

Put another way. I don't give a hoot what's going on with your appliances in your house. In a sense they're not synchronized with my schedule, so they're asynchronous, but not so much "concurrent".

So I think of "concurrency" as "organized asynchronous processes".

Does that make sense?

Ah, also neither asynchronous nor concurrent mean they're happening at the same time... That's parallelism, and not the same thing as either one.

Ok, now I'll read the article lol

didibus3• 1 year ago

I think asynchronous as meaning out-of-sync, implies that there needs to be synchronicity between the two tasks.

In that case, asynchronous just means the state that two or more tasks that should be synchronized in some capacity for the whole behavior to be as desired, is not properly in-sync, it's out-of-sync.

Then I feel there can be many cause of asynchronous behavior, you can be out-of-sync due to concurent execution or due to parallel execution, or due to buggy synchronization, etc.

And because of that, I consider asynchronous programming as the mechanisms that one can leverage to synchronize asynchronous behavior.

But I guess you could also think of asynchronous as doesn't need to be synchronized.

Also haven't read the article yet lol

criddell2• 1 year ago

I consider those things not occurring at "the same time" as they're independent of one another.

What would it take for you to consider them as running at the same time then?

kristoff_it5• 1 year ago

That eventually the server and the client are able to connect.

butterisgood4• 1 year ago

Actually running at the same time is parallelism. "Logically" running at the same time would be "asynchronous". It has to do with the independence of the "processes" themselves.

Could they run in parallel? Or even partially? If it's a yes - then it's already concurrent if it's organized as such. Or it could still just be sequential if that organization hasn't occurred.

So I think of the terminology as a way to frame the independence of parts of a larger process.

throwawaymaths5• 1 year ago

a core problem is that the term async itself is all sorts of terrible, synchronous usually means "happening at the same time", is not what is happening when you don't use `async`

its like the whole flammable/inflammable thing

butterisgood4• 1 year ago

Concurrency refers to the ability of a system to execute multiple tasks through simultaneous execution or time-sharing (context switching)

Wikipedia had the wrong idea about microkernels for about a decade too, so ... here we are I guess.

It's not a _wrong_ description but it's incomplete...

Consider something like non-strict evaluation, in a language like Haskell. One can be evaluating thunks from an _infinite_ computation, terminate early, and resume something else just due to the evaluation patterns.

That is something that could be simulated via generators with "yield" in other languages, and semantically would be pretty similar.

Also consider continuations in lisp-family languages... or exceptions for error handling.

You have to assume all things could occur simultaneously relative to each other in what "feels like" interrupted control flow to wrangle with it. Concurrency is no different from the outside looking in, and sequencing things.

Is it evaluated in parallel? Who knows... that's a strategy that can be applied to concurrent computation, but it's not required. Nor is "context switching" unless you mean switched control flow.

The article is very good, but if we're going by the "dictionary definition" (something programming environments tend to get only "partially correct" anyway), then I think we're kind of missing the point.

The stuff we call "asynchronous" is usually a subset of asynchronous things in the real world. The stuff we treat as task switching is a single form of concurrency. But we seem to all agree on parallelism!

raluk3• 1 year ago

One thing that most languages are lacking is expressing lazy return values. -> await f1() + await f2() and to express this concurently requres manually handing of futures.

sedatk6• 1 year ago

Which languages do have such a thing?

Twey• 1 year ago

I suppose Haskell does, as `(+) <$> f1 <*> f2`.

steveklabnik• 1 year ago

Rust does this, if you don’t call await on them. You can then await on the join of both.

zmj• 1 year ago

That's because f2's result could depend on whether f1 has executed.

jayd168• 1 year ago

you mean like?

   await Join(f1(), f2())

Although more realistically

   Promise1 = f1(); Promise2 = f2();
   await Join(Promise1, Promise2);

But also, futures are the expression of lazy values so I'm not sure what else you'd be asking for.

raluk3• 1 year ago

This is what i hand in mind whit "manually handing of futures". In this case you have to write

   Promise1 = f1(); Promise2 = f2();
   v1,v2 = await Join(Promise1, Promise2);
   return v1 + v2

I think this is just too much of synthactic noise.

On the other hand, it is necessary becase some of underlying async calls can be order dependend.

for example

    await sock.rec(1) == 'A' && await sock.rec(1) == 'B'

checks that first received socket byte is A and second is B. This is clearly order dependant that can't be executed concurrently out of order.

kobzol• 1 year ago

The new Zig I/O idea seems like a pretty ingenious idea, if you write mostly applications and don't need stackless coroutines. I suspect that writing libraries using this style will be quite error-prone, because library authors will not know whether the provided I/O is single or multi-threaded, whether it uses evented I/O or not... Writing concurrent/async/parallel/whatever code is difficult enough on its own even if you have perfect knowledge of the I/O stack that you're using. Here the library author will be at the mercy of the IO implementation provided from the outside. And since it looks like the IO interface will be a proper kitchen sink, essentially an implementation of a "small OS", it might be very hard to test all the potential interactions and combinations of behavior. I'm not sure if a few async primitives offered by the interface will be enough in practice to deal with all the funny edge cases that you can encounter in practice. To support a wide range of IO implementations, I think that the code would have to be quite defensive and essentially assume the most parallel/concurrent version of IO to be used.

It will IMO also be quite difficult to combine stackless coroutines with this approach, especially if you'd want to avoid needless spawning of the coroutines, because the offered primitives don't seem to allow expressing explicit polling of the coroutines (and even if they did, most people probably wouldn't bother to write code like that, as it would essentially boil down to the code looking like "normal" async/await code, not like Go with implicit yield points). Combined with the dynamic dispatch, it seems like Zig is going a bit higher-level with its language design. Might be a good fit in the end.

It's quite courageous calling this approach "without any compromise" when it has not been tried in the wild yet - you can claim this maybe after 1-2 years of usage in a wider ecosystem. Time will tell :)

ta8645• 1 year ago

It will IMO also be quite difficult to combine stackless coroutines with this approach

Maybe there will be unforeseen problems, but they have promised to provide stackless coroutines; since it's needed for the WASM target, which they're committed to supporting.

Combined with the dynamic dispatch

Dynamic dispatch will only be used if your program employs more than one IO implementation. For the common case where you're only using a single implementation for your IO, dynamic dispatch will be replaced with direct calls.

It's quite courageous calling this approach "without any compromise" when it has not been tried in the wild yet.

You're right. Although it seems quite close to what "Jai" is purportedly having success with (granted with an implicit IO context, rather than an explicitly passed one). But it's arguable if you can count that as being in the wild either...

necovek3• 1 year ago

I think that the code would have to be quite defensive and essentially assume the most parallel/concurrent version of IO to be used.

Exactly, but why would anyone think differently when the goal is to support both synchronous and async execution?

However, if asynchrony is done well at the lower levels of IO event handler, it should be simple to implemcent by following these principles everywhere — the "worst" that could happen is that your code runs sequentially (thus slower), but not run into races or deadlocks.

sedatk6• 1 year ago

Blocking async code is not async. In order for something to execute "out of order", you must have an escape mechanism from that task, and that mechanism essentially dictates a form of concurrency. Async must be concurrent, otherwise it stops being async. It becomes synchronous.

vitaminCPP• 1 year ago

This is exactly what the article is trying to debunk.

didibus3• 1 year ago

If you need to do A and then B in that order, but you're doing B and then A. It doesn't matter if you're doing B and then A in a single thread, the operations are out of sync.

So I guess you could define this scenario as asynchronous.

jayd168• 1 year ago

So wait, is the word they mean by asynchrony actually the word "dependency"?

nemothekid2• 1 year ago

Consider:

    readA.await
    readB.await

From the perspective of the application programmer, readA "block" readB. They aren't concurrent.

    join(readA, readB).await

In this example, the two operations are interleaved and the reads happen concurrently. The author makes this distinction and I think it's a useful one, that I imagine most people are familiar with even if there is no name for it.

sedatk6• 1 year ago

I think that confuses paradigm with configuration. Say, if one thread waits on another to finish, that doesn't mean the code suddenly becomes "single-threaded", it just means your two threads are in a serialized configuration in that instance. Similarly, when async code becomes serialized, it doesn't cease to be async: the scaffolding to make it concurrent is there, it's just unused in that specific configuration.

For example, C# uses this syntax:

   await readA();
   await readB();

when you have these two lines, the first I/O operation still yields control to a main executor during `await`, and other web requests can continue executing in the same thread while "readA()" is running. It's inherently concurrent, not in the scope of your two lines, but in the scope of your program.

Is Zig any different?

tossandthrow2• 1 year ago

The author does not seem to have made any non-trivial projects with asynchronicity.

All the pitfalls of concurrency are there - in particular when executing non-idempotent functions multiple times before previous executions finish, then you need mutexes!

ajross3• 1 year ago

All the pitfalls of concurrency are there [in async APIs]

This is one of those "in practice, theory and practice are different" situations.

There is nothing in the async world that looks like a parallel race condition. Code runs to completion until it deterministically yields, 100% of the time, even if the location of those yields may be difficult to puzzle out.

And so anyone who's ever had to debug and reason about a parallel race condition is basically laughing at that statement. It's just not the same.

kibwen2• 1 year ago

Code runs to completion until it deterministically yields

No, because async can be (quote often is) used to perform I/O, whose time to completion does not need to be deterministic or predictable. Selecting on multiple tasks and proceeding with the one that completes first is an entirely ordinary feature of async programming. And even if you don't need to suffer the additional nondeterminism of your OS's thread scheduler, there's nothing about async that says you can't use threads as part of its implementation.

tossandthrow2• 1 year ago

Idk, I work in typescript though but I do have race conditions that look exactly like those of concurrent software.

In particular promise.all([f,f,f]) where I want to ensure that I only Run the body of f a single time.

alerighi• 1 year ago

You don't need mutex in async code, since there is no parallel execution whatsoever. In fact languages that use async programming as a first class citizen (JavaScript) don't even have a construct to do them.

If you need to synchronize stuff in the program you can use normal plain variables, since it's guaranteed that your task will be never interrupted till you give control back to the scheduler by performing an await operation.

In a way, async code can be used to implement mutex (or something similar) themself: it's a technique that I use often in JavaScript, to implement stuff that works like a mutex or a semaphores with just promises to syncronize stuff (e.g. you want to be sure that a function that itself does async operations inside is not interrupted, it's possible to do so with promises and normal JS variables).

Spivak• 1 year ago

See this is what the OP is getting at, this is only true for async implementations that don't have any parallelism. That doesn't have to be the case, there's no reason that your javascript runtime couldn't take

    await foo()
    await bar()

and execute them in two threads transparently for you. It just happens, like the Python GIL, that it doesn't. Your JS implementation actually already has mutexes because web workers with shared memory bring true parallelization along with the challenges that come with.

mikojan• 1 year ago

https://developer.mozilla.org/en-US/docs/Web/API/LockManager...

Please don't implement this yourself

saghm3• 1 year ago

You don't need mutex in async code, since there is no parallel execution whatsoever. In fact languages that use async programming as a first class citizen (JavaScript) don't even have a construct to do them.

This isn't even remotely true; plenty of languages have both async and concurrency, probably more than ones that don't. C# was the language that originated async/await, not JavaScript, and it certainly has concurrency, as do Swift, Python. Rust, and many more. You're conflating two independent proprieties of JavaScript as language and incorrectly inferring a link between them that doesn't actually exist.

laserbeam4• 1 year ago

Mutexes are part of the Io interface in zig. So is sleep, select, network calls, file io, cancellation…

jayd168• 1 year ago

I kind of think the author simply pulled the concept of yielding execution out of the definition of concurrency and into this new "asynchrony" term. Then they argued that the term is needed because without it the entire concept of concurrency is broken.

Indeed so, but I would argue that concurrency makes little sense without the ability to yield and is therefore intrinsic to it. Its a very important concept but breaking it out into a new term adds confusion, instead of reducing it.

LegionMammal978• 1 year ago

I'd count pure one-to-one parallelism as a form of concurrency that doesn't involve any yielding. But otherwise, I agree that all forms of non-parallel concurrency have to be yielding execution at some cadence, even if it's at the instruction level. (E.g., in CUDA, diverging threads in a warp will interleave execution of their instructions, in case one branch tries blocking on the other.)

kristoff_it5• 1 year ago

I kind of think the author simply pulled the concept of yielding execution out of the definition of concurrency and into this new "asynchrony" term.

Quote from the article where the exact opposite is stated:

(and task switching is – by the definition I gave above – a concept specific to concurrency)

jayd168• 1 year ago

Well I'm having a hell of a time understanding what this article is trying to say. On a 3rd and 4th pass I think perhaps they mean task (in)dependency tracking is a fundamental concept. Independent tasks have "asynchrony." (Can we just say dependency and independency?)

But even with that definition, it seems like the idea of promises, task tracking, etc is well tread territory.

Then they conclude with how fire and forget tasks solve coloring but isn't that just the sync-over-async anti-pattern? I wouldn't be excited that my UI work stops to run something when there are no more green threads but they seem excited by it.

Anyway, I guess I got too distracted by the high concept "this is a fundamental change in thinking" fluff of the article.

omgJustTest• 1 year ago

Concurrency does not imply yielding...

Synchronous logic does imply some syncing and yielding could be a way to sync - which is what i expect you mean.

Asynchronous logic is concurrent without sync or yield.

Concurrency and asynchronous logic do not exist - in real form - in von Neumann machines

gf0003• 1 year ago

Could you expand on what you mean?

kazinator4• 1 year ago

Asynchrony, in this context, is an abstraction which separates the preparation and submission of a request from the collection of the result.

The abstraction makes it possible to submit multiple requests and only then begin to inquire about their results.

The abstraction allows for, but does not require, a concurrent implementation.

However, the intent behind the abstraction is that there be concurrency. The motivation is to obtain certain benefits which will not be realized without concurrency.

Some asynchronous abstractions cannot be implemented without some concurrency. Suppose the manner by which the requestor is informed about the completion of a request is not a blocking request on a completion queue, but a callback.

Now, yes, a callback can be issued in the context of the requesting thread, so everything is single-threaded. But if the requesting thread holds a non-recursive mutex, that ruse will reveal itself by causing a deadlock.

In other words, we can have an asynchronous request abstraction that positively will not work single threaded;

1 caller locks a mutex

2 caller submits request

3 caller unlocks mutex

4 completion callback occurs

If step 2 generates a callback in the same thread, then step 3 is never reached.

The implementation must use some minimal concurrency so that it has a thread waiting for 3 while allowing the requestor to reach that step.

brabel• 1 year ago

Completely agree. The server/client example in the post was just one example of a program not being able to make progress, you’ve just gave another which cannot be solved the same way, and I would bet there are many more that they will be discovering over time. IMO when async is used, concurrency needs to be ensured.

kazinator4• 1 year ago

It depends on the API. If the only way to obtain the result of the asynchronous dispatch is a synchronous operation on a completion queue, then there are no cases where a single-threaded implementation will break, other than not providing the performance.

However, we can argue that if there is only a synchronous operation to collect the result, then it's not truly async. Asynchrony should mean not only that we can initiate a request without waiting for the result, but that the completion can happen at any time.

ang_cire• 1 year ago

Asynchrony is not concurrency

This is what I tell my boss when I miss standups.

dvt3• 1 year ago

"Asynchrony" is a very bad word for this and we already have a very well-defined mathematical one: commutativity. Some operations are commutative (order does not matter: addition, multiplication, etc.), while others are non-commutative (order does matter: subtraction, division, etc.).

    try io.asyncConcurrent(Server.accept, .{server, io});
    io.async(Cient.connect, .{client, io});

Usually, ordering of operations in code is indicated by the line number (first line happens before the second line, and so on), but I understand that this might fly out the window in async code. So, my gut tells me this would be better achieved with the (shudder) `.then(...)` paradigm. It sucks, but better the devil you know than the devil you don't.

As written, `asyncConcurrent(...)` is confusing as shit, and unless you memorize this blog post, you'll have no idea what this code means. I get that Zig (like Rust, which I really like fwiw) is trying all kinds of new hipster things, but half the time they just end up being unintuitive and confusing. Either implement (async-based) commutativity/operation ordering somehow (like Rust's lifetimes maybe?) or just use what people are already used to.

ryandv5• 1 year ago

Strictly speaking commutativity is defined over (binary) operations - so if one were to say that two async statements (e.g. connect/accept) are commutative, I would have to ask, "under what operation?"

Currently my best answer for this is the bind (>>=) operator (including, incidentally, one of its instances, `.then(...)`), but this is just fuzzy intuition if anything at all.

dvt3• 1 year ago

Commutative operations (all of them I think?) are trivially generalized to n-ary operations (in fact, we do this via ∑ and ∏, in the case of addition and multiplication, respectively). You're right that the question of what "operation" we're dealing with here is a bit hazy; but I'd wager that it's probably in the family of the increment operation (N++ === N + 1 = 1 + N) since we're constantly evaluating the next line of code, like the head of a Turing machine.

Edit: maybe it's actually implication? Since the previous line(s) logically imply the next. L_0 → L_1 → L_2 → L_n? Though this is non-commutative. Not sure, it's been a few years since my last metalogic class :P

benreesman• 1 year ago

It's a good intuition. This has been studied extensively, the composition rule that is lax enough to permit arbitrary effects but strict enough to guarantee this class of outcomes is (>>=). We can keep trying to cheat this as long as we want, but it's bind.

xscott• 1 year ago

"under what operation?"

You could treat the semicolon as an operator, and just like multiplication over matrices, it's only commutative for a subset of the general type.

noduerme• 1 year ago

`.then()` is ugly, `await` is pretty, but wouldn't the critical part to guarantee commutivity less than guaranteed order (in js) be the `Promise.all([])` part?

Nevermark• 1 year ago

The "operator" in this case would be the CPU executing 2 or N procedures (or functions).

Commutivity is a very light weight pattern, and so is correctly applicable to many things, and at any level of operation, as long as the context is clear.

jhanschoo2• 1 year ago

Under function composition `;`, where both the LHS and RHS are viewed as functions operating on the whole environment state.

dooglius2• 1 year ago

Commutativity is a much weaker claim because one is totally before or after the other. e.g. AB may commute with C so ABC=CAB but it is not necessarily the case that this equals ACB. With asynchrony you are guaranteed ABC=ACB=CAB. (There may be an exisiting mathematical term for this but I don't know it)

dvt3• 1 year ago

You can prove three-term commutativity from two-term (I did it years ago, I think it looked something like this[1]), so the ordering doesn't matter.

[1] https://math.stackexchange.com/questions/785576/prove-the-co...

jhanschoo2• 1 year ago

I agree. T and U async with respect to each other means at least that T and U can be broken down into tasks t1, t2, t3, ... tn and u1, u2, ..., un, such that they can be interleaved in any order, but typically we still require that the t tasks are executed in sequential order. The divisions between the tasks are where they give up control, e.g. as they wait for data to be loaded into memory, or on a network call.

This is still a special case of what we mean by async wrt each other, because depending on the interleaving at each step and e.g. the data loaded into memory, the number of tasks may change, but the idea is that they still eventually terminate in a correct state.

brailsafe• 1 year ago

"Asynchrony" is a very bad word for this and we already have a very well-defined mathematical one: commutativity.

I don't think it's sufficient to say that just because another term defines this concept means it's a better or worse word. "commutativity" feels, sounds, and reads like a mess imo. Asynchrony is way easier on the palette

throwawaymaths5• 1 year ago

commutativity is also not correct, because 1) it means way more things than just temporal ordering and 2) there are cooky temporal ordering schemes you can come up with (interleaving multiple async/awaits in weird time-dependent ways) which aren't really describable in the simple mathematical notion of commutativity.

hinkley• 1 year ago

Asynchrony also allows for partial ordering. Two operations may still need to be retired in a particular order without having to execute in that order.

Subtraction for instance is not commutative. But you could calculate the balance and the deduction as two separate queries and then apply the results in the appropriate order.

ordu• 1 year ago

As written, `asyncConcurrent(...)` is confusing as shit, and unless you memorize this blog post, you'll have no idea what this code means. I get that Zig (like Rust, which I really like fwiw) is trying all kinds of new hipster things, but half the time they just end up being unintuitive and confusing. Either implement (async-based) commutativity/operation ordering somehow (like Rust's lifetimes maybe?) or just use what people are already used to.

I can't agree. It is confusing, because you need to remember the blog post, it wouldn't be confusing in the slightest if you internalized the core idea. The question remains: is it worth it to internalize the idea? I don't know, but what I do know is some people will internalize it and try to do a lot of shit with this in mind, and after a while we will be able to see where this path leads to. At that point we will be able to decide if it is a good idea or not.

"Asynchrony" is a very bad word for this and we already have a very well-defined mathematical one: commutativity.

It is risky to use "commutativity" for this. Zig has operators, and some of them are commutative. And it will be confusing. Like if I wrote `f() + g(). Addition is commutative, then Zig is free to choose to run f() and g() in parallel. The order of execution and commutativity are different things. Probably one could tie them into one thing with commutative/non-commutative operators, but I'm not sure it is a good idea, and I'm sure that this is the completely different issue to experimenting with asynchrony.

psychoslave3• 1 year ago

I'm not sure they are that different, you could just as well store function calls in some constant each on its line then addition the result on a third. This is only syntax, not conceptual difference here. And on practical level, the difference is that the operator can be directly matched with some machine instruction, with operands being native data type such as integer.

Still, you might then prefer a word as permutability, or swappability.

delusional• 1 year ago

Usually, ordering of operations in code is indicated by the line number

Except for loops which allow going backwards, and procedures which allow temporarily jumping to some other locally linear operation.

We have plenty of syntax for doing non-forwards things.

tbrownaw• 1 year ago

Some operations are commutative (order does not matter: addition, multiplication, etc.)

Fun fact: order does matter for addition. (When adding many floating-point numbers with widely varying exponents.)

tsimionescu2• 1 year ago

So, my gut tells me this would be better achieved with the (shudder) `.then(...)` paradigm. It sucks, but better the devil you know than the devil you don't.

The whole idea behind `await` is to make the old intuition work without the ugliness of `.then()`. `f(); await g(); h()` has exactly the expected execution ordering.

Yoric11• 1 year ago

Can confirm.

In JS, we designed `await` specifically to hide `.then()`, just as we had designed `.then()` because callbacks made tracking control flow (in particular errors) too complex.

alfiedotwtf2• 1 year ago

Usually, ordering of operations in code is indicated by the line number (first line happens before the second line, and so on), but I understand that this might fly out the window in async code

This isn’t always true at the language level, and almost certainly not at the CPU pipeline and microcode level.

Logic languages like Prolog will execute statements out of order, by design. Other languages like Mercury use the IO monad to signify serial operations

sdbrady• 1 year ago

I'm not sure what you mean by "statements" in Prolog as it's not a term the language defines. If you're referring to clauses, it's not true that execution is unordered: the Prolog interpreter attempts to unify a goal with clauses from the knowledge base in the order they appear. This ordering is semantically significant for control flow.

If instead you're referring to goals within the body of a clause, this is also incorrect. Goals are evaluated strictly left-to-right, and each must succeed before the next is attempted. This evaluation order is likewise required and observable, especially in the presence of side effects.

skybrian• 1 year ago

The way I like to think about it is that libraries vary in which environments they support. Writing portable libraries that work in any environment is nice, but often unnecessary. Sometimes you don't care if your code works on Windows, or whether it works without green threads, or (in Rust) whether it works without the standard library.

So I think it's nice when type systems let you declare the environments a function supports. This would catch mistakes where you call a less-portable function in a portable library; you'd get a compile error, indicating that you need to detect that situation and call the function conditionally, with a fallback.

andrewstuart• 1 year ago

That’s word games.

If I launch 2 network requests from my async JavaScript and both are in flight then that’s concurrent.

Definition from Oxford Dictionary adjective 1. existing, happening, or done at the same time. "there are three concurrent art fairs around the city"

necovek3• 1 year ago

It is an attempt to delineate some classes of concurrent & parallel programming challenges using a new term (really, redefining it in the programming context to be a bit tighter).

Oxford dictionary holds no relevance here, unless it has took over a definition from the field already (eg. look up "file": I am guessing it will have a computer file defined there) — but as it lags by default, it can't have specific definitions being offered.

jillesvangurp• 1 year ago

The concepts of concurrency and parallelism are adjacent enough that they are often confused. A lot of languages provide basic concepts for both but use different frameworks for both. So the difference really matters in that case. Or the frameworks are just a bit low level and the difference really matters for that reason (because you need to think about and be aware of different issues).

I've been using Kotlin in the last few years. And while it is not without issues, their co-routines approach is a thing of beauty as it covers the whole of this space with one framework that is designed to do all of it and pretty well thought through. It provides a higher level approach in the form of structured concurrency, which is what Zig is dancing around here if I read this correctly (not that familiar with it so please correct if wrong) and not something that a lot of languages provide currently (Java, Javascript, Go, Rust, Python, etc.). Several of those have work in progress related to that though. I could see python going there now that they've bit the bullet with removing the GIL. But they have a bit of catching up to do. And several other languages provide ways that are similarly nice and sophisticated; and some might claim better.

In Kotlin, something being async or not is called suspending. Suspending just means that "this function sometimes releases control back to whatever called it". Typical moments when that happens are when it does evented IO and/or when it calls into other suspending functions.

What makes it structured concurrency is that suspend functions are executed in a scope, which has something called a dispatcher and a context (meta data about the scope). Kotlin enforces this via colored "suspend" functions. Calling them outside a coroutine scope is a compile error. Function colors are controversial with some. But they works and it's simple enough to understand. There's zero confusion on the topic. You'll know when you do it wrong.

Some dispatchers are single threaded, some dispatchers are threaded, and some dispatchers are green threaded (e.g. if on the JVM). In Kotlin, a coroutine scope is obtained with a function that takes a block as a parameter. That block receives its scope as a context parameter (typically 'this'). When the block exits, the whole tree of sub coroutines the scope had is guaranteed to have completed or failed. The whole tree is cancelled in case of an exception. Cancellation is one of the nasty things many other languages don't handle very well. A scope failure is a simple exception and if something cancelled, that's a CancellationException. If this sounds complicated, it's not that bad (because of Kotlin's DSL features). But consider it necessary complexity. Because there is a very material difference between how different dispatchers work. Kotlin makes that explicit. But otherwise, it kind of is all the same.

If inside a coroutine, you want to do two things asynchronously, you simply call functions like launch or async with another block. Those functions are provided by the coroutine scope. If you don't have one, you can't call those. That block will be executed by a dispatcher. If you want use different threads, you give async/launch an optional new coroutine scope with it's own dispatcher and context as a parameter (you can actually combine these with a + operator). If you don't provide the optional parameter, it simply uses the parent scope to construct a new scope on the fly. Structured concurrency here means that you have a nested tree of coroutines that each have their own context and dispatchers.

A dispatcher can be multi threaded (each coroutine gets its own thread) and backed by a thread pool, or a simple single threaded dispatcher that just lets each coroutine run until it suspends and then switches to the next. And if you are on the JVM where green thread pools look just like regular thread pools (this is by design), you can trivially create a green thread pool dispatcher and dispatch your co routines to a green thread. Note, this is only useful when calling into Java's blocking IO frameworks that have been adapted to sort of work with green threads (lots of hairy exceptions to that). Technically, green threads have a bit more overhead for context switching than Kotlin's own co-routine dispatcher. So use those if you need it; avoid otherwise unless you want your code to run slower.

There's a lot more to this of course but the point here is that the resulting code looks very similar regardless of what dispatchers you use. Whether you are doing things concurrently or in parallel. The paradigm here is that it is all suspend functions all the way down and that there is no conceptual difference. If you want to fork and join coroutines, you use functions like async and launch that return jobs that you can await. You can map a list of things to async jobs and then call awaitAll on the resulting list. That just suspends the parent coroutine until the jobs have completed. Works exactly the same with 1 thread or a million threads.

If you want to share data between your co-routines, you still need to worry about concurrency issues and use locks/mutexes, etc. But if your coroutine doesn't do that and simply returns a value without having side effects on memory (think functional programming here), things are quite naturally thread safe and composable for structured concurrency.

There are a lot of valid criticisms on this approach. Colored functions are controversial. Which I think is valid but not as big of a deal in Kotlin as it is made out to be. Go's approach is simpler but at the price of not dealing with failures and cancellation as nicely. All functions are the same color. But that simplicity has a price (e.g. no structured concurrency). And it kind of shovels paralellism under the carpet. And it kind of forces a lot of boiler plate on users by not having proper exceptions and job cancellation mechanisms. Failures are messy. It's simple. But at a price.

necovek3• 1 year ago

The idea behind Zig approach which is only being implemented is to extend concurrent code to be executable outside the coroutine context, making it trivially serializable when that's possible (thus the networking example).

In general, the heavy lifting should always be moved to the lower level infrastructure (compiler, standard library, RDBMS system in case of ACID guarantees...) — leaving developer his brainspace for the business logic.

This requires minimum "function coloring", and I'd prefer if Python took that approach instead.

messe• 1 year ago

If I launch 2 network requests from my async JavaScript and both are in flight then that’s concurrent.

That's because JS conflates the two. The async keyword in JavaScript queues things for the event loop which is running in a different thread, and progress will be made on them even if they are never awaited. In Rust, for example, nothing will happen unless those Futures are awaited.

tekbog• 1 year ago

There's a great old book on this if someone wants to check it: Communicating Sequential Processes. From Hoare. Go channels and the concurrent approach was inspired on this.

I also wrote a blog post a while back when I did a talk at work, it's Go focused but still worth the read I think.

[0] https://bognov.tech/communicating-sequential-processes-in-go...

bentleya• 1 year ago

Non-blocking i/o isn't asynchrony and the author should know better. Non-blocking io is a building block of asynchronous systems -- it is not asynchony itself. Today's asynchronous programming did not exist when non-blocking I/O was implemented in Unix in the 80's.

nemothekid2• 1 year ago

I think I'm missing something here, but the most interesting piece here is how would stackless coroutines work in Zig?

Since any function can be turned into a coroutine, is the red/blue problem being moved into the compiler? If I call:

     io.async(saveFileA, .{io});

Is that a function call? Or is that some "struct" that gets allocated on the stack and passed into an event loop?

Furthermore, I guess if you are dealing with pure zig, then its fine, but if you use any FFI, you can potentially end up issuing a blocking syscall anyways.

laserbeam4• 1 year ago

I hope this is not a bad answer as I tried to understand what stackless coroutines even are for the past week.

1. Zig plans to annotate the maximum possible stack size of a function call https://github.com/ziglang/zig/issues/23367 . As people say, this would give the compiler enough information to implemented stackless coroutines. I do not understand well enough why that’s the case.

2. Allegedly, this is only possible because zig uses a single compilation unit. You are very rarely dealing with modules that are compiled independently. If a function in zig is not called, it’s not compiled. I can see how this helps with point 1.

3. Across FFI boundaries this is a problem in every language. In theory you can always do dumb things after calling into a shared library. A random C lib can always spawn threads and do things the caller isn’t expecting. You need unsafe blocks in rust for the same reason.

4. In theory, zig controls the C std library when compiling C code. In some cases, if there’s only one Io implementation used for example, zig could replace functions in the c std library to use that io vtable instead.

Regardless, I kinda wish kristoff/andrew went over what stackless coroutines are (for dummies) in an article at some point. I am unsure people are talking about the same thing when mentioning that term. I am happy to wait for that article until zig tries to implement that using the new async model.

kibwen2• 1 year ago

As people say, this would give the compiler enough information to implemented stackless coroutines.

Stackless coroutines require creating a structure big enough to hold all the locals for the would-be function, but Zig already has that information, along with Rust, and, by definition, every other language that already supports stackless coroutines.

The root of that linked issue is that Zig has some desire to statically compute the total stack usage of an entire program, but the difficulty there is not in computing the stack size for any given function (which is generally trivial in most languages; supporting growable stack via something like C's `alloca` is the exception, not the rule). The difficulty is that recursive functions can push an unbounded number of function calls to the stack. So what Zig wants to do is forbid recursion, even mutual recursion, unless you do some kind of opt-in.

And this is where "Allegedly, this is only possible because zig uses a single compilation unit" comes in, because detecting mutual recursion is tricky, especially when virtual dispatch gets involved.

But no, you don't need Zig-style whole-program compilation to make that happen. All you need is 1) to be able to detect mutual recursion within a single compilation unit (again, stymied by virtual dispatch), and then 2) to prevent cyclical dependencies between compilation units. Go and Rust both do the latter, so they could get away with the same analysis, assuming you can find a good solution for the former.

User23• 1 year ago

Asynchrony, parallelism, concurrency, and even deterministic execution (albeit as a degenerate case) are all just species of nondeterminism. Dijkstra and Scholten’s work on the subject is sadly under appreciated. And lest one thing this was ivory tower stuff, before he was a professor Dijkstra was a systems engineer writing operating systems on hilariously bad, by our standards, hardware.

riwsky• 1 year ago

“Permission for concurrency is not an obligation for concurrency. Zig lets you explicitly permit-without-obligation, to support the design of libraries that are polymorphic over a/sync ‘function color’.”

Salgat• 1 year ago

It's more accurate to say that callbacks and async/await can facilitate concurrency.

reichstein• 1 year ago

So "cooperative multitasking is not preemptive multitasking".

The typical use of the word "asynchronous" means that the _language is single-threaded_ with cooperative multitasking (yield points) and event based, and external computations may run concurrently, instead of blocking, and will report result(s) as events.

There is no point in having asynchrony in a multithreaded or concurrent execution model, you can use blocking I/O and still have progress in the program while that one execution thread is blocked. Then you don't need the yield points to be explicit.

Yoric11• 1 year ago

While this is indeed the most common use, I'll bring as counter-examples Rust (or C#, or F#, or OCaml 5+) that supports both OS threads and async. OS threads are good for CPU-bound tasks, async for IO-bound tasks.

The main benefit of having async (or Go-style M:N scheduling) is that you can afford to launch as many tasks/fibers/goroutines/... as you want, as long as you have RAM. If you're using OS threads, you need to pool them responsively to avoid choking your CPU with context-switches, running out of OS threads, running out of RAM, etc. – hardly impossible, but if you're doing more than just I/O, you can run into interesting deadlocks.

wasmperson• 1 year ago

The main benefit of having async (or Go-style M:N scheduling) is that you can afford to launch as many tasks/fibers/goroutines/... as you want

Some have argued that the real solution to this problem is to "just" fix OS threads. Rumor has it Google has done exactly this, but keeps it close to their chest:

https://www.youtube.com/watch?v=KXuZi9aeGTw

https://lwn.net/Articles/879398/

Somewhat related and also by Google is WebAssembly Promise Integration, which converts blocking code into non-blocking code without requiring language support:

https://v8.dev/blog/jspi

I see a possible future where the "async/await" idea simply fades away outside of niche use-cases.

Yoric11• 1 year ago

Defining async is hard. And I'm writing this as one of the many people who designed async in JavaScript.

I don't quite agree with the definition in this post: just because it's async doesn't mean that it's correct. You can get all sorts of user-land race conditions with async code, whether it uses `async`/`await` (in languages that need/support it) or not.

My latest formulation (and I think that it still needs work) is that async means that the code is explicitly structured for concurrency.

I wrote some more about the topic recently: https://yoric.github.io/post/quite-a-few-words-about-async/ .

atoav2• 1 year ago

I am not deep into the matter but I would have given the answer: Async code is making code that would have been blocking non-blocking in a manner other stuff can still happen while it is being completed.

Since I work a lot in embedded loops where long running blocking snippets could literally break your I/O, lead to visible/audible dropouts etc. this would be the obvious answer.

Yoric11• 1 year ago

But that's the thing: async, by itself, doesn't guarantee that anything is non-blocking. For your fiber (or any other kind of user-land abstraction) to be non-blocking, you MUST ensure that it doesn't perform any blocking call.

All async does is give you (some of) the tools to make code non-blocking.

twwwt• 1 year ago

The important thing to me is to distinguish between the abstract concept of asynchronism and how it can be implemented, and by the latter I mean both at the abstract level of a programming language and by technical coordination means in a machine. For the abstract concept at the highest level, well, it is just the dual of synchronism: two (or more) parties that somehow need to work together (i.e., one has a dependency on the other in a way that certain things need to happen before another one can continue) are not synchronized, meaning that it is not known or not defined when the things that need to happen after something else will be done. Seen that way, this definition is not hard. The hard thing can be the abstract means designed in a language: the amount of cognitive effort it takes in order to comprehended them and/or use them (in an fault-free way).

Yoric11• 1 year ago

Largely agreed: async means that the code is structured in such a manner that the only way to be certain that a task is complete is to perform some rendez-vous. By extension, it covers mechanisms to make this happen in your code.

rasmul• 1 year ago

i am not even sure we should define async

it may be hard (it is) because it cannot be matched to one thing

the question is: is it useful to define async? or event loop? there must be tons of concepts i have no idea in the realm of physical chips that make true parallelism possible

i am totally fine with "user finger" and "quickies", job queues and blocking or non-blocking APIs

the finger symbolizes touch events and even mouse clicks and keyboard or general user initiated events, which i have to match to quickies which are very tiny (execution time) blocking(!) jobs that will be queued by the browser

to reach my goals, i prefer non-blocking APIs because i can discard some time consuming jobs to underlying systems and i jsut write a quicky for what i want (store data in indexed db) and what will happen if it succeeds or fails etc (different quickies)

sync, async do not really help me, of course i have to understand when others talk about it or i see or use (or my preferred AI coder) async, but it just means non-blocking API

but again, the async programming model is actually writing very much blocking quickies where the non-blocking nature is the small, atomic nature (execution-time-wise) of the blocking jobs I try to match to chaotic, non-deterministic events, triggered by fingers or browsers or whatever

I actually dont care, just hope that the browser code uses great concurrent models with cpp or rust or whatever and the device has multiple executions units (os threads) and the os scheduler does a great job, managing things whether there are more execution units or just 1 available

async for me a not well defined concept and even if it was somehow defined, i am not sure it would be useful to me

useful concepts are events, the blocking nature of jobs i write in js, what my functions see (closure i guess), what runs as a job if i use APIs and what runs as a different job after the events the browser triggers (ready, error whatever)

even the name callback was extremely confusing because i really thought back then that the code somehow stops there and waits for a callback... no, it runs to the end of that section and you really have to understand what other things run when it "calls back" and what that code sees

to be honest, i think it is a mess and genius at the same time... but understanding "async" or rather the model was really difficult because i just dont think this means anything

it is actually very simple to understand with different concepts like event, blocking job, job queue, non-blocking API

what i also find important to know what we are doing and what others do like browser code, os etc... it is a bit like a cpp code declares a concurrent model with a thrad but the os will decide... in js, we use non-blocking api which implicitly declares a probably concurrent model the browser or node or whatever should use and i am sure they always do

the most important thing is to keep your jobs quick, probably under 30-50ms and non-blocking API are great because your job just declares the intent and done, and languages like cpp, rust will declare the os that they want the actual task done concurrently so even if the os has one real physical thread, the UI will be responsive since the OS will switch between UI code execution and "real task" execution like some networking or database or whatever

but all an "async" programmer has to do is to create a great UX model and match events to quickies

Yoric11• 1 year ago

Not entirely sure what you mean.

If you're writing that you don't need to understand how your browser works, "just" to make things fast enough... well, sure, go ahead.

But anybody who wants to graduate to a higher-level of comprehension, will need to understand a bit better under the hood.

jongjong• 1 year ago

I think there's not much point trying to define these concepts as there is no consensus about what they mean. Different people have clear ideas about what each concept means but they just don't agree.

It's like integration tests vs unit tests... Most developers think they have a clear idea about what each one means, but based on my experience there is very little consensus about where the line is between unit test vs integration test. Some people will say a unit test requires mocking or stubbing out all dependencies, others will say that this isn't necessary; so long as you mock out I/O calls... Others will say unit tests can make I/O calls but not database calls or calls which interface with an external service... Some people will say that if a test covers the module without mocking out I/O calls then it's not an integration test, it's an end-to-end test.

Anyway it's the same thing with asynchrony vs concurrency vs parallelism.

I think most people will agree that concurrency can potentially be achieved without parallelism and without asynchrony. For many people, asynchrony has the connotation that it's happening in the same process and thread (same CPU core). Some people who work with higher level languages might say that asynchrony is a kind of context switching (as it's switching context in the stack when callbacks at called or promises resolved) but system devs will say that context switching is more granular than that and not constrained to the duration of specific operations, they'll say it's a CPU level concept.

t43562• 1 year ago

I think it's a great idea to not have to have two libraries - so its a "tick" from me for any idea that permits it.

The thing that bothers me in general about asynchronous code is how you test it so that you know with some confidence that if it passes the tests today you have replicated all the scenarios/orderings that might happen in production.

You have this same problem with threads of course and I've always found multithreaded programs to be much harder to write and debug....such that I personally use threading only when I feel I have to.

The actual problem with it is that caution is communicating it to developers. I recently had to work on a python system where the developers were obviously doing Javascript half the time. So ... hooray.... they put out a huge changeset to make the thing async....and threaded. Oddly enough none of them had ever heard of the GIL and I got the feeling of being seen as an irritating old bastard as I explained it to their blank stares. Didn't matter. Threading is good. Then I pointed out that their tests were now always passing no matter if they broke the code. Blank stares. They didn't realise that mangum forced all background tasks and async things to finish at the end of an HTTP request so their efforts to shift processing to speed up the response were for nothing.

Knowing things doesn't always matter if you cannot get other people to see them.

Tanjim2• 1 year ago

That resonates. Testing asynchronous and multithreaded code for all possible interleavings is notoriously difficult. Even with advanced fuzzers or concurrency testing frameworks, you rarely gain full confidence without painful production learnings.

In distributed systems, it gets worse. For example, when designing webhook delivery infrastructure, you’re not just dealing with async code within your service but also network retries, timeouts, and partial failures across systems. We ran into this when building reliable webhook pipelines; ensuring retries, deduplication, and idempotency under high concurrency became a full engineering problem in itself.

That’s why many teams now offload this to specialized services like Vartiq.com (I’m working here), which handles guaranteed webhook delivery with automatic retries and observability out of the box. It doesn’t eliminate the async testing problem within your own code, but it reduces the blast radius by abstracting away a chunk of operational concurrency complexity.

Totally agree though – async, threading, and distributed concurrency all amplify each other’s risks. Communication and system design caution matter more than any syntax or library choice.

Tainnor• 1 year ago

That’s why many teams now offload this to specialized services like Vartiq.com

It would be nice to add a disclaimer that this is a system you're working on.

kristoff_it5• 1 year ago

We plan to have in Zig a testing `Io` implementation that will potentially use fuzzing to stress test your code under a concurrent execution model.

That said, I think a key insight is that we expect most of the library code out there to not do any calls to `io.async` or `io.asyncConcurrent`. Most database libraries for example don't need any of this and will still contain simple synchronous code. But then that code will be able to be used by application developers to express asynchrony at a higher level:

   io.async(writeToDb)
   io.async(doOtherThing)

Which makes things way less error prone and simpler to understand than having async/await sprinkled all over the place.

lll-o-lll• 1 year ago

More powerful than a “fuzzing” test io would be a deterministic test io. I.e., one you can tick forward the various concurrent branches deterministically to prove that various races are safely handled. This makes it possible to capture all those “what if thread A executes this line first then B is executed” etc. Something that is missing in most concurrent frameworks.

ddingus4• 1 year ago

I do not see these definitions as quite right:

Asynchrony: the possibility for tasks to run out of order and still be correct.

I like this. Great addition and yes it was missing.

Concurrency: the ability of a system to progress multiple tasks at a time, be it via parallelism or task switching.

I would say here, be it multiprocessing or task switching.

Parallelism: the ability of a system to execute more than one task simultaneously at the physical level.

This is technically multiprocessing as expressed above.

So, what is the difference between parallelism and concurrency?

Parallel tasks are like shaders. It is the same task, running many instances at the same time at the physical layer.

GPU devices are capable of parallel computing, for example.

Concurrent tasks are different tasks running at the same time at the physical layer. Often, the data is different too. Say a sprite engine running at the same time as a video display driver on the physical layer.

The shaders can all be running the same code but are processing different data elements, say each pixel having a position and is part of a larger rendering.

A GPU is a massively parallel multiprocessor.

A Threadripper is a massive Concurrent multiprocessor. It can also perform as a modest parallel multiprocessor.

The difference lies in what the various compute units can do and what they are actually doing.

Put another way, a 10ghz single core CPU is not a multiprocessor. It performs sequential computing and it can task switch to handle the same task load as a lower clock rate multiprocessor would handle.

A 10ghz multi core CPU is a concurrent multiprocessor, but is not a GPU. It could run shaders on par with a lower clock GPU. BUT a lower clock GPU cannot run a variety of tasks in the same way.

throwup238• 1 year ago

Parallel tasks are like shaders. It is the same task, running many instances at the same time at the physical layer.

That’s single instruction multiple data which I would argue is an orthogonal concern. A better example of parallelism would be FPGAs. All of the gates are switching all at the same time* and you have to actually figure out how to synchronize the whole lot to get anything useful out of them.

* PLL notwithstanding

ddingus4• 1 year ago

Yes, SIMD is a form of parallel computing. But that is not the only form. A shader is one, and the difference is lots of instructions and lots of data. It is just the same instructions executing in all the instances.

Concurrent would be many tasks running at the same time with each task containing different jnstructions on either the same data, or different data.

gf0003• 1 year ago

A single-threaded CPU can do concurrent processing just fine - this is an important distinction compared to parallelism, and I think you are muddying the two up a bit here.

ddingus4• 1 year ago

I agree with you and thought I was clear on that.

In fact, there is no effective difference between a very fast single thread, sequential compute CPU and a multiprocessor, or multi-core CPU.

yazantapuz• 1 year ago

I allways think of async concurrency as state machines.

jlouis2• 1 year ago

A good way to gauge if "asynchrony" is a term we need is to test if it is useful in other contexts than just a single language, or a single concurrency design.

If it's needed to reason correctly in a wide set of concurrency models, then I'd say it's going to be a useful addition. If not, then I'd say it's not really worth using in the grander scheme of things.

I.e., does this make any sense in Haskell, Erlang, OCaml, Scheme, Rust, Go, .... ?(assuming we pick one of the many concurrency models available in Haskell, Rust and OCaml).

More generally: if things are cooperatively scheduled, then there's a need for attention to additional details. This is because it's much easier for a bad piece of code to affect the system as a whole, by locking it up, or generating latency-problems. In a preemptively scheduled world, a large group of problems disappear instantly, since you can't lock up the system in the same way.

northhnbesthn• 1 year ago

As a network programmer who has written a metric asston of concurrent parallel asynchronous whatever-the-hell code [0], this article is confusing. It seems like doing somersaults over a leaky abstraction. The tool for the job is wrong and its implementation is wrong if you can shit the bed this easily.

[0] debugging is fun precisely because it’s amusing to watch people be frightened of having to debug multi threaded hydras.

lowbloodsugar• 1 year ago

Asynchrony: the possibility for tasks to run out of order and still be correct.

This is simply wrong. Asynchrony makes no claims about two unrelated tasks, so “order” here is irrelevant and in terms of each task, again, we expect the executions of a given task to be in order. So this statement cannot be true under either interpretation.

There’s lots more wrong with the article as you would expect when the starting premise is wrong.

JackSlateur• 1 year ago

"asynchrony is not concurrency" : this is true

What is also true is that asynchrony without concurrency is harmful

I might be more precise: asynchrony without parallelism is harmful, because you introduce a whole new set of computing operations without any benefits

Iujia• 1 year ago

Is this interpretation correct?

My original understanding was that asynchrony refers to a behavior — specifically, the non-blocking execution of code.

However, the article defines asynchrony as a capability — the ability to perform non-blocking operations, though it can also execute in a blocking manner depending on the I/O.

The new I/O design decouples the capability from the behavior of whether or not to use it, effectively addressing the function coloring problem.

klas_segeljakt• 1 year ago

This talk gives a good distinction between asynchrony, concurrency, parallelism, scheduling (cooperative, preemptive)

https://www.youtube.com/watch?v=x5_MmZVLiSM&t=346s

ddingus4• 1 year ago

My earlier comment was a mess!

I like the idea of this piece. My trouble with it boils down to getting concurrent and parallel wrong, or mangled somewhat.

Concurrent happens when multiple tasks are happening together. This can be task switching on a single processor, or it can mean they run together on a multiprocessor, or multi core processor.

Secondly, given a sufficiently fast single processor, there is no meaningful difference in concurrency.

Parallel is like concurrent in that multiple tasks are being processed, executed at the same time. What makes parallel different from concurrent is all the tasks are essentially the same, with each of them working on data intended for them to process. Secondly, parallel processing happens on multiprocessors. That is compute systems having multiple cores, each running the task on data made available to a given instance of the task.

Concurrency is a superset of parallel in that all the things that differentiate parallel processing satisfy the requirements needed to call a given compute exercise a concurrent one.

However, concurrency meets other requirements beyond those needed to label ancompute exercise as parallel processing.

I prefer and use the older term, multiprocessor and multiprocessing because "core" can be confusing. In this context they are essentially the same.

I also use the term "sequential compute" to refer to single threaded, single core, non multiprocessing units capable of one threadnof execution.

Asynchrony is a great addition to the topic!

After reading it all again, I submit that Asynchrony is a subset of concurrency, just like parallel is, and it is important enough to warrant an addition to the lexicon, just as parallel is.

However, one matter remains unclear to me as of my writing this:

Does this statement remain true for Asynchrony as it does currently for concurrent, which contains parallel as a specific case?

-->Given a sufficiently fast unprocessed, capable of sequential compute only, a single core, single threaded CPU, there is nobeffectiv3 difference between concurrency done via task switching and concurrency done with multiprocessing.

Is that true for Asynchrony?

I believe it is, and if so, I believe my comment here has a a lot more value than my earlier one.

Great discussion, and Asynchrony is added to my computing lexicon.

Asynchrony is not concurrency

Related Stories