Explain the difference between 'launch' and 'async' in Kotlin coroutines.

In Kotlin coroutines, `launch` and `async` are both functions used to initiate concurrent execution of code. However, they have distinct differences in terms of their behavior and return values. Here's an explanation of the difference between `launch` and `async`:

1. `launch` :
   * The `launch` function is used to launch a new coroutine without expecting any result.
   * It is suitable for tasks where the focus is on concurrent execution without the need to retrieve a specific result.
   * The `launch` function returns a `Job` object, which represents the coroutine and can be used to control or cancel the coroutine if needed.
   Example :

     val job = GlobalScope.launch {
         // Code to be executed concurrently
     }​

2. `async`:
   * The `async` function is used to launch a new coroutine and explicitly return a `Deferred` object, representing a future result of the computation.
   * It is suitable for tasks where you need to perform concurrent computations and retrieve a result or combine multiple results later.
   * The `Deferred` object allows you to explicitly await the result using the `await()` function, which suspends the coroutine until the result is available.
   * The `async` function returns a `Deferred<T>` object, where `T` is the type of the result.
   Example :

     val deferred = GlobalScope.async {
         // Code to be executed concurrently and return a result
         return@async "Result"
     }
     val result = deferred.await()​

In the key difference between `launch` and `async` lies in the return value and purpose:

* `launch` is used for concurrent execution without expecting a specific result. It returns a `Job` object.
* `async` is used for concurrent execution with an explicitly returned result. It returns a `Deferred<T>` object and allows you to await the result using `await()`.

Both `launch` and `async` are essential components of Kotlin coroutines, and the choice between them depends on whether you need to retrieve a result from the concurrent computation or simply perform concurrent tasks without expecting a specific outcome.