Sync with upstream @ 540d753e

.github/FUNDING.yml

@@ -0,0 +1 @@
+github: iliakan

1-js/01-getting-started/1-intro/article.md

@@ -34,6 +34,12 @@ I nomi citati sopra possono essere utili da ricordare, poiché si possono trovar
 
 Il funzionamento di questi motori è complicato, ma i concetti alla base sono semplici.
 
+<<<<<<< HEAD
+=======
+1. The engine (embedded if it's a browser) reads ("parses") the script.
+2. Then it converts ("compiles") the script to machine code.
+3. And then the machine code runs, pretty fast.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 1. I motori (integrati nei browser) leggono ("analizzano") lo script.
 2. Successivamente convertono ("compilano") lo script nel linguaggio della macchina.
@@ -44,7 +50,11 @@ Il motore ottimizza il codice ad ogni passaggio del processo, anche durante l'es
 
 ## Cosa può fare JavaScript a livello browser?
 
+<<<<<<< HEAD
 JavaScript, al giorno d'oggi, è un linguaggio di programmazione "sicuro". Non consente alcun accesso di basso livello alla memoria o alla CPU. Questo perché è stato creato con lo scopo di funzionare nei browser, che non richiedono questi tipi di privilegi.
+=======
+Modern JavaScript is a "safe" programming language. It does not provide low-level access to memory or the CPU, because it was initially created for browsers which do not require it.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Le capacità di JavaScript dipendono molto dall'ambiente in cui lo si esegue. Ad esempio, [Node.js](https://wikipedia.org/wiki/Node.js) supporta funzioni che consentono a JavaScript di scrivere/leggere file, eseguire richieste web, etc.
 
@@ -60,14 +70,19 @@ Ad esempio, è possibile:
 
 ## Cosa NON può fare JavaScript a livello browser?
 
+<<<<<<< HEAD
 Per la sicurezza dell'utente, le possibilità di JavaScript nel browser sono limitate. L'intento è di prevenire che una pagina "maligna" tenti di accedere alle informazioni personali o di danneggiare i dati degli utenti.
+=======
+JavaScript's abilities in the browser are limited to protect the user's safety. The aim is to prevent an evil webpage from accessing private information or harming the user's data.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Esempi di queste restrizioni possono essere:
 
 - JavaScript, in una pagina web, non può leggere o scrivere in qualsiasi file nell'hard disk, né copiare o eseguire programmi. Non ha accesso diretto alle funzioni del sistema operativo.
 
     I moderni browser gli consentono di lavorare con i file, sempre con un accesso limitato e comunque solo se il comando proviene da utente, come il "dropping" di un file nella finestra del browser, o con la selezione  tramite il tag `<input>`.
 
+<<<<<<< HEAD
     Ci sono anche funzionalità che consentono di interagire con la camera/microfono e altri dispositivi, ma in ogni caso richiedono il permesso esplicito dell'utente. Quindi una pagina con JavaScript abilitato non può attivare la web-cam di nascosto, osservare i nostri comportamenti e inviare  informazioni alla [CIA](https://it.wikipedia.org/wiki/Central_Intelligence_Agency).
 - Pagine o schede diverse generalmente non sono a conoscenza dell'esistenza delle altre. In certi casi, tuttavia, può capitare; ad esempio quando una finestra ne apre un'altra tramite JavaScript. Ma anche in questo caso, il codice JavaScript non può accedere all'altra pagina se non appartiene allo stesso sito (stesso dominio, protocollo o porta).
 
@@ -79,6 +94,19 @@ Esempi di queste restrizioni possono essere:
 ![](limitations.svg)
 
 Queste limitazioni non si pongono se JavaScript viene eseguito fuori dal browser, ad esempio in un server. I browser moderni permettono l'installazione di plugin ed estensioni che consentono di estendere vari permessi.
+=======
+    There are ways to interact with the camera/microphone and other devices, but they require a user's explicit permission. So a JavaScript-enabled page may not sneakily enable a web-camera, observe the surroundings and send the information to the [NSA](https://en.wikipedia.org/wiki/National_Security_Agency).
+- Different tabs/windows generally do not know about each other. Sometimes they do, for example when one window uses JavaScript to open the other one. But even in this case, JavaScript from one page may not access the other page if they come from different sites (from a different domain, protocol or port).
+
+    This is called the "Same Origin Policy". To work around that, *both pages* must agree for data exchange and must contain special JavaScript code that handles it. We'll cover that in the tutorial.
+
+    This limitation is, again, for the user's safety. A page from `http://anysite.com` which a user has opened must not be able to access another browser tab with the URL `http://gmail.com`, for example, and steal information from there.
+- JavaScript can easily communicate over the net to the server where the current page came from. But its ability to receive data from other sites/domains is crippled. Though possible, it requires explicit agreement (expressed in HTTP headers) from the remote side. Once again, that's a safety limitation.
+
+![](limitations.svg)
+
+Such limitations do not exist if JavaScript is used outside of the browser, for example on a server. Modern browsers also allow plugins/extensions which may ask for extended permissions.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 ## Cosa rende JavaScript unico?
 
@@ -93,20 +121,29 @@ JavaScript è l'unica tecnologia in ambiente browser che combina queste tre cara
 
 Questo rende JavaScript unico. Ed è il motivo per cui è lo strumento più diffuso per creare interfacce web.
 
+<<<<<<< HEAD
 Quando si ha in programma di imparare una nuova tecnologia, è fondamentale verificare le sue prospettive. Quindi diamo uno sguardo alle nuove tendenze che includono nuovi linguaggi e tecnologie.
+=======
+That said, JavaScript can be used to create servers, mobile applications, etc.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 ## Linguaggi "oltre" JavaScript
 
 La sintassi di JavaScript non soddisfa le necessità di tutti. Alcune persone necessitano di caratteristiche differenti.
 
 Questo è prevedibile, poiché i progetti e i requisiti sono diversi da persona a persona.
 
+<<<<<<< HEAD
 Recentemente, per questo motivo, sono nati molti nuovi linguaggi che vengono *convertiti* in JavaScript prima di essere eseguiti nel browser.
+=======
+So, recently a plethora of new languages appeared, which are *transpiled* (converted) to JavaScript before they run in the browser.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Gli strumenti moderni rendono la conversione molto veloce e pulita, consentendo agli sviluppatori di programmare in un altro linguaggio e di auto-convertirlo *under the hood*.
 
 Esempi di alcuni linguaggi:
 
+<<<<<<< HEAD
 - [CoffeeScript](http://coffeescript.org/) è un linguaggio che introduce una sintassi semplificata che consente di scrivere codice più leggibile. Amato dagli sviluppatori provenienti da Ruby.
 - [TypeScript](http://www.typescriptlang.org/) si occupa di aggiungere la "tipizzazione", per semplificare lo sviluppo e supportare sistemi più complessi. E' stato sviluppato da Microsoft.
 - [Flow](http://flow.org/) anche'esso aggiunge la tipizzazione dei dati, ma in un modo differente. Sviluppato da Facebook.
@@ -115,6 +152,16 @@ Esempi di alcuni linguaggi:
 - [Kotlin](https://kotlinlang.org/docs/reference/js-overview.html) è un moderno, conciso e sicuro linguaggio di programmazione mirato ai browsers o a Node.
 
 Ce ne sono molti altri. Ovviamente, per comprendere cosa stiamo facendo, se utilizziamo uno di questi linguaggi dovremmo altresì conoscere JavaScript.
+=======
+- [CoffeeScript](https://coffeescript.org/) is "syntactic sugar" for JavaScript. It introduces shorter syntax, allowing us to write clearer and more precise code. Usually, Ruby devs like it.
+- [TypeScript](https://www.typescriptlang.org/) is concentrated on adding "strict data typing" to simplify the development and support of complex systems. It is developed by Microsoft.
+- [Flow](https://flow.org/) also adds data typing, but in a different way. Developed by Facebook.
+- [Dart](https://www.dartlang.org/) is a standalone language that has its own engine that runs in non-browser environments (like mobile apps), but also can be transpiled to JavaScript. Developed by Google.
+- [Brython](https://brython.info/) is a Python transpiler to JavaScript that enables the writing of applications in pure Python without JavaScript.
+- [Kotlin](https://kotlinlang.org/docs/reference/js-overview.html) is a modern, concise and safe programming language that can target the browser or Node.
+
+There are more. Of course, even if we use one of these transpiled languages, we should also know JavaScript to really understand what we're doing.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 ## Riepilogo
 

1-js/01-getting-started/2-manuals-specifications/article.md

@@ -1,15 +1,23 @@
 
 # Manuali e Specifiche
 
+<<<<<<< HEAD
 Questo libro è un *tutorial*. L'obiettivo è quello di aiutarti ad apprender il linguaggio gradualmente. Una volta che avrai familiarizzato con le basi avrai bisogno di ulteriori risorse.
+=======
+This book is a *tutorial*. It aims to help you gradually learn the language. But once you're familiar with the basics, you'll need other resources.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 ## Specifiche
 
 [La specifica ECMA-262](https://www.ecma-international.org/publications/standards/Ecma-262.htm) contiene informazioni più dettagliate, approfondite e formalizzate riguardanti JavaScript. E' la definizione stessa del linguaggio.
 
 Iniziare a studiare dalla specifica può risultare difficile. Se avete bisogno di una fonte affidabile e formale riguardante i dettagli del linguaggio, la specifica è il posto in cui cercare. Ma non è una risorsa comoda da consultare per i problemi di tutti i giorni.
 
+<<<<<<< HEAD
 Ogni anno viene rilasciata una nuova specifica. Di queste pubblicazioni, è possibile trovare l'ultima bozza a <https://tc39.es/ecma262/>.
+=======
+A new specification version is released every year. Between these releases, the latest specification draft is at <https://tc39.es/ecma262/>.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Per leggere delle più recenti caratteristiche, incluse quelle considerate "quasi standard" (definite "stage 3"), potete consultare <https://github.com/tc39/proposals>.
 
@@ -19,16 +27,29 @@ Inoltre, se state sviluppando in ambiente browser, ci sono ulteriori specifiche
 
 - **MDN (Mozilla) JavaScript Reference** è il manuale principale, corredato di spiegazioni teoriche, esempi ed altre informazioni utili. E' ottimo per avere informazioni dettagliate riguardo le funzioni e altre caratteristiche del linguaggio.
 
+<<<<<<< HEAD
     Può essere consultato a <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference>.
 
     Tuttavia, spesso è meglio fare una ricerca su internet. E' sufficiente cercare "MDN", seguito dal termine da ricercare, e.g. <https://google.com/search?q=MDN+parseInt> per ricercare la funzione `parseInt`, oppure frasi come "RegExp MSDN" o "RegExp MSDN jscript".
+=======
+    You can find it at <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference>.
+
+Although, it's often best to use an internet search instead. Just use "MDN [term]" in the query, e.g. <https://google.com/search?q=MDN+parseInt> to search for the `parseInt` function.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 
     Può essere consultato al link <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference>.
 
 - **MSDN** – Manuale Microsoft con molte informazioni, tra cui su JavaScript (a cui viene fatto riferimento con il termine JScript). Se si ha bisogno di ottenere qualche informazione specifica per Internet Explorer, meglio consultare la guida: <http://msdn.microsoft.com/>.
 
+<<<<<<< HEAD
+
+=======
+- <https://caniuse.com> - per-feature tables of support, e.g. to see which engines support modern cryptography functions: <https://caniuse.com/#feat=cryptography>.
+- <https://kangax.github.io/compat-table> - a table with language features and engines that support those or don't support.
 
+All these resources are useful in real-life development, as they contain valuable information about language details, their support, etc.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 ## Tabelle di compatibilità
 

1-js/01-getting-started/3-code-editors/article.md

@@ -12,8 +12,13 @@ Un IDE carica il progetto (possono essere molti file), consente la navigazione t
 
 Se non hai ancora considerato di scegliere un IDE, dai un'occhiata a queste alternative:
 
+<<<<<<< HEAD
 - [Visual Studio Code](https://code.visualstudio.com/) (*cross-platform*, gratutito).
 - [WebStorm](http://www.jetbrains.com/webstorm/) (*cross-platform*, a pagamento).
+=======
+- [Visual Studio Code](https://code.visualstudio.com/) (cross-platform, free).
+- [WebStorm](https://www.jetbrains.com/webstorm/) (cross-platform, paid).
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Per Windows, c'è anche l'editor "Visual Studio", da non confondere con "Visual Studio Code". "Visual Studio" è un potente editor (a pagamento) disponibile solo per Windows, ottimo per le piattaforme .NET. E' disponibile anche una versione gratuita: ([Visual Studio Community](https://www.visualstudio.com/vs/community/).
 
@@ -29,18 +34,35 @@ La principale differenza tra gli editor semplici e un IDE è che quest'ultimo la
 
 In pratica, tuttavia, gli editor semplici possono avere molti plugin, tra cui la sintassi a livello directory e l'autocompletamento, quindi non ci sono delle differenze ben definite tra un editor semplice e un IDE.
 
+<<<<<<< HEAD
 Meritano attenzione le seguenti opzioni:
 
 - [Atom](https://atom.io/) (*cross-platform*, gratuito).
 - [Visual Studio Code](https://code.visualstudio.com/) (*cross-platform*, gratuito).
 - [Sublime Text](http://www.sublimetext.com) (*cross-platform*, con prova gratuita).
 - [Notepad++](https://notepad-plus-plus.org/) (Windows, gratuito).
 - [Vim](http://www.vim.org/) e [Emacs](https://www.gnu.org/software/emacs/) sono particolarmente carini se si sanno utilizzare.
+=======
+There are many options, for instance:
+
+- [Sublime Text](https://www.sublimetext.com/) (cross-platform, shareware).
+- [Notepad++](https://notepad-plus-plus.org/) (Windows, free).
+- [Vim](https://www.vim.org/) and [Emacs](https://www.gnu.org/software/emacs/) are also cool if you know how to use them.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 ## Non intestarditevi
 
 Gli editor elencanti sopra sono quelli che io e i miei amici, che considero buoni sviluppatori, abbiamo utilizzato senza problemi per molto tempo.
 
 Ci sono altri grandi editor nel nostro grande mondo. Scegli quello che più ti si addice.
 
+<<<<<<< HEAD
 La scelta di un editor, come pure di altri strumenti, è individuale e dipende dai progetti, dalle abitudini e preferenze personali.
+=======
+The choice of an editor, like any other tool, is individual and depends on your projects, habits, and personal preferences.
+
+The author's personal opinion:
+
+- I'd use [Visual Studio Code](https://code.visualstudio.com/) if I develop mostly frontend.
+- Otherwise, if it's mostly another language/platform and partially frontend, then consider other editors, such as XCode (Mac), Visual Studio (Windows) or Jetbrains family (Webstorm, PHPStorm, RubyMine etc, depending on the language).
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b

1-js/01-getting-started/4-devtools/article.md

@@ -23,7 +23,7 @@ Gli strumenti di sviluppo, di default, si apriranno nella scheda Console.
 
 Assomiglierà a qualcosa di simile a questo:
 
-![chrome](chrome.png)
+![chrome](chrome.webp)
 
 Il look esatto degli strumenti di sviluppo dipenderà dalla tua versione di Chrome. Nel tempo potrebbe cambiare un po', ma dovrebbe essere comunque molto simile.
 
@@ -51,7 +51,11 @@ Anche l'aspetto è molto simile. Quando avrai imparato come utilizzare uno di qu
 
 Safari (Mac browser, non supportato da Windows/Linux) è un pò speciale in questo ambito. E' necessario attivare prima il "Menu di Sviluppo".
 
+<<<<<<< HEAD
 Apri le Impostazioni e vai sul pannello "Avanzate". In basso troverai un'opzione da spuntare:
+=======
+Open Settings and go to the "Advanced" pane. There's a checkbox at the bottom:
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 ![safari](safari.png)
 

1-js/02-first-steps/04-variables/3-uppercast-constant/task.md

@@ -12,13 +12,18 @@ const birthday = '18.04.1982';
 const age = someCode(birthday);
 ```
 
+<<<<<<< HEAD
 Abbiamo una costante `birthday` che indica una data e  `age` che viene calcolata da `birthday` tramite un algoritmo (non viene fornito per brevità, e perchè non è importante per descrivere l'argomento).
+=======
+Here we have a constant `birthday` for the date, and also the `age` constant.
+
+The `age` is calculated from `birthday` using `someCode()`, which means a function call that we didn't explain yet (we will soon!), but the details don't matter here, the point is that `age` is calculated somehow based on the `birthday`.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Sarebbe giusto utilizzare lettere maiuscole per `birthday`? E per `age`? O anche per entrambe?
 
 ```js
-const BIRTHDAY = '18.04.1982'; // make uppercase?
+const BIRTHDAY = '18.04.1982'; // make birthday uppercase?
 
-const AGE = someCode(BIRTHDAY); // make uppercase?
+const AGE = someCode(BIRTHDAY); // make age uppercase?
 ```
-

1-js/02-first-steps/04-variables/article.md

@@ -63,7 +63,12 @@ let age = 25;
 let message = 'Hello';
 ```
 
+<<<<<<< HEAD
 Alcune persone scrivono variabili multiple in questo modo:
+=======
+Some people also define multiple variables in this multiline style:
+
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 ```js no-beautify
 let user = 'John',
   age = 25,
@@ -87,23 +92,38 @@ Nei vecchi script potresti trovare: `var` piuttosto che `let`:
 *!*var*/!* message = 'Hello';
 ```
 
+<<<<<<< HEAD
 La parola chiave `var` è *quasi* la stessa cosa di `let`. Dichiara comunque una variabile, ma in un maniera leggermente diversa, "vecchio stile".
 
 Ci sono delle sottili differenze tra `let` e `var`, ma per ora non hanno importanza. Le copriremo in dettaglio più avanti, nel capitolo <info:var>.
+=======
+The `var` keyword is *almost* the same as `let`. It also declares a variable but in a slightly different, "old-school" way.
+
+There are subtle differences between `let` and `var`, but they do not matter to us yet. We'll cover them in detail in the chapter <info:var>.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 ````
 
 ## Un'analogia con il mondo reale
 
 Possiamo comprendere meglio il concetto di "variabile" se la immaginiamo come una scatola per dati, con appiccicata un'etichetta univoca.
 
+<<<<<<< HEAD
 Per esempio, la variabile `message` può essere immaginata come una scatola con etichetta `"message"` con il valore `"Hello!"` al suo interno:
+=======
+For instance, the variable `message` can be imagined as a box labelled `"message"` with the value `"Hello!"` in it:
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 ![](variable.svg)
 
 Possiamo inserire qualsiasi valore all'interno della scatola.
 
 Possiamo anche cambiarlo. Il valore può cambiare tutte le volte che ne abbiamo bisogno:
 
+<<<<<<< HEAD
+=======
+We can also change it as many times as we want:
+
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 ```js run
 let message;
 
@@ -148,12 +168,21 @@ let message = "That"; // SyntaxError: 'message' has already been declared
 Quindi, dovremmo dichiarare una variabile una volta sola, e farne riferimento senza la parola chiave `let`.
 ````
 
+<<<<<<< HEAD
 ```smart header="Linguaggi funzionali"
 Può essere interessante sapere che esistono anche linguaggi di programmazione [funzionale](https://en.wikipedia.org/wiki/Functional_programming) che vietano di cambiare il valore di una variabile. Per esempio, [Scala](http://www.scala-lang.org/) o [Erlang](http://www.erlang.org/).
+=======
+```smart header="Functional languages"
+It's interesting to note that there exist so-called [pure functional](https://en.wikipedia.org/wiki/Purely_functional_programming) programming languages, such as [Haskell](https://en.wikipedia.org/wiki/Haskell), that forbid changing variable values.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 In questo tipo di linguaggi, una volta che il valore viene memorizzato "dentro la scatola", ci rimane per sempre. Se abbiamo bisogno di memorizzare qualcos altro, il linguaggio ci forza a creare una nuova scatola (dichiarare una nuova variabile). Non possiamo quindi riutilizzare quelle vecchie.
 
+<<<<<<< HEAD
 Anche se potrebbero sembrare un po' strano a prima vista, questi linguaggi sono veramente capaci di sviluppare grandi cose. Inoltre, ci sono certe situazioni come calcoli paralleli in cui questi limiti portano dei benefici. Studiare un linguaggio di questo tipo (anche se non abbiamo intenzione di utilizzarlo a breve) è consigliato per allargare le proprie conoscenze.
+=======
+Though it may seem a little odd at first sight, these languages are quite capable of serious development. More than that, there are areas like parallel computations where this limitation confers certain benefits.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 ```
 
 ## Nomi delle variabili [#variable-naming]
@@ -191,19 +220,32 @@ let 1a; // non può cominciare con una stringa
 let my-name; // '-' non è consentito nei nomi
 ```
 
+<<<<<<< HEAD
 ```smart header="La questione delle lettere"
 Le variabili `apple` ed `AppLE` sono distinte.
 ```
 
 ````smart header="Le lettere non latine sono permesse, ma sono sconsigliate"
 E' possibile utilizzare qualsiasi alfabeto, compreso quello cirillico o addirittura i geroglifici:
+=======
+```smart header="Case matters"
+Variables named `apple` and `APPLE` are two different variables.
+```
+
+````smart header="Non-Latin letters are allowed, but not recommended"
+It is possible to use any language, including Cyrillic letters, Chinese logograms and so on, like this:
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 ```js
 let имя = '...';
 let 我 = '...';
 ```
 
+<<<<<<< HEAD
 Tecnicamente, non ci sono errori, questo tipo di nomi sono permessi, ma la tradizione internazionale è di utilizzare l'alfabeto inglese per il nome delle variabili. Anche se stiamo scrivendo un piccolo script, questo potrebbe infatti avere una lunga vita. Persone di altre nazionalità potrebbero aver bisogno di leggerlo.
+=======
+Technically, there is no error here. Such names are allowed, but there is an international convention to use English in variable names. Even if we're writing a small script, it may have a long life ahead. People from other countries may need to read it sometime.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 ````
 
 ````warn header="Nomi riservati"
@@ -258,12 +300,20 @@ const myBirthday = '18.04.1982';
 myBirthday = '01.01.2001'; // errore, non è possibile riassegnare la costante!
 ```
 
+<<<<<<< HEAD
 Quando il programmatore è sicuro che il valore della variabile non cambierà mai, può utilizzare `const` per soddisfare questa esigenza, rendendolo cosi esplicito.
 
+=======
+When a programmer is sure that a variable will never change, they can declare it with `const` to guarantee and communicate that fact to everyone.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 ### Le costanti maiuscole
 
+<<<<<<< HEAD
 Una pratica molto diffusa è di utilizzare le variabili costanti come alias di valori difficili da ricordare, e che sono noti prima dell'esecuzione.
+=======
+There is a widespread practice to use constants as aliases for difficult-to-remember values that are known before execution.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Questo tipo di costanti vengono identificate con lettere maiuscole e underscore.
 
@@ -288,36 +338,62 @@ Benefici:
 
 Quando dovremmo utilizzare lettere maiuscole per una costante, e quando invece trattarle come normali variabili? Facciamo un pò di chiarezza.
 
+<<<<<<< HEAD
 Essere una "costante" significa che il valore non potrà mai cambiare. Ci sono costanti che sono note prima dell'esecuzione (come la codifica esadecimale del colore rosso), e ci sono quelle che vengono *calcolate* durante l'esecuzione, ma non cambieranno più dopo che gli sarà stato assegnato un valore.
 
 Per esempio:
+=======
+Being a "constant" just means that a variable's value never changes. But some constants are known before execution (like a hexadecimal value for red) and some constants are *calculated* in run-time, during the execution, but do not change after their initial assignment.
+
+For instance:
+
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 ```js
 const pageLoadTime = /* tempo necessario da una pagina web per caricare */;
 ```
 
+<<<<<<< HEAD
 Il valore di `pageLoadTime` non è noto prima del caricamento della pagina, quindi viene trattato come una normale variabile. Ma rimane comunque una costante, perché non potrà più cambiare dopo che gli sarà stato assegnato un valore.
 
 In altre parole, i nomi delle costanti in maiuscolo vengono utilizzati con variabili dal valore noto prima dell'esecuzione.
+=======
+The value of `pageLoadTime` is not known before the page load, so it's named normally. But it's still a constant because it doesn't change after the assignment.
+
+In other words, capital-named constants are only used as aliases for "hard-coded" values.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 ## Dare i giusti nomi alle cose
 
 Parlando di variabili, c'è un'altra cosa estremamente importante.
 
 Il nome di una variabile dovrebbe sempre essere pulito, ovvio e descrittivo del suo contenuto.
 
+<<<<<<< HEAD
 Dare i giusti nomi alle variabili è una delle abilità più importanti (e difficili) nella programmazione. 
 Una rapida occhiata ai nomi delle variabili può rivelare se il codice è stato scritto da un principiante o da uno sviluppatore esperto.
 
 In un progetto reale, la maggior parte del tempo lo si perde a modificare ed estendere del codice già esistente, piuttosto che riscriverne uno nuovo. E quando ritorneremo sul codice, dopo aver fatto qualcos'altro, sarà molto pù facile trovare informazioni se sono ben descritte. In altre parole, quando le variabili utilizzano dei nomi efficaci.
+=======
+Variable naming is one of the most important and complex skills in programming. A glance at variable names can reveal which code was written by a beginner versus an experienced developer.
+
+In a real project, most of the time is spent modifying and extending an existing code base rather than writing something completely separate from scratch. When we return to some code after doing something else for a while, it's much easier to find information that is well-labelled. Or, in other words, when the variables have good names.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Quindi è utile spendere del tempo a pensare il giusto nome per una variabile, prima di dichiararla. Questo approccio vi ripagherà.
 
 Alcune regole da seguire:
 
+<<<<<<< HEAD
 - Utilizzare nomi leggibili da persone, come `userName` o `shoppingCart`.
 - Evitate abbreviazioni o nomi brevi come `a`, `b`, `c`, senza che abbiano veramente senso.
 - Rendete il nome il più descrittivo e preciso possibile. Esempi di pessimi nomi sono `data` e `value`. Questo tipo di nomi non dicono niente. Si possono utilizzare eccezionalmente se il contesto rende esplicito il significato.
 - Definire delle regole personali o con il team. Se il visitatore del sito viene chiamato "user" allora dovremmo chiamare la relativa variabile come `currentUser` o `newUser`, non `currentVisitor` o `newManInTown`.
+=======
+- Use human-readable names like `userName` or `shoppingCart`.
+- Stay away from abbreviations or short names like `a`, `b`, and `c`, unless you know what you're doing.
+- Make names maximally descriptive and concise. Examples of bad names are `data` and `value`. Such names say nothing. It's only okay to use them if the context of the code makes it exceptionally obvious which data or value the variable is referencing.
+- Agree on terms within your team and in your mind. If a site visitor is called a "user" then we should name related variables `currentUser` or `newUser` instead of `currentVisitor` or `newManInTown`.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Sembra facile? Infatti lo è, ma trovare dei buoni nomi che siano precisi e descrittivi nella pratica non è sempre cosi semplice.
 

1-js/02-first-steps/05-types/article.md

@@ -46,13 +46,23 @@ Oltre a i normali valori numeri, esistono anche i "valori numerici speciali" che
     alert( "not a number" / 2 ); // NaN, è una divisione errata
     ```
 
+<<<<<<< HEAD
     `NaN` è "fisso". Qualsiasi operazione su `NaN` restituirà `NaN`:
+=======
+    `NaN` is sticky. Any further mathematical operation on `NaN` returns `NaN`:
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
     ```js run
-    alert( "not a number" / 2 + 5 ); // NaN
+    alert( NaN + 1 ); // NaN
+    alert( 3 * NaN ); // NaN
+    alert( "not a number" / 2 - 1 ); // NaN
     ```
 
+<<<<<<< HEAD
     Quindi, se è presente un `NaN` da qualche parte nell'operazione matematica, questo si propagherà fino al risultato.
+=======
+    So, if there's a `NaN` somewhere in a mathematical expression, it propagates to the whole result (there's only one exception to that: `NaN ** 0` is `1`).
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 ```smart header="Le operazioni matematiche sono sicure"
 In JavaScript le operazioni matematiche sono sicure. Possiamo fare qualsiasi cosa: dividere per zero, trattare stringhe non numeriche come numeri, etc.
@@ -66,9 +76,26 @@ Vedremo di più su come lavorare con i numeri nel capitolo <info:number>.
 
 ## BigInt [#bigint-type]
 
+<<<<<<< HEAD
 In JavaScript, il tipo "number" non può rappresentare valori interni più grandi di <code>(2<sup>53</sup>-1)</code> (che equivale a `9007199254740991`), o minori di <code>-(2<sup>53</sup>-1)</code>. Questa è una limitazione tecnica dovuta alla loro rappresentazione interna.
 
 Per la maggior parte degli scopi, questo intervallo è sufficiente, ma in alcuni casi potremmo aver bisogno di numeri molto grandi, ad esempio per la crittografia o timestamp con precisione al microsecondo.
+=======
+In JavaScript, the "number" type cannot safely represent integer values larger than <code>(2<sup>53</sup>-1)</code> (that's `9007199254740991`), or less than <code>-(2<sup>53</sup>-1)</code> for negatives.
+
+To be really precise, the "number" type can store larger integers (up to <code>1.7976931348623157 * 10<sup>308</sup></code>), but outside of the safe integer range <code>±(2<sup>53</sup>-1)</code> there'll be a precision error, because not all digits fit into the fixed 64-bit storage. So an "approximate" value may be stored.
+
+For example, these two numbers (right above the safe range) are the same:
+
+```js
+console.log(9007199254740991 + 1); // 9007199254740992
+console.log(9007199254740991 + 2); // 9007199254740992
+```
+
+So to say, all odd integers greater than <code>(2<sup>53</sup>-1)</code> can't be stored at all in the "number" type.
+
+For most purposes <code>±(2<sup>53</sup>-1)</code> range is quite enough, but sometimes we need the entire range of really big integers, e.g. for cryptography or microsecond-precision timestamps.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Il tipo `BigInt` è stato aggiunto di recente al linguaggio, e consente di rappresentare numeri interi di lunghezza arbitraria.
 
@@ -81,13 +108,16 @@ const bigInt = 1234567890123456789012345678901234567890n;
 
 Poiché i `BigInt` sono utilizzati raramente, non li analizzeremo in questo articolo, ma li vedremo più in dettaglio nel capitolo dedicato <info:bigint>.
 
+<<<<<<< HEAD
 
 ```smart header="Problemi di compatibilità"
 Attualmente, `BigInt` sono supportati da Firefox/Chrome/Edge/Safari, ma non da IE.
 ```
 
 Potete sempre verificare [la tabella di compatibilità di *MDN* BigInt](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt#Browser_compatibility) per sapere quali versioni dei browser li supportano.
 
+=======
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 ## String
 
 Una stringa in JavaScript deve essere tra apici.
@@ -211,7 +241,11 @@ Il tipo `symbol` viene utilizzato per creare identificatori unici per gli oggett
 
 L'operatore `typeof` ritorna il tipo dell'argomento. E' utile quando vogliamo lavorare con valori di tipi differenti, o per eseguire controlli rapidi.
 
+<<<<<<< HEAD
 Sono supportate due sintassi:
+=======
+The `typeof` operator returns the type of the operand. It's useful when we want to process values of different types differently or just want to do a quick check.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 1. Come operatore: `typeof x`.
 2. Come funzione: `typeof(x)`.
@@ -271,4 +305,27 @@ L'operatore `typeof` ci consente di vedere quale tipo è memorizzato nella varia
 - Ritorna una stringa con il nome del tipo, come `"string"`.
 - Il valore `null` ritorna `"object"` -- è un errore del linguaggio, infatti non è un oggetto.
 
+<<<<<<< HEAD
 Nel prossimo capitolo ci concentreremo nei tipi primitivi e quando avremo preso familiarità, passeremo agli oggetti.
+=======
+There are 8 basic data types in JavaScript.
+
+- Seven primitive data types:
+    - `number` for numbers of any kind: integer or floating-point, integers are limited by <code>±(2<sup>53</sup>-1)</code>.
+    - `bigint` for integer numbers of arbitrary length.
+    - `string` for strings. A string may have zero or more characters, there's no separate single-character type.
+    - `boolean` for `true`/`false`.
+    - `null` for unknown values -- a standalone type that has a single value `null`.
+    - `undefined` for unassigned values -- a standalone type that has a single value `undefined`.
+    - `symbol` for unique identifiers.
+- And one non-primitive data type:
+    - `object` for more complex data structures.
+
+The `typeof` operator allows us to see which type is stored in a variable.
+
+- Usually used as `typeof x`, but `typeof(x)` is also possible.
+- Returns a string with the name of the type, like `"string"`.
+- For `null` returns `"object"` -- this is an error in the language, it's not actually an object.
+
+In the next chapters, we'll concentrate on primitive values and once we're familiar with them, we'll move on to objects.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b

1-js/02-first-steps/07-type-conversions/article.md

@@ -6,8 +6,15 @@ Ad esempio, `alert` converte automaticamente un valore qualsiasi in una stringa,
 
 Ci sono invece casi in cui è necessario convertire esplicitamente i valori per poter evitare errori.
 
+<<<<<<< HEAD
 ```smart header="Non parliamo ancora di oggetti"
 In questo capitolo non parleremo ancora di oggetti ma ci dedicheremo ai tipi primitivi. Approfondiremo gli oggetti e la loro conversione dopo averli studiati, nel capitolo <info:object-toprimitive>.
+=======
+```smart header="Not talking about objects yet"
+In this chapter, we won't cover objects. For now, we'll just be talking about primitives.
+
+Later, after we learn about objects, in the chapter <info:object-toprimitive> we'll see how objects fit in.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 ```
 
 ## Conversione di stringhe
@@ -32,7 +39,11 @@ La conversione in stringa è quella più semplice. Il valore `false` diventa la
 
 ## Conversione numerica
 
+<<<<<<< HEAD
 La conversione a `Number` viene applicata automaticamente nelle funzioni ed espressioni matematiche.
+=======
+Numeric conversion in mathematical functions and expressions happens automatically.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Ad esempio, quando la divisione `/` viene applicata ad un tipo non numerico:
 
@@ -67,8 +78,13 @@ Le regole di conversione numerica:
 |-------|-------------|
 |`undefined`|`NaN`|
 |`null`|`0`|
+<<<<<<< HEAD
 |<code>true&nbsp;e&nbsp;false</code> | `1` e `0` |
 | `string` | Gli spazi bianchi all'inizio e alla fine vengono rimossi. Se la stringa rimanente è vuota, il risultato sarà `0`. Altrimenti, il numero viene "letto" dalla stringa. Un errore restituirà `NaN`. |
+=======
+|<code>true&nbsp;and&nbsp;false</code> | `1` and `0` |
+| `string` | Whitespaces (includes spaces, tabs `\t`, newlines `\n` etc.) from the start and end are removed. If the remaining string is empty, the result is `0`. Otherwise, the number is "read" from the string. An error gives `NaN`. |
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Esempi:
 
@@ -140,7 +156,11 @@ La conversione segue le seguenti regole:
 |`undefined`|`NaN`|
 |`null`|`0`|
 |<code>true&nbsp;/&nbsp;false</code> | `1 / 0` |
+<<<<<<< HEAD
 | `string` | La stringa viene letta per "com'è", gli spazi bianchi agli estremi vengono ignorati. Una stringa vuota diventa `0`. Un errore restituisce `NaN`. |
+=======
+| `string` | The string is read "as is", whitespaces (includes spaces, tabs `\t`, newlines `\n` etc.) from both sides are ignored. An empty string becomes `0`. An error gives `NaN`. |
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 **`Conversione booleana`** -- Avviene nelle operazioni logiche, può anche essere richiamato esplicitamente con `Boolean(value)`.
 

1-js/02-first-steps/08-operators/3-primitive-conversions-questions/solution.md

@@ -16,10 +16,20 @@ undefined + 1 = NaN // (6)
 " \t \n" - 2 = -2 // (7)
 ```
 
+<<<<<<< HEAD
 1. L'addizione con una stringa `"" + 1` converte `1` a stringa: `"" + 1 = "1"`, applichiamo la stessa regola a `"1" + 0`.
 2. La sottrazione `-` (come molte altre operazioni matematiche) funziona solamente con i numeri, quindi una stringa vuota come: `""` viene convertita in `0`.
 3. La somma con una stringa appende in coda alla stringa il numero `5`.
 4. La sottrazione converte sempre in numero, quindi `"  -9  "` diventa `-9` (gli spazi vuoti vengono ignorati).
 5. `null` diventa `0` dopo la conversione numerica.
 6. `undefined` diventa `NaN` dopo la conversione numerica.
 7. Gli spazi all'inizio e alla fine di una stringa vengono rimossi quando questa viene convertita ad numero. In questo caso l'intera stringa è composta da spazi, come `\t`, `\n` ed uno "spazio" normale tra di essi. Quindi allo stesso modo di una stringa vuota, diventa `0`.
+=======
+1. The addition with a string `"" + 1` converts `1` to a string: `"" + 1 = "1"`, and then we have `"1" + 0`, the same rule is applied.
+2. The subtraction `-` (like most math operations) only works with numbers, it converts an empty string `""` to `0`.
+3. The addition with a string appends the number `5` to the string.
+4. The subtraction always converts to numbers, so it makes `"  -9  "` a number `-9` (ignoring spaces around it).
+5. `null` becomes `0` after the numeric conversion.
+6. `undefined` becomes `NaN` after the numeric conversion.
+7. Space characters are trimmed off string start and end when a string is converted to a number. Here the whole string consists of space characters, such as `\t`, `\n` and a "regular" space between them. So, similarly to an empty string, it becomes `0`.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b

1-js/02-first-steps/08-operators/article.md

@@ -51,8 +51,14 @@ Il risultato di `a % b` è il [resto](https://en.wikipedia.org/wiki/Remainder) d
 Ad esempio:
 
 ```js run
+<<<<<<< HEAD
 alert( 5 % 2 ); // 1, è il resto dell'operazione 5 diviso 2
 alert( 8 % 3 ); // 2, è il resto dell'operazione 8 diviso 3
+=======
+alert( 5 % 2 ); // 1, the remainder of 5 divided by 2
+alert( 8 % 3 ); // 2, the remainder of 8 divided by 3
+alert( 8 % 4 ); // 0, the remainder of 8 divided by 4
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 ```
 
 ### Elevamento a Potenza **
@@ -70,7 +76,11 @@ alert( 2 ** 3 ); // 2³ = 8
 alert( 2 ** 4 ); // 2⁴ = 16
 ```
 
+<<<<<<< HEAD
 Come in matematica, l'esponente può essere anche un valore numerico non intero.
+=======
+Just like in maths, the exponentiation operator is defined for non-integer numbers as well.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Ad esempio, la radice quadrata può essere vista come un elevamento a potenza con esponente `1/2`:
 
@@ -82,7 +92,11 @@ alert( 8 ** (1/3) ); // 2 (potenza 1/3 equivale alla radice cubica)
 
 ##  Concatenazione di stringhe, operatore binario +
 
+<<<<<<< HEAD
 Adesso diamo un'occhiata alle caratteristiche degli operatori in JavaScript, che vanno oltre l'aritmetica scolastica.
+=======
+Let's meet the features of JavaScript operators that are beyond school arithmetics.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Solitamente l'operatore di somma `+` viene utilizzato per sommare due numeri.
 
@@ -199,22 +213,30 @@ Un estratto della [tabella delle precedenze](https://developer.mozilla.org/en/Ja
 | Precedence | Name | Sign |
 |------------|------|------|
 | ... | ... | ... |
-| 17 | unary plus | `+` |
-| 17 | unary negation | `-` |
-| 16 | exponentiation | `**` |
-| 15 | multiplication | `*` |
-| 15 | division | `/` |
-| 13 | addition | `+` |
-| 13 | subtraction | `-` |
+| 14 | unary plus | `+` |
+| 14 | unary negation | `-` |
+| 13 | exponentiation | `**` |
+| 12 | multiplication | `*` |
+| 12 | division | `/` |
+| 11 | addition | `+` |
+| 11 | subtraction | `-` |
 | ... | ... | ... |
-| 3 | assignment | `=` |
+| 2 | assignment | `=` |
 | ... | ... | ... |
 
+<<<<<<< HEAD
 Come possiamo vedere, la "somma unaria"(unary plus) ha una priorità di `17`, che è maggiore del `13` dell'addizione(`+` binario). Questo è il motivo per cui l'espressione `"+apples + +oranges"` esegue prima il `+` unario, e successivamente l'addizione.
+=======
+As we can see, the "unary plus" has a priority of `14` which is higher than the `11` of "addition" (binary plus). That's why, in the expression `"+apples + +oranges"`, unary pluses work before the addition.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 ## Assegnazione
 
+<<<<<<< HEAD
 Da notare che anche l'assegnazione `=` è un operatore. Viene infatti elencato nella tabella delle precedenze con una priorità molto bassa: `3`.
+=======
+Let's note that an assignment `=` is also an operator. It is listed in the precedence table with the very low priority of `2`.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Questo è il motivo per cui quando assegniamo un valore ad una variabile, come `x = 2 * 2 + 1`, i calcoli vengono eseguiti per primi, e successivamente viene valutato l'operatore `=`, che memorizza il risultato in `x`.
 
@@ -312,9 +334,14 @@ Questi operatori hanno la stessa precedenza delle normali assegnazioni, quindi v
 ```js run
 let n = 2;
 
-n *= 3 + 5;
+n *= 3 + 5; // right part evaluated first, same as n *= 8
 
+<<<<<<< HEAD
 alert( n ); // 16  (prima viene valutata la parte destra, equivale a n *= 8)
+=======
+alert( n ); // 16
+```
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 ## Incremento/Decremento
 
@@ -445,7 +472,11 @@ La lista degli operatori:
 - RIGHT SHIFT ( `>>` )
 - ZERO-FILL RIGHT SHIFT ( `>>>` )
 
+<<<<<<< HEAD
 Questi operatori vengono utilizzati molto raramente, quando abbiamo bisogno di lavorare con i numeri al più basso livello (bit per bit).  Non avremo bisogno di questi operatori molto presto, poiché lo sviluppo web ne fa un uso limitato, ma in alcune aree speciali, come la crittografia, sono utili.In caso di necessità potete leggere l'articolo [operatori BitWise](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators) su MDN.
+=======
+These operators are used very rarely, when we need to fiddle with numbers on the very lowest (bitwise) level. We won't need these operators any time soon, as web development has little use of them, but in some special areas, such as cryptography, they are useful. You can read the [Bitwise Operators](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators#bitwise_operators) chapter on MDN when a need arises.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 
 ## Virgola

1-js/02-first-steps/10-ifelse/article.md

@@ -68,7 +68,11 @@ if (cond) {
 
 ## La clausola "else" 
 
+<<<<<<< HEAD
 L'istruzione `if` può essere seguita da un blocco opzionale "else". Questo viene eseguito quando la condizione è falsa.
+=======
+The `if` statement may contain an optional `else` block. It executes when the condition is falsy.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Ad esempio:
 ```js run
@@ -180,10 +184,17 @@ alert( message );
 
 Potrebbe essere difficile, inizialmente, capirne la logica. Ma dopo averlo guardato da più vicino ci accorgeremo che è una semplice sequenza di condizioni.
 
+<<<<<<< HEAD
 1. Il primo operatore "?" controlla `age < 3`.
 2. Se è vero -- ritorna `'Hi, baby!'`, altrimenti -- segue la colonna `":"`, controlla `age < 18`.
 3. Se questo è vero -- ritorna `'Hello!'`, altrimenti -- segue la colonna `":"`, controlla `age < 100`.
 4. Se questo è vero -- ritorna `'Greetings!'`, altrimenti -- segue la colonna `":"`, ritorna `'What an unusual age!'`.
+=======
+1. The first question mark checks whether `age < 3`.
+2. If true -- it returns `'Hi, baby!'`. Otherwise, it continues to the expression after the colon ":", checking `age < 18`.
+3. If that's true -- it returns `'Hello!'`. Otherwise, it continues to the expression after the next colon ":", checking `age < 100`.
+4. If that's true -- it returns `'Greetings!'`. Otherwise, it continues to the expression after the last colon ":", returning `'What an unusual age!'`.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 La stessa logica riscritta utilizzando `if..else`:
 

1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/solution.md

@@ -1,6 +1,6 @@
 La risposta è: `null`, perchè è il primo valore falso nella lista.
 
 ```js run
-alert( 1 && null && 2 );
+alert(1 && null && 2);
 ```
 

1-js/02-first-steps/12-nullish-coalescing-operator/article.md

@@ -4,7 +4,11 @@
 
 Il *nullish coalescing operator* è rappresentato da due punti di domanda `??`.
 
+<<<<<<< HEAD
 Siccome trattiamo `null` e `undefined` in modo simile, avremo bisogno di una definizione particolare. In questo articolo, diremo che un'espressione è "definita" quando non è né `null` né `undefined`.
+=======
+As it treats `null` and `undefined` similarly, we'll use a special term here, in this article. For brevity, we'll say that a value is "defined" when it's neither `null` nor `undefined`.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Il risultato di `a ?? b` è:
 - se `a` è definito, allora `a`,
@@ -22,27 +26,39 @@ result = (a !== null && a !== undefined) ? a : b;
 
 Un caso d'uso comune per l'operatore `??` è quello di fornire un valore di default per una variabile potenzialmente "non definita".
 
+<<<<<<< HEAD
 Per esempio, qui mostriamo `Anonymous` se `user` non è definito:
+=======
+The common use case for `??` is to provide a default value.
+
+For example, here we show `user` if its value isn't `null/undefined`, otherwise `Anonymous`:
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 ```js run
 let user;
 
-alert(user ?? "Anonymous"); // Anonymous (user not defined)
+alert(user ?? "Anonymous"); // Anonymous (user is undefined)
 ```
 
 Ovviamente, se `user` ha un qualsiasi valore eccetto `null/undefined`, allora vedremo quel valore:
 
 ```js run
 let user = "John";
 
-alert(user ?? "Anonymous"); // John (user defined)
+alert(user ?? "Anonymous"); // John (user is not null/undefined)
 ```
 
 Possiamo anche usare una sequenza di `??` per selezionare, da una lista, il primo valore che non sia `null/undefined`.
 
+<<<<<<< HEAD
 Per esempio, supponiamo di avere i dati di un utente nelle variabili `firstName`, `lastName` o `nickName`. Tutte queste potrebbero essere non definite, se l'utente dovesse decidere di non inserirne i valori.
 
 Vorremmo visualizzare il nome dell'utente usando una di queste variabili, oppure mostrare "Anonymous" se nessuna di esse è definita.
+=======
+Let's say we have a user's data in variables `firstName`, `lastName` or `nickName`. All of them may be not defined, if the user decided not to fill in the corresponding values.
+
+We'd like to display the user name using one of these variables, or show "Anonymous" if all of them are `null/undefined`.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Usiamo l'operatore `??`:
 
@@ -74,7 +90,11 @@ alert(firstName || lastName || nickName || "Anonymous"); // Supercoder
 */!*
 ```
 
+<<<<<<< HEAD
 L'operatore OR `||` esiste sin dagli inizi di JavaScript e gli sviluppatori lo hanno usato a tale scopo per molto tempo.
+=======
+Historically, the OR `||` operator was there first. It's been there since the beginning of JavaScript, so developers were using it for such purposes for a long time.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Il nullish coalescing operator `??`, invece, è stato aggiunto  recentemente. La ragione è che alcuni sviluppatori non erano del tutto contenti dell'operatore `||`.
 
@@ -104,9 +124,17 @@ Se un'altezza pari a zero è un valore accettabile, questo non dovrebbe essere r
 
 ## Precedenza
 
+<<<<<<< HEAD
 La precedenza dell'operatore `??` è piuttosto bassa: `5` nella [MDN table](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table). Quindi `??` è valutato prima di `=` e `?`, ma dopo la maggior parte degli altri operatori, come `+` o `*`.
 
 Quindi, se volessimo scegliere un valore tramite l'operatore `??` in un'espressione contenente altri operatori, dovremmo considerare l'utilizzo delle parentesi:
+=======
+The precedence of the `??` operator is the same as `||`. They both equal `3` in the [MDN table](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table).
+
+That means that, just like `||`, the nullish coalescing operator `??` is evaluated before `=` and `?`, but after most other operations, such as `+`, `*`.
+
+So we may need to add parentheses in expressions like this:
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 ```js run
 let height = null;
@@ -124,7 +152,11 @@ Altrimenti, se omettessimo le parentesi, siccome `*` ha una precedenza maggiore
 // senza parentesi
 let area = height ?? 100 * width ?? 50;
 
+<<<<<<< HEAD
 // ...funziona allo stesso modo del seguente codice (probabilmente non ciò che vogliamo)
+=======
+// ...works this way (not what we want):
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 let area = height ?? (100 * width) ?? 50;
 ```
 

1-js/02-first-steps/13-while-for/article.md

@@ -6,7 +6,24 @@ Ad esempio, quando abbiamo bisogno di ritornare, una dopo l'altra, della merce d
 
 I *cicli* sono un modo di ripetere una stessa parte di codice più volte.
 
+<<<<<<< HEAD
 ## Il ciclo "while" 
+=======
+```smart header="The for..of and for..in loops"
+A small announcement for advanced readers.
+
+This article covers only basic loops: `while`, `do..while` and `for(..;..;..)`.
+
+If you came to this article searching for other types of loops, here are the pointers:
+
+- See [for..in](info:object#forin) to loop over object properties.
+- See [for..of](info:array#loops) and [iterables](info:iterable) for looping over arrays and iterable objects.
+
+Otherwise, please read on.
+```
+
+## The "while" loop
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Il ciclo `while` ha la seguente sintassi:
 
@@ -161,11 +178,14 @@ for (i = 0; i < 3; i++) { // utilizza una variabile esistente
 
 alert(i); // 3; la variabile `i` è accessibile (è stata dichiarata fuori dal corpo del ciclo)
 ```
-
 ````
 
+<<<<<<< HEAD
 
 ### Parti opzionali
+=======
+### Skipping parts
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Ogni parte del ciclo `for` è opzionale.
 
@@ -265,7 +285,13 @@ for (let i = 0; i < 10; i++) {
 }
 ```
 
+<<<<<<< HEAD
 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à.
+=======
+From a technical point of view, this is identical to the example above. Surely, we can just wrap the code in an `if` block instead of using `continue`.
+
+But as a side effect, this created one more level of nesting (the `alert` call inside the curly braces). If the code inside of `if` is longer than a few lines, that may decrease the overall readability.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 ````
 
 ````warn header="Vietato `break/continue` alla desta di '?'"
@@ -283,7 +309,6 @@ if (i > 5) {
 
 ...E lo riscriviamo utilizzando l'operatore ternario:
 
-
 ```js no-beautify
 (i > 5) ? alert(i) : *!*continue*/!*; // continue non è consentito qui
 ```
@@ -320,7 +345,12 @@ Abbiamo bisogno di un modo per bloccare il processo se l'utente annulla l'input.
 
 Un semplice `break` dopo la variabile `input` interromperebbe solo il ciclo più interno. Questo non è sufficiente. I *label* ci vengono in soccorso.
 
+<<<<<<< HEAD
 Un *label* ("etichetta") è un identificatore seguito da ":" e da un ciclo:
+=======
+A *label* is an identifier with a colon before a loop:
+
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 ```js
 labelName: for (...) {
   ...
@@ -344,6 +374,7 @@ Come nell'esempio:
     // fa qualcosa con i valori...
   }
 }
+
 alert('Done!');
 ```
 
@@ -363,14 +394,24 @@ Anche la direttiva `continue` può essere utilizzata con un'etichetta. In questo
 ````warn header="I *label* non equivalgono a \"goto\""
 I *label* non permettono di saltare in un punto arbitrario del codice.
 
+<<<<<<< HEAD
 Ad esempio, non è possibile:
+=======
+For example, it is impossible to do this:
+
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 ```js
 break label;  // non salta all'etichetta sotto
 
 label: for (...)
 ```
 
+<<<<<<< HEAD
 La direttiva `break` deve essere all'interno del blocco di codice. Tecnicamente l'etichettatura funzionerà con qualsiasi blocco di codice, ad esempio:
+=======
+A `break` directive must be inside a code block. Technically, any labelled code block will do, e.g.:
+
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 ```js
 label: {
   // ...

1-js/02-first-steps/14-switch/article.md

@@ -140,7 +140,11 @@ switch (a) {
 
 Ora sia `3` che `5` mostreranno lo stesso messaggio.
 
+<<<<<<< HEAD
 L'abilità di "raggruppare" più `case` è un effetto collaterale di come `switch/case` funziona senza `break`. Qui l'esecuzione del `case 3` inizia dalla linea `(*)` e prosegue fino a `case 5`, perché non c'è alcun `break`.
+=======
+The ability to "group" cases is a side effect of how `switch/case` works without `break`. Here the execution of `case 3` starts from the line `(*)` and goes through `case 5`, because there's no `break`.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 ## Il tipo conta
 

1-js/02-first-steps/15-function-basics/1-if-else-required/solution.md

@@ -1 +1,7 @@
-No, non ci sono differenze.
+<<<<<<< HEAD
+No, non ci sono differenze.
+=======
+No difference!
+
+In both cases, `return confirm('Did parents allow you?')` executes exactly when the `if` condition is falsy.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b

1-js/02-first-steps/15-function-basics/article.md

@@ -24,7 +24,7 @@ La parola chiave `function` va posta all'inizio; viene seguita dal *nome della f
 
 ```js
 function name(parameter1, parameter2, ... parameterN) {
-  ...body...
+ // body
 }
 ```
 
@@ -177,8 +177,13 @@ Quando un valore viene passato come parametro di funzione, vine anche chiamato *
 In altre parole
 In other words, per chiarire questi termini:
 
+<<<<<<< HEAD
 - Un parametro è la variabile elencata tra parentesi nella dichiarazione della funzione (fa parte della dichiarazione).
 - Un argomento è il valore passato alla funzione quando viene chiamata (fa parte della chiamata).
+=======
+- A parameter is the variable listed inside the parentheses in the function declaration (it's a declaration time term).
+- An argument is the value that is passed to the function when it is called (it's a call time term).
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Dichiariamo le funzioni elencando i loro parametri, quindi le chiamiamo passando gli argomenti.
 
@@ -206,7 +211,17 @@ function showMessage(from, *!*text = "no text given"*/!*) {
 showMessage("Ann"); // Ann: nessun text fornito
 ```
 
+<<<<<<< HEAD
 Adesso, se il parametro `text` non viene passato, assumerà il valore `"no text given"`
+=======
+Now if the `text` parameter is not passed, it will get the value `"no text given"`.
+
+The default value also jumps in if the parameter exists, but strictly equals `undefined`, like this:
+
+```js
+showMessage("Ann", undefined); // Ann: no text given
+```
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 In questo caso `"no text given"` è una stringa, ma potrebbe essere un'espressione più complessa, che viene valutata e assegnata solamente se il parametro non viene fornito. Quindi, è possibile anche:
 
@@ -225,9 +240,49 @@ Nell'esempio sopra, `anotherFunctions()` non viene chiamata se viene passato il
 Viene invece chiamata ogni volta che il parametro manca.
 ```
 
+<<<<<<< HEAD
 A volte ha senso assegnare valori default ai parametri, non nella dichiarazione della funzione, ma in una fase successiva.
 
 Possiamo verificare se il parametro viene passato durante l'esecuzione della funzione, confrontandolo con `undefined`:
+=======
+````smart header="Default parameters in old JavaScript code"
+Several years ago, JavaScript didn't support the syntax for default parameters. So people used other ways to specify them.
+
+Nowadays, we can come across them in old scripts.
+
+For example, an explicit check for `undefined`:
+
+```js
+function showMessage(from, text) {
+*!*
+  if (text === undefined) {
+    text = 'no text given';
+  }
+*/!*
+
+  alert( from + ": " + text );
+}
+```
+
+...Or using the `||` operator:
+
+```js
+function showMessage(from, text) {
+  // If the value of text is falsy, assign the default value
+  // this assumes that text == "" is the same as no text at all
+  text = text || 'no text given';
+  ...
+}
+```
+````
+
+
+### Alternative default parameters
+
+Sometimes it makes sense to assign default values for parameters at a later stage after the function declaration.
+
+We can check if the parameter is passed during the function execution, by comparing it with `undefined`:
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 ```js run
 function showMessage(text) {
@@ -409,7 +464,11 @@ Questi esempi assumono i significati comuni dei prefissi. Il loro significato di
 ```smart header="Nomi di funzioni ultra-corti"
 Funzioni che vengono utilizzate *molto spesso* potrebbero avere nomi molto corti.
 
+<<<<<<< HEAD
 Ad esempio il framework [jQuery](http://jquery.com) definisce una funzione con `$`. La libreria [Lodash](http://lodash.com/) ha nel *core* una funzione denominata `_`.
+=======
+For example, the [jQuery](https://jquery.com/) framework defines a function with `$`. The [Lodash](https://lodash.com/) library has its core function named `_`.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Queste sono eccezioni. Generalmente i nomi delle funzioni dovrebbero essere concisi e descrittivi.
 ```
@@ -477,7 +536,11 @@ function name(parameters, delimited, by, comma) {
 
 Per rendere il codice pulito e più facile da leggere, è consigliabile utilizzare principalmente variabili locali e parametri di funzione, non variabili esterne.
 
+<<<<<<< HEAD
 E' sempre più facile capire una funzione che accetta parametri, li lavora e ritorna un valore piuttosto di una funzione che non richiede parametri ma, come effetto collaterale, modifica variabili esterne.
+=======
+It is always easier to understand a function which gets parameters, works with them and returns a result than a function which gets no parameters, but modifies outer variables as a side effect.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Denominare le funzioni:
 

1-js/02-first-steps/16-function-expressions/article.md

@@ -12,7 +12,13 @@ function sayHi() {
 
 E' disponibile un'altra sintassi per creare una funzione, chiamata *function expression*.
 
+<<<<<<< HEAD
 La sintassi:
+=======
+It allows us to create a new function in the middle of any expression.
+
+For example:
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 ```js
 let sayHi = function() {
@@ -72,15 +78,20 @@ let sayHi = function() { // (1) create
   alert( "Hello" );
 };
 
-let func = sayHi;
+let func = sayHi;  //(2)
 // ...
 ```
 
 Tutto funzionerebbe ugualmente. Risulta anche più chiaro cosa sta succedendo, giusto?
 
 
+<<<<<<< HEAD
 ````smart header="Perché c'è un punto e virgola alla fine?"
 Vi starete chiedendo perché con la function expression bisogna mettere `;` alla fine, mentre con la dichiarazione di funzione non serve:
+=======
+````smart header="Why is there a semicolon at the end?"
+You might wonder, why do Function Expressions have a semicolon `;` at the end, but Function Declarations do not:
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 ```js
 function sayHi() {
@@ -135,13 +146,21 @@ function showCancel() {
 ask("Do you agree?", showOk, showCancel);
 ```
 
+<<<<<<< HEAD
 Queste funzioni possono essere molto utili. La principale differenza tra un'implementazione realistica e gli esempi sopra è che le funzioni "reali" utilizzano modalità più complesse per interagire con l'utente, non un semplice `confirm`. In ambiente browser, queste funzioni mostrano spesso delle finestre molto carine per gli input dell'utente. Ma questo è un altro discorso.
+=======
+In practice, such functions are quite useful. The major difference between a real-life `ask` and the example above is that real-life functions use more complex ways to interact with the user than a simple `confirm`. In the browser, such functions usually draw a nice-looking question window. But that's another story.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 **Gli argomenti `showOk` e `showCancel` della `ask` sono chiamati *funzioni di richiamo* o semplicemente *callbacks*.**
 
 L'idea è di passare una funzione e di "richiamarla" più tardi se necessario. Nel nostro caso `showOk` diventa la callback per la risposta "yes", e `showCancel` per la risposta "no".
 
+<<<<<<< HEAD
 Possiamo utilizzare una function expression per scrivere la stessa funzione più concisamente:
+=======
+We can use Function Expressions to write an equivalent, shorter function:
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 ```js run no-beautify
 function ask(question, yes, no) {
@@ -179,16 +198,25 @@ Cerchiamo di elencare le differenze chiave tra Dichiarazioni ed Espressioni di F
 
 Primo, la sintassi: come  distinguerle nel codice.
 
+<<<<<<< HEAD
 - *Dichiarazione di funzione:* una funzione, dichiarata come un'istruzione separata, nel flusso principale del programma.
+=======
+- *Function Declaration:* a function, declared as a separate statement, in the main code flow:
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
     ```js
     // Dichiarazione di funzione
     function sum(a, b) {
       return a + b;
     }
     ```
+<<<<<<< HEAD
 - *Function expression:* una funzione, creata all'interno di un'espressione o all'interno di un altro costrutto. Qui, la funzione è creata alla destra dell' "espressione di assegnazione" `=`:
 
+=======
+- *Function Expression:* a function, created inside an expression or inside another syntax construct. Here, the function is created on the right side of the "assignment expression" `=`:
+
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
     ```js
     // function expression
     let sum = function(a, b) {
@@ -284,17 +312,27 @@ if (age < 18) {
   welcome();               // \   (esegue)
 */!*
                            //  |
+<<<<<<< HEAD
   function welcome() {     //  |  
     alert("Hello!");       //  |  Dichiarazione di funzione disponibile
   }                        //  |  ovunque nel blocco in cui è stata dichiarata
+=======
+  function welcome() {     //  |
+    alert("Hello!");       //  |  Function Declaration is available
+  }                        //  |  everywhere in the block where it's declared
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
                            //  |
 *!*
   welcome();               // /   (esegue)
 */!*
 
 } else {
 
+<<<<<<< HEAD
   function welcome() {     
+=======
+  function welcome() {
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
     alert("Greetings!");
   }
 }
@@ -352,8 +390,13 @@ welcome(); // ora funziona
 ```
 
 
+<<<<<<< HEAD
 ```smart header="Quando conviene scegliere una dichiarazione di funzione piuttosto di una function expression?"
 Come regola fondamentale, quando abbiamo la necessità di dichiarare una funzione, la prima opzione da considerare è la dichiarazione di funzione. Fornisce maggiore libertà per quanto riguarda l'organizzazione del codice, poiché possiamo utilizzare la funzione anche prima della sua dichiarazione.
+=======
+```smart header="When to choose Function Declaration versus Function Expression?"
+As a rule of thumb, when we need to declare a function, the first thing to consider is Function Declaration syntax. It gives more freedom in how to organize our code, because we can call such functions before they are declared.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Risulta anche più facile vedere `function f(…) {…}`, nel codice, piuttosto di `let f = function(…) {…}`. La dichiarazione di funzione è più facile da individuare.
 

1-js/02-first-steps/17-arrow-functions-basics/article.md

@@ -33,7 +33,11 @@ let sum = function(a, b) {
 alert( sum(1, 2) ); // 3
 ```
 
+<<<<<<< HEAD
 Come puoi vedere `(a, b) => a + b` rappresenta una funzione che accetta due argomenti `a` e `b`. Al momento dell'esecuzione, questa valuta l'espressione `a + b` e restituisce il risultato.
+=======
+As you can see, `(a, b) => a + b` means a function that accepts two arguments named `a` and `b`. Upon the execution, it evaluates the expression `a + b` and returns the result.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 - Se abbiamo un solo argomento, le parentesi che racchiudono gli argomenti possono essere omesse, abbreviando ulteriormente il codice.
 
@@ -48,7 +52,11 @@ Come puoi vedere `(a, b) => a + b` rappresenta una funzione che accetta due argo
     alert( double(3) ); // 6
     ```
 
+<<<<<<< HEAD
 - Se non ci sono argomenti, le parentesi saranno vuote (ma devono essere presenti):
+=======
+- If there are no arguments, parentheses are empty, but they must be present:
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
     ```js run
     let sayHi = () => alert("Hello!");
@@ -64,7 +72,7 @@ Ad esempio, per creare dinamicamente una funzione:
 let age = prompt("What is your age?", 18);
 
 let welcome = (age < 18) ?
-  () => alert('Hello') :
+  () => alert('Hello!') :
   () => alert("Greetings!");
 
 welcome();
@@ -76,17 +84,27 @@ Esse sono molto comode per semplici azioni su una riga, se siamo troppo pigri pe
 
 ## Arrow functions su più linee
 
+<<<<<<< HEAD
 Gli esempi precedenti hanno preso argomenti alla sinistra di "=>" e con essi hanno valutato l'espressione a destra.
 
 A volte abbiamo bisogno di qualcosa di un po' più complesso, come espressioni o dichiarazioni multiple. Anche questo è possibile, ma dovremo racchiuderle tra parentesi graffe ed usare un normale return.
+=======
+The arrow functions that we've seen so far were very simple. They took arguments from the left of `=>`, evaluated and returned the right-side expression with them.
+
+Sometimes we need a more complex function, with multiple expressions and statements. In that case, we can enclose them in curly braces. The major difference is that curly braces require a `return` within them to return a value (just like a regular function does).
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 In questo modo:
 
 ```js run
 let sum = (a, b) => {  // le parentesi graffe aprono una funzione multilinea
   let result = a + b;
 *!*
+<<<<<<< HEAD
   return result; // se usiamo le parentesi graffe abbiamo bisogno di un esplicito "return" 
+=======
+  return result; // if we use curly braces, then we need an explicit "return"
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 */!*
 };
 
@@ -106,8 +124,15 @@ Per ora possiamo già utilizzarle per azioni su una riga sola e per callbacks.
 
 ## Summary
 
+<<<<<<< HEAD
 Le arrow functions sono utili per azioni su una riga sola. Possono essere scritte in due modi:
 
 1. Senza parentesi graffe: `(...args) => expression` -- la parte destra è un'espressione: la funzione la valuta e restituisce il risultato.
 2. Con parentesi graffe: `(...args) => { body }` -- le parentesi ci permettono di scrivere comandi multipli all'interno della funzione, ma abbiamo bisogno di dichiarare esplicitamente
 `return` affinché sia ritornato qualcosa.
+=======
+Arrow functions are handy for simple actions, especially for one-liners. They come in two flavors:
+
+1. Without curly braces: `(...args) => expression` -- the right side is an expression: the function evaluates it and returns the result. Parentheses can be omitted, if there's only a single argument, e.g. `n => n*2`.
+2. With curly braces: `(...args) => { body }` -- brackets allow us to write multiple statements inside the function, but we need an explicit `return` to return something.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b

1-js/02-first-steps/18-javascript-specials/article.md

@@ -55,7 +55,11 @@ Per abilitare completamente tutte le caratteristiche del moderno JavaScript, dov
 
 La direttiva deve essere posta all'inizio di ogni script o all'inizio di una funzione.
 
+<<<<<<< HEAD
 Senza `"use strict"`, tutto continuerebbe a funzionare, ma alcune caratteristiche si comporterebbero in vecchio-stile, per retrocompatibilità. Generalmente si preferisce la modalità con i comportamenti moderni.
+=======
+Without `"use strict"`, everything still works, but some features behave in the old-fashioned, "compatible" way. We'd generally prefer the modern behavior.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Alcune caratteristiche moderne del linguaggio (come le classi che studieremo più avanti) attivano automaticamente la modalità script.
 
@@ -103,6 +107,7 @@ Di più in: <info:variables> e <info:types>.
 
 Abbiamo utilizzato solo il browser come ambiente di sviluppo, quindi le interfacce di base saranno:
 
+<<<<<<< HEAD
 [`prompt(question[, default])`](mdn:api/Window/prompt)
 : Pone una domanda `question`, e ritorna quello che l'utente ha inserito oppure `null` se ha premuto "cancel".
 
@@ -111,6 +116,16 @@ Abbiamo utilizzato solo il browser come ambiente di sviluppo, quindi le interfac
 
 [`alert(message)`](mdn:api/Window/alert)
 : Stampa un messaggio `message`.
+=======
+[`prompt(question, [default])`](https://developer.mozilla.org/en-US/docs/Web/API/Window/prompt)
+: Ask a `question`, and return either what the visitor entered or `null` if they clicked "cancel".
+
+[`confirm(question)`](https://developer.mozilla.org/en-US/docs/Web/API/Window/confirm)
+: Ask a `question` and suggest to choose between Ok and Cancel. The choice is returned as `true/false`.
+
+[`alert(message)`](https://developer.mozilla.org/en-US/docs/Web/API/Window/alert)
+: Output a `message`.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Tutte queste funzioni sono dei *modal*, interrompono l'esecuzione e impediscono all'utente di interagire con una pagina fino a che il visitatore non risponde.
 
@@ -143,8 +158,13 @@ Aritmetici
 Assegnazione
 : Ci sono le assegnazioni semplici: `a = b` e quelle combinate `a *= 2`.
 
+<<<<<<< HEAD
 Bit a Bit
 : Gli operatori bit a bit funzionano con gli interi a livello di bit: guarda la [documentazione](mdn:/JavaScript/Reference/Operators/Bitwise_Operators) se ne avrai bisogno.
+=======
+Bitwise
+: Bitwise operators work with 32-bit integers at the lowest, bit-level: see the [docs](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators#bitwise_operators) when they are needed.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Ternari
 : C'è un solo operatore con tre parametri: `cond ? resultA : resultB`. Se `cond` è vera, ritorna `resultA`, altrimenti `resultB`.
@@ -258,7 +278,11 @@ Abbiamo studiato tre modi per creare funzioni in JavaScript:
 3. Funzione freccia:
 
     ```js
+<<<<<<< HEAD
     // espressione dalla parte destra
+=======
+    // expression on the right side
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
     let sum = (a, b) => a + b;
 
     // oppure la sintassi multi-riga con { ... }, è necessario esplicitare return

1-js/03-code-quality/01-debugging-chrome/article.md

@@ -38,7 +38,11 @@ Se premiamo `key:Esc`, si apre una console in basso. Possiamo digitare comandi e
 
 Dopo l'esecuzione dell'istruzione, il risultato viene mostrato sotto.
 
+<<<<<<< HEAD
 Ad esempio, `1+2` con risultato `3`, ed `hello("debugger")` non ritorna nulla, quindi il risultato è `undefined`:
+=======
+For example, here `1+2` results in `3`, while the function call `hello("debugger")` returns nothing, so the result is `undefined`:
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 ![](chrome-sources-console.svg)
 
@@ -62,13 +66,22 @@ Possiamo anche visualizzare la lista dei breakpoint nel pannello di destra. Ques
 - Rimuovere breakpoint cliccando con il tasto destro e selezionando Rimuovi.
 - ...E molto altro.
 
+<<<<<<< HEAD
 ```smart header="Breakpoint condizionali"
 *Tasto destro* sul numero della riga ci consente di creare un breakpoint *condizionale*. Che viene attivato solo quando l'espressione fornita risulta vera.
+=======
+```smart header="Conditional breakpoints"
+*Right click* on the line number allows to create a *conditional* breakpoint. It only triggers when the given expression, that you should provide when you create it, is truthy.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Questa caratteristica risulta molto utile quando abbiamo bisogno di fermare il flusso di esecuzione per determinati valori di una variabile.
 ```
 
+<<<<<<< HEAD
 ## Comando debugger
+=======
+## The command "debugger"
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Possiamo mettere in pausa il codice anche utilizzando il comando `debugger`, come nell'esempio:
 
@@ -84,8 +97,12 @@ function hello(name) {
 }
 ```
 
+<<<<<<< HEAD
 Questo risulta molto utile quando stiamo lavorando in un editor e non vogliamo passare alla finestra del browser, cercare il punto corretto nello script interessato e impostare il breakpoint.
 
+=======
+Such command works only when the development tools are open, otherwise the browser ignores it.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 ## Interrompere l'esecuzione e guardarsi intorno
 
@@ -99,7 +116,11 @@ Ora aprite il menu a cascata (quello con la freccetta accanto al nome). Ti conse
 
 1. **`Watch` -- mostra il valore corrente per ogni espressione.**
 
+<<<<<<< HEAD
     Puoi cliccare su `+` e inserire un espressione. Il debugger ti mostrerà il suo valore ad ogni istante, che verrà automaticamente ricalcolato durante l'esecuzione.
+=======
+    You can click the plus `+` and input an expression. The debugger will show its value, automatically recalculating it in the process of execution.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 2. **`Call Stack` -- mostra la catena delle chiamate annidate.**
 
@@ -134,12 +155,21 @@ Ci sono dei bottoni appositi nella parte superiore del pannello di destra. Provi
 
     Continuando a cliccare eseguiremo lo script un passo per volta.
 
+<<<<<<< HEAD
 <span class="devtools" style="background-position:-62px -192px"></span> -- "Step over": esegue il prossimo comando, ma *non entra nella funzione*, hotkey `key:F10`.
 : Molto simile al comando "Step", ma si comporta diversamente nel caso in cui l'istruzione successiva sia una chiamata a funzione. O meglio: non una funzione built-in come `alert`, ma una funzione definita da noi.
 
     Il comando "Step" entra nella funzione e mette in pausa l'esecuzione, mentre "Step over" esegue la chiamata a funzione, saltandone il contenuto.
 
     L'esecuzione viene interrotta al termine della chiamata.
+=======
+<span class="devtools" style="background-position:-62px -192px"></span> -- "Step over": run the next command, but *don't go into a function*, hotkey `key:F10`.
+: Similar to the previous "Step" command, but behaves differently if the next statement is a function call (not a built-in, like `alert`, but a function of our own).
+
+    If we compare them, the "Step" command goes into a nested function call and pauses the execution at its first line, while "Step over" executes the nested function call invisibly to us, skipping the function internals.
+
+    The execution is then paused immediately after that function call.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
     Questo è molto utile se non siamo interessati nel vedere cosa accade dentro la funzione.
 
@@ -157,8 +187,13 @@ Ci sono dei bottoni appositi nella parte superiore del pannello di destra. Provi
 <span class="devtools" style="background-position:-7px -28px"></span> -- attiva/disattiva tutti i breakpoint.
 : Questo bottone non influenza l'esecuzione. E' semplicemente un on/off per i breakpoint.
 
+<<<<<<< HEAD
 <span class="devtools" style="background-position:-264px -4px"></span> -- attiva/disattiva la pausa automatica in caso di errori.
 : Quando questa opzione è attiva, e il pannello degli strumenti sviluppatore è aperto, un errore nello script metterà automaticamente in pausa l'esecuzione. Cosi potremmo analizzare le variabili per capire cosa è andato storto. Quindi se il nostro script si blocca con un errore, possiamo aprire il debugger, attivare questa opzione e ricaricare la pagina per vedere dove si blocca lo script e capirne il motivo.
+=======
+<span class="devtools" style="background-position:-90px -146px"></span> -- enable/disable automatic pause in case of an error.
+: When enabled, if the developer tools is open, an error during the script execution automatically pauses it. Then we can analyze variables in the debugger to see what went wrong. So if our script dies with an error, we can open debugger, enable this option and reload the page to see where it dies and what's the context at that moment.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 ```smart header="Continua fino a qui"
 Premendo tasto destro su una riga di codice si aprirà un menu con una bellissima opzione denominata  "Continua fino a qui".
@@ -190,7 +225,11 @@ Come abbiamo visto, ci sono tre diversi modi di mettere in pausa uno script:
 2. L'istruzione `debugger`.
 3. Un errore (solo se gli strumenti sviluppatore sono aperti ed è attivo il bottone <span class="devtools" style="background-position:-264px -4px"></span>)
 
+<<<<<<< HEAD
 Cosi possiamo esaminare le variabili e capire cosa è andato male durante l'esecuzione.
+=======
+When paused, we can debug: examine variables and trace the code to see where the execution goes wrong.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Ci sono veramente troppe opzioni negli strumenti da sviluppatore per coprirle qui. Il manuale completo è disponibile all'indirizzo <https://developers.google.com/web/tools/chrome-devtools>.
 

1-js/03-code-quality/03-comments/article.md

@@ -143,7 +143,11 @@ Documentare l'utilizzo di una funzione
 
     I molti casi, gli editor come [WebStorm](https://www.jetbrains.com/webstorm/) sono in grado di comprenderli e possono quindi utilizzarli per autocompletamenti e alcune verifiche automatiche del codice.
 
+<<<<<<< HEAD
     Ci sono anche tool come [JSDoc 3](https://github.com/jsdoc3/jsdoc) che possono generare documentazione in HTML a partire dai commenti. Puoi scoprire di più riguardo JSDoc su <http://usejsdoc.org/>.
+=======
+Also, there are tools like [JSDoc 3](https://github.com/jsdoc/jsdoc) that can generate HTML-documentation from the comments. You can read more information about JSDoc at <https://jsdoc.app>.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Perché l'azione viene risolta in quel modo?
 : Quello che viene scritto è fondamentale. Ma quello che *non* viene scritto potrebbe esserlo anche di più per capire cosa sta succedendo. Perché l'azione viene portata a termine in quel modo? Il codice non fornisce risposte.

1-js/03-code-quality/05-testing-mocha/article.md

@@ -53,7 +53,11 @@ describe("pow", function() {
 Una spec ha tre principali blocchi:
 
 `describe("title", function() { ... })`
+<<<<<<< HEAD
 : Viene descritta la funzionalità. Utilizzata per raggruppare le "attività" -- i blocchi `it`. Nel nostro caso descriviamo la funzione `pow`.
+=======
+: What functionality we're describing? In our case we're describing the function `pow`. Used to group "workers" -- the `it` blocks.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 `it("title", function() { ... })`
 : Nel titolo di `it` descriviamo il particolare caso d'uso *leggibile per gli umani*, come secondo argomento una funzione che lo testa.
@@ -69,27 +73,47 @@ Una spec ha tre principali blocchi:
 
 Il flusso di sviluppo solitamente segue i passi:
 
+<<<<<<< HEAD
 1. Viene scritta una spec iniziale, con dei test per le funzionalità di base.
 2. Si crea un implementazione di base.
 3. Per verificare che questa funzioni, utilizziamo un framework di testing come [Mocha](http://mochajs.org/) (presto maggiori dettagli) che esegue le spec. Vengono mostrati gli errori. Facciamo le correzioni e riproviamo finché tutto funziona correttamente.
 4. Ora abbiamo un'implementazione iniziale che funziona bene con i test.
 5. Aggiungiamo più casi d'uso alla spec, magari ancora non supportate dall'implementazione. Cosi i test inizieranno a fallire.
 6. Quindi tornate al passo 3, aggiornate l'implementazione e continuate finché tutto non funziona correttamente.
 7. Ripetete gli step 3-6 fino ad ottenere la funzionalità desiderata.
+=======
+1. An initial spec is written, with tests for the most basic functionality.
+2. An initial implementation is created.
+3. To check whether it works, we run the testing framework [Mocha](https://mochajs.org/) (more details soon) that runs the spec. While the functionality is not complete, errors are displayed. We make corrections until everything works.
+4. Now we have a working initial implementation with tests.
+5. We add more use cases to the spec, probably not yet supported by the implementations. Tests start to fail.
+6. Go to 3, update the implementation till tests give no errors.
+7. Repeat steps 3-6 till the functionality is ready.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Quindi la fase di sviluppo è *iterativa*. Scriviamo la specifica, la implementiamo, ci accertiamo che passi i test, ci assicuriamo che faccia ciò che deve. Al termine di questa procedura avremmo un implementazione già testata e funzionante.
 
 Nel nostro caso, il primo step è completo: abbiamo un specifica iniziale di `pow`. Quindi ora passiamo all'implementazione. Come prima cosa facciamo l'esecuzione "zero" con le specifiche scritte, per essere sicuri che tutto funzioni (ovviamente i test dovrebbero fallire tutti).
 
+<<<<<<< HEAD
 ## La spec in azione
+=======
+The first step is already complete: we have an initial spec for `pow`. Now, before making the implementation, let's use a few JavaScript libraries to run the tests, just to see that they are working (they will all fail).
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 In questo guida utilizzeremo le seguenti librerie JavaScript per fare test:
 
 - [Mocha](http://mochajs.org/) -- un core framework: fornisce le maggiori funzioni di test come `describe` e `it` e le principali funzioni che eseguono i test.
 - [Chai](http://chaijs.com) -- una libreria con molte asserzioni. Ci consente di utilizzare molte asserzioni differenti, per ora ci servirà solamente `assert.equal`.
 - [Sinon](http://sinonjs.org/) -- una libreria per il controllo oltre le funzioni, emula funzioni integrate e molto altro, la utilizzeremo più avanti.
 
+<<<<<<< HEAD
 Queste librerie sono utili sia per per il test browser, sia per il test lato server. Qui considereremo la variante browser.
+=======
+- [Mocha](https://mochajs.org/) -- the core framework: it provides common testing functions including `describe` and `it` and the main function that runs tests.
+- [Chai](https://www.chaijs.com/) -- the library with many assertions. It allows to use a lot of different assertions, for now we need only `assert.equal`.
+- [Sinon](https://sinonjs.org/) -- a library to spy over functions, emulate built-in functions and more, we'll need it much later.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 La pagina HTML con questi framework e le spec di pow `pow`:
 
@@ -336,6 +360,7 @@ I nuovi test aggiunti falliranno, perché la nostra implementazione non li suppo
 
 ```smart header="Altre asserzioni"
 
+<<<<<<< HEAD
 Metto in evidenza l'asserzione `assert.isNaN`: che effettua controlli di tipo `NaN`.
 
 In Chai sono presenti molte altre asserzioni, ad esempio:
@@ -346,6 +371,16 @@ In Chai sono presenti molte altre asserzioni, ad esempio:
 - `assert.isTrue(value)` -- esegue il controllo `value === true`
 - `assert.isFalse(value)` -- verifica che `value === false`
 - ...l'inter lista è disponibile nella [documentazione](http://chaijs.com/api/assert/)
+=======
+There are other assertions in [Chai](https://www.chaijs.com/) as well, for instance:
+
+- `assert.equal(value1, value2)` -- checks the equality  `value1 == value2`.
+- `assert.strictEqual(value1, value2)` -- checks the strict equality `value1 === value2`.
+- `assert.notEqual`, `assert.notStrictEqual` -- inverse checks to the ones above.
+- `assert.isTrue(value)` -- checks that `value === true`
+- `assert.isFalse(value)` -- checks that `value === false`
+- ...the full list is in the [docs](https://www.chaijs.com/api/assert/)
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 ```
 
 Dovremmo quindi aggiungere un paio di linee a `pow`:

1-js/03-code-quality/06-polyfills/article.md

@@ -1,13 +1,23 @@
 
 # Polyfills e transpilers
 
+<<<<<<< HEAD
 Il linguaggio JavaScript si evolve costantemente. Nuove proposte per il linguaggio arrivano regolarmente, vengono analizzate, e successivamente se ritenute valide vengono aggiunte alla lista <https://tc39.github.io/ecma262/> fino a diventare delle [specifiche](http://www.ecma-international.org/publications/standards/Ecma-262.htm).
+=======
+The JavaScript language steadily evolves. New proposals to the language appear regularly, they are analyzed and, if considered worthy, are appended to the list at <https://tc39.github.io/ecma262/> and then progress to the [specification](https://www.ecma-international.org/publications-and-standards/standards/ecma-262/).
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 I team che stanno dietro il motore di JavaScript hanno le loro personali idee riguardo cosa implementare. Potrebbero quindi decidere di implementare delle proposte recenti e posticipare quelle più vecchie a causa di difficoltà nell'implementazione.
 
+<<<<<<< HEAD
 Quindi per un motore di script è naturale implementare solo le cose che si trovano nello standard.
 
 Se si vuole rimanere aggiornati riguardo lo stato di supporto delle caratteristiche si può controllare la pagina <https://kangax.github.io/compat-table/es6/> (è molto grande, dovremmo studiare ancora molto).
+=======
+So it's quite common for an engine to implement only part of the standard.
+
+A good page to see the current state of support for language features is <https://compat-table.github.io/compat-table/es6/> (it's big, we have a lot to study yet).
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Come programmatori, amiamo utilizzare le più recenti caratteristiche del linguaggio!
 
@@ -40,9 +50,15 @@ Ora il codice riscritto è adatto anche ai vecchi motori JavaScript.
 
 In genere lo sviluppatore fa girare il transpiler in locale sul proprio computer, quindi distribuisce sul server il codice riscritto.
 
+<<<<<<< HEAD
 Facendo qualche nome, [Babel](https://babeljs.io) è uno dei più diffusi transpilers del momento. 
 
 I moderni 'bundler' utilizzati per 'assemblare' progetti, come [webpack](http://webpack.github.io/), possono eseguire il transpiler automaticamente ad ogni modifica del codice, è quindi molto facile integrarlo nei processi di sviluppo.
+=======
+Speaking of names, [Babel](https://babeljs.io) is one of the most prominent transpilers out there.
+
+Modern project build systems, such as [webpack](https://webpack.js.org/), provide a means to run a transpiler automatically on every code change, so it's very easy to integrate into the development process.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 ## Polyfills
 
@@ -69,23 +85,40 @@ if (!Math.trunc) { // se la funzione non esiste
 }
 ```
 
+<<<<<<< HEAD
 JavaScript è un linguaggio altamente dinamico, gli script possono aggiungere/modificare qualsiasi funzione, anche quelle integrate.
 
 Due interessanti librerie polyfills sono:
 - [core js](https://github.com/zloirock/core-js) ha molte funzioni e consente di includere solo le funzionalità necessarie.
 - [polyfill.io](http://polyfill.io) servizio che fornisce uno script con polyfill, a seconda delle funzionalità e del browser dell'utente.
+=======
+JavaScript is a highly dynamic language. Scripts may add/modify any function, even built-in ones.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
+One interesting polyfill library is [core-js](https://github.com/zloirock/core-js), which supports a wide range of features and allows you to include only the ones you need.
 
 ## Riepilogo
 
 In questo capitolo vorremmo motivarvi a studiare le funzionalità più moderne ed all'avanguardia" del linguaggio, anche se non sono ancora ben supportate dai motori JavaScript.
 
+<<<<<<< HEAD
 Basta non dimenticare di usare transpiler (se si utilizza la sintassi o gli operatori moderni) e i polyfill (per aggiungere funzioni che potrebbero mancare). Questi si assicureranno che il codice funzioni.
 
 Ad esempio, in seguito, quando avrai familiarità con JavaScript, potrai configurare un sistema di compilazione del codice basato su [webpack](http://webpack.github.io/) con [babel-loader](https://github.com/babel/babel-loader) plugin.
 
 Buone risorse che mostrano lo stato attuale del supporto per varie funzionalità:
 - <https://kangax.github.io/compat-table/es6/> - per puro JavaScript.
 - <https://caniuse.com/> - per le funzioni integrate dei browsers.
+=======
+Just don't forget to use a transpiler (if using modern syntax or operators) and polyfills (to add functions that may be missing). They'll ensure that the code works.
+
+For example, later when you're familiar with JavaScript, you can setup a code build system based on [webpack](https://webpack.js.org/) with the [babel-loader](https://github.com/babel/babel-loader) plugin.
+
+Good resources that show the current state of support for various features:
+- <https://compat-table.github.io/compat-table/es6/> - for pure JavaScript.
+- <https://caniuse.com/> - for browser-related functions.
+
+P.S. Google Chrome is usually the most up-to-date with language features, try it if a tutorial demo fails. Most tutorial demos work with any modern browser though.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 P.S. Google Chrome è solitamente il browser più aggiornato con le funzionalità del linguaggio, provalo se una demo tutorial fallisce. Tuttavia, la maggior parte delle demo dei tutorial funziona con qualsiasi browser moderno.

1-js/04-object-basics/01-object/article.md

@@ -44,7 +44,11 @@ L'oggetto `user` può essere visto come un archivio con due file etichettati com
 
 ![user object](object-user.svg)
 
+<<<<<<< HEAD
 Possiamo aggiungere, rimuovere o leggere un file in qualsiasi momento.
+=======
+We can add, remove and read files from it at any time.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 I valori delle proprietà sono accessibili utilizzando la notazione puntata:
 
@@ -62,7 +66,11 @@ user.isAdmin = true;
 
 ![user object 2](object-user-isadmin.svg)
 
+<<<<<<< HEAD
 Per rimuovere una proprietà, possiamo utilizzare l'operatore `delete`:
+=======
+To remove a property, we can use the `delete` operator:
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 ```js
 delete user.age;
@@ -197,13 +205,21 @@ let bag = {
 };
 ```
 
+<<<<<<< HEAD
 Le parentesi quadre sono molto più potenti della notazione puntata. Ci permettono di assegnare qualsiasi nome, ma sono più "ingombranti".
 La maggior parte delle volte, quando il nome della proprietà è conosciuto e semplice, la notazione puntata viene preferita. Se invece necessitiamo di qualcosa di più complesso, possiamo utilizzare le parentesi quadre.
+=======
+Square brackets are much more powerful than dot notation. They allow any property names and variables. But they are also more cumbersome to write.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 
 ## Abbreviazione per il valore di una proprietà
 
+<<<<<<< HEAD
 Spesso usiamo delle variabili esistenti come valori per i nomi delle proprietà.
+=======
+In real code, we often use existing variables as values for property names.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Ad esempio:
 
@@ -247,7 +263,15 @@ let user = {
 
 Come già sappiamo, una variabile non può avere il nome uguale ad una parola chiave riservata al linguaggio come "for", "let", "return" etc.
 
+<<<<<<< HEAD
 Ma per le proprietà degli oggetti, non ci sono restrizioni:
+=======
+## Property names limitations
+
+As we already know, a variable cannot have a name equal to one of the language-reserved words like "for", "let", "return" etc.
+
+But for an object property, there's no such restriction:
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 ```js run
 // queste variabili sono tutte corrette
@@ -318,7 +342,11 @@ alert( "blabla" in user ); // false, significa che user.blabla non esiste
 
 Da notare che alla sinistra di `in` deve esserci il *nome di una proprietà*. Questa, solitamente, è una stringa.
 
+<<<<<<< HEAD
 Se omettiamo le virgolette attorno alla proprietà da cercare, verrà cercata una variabile con quel nome e verrà utilizzato il suo valore. Ad esempio:
+=======
+If we omit quotes, that means a variable should contain the actual name to be tested. For instance:
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 ```js run
 let user = { age: 30 };
@@ -348,7 +376,11 @@ Nel codice sopra, tecnicamente, la proprietà `obj.test` esiste. Quindi l'operat
 Situazioni come questa capitano raramente, perché solitamente non si assegna `undefined`. Si usa più comunemente `null` per valori "sconosciuti" o "vuoti". Quindi l'operatore `in` è più un ospite "esotico" nel codice.
 
 
+<<<<<<< HEAD
 ## Il ciclo "for..in" 
+=======
+## The "for..in" loop [#forin]
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Per attraversare tutte le chiavi di un oggetto, esiste una speciale forma di ciclo: `for..in`. Questo è completamente diverso da `for(;;)`.
 
@@ -406,7 +438,11 @@ for (let code in codes) {
 */!*
 ```
 
+<<<<<<< HEAD
 L'oggetto può essere utilizzato per suggerire una lista di opzioni all'utente. Se stiamo sviluppando un sito dedicato al pubblico tedesco propbabilmente vorrano vedersi apparire come primo valore `49`.
+=======
+The object may be used to suggest a list of options to the user. If we're making a site mainly for a German audience then we probably want `49` to be the first.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Se proviamo ad eseguire il codice, vedremo un risultato totalmente inaspettato:
 
@@ -418,13 +454,24 @@ I prefissi telefonici seguono un ordine crescente; questo accade perché sono nu
 ````smart header="Proprietà degli interi? Cos'è?"
 La "proprietà degli interi" è un termine che indica una stringa che può essere convertita da e ad un intero senza subire modifiche.
 
+<<<<<<< HEAD
 Quindi "49" segue la proprietà degli interi, perché quando viene trasformato in un numero intero e riportato a stringa, rimane uguale. Ad esempio "+49" e "1.2" non lo sono:
 
 ```js run
 // Math.trunc è una proprietà integrata che rimuove la parte decimale
 alert( String(Math.trunc(Number("49"))) ); // "49", rimane uguale
 alert( String(Math.trunc(Number("+49"))) ); // "49", è diverso da "+49" ⇒ non è un numero intero
 alert( String(Math.trunc(Number("1.2"))) ); // "1", è diverso da "1.2" ⇒ non è un numero intero
+=======
+So, `"49"` is an integer property name, because when it's transformed to an integer number and back, it's still the same. But `"+49"` and `"1.2"` are not:
+
+```js run
+// Number(...) explicitly converts to a number
+// Math.trunc is a built-in function that removes the decimal part
+alert( String(Math.trunc(Number("49"))) ); // "49", same, integer property
+alert( String(Math.trunc(Number("+49"))) ); // "49", not same "+49" ⇒ not integer property
+alert( String(Math.trunc(Number("1.2"))) ); // "1", not same "1.2" ⇒ not integer property
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 ```
 ````
 
@@ -476,10 +523,16 @@ Per accedere ad una proprietà possiamo utilizzare:
 - La notazione puntata: `obj.property`.
 - La notazione con parentesi quadre `obj["property"]`. Questa notazione consente di accettare chiavi dalle variabili, come `obj[varWithKey]`.
 
+<<<<<<< HEAD
 Operatori specifici:
 - Per cancellare una proprietà: `delete obj.prop`.
 - Per controllare se un una proprietà con un certo nome esiste: `"key" in obj`.
 - Per iterare un oggetto: `for(let key in obj)`.
+=======
+To access a property, we can use:
+- The dot notation: `obj.property`.
+- Square brackets notation `obj["property"]`. Square brackets allow taking the key from a variable, like `obj[varWithKey]`.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Gli oggetti vengono assegnati e copiati per riferimento. In altre parole, la variabile non memorizza il "valore dell'oggetto", ma piuttosto un "riferimento" (indirizzo di memoria). Quindi copiando questa variabile o passandola come argomento ad una funzione, fornirà un riferimento all'oggetto e non una copia. Tutte le operazioni effettuate su un oggetto copiato per riferimento (come aggiungere/rimuovere proprietà) vengono effettuate sullo stesso oggetto.
 

1-js/04-object-basics/02-object-copy/article.md

@@ -37,7 +37,11 @@ Ed ecco come viene effettivamente archiviata in memoria:
 
 L'oggetto è archiviato da qualche parte nella memoria (a destra nell'immagine), mentre la variabile `user` (a sinistra) contiene il "riferimento" ad esso.
 
+<<<<<<< HEAD
 Potremmo immaginare la "variabile oggetto" `user`,  come un foglio di carta con scritto l'indirizzo dell'oggetto.
+=======
+We may think of an object variable, such as `user`, like a sheet of paper with the address of the object on it.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Quando eseguiamo azioni con l'oggetto, ad es. leggere una proprietà `user.name`, il motore JavaScript guarda cosa c'è a quell'indirizzo ed esegue l'operazione sull'oggetto reale.
 
@@ -101,6 +105,7 @@ alert( a == b ); // false
 
 Per confronti tra oggetti (Es. `obj1 > obj2`) o con primitivi (Es. `obj == 5`), gli oggetti vengono convertiti in primitivi. Vedremo molto presto come avviene questa conversione, anche se, a dire il vero, questo tipo di confronto è molto raro e generalmente è il risultato di un errore di programmazione.
 
+<<<<<<< HEAD
 ## Clonazione e unione, Object.assign [#cloning-and-merging-object-assign]
 
 Come abbiamo detto, copiare una "variabile oggetto" crea un ulteriore riferimento allo stesso oggetto.
@@ -235,6 +240,10 @@ Per implementare questa funzione possiamo usare la ricorsione. Oppure, per non r
 
 ````smart header="Gli oggetti dichiarati con const possono essere modificati"
 Un importante "side effect" della memorizzazione per riferimento è che un oggetto dichiarato con `const` *può* essere modificato.
+=======
+````smart header="Const objects can be modified"
+An important side effect of storing objects as references is that an object declared as `const` *can* be modified.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Esempio:
 
@@ -257,10 +266,210 @@ In altre parole, `const user` restituisce un errore solo se se proviamo a riasse
 Detto questo, se vogliamo veramente rendere invariabili le proprietà di un oggetto, possiamo farlo, ma con un metodo totalmente differente. Ne parleremo nel capitolo <info:property-descriptors>.
 ````
 
+<<<<<<< HEAD
 ## Riepilogo
+=======
+## Cloning and merging, Object.assign [#cloning-and-merging-object-assign]
+
+So, copying an object variable creates one more reference to the same object.
+
+But what if we need to duplicate an object?
+
+We can create a new object and replicate the structure of the existing one, by iterating over its properties and copying them on the primitive level.
+
+Like this:
+
+```js run
+let user = {
+  name: "John",
+  age: 30
+};
+
+*!*
+let clone = {}; // the new empty object
+
+// let's copy all user properties into it
+for (let key in user) {
+  clone[key] = user[key];
+}
+*/!*
+
+// now clone is a fully independent object with the same content
+clone.name = "Pete"; // changed the data in it
+
+alert( user.name ); // still John in the original object
+```
+
+We can also use the method [Object.assign](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign).
+
+The syntax is:
+
+```js
+Object.assign(dest, ...sources)
+```
+
+- The first argument `dest` is a target object.
+- Further arguments is a list of source objects.
+
+It copies the properties of all source objects into the target `dest`, and then returns it as the result.
+
+For example, we have `user` object, let's add a couple of permissions to it:
+
+```js run
+let user = { name: "John" };
+
+let permissions1 = { canView: true };
+let permissions2 = { canEdit: true };
+
+*!*
+// copies all properties from permissions1 and permissions2 into user
+Object.assign(user, permissions1, permissions2);
+*/!*
+
+// now user = { name: "John", canView: true, canEdit: true }
+alert(user.name); // John
+alert(user.canView); // true
+alert(user.canEdit); // true
+```
+
+If the copied property name already exists, it gets overwritten:
+
+```js run
+let user = { name: "John" };
+
+Object.assign(user, { name: "Pete" });
+
+alert(user.name); // now user = { name: "Pete" }
+```
+
+We also can use `Object.assign` to perform a simple object cloning:
+
+```js run
+let user = {
+  name: "John",
+  age: 30
+};
+
+*!*
+let clone = Object.assign({}, user);
+*/!*
+
+alert(clone.name); // John
+alert(clone.age); // 30
+```
+
+Here it copies all properties of `user` into the empty object and returns it.
+
+There are also other methods of cloning an object, e.g. using the [spread syntax](info:rest-parameters-spread) `clone = {...user}`, covered later in the tutorial.
+
+## Nested cloning
+
+Until now we assumed that all properties of `user` are primitive. But properties can be references to other objects.
+
+Like this:
+```js run
+let user = {
+  name: "John",
+  sizes: {
+    height: 182,
+    width: 50
+  }
+};
+
+alert( user.sizes.height ); // 182
+```
+
+Now it's not enough to copy `clone.sizes = user.sizes`, because `user.sizes` is an object, and will be copied by reference, so `clone` and `user` will share the same sizes:
+
+```js run
+let user = {
+  name: "John",
+  sizes: {
+    height: 182,
+    width: 50
+  }
+};
+
+let clone = Object.assign({}, user);
+
+alert( user.sizes === clone.sizes ); // true, same object
+
+// user and clone share sizes
+user.sizes.width = 60;    // change a property from one place
+alert(clone.sizes.width); // 60, get the result from the other one
+```
+
+To fix that and make `user` and `clone` truly separate objects, we should use a cloning loop that examines each value of `user[key]` and, if it's an object, then replicate its structure as well. That is called a "deep cloning" or "structured cloning". There's [structuredClone](https://developer.mozilla.org/en-US/docs/Web/API/structuredClone) method that implements deep cloning.
+
+
+### structuredClone
+
+The call `structuredClone(object)` clones the `object` with all nested properties.
+
+Here's how we can use it in our example:
+
+```js run
+let user = {
+  name: "John",
+  sizes: {
+    height: 182,
+    width: 50
+  }
+};
+
+*!*
+let clone = structuredClone(user);
+*/!*
+
+alert( user.sizes === clone.sizes ); // false, different objects
+
+// user and clone are totally unrelated now
+user.sizes.width = 60;    // change a property from one place
+alert(clone.sizes.width); // 50, not related
+```
+
+The `structuredClone` method can clone most data types, such as objects, arrays, primitive values.
+
+It also supports circular references, when an object property references the object itself (directly or via a chain or references).
+
+For instance:
+
+```js run
+let user = {};
+// let's create a circular reference:
+// user.me references the user itself
+user.me = user;
+
+let clone = structuredClone(user);
+alert(clone.me === clone); // true
+```
+
+As you can see, `clone.me` references the `clone`, not the `user`! So the circular reference was cloned correctly as well.
+
+Although, there are cases when `structuredClone` fails.
+
+For instance, when an object has a function property:
+
+```js run
+// error
+structuredClone({
+  f: function() {}
+});
+```
+
+Function properties aren't supported.
+
+To handle such complex cases we may need to use a combination of cloning methods, write custom code or, to not reinvent the wheel, take an existing implementation, for instance [_.cloneDeep(obj)](https://lodash.com/docs#cloneDeep) from the JavaScript library [lodash](https://lodash.com).
+
+## Summary
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Gli oggetti sono assegnati e copiati per riferimento. In altre parole una variabile non contiene il "valore oggetto" ma un "riferimento" (indirizzo in memoria) di quel valore. Quindi copiando tale variabile o passandola come argomento di una funzione si copia quel riferimento, non l'oggetto stesso.
 
 Tutte le operazioni su un riferimento duplicato (come aggiungere o rimuovere proprietà) hanno effetto sul medesimo oggetto.
 
+<<<<<<< HEAD
 Per creare una "vera copia" (clonare) effettuare una cosiddetta "shallow copy" (copia superficiale) con `Object.assign`(gli oggetti nidificati vengo copiati per riferimento), oppure un "deep cloning" (copia profonda) con funzioni tipo [_.cloneDeep(obj)](https://lodash.com/docs#cloneDeep).
+=======
+To make a "real copy" (a clone) we can use `Object.assign` for the so-called "shallow copy" (nested objects are copied by reference) or a "deep cloning" function `structuredClone` or use a custom cloning implementation, such as [_.cloneDeep(obj)](https://lodash.com/docs#cloneDeep).
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b

1-js/04-object-basics/03-garbage-collection/article.md

@@ -74,7 +74,11 @@ Ora se facciamo:
 user = null;
 ```
 
+<<<<<<< HEAD
 ...L'oggetto rimane raggiungibile tramite `admin`, quindi è in memoria. Se sovrascriviamo anche `admin`, allora verrà rimosso.
+=======
+...Then the object is still reachable via `admin` global variable, so it must stay in memory. If we overwrite `admin` too, then it can be removed.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 ## Oggetti interconnessi
 
@@ -169,11 +173,19 @@ Il primo step sta nel marcare le radici:
 
 ![](garbage-collection-2.svg)
 
+<<<<<<< HEAD
 Poi vengono marcari i loro riferimenti:
 
 ![](garbage-collection-3.svg)
 
 ...E i loro riferimenti, finchè non si esauriscono:
+=======
+Then we follow their references and mark referenced objects:
+
+![](garbage-collection-3.svg)
+
+...And continue to follow further references, while possible:
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 ![](garbage-collection-4.svg)
 
@@ -183,30 +195,54 @@ Ora gli oggetti che non sono stati visitati vengono considerati irraggiungibili
 
 Questo è il concetto che sta dietro il funzionamento del Garbage collector.
 
+<<<<<<< HEAD
 JavaScript applica diverse ottimizzazioni per renderlo più rapido.
+=======
+That's the concept of how garbage collection works. JavaScript engines apply many optimizations to make it run faster and not introduce any delays into the code execution.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Alcune delle ottimizzazioni:
 
+<<<<<<< HEAD
 - **Raggruppamento generazionale** -- gli oggetti vengono divisi in due gruppi: "nuovi" e "vecchi". Molti oggetti vengono costruiti, eseguono il proprio lavoro e muoiono, quindi possono essere rimossi rapidamente. Quelli che vivono abbastanza al lungo vengono considerati come "vecchi" e verranno controllati con minore intensità
 - **Raggruppamento incrementale** -- se ci sono molti oggetti, e ci mettessimo a controllare interi gruppi per marcarli, si perderebbe molto tempo, questo ritardo diventerebbe visibile durante l'esecuzione. Quindi i motori JavaScript tentano di dividere il processo in diverse parti. Questi pezzi vengono controllati uno per uno, separatamente. E' richiesto l'utilizzo di un registro per tenere traccia dei cambiamenti, in cambio avremmo tanti piccoli ritardi piuttosto che uno singolo ma enorme.
 - **Raggruppamento per inattività** -- il garbage collector cerca di eseguire i suoi processi solo nei momenti in cui la CPU è inattiva, per ridurre al minimo possibile i ritardi durante l'esecuzione.
+=======
+- **Generational collection** -- objects are split into two sets: "new ones" and "old ones". In typical code, many objects have a short life span: they appear, do their job and die fast, so it makes sense to track new objects and clear the memory from them if that's the case. Those that survive for long enough, become "old" and are examined less often.
+- **Incremental collection** -- if there are many objects, and we try to walk and mark the whole object set at once, it may take some time and introduce visible delays in the execution. So the engine splits the whole set of existing objects into multiple parts. And then clear these parts one after another. There are many small garbage collections instead of a total one. That requires some extra bookkeeping between them to track changes, but we get many tiny delays instead of a big one.
+- **Idle-time collection** -- the garbage collector tries to run only while the CPU is idle, to reduce the possible effect on the execution.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Ci sono altre ottimizzazioni per ottimizzare i processi del Garbage collector. Anche se mi piacerebbe poterli spiegare in dettaglio, sono costretto a fermarmi, poiché le varia ottimizzazioni dipendono dai motori che vengono utilizzati. Inoltre, i motori cambiano, si aggiornano e diventano sempre più "avanzati". Quindi se siete realmente interessati, vi lascio qualche link sotto.
 
 ## Riepilogo
 
 Le principali cose da conoscere:
 
+<<<<<<< HEAD
 - Il processo di Garbage collection viene eseguito automaticamente. Non possiamo forzarlo o bloccarlo.
 - Gli oggetti vengono mantenuti in memoria solo finché risultano raggiungibili.
 - Essere riferimento di qualunque altro oggetto non significa essere raggiungibili (dalla radice): un gruppo di oggetti possono diventare irraggiungibili in un solo colpo.
+=======
+- Garbage collection is performed automatically. We cannot force or prevent it.
+- Objects are retained in memory while they are reachable.
+- Being referenced is not the same as being reachable (from a root): a pack of interlinked objects can become unreachable as a whole, as we've seen in the example above.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 I motori moderni applicano algoritmi avanzati di garbage collection.
 
 Un buon libro "The Garbage Collection Handbook: The Art of Automatic Memory Management" (R. Jones et al) che descrive alcuni degli algoritmi.
 
 Se conoscete la programmazione a basso livello, informazioni più dettagliate riguardo il Garbage collector V8 sono disponibili nell'articolo [A tour of V8: Garbage Collection](http://jayconrod.com/posts/55/a-tour-of-v8-garbage-collection).
 
+<<<<<<< HEAD
 [V8 blog](http://v8project.blogspot.com/) pubblica articoli riguardo i cambiamenti nella gestione della memoria. Ovviamente per apprendere il processo di garbage collection, è fortemente consigliato imparare il funzionamento del garbage collector V8 leggendo il blog [Vyacheslav Egorov](http://mrale.ph) che ha lavorato come ingegnere per lo sviluppo del V8. Vi dico "V8" perché è quello più utilizzato e maggiormente spiegato su internet. Per gli altri motori, gli approcci sono simili, ci sono alcune sottili differenze.
 
 Le conoscenze profonde dei motori sono importanti quando necessitate di ottimizzazioni a basso livello. Potrebbe essere un buon traguardo dopo essere diventati familiari con il linguaggio.
+=======
+If you are familiar with low-level programming, more detailed information about V8's garbage collector is in the article [A tour of V8: Garbage Collection](https://jayconrod.com/posts/55/a-tour-of-v8-garbage-collection).
+
+The [V8 blog](https://v8.dev/) also publishes articles about changes in memory management from time to time. Naturally, to learn more about garbage collection, you'd better prepare by learning about V8 internals in general and read the blog of [Vyacheslav Egorov](https://mrale.ph) who worked as one of the V8 engineers. I'm saying: "V8", because it is best covered by articles on the internet. For other engines, many approaches are similar, but garbage collection differs in many aspects.
+
+In-depth knowledge of engines is good when you need low-level optimizations. It would be wise to plan that as the next step after you're familiar with the language.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b

1-js/04-object-basics/04-object-methods/7-calculator/task.md

@@ -6,9 +6,15 @@ importance: 5
 
 Create un oggetto `calculator` con tre metodi:
 
+<<<<<<< HEAD
 - `read()` richiede tramite prompt due valori e li salva come proprietà dell'oggetto.
 - `sum()` ritorna la somma dei valori salvati.
 - `mul()` moltiplica i valori salvati e ritorna il risultato.
+=======
+- `read()` prompts for two values and saves them as object properties with names `a` and `b` respectively.
+- `sum()` returns the sum of saved values.
+- `mul()` multiplies saved values and returns the result.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 ```js
 let calculator = {
@@ -21,4 +27,3 @@ alert( calculator.mul() );
 ```
 
 [demo]
-

1-js/04-object-basics/04-object-methods/8-chain-calls/_js.view/solution.js

@@ -11,5 +11,6 @@ let ladder = {
   },
   showStep: function() { 
     alert(this.step);
+    return this;
   }
 };

1-js/04-object-basics/04-object-methods/8-chain-calls/_js.view/test.js

@@ -32,6 +32,14 @@ describe('Ladder', function() {
   it('down().up().up().up() ', function() {
     assert.equal(ladder.down().up().up().up().step, 2);
   });
+
+  it('showStep() should return this', function() {
+    assert.equal(ladder.showStep(), ladder);
+  });
+
+  it('up().up().down().showStep().down().showStep()', function () {
+    assert.equal(ladder.up().up().down().showStep().down().showStep().step, 0)
+  });
 
   after(function() {
     ladder.step = 0;

1-js/04-object-basics/04-object-methods/8-chain-calls/task.md

@@ -4,7 +4,11 @@ importance: 2
 
 # Concatenazione
 
+<<<<<<< HEAD
 Qui abbiamo un oggetto `ladder` che ci consente di salire e scendere:
+=======
+There's a `ladder` object that allows you to go up and down:
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 ```js
 let ladder = {
@@ -21,7 +25,11 @@ let ladder = {
 };
 ```
 
+<<<<<<< HEAD
 Ora, se abbiamo bisogno di eseguire più chiamate in sequenza, possiamo:
+=======
+Now, if we need to make several calls in sequence, we can do it like this:
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 ```js
 ladder.up();
@@ -32,10 +40,18 @@ ladder.down();
 ladder.showStep(); // 0
 ```
 
+<<<<<<< HEAD
 Modificare il codice di `up`, `down` e `showStep` per rendere le chiamate concatenabili, come in questo esempio:
+=======
+Modify the code of `up`, `down`, and `showStep` to make the calls chainable, like this:
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 ```js
 ladder.up().up().down().showStep().down().showStep(); // shows 1 then 0
 ```
 
+<<<<<<< HEAD
 Questo approccio è largamente utilizzato dalle librerie JavaScript.
+=======
+Such an approach is widely used across JavaScript libraries.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b

1-js/04-object-basics/04-object-methods/article.md

@@ -51,7 +51,7 @@ let user = {
 // prima la dichiariamo
 function sayHi() {
   alert("Hello!");
-};
+}
 
 // poi la aggiungiamo come metodo
 user.sayHi = sayHi;
@@ -90,7 +90,11 @@ user = {
 
 Come possiamo notare, si può omettere `"function"` e scrivere solamente `sayHi()`.
 
+<<<<<<< HEAD
 A dire la verità, la notazione non è proprio uguale. Ci sono delle sottili differenze legate all'ereditarietà degli oggetti (le studieremo più avanti), ma per ora non hanno importanza. Nella maggior parte dei casi la forma breve viene preferita.
+=======
+To tell the truth, the notations are not fully identical. There are subtle differences related to object inheritance (to be covered later), but for now they do not matter. In almost all cases, the shorter syntax is preferred.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 ## "this" nei metodi
 

1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/task.md

@@ -10,8 +10,8 @@ E' possibile creare due funzioni `A` e `B` tali che `new A()==new B()`?
 function A() { ... }
 function B() { ... }
 
-let a = new A;
-let b = new B;
+let a = new A();
+let b = new B();
 
 alert( a == b ); // true
 ```

1-js/04-object-basics/06-constructor-new/2-calculator-constructor/task.md

@@ -6,9 +6,15 @@ importance: 5
 
 Scrivete un costruttore `Calculator` che crea oggetti con 3 metodi:
 
+<<<<<<< HEAD
 - `read()` richiede due valori utilizzando `prompt` e li memorizza nelle proprietà dell'oggetto.
 - `sum()` ritorna la somma delle proprietà.
 - `mul()` ritorna il prodotto delle proprietà.
+=======
+- `read()` prompts for two values and saves them as object properties with names `a` and `b` respectively.
+- `sum()` returns the sum of these properties.
+- `mul()` returns the multiplication product of these properties.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Ad esempio:
 

1-js/04-object-basics/06-constructor-new/article.md

@@ -1,6 +1,10 @@
 # Costruttore, operatore "new"
 
+<<<<<<< HEAD
 La sintassi `{...}` ci consente di creare un oggetto. Ma spesso abbiamo bisogno di creare multipli oggetti simili, come ad esempio più utenti, oggetti del menu e molto altro.
+=======
+The regular `{...}` syntax allows us to create one object. But often we need to create many similar objects, like multiple users or menu items and so on.
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 Questo può essere fatto utilizzando un costruttore e l'operatore `"new"`.
 
@@ -172,8 +176,13 @@ alert(new SmallUser().name);  //John
 
 Solitamente i costruttori non hanno l'istruzione `return`. Abbiamo comunque riportato, per completezza, quel che succede se si tenta di ritornare un oggetto.
 
+<<<<<<< HEAD
 ````smart header="Omettere le parentesi"
 Possiamo anche omettere le parentesi dopo `new`, se non ci sono argomenti:
+=======
+````smart header="Omitting parentheses"
+By the way, we can omit parentheses after `new`:
+>>>>>>> 540d753e90789205fc6e75c502f68382c87dea9b
 
 ```js
 let user = new User; // <-- no parentheses