A modern programming language that makes developers happier.

kotlinlang

What is the purpose of `join` now that the outer scope will wait for all functions launched within to complete?

Sometime you need to join your particular children before doing something else:

```
val subTask = launch { doSomething() } 
// do something else in parallel
subTask.join()
// continue only when subTask completes
// do more stuff 
```

that is fork-join type of programming style (launch == fork)

But then why not just use `withContext` at that point?

you can _also_ use `coroutineContext` to the same effect:
```
coroutineContext { 
    launch { doSomething() } 
    // do something else in parallel
}
// continue only when subTask completes
// do more stuff 
```
But that is more nesting in code

Nevermind about with context, o got myself confused

I guess what bothers me about your code sample is that has two different indentations for parallel work which makes things unclear

```
val subTask = async { doSomething() }
val sub2 = async { ... }

awaitAll(subTask, sub2)

// do more stuff 
```

Or is the point that the first `launch` just needs to do _some_ background with and we don't care about a result?

Yes. You use `launch` if you need _side-effect_ of some work (like store stuff to DB). You use _async_ if you need _result_ of some work.

Ahhhhh, finally putting it all together. Thanks so much!!! :heart:

And I've been using coroutines for a year, lol