From e8e227619bcfcf589d93a4cd2e8a00f1dde2da10 Mon Sep 17 00:00:00 2001
From: Dorin-David <70648503+Dorin-David@users.noreply.github.com>
Date: Thu, 21 Jan 2021 11:27:41 +0100
Subject: [PATCH 01/23] Update article.md

---
 .../11-logical-operators/article.md           | 30 +++++++++----------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/1-js/02-first-steps/11-logical-operators/article.md b/1-js/02-first-steps/11-logical-operators/article.md
index 5fda35104..ebdf8b1ae 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -1,8 +1,8 @@
 # Operatori logici
 
-In JavaScript ci sono tre operatori logici: `||` (OR), `&&` (AND), `!` (NOT).
+In JavaScript ci sono tre operatori logici: `||` (OR), `&&` (AND), e `!` (NOT).
 
-Nonostante si chiamino "logici", possono essere applicati a valori di qualsiasi tipo, non solo ai booleani. Il risultato stesso può essere di qualunque tipo.
+Nonostante si chiamino "logici", possono essere applicati a valori di qualsiasi tipo, non solo ai booleani. Il risultato può essere di qualunque tipo.
 
 Vediamoli nei dettagli.
 
@@ -16,7 +16,7 @@ result = a || b;
 
 Nella programmazione classica, l'OR logico è pensato per manipolare solo tipi booleani. Se almeno un argomento è `true`, allora il risultato sarà `true`, altrimenti sarà `false`.
 
-In JavaScript questo operatore è un pò più potente. Ma prima guardiamo come si comporta con valori booleani.
+In JavaScript questo operatore è un pò più potente. Ma prima vediamo come si comporta con i valori booleani.
 
 Ci sono quattro combinazioni logiche possibili:
 
@@ -29,9 +29,9 @@ alert( false || false ); // false
 
 Come possiamo vedere, il risultato è sempre `true` tranne nei casi in cui entrambi gli operandi sono `false`.
 
-Se un operando non è booleano, allora viene convertito in booleano per essere valutato.
+Se un operando non è booleano viene convertito per essere valutato.
 
-Ad esempio, il numero `1` viene visto come `true`, il numero `0` -- come `false`:
+Ad esempio, il numero `1` viene considerato come `true`, il numero `0` come `false`:
 
 ```js run
 if (1 || 0) { // funziona proprio come ( true || false )
@@ -68,9 +68,9 @@ if (hour < 10 || hour > 18 || isWeekend) {
 
 La logica descritta sopra è ovvia. Adesso proviamo ad addentrarci in qualche caratteristica "extra" di JavaScript.
 
-Si può estendere l'algoritmo come segue:
+Si può estendere l'algoritmo come segue.
 
-Dando molti valori tramite OR:
+Dati svariati operandi: 
 
 ```js
 result = value1 || value2 || value3;
@@ -79,12 +79,12 @@ result = value1 || value2 || value3;
 L'operatore OR `||` si comporta come segue:
 
 - Valuta gli operandi da sinistra a destra.
-- Ogni operando viene converito in booleano. Se il risultato è `true`, allora si ferma e ritorna il valore originale dell'operando.
+- Ogni operando viene convertito in booleano. Se il risultato è `true`, allora si ferma e ritorna il valore originale dell'operando.
 - Se tutti gli altri operandi sono stati valutati (ad esempio tutti erano `false`), ritorna l'ultimo operando.
 
-Un valore viene ritornato nella sua forma originale, non nella sua conversione booleana.
+**Un valore viene ritornato nella sua forma originale, non nella sua conversione booleana.
 
-In altra parole, una catena di OR `"||"` ritorna il primo valore vero, se invece non ce ne sono ritorna l'ultimo valore trovato.
+In altra parole, una catena di OR `"||"` ritorna il primo valore vero; se invece non ce ne sono ritorna l'ultimo valore trovato.
 
 Ad esempio:
 
@@ -97,13 +97,13 @@ alert( null || 0 || 1 ); // 1 (il primo valore true)
 alert( undefined || null || 0 ); // 0 (tutti falsi, ritorna l'ultimo valore)
 ```
 
-Questo ci porta ad alcuni utilizzi interessanti rispetto al "puro e classico OR booleano".boolean-only OR".
+Questo ci permette alcuni utilizzi interessanti rispetto al "puro e classico OR booleano"boolean-only OR".
 
 1. **Prelevare il primo valore vero da una lista di variabili o espressioni.**
 
-    Immaginiamo di avere diverse variabili, `firstName`, `lastName` e `nickName`, tutti opzionali (possono quindi essere undefined o avere valori falsi).
+    Immaginiamo di avere diverse variabili, `firstName`, `lastName` e `nickName`, tutte opzionali (possono quindi essere *undefined* o avere valori falsi).
 
-    Possiamo utilizzare OR `||` per selezionare quello che contiene il valore e mostrarlo (oppure mostrare `"Anonymous"` se nessun valore è settato):
+    Possiamo utilizzare OR `||` per selezionare quella che contiene un valore e mostrarlo (oppure mostrare `"Anonymous"` se nessua variabile è definita):
 
     ```js run
     let firstName = "";
@@ -119,9 +119,9 @@ Questo ci porta ad alcuni utilizzi interessanti rispetto al "puro e classico OR
 
 2. **Valutazione a Corto-Circuito.**
 
-    Gli operandi, oltre che valori, possono essere anche espressioni arbitrarie. OR valuta ed esegue i test da sinistra a destra. La valutazione si ferma al primo risultato vero, questo viene poi ritornato. Il processo è chiamato "valutazione a corto-circuito", perchè cerca di terminare il prima possibile partendo da sinistra verso destra.
+    Gli operandi, oltre che valori, possono essere anche espressioni arbitrarie. OR valuta ed esegue i test da sinistra a destra. La valutazione si ferma al primo risultato vero, che viene ritornato. Il processo è chiamato "valutazione a corto-circuito" perchè cerca di concludersi il prima possibile (quando possibile), senza aver toccato l’operando successivo. 
 
-    Questo si vede chiaramente quando il secondo argomento causerebbe side-effect. Come l'assegnazione di una variabile.
+    Questo si nota chiaramente quando il secondo argomento causerebbe un *side-effect* come l'assegnazione di una variabile o una function call.
 
     Se proviamo ad eseguire l'esempio che segue, `x` non verrà assegnata:
 

From b9df73bccfec832d63fedb35793fabc42a1d4c16 Mon Sep 17 00:00:00 2001
From: Dorin-David <70648503+Dorin-David@users.noreply.github.com>
Date: Thu, 21 Jan 2021 21:25:43 +0100
Subject: [PATCH 02/23] Update article.md

---
 .../11-logical-operators/article.md           | 38 +++++++------------
 1 file changed, 14 insertions(+), 24 deletions(-)

diff --git a/1-js/02-first-steps/11-logical-operators/article.md b/1-js/02-first-steps/11-logical-operators/article.md
index ebdf8b1ae..0ec7287b6 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -2,7 +2,7 @@
 
 In JavaScript ci sono tre operatori logici: `||` (OR), `&&` (AND), e `!` (NOT).
 
-Nonostante si chiamino "logici", possono essere applicati a valori di qualsiasi tipo, non solo ai booleani. Il risultato può essere di qualunque tipo.
+Nonostante si chiamino "logici", possono essere applicati a valori di qualsiasi tipo, non solo ai booleani (i risultati stessi possono essere di qualunque tipo).
 
 Vediamoli nei dettagli.
 
@@ -14,7 +14,7 @@ L'operatore "OR" viene rappresentato da due linee verticali:
 result = a || b;
 ```
 
-Nella programmazione classica, l'OR logico è pensato per manipolare solo tipi booleani. Se almeno un argomento è `true`, allora il risultato sarà `true`, altrimenti sarà `false`.
+Nella programmazione classica, l'OR logico è utilizzato per manipolare solo tipi booleani. Se almeno un argomento è `true`, allora il risultato sarà `true`, altrimenti sarà `false`.
 
 In JavaScript questo operatore è un pò più potente. Ma prima vediamo come si comporta con i valori booleani.
 
@@ -27,9 +27,9 @@ alert( true || false );  // true
 alert( false || false ); // false
 ```
 
-Come possiamo vedere, il risultato è sempre `true` tranne nei casi in cui entrambi gli operandi sono `false`.
+Come possiamo vedere, il risultato è sempre `true`, tranne nei casi in cui entrambi gli operandi sono `false`.
 
-Se un operando non è booleano viene convertito per essere valutato.
+Se un operando non è di tipo booleano vi viene momentaneamente convertito per la valutazione.
 
 Ad esempio, il numero `1` viene considerato come `true`, il numero `0` come `false`:
 
@@ -60,7 +60,7 @@ let hour = 12;
 let isWeekend = true;
 
 if (hour < 10 || hour > 18 || isWeekend) {
-  alert( 'The office is closed.' ); // è il fine settimana
+  alert( 'The office is closed.' ); // l'Ufficio è chiuso
 }
 ```
 
@@ -79,12 +79,12 @@ result = value1 || value2 || value3;
 L'operatore OR `||` si comporta come segue:
 
 - Valuta gli operandi da sinistra a destra.
-- Ogni operando viene convertito in booleano. Se il risultato è `true`, allora si ferma e ritorna il valore originale dell'operando.
-- Se tutti gli altri operandi sono stati valutati (ad esempio tutti erano `false`), ritorna l'ultimo operando.
+- Ogni operando viene convertito a booleano. Se il risultato è `true`, il logical OR si ferma e ritorna il valore originale dell'operando.
+- Se tutti gli operandi sono stati valutati e nessuno è `true`, ritorna l'ultimo operando.
 
 **Un valore viene ritornato nella sua forma originale, non nella sua conversione booleana.
 
-In altra parole, una catena di OR `"||"` ritorna il primo valore vero; se invece non ce ne sono ritorna l'ultimo valore trovato.
+In altre parole, una catena di OR `"||"` ritorna il primo valore vero; se invece non ce ne sono ritorna l'ultimo valore.
 
 Ad esempio:
 
@@ -99,7 +99,7 @@ alert( undefined || null || 0 ); // 0 (tutti falsi, ritorna l'ultimo valore)
 
 Questo ci permette alcuni utilizzi interessanti rispetto al "puro e classico OR booleano"boolean-only OR".
 
-1. **Prelevare il primo valore vero da una lista di variabili o espressioni.**
+1. **Trovare il primo valore vero in una lista di variabili o espressioni.**
 
     Immaginiamo di avere diverse variabili, `firstName`, `lastName` e `nickName`, tutte opzionali (possono quindi essere *undefined* o avere valori falsi).
 
@@ -119,27 +119,17 @@ Questo ci permette alcuni utilizzi interessanti rispetto al "puro e classico OR
 
 2. **Valutazione a Corto-Circuito.**
 
-    Gli operandi, oltre che valori, possono essere anche espressioni arbitrarie. OR valuta ed esegue i test da sinistra a destra. La valutazione si ferma al primo risultato vero, che viene ritornato. Il processo è chiamato "valutazione a corto-circuito" perchè cerca di concludersi il prima possibile (quando possibile), senza aver toccato l’operando successivo. 
+    Gli operandi, oltre che valori, possono essere anche espressioni arbitrarie. L'operatore OR esegue la valutazione da sinistra a destra e si ferma al primo risultato vero, che viene ritornato. Il processo è chiamato "valutazione a corto-circuito" perchè cerca di concludersi il prima possibile (quando possibile), senza aver raggiunto l’operando successivo. 
 
-    Questo si nota chiaramente quando il secondo argomento causerebbe un *side-effect* come l'assegnazione di una variabile o una function call.
-
-    Se proviamo ad eseguire l'esempio che segue, `x` non verrà assegnata:
-
-    alert(x); // undefined, perché (x = 1) non viene valutato
-    ```
-
-    Se invece il primo argomento è `false`, allora `||` prosegue e valuta il secondo, in questo caso l'assegnazione funziona:
+    Il logical OR è particolarmente utile quando il secondo argomento causerebbe un *side-effect* come l'assegnazione di una variabile o la chiamata a una funzione.
+    Nell'esempio che segue solo il secondo messaggio verrà mostrato. 
 
     ```js run no-beautify
     *!*true*/!* || alert("not printed");
     *!*false*/!* || alert("printed");
     ```
-
-    Un'assegnazione è un caso semplice. Potrebbero essere coinvolti altri tipi di side-effect.
-
-    Quello che abbiamo visto, è un "modo breve di fare `if`". Il primo operando viene convertito a booleano e solo se è falso viene eseguito il secondo.
-
-    La maggior parte delle volte è meglio utilizzare un " `if` "regolare", per mantenere il codice leggibile, in alcuni casi però può risultare utile.
+   Nella prima linea l'operatore OR trova subito un valore vero e ferma immediatamente la valutazione, quindi *alert* non viene eseguito.
+   Si può utilizzare questa funzionalità per eseguire un commando nel caso in cui la prima parte della condizione sia falsa. 
 
 ## && (AND)
 

From f80fb36244efe72d7a574f5200b12b6383c22e8b Mon Sep 17 00:00:00 2001
From: Dorin-David <70648503+Dorin-David@users.noreply.github.com>
Date: Fri, 22 Jan 2021 08:57:29 +0100
Subject: [PATCH 03/23] Update article.md

---
 .../11-logical-operators/article.md           | 27 ++++++++++---------
 1 file changed, 14 insertions(+), 13 deletions(-)

diff --git a/1-js/02-first-steps/11-logical-operators/article.md b/1-js/02-first-steps/11-logical-operators/article.md
index 0ec7287b6..68d1731a4 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -170,7 +170,7 @@ if (1 && 0) { // valutato come true && false
 
 ## AND "&& trova il primo valore falso
 
-Fornire più valori AND:
+Dati svariati operandi:
 
 ```js
 result = value1 && value2 && value3;
@@ -179,12 +179,12 @@ result = value1 && value2 && value3;
 L'operatore AND `&&` si comporta come segue:
 
 - Valuta gli operandi da sinistra a destra.
-- Ogni operando viene convertito in booleano. Se il risultato è `false`, si ferma e ritorna il valore originale dell'operando.
-- Se tutti gli operandi precedenti sono stati valutati (ad esempio nel caso siano tutti veri) , ritorna l'ultimo operando.
+- Ogni operando viene convertito a booleano. Se il risultato è `false`, si ferma e ritorna il valore originale dell'operando.
+- Se tutti gli operandi precedenti sono stati valutati e nessuno è `false`, ritorna l'ultimo operando.
 
-In altre parole, AND ritorna il primo valore falso se lo trova, altrimenti ritorna l'ultimo valore.
+In altre parole, AND ritorna il primo valore falso, altrimenti ritorna l'ultimo valore.
 
-Le regole sono molto simili a quelle dell'OR. La differenza è che AND ritorna il primo valore *falso* mentre OR ritorna il primo valore *VERO*.
+Le regole sono molto simili a quelle dell'OR. La differenza è che AND ritorna il primo valore *falso* mentre OR ritorna il primo valore *vero*.
 
 Esempi:
 
@@ -200,7 +200,7 @@ alert( null && 5 ); // null
 alert( 0 && "no matter what" ); // 0
 ```
 
-Possiamo anche passare diversi valori in una sola riga. Vediamo come viene ritornato il primo valore falso:
+Possiamo anche passare diversi valori in una sola riga. Nota come il primo valore falso viene ritornato non appena raggiunto:
 
 ```js run
 alert( 1 && 2 && null && 3 ); // null
@@ -215,7 +215,7 @@ alert( 1 && 2 && 3 ); // 3, l'ultimo
 ````smart header="Precedenza di AND `&&` è maggiore dell'OR `||`"
 La precedenza dell'operatore AND `&&` è maggiore di quella dell'OR `||`.
 
-Quindi il codice `a && b || c && d` esegue in maniera analoga all'espressione: `(a && b) || (c && d)`.
+Quindi il codice `a && b || c && d` è analogo all'espressione: `(a && b) || (c && d)`.
 ````
 
 ````warn header="Non rimpiazzate `if` con `||` o `&&`"
@@ -232,7 +232,7 @@ let x = 1;
 
 Le azioni nella parte destra di `&&` vengono eseguite solamente se la valutazione non si ferma prima. Cioè: solo se `(x > 0)` è vera.
 
-Quindi sostanzialmente è analogo a:
+Il codie sopra è sostanzialmente analogo a:
 
 ```js run
 let x = 1;
@@ -243,6 +243,7 @@ if (x > 0) alert( 'Greater than zero!' );
 La variante con `&&` sembra essere più corta. Ma l'istruzione `if` è più ovvia e tende ad essere più leggibile.
 
 Quindi è consigliato usare ogni costrutto solo per i suoi scopi. Usate un `if` se volete imporre una condizione. Utilizzate invece `&&` se volete un AND.
+````
 
 ## ! (NOT)
 
@@ -256,8 +257,8 @@ result = !value;
 
 L'operatore accetta un solo argomento e si comporta come segue:
 
-1. Converte l'operando al tipo booleano: `true/false`.
-2. Ritorna il valore inverso.
+1. Converte l'operando a booleano: `true/false`.
+2. Ritorna il valore **inverso.
 
 Ad esempio:
 
@@ -273,13 +274,13 @@ alert( !!"non-empty string" ); // true
 alert( !!null ); // false
 ```
 
-Quello che accade è che il primo NOT converte il tipo a booleano e ritorna il suo inverso, il secondo NOT lo inverte nuovamente. Alla fine abbiamo un valore di tipo booleano.
+Quello che accade è che il primo NOT converte l'operando a booleano e ritorna il suo inverso, e il secondo NOT lo *inverte nuovamente*. Il risultato è un valore di tipo booleano.
 
-C'è un modo molto più lungo per fare la stessa cosa -- una funzione del linguaggio `Boolean`:
+C'è un modo molto più lungo per fare la stessa cosa -- una funzione *built-in* di `Boolean`:
 
 ```js run
 alert( Boolean("non-empty string") ); // true
 alert( Boolean(null) ); // false
 ```
 
-La precedenza del NOT `!` è la più alta fra tutti gli operatori logici quindi viene sempre eseguita per prima, precede `&&`, `||`.
+La precedenza del NOT `!` è la più alta fra tutti gli operatori logici; viene sempre eseguita per prima e precede sia `&&` che `||`.

From a45abf065a41272389c5e296b2a32053b9965627 Mon Sep 17 00:00:00 2001
From: Dorin-David <70648503+Dorin-David@users.noreply.github.com>
Date: Fri, 22 Jan 2021 09:01:48 +0100
Subject: [PATCH 04/23] Update task.md

---
 .../11-logical-operators/1-alert-null-2-undefined/task.md     | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/task.md b/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/task.md
index f8b15275c..8067c2a1d 100644
--- a/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/task.md
+++ b/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/task.md
@@ -2,9 +2,9 @@ importance: 5
 
 ---
 
-# Qual'e il risultato dell'OR?
+# Qual è il risultato dell'OR?
 
-Che risultato restituirà il codice qui sotto?
+Quale sarà il risultato del codice sotto?
 
 ```js
 alert( null || 2 || undefined );

From fb58982732458a25361fbb0f3a930689b88e3c99 Mon Sep 17 00:00:00 2001
From: Dorin-David <70648503+Dorin-David@users.noreply.github.com>
Date: Fri, 22 Jan 2021 09:07:22 +0100
Subject: [PATCH 05/23] Update task.md

---
 1-js/02-first-steps/11-logical-operators/2-alert-or/task.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/1-js/02-first-steps/11-logical-operators/2-alert-or/task.md b/1-js/02-first-steps/11-logical-operators/2-alert-or/task.md
index eb9f3ef4d..59216589c 100644
--- a/1-js/02-first-steps/11-logical-operators/2-alert-or/task.md
+++ b/1-js/02-first-steps/11-logical-operators/2-alert-or/task.md
@@ -2,9 +2,9 @@ importance: 3
 
 ---
 
-# Qual'è il risultato dell'alert con l'OR?
+# Qual è il risultato dell'alert con l'OR?
 
-Cosa stampa il codice qui sotto?
+Cosa mostrerà il codice sotto?
 
 ```js
 alert( alert(1) || 2 || alert(3) );

From aff5e391d47018f9414c8acf7d7275b02375511f Mon Sep 17 00:00:00 2001
From: Dorin-David <70648503+Dorin-David@users.noreply.github.com>
Date: Fri, 22 Jan 2021 09:16:10 +0100
Subject: [PATCH 06/23] Update solution.md

---
 .../11-logical-operators/2-alert-or/solution.md             | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/1-js/02-first-steps/11-logical-operators/2-alert-or/solution.md b/1-js/02-first-steps/11-logical-operators/2-alert-or/solution.md
index ff9f9b9da..e79ec1f7b 100644
--- a/1-js/02-first-steps/11-logical-operators/2-alert-or/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/2-alert-or/solution.md
@@ -4,10 +4,10 @@ La risposta: prima `1`, poi `2`.
 alert( alert(1) || 2 || alert(3) );
 ```
 
-La chiamata ad `alert` non ritorna alcun valore. In altre parole, ritorna `undefined`.
+La chiamata ad `alert` non ritorna alcun valore; dunque `undefined`.
 
-1. Il primo OR `||` valuta il suo operando sinistro `alert(1)`. Questo mostra il primo messaggio con `1`.
-2. La funzione `alert` ritorna `undefined`, quindi OR prosegue con il secondo operando alla ricerca di un valore vero.
+1. Il primo OR `||` valuta l'operando sinistro `alert(1)`. Questo mostra il primo messaggio, `1`.
+2. La funzione `alert` ritorna `undefined`, quindi OR prosegue con il secondo operando, alla ricerca di un valore vero.
 3. Il secondo operando `2` è vero; quindi l'esecuzione si ferma, viene ritornato `2` e mostrato dall'alert esterno.
 
 Non ci sarà il `3`, perchè la valutazione non arriva a `alert(3)`.

From f70d723e50e978de65e3105ccac432abf675645f Mon Sep 17 00:00:00 2001
From: Dorin-David <70648503+Dorin-David@users.noreply.github.com>
Date: Fri, 22 Jan 2021 09:29:03 +0100
Subject: [PATCH 07/23] Update task.md

---
 .../11-logical-operators/3-alert-1-null-2/task.md               | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/task.md b/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/task.md
index 8c73f5d56..f221e6c2e 100644
--- a/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/task.md
+++ b/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/task.md
@@ -2,7 +2,7 @@ importance: 5
 
 ---
 
-# Qual'è il risultato dell'AND?
+# Qual è il risultato dell'AND?
 
 Cosa mostrerà l'esecuzione di questo codice?
 

From 7f20acfdafecb3bdab3ef4814acb8be88a6cdd14 Mon Sep 17 00:00:00 2001
From: Dorin-David <70648503+Dorin-David@users.noreply.github.com>
Date: Fri, 22 Jan 2021 09:30:38 +0100
Subject: [PATCH 08/23] Update task.md

---
 1-js/02-first-steps/11-logical-operators/4-alert-and/task.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/11-logical-operators/4-alert-and/task.md b/1-js/02-first-steps/11-logical-operators/4-alert-and/task.md
index 9d276beb5..5c435a17e 100644
--- a/1-js/02-first-steps/11-logical-operators/4-alert-and/task.md
+++ b/1-js/02-first-steps/11-logical-operators/4-alert-and/task.md
@@ -2,7 +2,7 @@ importance: 3
 
 ---
 
-# Qual'è il risultato degli alert?
+# Qual è il risultato degli alert?
 
 Cosa mostrerà questo codice?
 

From ba54fbf1c3793e2767ae9ab6b9e03babe9c8be80 Mon Sep 17 00:00:00 2001
From: Dorin-David <70648503+Dorin-David@users.noreply.github.com>
Date: Fri, 22 Jan 2021 09:37:33 +0100
Subject: [PATCH 09/23] Update solution.md

---
 .../11-logical-operators/4-alert-and/solution.md              | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/1-js/02-first-steps/11-logical-operators/4-alert-and/solution.md b/1-js/02-first-steps/11-logical-operators/4-alert-and/solution.md
index c1d39e0e8..6b0d58e00 100644
--- a/1-js/02-first-steps/11-logical-operators/4-alert-and/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/4-alert-and/solution.md
@@ -4,7 +4,7 @@ La risposta è: `1`, e poi `undefined`.
 alert( alert(1) && alert(2) );
 ```
 
-La chiamata `alert` ritorna `undefined` (mostra solo un messaggio, quindi non ha nessuna valore di ritorno significativo).
+La chiamata `alert` ritorna `undefined` (mostra solo un messaggio, quindi non ha nessuna valore significativo di ritorno).
 
-Per questo `&&` valuta l'operando di sinistra (che mostra `1`), e si ferma immediatamente, perchè `undefined` è un valore falso.  AND `&&` cerca un valore falso e lo ritorna.
+Per questo `&&`, valutato l'operando di sinistra (che mostra `1`), si ferma: `undefined` è un valore falso e `&&` lo ritorna immediatamente.
 

From d5bafd0f26a12a5bad5614a4374a8bddd5d0b968 Mon Sep 17 00:00:00 2001
From: Dorin-David <70648503+Dorin-David@users.noreply.github.com>
Date: Fri, 22 Jan 2021 09:41:24 +0100
Subject: [PATCH 10/23] Update task.md

---
 .../11-logical-operators/6-check-if-in-range/task.md          | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/1-js/02-first-steps/11-logical-operators/6-check-if-in-range/task.md b/1-js/02-first-steps/11-logical-operators/6-check-if-in-range/task.md
index 4623d4080..fadeba338 100644
--- a/1-js/02-first-steps/11-logical-operators/6-check-if-in-range/task.md
+++ b/1-js/02-first-steps/11-logical-operators/6-check-if-in-range/task.md
@@ -4,6 +4,4 @@ importance: 3
 
 # Controlla l'intervallo
 
-Scrivi una condizione `if` per controllare che `age` sia compresa tra `14` e `90` estremi inclusi.
-
-"Inclusi" significa che `age` può valere anche `14` o `90`.
+Scrivi una condizione `if` per controllare che `age` sia compresa tra `14` e `90` (inclusi: `age` può valere anche `14` o `90`).

From 3b38b4d054c49f8aa4f27a25f9c2d1999cff067e Mon Sep 17 00:00:00 2001
From: Simone Pasini <66781510+pasor1@users.noreply.github.com>
Date: Fri, 22 Jan 2021 10:05:18 +0100
Subject: [PATCH 11/23] Update article.md

Piccola correzione
---
 1-js/02-first-steps/11-logical-operators/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/11-logical-operators/article.md b/1-js/02-first-steps/11-logical-operators/article.md
index 68d1731a4..374968a2e 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -168,7 +168,7 @@ if (1 && 0) { // valutato come true && false
 ```
 
 
-## AND "&& trova il primo valore falso
+## AND "&&" trova il primo valore falso
 
 Dati svariati operandi:
 

From cf4680a413f42c03bb364a660803691af411bfbc Mon Sep 17 00:00:00 2001
From: Dorin-David <70648503+Dorin-David@users.noreply.github.com>
Date: Fri, 22 Jan 2021 14:10:51 +0100
Subject: [PATCH 12/23] Update task.md

non ancora convintissimo del termine 'fuori', ma credo possa funzionare
---
 .../11-logical-operators/7-check-if-out-range/task.md         | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/task.md b/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/task.md
index dd854f726..760471fdd 100644
--- a/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/task.md
+++ b/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/task.md
@@ -2,8 +2,8 @@ importance: 3
 
 ---
 
-# Controlla l'intervallo esternamente
+# Controlla l'intervallo fuori
 
-Scrivi una condizione `if` che controlli la variabile `age`, questa NON deve essere compresa tra `14` e `90`, estremi inclusi.
+Scrivi una condizione `if` che controlli la variabile `age`; questa NON deve essere compresa tra `14` e `90` (inclusi).
 
 Scrivi due varianti: la prima utilizzando NOT `!`, la seconda -- senza.

From d9a93b930bc905b7df765cba50d71cf84a0d514e Mon Sep 17 00:00:00 2001
From: Dorin-David <70648503+Dorin-David@users.noreply.github.com>
Date: Fri, 22 Jan 2021 14:15:47 +0100
Subject: [PATCH 13/23] Update task.md

---
 .../02-first-steps/11-logical-operators/8-if-question/task.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/1-js/02-first-steps/11-logical-operators/8-if-question/task.md b/1-js/02-first-steps/11-logical-operators/8-if-question/task.md
index c308e75e1..9def51940 100644
--- a/1-js/02-first-steps/11-logical-operators/8-if-question/task.md
+++ b/1-js/02-first-steps/11-logical-operators/8-if-question/task.md
@@ -2,11 +2,11 @@ importance: 5
 
 ---
 
-# Una indovinello con "if"
+# Un indovinello con "if"
 
 Quali di questi `alert` verranno eseguiti?
 
-Quale sarà il risultato dell'espressione all'interno di `if(...)`?
+Quale sarà il risultato delle espressioni all'interno dei vari `if(...)`?
 
 ```js
 if (-1 || 0) alert( 'first' );

From 698314bf08de7142ae0ed910ca2572acfb4e129b Mon Sep 17 00:00:00 2001
From: Dorin-David <70648503+Dorin-David@users.noreply.github.com>
Date: Fri, 22 Jan 2021 14:26:09 +0100
Subject: [PATCH 14/23] Update task.md

---
 .../11-logical-operators/9-check-login/task.md     | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/1-js/02-first-steps/11-logical-operators/9-check-login/task.md b/1-js/02-first-steps/11-logical-operators/9-check-login/task.md
index 055bdff56..7d9afdf29 100644
--- a/1-js/02-first-steps/11-logical-operators/9-check-login/task.md
+++ b/1-js/02-first-steps/11-logical-operators/9-check-login/task.md
@@ -6,20 +6,20 @@ importance: 3
 
 Scrivi il codice che richiede un login tramite `prompt`.
 
-Se l'utente digita `"Admin"`, allora si richiede una password tramite `prompt`, se l'input è una stringa vuota o `key:Esc` -- mostra "Canceled.", se invece è un'altra stringa -- allora mostra "I don't know you".
+Se l'utente digita `"Admin"`, si richiede una password tramite `prompt`; se l'input è una stringa vuota o `key:Esc` -- mostra "Canceled."; se  è diversa da `"Admin"`, mostra "I don't know you".
 
-La passoword viene controllata con le seguenti regole:
+La passoword viene controllata secondo i seguenti criteri:
 
-- Se è uguale a "TheMaster", allora mostra "Welcome!",
-- Un'altra stringa -- mostra "Wrong password",
-- Per una stringa vuota o `key:Esc`, mostra "Canceled."
+- Se è uguale a "TheMaster", mostra "Welcome!",
+- Un stringa diversa da "TheMaster" -- mostra "Wrong password",
+- Una stringa vuota o `key:Esc` -- mostra "Canceled."
 
 Lo schema:
 
 ![](ifelse_task.svg)
 
-Utilizzate blocchi `if` annidati. Tenete a mente anche la leggibilità del codice.
+Utilizza blocchi `if` annidati e tieni a mente la leggibilità del codice.
 
-Suggerimento: passare un input vuoto tramite prompt ritorna una stringa vuota `''`. Premere `key:ESC` con prompt aperto ritorna `null`.
+Suggerimento: passare un input vuoto tramite prompt ritorna una stringa vuota `''`. Premere `key:ESC` metre il prompt è aperto ritorna `null`.
 
 [demo]

From 27587d1ead4db18919b95e85cd154d76effa14d3 Mon Sep 17 00:00:00 2001
From: Dorin-David <70648503+Dorin-David@users.noreply.github.com>
Date: Sat, 23 Jan 2021 23:30:56 +0100
Subject: [PATCH 15/23] Update
 1-js/02-first-steps/11-logical-operators/2-alert-or/solution.md

Co-authored-by: Simone Pasini <66781510+pasor1@users.noreply.github.com>
---
 1-js/02-first-steps/11-logical-operators/2-alert-or/solution.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/11-logical-operators/2-alert-or/solution.md b/1-js/02-first-steps/11-logical-operators/2-alert-or/solution.md
index e79ec1f7b..99241bd73 100644
--- a/1-js/02-first-steps/11-logical-operators/2-alert-or/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/2-alert-or/solution.md
@@ -4,7 +4,7 @@ La risposta: prima `1`, poi `2`.
 alert( alert(1) || 2 || alert(3) );
 ```
 
-La chiamata ad `alert` non ritorna alcun valore; dunque `undefined`.
+La chiamata ad `alert` non ritorna alcun valore; ossia `undefined`.
 
 1. Il primo OR `||` valuta l'operando sinistro `alert(1)`. Questo mostra il primo messaggio, `1`.
 2. La funzione `alert` ritorna `undefined`, quindi OR prosegue con il secondo operando, alla ricerca di un valore vero.

From f92c0cb155dac1f8e2775ff87594ec658b796b04 Mon Sep 17 00:00:00 2001
From: Dorin-David <70648503+Dorin-David@users.noreply.github.com>
Date: Sat, 23 Jan 2021 23:32:05 +0100
Subject: [PATCH 16/23] Update
 1-js/02-first-steps/11-logical-operators/article.md

Co-authored-by: Simone Pasini <66781510+pasor1@users.noreply.github.com>
---
 1-js/02-first-steps/11-logical-operators/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/11-logical-operators/article.md b/1-js/02-first-steps/11-logical-operators/article.md
index 374968a2e..7c0c2366f 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -16,7 +16,7 @@ result = a || b;
 
 Nella programmazione classica, l'OR logico è utilizzato per manipolare solo tipi booleani. Se almeno un argomento è `true`, allora il risultato sarà `true`, altrimenti sarà `false`.
 
-In JavaScript questo operatore è un pò più potente. Ma prima vediamo come si comporta con i valori booleani.
+In JavaScript questo operatore è un po' più potente. Ma prima vediamo come si comporta con i valori booleani.
 
 Ci sono quattro combinazioni logiche possibili:
 

From 1a39e5f1438c76aabfb8e3dc8c1906fdf2fec46f Mon Sep 17 00:00:00 2001
From: Dorin-David <70648503+Dorin-David@users.noreply.github.com>
Date: Sat, 23 Jan 2021 23:34:10 +0100
Subject: [PATCH 17/23] Update
 1-js/02-first-steps/11-logical-operators/article.md

Co-authored-by: Simone Pasini <66781510+pasor1@users.noreply.github.com>
---
 1-js/02-first-steps/11-logical-operators/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/11-logical-operators/article.md b/1-js/02-first-steps/11-logical-operators/article.md
index 7c0c2366f..52b35059f 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -29,7 +29,7 @@ alert( false || false ); // false
 
 Come possiamo vedere, il risultato è sempre `true`, tranne nei casi in cui entrambi gli operandi sono `false`.
 
-Se un operando non è di tipo booleano vi viene momentaneamente convertito per la valutazione.
+Se un operando non è di tipo booleano, allora viene momentaneamente convertito per la valutazione.
 
 Ad esempio, il numero `1` viene considerato come `true`, il numero `0` come `false`:
 

From 803368d9cc52b96c30f43ad3d2cc0492fb9424d5 Mon Sep 17 00:00:00 2001
From: Dorin-David <70648503+Dorin-David@users.noreply.github.com>
Date: Sat, 23 Jan 2021 23:37:13 +0100
Subject: [PATCH 18/23] Update
 1-js/02-first-steps/11-logical-operators/article.md

Co-authored-by: Simone Pasini <66781510+pasor1@users.noreply.github.com>
---
 1-js/02-first-steps/11-logical-operators/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/11-logical-operators/article.md b/1-js/02-first-steps/11-logical-operators/article.md
index 52b35059f..48f4406b0 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -82,7 +82,7 @@ L'operatore OR `||` si comporta come segue:
 - Ogni operando viene convertito a booleano. Se il risultato è `true`, il logical OR si ferma e ritorna il valore originale dell'operando.
 - Se tutti gli operandi sono stati valutati e nessuno è `true`, ritorna l'ultimo operando.
 
-**Un valore viene ritornato nella sua forma originale, non nella sua conversione booleana.
+Un valore viene ritornato nella sua forma originale, non nella sua conversione booleana.
 
 In altre parole, una catena di OR `"||"` ritorna il primo valore vero; se invece non ce ne sono ritorna l'ultimo valore.
 

From 9930428bde549fb816e70ba2b202f7661a90647e Mon Sep 17 00:00:00 2001
From: Dorin-David <70648503+Dorin-David@users.noreply.github.com>
Date: Sat, 23 Jan 2021 23:44:27 +0100
Subject: [PATCH 19/23] Update
 1-js/02-first-steps/11-logical-operators/article.md

Co-authored-by: Simone Pasini <66781510+pasor1@users.noreply.github.com>
---
 1-js/02-first-steps/11-logical-operators/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/11-logical-operators/article.md b/1-js/02-first-steps/11-logical-operators/article.md
index 48f4406b0..8aec3e268 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -119,7 +119,7 @@ Questo ci permette alcuni utilizzi interessanti rispetto al "puro e classico OR
 
 2. **Valutazione a Corto-Circuito.**
 
-    Gli operandi, oltre che valori, possono essere anche espressioni arbitrarie. L'operatore OR esegue la valutazione da sinistra a destra e si ferma al primo risultato vero, che viene ritornato. Il processo è chiamato "valutazione a corto-circuito" perchè cerca di concludersi il prima possibile (quando possibile), senza aver raggiunto l’operando successivo. 
+    Gli operandi, oltre che valori, possono essere anche espressioni arbitrarie. L'operatore OR esegue la valutazione da sinistra a destra e si ferma al primo risultato vero, il quale viene ritornato. Il processo è chiamato "valutazione a corto-circuito" perché cerca di concludersi il prima possibile, senza dover elaborare tutti gli operandi. 
 
     Il logical OR è particolarmente utile quando il secondo argomento causerebbe un *side-effect* come l'assegnazione di una variabile o la chiamata a una funzione.
     Nell'esempio che segue solo il secondo messaggio verrà mostrato. 

From e2c97bd74802b03990667da979e6d27c8406974f Mon Sep 17 00:00:00 2001
From: Dorin-David <70648503+Dorin-David@users.noreply.github.com>
Date: Sat, 23 Jan 2021 23:46:29 +0100
Subject: [PATCH 20/23] Update
 1-js/02-first-steps/11-logical-operators/article.md

Co-authored-by: Simone Pasini <66781510+pasor1@users.noreply.github.com>
---
 1-js/02-first-steps/11-logical-operators/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/11-logical-operators/article.md b/1-js/02-first-steps/11-logical-operators/article.md
index 8aec3e268..8fc858503 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -276,7 +276,7 @@ alert( !!null ); // false
 
 Quello che accade è che il primo NOT converte l'operando a booleano e ritorna il suo inverso, e il secondo NOT lo *inverte nuovamente*. Il risultato è un valore di tipo booleano.
 
-C'è un modo molto più lungo per fare la stessa cosa -- una funzione *built-in* di `Boolean`:
+C'è un modo molto più lungo per fare la stessa cosa, usare la funzione `Boolean`, integrata in JavaScript:
 
 ```js run
 alert( Boolean("non-empty string") ); // true

From b54fa5a7e6f5f4c748aeb85df5ce6f534fce69b5 Mon Sep 17 00:00:00 2001
From: Dorin-David <70648503+Dorin-David@users.noreply.github.com>
Date: Sun, 24 Jan 2021 07:53:51 +0100
Subject: [PATCH 21/23] Update
 1-js/02-first-steps/11-logical-operators/article.md

Co-authored-by: Simone Pasini <66781510+pasor1@users.noreply.github.com>
---
 1-js/02-first-steps/11-logical-operators/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/11-logical-operators/article.md b/1-js/02-first-steps/11-logical-operators/article.md
index 8fc858503..feedabaf4 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -258,7 +258,7 @@ result = !value;
 L'operatore accetta un solo argomento e si comporta come segue:
 
 1. Converte l'operando a booleano: `true/false`.
-2. Ritorna il valore **inverso.
+2. Ritorna il valore inverso.
 
 Ad esempio:
 

From f25f2a625dc4d19e497089ba58a8171b83c26b2a Mon Sep 17 00:00:00 2001
From: Dorin-David <70648503+Dorin-David@users.noreply.github.com>
Date: Sun, 24 Jan 2021 07:57:14 +0100
Subject: [PATCH 22/23] Update task.md

---
 .../11-logical-operators/6-check-if-in-range/task.md          | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/11-logical-operators/6-check-if-in-range/task.md b/1-js/02-first-steps/11-logical-operators/6-check-if-in-range/task.md
index fadeba338..4623d4080 100644
--- a/1-js/02-first-steps/11-logical-operators/6-check-if-in-range/task.md
+++ b/1-js/02-first-steps/11-logical-operators/6-check-if-in-range/task.md
@@ -4,4 +4,6 @@ importance: 3
 
 # Controlla l'intervallo
 
-Scrivi una condizione `if` per controllare che `age` sia compresa tra `14` e `90` (inclusi: `age` può valere anche `14` o `90`).
+Scrivi una condizione `if` per controllare che `age` sia compresa tra `14` e `90` estremi inclusi.
+
+"Inclusi" significa che `age` può valere anche `14` o `90`.

From c6a51aa4c874ee1c625e033c26eac34a417f8576 Mon Sep 17 00:00:00 2001
From: Dorin-David <70648503+Dorin-David@users.noreply.github.com>
Date: Sun, 24 Jan 2021 08:08:06 +0100
Subject: [PATCH 23/23] Update solution.md

---
 .../11-logical-operators/8-if-question/solution.md | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/1-js/02-first-steps/11-logical-operators/8-if-question/solution.md b/1-js/02-first-steps/11-logical-operators/8-if-question/solution.md
index 1c30697ea..5804953fc 100644
--- a/1-js/02-first-steps/11-logical-operators/8-if-question/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/8-if-question/solution.md
@@ -3,17 +3,17 @@ La risposta: il primo e il terzo verranno eseguiti.
 I dettagli:
 
 ```js run
-// Runs.
-// The result of -1 || 0 = -1, truthy
+// Viene eseguito
+// Il risultato di -1 || 0 = -1 è vero
 if (-1 || 0) alert( 'first' );
 
-// Doesn't run
-// -1 && 0 = 0, falsy
+// Non viene eseguito
+// -1 && 0 = 0, falso
 if (-1 && 0) alert( 'second' );
 
-// Executes
-// Operator && has a higher precedence than ||
-// so -1 && 1 executes first, giving us the chain:
+// Eseguito
+// L'operatore && ha la precedenza su ||,
+// quindi -1 && 1 vengono eseguiti per primi; la catena dentro `if` diventa:
 // null || -1 && 1  ->  null || 1  ->  1
 if (null || -1 && 1) alert( 'third' );
 ```