Clarify parallelism execution of asynchronous computations

Author: julienrf

_overviews/scala3-book/concurrency.md

@@ -182,17 +182,18 @@ See the [Futures and Promises][futures] page for a discussion of additional meth
 ## Running multiple futures and joining their results
 
 To run multiple computations in parallel and join their results when all of the futures have been completed, use a `for` expression.
+
 The correct approach is:
 
-1. Create the futures
+1. Run the computations that return `Future` results
 2. Merge their results in a `for` expression
 3. Extract the merged result using `onComplete` or a similar technique
 
 
 ### An example
 
 The three steps of the correct approach are shown in the following example.
-A key is that you first create the futures and then join them in the `for` expression:
+A key is that you first run the computations that return futures, and then join them in the `for` expression:
 
 ```scala
 import scala.concurrent.Future
@@ -207,12 +208,12 @@ def sleep(millis: Long) = Thread.sleep(millis)
 
   println(s"creating the futures:   ${delta()}")
 
-  // (1) create the futures
+  // (1) run the computations that return futures
   val f1 = Future { sleep(800); 1 }   // eventually returns 1
   val f2 = Future { sleep(200); 2 }   // eventually returns 2
   val f3 = Future { sleep(400); 3 }   // eventually returns 3
 
-  // (2) run them simultaneously in a `for` expression
+  // (2) join them in a `for` expression
   val result =
     for
       r1 <- f1
@@ -252,10 +253,23 @@ All of that code is run on the JVM’s main thread.
 Then, at 806 ms, the three futures complete and the code in the `yield` block is run.
 Then the code immediately goes to the `Success` case in the `onComplete` method.
 
-The 806 ms output is a key to seeing that the three futures are run in parallel.
-If they were run sequentially, the total time would be about 1,400 ms---the sum of the sleep times of the three futures.
-But because they’re run in parallel, the total time is just slightly longer than the longest-running future: `f1`, which is 800 ms.
-
+The 806 ms output is a key to seeing that the three computations are run in parallel.
+If they were run sequentially, the total time would be about 1,400 ms---the sum of the sleep times of the three computations.
+But because they’re run in parallel, the total time is just slightly longer than the longest-running computation: `f1`, which is 800 ms.
+
+> Notice that if the computations were run within the `for` expression, they
+> would be executed sequentially, not in parallel:
+> ~~~
+> // Sequential execution (no parallelism!)
+> for
+>   r1 <- Future { sleep(800); 1 }
+>   r2 <- Future { sleep(200); 2 }
+>   r3 <- Future { sleep(400); 3 }
+> yield
+>   r1 + r2 + r3
+> ~~~
+> So, if you want the computations to be possibly run in parallel, remember
+> to run them outside of the `for` expression.
 
 ### A method that returns a future