A modern programming language that makes developers happier.

kotlinlang

Should I avoid doing this
```        launch {
            launch {}
            launch {}
            launch {}
        }.join()```
over this?
```        listOf(
            launch {},
            launch {},
            launch {}
        ).joinAll()```

Either way, why? Thanks!

the first one will have a bit more overhead since it still needs to do an initial async launch. probably the most kotlin-like way is:
```coroutineScope {
  launch {}
  launch {}
  launch {}
}```

afaik in option 1 you will wait only for outer launch to finish, not for inner launches
you HAVE to use `coroutineScope` as in previous answer or option 2

What about this? Looks like you're wanting to do parallel ops and join results in the end

```
suspend fun concurrentSum(): Int = coroutineScope {
    val one = async { doSomethingUsefulOne() }
    val two = async { doSomethingUsefulTwo() }
    one.await() + two.await()
}
```

That'd be what I'd expect if using kx.coroutines

If you're waiting for return values.
This is not the case here AFAIU

<@UNKNBSP33>
``` launch {
            launch {}
            launch {}
            launch {}
        }.join()```
behaves in the exact same was as
```coroutineScope {
  launch {}
  launch {}
  launch {}
}```

<@UNKNBSP33> because of the principle of Structured Concurrency that a parent (outer launch) does not complete before all of its children (inner launches) have completed.

indeed, my mistake, i missed the `join` in option 1