diff --git a/1-js/02-first-steps/13-while-for/1-loop-last-value/solution.md b/1-js/02-first-steps/13-while-for/1-loop-last-value/solution.md
index a6395f772..00f4082a0 100644
--- a/1-js/02-first-steps/13-while-for/1-loop-last-value/solution.md
+++ b/1-js/02-first-steps/13-while-for/1-loop-last-value/solution.md
@@ -1,4 +1,4 @@
-La risposta: `1`.
+La risposta è: `1`.
 
 ```js run
 let i = 3;
@@ -15,11 +15,11 @@ Quindi, gli step del ciclo sono ("loop unrolled"):
 ```js
 let i = 3;
 
-alert(i--); // shows 3, decreases i to 2
+alert(i--); //mostra 3, decrementa i a 2
 
-alert(i--) // shows 2, decreases i to 1
+alert(i--) // mostra 2, decrementa i a 1
 
-alert(i--) // shows 1, decreases i to 0
+alert(i--) // mostra 1, decrementa i a 0
 
-// done, while(i) check stops the loop
+// finito, `i` è ora 0, che convertito a booleano è falso
 ```
diff --git a/1-js/02-first-steps/13-while-for/1-loop-last-value/task.md b/1-js/02-first-steps/13-while-for/1-loop-last-value/task.md
index 54c9d1f15..89f1e2a6b 100644
--- a/1-js/02-first-steps/13-while-for/1-loop-last-value/task.md
+++ b/1-js/02-first-steps/13-while-for/1-loop-last-value/task.md
@@ -4,7 +4,7 @@ importance: 3
 
 # Valore all'ultimo ciclo
 
-Qualè l'ultimo valore stampato da alert in questo codice? Perchè?
+Qual è l'ultimo valore mostrato da *alert* in questo codice? Perché?
 
 ```js
 let i = 3;
diff --git a/1-js/02-first-steps/13-while-for/2-which-value-while/solution.md b/1-js/02-first-steps/13-while-for/2-which-value-while/solution.md
index 783cacc3c..7fbb1778c 100644
--- a/1-js/02-first-steps/13-while-for/2-which-value-while/solution.md
+++ b/1-js/02-first-steps/13-while-for/2-which-value-while/solution.md
@@ -9,9 +9,9 @@ L'esercizio dimostrava come le forme prefissa/postfissa possono portare a risult
 
     Il primo valore è `i = 1`, perchè `++i` incrementa prima `i` e poi ritorna il nuovo valore. Quindi il primo confronto è `1 < 5` e `alert` mostra `1`.
 
-    Poi seguono `2, 3, 4…` -- i valori vengono mostrati uno dopo l'altro. Il confroto utilizza sempre il valose incrementato, perchè `++` è posto prima della variabile.
+    Poi seguono `2, 3, 4…` -- i valori vengono mostrati uno dopo l'altro. Il confronto utilizza sempre il valore incrementato, perchè `++` è posto prima della variabile.
 
-    Ultima iterazione, `i = 4` viene incrementato a `5`, il confronto `while(5 < 5)` fallisce, e il ciclo termina. Quindi `5` non viene mostrato.
+    Ultima iterazione, `i = 4` viene incrementato a `5`, il confronto `while(5 < 5)` risulta `false`, e il ciclo termina. `5` non viene mostrato.
 
 2. **Da 1 a 5**
 
@@ -22,10 +22,10 @@ L'esercizio dimostrava come le forme prefissa/postfissa possono portare a risult
 
     Il primo valore è ancora `i = 1`. La forma postfissa `i++` incrementa `i` e ritorna il *vecchio* valore, quindi il confronto `i++ < 5` utilizza `i = 0` (a differenza di `++i < 5`).
 
-    La chiamata ad `alert` è separata. E' un istruzione che viene eseguita dopo l'incremento e il confronto. Quindi avra il valore `i = 1`.
+    La chiamata ad `alert` è separata. E' un istruzione che viene eseguita dopo l'incremento di `i` e il controllo della condizione. Quindi `i = 1`.
 
     Seguono `2, 3, 4…`
 
-    Fermiamoci a `i = 4`. La forma prefissa `++i` incrementerebbe ed utilizzerebbe `5` nel confronto. Qui però stiamo usando la forma postfissa `i++`. Quindi incrementa `i`a `5`, ma ritorna il vecchio valore. Il confronto è `while(4 < 5)` -- vero, il controllo passa alla chiamata `alert`.
+    Fermiamoci a `i = 4`. La forma prefissa `++i` incrementerebbe ed utilizzerebbe `5` nel controllo della condizione `i < 5`. Qui però stiamo usando la forma postfissa `i++`. Quindi incrementa `i`a `5`, ma ritorna il vecchio valore. Il confronto è dunque `while(4 < 5)` -- vero; il controllo passa alla chiamata `alert`.
 
-    Il valore `i = 5` è l'ultimo, perchè nello step successivo avremmo `while(5 < 5)` che è falso.
+    Il valore `i = 5` è l'ultimo, perchè nell'iterazione successiva avremmo `while(5 < 5)` e la condizione sarebbe falsa.
diff --git a/1-js/02-first-steps/13-while-for/2-which-value-while/task.md b/1-js/02-first-steps/13-while-for/2-which-value-while/task.md
index ee3673159..23651c039 100644
--- a/1-js/02-first-steps/13-while-for/2-which-value-while/task.md
+++ b/1-js/02-first-steps/13-while-for/2-which-value-while/task.md
@@ -2,11 +2,11 @@ importance: 4
 
 ---
 
-# Quali valori mostra il ciclo while?
+# Quali valori mostrerà il ciclo while?
 
-Per ogni iterazione del ciclo, scrivi quali valori vengono mostrati e poi confrontali alla soluzione.
+Per ogni iterazione del ciclo, scrivi quali valori verranno mostrati e poi confrontali con la soluzione.
 
-Entrambi i cicli mostrano gli stessi valori in `alert`, o no?
+Entrambi i cicli mostreranno gli stessi valori in `alert`, o no?
 
 1. La forma prefissa `++i`:
 
diff --git a/1-js/02-first-steps/13-while-for/3-which-value-for/solution.md b/1-js/02-first-steps/13-while-for/3-which-value-for/solution.md
index 62dcfe315..6da255a83 100644
--- a/1-js/02-first-steps/13-while-for/3-which-value-for/solution.md
+++ b/1-js/02-first-steps/13-while-for/3-which-value-for/solution.md
@@ -6,12 +6,12 @@ for (let i = 0; i < 5; ++i) alert( i );
 for (let i = 0; i < 5; i++) alert( i );
 ```
 
-Questo può eserre facilmete dedotto dall'algoritmo  `for`:
+Questo può essere facilmente dedotto dall'algoritmo  `for`:
 
-1. Esegue un asola volta `i = 0` come prima cosa (begin)
+1. Esegue come prima cosa `i = 0` (una sola volta)
 2. Verifica la condizione `i < 5`
-3. Se è `true` -- esegue il corpo del ciclo `alert(i)`, successivamente `i++`
+3. Se è `true` -- esegue il corpo del ciclo, dove si trova `alert(i)`, poi incrementa `i` di 1
 
-L'incremento `i++` è separato dal controllo della condizione(2). E' un istruzione differente.
+L'incremento `i++` è separato dal controllo della condizione(2). E' un'istruzione differente.
 
 Il valore ritornato non viene utilizzato, quindi non c'è differenza tra `i++` e `++i`.
diff --git a/1-js/02-first-steps/13-while-for/3-which-value-for/task.md b/1-js/02-first-steps/13-while-for/3-which-value-for/task.md
index b3c086e15..8a7508673 100644
--- a/1-js/02-first-steps/13-while-for/3-which-value-for/task.md
+++ b/1-js/02-first-steps/13-while-for/3-which-value-for/task.md
@@ -2,11 +2,11 @@ importance: 4
 
 ---
 
-# Quali valori verrano mostrati dal ciclo "for"?
+# Quali valori verranno mostrati dal ciclo "for"?
 
 Per ogni ciclo scrivete quali valori verranno mostrati. Poi confrontateli con la soluzione.
 
-Entrambi gli `alert` mostrano gli stessi valori?
+I due `alert` mostreranno gli stessi valori?
 
 1. Forma postfissa:
 
diff --git a/1-js/02-first-steps/13-while-for/4-for-even/solution.md b/1-js/02-first-steps/13-while-for/4-for-even/solution.md
index ff49375db..fc7287a14 100644
--- a/1-js/02-first-steps/13-while-for/4-for-even/solution.md
+++ b/1-js/02-first-steps/13-while-for/4-for-even/solution.md
@@ -8,4 +8,4 @@ for (let i = 2; i <= 10; i++) {
 }
 ```
 
-Utilizziamo l'operatore modulo `%` per ottenre il resto e controllare la parità.
+Utilizziamo l'operatore modulo `%` per controllare che un numero sia pari.
diff --git a/1-js/02-first-steps/13-while-for/4-for-even/task.md b/1-js/02-first-steps/13-while-for/4-for-even/task.md
index 4d063c6c9..478378edc 100644
--- a/1-js/02-first-steps/13-while-for/4-for-even/task.md
+++ b/1-js/02-first-steps/13-while-for/4-for-even/task.md
@@ -2,8 +2,8 @@ importance: 5
 
 ---
 
-# Stampare i numeri pari con un ciclo
+# Mostra i numeri pari con un ciclo 'for'
 
-Utilizzate il ciclo `for` per stampare i numeri pari da `2` a `10`.
+Utilizzate il ciclo `for` per mostrare i numeri pari da `2` a `10`.
 
 [demo]
diff --git a/1-js/02-first-steps/13-while-for/5-replace-for-while/task.md b/1-js/02-first-steps/13-while-for/5-replace-for-while/task.md
index 662d303ff..af597477a 100644
--- a/1-js/02-first-steps/13-while-for/5-replace-for-while/task.md
+++ b/1-js/02-first-steps/13-while-for/5-replace-for-while/task.md
@@ -4,7 +4,7 @@ importance: 5
 
 # Sostituisci "for" con "while"
 
-Riscrivi il codice cambiando il ciclo `for` con `while` senza modificare il comportamento (l'output deve rimanere lo stesso).
+Riscrivi il ciclo `for` utilizzando la sintassi `while`, ma senza alterarne la funzionalità (l'output deve rimanere lo stesso).
 
 ```js run
 for (let i = 0; i < 3; i++) {
diff --git a/1-js/02-first-steps/13-while-for/6-repeat-until-correct/solution.md b/1-js/02-first-steps/13-while-for/6-repeat-until-correct/solution.md
index 5646678c4..edcafbc09 100644
--- a/1-js/02-first-steps/13-while-for/6-repeat-until-correct/solution.md
+++ b/1-js/02-first-steps/13-while-for/6-repeat-until-correct/solution.md
@@ -7,9 +7,9 @@ do {
 } while (num <= 100 && num);
 ```
 
-Il ciclo `do..while` si ripete fino a chè entrambe le condizioni non risultano vere:
+Il ciclo `do..while` si ripete fintanto che entrambe le condizioni non risultano vere:
 
-1. Il controllo `num <= 100` -- controlla se il valore non risulta ancora maggiore di `100`.
-2. Il controllo `&& num` è falso quando `num` è `null` o una stringa. Quindi il ciclo `while` termina.
+1. Il controllo `num <= 100` -- controlla se il valore non risulti ancora maggiore di `100`.
+2. Il controllo `&& num` diventa falso quando `num` è `null` o una stringa. Quindi il ciclo `while` termina.
 
-P.S. Se `num` è `null` allora la condizione `num <= 100` è `true`, quindi senza il secondo controllo il ciclo non terminerebbe nel caso in cui l'utente prema CANCEL. Entrambi i controlli sono necessari.
+P.S. Se `num` è `null` allora la condizione `num <= 100` è `true`, quindi senza la seconda condizione il ciclo non terminerebbe nel caso in cui l'utente prema CANCEL. Entrambe le condizioni sono necessarie.
diff --git a/1-js/02-first-steps/13-while-for/6-repeat-until-correct/task.md b/1-js/02-first-steps/13-while-for/6-repeat-until-correct/task.md
index 30fb305e9..0a23a64f8 100644
--- a/1-js/02-first-steps/13-while-for/6-repeat-until-correct/task.md
+++ b/1-js/02-first-steps/13-while-for/6-repeat-until-correct/task.md
@@ -2,12 +2,12 @@ importance: 5
 
 ---
 
-# Ripeti fino a trovare un input corretto 
+# Ripeti fino a quando l'input è corretto 
 
-Scrivi un ciclo che richieda (prompt) un numero maggiore di `100`. Se l'utente inserisce un numero non valido -- chiedete di inserirlo nuovamente.
+Scrivi un ciclo che richieda (tramite *prompt*) un numero maggiore di `100`. Se l'utente inserisce un numero non valido -- chiedete di inserirlo nuovamente.
 
-Il ciclo deve continuare a richiede un numero fino a chè l'utente non inserisce un numero maggiore di `100`, oppure annulla l'input sia premendo cancel, che inserendo una riga vuota.
+Il ciclo deve continuare a richiede un numero fintanto che l'utente non inserisce un numero maggiore di `100`, oppure annulla l'input (sia premendo *cancel* che inserendo una riga vuota).
 
-Possiamo assumere che l'utente inserisca solo numeri. Non c'è quindi bisogno di implementare alcun tipo di gestione per un input di tipo non numerico.
+Possiamo assumere che l'utente inserisca solo numeri. Non c'è quindi bisogno di implementare alcun tipo di logica per un input di tipo non numerico.
 
 [demo]
diff --git a/1-js/02-first-steps/13-while-for/7-list-primes/solution.md b/1-js/02-first-steps/13-while-for/7-list-primes/solution.md
index 2fb8dcccc..0816bca21 100644
--- a/1-js/02-first-steps/13-while-for/7-list-primes/solution.md
+++ b/1-js/02-first-steps/13-while-for/7-list-primes/solution.md
@@ -1,4 +1,4 @@
-Ci sono diversi algoritmi per compiere questa attività.
+Ci sono diversi possibili algoritmi per il nostro scopo.
 
 Usiamo un ciclo annidato:
 
@@ -10,20 +10,20 @@ For each i in the interval {
 }
 ```
 
-Il codice usa un etichetta:
+Il codice usa un'etichetta:
 
 ```js run
 let n = 10;
 
 nextPrime:
-for (let i = 2; i <= n; i++) { // for each i...
+for (let i = 2; i <= n; i++) { // per ogni i...
 
-  for (let j = 2; j < i; j++) { // look for a divisor..
-    if (i % j == 0) continue nextPrime; // not a prime, go next i
+  for (let j = 2; j < i; j++) { // controlla i suoi divisori..
+    if (i % j == 0) continue nextPrime; // se è divisibile per uno di essi, non è un numero primo; passa a prossima iterazione
   }
 
-  alert( i ); // a prime
+  alert( i ); // un numero primo
 }
 ```
 
-Ci sono molti modi per ottimizzarlo. Ad esempio, potremmo controllare i divisori di `2` fino alla radice di `i`. In ogni caso, se vogliamo essere veramete efficenti su grandi intervalli, abbiamo bisogno di cambiare approcio ed affidarci ad algoritmi matematici più avanzati e complessi, come [Quadratic sieve](https://en.wikipedia.org/wiki/Quadratic_sieve), [General number field sieve](https://en.wikipedia.org/wiki/General_number_field_sieve) etc.
+Ci sono molti modi per ottimizzare questo algoritmo. Ad esempio, potremmo controllare i divisori di `2` fino alla radice di `i`. In ogni caso, se vogliamo essere veramete efficenti su grandi intervalli, abbiamo bisogno di cambiare approcio ed affidarci ad algoritmi matematici più avanzati e complessi, come [Quadratic sieve](https://en.wikipedia.org/wiki/Quadratic_sieve), [General number field sieve](https://en.wikipedia.org/wiki/General_number_field_sieve) etc.
diff --git a/1-js/02-first-steps/13-while-for/7-list-primes/task.md b/1-js/02-first-steps/13-while-for/7-list-primes/task.md
index b1bf39844..a02590992 100644
--- a/1-js/02-first-steps/13-while-for/7-list-primes/task.md
+++ b/1-js/02-first-steps/13-while-for/7-list-primes/task.md
@@ -2,15 +2,15 @@ importance: 3
 
 ---
 
-# Stampare i numeri primi
+# Mostra i numeri primi
 
-Un valore intero maggiore di `1` si definisce [primo](https://en.wikipedia.org/wiki/Prime_number) se non può essere diviso, senza resto, da nessun numero ad eccezione di `1` e se stesso.
+Un valore intero maggiore di `1` si definisce [primo](https://it.wikipedia.org/wiki/Numero_primo) se non può essere diviso, senza [resto](https://it.wikipedia.org/wiki/Resto), da nessun numero ad eccezione di `1` e se stesso.
 
 In altre parole, `n > 1` è primo se non può essere diviso da nessun altro numero ad eccezione di `1` e `n`.
 
-Ad esempio, `5` è primo, perchè non può essere diviso senza resto da `2`, `3` e `4`.
+Ad esempio, `5` è primo perchè non può essere diviso senza resto da `2`, `3` o `4`.
 
-**scrivi un codice che stampa i numeri primi nell'interballo da `2` a `n`.**
+**scrivi un codice che mostri i numeri primi nell'intervallo da `2` a `n`.**
 
 Per `n = 10` il risultato sarà `2,3,5,7`.
 
diff --git a/1-js/02-first-steps/13-while-for/article.md b/1-js/02-first-steps/13-while-for/article.md
index 8dc0f1094..a04ab6817 100644
--- a/1-js/02-first-steps/13-while-for/article.md
+++ b/1-js/02-first-steps/13-while-for/article.md
@@ -2,9 +2,9 @@
 
 Abbiamo spesso bisogno di eseguire la stessa azione più volte di fila.
 
-Ad esempio, quando abbiamo bisogno di ritornare della merce da una lista una dopo l'altra. O anche solo eseguire lo stesso codice per ogni numero da 1 a 10.
+Ad esempio, quando abbiamo bisogno di ritornare, una dopo l'altra, della merce da una lista; o anche solo eseguire lo stesso codice per ogni numero da 1 a 10.
 
-I *Cicli* sono un modo di ripetere la stessa parte di codice più volte.
+I *cicli* sono un modo di ripetere una stessa parte di codice più volte.
 
 ## Il ciclo "while" 
 
@@ -17,9 +17,9 @@ while (condition) {
 }
 ```
 
-Fino a che la `condition` è `true`, il `code` dal corpo del ciclo viene eseguito.
+Fino a che la `condition` è `true`, il `code` nel corpo del ciclo viene eseguito.
 
-Ad esempio, il ciclo qui sotto stampa `i` fino a che `i < 3`:
+Ad esempio, il ciclo qui sotto mostra `i` fino a che `i < 3`:
 
 ```js run
 let i = 0;
@@ -29,11 +29,11 @@ while (i < 3) { // mostra 0, poi 1, poi 2
 }
 ```
 
-Una singola esecuzione del corpo del ciclo viene chiamata *un iterazione*. Il ciclo nell'esempio sopra fa tre iterazioni.
+Un'esecuzione del codice nel corpo del ciclo viene chiamata *un'iterazione*. Il ciclo nell'esempio sopra fa tre iterazioni.
 
-Se nell'esempio sopra non ci fosse `i++`, il ciclo si ripeterebbe per sempre (in teoria). Nella pratica, il browser ha dei metodi per bloccare questi cicli, con JavaScript server-side è necessario arrestare il processo.
+Se nell'esempio sopra non ci fosse `i++`, il ciclo si ripeterebbe per sempre; in teoria: in pratica, il browser ha dei metodi per bloccare questi cicli. In JavaScript server-side è necessario arrestare il processo.
 
-Qualsiasi espressione o variabile può essere utilizzata come condizione di un ciclo, non solo un confronto. Le espressioni vengono valutate e convertite al tipo bool dal ciclo `while`.
+Qualsiasi espressione o variabile può essere utilizzata come condizione di un ciclo, non solo un confronto come `i < 3`. Il ciclo `while` converte le espressioni al tipo booleano, che vengono poi valutate.
 
 Ad esempio, un modo più breve di scrivere `while (i != 0)` potrebbe essere `while (i)`:
 
@@ -47,7 +47,7 @@ while (i) { // quando i diventa 0, la condizione diventa falsa e il ciclo si con
 }
 ```
 
-````smart header="Le parentesi non sono richieste per un corpo composto da una singola linea"
+````smart header="Le parentesi non sono richieste per un corpo composto da una singola linea di codice"
 Se il corpo del ciclo ha una singola istruzione, possiamo omettere le parentesi `{…}`:
 
 ```js run
@@ -60,7 +60,7 @@ while (i) alert(i--);
 
 ## Il ciclo "do..while" 
 
-La condizione da controllare può essere messa *dopo* il corpo del ciclo utilizzando la sintassi `do..while`:
+La condizione da controllare può essere messa *dopo* il corpo del ciclo. Lo si fa utilizzando la sintassi `do..while`:
 
 ```js
 do {
@@ -68,7 +68,7 @@ do {
 } while (condition);
 ```
 
-Il ciclo esegue prima il corpo, poi controlla la condizione, se questa è vera, esegue nuovamente il corpo.
+Il ciclo esegue prima il corpo, poi controlla la condizione; se questa è vera, esegue nuovamente il corpo.
 
 Ad esempio:
 
@@ -80,21 +80,21 @@ do {
 } while (i < 3);
 ```
 
-Questa tipo di sintassi viene usata molto raramente ad eccezione dei casi in cui si vuole che il corpo del ciclo venga eseguito **almeno una volta** senza controllo sulla condizione. La forma più utilizzata è comunque: `while(…) {…}`.
+Questa tipo di sintassi viene usata molto raramente, ad eccezione dei casi in cui si vuole che il corpo del ciclo venga eseguito **almeno una volta**. Questo avviene ancor *prima* del controllo della condizione. La forma più comune, comunque, è `while(…) {…}`.
 
 ## Il ciclo "for" 
 
-Il ciclo `for` è spesso il più utilizzato.
+Il ciclo `for` è forse il più utilizzato.
 
-La sua forma è del tipo:
+La sua sintassi è:
 
 ```js
 for (begin; condition; step) {
   // ... corpo del ciclo ...
 }
 ```
-
-Cerchiamo ora di capire il significato tramite degli esempi. Il ciclo sotto esegue `alert(i)` per `i` da `0` fino a (ma non incluso) `3`:
+Cerchiamo ora di capire, tramite esempi, il suo funzionamento. 
+Il ciclo sotto esegue `alert(i)` fino a quando la variabile `i` è più piccola di 3. A ogni iterazione, il valore di `i` aumenta di 1.
 
 ```js run
 for (let i = 0; i < 3; i++) { // mostra 0, poi 1, poi 2
@@ -106,12 +106,12 @@ Esaminiamo l'istruzione `for` parte per parte:
 
 | Parte |          |                                                                            |
 |-------|----------|----------------------------------------------------------------------------|
-| begin | `i = 0`    | Viene eseguito una volta all'entrata nel ciclo.                          |
-| condition | `i < 3`| Viene controllata prima di ogni iterazione del ciclo, se fallisce il ciclo si interrompe.|
-| body | `alert(i)`| Viene eseguito fino a che vale la condizione.
-| step| `i++`      | Viene eseguito prima del corpo ad ogni iterazione, ma dopo il controllo della condizione.|
+| begin | `i = 0`    | Viene eseguito una volta sola, all'entrata nel ciclo.                          |
+| condition | `i < 3`| Viene controllata prima di ogni iterazione; se falsa, il ciclo si interrompe.|
+| body | `alert(i)`| Viene eseguito fino a quando la condizione è vera.
+| step| `i++`      | Viene eseguito ad ogni iterazione, dopo il corpo, fintato che la condizione è `true`.|
 
-L'iterazione generalmente funziona nel seguente modo:
+L'iterazione, generalmente, funziona nel modo seguente:
 ```
 Eseguiamo begin
 → (if condition → run body and run step)
@@ -120,37 +120,37 @@ Eseguiamo begin
 → ...
 ```
 
-Quindi, `begin` viene eseguito una volta sola, dopo inizia il processo di iterazione: dopo ogni test della `condition`, vengono eseguiti `body` e `step`.
+Ricapitolando: `begin` viene eseguito per primo, *una volta sola*; subito dopo, inizia l'iterazione. Se `condition`, dopo la conversione a booleano, è `true`, vengono eseguiti `body` e `step`; se è `false`, il ciclo si interrompe. 
 
-Se i cicli vi sono nuovi, allora forse vi sarà d'aiuto tornare indietro agli esempi e provare a riprodurli passo-passo su un foglio di carta.
+Se i cicli vi sono nuovi, forse vi sarà d'aiuto tornare indietro agli esempi e provare a riprodurli, passo passo, su un foglio di carta.
 
-Questo è quello che succede esattamente nel nostro codice:
+Ecco esattamente, in dettaglio, ciò che avviene nel nostro codice:
 
 ```js
 // for (let i = 0; i < 3; i++) alert(i)
 
-// inizia l'esecuzione
+// inizia l'esecuzione, viene dichiarata la variabile i
 let i = 0
-// if condition → esegue il corpo e avanza
+// if(condition == true) → esegue il corpo e avanza
 if (i < 3) { alert(i); i++ }
-// if condition → esegue il corpo e avanza
+// if(condition == true) → esegue il corpo e avanza
 if (i < 3) { alert(i); i++ }
-// if condition → esegue il corpo e avanza
+// if(condition == true) → esegue il corpo e avanza
 if (i < 3) { alert(i); i++ }
-// ...si conclude, perché ora i == 3
+// ...si conclude, perché ora i == 3 e la condizione i < 3 == false
 ```
 
 ````smart header="Dichiarazioni di variabili inline"
-Qui il "counter" è una variabile `i` che viene dichiarata all'interno del ciclo. Questa viene chiamata una dichiarazione di una variabile "inline". Queste variabili sono visibile solo all'interno del ciclo.
+Qui il "counter", che utlizzeremo nella nostra *condition*, è una variabile: `i`. Viene dichiarata all'interno del corpo del ciclo ed è accessibile solo al suo interno. Questo tipo di espressione si chiama "dichiarazione di una variabile *inline*". 
 
 ```js run
-for (*!*let*/!* i = 0; i < 3; i++) {
+for (*!*let*/!* i = 0; i < 3; i++) { //'i' è definito, e accessibile, solo dentro il corpo del ciclo
   alert(i); // 0, 1, 2
 }
-alert(i); // errore, nessuna variabile
+alert(i); // errore, nessuna variabile 'i' fuori dal corpo del ciclo
 ```
 
-Invece che definire una nuova variabile, possiamo utilizzarne una già esistente:
+Invece di definire una nuova variabile, possiamo utilizzarne una già esistente:
 
 ```js run
 let i = 0;
@@ -159,7 +159,7 @@ for (i = 0; i < 3; i++) { // utilizza una variabile esistente
   alert(i); // 0, 1, 2
 }
 
-alert(i); // 3, visibile, perché è stata dichiarata fuori dal ciclo
+alert(i); // 3; la variabile `i` è accessibile (è stata dichiarata fuori dal corpo del ciclo)
 ```
 
 ````
@@ -167,16 +167,16 @@ alert(i); // 3, visibile, perché è stata dichiarata fuori dal ciclo
 
 ### Parti opzionali
 
-Ogni parte del `for` può essere saltata.
+Ogni parte del `for` è opzionale.
 
-Ad esempio, possiamo omettere `begin` se non abbiamo bisogno di fare niente all'inizio del ciclo.
+Ad esempio, possiamo omettere `begin` se non abbiamo bisogno di una variabile per la nostra `condition`.
 
 Come in questo esempio:
 
 ```js run
-let i = 0; // la abbiamo già dichiarata e assegnata
+let i = 0; // la variabile 'i' è stata già dichiarata e assegnata
 
-for (; i < 3; i++) { // non c'è alcun bisogno di "begin"
+for (; i < 3; i++) { // saltiamo "begin"
   alert( i ); // 0, 1, 2
 }
 ```
@@ -187,29 +187,29 @@ Possiamo anche rimuovere lo`step`:
 let i = 0;
 
 for (; i < 3;) {
-  alert( i++ );
+  alert( i++ ); //la variabile 'i' viene incrementata nel corpo del ciclo
 }
 ```
 
-Il ciclo diventa uguale ad un `while (i < 3)`.
+Il ciclo, nell'esempio sopra, diventa uguale ad un `while (i < 3)`.
 
-Possiamo rimuovere tutto, questo genererà un ciclo infinito:
+Possiamo rimuovere tutto, ma questo risulterebbe in un ciclo infinito:
 
 ```js
 for (;;) {
-  // ripete senza terminare
+  // esegue il corpo del ciclo senza mai terminare
 }
 ```
 
-Nota che le due `;` del ciclo `for` devono essere presenti, altrimenti sarebbe un errore di sintassi.
+Nota che le due `;` del ciclo `for` devono essere presenti, altrimenti vi sarebbe un errore di sintassi.
 
 ## Interrompere un ciclo 
 
 Normalmente un ciclo termina quando la condizione diventa falsa.
 
-Ma è possibile forzare l'uscita in qualsiasi momento. C'è una speciale direttiva `break` per fare questo.
+Ma è possibile forzare l'uscita in qualsiasi momento. C'è una speciale direttiva per fare questo: `break`.
 
-Ad esempio, il ciclo sotto chiede all'utente una serie di numeri, ma "termina" quando nessun numero viene inserito: 
+Ad esempio, il ciclo sotto richiede all'utente una serie di numeri, e termina quando nessun numero viene inserito: 
 
 ```js run
 let sum = 0;
@@ -228,50 +228,48 @@ while (true) {
 alert( 'Sum: ' + sum );
 ```
 
-La direttiva `break` viene attivata alla linea `(*)` se l'utente inserisce una linea vuota o annulla la procedura di input. Questo fermerà il ciclo immediatamente, passando il controllo alla prima linea successiva al ciclo. In questo caso, `alert`.
+La direttiva `break` viene attivata alla linea `(*)`, quando l'utente inserisce una linea vuota o annulla la procedura di input. Questo ferma il ciclo immediatamente, passando il controllo alla prima linea successiva al ciclo. In questo caso, `alert`.
 
-La combinazione "ciclo infinito + `break` quando necessario" è ottima per le situazioni in cui la condizione deve essere verificata in un punto differente dall'inizio/fine del ciclo, che può essere a metà, o in qualsiasi altro punto del corpo.
+La combinazione "ciclo infinito + `break` quando necessario" è utile in situazioni in cui la condizione deve essere verificata in un punto differente dall'inizio/fine del ciclo (questo può avvenire in un qualsiasi altro punto del corpo).
 
 ## Vai alla prossima iterazione [#continue]
 
-La direttiva `continue` è una versione leggera del `break`. Non blocca l'intero ciclo. Invece interrompe solo l'iterazione corrente e forza il ciclo a reiniziare dall'iterazione successiva (se la condizione è soddisfatta).
+La direttiva `continue` è una versione leggera del `break`. Non blocca l'intero ciclo: interrompe solo l'iterazione corrente e forza il ciclo a passare all'iterazione successiva.
 
-Possiamo utilizzarla se abbiamo finito con le operazioni che ci interessano in una data iterazione e vogliamo passare a quella seguente.
+Possiamo utilizzarla se abbiamo finito con le operazioni che ci interessano e vogliamo passare all'iterazione seguente.
 
-Il ciclo sotto usa `continue` per ritornare i valori dispari:
+Il ciclo sotto usa `continue` per ritornare *solo* i valori dispari:
 
 ```js run no-beautify
 for (let i = 0; i < 10; i++) {
 
-  // se è true, salta la restante parte di codice
+  // se condizione == true (`i` è pari) salta la restante parte di codice a passa alla prossima iterazione
   *!*if (i % 2 == 0) continue;*/!*
-
-  alert(i); // 1, poi 3, 5, 7, 9
+  //se `i` è dispari, esegui codice
+  alert(i); // 1, poi 3, 5, 7, 9 (nota le due condizioni sopra: abbiamo solo i con un valore dispari, e inferiore a 10)
 }
 ```
 
-Per i valori pari di `i`, la direttiva `continue` interrompe l'esecuzione del corpo e passa il controllo alla successiva iterazione del `for` (con il numero successivo). Quindi l'`alert` viene chiamato solo con i valori dispari.
+Per i valori pari di `i` la direttiva `continue` interrompe l'esecuzione del corpo e passa il controllo alla successiva iterazione del `for` (`i` viene incrementato, poi si controlla che la condizione sia true). Di conseguenza, l'`alert` viene seguito solo con i valori dispari.
 
 ````smart header="La direttiva `continue` aiuta a diminuire i livelli di nidificazione"
-Un ciclo che mostra i valori dispari potrebbe essere:
+Un ciclo che mostra *solo* valori dispari potrebbe essere:
 
 ```js run
 for (let i = 0; i < 10; i++) {
 
-  if (i % 2) {
+  if (i % 2) { //la condizione == 0 quando un numero è pari; 0, ricordiamo, convertito a booleano, è false
     alert( i );
   }
 
 }
 ```
 
-Dal punto di vista tecnico è identico all'esempio sopra. Ovviamente possiamo raccogliere il codice in un blocco `if` piuttosto di usare `continue`.
-
-Ma come effetto collaterale abbiamo aggiunto un livello di annidamento ulteriore (la chiamata `alert` all'interno delle parentesi graffe). Se il codice dentro `if` è più lungo di un paio di righe, si rischia di perdere in leggibilità.
+Ovviamente possiamo raccogliere il codice in un blocco `if` piuttosto di usare `continue`. Dal punto di vista tecnico l'esempio sopra è identico a quello che lo precede, che invece utilizza `continue`. Nell'esempio sopra il codice dentro il corpo di `if` è una semplice chiamata ad `alert`; ma se il codice fosse più lungo di un paio di righe si rischierebbe di perdere in leggibilità.
 ````
 
 ````warn header="Vietato `break/continue` alla desta di '?'"
-Da notare che questo costrutto sintattico non è un espressione e non può quindi essere utilizzato con l'operatore ternario `?`. In particolare, direttive come  `break/continue` non sono concesse.
+Va notato che questo costrutto sintattico non è un espressione e non può quindi essere utilizzato con l'operatore ternario `?`. In particolare, direttive come  `break/continue` non sono permesse.
 
 Ad esempio, se prendiamo questo codice:
 
@@ -290,17 +288,18 @@ if (i > 5) {
 (i > 5) ? alert(i) : *!*continue*/!*; // continue non è consentito qui
 ```
 
-...Questo smetterà di funzionare. Codice scritto cosi vi darà un errore di sintassi:
+...Questo smetterà di funzionare. Un codice come quello sopra risulterà in un errore di sintassi:
 
 
-Questa è solo un'altra ragione per cui non utilizzare l'operatore ternario `?` piuttosto che `if`.
+Questa è solo un'altra ragione per cui non utilizzare l'operatore ternario `?` piuttosto di `if`.
 ````
 
 ## Etichette break/continue
 
-Qualche volta abbiamo bisogno di uscire da una serie di cicli annidati in un colpo solo.
+Qualche volta abbiamo bisogno di uscire da una serie di cicli annidati in un *colpo solo*.
 
-Ad esempio, nel codice sotto cicliamo su `i` e `j` eseguendo prompt sulle coordinate `(i, j)` da `(0,0)` a `(3,3)`:
+Ad esempio, nel codice sotto abbiamo due cicli `for` che usano `(i, j)` nelle proprie condizioni; fino a quando le variabili sono minori di 3, il ciclo viene eseguito; dentro al ciclo più interno un prompt mostra le due variabili 
+`(i, j)` in una stringa di testo:
 
 ```js run no-beautify
 for (let i = 0; i < 3; i++) {
@@ -319,16 +318,16 @@ alert('Done!');
 
 Abbiamo bisogno di un modo per bloccare il processo se l'utente annulla l'input.
 
-Un semplice `break` dopo `input` interromperebbe solo il break interno. Questo non è sufficiente. Le etichette ci vengono in soccorso.
+Un semplice `break` dopo la variabile `input` interromperebbe solo il ciclo più interno. Questo non è sufficiente. I *label* ci vengono in soccorso.
 
-Una *label* (etichetta) è un identificatore seguito da ":" posti prima di un ciclo:
+Un *label* ("etichetta") è un identificatore seguito da ":" e da un ciclo:
 ```js
 labelName: for (...) {
   ...
 }
 ```
 
-L'istruzione `break <labelName>` nel ciclo uscirà fino alla label.
+L'istruzione `break <labelName>` interrompe il ciclo e passa il controllo a *label*.
 
 Come nell'esempio:
 
@@ -348,7 +347,7 @@ Come nell'esempio:
 alert('Done!');
 ```
 
-Nel codice sopra `break outer` va alla ricerca della label (etichetta) chiamata `outer` ed esce dal ciclo.
+Nel codice sopra `break outer` interrompoe il ciclo e va all'etichetta chiamata `outer`.
 
 Quindi il controllo va da `(*)` a `alert('Done!')`.
 
@@ -361,29 +360,29 @@ for (let i = 0; i < 3; i++) { ... }
 
 Anche la direttiva `continue` può essere utilizzata con un'etichetta. In questo caso l'esecuzione salta alla prossima iterazione del ciclo con quell'etichetta.
 
-````warn header="Label non equivalgono a \"goto\""
-Le Label non permettono di saltare in un punto arbitrario del codice.
+````warn header="I *label* non equivalgono a \"goto\""
+I *label* non permettono di saltare in un punto arbitrario del codice.
 
-Ad esempio, non è possibile fare:
+Ad esempio, non è possibile:
 ```js
 break label;  // non salta all'etichetta sotto
 
 label: for (...)
 ```
 
-La chiamata a `break/continue` è possibile solo dall'interno di un ciclo, e l'etichetta deve essere da qualche parte sopra la chiamata.
+La chiamata a `break/continue` è possibile solo dall'interno di un ciclo, e l'etichetta deve essere da qualche parte **sopra** la chiamata.
 ````
 
-## Summary
+## Riepilogo
 
-Abbiamo coperto 3 tipi di cicli:
+Abbiamo visto tre tipi di cicli:
 
 - `while` -- La condizione viene controllata prima di ogni iterazione.
-- `do..while` -- La condizione viene controllata dopo ogni iterazione.
-- `for (;;)` -- La condizione viene controllata prima di ogni iterazione, rende disponibili ulteriori controlli.
+- `do..while` -- La condizione viene controllata dopo una prima iterazione.
+- `for (;;)` -- La condizione viene controllata prima di ogni iterazione; sono possibili altre condizioni all'interno del ciclo.
 
 Per crere un ciclo infinito, si usa il costrutto `while(true)`. Questo tipo di cicli, come tutti gli altri, possono essere interrotti con la direttiva `break`.
 
-Se non si ha più intenzione di fare nulla nell'iterazione corrente e si vuole quindi saltare alla successiva, la direttiva `continue` lo consente.
+Se non si ha più intenzione di fare nulla nell'iterazione corrente e si vuole quindi saltare alla successiva, possiamo usare la direttiva `continue`.
 
-`break/continue` supportano le etichette prima del ciclo. Un etichetta è l'unico modo per `break/continue` di uscire da cicli annidati ed andare al ciclo esterno.
+`break/continue` supportano le etichette prima del ciclo. Un etichetta è l'unico modo per `break/continue` di uscire da cicli annidati ed arrivare ciclo esterno.