coroutineScope {
    launch { foo() }
    bar()
}

coroutineScope {
    launch { foo() }
    launch { bar() }
}

are these equivalent?

Yes in terms of execution order

You definitely can observe different execution orders between those

Really? On what scenarios?

well I think the only time you wouldn't see a difference is if you were in an Unconfined dispatcher

call it in runBlocking and you'll get different execution order

but if I don't care about the order of getting started, and I only care that

coroutineScope

will await them both, then it doesn't matter/first has less overhead?

Ah, gotcha. It's like js event loop shit all over again! Apologies for spreading misinformation!

A coroutinescope will always wait for all of its children to finish before it can itself finish

if the first line in`bar()` was

yield()

then they might appear to be in the same order

after

launch { foo() }

, it is not specified how much of

foo

has run before the next statement in the caller

that still depends on scheduling and dispatcher support of

yield

, but yes they might be the same sometimes

with

launch(start = CoroutineStart.UNDISPATCHED) { foo() }

you can say that up to the first suspension point in

foo()

has executed, I believe

so given

io

dispatcher, then what is more idiomatic, if you only care that they're executed in parallel a nd coroutineScope awaits both of them

sure, but now you're changing the code. if the caller is using the Unconfined dispatcher

foo

will always run before

bar

I don't think one is more idiomatic than the other

I'd write whichever is clearer for the purpose

well that's my question, what does look more clearer 😄 basically I want to sync two apis at once

coroutineScope {
	launch { syncInvoices() }
	launch { syncMessages() }
}

probably the dual launch makes it more apparent that they're both going in parallel?

If the main thing you’re trying to express is 2 jobs running in parallel, I would make sure that’s explicit in the code. So yes, like the snippet above, I’d use 2

launch

blocks

if both launches are equally "async", then yes I'd write them both as

launch

thanks!

that's one way to look at it

It is, but if one has to add one more "sync", they may be confused how to do this. So 2 launch blocks are easier to read and shows intent better