diff --git a/1-js/01-getting-started/index.md b/1-js/01-getting-started/index.md
index ffde6849c..cc4d66be2 100644
--- a/1-js/01-getting-started/index.md
+++ b/1-js/01-getting-started/index.md
@@ -1,3 +1,3 @@
 # Introduzione
 
-Riguardo il linguaggio JavaScript e l'ambiente di sviluppo.
+Studieremo il linguaggio JavaScript e l'ambiente di sviluppo.
diff --git a/1-js/02-first-steps/index.md b/1-js/02-first-steps/index.md
index c5569cdd6..ee7725e51 100644
--- a/1-js/02-first-steps/index.md
+++ b/1-js/02-first-steps/index.md
@@ -1,3 +1,3 @@
 # Le basi JavaScript 
 
-Impariamo le basi della scrittura di uno script.
\ No newline at end of file
+Impareremo le basi dello sviluppo di uno script.
\ No newline at end of file
diff --git a/1-js/03-code-quality/index.md b/1-js/03-code-quality/index.md
index 0dda8220f..8a61d522f 100644
--- a/1-js/03-code-quality/index.md
+++ b/1-js/03-code-quality/index.md
@@ -1,3 +1,3 @@
 # Qualità del codice
 
-Questo capitolo spiega le buone pratiche di programmazione da utilizzare durante lo sviluppo. 
+Impareremo le buone pratiche di programmazione da utilizzare durante lo sviluppo. 
diff --git a/1-js/07-object-properties/index.md b/1-js/07-object-properties/index.md
index 38784dd6b..0029cbeb4 100644
--- a/1-js/07-object-properties/index.md
+++ b/1-js/07-object-properties/index.md
@@ -1,3 +1,3 @@
 # Configurazione delle proprietà dell'oggetto
 
-In questa sezione torniamo a vedere gli oggetti e studiremo le loro proprietà più nel dettaglio.
+Procederemo con lo studio degli oggetti e studieremo le loro proprietà più nel dettaglio.
diff --git a/1-js/index.md b/1-js/index.md
index a97e3a981..3ef150d82 100644
--- a/1-js/index.md
+++ b/1-js/index.md
@@ -1,5 +1,6 @@
 # Il linguaggio JavaScript
-Qui impareremo JavaScript, iniziando dalle basi e passando per i concetti avanzati come OOP.
+
+Impareremo JavaScript, iniziando dalle basi e passando a concetti avanzati come OOP.
 
 Ci concentreremo principalmente sul linguaggio, con un minimo di annotazioni riguardo gli ambienti di sviluppo.
 
diff --git a/2-ui/1-document/08-styles-and-classes/2-create-notification/solution.view/index.html b/2-ui/1-document/08-styles-and-classes/2-create-notification/solution.view/index.html
index dc4eeec9f..8ef5d48f5 100755
--- a/2-ui/1-document/08-styles-and-classes/2-create-notification/solution.view/index.html
+++ b/2-ui/1-document/08-styles-and-classes/2-create-notification/solution.view/index.html
@@ -32,7 +32,7 @@ <h2>Notification is on the right</h2>
       setTimeout(() => notification.remove(), 1500);
     }
 
-    // test it
+    // prova
     let i = 1;
     setInterval(() => {
       showNotification({
diff --git a/2-ui/1-document/08-styles-and-classes/2-create-notification/source.view/index.html b/2-ui/1-document/08-styles-and-classes/2-create-notification/source.view/index.html
index b5e2f83f7..c92597797 100755
--- a/2-ui/1-document/08-styles-and-classes/2-create-notification/source.view/index.html
+++ b/2-ui/1-document/08-styles-and-classes/2-create-notification/source.view/index.html
@@ -16,10 +16,10 @@ <h2>Notification is on the right</h2>
 
   <script>
     function showNotification({top = 0, right = 0, className, html}) {
-      /* your code */
+      /* il tuo codice */
     }
 
-    // test it
+    // prova
     let i = 1;
     setInterval(() => {
       showNotification({
diff --git a/2-ui/1-document/08-styles-and-classes/2-create-notification/task.md b/2-ui/1-document/08-styles-and-classes/2-create-notification/task.md
index 60930cb6c..7c64fa49a 100644
--- a/2-ui/1-document/08-styles-and-classes/2-create-notification/task.md
+++ b/2-ui/1-document/08-styles-and-classes/2-create-notification/task.md
@@ -1,24 +1,24 @@
-importance: 5
+importanza: 5
 
 ---
 
-# Create a notification
+# Create un messaggio di notifica
 
-Write a function `showNotification(options)` that creates a notification: `<div class="notification">` with the given content. The notification should automatically disappear after 1.5 seconds.
+Scrivete una funzione `showNotification(options)` che crei una notifica: `<div class="notification">` con un dato contenuto. La notifica dovrebbe automaticamente sparire dopo 1.5 secondi.
 
-The options are:
+Le opzioni sono:
 
 ```js
-// shows an element with the text "Hello" near the right-top of the window
+// mostra un elemento con il testo "Hello" in prossimità dell'angolo in alto a destra della finestra
 showNotification({
-  top: 10, // 10px from the top of the window (by default 0px)
-  right: 10, // 10px from the right edge of the window (by default 0px)
-  html: "Hello!", // the HTML of notification
-  className: "welcome" // an additional class for the div (optional)
+  top: 10, // 10px dalla parte superiore della finestra (valore predefinito 0px)
+  right: 10, // 10px dal bordo destro della finestra (valore predefinito 0px)
+  html: "Hello!", // l'HTML della notifica
+  className: "welcome" // una classe addizionale per il div (opzionale)
 });
 ```
 
 [demo src="solution"]
 
 
-Use CSS positioning to show the element at given top/right coordinates. The source document has the necessary styles.
+Usate il posizionamento CSS per mostrare l'elemento nelle coordinate top/right ricevute. Il documento sorgente ha gli stili necessari.
diff --git a/2-ui/1-document/08-styles-and-classes/article.md b/2-ui/1-document/08-styles-and-classes/article.md
index 9154d43d6..bbb230894 100644
--- a/2-ui/1-document/08-styles-and-classes/article.md
+++ b/2-ui/1-document/08-styles-and-classes/article.md
@@ -1,37 +1,37 @@
-# Styles and classes
+# Stili e classi
 
-Before we get into JavaScript's ways of dealing with styles and classes -- here's an important rule. Hopefully it's obvious enough, but we still have to mention it.
+Prima di cominciare a trattare i modi in cui JavaScript interagisce con gli stili e le classi -- ecco una regola importante. Si spera che sia abbastanza scontata, ma non guasta ripeterla.
 
-There are generally two ways to style an element:
+Ci sono in genere due modi di applicare uno stile ad un elemento:
 
-1. Create a class in CSS and add it: `<div class="...">`
-2. Write properties directly into `style`: `<div style="...">`.
+1. Creare una classe CSS ed aggiungerla: `<div class="...">`
+2. Scrivere direttamente le proprietà dentro `style`: `<div style="...">`.
 
-JavaScript can modify both classes and `style` properties.
+JavaScript può modificare sia le classi sia le proprietà all'interno di `style`.
 
-We should always prefer CSS classes to `style`. The latter should only be used if classes "can't handle it".
+Dovremmo sempre preferire le classi CSS a `style`. Quest'ultimo dovrebbe essere usato solo se le classi non sono sufficienti.
 
-For example, `style` is acceptable if we calculate coordinates of an element dynamically and want to set them from JavaScript, like this:
+Per esempio, è ragionevole l'uso di `style` se calcoliamo dinamicamente le coordinate di un elemento e vogliamo impostarle con JavaScript, come in casi analoghi:
 
 ```js
-let top = /* complex calculations */;
-let left = /* complex calculations */;
+let top = /* calcoli complessi */;
+let left = /* calcoli complessi */;
 
-elem.style.left = left; // e.g '123px', calculated at run-time
-elem.style.top = top; // e.g '456px'
+elem.style.left = left; // es '123px', calcolato al momento dell'esecuzione
+elem.style.top = top; // es '456px'
 ```
 
-For other cases, like making the text red, adding a background icon -- describe that in CSS and then add the class (JavaScript can do that). That's more flexible and easier to support.
+Per gli altri casi, come rendere rosso un testo, aggiungere un'icona di sfondo -- definiamo degli stili CSS e poi applichiamo la classe con JavaScript. È più flessibile e più facile da supportare.
 
-## className and classList
+## className e classList
 
-Changing a class is one of the most often used actions in scripts.
+Modificare una classe è una delle operazioni più comuni negli script.
 
-In the ancient time, there was a limitation in JavaScript: a reserved word like `"class"` could not be an object property. That limitation does not exist now, but at that time it was impossible to have a `"class"` property, like `elem.class`.
+Anticamente c'era una limitazione in JavaScript: una parola riservata come `"class"` non poteva essere una proprietà di un oggetto. Tale limitazione non c'è più, ma a quel tempo era impossibile avere una proprietà `"class"` come `elem.class`.
 
-So for classes the similar-looking property `"className"` was introduced: the `elem.className` corresponds to the `"class"` attribute.
+Quindi per le classi fu introdotta la proprietà `"className"` che è simile: l'attributo `"class"` ha il suo corrispettivo DOM in `elem.className`.
 
-For instance:
+Per esempio:
 
 ```html run
 <body class="main page">
@@ -41,19 +41,19 @@ For instance:
 </body>
 ```
 
-If we assign something to `elem.className`, it replaces the whole string of classes. Sometimes that's what we need, but often we want to add/remove a single class.
+Se assegniamo un valore a `elem.className` rimpiazziamo l'intero contenuto dell'attributo `"class"`. Talvolta è il risultato che vogliamo ottenere, spesso invece vogliamo aggiungere/rimuovere una singola classe.
 
-There's another property for that: `elem.classList`.
+Esiste un'altra proprietà per quello: `elem.classList`.
 
-The `elem.classList` is a special object with methods to `add/remove/toggle` a single class.
+La proprietà `elem.classList` è uno speciale oggetto con i metodi `add/remove/toggle` per aggiungere/rimuovere/alternare una singola classe.
 
-For instance:
+Per esempio:
 
 ```html run
 <body class="main page">
   <script>
 *!*
-    // add a class
+    // aggiunge una classe
     document.body.classList.add('article');
 */!*
 
@@ -62,31 +62,31 @@ For instance:
 </body>
 ```
 
-So we can operate both on the full class string using `className` or on individual classes using `classList`. What we choose depends on our needs.
+Possiamo agire pertanto sia sulla stringa intera delle classi rappresentata da `className`, oppure sulle singole classi usando `classList`. La scelta dipende dalle nostre esigenze.
 
-Methods of `classList`:
+Metodi di `classList`:
 
-- `elem.classList.add/remove("class")` -- adds/removes the class.
-- `elem.classList.toggle("class")` -- adds the class if it doesn't exist, otherwise removes it.
-- `elem.classList.contains("class")` -- checks for the given class, returns `true/false`.
+- `elem.classList.add/remove("class")` -- aggiunge/rimuove la classe.
+- `elem.classList.toggle("class")` -- aggiunge la classe se non esiste, diversamente la rimuove.
+- `elem.classList.contains("class")` -- verifica che esista una determinata classe, restituisce `true/false`.
 
-Besides, `classList` is iterable, so we can list all classes with `for..of`, like this:
+In aggiunta `classList` è iterabile, quindi possiamo elencare tutte le classi con `for..of` in questo modo:
 
 ```html run
 <body class="main page">
   <script>
     for (let name of document.body.classList) {
-      alert(name); // main, and then page
+      alert(name); // main, e dopo page
     }
   </script>
 </body>
 ```
 
-## Element style
+## La proprietà style di un elemento
 
-The property `elem.style` is an object that corresponds to what's written in the `"style"` attribute. Setting `elem.style.width="100px"` works the same as if we had in the attribute `style` a string `width:100px`.
+La proprietà `elem.style` è un oggetto corrispondente a ciò che è scritto dentro l'attributo `"style"`. Impostando `elem.style.width="100px"` otteniamo lo stesso effetto che otterremmo scrivendo `width:100px` dentro l'attributo `style`.
 
-For multi-word property the camelCase is used:
+Per le proprietà composte da più di una parola, si usa l'iniziale maiuscola dalla seconda parola in poi (camel case):
 
 ```js no-beautify
 background-color  => elem.style.backgroundColor
@@ -94,16 +94,16 @@ z-index           => elem.style.zIndex
 border-left-width => elem.style.borderLeftWidth
 ```
 
-For instance:
+Per esempio:
 
 ```js run
 document.body.style.backgroundColor = prompt('background color?', 'green');
 ```
 
-````smart header="Prefixed properties"
-Browser-prefixed properties like `-moz-border-radius`, `-webkit-border-radius` also follow the same rule: a dash means upper case.
+````smart header="Proprietà con prefisso"
+Le proprietà con il prefisso del browser come `-moz-border-radius`, `-webkit-border-radius` seguono anch'esse la stessa regola: un trattino comporta l'uso del maiuscolo.
 
-For instance:
+Per esempio:
 
 ```js
 button.style.MozBorderRadius = '5px';
@@ -111,33 +111,34 @@ button.style.WebkitBorderRadius = '5px';
 ```
 ````
 
-## Resetting the style property
+## Resettare la proprietà style
 
-Sometimes we want to assign a style property, and later remove it.
+Talvolta vogliamo assegnare uno stile e successivamente rimuoverlo.
 
-For instance, to hide an element, we can set `elem.style.display = "none"`.
+Per esempio, per nascondere un elemento, possiamo impostare `elem.style.display = "none"`.
+
+Successivamente potremmo voler rimuovere `style.display` come se non fosse impostato. Invece di `delete elem.style.display` dovremmo assegnargli una stringa vuota: `elem.style.display = ""`.
 
-Then later we may want to remove the `style.display` as if it were not set. Instead of `delete elem.style.display` we should assign an empty string to it: `elem.style.display = ""`.
 
 ```js run
-// if we run this code, the <body> will blink
+// se eseguiamo questo codice, il <body> lampeggerà
 document.body.style.display = "none"; // hide
 
-setTimeout(() => document.body.style.display = "", 1000); // back to normal
+setTimeout(() => document.body.style.display = "", 1000); // ritorna alla normalità
 ```
 
-If we set `style.display` to an empty string, then the browser applies CSS classes and its built-in styles normally, as if there were no such `style.display` property at all.
+Se assegniamo una stringa vuota a `style.display`, il browser applica come di consueto le classi CSS ed i suoi stili predefiniti, come se non ci fosse alcuna proprietà `style.display`.
 
-````smart header="Full rewrite with `style.cssText`"
-Normally, we use `style.*` to assign individual style properties. We can't set the full style like `div.style="color: red; width: 100px"`, because `div.style` is an object, and it's read-only.
+````smart header="Riscrittura completa con `style.cssText`"
+Di solito usiamo `style.*` per assegnare le proprietà di stile individualmente. Non possiamo impostare tutti gli stili in questo modo `div.style="color: red; width: 100px"`, perché `div.style` è un oggetto ed è in sola lettura.
 
-To set the full style as a string, there's a special property `style.cssText`:
+Per impostare tutti gli stili come stringa c'è una speciale proprietà `style.cssText`:
 
 ```html run
 <div id="div">Button</div>
 
 <script>
-  // we can set special style flags like "important" here
+  // qui possiamo impostare speciali clausole di stile come "important"
   div.style.cssText=`color: red !important;
     background-color: yellow;
     width: 100px;
@@ -148,27 +149,27 @@ To set the full style as a string, there's a special property `style.cssText`:
 </script>
 ```
 
-This property is rarely used, because such assignment removes all existing styles: it does not add, but replaces them. May occasionally delete something needed. But we can safely use it for new elements, when we know we won't delete an existing style.
+Questa proprietà è usata di rado, poiché un tale assegnamento rimuove tutti gli stili esistenti: non li aggiunge, piuttosto li sostituisce. Potrebbe eliminare in modo fortuito qualcosa di necessario. Possiamo tuttavia usarla in sicurezza per i nuovi elementi, quando siamo certi che non cancelleremo uno stile preesistente.
 
-The same can be accomplished by setting an attribute: `div.setAttribute('style', 'color: red...')`.
+Lo stesso risultato può essere ottenuto impostando un attributo: `div.setAttribute('style', 'color: red...')`.
 ````
 
-## Mind the units
+## Prestate attenzione alle unità di misura
 
-Don't forget to add CSS units to values.
+Non dimenticate di aggiungere le unità di misura CSS ai valori.
 
-For instance, we should not set `elem.style.top` to `10`, but rather to `10px`. Otherwise it wouldn't work:
+Ad esempio, non dovremmo impostare `elem.style.top` a `10`, piuttosto a `10px`. Altrimenti non funzionerebbe:
 
 ```html run height=100
 <body>
   <script>
   *!*
-    // doesn't work!
+    // non funziona!
     document.body.style.margin = 20;
-    alert(document.body.style.margin); // '' (empty string, the assignment is ignored)
+    alert(document.body.style.margin); // '' (stringa vuota, l'assegnamento è stato ignorato)
   */!*
 
-    // now add the CSS unit (px) - and it works
+    // aggiungiamo ora l'unità di misura CSS (px) - e funziona
     document.body.style.margin = '20px';
     alert(document.body.style.margin); // 20px
 
@@ -178,19 +179,19 @@ For instance, we should not set `elem.style.top` to `10`, but rather to `10px`.
 </body>
 ```
 
-Please note: the browser "unpacks" the property `style.margin` in the last lines and infers `style.marginLeft` and `style.marginTop` from it.
+Nota: il browser "spacchetta" la proprietà `style.margin` nelle ultime linee e deduce da essa `style.marginLeft` e `style.marginTop`.
 
-## Computed styles: getComputedStyle
+## Stili calcolati: getComputedStyle
 
-So, modifying a style is easy. But how to *read* it?
+Modificare uno stile, quindi, è semplice. Ma come *leggerlo*?
 
-For instance, we want to know the size, margins, the color of an element. How to do it?
+Vogliamo, ad esempio, conoscere la dimensione, i margini, il colore di un elemento. Come fare?
 
-**The `style` property operates only on the value of the `"style"` attribute, without any CSS cascade.**
+**La proprietà `style` agisce solo sul valore dell'attributo `"style"`, senza considerare alcuna cascata CSS.**
 
-So we can't read anything that comes from CSS classes using `elem.style`.
+Pertanto non possiamo leggere nulla che derivi dalle classi CSS tramite `elem.style`.
 
-For instance, here `style` doesn't see the margin:
+Qui, per esempio, `style` non rileva il margine:
 
 ```html run height=60 no-beautify
 <head>
@@ -201,32 +202,32 @@ For instance, here `style` doesn't see the margin:
   The red text
   <script>
 *!*
-    alert(document.body.style.color); // empty
-    alert(document.body.style.marginTop); // empty
+    alert(document.body.style.color); // vuoto
+    alert(document.body.style.marginTop); // vuoto
 */!*
   </script>
 </body>
 ```
 
-...But what if we need, say, to increase the margin by `20px`? We would want the current value of it.
+...ma cosa dovremmo fare se avessimo bisogno, per dire, di incrementare il margine di `20px`? Dovremmo prima conoscerne il valore corrente.
 
-There's another method for that: `getComputedStyle`.
+C'è un altro metodo per quello: `getComputedStyle`.
 
-The syntax is:
+La sintassi è:
 
 ```js
 getComputedStyle(element, [pseudo])
 ```
 
 element
-: Element to read the value for.
+: L'elemento di cui leggere il valore.
 
 pseudo
-: A pseudo-element if required, for instance `::before`. An empty string or no argument means the element itself.
+: Uno pseudo-elemento se richiesto, per esempio `::before`. Una stringa vuota o nessun argomento significa l'elemento stesso.
 
-The result is an object with styles, like `elem.style`, but now with respect to all CSS classes.
+Il risultato è un oggetto con gli stili, come `elem.style`, ma, a differenza di quello, tiene conto di tutte le classi CSS.
 
-For instance:
+Per esempio:
 
 ```html run height=100
 <head>
@@ -237,7 +238,7 @@ For instance:
   <script>
     let computedStyle = getComputedStyle(document.body);
 
-    // now we can read the margin and the color from it
+    // adesso possiamo ricavarne il margine ed il colore
 
     alert( computedStyle.marginTop ); // 5px
     alert( computedStyle.color ); // rgb(255, 0, 0)
@@ -246,23 +247,23 @@ For instance:
 </body>
 ```
 
-```smart header="Computed and resolved values"
-There are two concepts in [CSS](https://drafts.csswg.org/cssom/#resolved-values):
+```smart header="Valori computed e resolved"
+Ci sono due concetti nei [CSS](https://drafts.csswg.org/cssom/#resolved-values):
 
-1. A *computed* style value is the value after all CSS rules and CSS inheritance is applied, as the result of the CSS cascade. It can look like `height:1em` or `font-size:125%`.
-2. A *resolved* style value is the one finally applied to the element. Values like `1em` or `125%` are relative. The browser takes the computed value and makes all units fixed and absolute, for instance: `height:20px` or `font-size:16px`. For geometry properties resolved values may have a floating point, like `width:50.5px`.
+1. Un valore di uno stile *computed* è il valore derivante dall'applicazione di tutte le regole e dell'ereditarietà dei CSS: il risultato della cascata CSS. Può essere simile a `height:1em` o `font-size:125%`.
+2. Un valore di uno stile *resolved* è quello applicato realmente sull'elemento. Valori come `1em` o `125%` sono relativi. Il browser prende i valori computed e li converte tutti in unità di misura fisse e assolute, per esempio: `height:20px` o `font-size:16px`. Per le proprietà geometriche i valori resolved possono avere la virgola, come `width:50.5px`.
 
-A long time ago `getComputedStyle` was created to get computed values, but it turned out that resolved values are much more convenient, and the standard changed.
+Molto tempo addietro `getComputedStyle` è stato creato per ottenere i valori computed, ma si scoprì che i valori resolved erano molto più utili e lo standard è cambiato.
 
-So nowadays `getComputedStyle` actually returns the resolved value of the property, usually in `px` for geometry.
+Attualmente, quindi, restituisce il valore resolved della proprietà, di solito espressa in `px` per le proprietà geometriche.
 ```
 
-````warn header="`getComputedStyle` requires the full property name"
-We should always ask for the exact property that we want, like `paddingLeft` or `marginTop` or `borderTopWidth`. Otherwise the correct result is not guaranteed.
+````warn header="`getComputedStyle` richiede il nome completo della proprietà"
+Dovremmo sempre chiedere l'esatta proprietà che si desidera, come `paddingLeft` o `marginTop` o `borderTopWidth`. Diversamente il risultato corretto non è garantito.
 
-For instance, if there are properties `paddingLeft/paddingTop`, then what should we get for `getComputedStyle(elem).padding`? Nothing, or maybe a "generated" value from known paddings? There's no standard rule here.
+Per esempio, se ci sono le proprietà `paddingLeft/paddingTop`, cosa dovremmo ottenere con `getComputedStyle(elem).padding`? Niente, o forse un valore "generato" a partire dai valori di padding noti? Non esiste una regola standard in questo caso.
 
-There are other inconsistencies. As an example, some browsers (Chrome) show `10px` in the document below, and some of them (Firefox) --  do not:
+Ci sono altre incongruenze. Ad esempio, alcuni browser (Chrome) mostrano `10px` nel documento in basso, ed altri (Firefox) -- invece no:
 
 ```html run
 <style>
@@ -272,32 +273,32 @@ There are other inconsistencies. As an example, some browsers (Chrome) show `10p
 </style>
 <script>
   let style = getComputedStyle(document.body);
-  alert(style.margin); // empty string in Firefox
+  alert(style.margin); // Firefox restituisce una stringa vuota
 </script>
 ```
 ````
 
-```smart header="Styles applied to `:visited` links are hidden!"
-Visited links may be colored using `:visited` CSS pseudoclass.
+```smart header="Gli stili applicati ai link `:visited` sono nascosti!"
+I link visitati possono ricevere un colore tramite la pseudoclasse CSS `:visited`.
 
-But `getComputedStyle` does not give access to that color, because otherwise an arbitrary page could find out whether the user visited a link by creating it on the page and checking the styles.
+Tuttavia `getComputedStyle non dà accesso a quel colore, poiché diversamente una pagina arbitraria potrebbe scoprire se l'utente ha visitato un link creandolo sulla pagina e verificandone gli stili.
 
-JavaScript may not see the styles applied by `:visited`. And also, there's a limitation in CSS that forbids applying geometry-changing styles in `:visited`. That's to guarantee that there's no side way for an evil page to test if a link was visited and hence to break the privacy.
+JavaScript potrebbe non rilevare gli stili applicati da `:visited`. C'è una limitazione nei CSS, inoltre, che vieta su `:visited` l'applicazione di stili che modifichino le proprietà geometriche. Questo per garantire che, per una pagina malevola, non ci sia una via traversa di testare se un link è stato visitato e quindi di violare la privacy.
 ```
 
-## Summary
+## Riepilogo
 
-To manage classes, there are two DOM properties:
+Per gestire le classi ci sono due proprietà DOM:
 
-- `className` -- the string value, good to manage the whole set of classes.
-- `classList` -- the object with methods `add/remove/toggle/contains`, good for individual classes.
+- `className` -- il valore stringa, ottimo per gestire l'intero insieme delle classi.
+- `classList` -- il valore oggetto con i metodi `add/remove/toggle/contains`, ottimo per gestire le classi individualmente.
 
-To change the styles:
+Per modificare gli stili:
 
-- The `style` property is an object with camelCased styles. Reading and writing to it has the same meaning as modifying individual properties in the `"style"` attribute. To see how to apply `important` and other rare stuff -- there's a list of methods at [MDN](mdn:api/CSSStyleDeclaration).
+- La proprietà `style` è un oggetto contenente gli stili CSS, le proprietà composte da più di una parola sono trascritte in camel case. Leggere e scrivere con questa proprietà equivale a modificare individualmente gli stili con l'attributo `"style"`. Per vedere come applicare `important` e per altre esigenze poco comuni -- c'è una lista di metodi su [MDN](mdn:api/CSSStyleDeclaration).
 
-- The `style.cssText` property corresponds to the whole `"style"` attribute, the full string of styles.
+- La proprietà `style.cssText` corrisponde al contenuto completo dell'attributo `"style"`, l'intera stringa degli stili.
 
-To read the resolved styles (with respect to all classes, after all CSS is applied and final values are calculated):
+Per leggere gli stili resolved (che tengono conto di tutte le classi, dopo che tutti i CSS sono stati applicati e sono stati calcolati i valori risultanti):
 
-- The `getComputedStyle(elem, [pseudo])` returns the style-like object with them. Read-only.
+- Il metodo `getComputedStyle(elem, [pseudo])` restituisce un oggetto simile a `style` con tali valori. Questi sono in sola lettura.
diff --git a/2-ui/1-document/index.md b/2-ui/1-document/index.md
index 1b60cdf2c..766141ea4 100644
--- a/2-ui/1-document/index.md
+++ b/2-ui/1-document/index.md
@@ -1,3 +1,3 @@
 # Document
 
-Here we'll learn to manipulate a web-page using JavaScript.
+Impareremo come manipolare una pagina web usando JavaScript.
diff --git a/2-ui/2-events/index.md b/2-ui/2-events/index.md
index f4996083c..b996f643c 100644
--- a/2-ui/2-events/index.md
+++ b/2-ui/2-events/index.md
@@ -1,3 +1,3 @@
-# Introduction to Events
+# Introduzione agli Eventi
 
-An introduction to browser events, event properties and handling patterns.
+Introdurremo gli eventi browser, le loro proprietà e i pattern per la loro gestione.
diff --git a/2-ui/3-event-details/index.md b/2-ui/3-event-details/index.md
index 569f08137..00082a4f1 100644
--- a/2-ui/3-event-details/index.md
+++ b/2-ui/3-event-details/index.md
@@ -1,3 +1,3 @@
-# UI Events
+# Eventi UI
 
-Here we cover most important user interface events and how to work with them.
+Studieremo i principali eventi per interfacce utente e come gestrili.
diff --git a/2-ui/4-forms-controls/index.md b/2-ui/4-forms-controls/index.md
index 726474b19..f71568059 100644
--- a/2-ui/4-forms-controls/index.md
+++ b/2-ui/4-forms-controls/index.md
@@ -1,3 +1,3 @@
 # Forms, controls
 
-Special properties and events for forms `<form>` and controls: `<input>`, `<select>` and other.
+Studieremo proprietà speciali ed eventi per i form `<form>` e i controlli: `<input>`, `<select>` e altri.
diff --git a/2-ui/index.md b/2-ui/index.md
index d94378cf3..04c48a974 100644
--- a/2-ui/index.md
+++ b/2-ui/index.md
@@ -1,3 +1,3 @@
-# Browser: Document, Events, Interfaces 
+# Browser: Document, Eventi, Interfacce
 
-Learning how to manage the browser page: add elements, manipulate their size and position, dynamically create interfaces and interact with the visitor.
+Impareremo come gestire la pagina del browser: aggiungere elementi, manipolare dimensione e posizione, creare interfacce dinamiche e interagire con l'utente.