Merge branch 'master' into master

21 files changed, 3562 insertions, 118 deletions

diff --git a/it-it/asciidoc-it.html.markdown b/it-it/asciidoc-it.html.markdown
new file mode 100644
index 00000000..47a57349
--- /dev/null
+++ b/it-it/asciidoc-it.html.markdown
@@ -0,0 +1,135 @@
+---
+language: asciidoc
+contributors:
+    - ["Ryan Mavilia", "http://unoriginality.rocks/"]
+    - ["Abel Salgado Romero", "https://twitter.com/abelsromero"]
+translators:
+    - ["Ale46", "https://github.com/ale46"]
+lang: it-it
+filename: asciidoc-it.md
+---
+
+AsciiDoc è un linguaggio di markup simile a Markdown e può essere usato per qualsiasi cosa, dai libri ai blog. Creato nel 2002 da Stuart Rackman, questo linguaggio è semplice ma permette un buon numero di personalizzazioni.
+
+Intestazione Documento
+
+Le intestazioni sono opzionali e possono contenere linee vuote. Deve avere almeno una linea vuota rispetto al contenuto.
+
+Solo titolo
+
+```
+= Titolo documento
+
+Prima frase del documento.
+```
+
+Titolo ed Autore
+
+```
+= Titolo documento
+Primo Ultimo <first.last@learnxinyminutes.com>
+
+Inizio del documento
+```
+
+Autori multipli
+
+```
+= Titolo Documento
+John Doe <john@go.com>; Jane Doe<jane@yo.com>; Black Beard <beardy@pirate.com>
+
+Inizio di un documento con autori multipli.
+```
+
+Linea di revisione (richiede una linea autore)
+
+```
+= Titolo documento V1
+Potato Man <chip@crunchy.com>
+v1.0, 2016-01-13
+
+Questo articolo sulle patatine sarà divertente.
+```
+
+Paragrafi
+
+```
+Non hai bisogno di nulla di speciale per i paragrafi.
+
+Aggiungi una riga vuota tra i paragrafi per separarli.
+
+Per creare una riga vuota aggiungi un +
+e riceverai una interruzione di linea!
+```
+
+Formattazione Testo
+
+```
+_underscore crea corsivo_
+*asterischi per il grassetto*
+*_combinali per maggiore divertimento_*
+`usa i ticks per indicare il monospazio`
+`*spaziatura fissa in grassetto*`
+```
+
+Titoli di sezione
+
+```
+= Livello 0 (può essere utilizzato solo nell'intestazione del documento)
+
+== Livello 1 <h2>
+
+=== Livello 2 <h3>
+
+==== Livello 3 <h4>
+
+===== Livello 4 <h5>
+
+```
+
+Liste
+
+Per creare un elenco puntato, utilizzare gli asterischi.
+
+```
+* foo
+* bar
+* baz
+```
+
+Per creare un elenco numerato usa i periodi.
+
+```
+. item 1
+. item 2
+. item 3
+```
+
+È possibile nidificare elenchi aggiungendo asterischi o periodi aggiuntivi fino a cinque volte.
+
+```
+* foo 1
+** foo 2
+*** foo 3
+**** foo 4
+***** foo 5
+
+. foo 1
+.. foo 2
+... foo 3
+.... foo 4
+..... foo 5
+```
+
+## Ulteriori letture
+
+Esistono due strumenti per elaborare i documenti AsciiDoc:
+
+1. [AsciiDoc](http://asciidoc.org/): implementazione Python originale, disponibile nelle principali distribuzioni Linux. Stabile e attualmente in modalità di manutenzione.
+2. [Asciidoctor](http://asciidoctor.org/): implementazione alternativa di Ruby, utilizzabile anche da Java e JavaScript. In fase di sviluppo attivo, mira ad estendere la sintassi AsciiDoc con nuove funzionalità e formati di output.
+
+I seguenti collegamenti sono relativi all'implementazione di `Asciidoctor`:
+
+* [Markdown - AsciiDoc comparazione sintassi](http://asciidoctor.org/docs/user-manual/#comparison-by-example): confronto affiancato di elementi di Markdown e AsciiDoc comuni.
+* [Per iniziare](http://asciidoctor.org/docs/#get-started-with-asciidoctor): installazione e guide rapide per il rendering di documenti semplici.
+* [Asciidoctor Manuale Utente](http://asciidoctor.org/docs/user-manual/): manuale completo con riferimento alla sintassi, esempi, strumenti di rendering, tra gli altri.
diff --git a/it-it/c++-it.html.markdown b/it-it/c++-it.html.markdown
index b4f9c50e..449aebfb 100644
--- a/it-it/c++-it.html.markdown
+++ b/it-it/c++-it.html.markdown
@@ -1130,7 +1130,6 @@ compl 4    // Effettua il NOT bit-a-bit
 ```
 Letture consigliate:
 
-Un riferimento aggiornato del linguaggio può essere trovato qui
-<http://cppreference.com/w/cpp>
-
-Risorse addizionali possono essere trovate qui <http://cplusplus.com>
+* Un riferimento aggiornato del linguaggio può essere trovato qui [CPP Reference](http://cppreference.com/w/cpp).
+* Risorse addizionali possono essere trovate qui [CPlusPlus](http://cplusplus.com).
+* Un tutorial che copre le basi del linguaggio e l'impostazione dell'ambiente di codifica è disponibile su [TheChernoProject - C ++](https://www.youtube.com/playlist?list=PLlrATfBNZ98dudnM48yfGUldqGD0S4FFb).
diff --git a/it-it/dynamic-programming-it.html.markdown b/it-it/dynamic-programming-it.html.markdown
new file mode 100644
index 00000000..9c7bd9b6
--- /dev/null
+++ b/it-it/dynamic-programming-it.html.markdown
@@ -0,0 +1,55 @@
+---
+category: Algorithms & Data Structures
+name: Dynamic Programming
+contributors:
+    - ["Akashdeep Goel", "http://github.com/akashdeepgoel"]
+translators:
+    - ["Ale46", "https://github.com/ale46"]
+lang: it-it
+---
+
+# Programmazione dinamica
+
+## Introduzione
+
+La programmazione dinamica è una tecnica potente utilizzata per risolvere una particolare classe di problemi, come vedremo. L'idea è molto semplice, se hai risolto un problema con l'input dato, salva il risultato come riferimento futuro, in modo da evitare di risolvere nuovamente lo stesso problema.
+
+Ricordate sempre!
+"Chi non ricorda il passato è condannato a ripeterlo"
+
+## Modi per risolvere questi problemi
+
+1. *Top-Down* : Inizia a risolvere il problema specifico suddividendolo. Se vedi che il problema è già stato risolto, rispondi semplicemente con la risposta già salvata. Se non è stato risolto, risolvilo e salva la risposta. Di solito è facile da pensare e molto intuitivo. Questo è indicato come Memoization.
+
+2. *Bottom-Up* : Analizza il problema e vedi l'ordine in cui i sotto-problemi sono risolti e inizia a risolvere dal sottoproblema banale, verso il problema dato. In questo processo, è garantito che i sottoproblemi vengono risolti prima di risolvere il problema. Si parla di programmazione dinamica.
+
+## Esempio di programmazione dinamica
+
+Il problema di "Longest Increasing Subsequence" consiste nel trovare la sottosequenza crescente più lunga di una determinata sequenza. Data una sequenza `S= {a1 , a2 , a3, a4, ............., an-1, an }` dobbiamo trovare il sottoinsieme più lungo tale che per tutti gli `j` e gli `i`,  `j<i` nel sotto-insieme `aj<ai`.
+Prima di tutto dobbiamo trovare il valore delle sottosequenze più lunghe (LSi) ad ogni indice i con l'ultimo elemento della sequenza che è ai. Quindi il più grande LSi sarebbe la sottosequenza più lunga nella sequenza data. Per iniziare LSi viene inizializzato ad 1, dato che ai è un element della sequenza (Ultimo elemento). Quindi per tutti gli `j` tale che `j<i` e `aj<ai`, troviamo il più grande LSj e lo aggiungiamo a LSi. Quindi l'algoritmo richiede un tempo di *O(n2)*.
+
+Pseudo-codice per trovare la lunghezza della sottosequenza crescente più lunga:
+Questa complessità degli algoritmi potrebbe essere ridotta usando una migliore struttura dei dati piuttosto che una matrice. La memorizzazione dell'array predecessore e della variabile come `largest_sequences_so_far` e il suo indice farebbero risparmiare molto tempo.
+
+Un concetto simile potrebbe essere applicato nel trovare il percorso più lungo nel grafico aciclico diretto.
+
+```python
+for i=0 to n-1
+    LS[i]=1
+    for j=0 to i-1
+        if (a[i] >  a[j] and LS[i]<LS[j])
+            LS[i] = LS[j]+1
+for i=0 to n-1
+    if (largest < LS[i])
+```
+
+### Alcuni famosi problemi DP
+
+- Floyd Warshall Algorithm - Tutorial e Codice sorgente in C del programma: [http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code]()
+- Integer Knapsack Problem - Tutorial e Codice sorgente in C del programma: [http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem]()
+- Longest Common Subsequence - Tutorial e Codice sorgente in C del programma: [http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence]()
+
+
+## Risorse online
+
+* [codechef](https://www.codechef.com/wiki/tutorial-dynamic-programming)
diff --git a/it-it/go-it.html.markdown b/it-it/go-it.html.markdown
index e005f2dc..797f6b0b 100644
--- a/it-it/go-it.html.markdown
+++ b/it-it/go-it.html.markdown
@@ -26,14 +26,14 @@ Aggiunge la concorrenza in maniera diretta e semplice da capire, per far
 forza sulle CPU multi-core di oggigiorno. Presenta caratteristiche utili
 per la programmazione in larga scala.
 
-Go comes with a great standard library and an enthusiastic community.
+Go include un'ottima libreria standard e ha una community entusiasta.
 
 ```go
 // Commento su riga singola
 /* Commento
  su riga multipla */
 
-// In cima a ogni file è necessario specificare il package.
+// In cima ad ogni file è necessario specificare il package.
 // Main è un package speciale che identifica un eseguibile anziché una libreria.
 package main
 
@@ -65,19 +65,19 @@ func oltreIlCiaoMondo() {
 	x = 3     // Assegnazione di una variabile.
     // E' possibile la dichiarazione "rapida" := per inferire il tipo, dichiarare e assegnare contemporaneamente.
 	y := 4
-    // Una funzione che ritorna due valori.
-	somma, prod := imparaMoltepliciValoriDiRitorno(x, y)
+    // Una funzione che restituisce due valori.
+	somma, prod := imparaMoltepliciValoriRestituiti(x, y)
 	fmt.Println("somma:", somma, "prodotto:", prod)    // Semplice output.
 	imparaTipi()                                       // < y minuti, devi imparare ancora!
 }
 
 /* <- commento su righe multiple
-Le funzioni possono avere parametri e ritornare (molteplici!) valori.
-Qua, x e y sono gli argomenti, mentre somma e prod sono i valori ritornati.
+Le funzioni possono avere parametri e restituire (molteplici!) valori.
+In questo esempio, x e y sono gli argomenti, mentre somma e prod sono i valori restituiti.
 Da notare il fatto che x e somma vengono dichiarati come interi.
 */
-func imparaMoltepliciValoriDiRitorno(x, y int) (somma, prod int) {
-	return x + y, x * y // Ritorna due valori.
+func imparaMoltepliciValoriRestituiti(x, y int) (somma, prod int) {
+	return x + y, x * y // Restituisce due valori.
 }
 
 // Ecco alcuni tipi presenti in Go
@@ -86,7 +86,7 @@ func imparaTipi() {
 	str := "Impara il Go!" // Tipo stringa.
 
 	s2 := `Una stringa letterale
-puo' includere andata a capo.` // Sempre di tipo stringa.
+può includere andata a capo.` // Sempre di tipo stringa.
 
     // Stringa letterale non ASCII. I sorgenti Go sono in UTF-8.
 	g := 'Σ' // Il tipo runa, alias per int32, è costituito da un code point unicode.
@@ -144,20 +144,20 @@ puo' includere andata a capo.` // Sempre di tipo stringa.
 	imparaControlloDiFlusso() // Torniamo in carreggiata.
 }
 
-// In Go è possibile associare dei nomi ai valori di ritorno di una funzione.
-// Assegnare un nome al tipo di dato ritornato permette di fare return in vari
+// In Go è possibile associare dei nomi ai valori restituiti da una funzione.
+// Assegnare un nome al tipo di dato restituito permette di fare return in vari
 // punti all'interno del corpo della funzione, ma anche di usare return senza
-// specificare in modo esplicito che cosa ritornare.
-func imparaValoriDiRitornoConNome(x, y int) (z int) {
+// specificare in modo esplicito che cosa restituire.
+func imparaValoriRestituitiConNome(x, y int) (z int) {
 	z = x * y
 	return // z è implicito, perchè compare nella definizione di funzione.
 }
 
 // Go è dotato di garbage collection. Ha i puntatori, ma non l'aritmetica dei
-// puntatori. Puoi fare errori coi puntatori a nil, ma non puoi direttamente
-// incrementare un puntatore.
+// puntatori. Puoi commettere errori a causa di puntatori nulli, ma non puoi
+// incrementare un puntatore direttamente.
 func imparaLaMemoria() (p, q *int) {
-    // I valori di ritorno (con nome) p e q sono puntatori a int.
+    // I valori restituiti (con nome) p e q sono puntatori a int.
 	p = new(int) // La funzione new si occupa di allocare memoria.
     // L'int allocato viene inizializzato a 0, dunque p non è più nil.
 	s := make([]int, 20) // Alloca 20 int come un singolo blocco di memoria.
@@ -207,14 +207,14 @@ func imparaControlloDiFlusso() {
 	}
 	// x == 42 qua.
 
-    // Il for è l'unica istruzione per ciclare in Go, ma ha varie forme.
+    // Il for è l'unica istruzione per i loop in Go, ma ha varie forme.
 	for { // Ciclo infinito.
 		break    // Scherzavo.
 		continue // Non si arriva qua.
 	}
 
-    // Puoi usare range per ciclare su un vettore, slice, stringa, mappa o canale.
-    // range ritorna uno (per i canali) o due valori (vettore, slice, stringa, mappa).
+    // Puoi usare range per iterare lungo un vettore, slice, stringa, mappa o canale.
+    // range restituisce uno (per i canali) o due valori (vettore, slice, stringa, mappa).
 	for chiave, valore := range map[string]int{"uno": 1, "due": 2, "tre": 3} {
         // per ogni coppia dentro la mappa, stampa chiave e valore
 		fmt.Printf("chiave=%s, valore=%d\n", chiave, valore)
@@ -236,7 +236,7 @@ func imparaControlloDiFlusso() {
     // Inoltre le funzioni letterali possono essere definite e chiamate
     // inline, col ruolo di parametri di funzione, a patto che:
     // a) la funzione letterale venga chiamata subito (),
-    // b) il valore ritornato è in accordo con il tipo dell'argomento.
+    // b) il valore restituito è in accordo con il tipo dell'argomento.
 	fmt.Println("Somma e raddoppia due numeri: ",
 		func(a, b int) int {
 			return (a + b) * 2
@@ -247,7 +247,7 @@ func imparaControlloDiFlusso() {
 	goto amore
 amore:
 
-	imparaFabbricaDiFunzioni() // Una funzione che ritorna un'altra funzione è divertente!
+	imparaFabbricaDiFunzioni() // Una funzione che restituisce un'altra funzione è divertente!
 	imparaDefer()              // Un tour veloce di una parola chiave importante.
 	imparaInterfacce()         // Arriva la roba buona!
 }
@@ -270,12 +270,13 @@ func fabbricaDiFrasi(miaStringa string) func(prima, dopo string) string {
 }
 
 func imparaDefer() (ok bool) {
-    // Le istruzioni dette "deferred" (rinviate) sono eseguite
-    // appena prima che la funzione ritorni.
+	// La parola chiave "defer" inserisce una funzione in una lista.
+	// La lista contenente tutte le chiamate a funzione viene eseguita DOPO
+	// il return finale della funzione che le circonda.
 	defer fmt.Println("le istruzioni 'deferred' sono eseguite in ordine inverso (LIFO).")
 	defer fmt.Println("\nQuesta riga viene stampata per prima perché")
     // defer viene usato di solito per chiudere un file, così la funzione che
-    // chiude il file viene messa vicino a quella che lo apre.
+    // chiude il file, preceduta da "defer", viene messa vicino a quella che lo apre.
 	return true
 }
 
diff --git a/it-it/html-it.html.markdown b/it-it/html-it.html.markdown
index 471019a1..8f7391a2 100644
--- a/it-it/html-it.html.markdown
+++ b/it-it/html-it.html.markdown
@@ -1,6 +1,6 @@
 ---
 language: html
-filename: learnhtml-it.html
+filename: learnhtml-it.txt
 contributors:
     - ["Christophe THOMAS", "https://github.com/WinChris"]
 translators:
@@ -112,7 +112,7 @@ Questo articolo riguarda principalmente la sintassi HTML ed alcuni suggerimenti
 
 ## Uso
 
-HTML è scritto in files che finiscono con `.html`.
+HTML è scritto in files che finiscono con `.html` o `.htm`. Il "MIME type" è `text/html`.
 
 ## Per saperne di più
 
diff --git a/it-it/java-it.html.markdown b/it-it/java-it.html.markdown
index 54602cff..1669816e 100644
--- a/it-it/java-it.html.markdown
+++ b/it-it/java-it.html.markdown
@@ -17,14 +17,14 @@ concorrente, basato su classi e adatto a svariati scopi.
 ```java
 // I commenti su singola linea incominciano con //
 /*
-I commenti su piu' linee invece sono cosi'
+I commenti su più linee invece sono così
 */
 /**
-I commenti per la documentazione JavaDoc si fanno cosi'.
+I commenti per la documentazione JavaDoc si fanno così.
 Vengono usati per descrivere una classe o alcuni suoi attributi.
 */
 
-// Per importare la classe ArrayList conenuta nel package java.util
+// Per importare la classe ArrayList contenuta nel package java.util
 import java.util.ArrayList;
 // Per importare tutte le classi contenute nel package java.security
 import java.security.*;
@@ -48,7 +48,7 @@ public class LearnJava {
         System.out.print("Ciao ");
         System.out.print("Mondo ");
 
-        // Per stampare del testo formattato, si puo' usare System.out.printf
+        // Per stampare del testo formattato, si può usare System.out.printf
         System.out.printf("pi greco = %.5f", Math.PI); // => pi greco = 3.14159
 
         ///////////////////////////////////////
@@ -60,7 +60,7 @@ public class LearnJava {
         */
         // Per dichiarare una variabile basta fare <tipoDato> <nomeVariabile>
         int fooInt;
-        // Per dichiarare piu' di una variabile dello lo stesso tipo si usa:
+        // Per dichiarare più di una variabile dello lo stesso tipo si usa:
         // <tipoDato> <nomeVariabile1>, <nomeVariabile2>, <nomeVariabile3>
         int fooInt1, fooInt2, fooInt3;
 
@@ -71,7 +71,7 @@ public class LearnJava {
         // Per inizializzare una variabile si usa
         // <tipoDato> <nomeVariabile> = <valore>
         int fooInt = 1;
-        // Per inizializzare piu' di una variabile dello lo stesso tipo
+        // Per inizializzare più di una variabile dello lo stesso tipo
         // si usa <tipoDato> <nomeVariabile1>, <nomeVariabile2>, <nomeVariabile3> = <valore>
         int fooInt1, fooInt2, fooInt3;
         fooInt1 = fooInt2 = fooInt3 = 1;
@@ -94,7 +94,7 @@ public class LearnJava {
         // Long - intero con segno a 64 bit (in complemento a 2)
         // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
         long fooLong = 100000L;
-        // L viene usato per indicare che il valore e' di tipo Long;
+        // L viene usato per indicare che il valore è di tipo Long;
         // altrimenti il valore viene considerato come intero.
 
         // Nota: Java non dispone di interi senza segno.
@@ -102,14 +102,14 @@ public class LearnJava {
         // Float - Numero in virgola mobile a 32 bit con precisione singola (IEEE 754)
         // 2^-149 <= float <= (2-2^-23) * 2^127
         float fooFloat = 234.5f;
-        // f o F indicano the la variabile e' di tipo float;
+        // f o F indicano the la variabile è di tipo float;
         // altrimenti il valore viene considerato come double.
 
         // Double - Numero in virgola mobile a 64 bit con precisione doppia (IEEE 754)
         // 2^-1074 <= x <= (2-2^-52) * 2^1023
         double fooDouble = 123.4;
 
-        // Boolean - Puo' assumere il valore vero (true) o falso (false)
+        // Boolean - Può assumere il valore vero (true) o falso (false)
         boolean fooBoolean = true;
         boolean barBoolean = false;
 
@@ -118,26 +118,26 @@ public class LearnJava {
 
         // Le variabili precedute da final possono essere inizializzate una volta sola,
         final int HOURS_I_WORK_PER_WEEK = 9001;
-        // pero' e' possibile dichiararle e poi inizializzarle in un secondo momento.
+        // però è possibile dichiararle e poi inizializzarle in un secondo momento.
         final double E;
         E = 2.71828;
 
 
         // BigInteger - Interi a precisione arbitraria
         //
-        // BigInteger e' un tipo di dato che permette ai programmatori di
-        // gestire interi piu' grandi di 64 bit. Internamente, le variabili
+        // BigInteger è un tipo di dato che permette ai programmatori di
+        // gestire interi più grandi di 64 bit. Internamente, le variabili
         // di tipo  BigInteger vengono memorizzate come un vettore di byte e 
         // vengono manipolate usando funzioni dentro la classe BigInteger.
         //
-        // Una variabile di tipo BigInteger puo' essere inizializzata usando
+        // Una variabile di tipo BigInteger può essere inizializzata usando
         // un array di byte oppure una stringa.
         
         BigInteger fooBigInteger = new BigDecimal(fooByteArray);
 
         // BigDecimal - Numero con segno, immutabile, a precisione arbitraria
         //
-        // Una variabile di tipo BigDecimal e' composta da due parti: un intero
+        // Una variabile di tipo BigDecimal è composta da due parti: un intero
         // a precisione arbitraria detto 'non scalato', e un intero a 32 bit
         // che rappresenta la 'scala', ovvero la potenza di 10 con cui
         // moltiplicare l'intero non scalato.
@@ -158,9 +158,9 @@ public class LearnJava {
         // Stringhe
         String fooString = "Questa e' la mia stringa!";
 
-        // \n e' un carattere di escape che rappresenta l'andare a capo
+        // \n è un carattere di escape che rappresenta l'andare a capo
         String barString = "Stampare su una nuova riga?\nNessun problema!";
-        // \t e' un carattere di escape che aggiunge un tab
+        // \t è un carattere di escape che aggiunge un tab
         String bazString = "Vuoi aggiungere un tab?\tNessun problema!";
         System.out.println(fooString);
         System.out.println(barString);
@@ -168,7 +168,7 @@ public class LearnJava {
 
         // Vettori
         // La dimensione di un array deve essere decisa in fase di
-        // istanziazione. Per dichiarare un array si puo' fare in due modi:
+        // istanziazione. Per dichiarare un array si può fare in due modi:
         // <tipoDato>[] <nomeVariabile> = new <tipoDato>[<dimensioneArray>];
         // <tipoDato> <nomeVariabile>[] = new <tipoDato>[<dimensioneArray>];
         int[] intArray = new int[10];
@@ -189,8 +189,8 @@ public class LearnJava {
         System.out.println("intArray @ 1: " + intArray[1]); // => 1
 
         // Ci sono altri tipo di dato interessanti.
-        // ArrayList - Simili ai vettori, pero' offrono altre funzionalita',
-        //             e la loro dimensione puo' essere modificata.
+        // ArrayList - Simili ai vettori, però offrono altre funzionalità,
+        //             e la loro dimensione può essere modificata.
         // LinkedList - Si tratta di una lista linkata doppia, e come tale
         //              implementa tutte le operazioni del caso.
         // Map - Un insieme di oggetti che fa corrispondere delle chiavi
@@ -207,7 +207,7 @@ public class LearnJava {
 
         int i1 = 1, i2 = 2; // Dichiarazone multipla in contemporanea
 
-        // L'aritmetica e' lineare.
+        // L'aritmetica è lineare.
         System.out.println("1+2 = " + (i1 + i2)); // => 3
         System.out.println("2-1 = " + (i2 - i1)); // => 1
         System.out.println("2*1 = " + (i2 * i1)); // => 2
@@ -253,7 +253,7 @@ public class LearnJava {
         ///////////////////////////////////////
         System.out.println("\n->Strutture di controllo");
 
-        // La dichiarazione dell'If e'' C-like.
+        // La dichiarazione dell'If è C-like.
         int j = 10;
         if (j == 10){
             System.out.println("Io vengo stampato");
@@ -328,18 +328,18 @@ public class LearnJava {
         System.out.println("Risultato del costrutto switch: " + stringaMese);
 
         // Condizioni brevi
-        // Si puo' usare l'operatore '?' per un rapido assegnamento
+        // Si può usare l'operatore '?' per un rapido assegnamento
         // o per operazioni logiche.
         // Si legge: 
-        // Se (condizione) e' vera, usa <primo valore>, altrimenti usa <secondo valore>
+        // Se (condizione) è vera, usa <primo valore>, altrimenti usa <secondo valore>
         int foo = 5;
         String bar = (foo < 10) ? "A" : "B";
         System.out.println("Se la condizione e' vera stampa A: "+bar); 
-        // Stampa A, perche' la condizione e' vera.
+        // Stampa A, perché la condizione è vera.
 
 
         /////////////////////////////////////////
-        // Convertire i tipi di tati e Typcasting
+        // Convertire i tipi di dati e Typecasting
         /////////////////////////////////////////
 
         // Convertire tipi di dati
@@ -397,16 +397,16 @@ class Bicicletta {
 
     // Variabili della bicicletta
     public int cadenza; 
-      // Public: Puo' essere richiamato da qualsiasi classe
+      // Public: Può essere richiamato da qualsiasi classe
     private int velocita; 
-      // Private: e'' accessibile solo dalla classe dove e'' stato inizializzato
+      // Private: è accessibile solo dalla classe dove è stato inizializzato
     protected int ingranaggi; 
-      // Protected: e'' visto sia dalla classe che dalle sottoclassi
+      // Protected: è visto sia dalla classe che dalle sottoclassi
     String nome; 
-      // default: e'' accessibile sono all'interno dello stesso package
+      // default: è accessibile sono all'interno dello stesso package
 
     // I costruttori vengono usati per creare variabili
-    // Questo e'' un costruttore
+    // Questo è un costruttore
     public Bicicletta() {
         ingranaggi = 1;
         cadenza = 50;
@@ -414,7 +414,7 @@ class Bicicletta {
         nome = "Bontrager";
     }
 
-    // Questo e'' un costruttore che richiede parametri
+    // Questo è un costruttore che richiede parametri
     public Bicicletta(int cadenza, int velocita, int ingranaggi, String nome) {
         this.ingranaggi = ingranaggi;
         this.cadenza = cadenza;
@@ -469,7 +469,7 @@ class Bicicletta {
     }
 } // Fine classe bicicletta
 
-// PennyFarthing e'' una sottoclasse della bicicletta
+// PennyFarthing è una sottoclasse della bicicletta
 class PennyFarthing extends Bicicletta {
     // (Sono quelle biciclette con un unica ruota enorme
     // Non hanno ingranaggi.)
@@ -481,7 +481,7 @@ class PennyFarthing extends Bicicletta {
 
     // Bisogna contrassegnre un medodo che si sta riscrivendo 
     // con una @annotazione
-    // Per saperne di piu' sulle annotazioni
+    // Per saperne di più sulle annotazioni
     // Vedi la guida: http://docs.oracle.com/javase/tutorial/java/annotations/
     @Override
     public void setIngranaggi(int ingranaggi) {
@@ -518,8 +518,8 @@ class Frutta implements Commestibile, Digestibile {
 	}
 }
 
-//In Java si puo' estendere solo una classe, ma si possono implementare 
-//piu' interfaccie, per esempio:
+//In Java si può estendere solo una classe, ma si possono implementare 
+//più interfaccie, per esempio:
 class ClasseEsempio extends AltraClasse implements PrimaInterfaccia, SecondaInterfaccia {
 	public void MetodoPrimaInterfaccia() {
 
diff --git a/it-it/javascript-it.html.markdown b/it-it/javascript-it.html.markdown
new file mode 100644
index 00000000..68bf6287
--- /dev/null
+++ b/it-it/javascript-it.html.markdown
@@ -0,0 +1,617 @@
+---
+language: javascript
+contributors:
+    - ["Adam Brenecki", "http://adam.brenecki.id.au"]
+    - ["Ariel Krakowski", "http://www.learneroo.com"]
+translators:
+    - ["vinniec", "https://github.com/vinniec"]
+filename: javascript-it.js
+lang: it-it
+---
+
+JavaScript è stato creato da Netscape di Brendan Eich nel 1995. È stato originariamente pensato come un semplice linguaggio di scripting per i siti web, complementare all'uso di java per applicazioni più complesse ma la sua stretta integrazione con le pagine Web e il supporto integrato con esse ha causato il suo divenire più comune di Java per i frontend web.
+
+Tuttavia JavaScript non è semplicemente limitato ai web browser: Node.js è un progetto che fornisce una runtime standalone dell'engine JavaScript V8 per Google Chrome, sta diventando sempre più popolare.
+
+JavaScript ha una sintassi C-like, quindi se usate linguaggi come C o Java, molta della sintassi di base sarà già familiare. A dispetto di questo, e a dispetto del nome similare, il modello a oggetti di JavaScript è significativamente diverso da quello di Java.
+
+```js
+// I commenti a singola linea iniziano con due slash.
+/* I commenti multilinea cominciano con uno slash e un asterisco,
+   e terminano con un asterisco e uno slash */
+
+// Le istruzioni possono essere terminate con ;
+doStuff();
+
+// ... ma non devono esserci per forza, i punti e virgola vengono automaticamente inseriti
+// dove c'è un newline, ad eccezione di alcuni casi.
+doStuff()
+
+// Poiché questi casi possono causare risultati inaspettati, noi continueremo ad usare
+// i punti e virgola in questa guida.
+
+///////////////////////////////////
+// 1. Numeri, Stringe e Operatori
+
+// JavaScript ha un tipo numero (che è a 64-bit IEEE 754 double).
+// Double ha una mantissa di 52-bit che è abbastanza per memorizzare interi
+// fino a 9x10¹⁵ per essere precisi.
+3; // = 3
+1.5; // = 1.5
+
+// Alcuni lavori aritmetici di base come ci si può aspettare.
+1 + 1; // = 2
+0.1 + 0.2; // = 0.30000000000000004
+8 - 1; // = 7
+10 * 2; // = 20
+35 / 5; // = 7
+
+// inclusa la divisione con la virgola.
+5 / 2; // = 2.5
+
+// E il modulo.
+10 % 2; // = 0
+30 % 4; // = 2
+18.5 % 7; // = 4.5
+
+// Anche le operazioni binarie funzionano; quando effettuate una operazione binaria il vostro numero decimale
+// è convertito in un intero con segno *fino a* 32 bit..
+1 << 2; // = 4
+
+// Le precedenza è subordinata dalle parentesi.
+(1 + 3) * 2; // = 8
+
+// Ci sono tre valori speciali che non sono numeri reali:
+Infinity; // ad esempio il risultato di 1/0
+-Infinity; // ad esempio il risultato di -1/0
+NaN; // ad esempio il risultato di 0/0, sta per 'Not a Number'
+
+// Ci sono anche i tipi booleani.
+true;
+false;
+
+// Le stringe sono create con ' oppure ".
+'abc';
+"Hello, world";
+
+// La negazione usa il ! simbolo
+!true; // = false
+!false; // = true
+
+// L'uguaglianza è ===
+1 === 1; // = true
+2 === 1; // = false
+
+// L'inuguaglianza è !==
+1 !== 1; // = false
+2 !== 1; // = true
+
+// Altre comparazioni
+1 < 10; // = true
+1 > 10; // = false
+2 <= 2; // = true
+2 >= 2; // = true
+
+// Le stringhe si concatenano con il +
+"Hello " + "world!"; // = "Hello world!"
+
+// ... che funziona con qualcosa in più delle semplici stringhe
+"1, 2, " + 3; // = "1, 2, 3"
+"Hello " + ["world", "!"]; // = "Hello world,!"
+
+// e sono comparate con < e >
+"a" < "b"; // = true
+
+// La comparazione con conversione implicita si fa con il doppio uguale...
+"5" == 5; // = true
+null == undefined; // = true
+
+// ...ammenoché non si usi ===
+"5" === 5; // = false
+null === undefined; // = false
+
+// ...che può provocare strani comportamenti...
+13 + !0; // 14
+"13" + !0; // '13true'
+
+// Si può accedere ai caratteri di una stringa con  `charAt`
+"This is a string".charAt(0);  // = 'T'
+
+// ...o usando le `substring` per ottenere una parte.
+"Hello world".substring(0, 5); // = "Hello"
+
+// `length` è una proprietà, quindi non usate le ().
+"Hello".length; // = 5
+
+// Ci sono anche `null` e `undefined`.
+null;      // usato per indicato deliberatamente un non-valore
+undefined; // usato per indicare un valore che attualmente non è presente (sebbene
+           // `undefined` sia un valore a sua stessa volta)
+
+// false, null, undefined, NaN, 0 e "" sono falsi; tutto il resto è vero.
+// Notare che 0 è falso e "0" è vero, nonostante 0 == "0".
+
+///////////////////////////////////
+// 2. Variabili, Array e Oggetti
+
+// Le variabili sono dichiarate con la parola chiave `var`. JavaScript è tipato
+// dinamicamente, quindi non serve specificare il tipo. L'assegnamento usa un carattere `=`
+// singolo.
+var someVar = 5;
+
+// Se si toglie la parola chiave var non si otterrà un errore...
+someOtherVar = 10;
+
+// ...ma la tua variabile sarà creata con visibilità globale e non
+// nel blocco dove la si è definita.
+
+// Le variabili dichiarate senza essere definite vengono impostate come undefined.
+var someThirdVar; // = undefined
+
+// Se si vuole dichiarare una coppia di variabili, lo si può fare usando una virgola
+// come separatore
+var someFourthVar = 2, someFifthVar = 4;
+
+// C'è una scorciatoia per effettuare operazioni matematiche sulle variabili:
+someVar += 5; // equivalente di someVar = someVar + 5; someVar vale 10 ora
+someVar *= 10; // ora someVar è 100
+
+// e un ulteriore scorciatoia per aggiungere o sottrarre 1
+someVar++; // ora someVar è 101
+someVar--; // di nuovo 100
+
+// Gli array sono liste ordinati di valori, di qualsiasi tipo.
+var myArray = ["Hello", 45, true];
+
+// Si può accedere ai loro membri usando la sintassi sottoscritta con le parentesi quadra.
+// Gli indici degli array iniziano a zero.
+myArray[1]; // = 45
+
+// Gli Array sono mutabili e di dimensione variabile.
+myArray.push("World");
+myArray.length; // = 4
+
+// Aggiungere/Modificare in un indice preciso
+myArray[3] = "Hello";
+
+// Aggiungere e rimovere un elemento dall'inizio o dalla fine di un array
+myArray.unshift(3); // Aggiungere come primo elemento
+someVar = myArray.shift(); // Rimuovere il primo elemento e restituirlo
+myArray.push(3); // Aggiungere come ultimo elemento
+someVar = myArray.pop(); // Rimuovere l'ultimo elemento e restituirlo
+
+// Unire tutti gli elementi di un array con un punto e virgola
+var myArray0 = [32,false,"js",12,56,90];
+myArray0.join(";") // = "32;false;js;12;56;90"
+
+// Ottenere un subarray di elementi dall'indice 1 (incluso) al 4 (escluso)
+myArray0.slice(1,4); // = [false,"js",12]
+
+// Rimuovere 4 elementi partendo dall'indice 2 e inserirci delle stringhe
+// "hi","wr" e "ld"; restituiscono i subarray rimossi
+myArray0.splice(2,4,"hi","wr","ld"); // = ["js",12,56,90]
+// myArray0 === [32,false,"hi","wr","ld"]
+
+// Gli oggetti di JavaScript sono equivalenti ai "dizionari" o "mappe" in altri
+// linguaggi: una collezione non ordinata di coppie di chiave-valore.
+var myObj = {key1: "Hello", key2: "World"};
+
+// Le chiavi sono stringhe, ma non è necessario quotarle se sono identificatori
+// JavaScript validi. I valori possono essere di ogni tipo.
+var myObj = {myKey: "myValue", "my other key": 4};
+
+// Gli attributi degli oggetti possono essere acceduti usando la sintassi "subscript",
+myObj["my other key"]; // = 4
+
+// ... o usando la notazione puntata fornendo una chiave che sia un identificatore valido.
+myObj.myKey; // = "myValue"
+
+// Gli oggetti sono mutabilil; i valori possono essere cambiati e nuove chiavi possono essere aggiunte.
+myObj.myThirdKey = true;
+
+// se si prova ad accedere ad un valore che non è stato ancora impostato, si otterrà undefined.
+myObj.myFourthKey; // = undefined
+
+///////////////////////////////////
+// 3. Strutture logiche e di controllo.
+
+// La struttura `if` funziona come ci si aspetta.
+var count = 1;
+if (count == 3){
+    // eseguito se count vale 3
+} else if (count == 4){
+    // eseguito se count vale 4
+} else {
+    // eseguito se count non è né 3 e né 4
+}
+
+// Così come il `while`.
+while (true){
+    // Un ciclo infinito!
+}
+
+// I cicli do-while sono come i cicli while ad eccezione che loro iterano almeno una volta.
+var input;
+do {
+    input = getInput();
+} while (!isValid(input));
+
+// Il ciclo `for` è lo stesso di C e di Java:
+// inizializzazione, condizione di proseguimento; iterazione.
+for (var i = 0; i < 5; i++){
+    // verrà eseguito 5 volte
+}
+
+// Uscire forzatamente da un un ciclo etichettato è simile a java:
+outer:
+for (var i = 0; i < 10; i++) {
+    for (var j = 0; j < 10; j++) {
+        if (i == 5 && j ==5) {
+            break outer;
+            // esce fuori dal ciclo outer invece che solo da quello più interno
+        }
+    }
+}
+
+// L'istruzione for/in permette l'iterazione sulle proprietà di un oggetto.
+var description = "";
+var person = {fname:"Paul", lname:"Ken", age:18};
+for (var x in person){
+    description += person[x] + " ";
+} // description = 'Paul Ken 18 '
+
+// L'istruzione for/of permette l'iterazione su oggetti iterabili (inclusi i built-in String,
+// Array, es. gli argomenti Array-like o gli oggetti NodeList, TypedArray, Map e Set,
+// e gli iterabili decisi dall'utente).
+var myPets = "";
+var pets = ["cat", "dog", "hamster", "hedgehog"];
+for (var pet of pets){
+    myPets += pet + " ";
+} // myPets = 'cat dog hamster hedgehog '
+
+// && è la congiunzione logica, || è la disgiunione logica
+if (house.size == "big" && house.colour == "blue"){
+    house.contains = "bear";
+}
+if (colour == "red" || colour == "blue"){
+    // i colori sono sia rossi che blu
+}
+
+// && e || "short circuit", utili per impostare i valori di default.
+var name = otherName || "default";
+
+// L'istruzione `switch` controlla l'uguaglianza con `===`.
+// Usare 'break' dopo ogni caso
+// oppure i casi dopo quello corretto verranno eseguiti comunque.
+grade = 'B';
+switch (grade) {
+  case 'A':
+    console.log("Great job");
+    break;
+  case 'B':
+    console.log("OK job");
+    break;
+  case 'C':
+    console.log("You can do better");
+    break;
+  default:
+    console.log("Oy vey");
+    break;
+}
+
+
+///////////////////////////////////
+// 4. Funzioni, Visibilità e Closure
+
+// Le funzioni di JavaScript sono dichiarate con la parolachiave `function`.
+function myFunction(thing){
+    return thing.toUpperCase();
+}
+myFunction("foo"); // = "FOO"
+
+// Nota che il valore da restituire deve iniziare nella stessa riga della
+// keyword `return`, altrimenti verrà sempre restituito `undefined` per via due to
+// dell'inserimento automatico dei punti e virgola. Fare attenzione a questo quando si usa lo stile Allman.
+function myFunction(){
+    return // <- punto e virgola automaticamente inserito qui
+    {thisIsAn: 'object literal'};
+}
+myFunction(); // = undefined
+
+// Le funzioni di JavaScript sono oggetti di prima classe, quindi possono essere riassegnate
+// a diversi nomi di variabili e passate ad altre funzioni come argomenti - per esempio,
+// mentre si fornisce un gestore di eventi:
+function myFunction(){
+    // questo codice sarà chiamato in 5 secondi
+}
+setTimeout(myFunction, 5000);
+// Nota: setTimeout non è parte del linguaggio JS, ma è fornito dai browser
+// e da Node.js.
+
+// Un altra funzione fornita dai browser è setInterval
+function myFunction(){
+    // questo codice verrà chiamato ogni 5 secondi
+}
+setInterval(myFunction, 5000);
+
+// Gli oggetti funzione non devono essere dichiarati con un nome - potete scrivere
+// la definizione di una funzione anonima direttamente come argomento di un'altra.
+setTimeout(function(){
+    // questo codice sarà chiamato in 5 secondi
+}, 5000);
+
+// In JavaScript le funzioni hanno una propria visibilità; le funzioni hanno
+// il loro scope ma gli altri blocchi no.
+if (true){
+    var i = 5;
+}
+i; // = 5 - non è undefined come ci si potrebbe aspettare in un linguaggio con una propria visibilità per blocco
+
+// Questo ha portato ad un pattern comune di "esecuzione immediata di funzioni
+// anonime", che previene alle variabili temporanee di finire nella
+// visibilità globale.
+(function(){
+    var temporary = 5;
+    // Noi possiamo accedere alla visibilità globale assegnando all' "oggetto globale", che
+    // in un browser web è sempre `windows`. L'oggetto globale potrebbe avere
+    // nomi differenti in ambienti diverso dal browser come Node.js.
+    window.permanent = 10;
+})();
+temporary; // solleva ReferenceError
+permanent; // = 10
+
+// Una delle più potenti caratteristiche di javascript sono le closure. Se una funzione è
+// definita dentro un'altra funzione, la funzione interna ha accesso a le variabili
+// della funzione esterna, anche dopo essere uscita dalla funzione esterna.
+function sayHelloInFiveSeconds(name){
+    var prompt = "Hello, " + name + "!";
+    // Le funzioni interne sono messe nella visibilità locale in modo predefinito, anche se vengono
+    // dichiarate con `var`.
+    function inner(){
+        alert(prompt);
+    }
+    setTimeout(inner, 5000);
+    // setTimeout è asincrono, quindi la funzione sayHelloInFiveSeconds
+    // esce immediatamente e setTimeout chiamera inner successivamente. Tuttavia,
+    // poiché inner è "chiuso prima" di sayHelloInFiveSeconds, inner ha ancora
+    // accesso alla variabile `prompt` quando viene finalmente richiamato.
+}
+sayHelloInFiveSeconds("Adam"); // aprirà un popup con "Hello, Adam!" in 5s
+
+///////////////////////////////////
+// 5. Di più sugli oggetti, costruttori e prototipi.
+
+// Gli oggetti possono contenere funzioni.
+var myObj = {
+    myFunc: function(){
+        return "Hello world!";
+    }
+};
+myObj.myFunc(); // = "Hello world!"
+
+// Quando una funzione contenuta in un oggetto viene chiamata, essa può accedere a questo oggetto
+// possono farlo usando la parola chiave `this`.
+myObj = {
+    myString: "Hello world!",
+    myFunc: function(){
+        return this.myString;
+    }
+};
+myObj.myFunc(); // = "Hello world!"
+
+// Questo ha a che fare con come la funzione è chiamata, non con dove
+// è definita. Quindi, la nostra funzione non funziona se non è chiamata
+// nel contesto dell'oggetto.
+var myFunc = myObj.myFunc;
+myFunc(); // = undefined
+
+// Al contrario, una funzione può essere assegnata ad un oggetto e poi accedere ad esso
+// attraverso `this`, anche se non è stata inserita durante la definizione.
+var myOtherFunc = function(){
+    return this.myString.toUpperCase();
+};
+myObj.myOtherFunc = myOtherFunc;
+myObj.myOtherFunc(); // = "HELLO WORLD!"
+
+// Possiamo anche specificare un contesto per una funzione da eseguire quando la invochiamo
+// usando `call` o `apply`.
+
+
+var anotherFunc = function(s){
+    return this.myString + s;
+};
+anotherFunc.call(myObj, " And Hello Moon!"); // = "Hello World! And Hello Moon!"
+
+// La funzione `apply` è quasi identica, ma prende un array come lista
+// di argomenti.
+
+anotherFunc.apply(myObj, [" And Hello Sun!"]); // = "Hello World! And Hello Sun!"
+
+// Questo è utile quanso si lavora con una funzione che accetta una sequenza di
+// argomenti e si vuole passare un array.
+
+Math.min(42, 6, 27); // = 6
+Math.min([42, 6, 27]); // = NaN (uh-oh!)
+Math.min.apply(Math, [42, 6, 27]); // = 6
+
+// Ma, `call` e `apply` sono solo temporanei. Quando vogliamo incollarli, possiamo
+// usare `bind`
+
+var boundFunc = anotherFunc.bind(myObj);
+boundFunc(" And Hello Saturn!"); // = "Hello World! And Hello Saturn!"
+
+// `bind` può essere anche usato per applicare parzialmente (curry) una funzione.
+
+var product = function(a, b){ return a * b; };
+var doubler = product.bind(this, 2);
+doubler(8); // = 16
+
+// Quando si chiama una funzione con la parola chiave `new`, un nuovo oggetto viene creato
+// e reso disponibile alla funzione attraverso la parola chiave `this`. Le funzioni progettate per essere
+// invocate in questo modo sono chiamate costruttrici.
+
+var MyConstructor = function(){
+    this.myNumber = 5;
+};
+myNewObj = new MyConstructor(); // = {myNumber: 5}
+myNewObj.myNumber; // = 5
+
+// Diversamente dalla molti degli altri linguaggi orientati agli oggetti, Javascript non ha
+// il concetto di 'istanze' create sull'impronta di una 'classe'; invece Javascript
+// combina l'instanziamento e l'ereditarietà in un singolo concetto: il 'prototipo'.
+
+// Ogni oggetto Javascript ha un 'prototipo'. Quando si cerca di accedere a una proprietà
+// su un oggetto che non la contiene, l'interprete
+// guarderà i suoi prototipi.
+
+// Alcune implementazioni di JS faranno accedere al propotipo di un oggetto con la proprietà
+// magica `__proto__`: Anche se questo è utile per spiegare i prototipi, non è
+// parte dello standard; capiremo più avanti come usare i prototipi in modo standard.
+var myObj = {
+    myString: "Hello world!"
+};
+var myPrototype = {
+    meaningOfLife: 42,
+    myFunc: function(){
+        return this.myString.toLowerCase();
+    }
+};
+
+myObj.__proto__ = myPrototype;
+myObj.meaningOfLife; // = 42
+
+// Questo funziona anche per le funzioni.
+myObj.myFunc(); // = "hello world!"
+
+// Ovviamente, se la proprietà non è nel prototipo, il prototipo
+// del prototipo viene ricercato, e così via.
+myPrototype.__proto__ = {
+    myBoolean: true
+};
+myObj.myBoolean; // = true
+
+// Non c'è nessuna copia coinvolta qui; ogni oggetto mantiene una referenza al suo
+// prototipo. Questo significa che possiamo modificare il prototipo e i nostri cambiamenti
+// si rifletteranno da ogni parte.
+myPrototype.meaningOfLife = 43;
+myObj.meaningOfLife; // = 43
+
+// L'istruzione for/in permette di iterare sulle proprietà di un oggetto,
+// risalendo la catena dei prototipi finché non trova un prototipo null.
+for (var x in myObj){
+    console.log(myObj[x]);
+}
+///stampa:
+// Hello world!
+// 43
+// [Function: myFunc]
+// true 
+
+// Per considerare solamente le proprietà inserite nell'oggetto stesso
+// e non i loro prototipi, usare il check `hasOwnProperty()`.
+for (var x in myObj){
+    if (myObj.hasOwnProperty(x)){
+        console.log(myObj[x]);
+    }
+}
+///stampa:
+// Hello world!
+
+// Abbiamo menzionato che `__proto__` non è standard, e non c'è nessun modo standard per
+// cambiare il prototipo di un oggetto esistente. Tuttavia, ci sono due strade per
+// creare un nuovo oggetto con un dato prototipo.
+
+// La prima è Object.create, che è una recente aggiunta a JS, e che quindi
+// non è disponibile ancora in tutte le implementazioni.
+var myObj = Object.create(myPrototype);
+myObj.meaningOfLife; // = 43
+
+// La seconda strada, che funziona ovunque, ha a che fare con i costruttori.
+// I costruttori hanno una proprietà chiamata prototype. Questo *non* è il prototipo del
+// costruttore della stessa funzione; invece è il prototipo del nuovo oggetto
+// che gli viene conferito alla creazione con quel costruttore e la parola chiave new.
+MyConstructor.prototype = {
+    myNumber: 5,
+    getMyNumber: function(){
+        return this.myNumber;
+    }
+};
+var myNewObj2 = new MyConstructor();
+myNewObj2.getMyNumber(); // = 5
+myNewObj2.myNumber = 6;
+myNewObj2.getMyNumber(); // = 6
+
+// I tipi built-in come stringhe e numeri hanno anche costruttori che creano
+// oggetti wrapper equivalenti.
+var myNumber = 12;
+var myNumberObj = new Number(12);
+myNumber == myNumberObj; // = true
+
+// Eccezione, loro non sono esattamente equivalenti.
+typeof myNumber; // = 'number'
+typeof myNumberObj; // = 'object'
+myNumber === myNumberObj; // = false
+if (0){
+    // Questo codice non verrà eseguito perchè 0 è falso.
+}
+if (new Number(0)){
+   // Questo codice verrà eseguito poiché i numeri wrappati sono oggetti e gli oggetti
+   // sono sempre veri.
+}
+
+// Tuttavia, gli oggetti wrapper e i regolari built-in condividono un prototipo, quindi
+// si possono aggiungere funzionalità ad una stringa, per esempio.
+String.prototype.firstCharacter = function(){
+    return this.charAt(0);
+};
+"abc".firstCharacter(); // = "a"
+
+// Questa caratteristica viene spesso usata nel "polyfilling", che implementa nuovi
+// aspetti in un vecchio sottoinsieme di JavaScript, in modo che si possano
+// usare in vecchi ambienti come browser non aggiornati.
+
+// Per esempio, abbiamo menzionato che Object.create non è disponibile in tutte le
+// implementazioni, ma possiamo ancora usarlo con questo polyfill:
+if (Object.create === undefined){ // non lo sovrascrive se esiste già
+    Object.create = function(proto){
+        // crea un costruttore temporaneo con il giusto prototipo
+        var Constructor = function(){};
+        Constructor.prototype = proto;
+        // quindi lo usa per creare un nuovo, propriamente-prototipato oggetto
+        return new Constructor();
+    };
+}
+```
+
+## Approfondimenti
+
+Il [Mozilla Developer Networ][1] fornisce una documentazione eccellente su come Javascript è utilizzato nei browsers. In più è un wiki, quindi si può imparare di più aiutando gli altri condividendo la propria conoscenza.
+
+MDN's [A re-introduction to JavaScript][2] copre molti dei concetti qui trattati in maggiore dettaglio. Questa guida ha deliberatamente coperto solamente il linguaggio JavaScript; se volete sapere di più su come usare JavaScript in una pagina web, iniziate leggendo il [Document Object Model][3].
+
+[Learn Javascript by Example and with Challenges][4] è una variante di questo referenziario con integrate delle sfide.
+
+[Javascript Garden][5] è una guida approfondita di tutte le parti controintuitive del linguaggio.
+
+[JavaScript: The Definitive Guide][6] è una guida classica e referenziario.
+
+[Eloqunt Javascript][8] di Marijn Haverbeke è un ottimo libro/ebook JS con terminale annesso
+
+[Javascript: The Right Way][10] è una guida dedicata all'introduzione dei nuovi sviluppatori a JavaScript e come aiuto agli sviluppatori esperti per imparare di più sulle best practice.
+
+[Javascript:info][11] è un moderno tutorial su javascript che copre le basi (linguaggio principale e lavorazione con un browser) come anche argomenti avanzati con spiegazioni concise.
+
+
+In aggiunta ai contributori di questo articolo, alcuni contenuti sono adattati dal Louie Dinh's Python tutorial su questo sito, e da [JS Tutorial][7] sul Mozilla Developer Network.
+
+
+[1]: https://developer.mozilla.org/en-US/docs/Web/JavaScript
+[2]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript
+[3]: https://developer.mozilla.org/en-US/docs/Using_the_W3C_DOM_Level_1_Core
+[4]: http://www.learneroo.com/modules/64/nodes/350
+[5]: http://bonsaiden.github.io/JavaScript-Garden/
+[6]: http://www.amazon.com/gp/product/0596805527/
+[7]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript
+[8]: http://eloquentjavascript.net/
+[10]: http://jstherightway.org/
+[11]: https://javascript.info/
diff --git a/it-it/jquery-it.html.markdown b/it-it/jquery-it.html.markdown
new file mode 100644
index 00000000..811c5c3a
--- /dev/null
+++ b/it-it/jquery-it.html.markdown
@@ -0,0 +1,131 @@
+---
+category: tool
+tool: jquery
+contributors:
+    - ["Sawyer Charles", "https://github.com/xssc"]
+filename: jquery-it.js
+translators:
+    - ["Ale46", "https://github.com/ale46"]
+lang: it-it
+---
+
+jQuery è una libreria JavaScript che ti aiuta a "fare di più, scrivendo meno". Rende molte attività comuni di JavaScript più facili da scrivere. jQuery è utilizzato da molte grandi aziende e sviluppatori in tutto il mondo. Rende AJAX, gestione degli eventi, manipolazione dei documenti e molto altro, più facile e veloce.
+
+Visto che jQuery è una libreria JavaScript dovresti prima [imparare JavaScript](https://learnxinyminutes.com/docs/javascript/)
+
+```js
+
+
+///////////////////////////////////
+// 1. Selettori
+
+// I selettori in jQuery vengono utilizzati per selezionare un elemento
+var page = $(window); // Seleziona l'intera finestra
+
+// I selettori possono anche essere selettori CSS
+var paragraph = $('p'); // Seleziona tutti gli elementi del paragrafo
+var table1 = $('#table1'); // Seleziona elemento con id 'table1'
+var squares = $('.square'); // Seleziona tutti gli elementi con la classe 'square'
+var square_p = $('p.square') // Seleziona i paragrafi con la classe 'square'
+
+
+///////////////////////////////////
+// 2. Eventi ed effetti
+// jQuery è molto bravo a gestire ciò che accade quando un evento viene attivato
+// Un evento molto comune è l'evento "pronto" sul documento
+// Puoi usare il metodo 'ready' per aspettare che l'elemento abbia finito di caricare
+$(document).ready(function(){
+  // Il codice non verrà eseguito fino a quando il documento non verrà caricato
+});
+// Puoi anche usare funzioni definite
+function onAction() {
+  // Questo viene eseguito quando l'evento viene attivato
+}
+$('#btn').click(onAction); // Invoca onAction al click
+
+// Alcuni altri eventi comuni sono:
+$('#btn').dblclick(onAction); // Doppio click
+$('#btn').hover(onAction); // Al passaggio del mouse
+$('#btn').focus(onAction); // Al focus
+$('#btn').blur(onAction); // Focus perso
+$('#btn').submit(onAction); // Al submit
+$('#btn').select(onAction); // Quando un elemento è selezionato
+$('#btn').keydown(onAction); // Quando un tasto è premuto (ma non rilasciato)
+$('#btn').keyup(onAction); // Quando viene rilasciato un tasto
+$('#btn').keypress(onAction); // Quando viene premuto un tasto
+$('#btn').mousemove(onAction); // Quando il mouse viene spostato
+$('#btn').mouseenter(onAction); // Il mouse entra nell'elemento
+$('#btn').mouseleave(onAction); // Il mouse lascia l'elemento
+
+
+// Questi possono anche innescare l'evento invece di gestirlo
+// semplicemente non passando alcun parametro
+$('#btn').dblclick(); // Innesca il doppio click sull'elemento
+
+// Puoi gestire più eventi mentre usi il selettore solo una volta
+$('#btn').on(
+  {dblclick: myFunction1} // Attivato con doppio clic
+  {blur: myFunction1} // Attivato al blur
+);
+
+// Puoi spostare e nascondere elementi con alcuni metodi di effetto
+$('.table').hide(); // Nascondi gli elementi
+
+// Nota: chiamare una funzione in questi metodi nasconderà comunque l'elemento
+$('.table').hide(function(){
+    // Elemento nascosto quindi funzione eseguita
+});
+
+// È possibile memorizzare selettori in variabili
+var tables = $('.table');
+
+// Alcuni metodi di manipolazione dei documenti di base sono:
+tables.hide(); // Nascondi elementi
+tables.show(); // Mostra elementi
+tables.toggle(); // Cambia lo stato nascondi/mostra
+tables.fadeOut(); // Fades out
+tables.fadeIn(); // Fades in
+tables.fadeToggle(); // Fades in o out
+tables.fadeTo(0.5); // Dissolve in opacità (tra 0 e 1)
+tables.slideUp(); // Scorre verso l'alto
+tables.slideDown(); // Scorre verso il basso
+tables.slideToggle(); // Scorre su o giù
+
+// Tutti i precedenti prendono una velocità (millisecondi) e la funzione di callback
+tables.hide(1000, myFunction); // nasconde l'animazione per 1 secondo quindi esegue la funzione
+
+// fadeTo ha un'opacità richiesta come secondo parametro
+tables.fadeTo(2000, 0.1, myFunction); // esegue in 2 sec. il fade sino ad una opacità di 0.1 opacity e poi la funzione
+
+// Puoi ottenere un effetti più avanzati con il metodo animate
+tables.animate({margin-top:"+=50", height: "100px"}, 500, myFunction);
+// Il metodo animate accetta un oggetto di css e valori con cui terminare,
+// parametri opzionali per affinare l'animazione,
+// e naturalmente la funzione di callback
+
+///////////////////////////////////
+// 3. Manipolazione
+
+// Questi sono simili agli effetti ma possono fare di più
+$('div').addClass('taming-slim-20'); // Aggiunge la classe taming-slim-20 a tutti i div 
+
+// Metodi di manipolazione comuni
+$('p').append('Hello world'); // Aggiunge alla fine dell'elemento
+$('p').attr('class'); // Ottiene l'attributo
+$('p').attr('class', 'content'); // Imposta l'attributo
+$('p').hasClass('taming-slim-20'); // Restituisce vero se ha la classe
+$('p').height(); // Ottiene l'altezza dell'elemento o imposta l'altezza
+
+
+// Per molti metodi di manipolazione, ottenere informazioni su un elemento
+// restituirà SOLO il primo elemento corrispondente
+$('p').height(); // Ottiene solo la prima altezza del tag 'p'
+
+// È possibile utilizzare each per scorrere tutti gli elementi
+var heights = [];
+$('p').each(function() {
+  heights.push($(this).height()); // Aggiunge tutte le altezze del tag 'p' all'array
+});
+
+
+```
diff --git a/it-it/logtalk-it.html.markdown b/it-it/logtalk-it.html.markdown
index 7f1e9eeb..5cc53e6f 100644
--- a/it-it/logtalk-it.html.markdown
+++ b/it-it/logtalk-it.html.markdown
@@ -43,7 +43,7 @@ Un oggetto incapsula le dichiarazioni e le definizioni dei predicati. Gli oggett
 :- end_object.
 ```
 
-# Compilazione dei file sorgenti
+# Compilazione e il caricamento dei file sorgenti
 
 Supponendo che il codice di cui sopra per l'oggetto `list` venga salvato in un file` list.lgt`, esso può essere compilato e caricato utilizzando il predicato predefiniti `logtalk_load/1` o la sua abbreviazione `{}/1`, con il percorso del file come argomento (l'estensione può essere omessa):
 
@@ -52,6 +52,9 @@ Supponendo che il codice di cui sopra per l'oggetto `list` venga salvato in un f
 yes
 ```
 
+In generale, le entità potrebbero avere dipendenze sulle entità definite in altri file di origine (ad esempio le entità di biblioteca). Per caricare un file e tutte le sue dipendenze, la soluzione consigliata consiste nel definire un file _loader_ che carica tutti i file necessari per un'applicazione. Un file loader è semplicemente un file di origine, in genere denominato `loader.lgt`, che effettua chiamate ai predicati built-in `logtalk_load/1-2`, di solito
+da una direttiva `initialization/1` per la portabilità e conformità agli standard. Caricatore file vengono forniti per tutte le librerie, strumenti ed esempi. 
+
 # Inviare un messaggio ad un oggetto
 
 L'operatore infisso `::/2` è usato per inviare messaggi ad un oggetto. Analogamente al Prolog, è possibile fare backtracking per le soluzioni alternative:
diff --git a/it-it/markdown.html.markdown b/it-it/markdown.html.markdown
index 44801747..b0a123f1 100644
--- a/it-it/markdown.html.markdown
+++ b/it-it/markdown.html.markdown
@@ -28,7 +28,7 @@ Markdown varia nelle sue implementazioni da un parser all'altro. Questa guida ce
 ## Elementi HTML
 Markdown è un superset di HTML, quindi ogni file HTML è a sua volta un file Markdown valido.
 
-```markdown
+```md
 <!-- Questo significa che possiamo usare elementi di HTML in Markdown, come per esempio i commenti,
 e questi non saranno modificati dal parser di Markdown. State attenti però, 
 se inserite un elemento HTML nel vostro file Markdown, non potrete usare la sua sintassi 
@@ -39,7 +39,7 @@ all'interno del contenuto dell'elemento. -->
 
 Potete creare gli elementi HTML da `<h1>` a `<h6>` facilmente, basta che inseriate un egual numero di caratteri cancelletto (#) prima del testo che volete all'interno dell'elemento
 
-```markdown
+```md
 # Questo è un <h1>
 ## Questo è un <h2>
 ### Questo è un <h3>
@@ -49,7 +49,7 @@ Potete creare gli elementi HTML da `<h1>` a `<h6>` facilmente, basta che inseria
 ```
 Markdown inoltre fornisce due alternative per indicare gli elementi h1 e h2
 
-```markdown
+```md
 Questo è un h1
 ==============
 
@@ -60,7 +60,7 @@ Questo è un h2
 ## Stili di testo semplici
 Il testo può essere stilizzato in corsivo o grassetto usando markdown
 
-```markdown
+```md
 *Questo testo è in corsivo.*
 _Come pure questo._
 
@@ -74,12 +74,12 @@ __Come pure questo.__
 
 In Github Flavored Markdown, che è utilizzato per renderizzare i file markdown su Github, è presente anche lo stile barrato:
 
-```markdown
+```md
 ~~Questo testo è barrato.~~
 ```
 ## Paragrafi
 
-```markdown
+```md
 I paragrafi sono una o più linee di testo adiacenti separate da una o più righe vuote.
 
 Questo è un paragrafo. Sto scrivendo in un paragrafo, non è divertente?
@@ -93,7 +93,7 @@ Qui siamo nel paragrafo 3!
 
 Se volete inserire l'elemento HTML `<br />`, potete terminare la linea con due o più spazi e poi iniziare un nuovo paragrafo.
 
-```markdown
+```md
 Questa frase finisce con due spazi (evidenziatemi per vederli).  
 
 C'è un <br /> sopra di me!
@@ -101,7 +101,7 @@ C'è un <br /> sopra di me!
 
 Le citazioni sono semplici da inserire, basta usare il carattere >.
 
-```markdown
+```md
 > Questa è una citazione. Potete
 > mandare a capo manualmente le linee e inserire un `>` prima di ognuna, oppure potete usare una sola linea e lasciare che vada a capo automaticamente.
 > Non c'è alcuna differenza, basta che iniziate ogni riga con `>`.
@@ -115,7 +115,7 @@ Le citazioni sono semplici da inserire, basta usare il carattere >.
 ## Liste
 Le liste non ordinate possono essere inserite usando gli asterischi, il simbolo più o dei trattini
 
-```markdown
+```md
 * Oggetto
 * Oggetto
 * Altro oggetto
@@ -135,7 +135,7 @@ oppure
 
 Le liste ordinate invece, sono inserite con un numero seguito da un punto.
 
-```markdown
+```md
 1. Primo oggetto
 2. Secondo oggetto
 3. Terzo oggetto
@@ -143,7 +143,7 @@ Le liste ordinate invece, sono inserite con un numero seguito da un punto.
 
 Non dovete nemmeno mettere i numeri nell'ordine giusto, markdown li visualizzerà comunque nell'ordine corretto, anche se potrebbe non essere una buona idea.
 
-```markdown
+```md
 1. Primo oggetto
 1. Secondo oggetto
 1. Terzo oggetto
@@ -152,7 +152,7 @@ Non dovete nemmeno mettere i numeri nell'ordine giusto, markdown li visualizzer�
 
 Potete inserire anche sotto liste
 
-```markdown
+```md
 1. Primo oggetto
 2. Secondo oggetto
 3. Terzo oggetto
@@ -163,7 +163,7 @@ Potete inserire anche sotto liste
 
 Sono presenti anche le task list. In questo modo è possibile creare checkbox in HTML.
 
-```markdown
+```md
 I box senza la 'x' sono checkbox HTML ancora da completare.
 - [ ] Primo task da completare.
 - [ ] Secondo task che deve essere completato.
@@ -174,14 +174,14 @@ Il box subito sotto è una checkbox HTML spuntata.
 
 Potete inserire un estratto di codice (che utilizza l'elemento `<code>`) indentando una linea con quattro spazi oppure con un carattere tab.
 
-```markdown
+```md
     Questa è una linea di codice
     Come questa
 ```
 
 Potete inoltre inserire un altro tab (o altri quattro spazi) per indentare il vostro codice
 
-```markdown
+```md
     my_array.each do |item|
         puts item
     end
@@ -189,7 +189,7 @@ Potete inoltre inserire un altro tab (o altri quattro spazi) per indentare il vo
 
 Codice inline può essere inserito usando il carattere backtick `
 
-```markdown
+```md
 Giovanni non sapeva neppure a cosa servisse la funzione `go_to()`!
 ```
 
@@ -205,7 +205,7 @@ Se usate questa sintassi, il testo non richiederà di essere indentato, inoltre
 ## Linea orizzontale
 Le linee orizzontali (`<hr/>`) sono inserite facilmente usanto tre o più asterischi o trattini, con o senza spazi. 
 
-```markdown
+```md
 ***
 ---
 - - -
@@ -215,24 +215,24 @@ Le linee orizzontali (`<hr/>`) sono inserite facilmente usanto tre o più asteri
 ## Links
 Una delle funzionalità migliori di markdown è la facilità con cui si possono inserire i link. Mettete il testo da visualizzare fra parentesi quadre [] seguite dall'url messo fra parentesi tonde ()
 
-```markdown
+```md
 [Cliccami!](http://test.com/)
 ```
 
 Potete inoltre aggiungere al link un titolo mettendolo fra doppi apici dopo il link
 
-```markdown
+```md
 [Cliccami!](http://test.com/ "Link a Test.com")
 ```
 
 La sintassi funziona anche con i path relativi.
 
-```markdown
+```md
 [Vai a musica](/music/).
 ```
 
 Markdown supporta inoltre anche la possibilità di aggiungere i link facendo riferimento ad altri punti del testo.
-```markdown
+```md
 [Apri questo link][link1] per più informazioni!
 [Guarda anche questo link][foobar] se ti va.
 
@@ -242,7 +242,7 @@ Markdown supporta inoltre anche la possibilità di aggiungere i link facendo rif
 l titolo può anche essere inserito in apici singoli o in parentesi, oppure omesso interamente. Il riferimento può essere inserito in un punto qualsiasi del vostro documento e l'identificativo del riferimento può essere lungo a piacere a patto che sia univoco.
 
 Esiste anche un "identificativo implicito" che vi permette di usare il testo del link come id.
-```markdown
+```md
 [Questo][] è un link.
 
 [Questo]: http://thisisalink.com/
@@ -252,13 +252,13 @@ Ma non è comunemente usato.
 ## Immagini
 Le immagini sono inserite come i link ma con un punto esclamativo inserito prima delle parentesi quadre!
 
-```markdown
+```md
 ![Qeusto è il testo alternativo per l'immagine](http://imgur.com/myimage.jpg "Il titolo opzionale")
 ```
 
 E la modalità a riferimento funziona esattamente come ci si aspetta
 
-```markdown
+```md
 ![Questo è il testo alternativo.][myimage]
 
 [myimage]: relative/urls/cool/image.jpg "Se vi serve un titolo, lo mettete qui"
@@ -266,25 +266,25 @@ E la modalità a riferimento funziona esattamente come ci si aspetta
 ## Miscellanea 
 ### Auto link
 
-```markdown
+```md
 <http://testwebsite.com/> è equivalente ad
 [http://testwebsite.com/](http://testwebsite.com/)
 ```
 ### Auto link per le email
 
-```markdown
+```md
 <foo@bar.com>
 ```
 ### Caratteri di escaping
 
-```markdown
+```md
 Voglio inserire *questo testo circondato da asterischi* ma non voglio che venga renderizzato in corsivo, quindi lo inserirò così: \*questo testo è circondato da asterischi\*.
 ```
 
 ### Combinazioni di tasti
 In Github Flavored Markdown, potete utilizzare il tag `<kbd>` per raffigurare i tasti della tastiera.
 
-```markdown
+```md
 Il tuo computer è crashato? Prova a premere
 <kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>Canc</kbd>
 ```
@@ -292,7 +292,7 @@ Il tuo computer è crashato? Prova a premere
 ### Tabelle
 Le tabelle sono disponibili solo in Github Flavored Markdown e sono leggeremente complesse, ma se proprio volete inserirle fate come segue:
 
-```markdown
+```md
 | Col1                 | Col2     | Col3               |
 | :------------------- | :------: | -----------------: |
 | Allineato a sinistra | Centrato | Allineato a destra |
@@ -300,7 +300,7 @@ Le tabelle sono disponibili solo in Github Flavored Markdown e sono leggeremente
 ```
 oppure, per lo stesso risultato
 
-```markdown
+```md
 Col 1 | Col2 | Col3
 :-- | :-: | --:
 È una cosa orrenda | fatela | finire in fretta
diff --git a/it-it/matlab-it.html.markdown b/it-it/matlab-it.html.markdown
index 8d6d4385..38be8848 100644
--- a/it-it/matlab-it.html.markdown
+++ b/it-it/matlab-it.html.markdown
@@ -199,8 +199,7 @@ size(A) % ans = 3 3
 A(1, :) =[] % Rimuove la prima riga della matrice
 A(:, 1) =[] % Rimuove la prima colonna della matrice
 
-transpose(A) % Traspone la matrice, equivale a:
-A one
+transpose(A) % Traspone la matrice, equivale a: A.'
 ctranspose(A) % Trasposizione hermitiana della matrice
 % (ovvero il complesso coniugato di ogni elemento della matrice trasposta)
 
diff --git a/it-it/pcre-it.html.markdown b/it-it/pcre-it.html.markdown
new file mode 100644
index 00000000..704392ef
--- /dev/null
+++ b/it-it/pcre-it.html.markdown
@@ -0,0 +1,85 @@
+---
+language: PCRE
+filename: pcre-it.txt
+contributors:
+    - ["Sachin Divekar", "http://github.com/ssd532"]
+translators:
+    - ["Christian Grasso", "https://grasso.io"]
+lang: it-it
+---
+
+Un'espressione regolare (regex o regexp in breve) è una speciale stringa
+utilizzata per definire un pattern, ad esempio per cercare una sequenza di
+caratteri; ad esempio, `/^[a-z]+:/` può essere usato per estrarre `http:`
+dall'URL `http://github.com/`.
+
+PCRE (Perl Compatible Regular Expressions) è una libreria per i regex in C.
+La sintassi utilizzata per le espressioni è molto simile a quella di Perl, da
+cui il nome. Si tratta di una delle sintassi più diffuse per la scrittura di
+regex.
+
+Esistono due tipi di metacaratteri (caratteri con una funzione speciale):
+
+* Caratteri riconosciuti ovunque tranne che nelle parentesi quadre
+
+```
+  \      carattere di escape
+  ^      cerca all'inizio della stringa (o della riga, in modalità multiline)
+  $      cerca alla fine della stringa (o della riga, in modalità multiline)
+  .      qualsiasi carattere eccetto le newline
+  [      inizio classe di caratteri
+  |      separatore condizioni alternative
+  (      inizio subpattern
+  )      fine subpattern
+  ?      quantificatore "0 o 1"
+  *      quantificatore "0 o più"
+  +      quantificatore "1 o più"
+  {      inizio quantificatore numerico
+```
+
+* Caratteri riconosciuti nelle parentesi quadre
+
+```
+  \      carattere di escape
+  ^      nega la classe se è il primo carattere
+  -      indica una serie di caratteri
+  [      classe caratteri POSIX (se seguita dalla sintassi POSIX)
+  ]      termina la classe caratteri
+```
+
+PCRE fornisce inoltre delle classi di caratteri predefinite:
+
+```
+  \d     cifra decimale
+  \D     NON cifra decimale
+  \h     spazio vuoto orizzontale
+  \H     NON spazio vuoto orizzontale
+  \s     spazio
+  \S     NON spazio
+  \v     spazio vuoto verticale
+  \V     NON spazio vuoto verticale
+  \w     parola
+  \W     "NON parola"
+```
+
+## Esempi
+
+Utilizzeremo la seguente stringa per i nostri test:
+
+```
+66.249.64.13 - - [18/Sep/2004:11:07:48 +1000] "GET /robots.txt HTTP/1.0" 200 468 "-" "Googlebot/2.1"
+```
+
+Si tratta di una riga di log del web server Apache.
+
+| Regex | Risultato          | Commento |
+| :---- | :-------------- | :------ |
+| `GET`   | GET | Cerca esattamente la stringa "GET" (case sensitive) |
+| `\d+.\d+.\d+.\d+` | 66.249.64.13 | `\d+` identifica uno o più (quantificatore `+`) numeri [0-9], `\.` identifica il carattere `.` |
+| `(\d+\.){3}\d+` | 66.249.64.13 | `(\d+\.){3}` cerca il gruppo (`\d+\.`) esattamente 3 volte. |
+| `\[.+\]` | [18/Sep/2004:11:07:48 +1000] | `.+` identifica qualsiasi carattere, eccetto le newline; `.` indica un carattere qualsiasi |
+| `^\S+` | 66.249.64.13 | `^` cerca all'inizio della stringa, `\S+` identifica la prima stringa di caratteri diversi dallo spazio |
+| `\+[0-9]+` | +1000 | `\+` identifica il carattere `+`. `[0-9]` indica una cifra da 0 a 9. L'espressione è equivalente a `\+\d+` |
+
+## Altre risorse
+[Regex101](https://regex101.com/) - tester per le espressioni regolari
diff --git a/it-it/pyqt-it.html.markdown b/it-it/pyqt-it.html.markdown
new file mode 100644
index 00000000..7238dd7b
--- /dev/null
+++ b/it-it/pyqt-it.html.markdown
@@ -0,0 +1,85 @@
+---
+category: tool
+tool: PyQT
+filename: learnpyqt-it.py
+contributors:
+    - ["Nathan Hughes", "https://github.com/sirsharpest"]
+translators:
+    - ["Ale46", "https://github.com/ale46"]
+lang: it-it
+---
+
+**Qt** è un framework ampiamente conosciuto per lo sviluppo di software multipiattaforma che può essere eseguito su varie piattaforme software e hardware con modifiche minime o nulle nel codice, pur avendo la potenza e la velocità delle applicazioni native. Sebbene **Qt** sia stato originariamente scritto in *C++*.
+
+
+Questo è un adattamento sull'introduzione di C ++ a QT di [Aleksey Kholovchuk] (https://github.com/vortexxx192
+), alcuni degli esempi di codice dovrebbero avere la stessa funzionalità
+che avrebbero se fossero fatte usando pyqt! 
+
+```python
+import sys
+from PyQt4 import QtGui
+	
+def window():
+	# Crea un oggetto applicazione
+    app = QtGui.QApplication(sys.argv)
+	# Crea un widget in cui verrà inserita la nostra etichetta
+    w = QtGui.QWidget()
+	# Aggiungi un'etichetta al widget
+    b = QtGui.QLabel(w)
+	# Imposta del testo per l'etichetta
+    b.setText("Ciao Mondo!")
+	# Fornisce informazioni su dimensioni e posizionamento
+    w.setGeometry(100, 100, 200, 50)
+    b.move(50, 20)
+	# Dai alla nostra finestra un bel titolo
+    w.setWindowTitle("PyQt")
+	# Visualizza tutto
+    w.show()
+	# Esegui ciò che abbiamo chiesto, una volta che tutto è stato configurato
+    sys.exit(app.exec_())
+
+if __name__ == '__main__':
+    window()
+
+```
+
+Per ottenere alcune delle funzionalità più avanzate in **pyqt**, dobbiamo iniziare a cercare di creare elementi aggiuntivi.
+Qui mostriamo come creare una finestra popup di dialogo, utile per chiedere all'utente di confermare una decisione o fornire informazioni
+
+```Python 
+import sys
+from PyQt4.QtGui import *
+from PyQt4.QtCore import *
+
+
+def window():
+    app = QApplication(sys.argv)
+    w = QWidget()
+    # Crea un pulsante e allegalo al widget w
+    b = QPushButton(w)
+    b.setText("Premimi")
+    b.move(50, 50)
+    # Indica a b di chiamare questa funzione quando si fa clic
+    # notare la mancanza di "()" sulla chiamata di funzione
+    b.clicked.connect(showdialog)
+    w.setWindowTitle("PyQt Dialog")
+    w.show()
+    sys.exit(app.exec_())
+	
+# Questa funzione dovrebbe creare una finestra di dialogo con un pulsante
+# che aspetta di essere cliccato e quindi esce dal programma
+def showdialog():
+    d = QDialog()
+    b1 = QPushButton("ok", d)
+    b1.move(50, 50)
+    d.setWindowTitle("Dialog")
+    # Questa modalità dice al popup di bloccare il genitore, mentre è attivo
+    d.setWindowModality(Qt.ApplicationModal)
+    # Al click vorrei che l'intero processo finisse
+    b1.clicked.connect(sys.exit)
+    d.exec_()
+
+if __name__ == '__main__':
+    window()
+```
diff --git a/it-it/python-it.html.markdown b/it-it/python-it.html.markdown
index e81d1676..794e7a70 100644
--- a/it-it/python-it.html.markdown
+++ b/it-it/python-it.html.markdown
@@ -640,7 +640,7 @@ i.age  # => Emette un AttributeError
 
 # Puoi importare moduli
 import math
-print math.sqrt(16)  # => 4
+print math.sqrt(16)  # => 4.0
 
 # Puoi ottenere specifiche funzione da un modulo
 from math import ceil, floor
diff --git a/it-it/python3-it.html.markdown b/it-it/python3-it.html.markdown
new file mode 100644
index 00000000..04f78cff
--- /dev/null
+++ b/it-it/python3-it.html.markdown
@@ -0,0 +1,1016 @@
+---
+language: python3
+filename: learnpython3-it.py
+contributors:
+    - ["Louie Dinh", "http://pythonpracticeprojects.com"]
+    - ["Steven Basart", "http://github.com/xksteven"]
+    - ["Andre Polykanine", "https://github.com/Oire"]
+    - ["Zachary Ferguson", "http://github.com/zfergus2"]
+    - ["evuez", "http://github.com/evuez"]
+    - ["Rommel Martinez", "https://ebzzry.io"]
+translators:
+    - ["Draio", "http://github.com/Draio/"]
+    - ["Ale46", "http://github.com/Ale46/"]
+    - ["Tommaso Pifferi", "http://github.com/neslinesli93/"]
+lang: it-it    
+---
+
+Python è stato creato da Guido Van Rossum agli inizi degli anni 90. Oggi è uno dei più popolari linguaggi esistenti. Mi sono innamorato di Python per la sua chiarezza sintattica. E' sostanzialmente pseudocodice eseguibile.
+
+Feedback sono altamente apprezzati! Potete contattarmi su [@louiedinh](http://twitter.com/louiedinh) oppure [at] [google's email service]
+
+Nota: Questo articolo è riferito a Python 3 in modo specifico. Se volete avete la necessità di utilizzare Python 2.7 potete consultarla [qui](https://learnxinyminutes.com/docs/it-it/python-it/)
+
+```python
+
+# I commenti su una sola linea iniziano con un cancelletto
+
+
+""" Più stringhe possono essere scritte
+    usando tre ", e sono spesso usate
+    come documentazione
+"""
+
+####################################################
+## 1. Tipi di dati primitivi ed Operatori
+####################################################
+
+# Ci sono i numeri
+3  # => 3
+
+# La matematica è quello che vi aspettereste
+1 + 1   # => 2
+8 - 1   # => 7
+10 * 2  # => 20
+35 / 5  # => 7.0
+
+# Risultato della divisione intera troncata sia in positivo che in negativo
+5 // 3       # => 1
+5.0 // 3.0   # => 1.0 # works on floats too
+-5 // 3      # => -2
+-5.0 // 3.0  # => -2.0
+
+# Il risultato di una divisione è sempre un numero decimale (float)
+10.0 / 3  # => 3.3333333333333335
+
+# Operazione Modulo
+7 % 3  # => 1
+
+# Elevamento a potenza (x alla y-esima potenza)
+2**3  # => 8
+
+# Forzare le precedenze con le parentesi
+(1 + 3) * 2  # => 8
+
+# I valori booleani sono primitive del linguaggio (nota la maiuscola)
+True
+False
+
+# nega con not
+not True   # => False
+not False  # => True
+
+# Operatori Booleani
+# Nota "and" e "or" sono case-sensitive
+True and False  # => False
+False or True   # => True
+
+# Note sull'uso di operatori Bool con interi
+# False è 0 e True è 1
+# Non confonderti tra bool(ints) e le operazioni bitwise and/or (&,|)
+0 and 2     # => 0
+-5 or 0     # => -5
+0 == False  # => True
+2 == True   # => False
+1 == True   # => True
+-5 != False != True #=> True
+
+# Uguaglianza è ==
+1 == 1  # => True
+2 == 1  # => False
+
+# Disuguaglianza è !=
+1 != 1  # => False
+2 != 1  # => True
+
+# Altri confronti
+1 < 10  # => True
+1 > 10  # => False
+2 <= 2  # => True
+2 >= 2  # => True
+
+# I confronti possono essere concatenati!
+1 < 2 < 3  # => True
+2 < 3 < 2  # => False
+
+# ('is' vs. '==') 
+# 'is' controlla se due variabili si riferiscono allo stesso oggetto
+# '==' controlla se gli oggetti puntati hanno lo stesso valore.
+a = [1, 2, 3, 4]  # a punta ad una nuova lista [1, 2, 3, 4]
+b = a             # b punta a ciò a cui punta a
+b is a            # => True, a e b puntano allo stesso oggeto
+b == a            # => True, gli oggetti di a e b sono uguali
+b = [1, 2, 3, 4]  # b punta ad una nuova lista  [1, 2, 3, 4]
+b is a            # => False, a e b non puntano allo stesso oggetto
+b == a            # => True, gli oggetti di a e b sono uguali
+
+# Le stringhe sono create con " o '
+"Questa è una stringa."
+'Anche questa è una stringa.'
+
+# Anche le stringhe possono essere sommate! Ma cerca di non farlo.
+"Hello " + "world!"  # => "Hello world!"
+# Le stringhe (ma non le variabili contenenti stringhe) possono essere 
+# sommate anche senza '+'
+"Hello " "world!"    # => "Hello world!"
+
+# Una stringa può essere considerata come una lista di caratteri
+"Questa è una stringa"[0]  # => 'Q'
+
+# Puoi conoscere la lunghezza di una stringa
+len("Questa è una stringa")  # => 20
+
+# .format può essere usato per formattare le stringhe, in questo modo:
+"{} possono essere {}".format("Le stringhe", "interpolate")  # => "Le stringhe possono essere interpolate"
+
+# Puoi ripetere gli argomenti di formattazione per risparmiare un po' di codice
+"{0} be nimble, {0} be quick, {0} jump over the {1}".format("Jack", "candle stick")
+# => "Jack be nimble, Jack be quick, Jack jump over the candle stick"
+
+# Puoi usare dei nomi se non vuoi contare gli argomenti
+"{nome} vuole mangiare {cibo}".format(nome="Bob", cibo="le lasagne")  # => "Bob vuole mangiare le lasagne"
+
+# Se il tuo codice Python 3 necessita di eseguire codice Python 2.x puoi ancora
+# utilizzare il vecchio stile di formattazione:
+"%s possono essere %s nel %s modo" % ("Le stringhe", "interpolate", "vecchio")  # => "Le stringhe possono essere interpolate nel vecchio modo"
+
+# None è un oggetto
+None  # => None
+
+# Non usare il simbolo di uguaglianza "==" per comparare oggetti a None
+# Usa "is" invece
+"etc" is None  # => False
+None is None   # => True
+
+# None, 0, e stringhe/liste/dizionari/tuple vuoti vengono considerati
+# falsi (False). Tutti gli altri valori sono considerati veri (True).
+bool(0)   # => False
+bool("")  # => False
+bool([])  # => False
+bool({})  # => False
+bool(())  # => False
+
+####################################################
+## 2. Variabili e Collections
+####################################################
+
+# Python ha una funzione per scrivere (sul tuo schermo)
+print("Sono Python. Piacere di conoscerti!")  # => Sono Python. Piacere di conoscerti!
+
+# Di default la funzione print() scrive e va a capo aggiungendo un carattere 
+# newline alla fine della stringa. È possibile utilizzare l'argomento opzionale
+# end per cambiare quest'ultimo carattere aggiunto.
+print("Hello, World", end="!")  # => Hello, World!
+
+# Un modo semplice per ricevere dati in input dalla riga di comando
+variabile_stringa_input  = input("Inserisci del testo: ") # Restituisce i dati letti come stringa
+# Nota: Nelle precedenti vesioni di Python, il metodo input() 
+# era chiamato raw_input()
+
+# Non c'è bisogno di dichiarare una variabile per assegnarle un valore
+# Come convenzione, per i nomi delle variabili, si utilizzano i caratteri 
+# minuscoli separati, se necessario, da underscore
+some_var = 5
+some_var          # => 5
+
+# Accedendo ad una variabile non precedentemente assegnata genera un'eccezione.
+# Dai un'occhiata al Control Flow per imparare di più su come gestire 
+# le eccezioni.
+some_unknown_var  # Genera un errore di nome
+
+# if può essere usato come un'espressione
+# È l'equivalente dell'operatore ternario in C
+"yahoo!" if 3 > 2 else 2  # => "yahoo!"
+
+# Le liste immagazzinano sequenze
+li = []
+# Puoi partire con una lista pre-riempita
+other_li = [4, 5, 6]
+
+# Aggiungere alla fine di una lista con append
+li.append(1)    # li ora è [1]
+li.append(2)    # li ora è [1, 2]
+li.append(4)    # li ora è [1, 2, 4]
+li.append(3)    # li ora è [1, 2, 4, 3]
+# Rimuovi dalla fine della lista con pop
+li.pop()        # => 3 e li ora è [1, 2, 4]
+# Rimettiamolo a posto
+li.append(3)    # li ora è [1, 2, 4, 3] di nuovo.
+
+# Accedi ad una lista come faresti con un array
+li[0]  # => 1
+# Guarda l'ultimo elemento
+li[-1]  # => 3
+
+# Guardare al di fuori dei limiti genera un IndexError
+li[4]  # Genera IndexError
+
+# Puoi guardare gli intervalli con la sintassi slice (a fetta).
+# (E' un intervallo chiuso/aperto per voi tipi matematici.)
+li[1:3]  # => [2, 4]
+# Ometti l'inizio
+li[2:]  # => [4, 3]
+# Ometti la fine
+li[:3]  # => [1, 2, 4]
+# Seleziona ogni seconda voce
+li[::2]   # =>[1, 4]
+# Copia al contrario della lista
+li[::-1]   # => [3, 4, 2, 1]
+# Usa combinazioni per fare slices avanzate
+# li[inizio:fine:passo]
+
+# Crea una copia (one layer deep copy) usando la sintassi slices
+li2 = li[:]  # => li2 = [1, 2, 4, 3] ma (li2 is li) risulterà falso.
+
+# Rimuovi arbitrariamente elementi da una lista con "del"
+del li[2]   # li è ora [1, 2, 3]
+
+# Rimuove la prima occorrenza di un elemento
+li.remove(2)  # Ora li è [1, 3, 4, 5, 6]
+li.remove(2)  # Emette un ValueError, poichè 2 non è contenuto nella lista
+
+# Inserisce un elemento all'indice specificato
+li.insert(1, 2)  # li è di nuovo [1, 2, 3, 4, 5, 6]
+
+ Ritorna l'indice della prima occorrenza dell'elemento fornito
+li.index(2)  # => 1
+li.index(7)  # Emette un ValueError, poichè 7 non è contenuto nella lista
+
+# Puoi sommare le liste
+# Nota: i valori per li e per other_li non vengono modificati.
+li + other_li  # => [1, 2, 3, 4, 5, 6]
+
+# Concatena le liste con "extend()"
+li.extend(other_li)  # Adesso li è [1, 2, 3, 4, 5, 6]
+
+# Controlla l'esistenza di un valore in una lista con "in"
+1 in li   # => True
+
+# Esamina la lunghezza con "len()"
+len(li)   # => 6
+
+
+# Le tuple sono come le liste ma immutabili.
+tup = (1, 2, 3)
+tup[0]      # => 1
+tup[0] = 3  # Genera un TypeError
+
+# Note that a tuple of length one has to have a comma after the last element but
+# tuples of other lengths, even zero, do not.
+type((1))   # => <class 'int'>
+type((1,))  # => <class 'tuple'>
+type(())    # => <class 'tuple'>
+
+# Puoi fare tutte queste cose da lista anche sulle tuple
+len(tup)         # => 3
+tup + (4, 5, 6)  # => (1, 2, 3, 4, 5, 6)
+tup[:2]          # => (1, 2)
+2 in tup         # => True
+
+# Puoi scompattare le tuple (o liste) in variabili
+a, b, c = (1, 2, 3)     # a è ora 1, b è ora 2 e c è ora 3
+d, e, f = 4, 5, 6       # puoi anche omettere le parentesi
+# Le tuple sono create di default se non usi le parentesi
+g = 4, 5, 6             # => (4, 5, 6)
+# Guarda come è facile scambiare due valori
+e, d = d, e             # d è ora 5 ed e è ora 4
+
+# I dizionari memorizzano insiemi di dati indicizzati da nomi arbitrari (chiavi)
+empty_dict= {}
+# Questo è un dizionario pre-caricato
+filled_dict = {"uno": 1, "due": 2, "tre": 3}
+
+# Nota: le chiavi  dei dizionari devono essere di tipo immutabile. Questo per
+# assicurare che le chiavi possano essere convertite in calori hash costanti 
+# per un risposta più veloce.
+invalid_dict = {[1,2,3]: "123"}  # => Emette un TypeError: unhashable type: 'list'
+valid_dict = {(1,2,3):[1,2,3]}   # I valori, invece, possono essere di qualunque tipo
+
+# Accedi ai valori indicando la chiave tra []
+filled_dict["uno"]   # => 1
+
+# Puoi ottenere tutte le chiavi di un dizionario con "keys()" 
+# (come oggetto iterabile). Per averle in formato lista è necessario 
+# utilizzare list().
+# Nota - Nei dizionari l'ordine delle chiavi non è garantito.
+# Il tuo risultato potrebbe non essere uguale a questo.
+list(filled_dict.keys())  # => ["tre", "due", "uno"]
+
+
+# Puoi ottenere tutti i valori di un dizionario con "values()" 
+# (come oggetto iterabile). 
+# Anche in questo caso, er averle in formato lista, è necessario utilizzare list()
+# Anche in questo caso, come per le chiavi, l'ordine non è garantito
+list(filled_dict.values())  # => [3, 2, 1]
+
+# Controlla l'esistenza delle chiavi in un dizionario con "in"
+"uno" in filled_dict   # => True
+1 in filled_dict       # => False
+
+# Cercando una chiave non esistente genera un KeyError
+filled_dict["quattro"]   # KeyError
+
+# Usa il metodo "get()" per evitare KeyError
+filled_dict.get("uno")      # => 1
+filled_dict.get("quattro")  # => None
+# Il metodo get supporta un argomento di default quando il valore è mancante
+filled_dict.get("uno", 4)   # => 1
+filled_dict.get("quattro", 4)   # => 4
+
+
+# "setdefault()" inserisce un valore per una chiave in un dizionario 
+# solo se la chiave data non è già presente
+filled_dict.setdefault("cinque", 5)  # filled_dict["cinque"] viene impostato a 5
+filled_dict.setdefault("cinque", 6)  # filled_dict["cinque"] rimane 5
+
+# Aggiungere una coppia chiave->valore a un dizionario
+filled_dict.update({"quattro":4})  # => {"uno": 1, "due": 2, "tre": 3, "quattro": 4}
+filled_dict["quattro"] = 4         # un altro modo pe aggiungere a un dizionario
+
+# Rimuovi una chiave da un dizionario con del
+del filled_dict["uno"]  # Rimuove la chiave "uno" dal dizionario
+
+# Da Python 3.5 puoi anche usare ulteriori opzioni di spacchettamento
+{'a': 1, **{'b': 2}}  # => {'a': 1, 'b': 2}
+{'a': 1, **{'a': 2}}  # => {'a': 2}
+
+# I set sono come le liste ma non possono contenere doppioni
+empty_set = set()
+# Inizializza un "set()" con un dei valori. Sì, sembra un dizionario.
+some_set = {1, 1, 2, 2, 3, 4}  # set_nuovo è {1, 2, 3, 4}
+
+# Come le chiavi di un dizionario, gli elementi di un set devono essere 
+# di tipo immutabile
+invalid_set = {[1], 1}  # => Genera un "TypeError: unhashable type: 'list'""
+valid_set = {(1,), 1}
+
+# Aggiungere uno o più elementi ad un set
+some_set.add(5)  # some_set ora è  {1, 2, 3, 4, 5}
+
+# Fai intersezioni su un set con &
+other_set = {3, 4, 5, 6}
+some_set & other_set  # => {3, 4, 5}
+
+# Fai unioni su set con |
+some_set | other_set  # => {1, 2, 3, 4, 5, 6}
+
+# Fai differenze su set con -
+{1, 2, 3, 4} - {2, 3, 5}  # => {1, 4}
+
+# Effettua la differenza simmetrica con ^
+{1, 2, 3, 4} ^ {2, 3, 5}  # => {1, 4, 5}
+
+# Controlla se il set a sinistra contiene quello a destra
+{1, 2} >= {1, 2, 3} # => False
+
+# Controlla se il set a sinistra è un sottoinsieme di quello a destra
+{1, 2} <= {1, 2, 3} # => True
+
+# Controlla l'esistenza in un set con in
+2 in some_set   # => True
+10 in some_set  # => False
+
+
+
+####################################################
+## 3. Control Flow e oggetti Iterabili
+####################################################
+
+# Dichiariamo  una variabile
+some_var = 5
+
+# Questo è un controllo if. L'indentazione è molto importante in python!
+# Come convenzione si utilizzano quattro spazi, non la tabulazione.
+# Il seguente codice stampa "some_var è minore di 10"
+if some_var > 10:
+    print("some_var è maggiore di 10")
+elif some_var < 10:    # La clausolo elif è opzionale
+    print("some_var è minore di 10")
+else:                  # Anche else è opzionale
+    print("some_var è  10.")
+
+"""
+I cicli for iterano sulle liste, cioè ripetono un codice per ogni elemento 
+di una lista.
+Il seguente codice scriverà:
+    cane è un mammifero
+    gatto è un mammifero
+    topo è un mammifero
+"""
+for animale in ["cane", "gatto", "topo"]:
+    # Puoi usare format() per interpolare le stringhe formattate.
+    print("{} è un mammifero".format(animale))
+
+"""
+"range(numero)" restituisce una lista di numeri da zero al numero dato
+Il seguente codice scriverà:
+    0
+    1
+    2
+    3
+"""
+for i in range(4):
+    print(i)
+
+"""
+"range(lower, upper)" restituisce una lista di numeri dal più piccolo (lower)
+al più grande (upper).
+Il seguente codice scriverà:
+    4
+    5
+    6
+    7
+"""
+for i in range(4, 8):
+    print(i)
+
+"""
+"range(lower, upper, step)" rrestituisce una lista di numeri dal più piccolo 
+(lower) al più grande (upper), incrementando del valore step.
+Se step non è indicato, avrà come valore di default 1.
+Il seguente codice scriverà:
+    4
+    6
+"""
+for i in range(4, 8, 2):
+    print(i)
+"""
+
+I cicli while vengono eseguiti finchè una condizione viene a mancare
+Il seguente codice scriverà:
+    0
+    1
+    2
+    3
+"""
+x = 0
+while x < 4:
+    print(x)
+    x += 1  # Forma compatta per x = x + 1
+
+# Gestione delle eccezioni con un blocco try/except
+try:
+    # Usa "raise" per generare un errore
+    raise IndexError("Questo è un IndexError")
+except IndexError as e:
+    pass    # Pass è solo una non-operazione. Solitamente vorrai rimediare all'errore.
+except (TypeError, NameError):
+    pass    # Eccezioni multiple possono essere gestite tutte insieme, se necessario.
+else:   # Clausola opzionale al blocco try/except. Deve essere dopo tutti i blocchi except
+    print("Tutto ok!")   # Viene eseguita solo se il codice dentro try non genera eccezioni
+finally: #  Eseguito sempre
+    print("Possiamo liberare risorse qui")
+
+# Se ti serve solo un try/finally, per liberare risorse, puoi usare il metodo with
+with open("myfile.txt") as f:
+    for line in f:
+        print(line)
+
+# In Python qualunque oggetto in grado di essere trattato come una 
+# sequenza è definito un oggetto Iterable (itarabile).
+# L'oggetto restituito da una funzione range è un iterabile.
+
+filled_dict = {"uno": 1, "due": 2, "tre": 3}
+our_iterable = filled_dict.keys()
+print(our_iterable)  # => dict_keys(['uno', 'due', 'tre']). 
+# Questo è un oggetto che implementa la nostra interfaccia Iterable.
+
+# È possibile utilizzarlo con i loop:
+for i in our_iterable:
+    print(i)  # Scrive uno, due, tre
+
+# Tuttavia non possiamo recuperarne i valori tramite indice.
+our_iterable[1]  # Genera un TypeError
+
+# Un oggetto iterabile è in grado di generare un iteratore
+our_iterator = iter(our_iterable)
+
+# L'iteratore è un oggetto che ricorda il suo stato mentro lo si "attraversa"
+# Possiamo accedere al successivo elemento con "next()".
+next(our_iterator)  # => "uno"
+
+# Mantiene il suo stato mentro eseguiamo l'iterazione
+next(our_iterator)  # => "due"
+next(our_iterator)  # => "tre"
+
+# Dopo che un iteratore ha restituito tutti i suoi dati, genera 
+# un'eccezione StopIteration 
+next(our_iterator)  # Raises StopIteration
+
+# Puoi prendere tutti gli elementi di un iteratore utilizzando list().
+list(filled_dict.keys())  # => Returns ["one", "two", "three"]
+
+
+
+####################################################
+## 4. Funzioni
+####################################################
+
+# Usa "def" per creare nuove funzioni
+def aggiungi(x, y):
+    print("x è {} e y è {}".format(x, y)) // Scrive i valori formattati in una stringa
+    return x + y  # Restituisce la somma dei valori con il metodo return
+
+# Chiamare funzioni con parametri
+aggiungi(5, 6)  # => scrive "x è 5 e y è 6" e restituisce 11
+
+# Un altro modo per chiamare funzioni  è con parole chiave come argomenti
+aggiungi(y=6, x=5)  # In questo modo non è necessario rispettare l'ordine degli argomenti
+
+# Puoi definire funzioni che accettano un numero non definito di argomenti
+def varargs(*args):
+    return args
+
+varargs(1, 2, 3)  # => (1, 2, 3)
+
+# Puoi definire funzioni che accettano un numero variabile di parole chiave
+# come argomento, che saranno interpretati come un dizionario usando **
+def keyword_args(**kwargs):
+    return kwargs
+
+# Chiamiamola per vedere cosa succede
+keyword_args(big="foot", loch="ness")   # => {"big": "foot", "loch": "ness"}
+
+
+# Puoi farle entrambi in una volta, se ti va
+def all_the_args(*args, **kwargs):
+    print(args)
+    print(kwargs)
+"""
+all_the_args(1, 2, a=3, b=4) stampa:
+    (1, 2)
+    {"a": 3, "b": 4}
+"""
+
+# Quando chiami funzioni, puoi fare l'opposto di args/kwargs!
+# Usa * per sviluppare gli argomenti posizionale ed usa ** per 
+# espandere gli argomenti parola chiave
+args = (1, 2, 3, 4)
+kwargs = {"a": 3, "b": 4}
+all_the_args(*args)            # equivalente a foo(1, 2, 3, 4)
+all_the_args(**kwargs)         # equivalente a foo(a=3, b=4)
+all_the_args(*args, **kwargs)  # equivalente a foo(1, 2, 3, 4, a=3, b=4)
+
+
+# Restituire valori multipli (with tuple assignments)
+def swap(x, y):
+    return y, x  # Restituisce valori multipli come tupla senza parentesi
+                 # (Nota: le parentesi sono state escluse ma possono essere messe)
+
+x = 1
+y = 2
+x, y = swap(x, y)     # => x = 2, y = 1
+# (x, y) = swap(x,y)  # Le parentesi sono state escluse ma possono essere incluse.
+
+# Funzioni - Visibilità delle variabili (variable scope)
+x = 5
+
+def set_x(num):
+    # La variabile locale x non è la variabile globale x
+    x = num    # => 43
+    print(x)   # => 43
+
+def set_global_x(num):
+    global x
+    print(x)   # => 5
+    x = num    # la variabile globable x è ora 6
+    print(x)   # => 6
+
+set_x(43)
+set_global_x(6)
+
+
+# Python ha "first class functions"
+def create_adder(x):
+    def adder(y):
+        return x + y
+    return adder
+
+add_10 = create_adder(10)
+add_10(3)   # => 13
+
+# Ci sono anche funzioni anonime
+(lambda x: x > 2)(3)                  # => True
+(lambda x, y: x ** 2 + y ** 2)(2, 1)  # => 5
+
+# È possibile creare "mappe" e "filtri"
+list(map(add_10, [1, 2, 3]))          # => [11, 12, 13]
+list(map(max, [1, 2, 3], [4, 2, 1]))  # => [4, 2, 3]
+
+list(filter(lambda x: x > 5, [3, 4, 5, 6, 7]))  # => [6, 7]
+
+# Possiamo usare le "list comprehensions" per mappe e filtri
+# Le "list comprehensions" memorizzano l'output come una lista che può essere 
+# di per sé una lista annidata
+[add_10(i) for i in [1, 2, 3]]         # => [11, 12, 13]
+[x for x in [3, 4, 5, 6, 7] if x > 5]  # => [6, 7]
+
+# Puoi fare anche la comprensione di set e dizionari
+{x for x in 'abcddeef' if x not in 'abc'}  # => {'d', 'e', 'f'}
+{x: x**2 for x in range(5)}  # => {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
+
+
+####################################################
+## 5. Modules
+####################################################
+
+# Puoi importare moduli
+import math
+print(math.sqrt(16))  # => 4.0
+
+# Puoi ottenere specifiche funzione da un modulo
+from math import ceil, floor
+print(ceil(3.7))   # => 4.0
+print(floor(3.7))  # => 3.0
+
+# Puoi importare tutte le funzioni da un modulo
+# Attenzione: questo non è raccomandato
+from math import *
+
+# Puoi abbreviare i nomi dei moduli
+import math as m
+math.sqrt(16) == m.sqrt(16)  # => True
+
+
+# I moduli di Python sono normali file python. Ne puoi
+# scrivere di tuoi ed importarli. Il nome del modulo
+# è lo stesso del nome del file.
+
+# Potete scoprire quali funzioni e attributi
+# sono definiti in un modulo
+import math
+dir(math)
+
+# Se nella cartella corrente hai uno script chiamato math.py,
+# Python caricherà quello invece del modulo math.
+# Questo succede perchè la cartella corrente ha priorità
+# sulle librerie standard di Python
+
+# Se hai uno script Python chiamato math.py nella stessa 
+# cartella del tua script, Python caricherà quello al posto del
+# comune modulo math.
+# Questo accade perché la cartella locale ha la priorità
+# sulle librerie built-in di Python.
+
+
+####################################################
+## 6. Classes
+####################################################
+
+# Usiamo l'istruzione "class" per creare una classe
+class Human:
+
+    # Un attributo della classe. E' condiviso tra tutte le istanze delle classe
+    species = "H. sapiens"
+
+    # Si noti che i doppi underscore iniziali e finali denotano gli oggetti o
+    # attributi utilizzati da Python ma che vivono nel namespace controllato 
+    # dall'utente
+    # Metodi, oggetti o attributi come: __init__, __str__, __repr__, etc. sono
+    # chiamati metodi speciali (o talvolta chiamati "dunder methods").
+    # Non dovresti inventare tali nomi da solo.
+
+    def __init__(self, name):
+        # Assegna l'argomento all'attributo name dell'istanza
+        self.name = name
+
+        # Inizializza una proprietà
+        self._age = 0
+
+    # Un metodo dell'istanza. Tutti i metodi prendo "self" come primo argomento
+    def say(self, msg):
+        print("{name}: {message}".format(name=self.name, message=msg))
+
+    # Un altro metodo dell'istanza
+    def sing(self):
+        return 'yo... yo... microphone check... one two... one two...'
+
+    # Un metodo della classe è condiviso fra tutte le istanze
+    # Sono chiamati con la classe chiamante come primo argomento
+    @classmethod
+    def get_species(cls):
+        return cls.species
+
+    # Un metodo statico è chiamato senza classe o istanza di riferimento
+    @staticmethod
+    def grunt():
+        return "*grunt*"
+
+    # Una property è come un metodo getter.
+    # Trasforma il metodo age() in un attributo in sola lettura, che ha 
+    # lo stesso nome 
+    # In Python non c'è bisogno di scrivere futili getter e setter.
+    @property
+    def age(self):
+        return self._age
+
+    # Questo metodo permette di modificare una property
+    @age.setter
+    def age(self, age):
+        self._age = age
+
+    # Questo metodo permette di cancellare una property
+    @age.deleter
+    def age(self):
+        del self._age
+
+# Quando l'interprete Python legge un sorgente esegue tutto il suo codice.
+# Questo controllo su __name__ assicura che questo blocco di codice venga 
+# eseguito solo quando questo modulo è il programma principale.
+
+if __name__ == '__main__':
+    # Crea un'istanza della classe
+    i = Human(name="Ian")
+    i.say("hi")                     # "Ian: hi"
+    j = Human("Joel")
+    j.say("hello")                  # "Joel: hello"
+    # i e j sono istanze del tipo Human, o in altre parole sono oggetti Human
+
+    # Chiama un metodo della classe
+    i.say(i.get_species())          # "Ian: H. sapiens"
+    # Cambia l'attributo condiviso
+    Human.species = "H. neanderthalensis"
+    i.say(i.get_species())          # => "Ian: H. neanderthalensis"
+    j.say(j.get_species())          # => "Joel: H. neanderthalensis"
+
+    # Chiama un metodo statico 
+    print(Human.grunt())            # => "*grunt*"
+    
+    # Non è possibile chiamare il metodo statico con l'istanza dell'oggetto
+    # poiché i.grunt() metterà automaticamente "self" (l'oggetto i) 
+    # come argomento 
+    print(i.grunt())                # => TypeError: grunt() takes 0 positional arguments but 1 was given
+                                    
+    # Aggiorna la property (age) di questa istanza
+    i.age = 42
+    # Leggi la property
+    i.say(i.age)                    # => "Ian: 42"
+    j.say(j.age)                    # => "Joel: 0"
+    # Cancella la property
+    del i.age
+    i.age                           # => questo genererà un AttributeError
+
+
+####################################################
+## 6.1 Ereditarietà  (Inheritance)
+####################################################
+
+# L'ereditarietà consente di definire nuove classi figlio che ereditano metodi e
+# variabili dalla loro classe genitore.
+
+# Usando la classe Human definita sopra come classe base o genitore, possiamo
+# definire una classe figlia, Superhero, che erediterà le variabili di classe
+# come "species", "name" e "age", così come i metodi, come "sing" e "grunt",
+# dalla classe Human, ma potrà anche avere le sue proprietà uniche.
+
+# Per importare le funzioni da altri file usa il seguente formato 
+# from "nomefile-senza-estensione" import "funzione-o-classe"
+
+from human import Human
+
+# Specificare le classi genitore come parametri della definizione della classe
+class Superhero(Human):
+
+    # Se la classe figlio deve ereditare tutte le definizioni del genitore  
+    # senza alcuna modifica, puoi semplicemente usare la parola chiave "pass"
+    # (e nient'altro)
+
+    #Le classi figlio possono sovrascrivere gli attributi dei loro genitori
+    species = 'Superhuman'
+
+    # Le classi figlie ereditano automaticamente il costruttore della classe 
+    # genitore, inclusi i suoi argomenti, ma possono anche definire ulteriori 
+    # argomenti o definizioni e sovrascrivere i suoi metodi (compreso  il 
+    # costruttore della classe).
+    # Questo costruttore eredita l'argomento "nome" dalla classe "Human" e 
+    # aggiunge gli argomenti "superpowers" e "movie":
+
+    def __init__(self, name, movie=False,
+                 superpowers=["super strength", "bulletproofing"]):
+
+        # aggiungi ulteriori attributi della classe
+        self.fictional = True
+        self.movie = movie
+        self.superpowers = superpowers
+
+        # La funzione "super" ti consente di accedere ai metodi della classe 
+        # genitore che sono stati sovrascritti dalla classe figlia,  
+        # in questo caso il metodo __init__.
+        # Il seguente codice esegue il costruttore della classe genitore:
+        super().__init__(name)
+
+    # Sovrascrivere il metodo "sing"
+    def sing(self):
+        return 'Dun, dun, DUN!'
+
+    # Aggiungi un ulteriore metodo dell'istanza
+    def boast(self):
+        for power in self.superpowers:
+            print("I wield the power of {pow}!".format(pow=power))
+
+
+if __name__ == '__main__':
+    sup = Superhero(name="Tick")
+
+    # Controllo del tipo di istanza
+    if isinstance(sup, Human):
+        print('I am human')
+    if type(sup) is Superhero:
+        print('I am a superhero')
+
+    # Ottieni il "Method Resolution search Order" usato sia da getattr () 
+    # che da super (). Questo attributo è dinamico e può essere aggiornato
+    print(Superhero.__mro__)    # => (<class '__main__.Superhero'>,
+                                # => <class 'human.Human'>, <class 'object'>)
+
+    # Esegui il metodo principale ma utilizza il proprio attributo di classe
+    print(sup.get_species())    # => Superhuman
+
+    # Esegui un metodo che è stato sovrascritto
+    print(sup.sing())           # => Dun, dun, DUN!
+
+    # Esegui un metodo di Human
+    sup.say('Spoon')            # => Tick: Spoon
+
+    # Esegui un metodo che esiste solo in Superhero
+    sup.boast()                 # => I wield the power of super strength!
+                                # => I wield the power of bulletproofing!
+
+    # Attributo di classe ereditato
+    sup.age = 31
+    print(sup.age)              # => 31
+
+    # Attributo che esiste solo in Superhero
+    print('Am I Oscar eligible? ' + str(sup.movie))
+
+####################################################
+## 6.2 Ereditarietà multipla
+####################################################
+
+# Un'altra definizione di classe
+# bat.py
+class Bat:
+
+    species = 'Baty'
+
+    def __init__(self, can_fly=True):
+        self.fly = can_fly
+
+    # Questa classe ha anche un metodo "say"
+    def say(self, msg):
+        msg = '... ... ...'
+        return msg
+
+    # E anche un suo metodo personale
+    def sonar(self):
+        return '))) ... ((('
+
+if __name__ == '__main__':
+    b = Bat()
+    print(b.say('hello'))
+    print(b.fly)
+
+# Definizione di classe che eredita da Superhero e Bat
+# superhero.py
+from superhero import Superhero
+from bat import Bat
+
+# Definisci Batman come classe figlia che eredita sia da Superhero che da Bat
+class Batman(Superhero, Bat):
+
+    def __init__(self, *args, **kwargs):
+        # In genere per ereditare gli attributi devi chiamare super:
+        # super(Batman, self).__init__(*args, **kwargs)
+        # Ma qui abbiamo a che fare con l'ereditarietà multipla, e super() 
+        # funziona solo con la successiva classe nell'elenco MRO.
+        # Quindi, invece, chiamiamo esplicitamente __init__ per tutti gli
+        # antenati. L'uso di *args e **kwargs consente di passare in modo 
+        # pulito gli argomenti, con ciascun genitore che "sbuccia un 
+        # livello della cipolla".    
+        Superhero.__init__(self, 'anonymous', movie=True, 
+                           superpowers=['Wealthy'], *args, **kwargs)
+        Bat.__init__(self, *args, can_fly=False, **kwargs)
+        # sovrascrivere il valore per l'attributo name
+        self.name = 'Sad Affleck'
+
+    def sing(self):
+        return 'nan nan nan nan nan batman!'
+
+
+if __name__ == '__main__':
+    sup = Batman()
+
+    # Ottieni il "Method Resolution search Order" utilizzato da getattr() e super().
+    # Questo attributo è dinamico e può essere aggiornato
+    print(Batman.__mro__)       # => (<class '__main__.Batman'>, 
+                                # => <class 'superhero.Superhero'>, 
+                                # => <class 'human.Human'>, 
+                                # => <class 'bat.Bat'>, <class 'object'>)
+
+    # Esegui il metodo del genitore ma utilizza il proprio attributo di classe
+    print(sup.get_species())    # => Superhuman
+
+    # Esegui un metodo che è stato sovrascritto
+    print(sup.sing())           # => nan nan nan nan nan batman!
+
+    # Esegui un metodo da Human, perché l'ordine di ereditarietà è importante 
+    sup.say('I agree')          # => Sad Affleck: I agree
+
+    # Esegui un metodo che esiste solo nel 2o antenato
+    print(sup.sonar())          # => ))) ... (((
+
+    # Attributo di classe ereditato
+    sup.age = 100
+    print(sup.age)              # => 100
+
+    # Attributo ereditato dal secondo antenato il cui valore predefinito
+    # è stato ignorato.
+    print('Can I fly? ' + str(sup.fly)) # => Can I fly? False
+
+
+
+####################################################
+## 7. Advanced
+####################################################
+
+# I generatori ti aiutano a creare codice pigro (lazy code).
+# Codice che darà un risultato solo quando sarà "valutato"
+def double_numbers(iterable):
+    for i in iterable:
+        yield i + i
+
+# I generatori sono efficienti in termini di memoria perché caricano
+# solo i dati necessari per elaborare il valore successivo nell'iterabile. 
+# Ciò consente loro di eseguire operazioni su intervalli di valori
+# altrimenti proibitivi.
+# NOTA: `range` sostituisce` xrange` in Python 3.
+for i in double_numbers(range(1, 900000000)):  # `range` is a generator.
+    print(i)
+    if i >= 30:
+        break
+
+# Proprio come è possibile creare una "list comprehension", è possibile 
+# creare anche delle "generator comprehensions".
+values = (-x for x in [1,2,3,4,5])
+for x in values:
+    print(x)  # prints -1 -2 -3 -4 -5 to console/terminal
+
+# Puoi anche trasmettere una "generator comprehensions" direttamente 
+# ad un elenco.
+values = (-x for x in [1,2,3,4,5])
+gen_to_list = list(values)
+print(gen_to_list)  # => [-1, -2, -3, -4, -5]
+
+
+# Decoratori
+# In questo esempio "beg" avvolge/wrappa  "say". 
+# Se say_please è True, cambierà il messaggio restituito.
+from functools import wraps
+
+def beg(target_function):
+    @wraps(target_function)
+    def wrapper(*args, **kwargs):
+        msg, say_please = target_function(*args, **kwargs)
+        if say_please:
+            return "{} {}".format(msg, "Per favore! Sono povero :(")
+        return msg
+
+    return wrapper
+
+
+@beg
+def say(say_please=False):
+    msg = "Puoi comprarmi una birra?"
+    return msg, say_please
+
+
+print(say())                 # Puoi comprarmi una birra?
+print(say(say_please=True))  # Puoi comprarmi una birra? Per favore! Sono povero :(
+```
+
+## Pronto per qualcosa di più?
+
+### Gratis Online
+
+* [Automate the Boring Stuff with Python](https://automatetheboringstuff.com)
+* [Ideas for Python Projects](http://pythonpracticeprojects.com)
+* [The Official Docs](http://docs.python.org/3/)
+* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
+* [Python Course](http://www.python-course.eu/index.php)
+* [First Steps With Python](https://realpython.com/learn/python-first-steps/)
+* [A curated list of awesome Python frameworks, libraries and software](https://github.com/vinta/awesome-python)
+* [30 Python Language Features and Tricks You May Not Know About](http://sahandsaba.com/thirty-python-language-features-and-tricks-you-may-not-know.html)
+* [Official Style Guide for Python](https://www.python.org/dev/peps/pep-0008/)
+* [Python 3 Computer Science Circles](http://cscircles.cemc.uwaterloo.ca/)
+* [Dive Into Python 3](http://www.diveintopython3.net/index.html)
+* [A Crash Course in Python for Scientists](http://nbviewer.jupyter.org/gist/anonymous/5924718)
diff --git a/it-it/qt-it.html.markdown b/it-it/qt-it.html.markdown
new file mode 100644
index 00000000..d7469f67
--- /dev/null
+++ b/it-it/qt-it.html.markdown
@@ -0,0 +1,161 @@
+---
+category: tool
+tool: Qt Framework
+language: c++
+filename: learnqt-it.cpp
+contributors:
+    - ["Aleksey Kholovchuk", "https://github.com/vortexxx192"]
+translators:
+    - ["Ale46", "https://gihub.com/ale46"]
+lang: it-it
+---
+
+**Qt** è un framework ampiamente conosciuto per lo sviluppo di software multipiattaforma che può essere eseguito su varie piattaforme software e hardware con modifiche minime o nulle nel codice, pur avendo la potenza e la velocità delle applicazioni native. Sebbene **Qt** sia stato originariamente scritto in *C++*, ci sono diversi porting in altri linguaggi: *[PyQt](https://learnxinyminutes.com/docs/pyqt/)*, *QtRuby*, *PHP-Qt*, etc.
+
+**Qt** è ottimo per la creazione di applicazioni con interfaccia utente grafica (GUI). Questo tutorial descrive come farlo in *C++*.
+
+```c++
+/*
+ * Iniziamo classicamente
+ */
+
+// tutte le intestazioni dal framework Qt iniziano con la lettera maiuscola 'Q'
+#include <QApplication>
+#include <QLineEdit>
+
+int main(int argc, char *argv[]) {
+	  // crea un oggetto per gestire le risorse a livello di applicazione
+    QApplication app(argc, argv);
+
+    // crea un widget di campo di testo e lo mostra sullo schermo
+    QLineEdit lineEdit("Hello world!");
+    lineEdit.show();
+
+    // avvia il ciclo degli eventi dell'applicazione
+    return app.exec();
+}
+```
+
+La parte relativa alla GUI di **Qt** riguarda esclusivamente *widget* e le loro *connessioni*.
+
+[LEGGI DI PIÙ SUI WIDGET](http://doc.qt.io/qt-5/qtwidgets-index.html)
+
+```c++
+/*
+ * Creiamo un'etichetta e un pulsante.
+ * Un'etichetta dovrebbe apparire quando si preme un pulsante.
+ * 
+ * Il codice Qt parla da solo.
+ */
+ 
+#include <QApplication>
+#include <QDialog>
+#include <QVBoxLayout>
+#include <QPushButton>
+#include <QLabel>
+
+int main(int argc, char *argv[]) {
+    QApplication app(argc, argv);
+
+    QDialog dialogWindow;
+    dialogWindow.show();
+    
+    // add vertical layout 
+    QVBoxLayout layout;
+    dialogWindow.setLayout(&layout);  
+
+    QLabel textLabel("Grazie per aver premuto quel pulsante");
+    layout.addWidget(&textLabel);
+    textLabel.hide();
+
+    QPushButton button("Premimi");
+    layout.addWidget(&button);
+    
+    // mostra l'etichetta nascosta quando viene premuto il pulsante
+    QObject::connect(&button, &QPushButton::pressed,
+                     &textLabel, &QLabel::show);
+
+    return app.exec();
+}
+```
+
+Si noti la parte relativa a *QObject::connect*. Questo metodo viene utilizzato per connettere *SEGNALI* di un oggetto agli *SLOTS* di un altro.
+
+**I SEGNALI** vengono emessi quando certe cose accadono agli oggetti, come il segnale *premuto* che viene emesso quando l'utente preme sull'oggetto QPushButton.
+
+**Gli slot** sono *azioni* che potrebbero essere eseguite in risposta ai segnali ricevuti.
+
+[LEGGI DI PIÙ SU SLOT E SEGNALI](http://doc.qt.io/qt-5/signalsandslots.html)
+
+
+Successivamente, impariamo che non possiamo solo usare i widget standard, ma estendere il loro comportamento usando l'ereditarietà. Creiamo un pulsante e contiamo quante volte è stato premuto. A tale scopo definiamo la nostra classe *CounterLabel*. Deve essere dichiarato in un file separato a causa dell'architettura Qt specifica.
+
+```c++
+// counterlabel.hpp
+
+#ifndef COUNTERLABEL
+#define COUNTERLABEL
+
+#include <QLabel>
+
+class CounterLabel : public QLabel {
+    Q_OBJECT  // Macro definite da Qt che devono essere presenti in ogni widget personalizzato
+    
+public:
+    CounterLabel() : counter(0) {
+        setText("Il contatore non è stato ancora aumentato");  // metodo di QLabel
+    }
+
+public slots:
+    // azione che verrà chiamata in risposta alla pressione del pulsante
+    void increaseCounter() {
+        setText(QString("Valore contatore: %1").arg(QString::number(++counter)));
+    }
+
+private:
+    int counter;
+};
+
+#endif // COUNTERLABEL
+```
+
+```c++
+// main.cpp
+// Quasi uguale all'esempio precedente
+
+#include <QApplication>
+#include <QDialog>
+#include <QVBoxLayout>
+#include <QPushButton>
+#include <QString>
+#include "counterlabel.hpp"
+
+int main(int argc, char *argv[]) {
+    QApplication app(argc, argv);
+
+    QDialog dialogWindow;
+    dialogWindow.show();
+
+    QVBoxLayout layout;
+    dialogWindow.setLayout(&layout);
+
+    CounterLabel counterLabel;
+    layout.addWidget(&counterLabel);
+
+    QPushButton button("Premimi ancora una volta");
+    layout.addWidget(&button);
+    QObject::connect(&button, &QPushButton::pressed,
+                     &counterLabel, &CounterLabel::increaseCounter);
+
+    return app.exec();
+}
+```
+
+Questo è tutto! Ovviamente, il framework Qt è molto più grande della parte che è stata trattata in questo tutorial, quindi preparatevi a leggere e fare pratica.
+
+## Ulteriori letture
+
+- [Qt 4.8 tutorials](http://doc.qt.io/qt-4.8/tutorials.html)
+- [Qt 5 tutorials](http://doc.qt.io/qt-5/qtexamplesandtutorials.html)
+
+Buona fortuna e buon divertimento!
diff --git a/it-it/rst-it.html.markdown b/it-it/rst-it.html.markdown
index 8947c738..a834e899 100644
--- a/it-it/rst-it.html.markdown
+++ b/it-it/rst-it.html.markdown
@@ -6,10 +6,12 @@ contributors:
     - ["Andre Polykanine", "https://github.com/Oire"]
 translators:
     - ["Ale46", "https://github.com/Ale46"]
+    - ["Chris54721", "https://chris54721.net"]
 lang: it-it
 ---
 
-RST è un formato di file formalmente creato dalla comunità Python per scrivere documentazione (e quindi fa parte di Docutils).
+RST (Restructured Text) è un formato di file inizialmente creato dalla comunità Python
+per la documentazione (per questo motivo appartiene a Docutils).
 
 I file RST sono semplici file di testo con una sintassi leggera (in confronto all'HTML).
 
@@ -23,7 +25,7 @@ Per usare Restructured Text, sarà necessario installare [Python](http://www.pyt
 $ easy_install docutils
 ```
 
-O se il tuo sistema ha `pip`, puoi usare anche lui:
+Oppure, se hai `pip` installato sul tuo sistema:
 
 ```bash
 $ pip install docutils
@@ -32,7 +34,7 @@ $ pip install docutils
 
 ## Sintassi del file
 
-Un semplice esempio della sintassi del file:
+Ecco un semplice esempio della sintassi RST:
 
 ```
 .. Le righe che iniziano con due punti sono comandi speciali. Ma se non è possibile trovare alcun comando, la riga viene considerata come un commento
@@ -41,16 +43,16 @@ Un semplice esempio della sintassi del file:
 I titoli principali sono scritti utilizzando caratteri di uguale, sopra e sotto
 ===============================================================================
 
-Si noti che devono esistere tanti caratteri di uguale quanti sono i caratteri del titolo.
+Si noti che devono esserci tanti caratteri di uguale quanti caratteri del titolo.
 
-Anche il titolo è sottolineato con caratteri di uguale
-======================================================
+Anche i titoli normali usano caratteri di uguale, ma solo sotto
+===============================================================
 
-Sottotitoli con i trattini
---------------------------
+I sottotitoli usano i trattini
+------------------------------
 
-E sotto-sottotitoli con tildi
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+E i sotto-sottotitoli le tildi
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Puoi inserire il testo in *corsivo* o in **grassetto**, puoi "contrassegnare" il testo come codice con un doppio apice ``: `` print () ``.
 
@@ -60,13 +62,13 @@ Le liste sono semplici come in Markdown:
 - Secondo elemento
      - Sottoelemento
 
-o
+oppure
 
 * Primo elemento
 * Secondo elemento
      * Sottoelemento
 
-Le tabelle sono davvero facili da scrivere:
+Le tabelle sono molto semplici da inserire:
 
 =========== ========
 Stato       Capitale
@@ -75,22 +77,21 @@ Francia     Parigi
 Giappone    Tokio
 =========== ========
 
-Le tabelle più complesse possono essere fatte facilmente (colonne e/o righe unite) ma ti suggerisco di leggere il documento completo per questo :)
+Anche le tabelle più complesse possono essere inserite facilmente (colonne e/o righe unite) ma ti suggerisco di leggere la documentazione completa per questo :)
 
 Esistono diversi modi per creare collegamenti:
 
-- Aggiungendo un underscore dopo una parola: Github_ e aggiungendo l'URL di destinazione dopo il testo (questo modo ha il vantaggio di non inserire URL non necessari all'interno del testo leggibile).
+- Aggiungendo un underscore dopo una parola: Github_ e aggiungendo l'URL di destinazione dopo il testo (questo metodo ha il vantaggio di non inserire URL non necessari all'interno del testo leggibile).
 - Digitando un URL completo: https://github.com/ (verrà automaticamente convertito in un collegamento)
-- Facendo un collegamento simile a Markdown: `Github <https://github.com/>`_ .
+- Utilizzando una sintassi simile a Markdown: `Github <https://github.com/>`_ .
 
 .. _Github https://github.com/
 
 ```
 
-
 ## Come usarlo
 
-RST viene fornito con docutils che dispone di `rst2html`, per esempio:
+RST viene fornito con docutils, che dispone di `rst2html`, per esempio:
 
 ```bash
 $ rst2html miofile.rst output.html
diff --git a/it-it/ruby-it.html.markdown b/it-it/ruby-it.html.markdown
new file mode 100644
index 00000000..295bf28a
--- /dev/null
+++ b/it-it/ruby-it.html.markdown
@@ -0,0 +1,653 @@
+---
+language: ruby
+filename: learnruby-it.rb
+contributors:
+  - ["David Underwood", "http://theflyingdeveloper.com"]
+  - ["Joel Walden", "http://joelwalden.net"]
+  - ["Luke Holder", "http://twitter.com/lukeholder"]
+  - ["Tristan Hume", "http://thume.ca/"]
+  - ["Nick LaMuro", "https://github.com/NickLaMuro"]
+  - ["Marcos Brizeno", "http://www.about.me/marcosbrizeno"]
+  - ["Ariel Krakowski", "http://www.learneroo.com"]
+  - ["Dzianis Dashkevich", "https://github.com/dskecse"]
+  - ["Levi Bostian", "https://github.com/levibostian"]
+  - ["Rahil Momin", "https://github.com/iamrahil"]
+  - ["Gabriel Halley", "https://github.com/ghalley"]
+  - ["Persa Zula", "http://persazula.com"]
+  - ["Jake Faris", "https://github.com/farisj"]
+  - ["Corey Ward", "https://github.com/coreyward"]
+translators:
+  - ["abonte", "https://github.com/abonte"]
+lang: it-it   
+---
+
+```ruby
+# Questo è un commento
+
+# In Ruby, (quasi) tutto è un oggetto.
+# Questo include i numeri...
+3.class #=> Integer
+
+# ...stringhe...
+"Hello".class #=> String
+
+# ...e anche i metodi!
+"Hello".method(:class).class #=> Method
+
+# Qualche operazione aritmetica di base
+1 + 1 #=> 2
+8 - 1 #=> 7
+10 * 2 #=> 20
+35 / 5 #=> 7
+2 ** 5 #=> 32
+5 % 3 #=> 2
+
+# Bitwise operators
+3 & 5 #=> 1
+3 | 5 #=> 7
+3 ^ 5 #=> 6
+
+# L'aritmetica è solo zucchero sintattico
+# per chiamare il metodo di un oggetto
+1.+(3) #=> 4
+10.* 5 #=> 50
+100.methods.include?(:/) #=> true
+
+# I valori speciali sono oggetti
+nil # equivalente a null in altri linguaggi
+true # vero
+false # falso
+
+nil.class #=> NilClass
+true.class #=> TrueClass
+false.class #=> FalseClass
+
+# Uguaglianza
+1 == 1 #=> true
+2 == 1 #=> false
+
+# Disuguaglianza
+1 != 1 #=> false
+2 != 1 #=> true
+
+# nil è l'unico valore, oltre a false, che è considerato 'falso'
+!!nil   #=> false
+!!false #=> false
+!!0     #=> true
+!!""    #=> true
+
+# Altri confronti
+1 < 10 #=> true
+1 > 10 #=> false
+2 <= 2 #=> true
+2 >= 2 #=> true
+
+# Operatori di confronto combinati (ritorna '1' quando il primo argomento è più
+# grande, '-1' quando il secondo argomento è più grande, altrimenti '0')
+1 <=> 10 #=> -1
+10 <=> 1 #=> 1
+1 <=> 1 #=> 0
+
+# Operatori logici
+true && false #=> false
+true || false #=> true
+
+# Ci sono versioni alternative degli operatori logici con meno precedenza.
+# Sono usati come costrutti per il controllo di flusso per concatenare
+# insieme statement finché uno di essi ritorna true o false.
+
+# `do_something_else` chiamato solo se `do_something` ha successo.
+do_something() and do_something_else()
+# `log_error` è chiamato solo se `do_something` fallisce.
+do_something() or log_error()
+
+# Interpolazione di stringhe
+
+placeholder = 'usare l\'interpolazione di stringhe'
+"Per #{placeholder} si usano stringhe con i doppi apici"
+#=> "Per usare l'interpolazione di stringhe si usano stringhe con i doppi apici"
+
+# E' possibile combinare le stringhe usando `+`, ma non con gli altri tipi
+'hello ' + 'world'  #=> "hello world"
+'hello ' + 3 #=> TypeError: can't convert Fixnum into String
+'hello ' + 3.to_s #=> "hello 3"
+"hello #{3}" #=> "hello 3"
+
+# ...oppure combinare stringhe e operatori
+'ciao ' * 3 #=> "ciao ciao ciao "
+
+# ...oppure aggiungere alla stringa
+'ciao' << ' mondo' #=> "ciao mondo"
+
+# Per stampare a schermo e andare a capo
+puts "Sto stampando!"
+#=> Sto stampando!
+#=> nil
+
+# Per stampare a schermo senza andare a capo
+print "Sto stampando!"
+#=> Sto stampando! => nil
+
+# Variabili
+x = 25 #=> 25
+x #=> 25
+
+# Notare che l'assegnamento ritorna il valore assegnato.
+# Questo significa che è possibile effettuare assegnamenti multipli:
+x = y = 10 #=> 10
+x #=> 10
+y #=> 10
+
+# Per convenzione si usa lo snake_case per i nomi delle variabili
+snake_case = true
+
+# Usare nomi delle variabili descrittivi
+path_to_project_root = '/buon/nome/'
+m = '/nome/scadente/'
+
+# I simboli sono immutabili, costanti riusabili rappresentati internamente da
+# un valore intero. Sono spesso usati al posto delle stringhe per comunicare
+# specifici e significativi valori.
+
+:pendente.class #=> Symbol
+
+stato = :pendente
+
+stato == :pendente #=> true
+
+stato == 'pendente' #=> false
+
+stato == :approvato #=> false
+
+# Le stringhe possono essere convertite in simboli e viceversa:
+status.to_s #=> "pendente"
+"argon".to_sym #=> :argon
+
+# Arrays
+
+# Questo è un array
+array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
+
+# Gli array possono contenere diversi tipi di elementi
+[1, 'hello', false] #=> [1, "hello", false]
+
+# Gli array possono essere indicizzati
+# Dall'inizio...
+array[0] #=> 1
+array.first #=> 1
+array[12] #=> nil
+
+
+# ...o dalla fine...
+array[-1] #=> 5
+array.last #=> 5
+
+# With a start index and length
+# ...o con un indice di inzio e la lunghezza...
+array[2, 3] #=> [3, 4, 5]
+
+# ...oppure con un intervallo.
+array[1..3] #=> [2, 3, 4]
+
+# Invertire l'ordine degli elementi di un array
+a = [1,2,3]
+a.reverse! #=> [3,2,1]
+
+# Come per l'aritmetica,  l'accesso tramite [var]
+# è solo zucchero sintattico
+# per chiamare il metodo '[]'' di un oggetto
+array.[] 0 #=> 1
+array.[] 12 #=> nil
+
+# Si può aggiungere un elemento all'array così
+array << 6 #=> [1, 2, 3, 4, 5, 6]
+# oppure così
+array.push(6) #=> [1, 2, 3, 4, 5, 6]
+
+# Controllare se un elemento esiste in un array
+array.include?(1) #=> true
+
+# Hash è un dizionario con coppie di chiave e valore
+# Un hash è denotato da parentesi graffe:
+hash = { 'colore' => 'verde', 'numero' => 5 }
+
+hash.keys #=> ['colore', 'numero']
+
+# E' possibile accedere all'hash tramite chiave:
+hash['colore'] #=> 'verde'
+hash['numero'] #=> 5
+
+# Accedere all'hash con una chiave che non esiste ritorna nil:
+hash['nothing here'] #=> nil
+
+# Quando si usano simboli come chiavi di un hash, si possono utilizzare
+# queste sintassi:
+
+hash = { :defcon => 3, :action => true }
+hash.keys #=> [:defcon, :action]
+# oppure
+hash = { defcon: 3, action: true }
+hash.keys #=> [:defcon, :action]
+
+# Controllare l'esistenza di una chiave o di un valore in un hash
+new_hash.key?(:defcon) #=> true
+new_hash.value?(3) #=> true
+
+# Suggerimento: sia gli array che gli hash sono enumerabili!
+# Entrambi possiedono metodi utili come each, map, count e altri.
+
+# Strutture di controllo
+
+#Condizionali
+if true
+  'if statement'
+elsif false
+  'else if, opzionale'
+else
+  'else, opzionale'
+end
+
+#Cicli
+# In Ruby, i tradizionali cicli `for` non sono molto comuni. Questi semplici
+# cicli, invece, sono implementati con un enumerable, usando `each`:
+(1..5).each do |contatore|
+  puts "iterazione #{contatore}"
+end
+
+# Esso è equivalente a questo ciclo, il quale è inusuale da vedere in Ruby:
+for contatore in 1..5
+  puts "iterazione #{contatore}"
+end
+
+# Il costrutto `do |variable| ... end` è chiamato 'blocco'. I blocchi
+# sono simili alle lambda, funzioni anonime o closure che si trovano in altri
+# linguaggi di programmazione. Essi possono essere passati come oggetti,
+# chiamati o allegati come metodi.
+# 
+# Il metodo 'each' di un intervallo (range) esegue il blocco una volta
+# per ogni elemento dell'intervallo.
+# Al blocco è passato un contatore come parametro.
+
+# E' possibile inglobare il blocco fra le parentesi graffe
+(1..5).each { |contatore| puts "iterazione #{contatore}" }
+
+# Il contenuto delle strutture dati può essere iterato usando "each".
+array.each do |elemento|
+  puts "#{elemento} è parte dell'array"
+end
+hash.each do |chiave, valore|
+  puts "#{chiave} è #{valore}"
+end
+
+# If you still need an index you can use 'each_with_index' and define an index
+# variable
+# Se comunque si vuole un indice, si può usare "each_with_index" e definire
+# una variabile che contiene l'indice
+array.each_with_index do |elemento, indice|
+  puts "#{elemento} è il numero #{index} nell'array"
+end
+
+contatore = 1
+while contatore <= 5 do
+  puts "iterazione #{contatore}"
+  contatore += 1
+end
+#=> iterazione 1
+#=> iterazione 2
+#=> iterazione 3
+#=> iterazione 4
+#=> iterazione 5
+
+# Esistono in Ruby ulteriori funzioni per fare i cicli,
+# come per esempio 'map', 'reduce', 'inject' e altri.
+# Nel caso di 'map', esso prende l'array sul quale si sta iterando, esegue
+# le istruzioni definite nel blocco, e ritorna un array completamente nuovo.
+array = [1,2,3,4,5]
+doubled = array.map do |elemento|
+  elemento * 2
+end
+puts doubled
+#=> [2,4,6,8,10]
+puts array
+#=> [1,2,3,4,5]
+
+# Costrutto "case"
+grade = 'B'
+
+case grade
+when 'A'
+  puts 'Way to go kiddo'
+when 'B'
+  puts 'Better luck next time'
+when 'C'
+  puts 'You can do better'
+when 'D'
+  puts 'Scraping through'
+when 'F'
+  puts 'You failed!'
+else
+  puts 'Alternative grading system, eh?'
+end
+#=> "Better luck next time"
+
+# 'case' può usare anche gli intervalli
+grade = 82
+case grade
+when 90..100
+  puts 'Hooray!'
+when 80...90
+  puts 'OK job'
+else
+  puts 'You failed!'
+end
+#=> "OK job"
+
+# Gestione delle eccezioni
+begin
+  # codice che può sollevare un eccezione
+  raise NoMemoryError, 'Esaurita la memoria.'
+rescue NoMemoryError => exception_variable
+  puts 'NoMemoryError è stato sollevato.', exception_variable
+rescue RuntimeError => other_exception_variable
+  puts 'RuntimeError è stato sollvato.'
+else
+  puts 'Questo viene eseguito se nessuna eccezione è stata sollevata.'
+ensure
+  puts 'Questo codice viene sempre eseguito a prescindere.'
+end
+
+# Metodi
+
+def double(x)
+  x * 2
+end
+
+# Metodi (e blocchi) ritornano implicitamente il valore dell'ultima istruzione
+double(2) #=> 4
+
+# Le parentesi sono opzionali dove l'interpolazione è inequivocabile
+double 3 #=> 6
+
+double double 3 #=> 12
+
+def sum(x, y)
+  x + y
+end
+
+# Gli argomenit dei metodi sono separati dalla virgola
+sum 3, 4 #=> 7
+
+sum sum(3, 4), 5 #=> 12
+
+# yield
+# Tutti i metodi hanno un implicito e opzionale parametro del blocco.
+# Esso può essere chiamato con la parola chiave 'yield'.
+
+def surround
+  puts '{'
+  yield
+  puts '}'
+end
+
+surround { puts 'hello world' }
+
+# {
+# hello world
+# }
+
+# I blocchi possono essere convertiti in 'proc', il quale racchiude il blocco
+# e gli permette di essere passato ad un altro metodo, legato ad uno scope
+# differente o modificato. Questo è molto comune nella lista parametri del
+# metodo, dove è frequente vedere il parametro '&block' in coda. Esso accetta
+# il blocco, se ne è stato passato uno, e lo converte in un 'Proc'.
+# Qui la denominazione è una convenzione; funzionerebbe anche con '&ananas'.
+def guests(&block)
+  block.class #=> Proc
+  block.call(4)
+end
+
+# Il metodo 'call' del Proc è simile allo 'yield' quando è presente un blocco.
+# Gli argomenti passati a 'call' sono inoltrati al blocco come argomenti:
+
+guests { |n| "You have #{n} guests." }
+# => "You have 4 guests."
+
+# L'operatore splat ("*") converte una lista di argomenti in un array
+def guests(*array)
+  array.each { |guest| puts guest }
+end
+
+# Destrutturazione
+
+# Ruby destruttura automaticamente gli array in assegnamento
+# a variabili multiple:
+a, b, c = [1, 2, 3]
+a #=> 1
+b #=> 2
+c #=> 3
+
+# In alcuni casi si usa l'operatore splat ("*") per destrutturare
+# un array in una lista.
+classifica_concorrenti = ["John", "Sally", "Dingus", "Moe", "Marcy"]
+
+def migliore(primo, secondo, terzo)
+  puts "I vincitori sono #{primo}, #{secondo}, e #{terzo}."
+end
+
+migliore *classifica_concorrenti.first(3)
+#=> I vincitori sono John, Sally, e Dingus.
+
+# The splat operator can also be used in parameters:
+def migliore(primo, secondo, terzo, *altri)
+  puts "I vincitori sono #{primo}, #{secondo}, e #{terzo}."
+  puts "C'erano altri #{altri.count} partecipanti."
+end
+
+migliore *classifica_concorrenti 
+#=> I vincitori sono John, Sally, e Dingus.
+#=> C'erano altri 2 partecipanti.
+
+# Per convenzione, tutti i metodi che ritornano un booleano terminano
+# con un punto interrogativo
+5.even? #=> false
+5.odd? #=> true
+
+# Per convenzione, se il nome di un metodo termina con un punto esclamativo,
+# esso esegue qualcosa di distruttivo. Molti metodi hanno una versione con '!'
+# per effettuare una modifiche, e una versione senza '!' che ritorna
+# una versione modificata.
+nome_azienda = "Dunder Mifflin"
+nome_azienda.upcase #=> "DUNDER MIFFLIN"
+nome_azienda #=> "Dunder Mifflin"
+# Questa volta modifichiamo nome_azienda
+nome_azienda.upcase! #=> "DUNDER MIFFLIN"
+nome_azienda #=> "DUNDER MIFFLIN"
+
+# Classi
+
+# Definire una classe con la parola chiave class
+class Umano
+
+  # Una variabile di classe. E' condivisa da tutte le istance di questa classe.
+  @@specie = 'H. sapiens'
+
+  # Inizializzatore di base
+  def initialize(nome, eta = 0)
+    # Assegna il valore dell'argomento alla variabile dell'istanza "nome"
+    @nome = nome
+    # Se l'età non è fornita, verrà assegnato il valore di default indicato
+    # nella lista degli argomenti
+    @eta = eta
+  end
+
+  # Metodo setter di base
+  def nome=(nome)
+    @nome = nome
+  end
+
+  # Metodo getter di base
+  def nome
+    @nome
+  end
+
+  # Le funzionalità di cui sopra posso essere incapsulate usando
+  # il metodo attr_accessor come segue
+  attr_accessor :nome
+
+  # Getter/setter possono anche essere creati individualmente
+  attr_reader :nome
+  attr_writer :nome
+
+  # Un metodo della classe usa 'self' per distinguersi dai metodi dell'istanza.
+  # Può essere richimato solo dalla classe, non dall'istanza.
+  def self.say(msg)
+    puts msg
+  end
+
+  def specie
+    @@specie
+  end
+end
+
+
+# Instanziare una classe
+jim = Umano.new('Jim Halpert')
+
+dwight = Umano.new('Dwight K. Schrute')
+
+# Chiamiamo qualche metodo
+jim.specie #=> "H. sapiens"
+jim.nome #=> "Jim Halpert"
+jim.nome = "Jim Halpert II" #=> "Jim Halpert II"
+jim.nome #=> "Jim Halpert II"
+dwight.specie #=> "H. sapiens"
+dwight.nome #=> "Dwight K. Schrute"
+
+# Chiamare un metodo della classe
+Umano.say('Ciao') #=> "Ciao"
+
+# La visibilità della variabile (variable's scope) è determinata dal modo
+# in cui le viene assegnato il nome.
+# Variabili che iniziano con $ hanno uno scope globale
+$var = "Sono una variabile globale"
+defined? $var #=> "global-variable"
+
+# Variabili che inziano con @ hanno a livello dell'istanza
+@var = "Sono una variabile dell'istanza"
+defined? @var #=> "instance-variable"
+
+# Variabili che iniziano con @@ hanno una visibilità a livello della classe
+@@var = "Sono una variabile della classe"
+defined? @@var #=> "class variable"
+
+# Variabili che iniziano con una lettera maiuscola sono costanti
+Var = "Sono una costante"
+defined? Var #=> "constant"
+
+# Anche una classe è un oggetto in ruby. Quindi la classe può avere
+# una variabile dell'istanza. Le variabili della classe sono condivise
+# fra la classe e tutti i suoi discendenti.
+
+# Classe base
+class Umano
+  @@foo = 0
+
+  def self.foo
+    @@foo
+  end
+
+  def self.foo=(value)
+    @@foo = value
+  end
+end
+
+# Classe derivata
+class Lavoratore < Umano
+end
+
+Umano.foo #=> 0
+Lavoratore.foo #=> 0
+
+Umano.foo = 2 #=> 2
+Lavoratore.foo #=> 2
+
+# La variabile dell'istanza della classe non è condivisa dai discendenti.
+
+class Umano
+  @bar = 0
+
+  def self.bar
+    @bar
+  end
+
+  def self.bar=(value)
+    @bar = value
+  end
+end
+
+class Dottore < Umano
+end
+
+Umano.bar #=> 0
+Dottore.bar #=> nil
+
+module EsempioModulo
+  def foo
+    'foo'
+  end
+end
+
+# Includere moduli vincola i suoi metodi all'istanza della classe.
+# Estendere moduli vincola i suoi metodi alla classe stessa.
+class Persona
+  include EsempioModulo
+end
+
+class Libro
+  extend EsempioModulo
+end
+
+Persona.foo     #=> NoMethodError: undefined method `foo' for Person:Class
+Persona.new.foo #=> 'foo'
+Libro.foo       #=> 'foo'
+Libro.new.foo   #=> NoMethodError: undefined method `foo'
+
+# Callbacks sono eseguiti quand si include o estende un modulo
+module ConcernExample
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.send(:include, InstanceMethods)
+  end
+
+  module ClassMethods
+    def bar
+      'bar'
+    end
+  end
+
+  module InstanceMethods
+    def qux
+      'qux'
+    end
+  end
+end
+
+class Something
+  include ConcernExample
+end
+
+Something.bar     #=> 'bar'
+Something.qux     #=> NoMethodError: undefined method `qux'
+Something.new.bar #=> NoMethodError: undefined method `bar'
+Something.new.qux #=> 'qux'
+```
+
+## Ulteriori risorse
+
+- [Learn Ruby by Example with Challenges](http://www.learneroo.com/modules/61/nodes/338) - Una variante di questa guida con esercizi nel browser.
+- [An Interactive Tutorial for Ruby](https://rubymonk.com/) - Imparare Ruby attraverso una serie di tutorial interattivi.
+- [Official Documentation](http://ruby-doc.org/core)
+- [Ruby from other languages](https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/)
+- [Programming Ruby](http://www.amazon.com/Programming-Ruby-1-9-2-0-Programmers/dp/1937785491/) - Una passata [edizione libera](http://ruby-doc.com/docs/ProgrammingRuby/) è disponibile online.
+- [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide) - A community-driven Ruby coding style guide.
+- [Try Ruby](http://tryruby.org) - Imparare le basi del linguaggio di programmazion Ruby, interattivamente nel browser.
diff --git a/it-it/rust-it.html.markdown b/it-it/rust-it.html.markdown
index 6b379f93..e4b7c33f 100644
--- a/it-it/rust-it.html.markdown
+++ b/it-it/rust-it.html.markdown
@@ -130,14 +130,14 @@ fn main() {
     /////////////
 
     // Strutture
-    struct Point {
+    struct Punto {
         x: i32,
         y: i32,
     }
 
     let origine: Punto = Punto { x: 0, y: 0 };
 
-    // Ana struct con campi senza nome, chiamata ‘tuple struct’
+    // Una struct con campi senza nome, chiamata ‘tuple struct’
     struct Punto2(i32, i32);
 
     let origine2 = Punto2(0, 0);
diff --git a/it-it/toml-it.html.markdown b/it-it/toml-it.html.markdown
new file mode 100644
index 00000000..99082048
--- /dev/null
+++ b/it-it/toml-it.html.markdown
@@ -0,0 +1,276 @@
+---

+language: toml

+filename: learntoml-it.toml

+contributors:

+  - ["Alois de Gouvello", "https://github.com/aloisdg"]

+translators:

+  - ["Christian Grasso", "https://grasso.io"]

+lang: it-it

+---

+

+TOML è l'acronimo di _Tom's Obvious, Minimal Language_. È un linguaggio per la

+serializzazione di dati, progettato per i file di configurazione.

+

+È un'alternativa a linguaggi come YAML e JSON, che punta ad essere più leggibile

+per le persone. Allo stesso tempo, TOML può essere utilizzato in modo abbastanza

+semplice nella maggior parte dei linguaggi di programmazione, in quanto è

+progettato per essere tradotto senza ambiguità in una hash table.

+

+Tieni presente che TOML è ancora in fase di sviluppo, e la sua specifica non è

+ancora stabile. Questo documento utilizza TOML 0.4.0.

+

+```toml

+# I commenti in TOML sono fatti così.

+

+################

+# TIPI SCALARI #

+################

+

+# Il nostro oggetto root (corrispondente all'intero documento) sarà una mappa,

+# anche chiamata dizionario, hash o oggetto in altri linguaggi.

+

+# La key, il simbolo di uguale e il valore devono trovarsi sulla stessa riga,

+# eccetto per alcuni tipi di valori.

+key = "value"

+stringa = "ciao"

+numero = 42

+float = 3.14

+boolean = true

+data = 1979-05-27T07:32:00-08:00

+notazScientifica = 1e+12

+"puoi utilizzare le virgolette per la key" = true # Puoi usare " oppure '

+"la key può contenere" = "lettere, numeri, underscore e trattini"

+

+############

+# Stringhe #

+############

+

+# Le stringhe possono contenere solo caratteri UTF-8 validi.

+# Possiamo effettuare l'escape dei caratteri, e alcuni hanno delle sequenze

+# di escape compatte. Ad esempio, \t corrisponde al TAB.

+stringaSemplice = "Racchiusa tra virgolette. \"Usa il backslash per l'escape\"."

+

+stringaMultiriga = """

+Racchiusa da tre virgolette doppie all'inizio e

+alla fine - consente di andare a capo."""

+

+stringaLiteral = 'Virgolette singole. Non consente di effettuare escape.'

+

+stringaMultirigaLiteral = '''

+Racchiusa da tre virgolette singole all'inizio e

+alla fine - consente di andare a capo.

+Anche in questo caso non si può fare escape.

+Il primo ritorno a capo viene eliminato.

+   Tutti gli altri spazi aggiuntivi

+   vengono mantenuti.

+'''

+

+# Per i dati binari è consigliabile utilizzare Base64 e

+# gestirli manualmente dall'applicazione.

+

+##########

+# Interi #

+##########

+

+## Gli interi possono avere o meno un segno (+, -).

+## Non si possono inserire zero superflui all'inizio.

+## Non è possibile inoltre utilizzare valori numerici

+## non rappresentabili con una sequenza di cifre.

+int1 = +42

+int2 = 0

+int3 = -21

+

+## Puoi utilizzare gli underscore per migliorare la leggibilità.

+## Fai attenzione a non inserirne due di seguito.

+int4 = 5_349_221

+int5 = 1_2_3_4_5     # VALIDO, ma da evitare

+

+#########

+# Float #

+#########

+

+# I float permettono di rappresentare numeri decimali.

+flt1 = 3.1415

+flt2 = -5e6

+flt3 = 6.626E-34

+

+###########

+# Boolean #

+###########

+

+# I valori boolean (true/false) devono essere scritti in minuscolo.

+bool1 = true

+bool2 = false

+

+############

+# Data/ora #

+############

+

+data1 = 1979-05-27T07:32:00Z # Specifica RFC 3339/ISO 8601 (UTC)

+data2 = 1979-05-26T15:32:00+08:00 # RFC 3339/ISO 8601 con offset

+

+######################

+# TIPI DI COLLECTION #

+######################

+

+#########

+# Array #

+#########

+

+array1 = [ 1, 2, 3 ]

+array2 = [ "Le", "virgole", "sono", "delimitatori" ]

+array3 = [ "Non", "unire", "tipi", "diversi" ]

+array4 = [ "tutte", 'le stringhe', """hanno lo stesso""", '''tipo''' ]

+array5 = [

+  "Gli spazi vuoti", "sono", "ignorati"

+]

+

+###########

+# Tabelle #

+###########

+

+# Le tabelle (o hash table o dizionari) sono collection di coppie key/value.

+# Iniziano con un nome tra parentesi quadre su una linea separata. 

+# Le tabelle vuote (senza alcun valore) sono valide.

+[tabella]

+

+# Tutti i valori che si trovano sotto il nome della tabella

+# appartengono alla tabella stessa (finchè non ne viene creata un'altra).

+# L'ordine di questi valori non è garantito.

+[tabella-1]

+key1 = "una stringa"

+key2 = 123

+

+[tabella-2]

+key1 = "un'altra stringa"

+key2 = 456

+

+# Utilizzando i punti è possibile creare delle sottotabelle.

+# Ogni parte suddivisa dai punti segue le regole delle key per il nome.

+[tabella-3."sotto.tabella"]

+key1 = "prova"

+

+# Ecco l'equivalente JSON della tabella precedente:

+# { "tabella-3": { "sotto.tabella": { "key1": "prova" } } }

+

+# Gli spazi non vengono considerati, ma è consigliabile

+# evitare di usare spazi superflui.

+[a.b.c]            # consigliato

+[ d.e.f ]          # identico a [d.e.f]

+

+# Non c'è bisogno di creare le tabelle superiori per creare una sottotabella.

+# [x] queste

+# [x.y] non

+# [x.y.z] servono

+[x.y.z.w] # per creare questa tabella

+

+# Se non è stata già creata prima, puoi anche creare

+# una tabella superiore più avanti.

+[a.b]

+c = 1

+

+[a]

+d = 2

+

+# Non puoi definire una key o una tabella più di una volta.

+

+# ERRORE

+[a]

+b = 1

+

+[a]

+c = 2

+

+# ERRORE

+[a]

+b = 1

+

+[a.b]

+c = 2

+

+# I nomi delle tabelle non possono essere vuoti.

+[]     # NON VALIDO

+[a.]   # NON VALIDO

+[a..b] # NON VALIDO

+[.b]   # NON VALIDO

+[.]    # NON VALIDO

+

+##################

+# Tabelle inline #

+##################

+

+tabelleInline = { racchiuseData = "{ e }", rigaSingola = true }

+punto = { x = 1, y = 2 }

+

+####################

+# Array di tabelle #

+####################

+

+# Un array di tabelle può essere creato utilizzando due parentesi quadre.

+# Tutte le tabelle con questo nome saranno elementi dell'array.

+# Gli elementi vengono inseriti nell'ordine in cui si trovano.

+

+[[prodotti]]

+nome = "array di tabelle"

+sku = 738594937

+tabelleVuoteValide = true

+

+[[prodotti]]

+

+[[prodotti]]

+nome = "un altro item"

+sku = 284758393

+colore = "grigio"

+

+# Puoi anche creare array di tabelle nested. Le sottotabelle con doppie

+# parentesi quadre apparterranno alla tabella più vicina sopra di esse.

+

+[[frutta]]

+  nome = "mela"

+

+  [frutto.geometria]

+    forma = "sferica"

+    nota = "Sono una proprietà del frutto"

+

+  [[frutto.colore]]

+    nome = "rosso"

+    nota = "Sono un oggetto di un array dentro mela"

+

+  [[frutto.colore]]

+    nome = "verde"

+    nota = "Sono nello stesso array di rosso"

+

+[[frutta]]

+  nome = "banana"

+

+  [[frutto.colore]]

+    nome = "giallo"

+    nota = "Anche io sono un oggetto di un array, ma dentro banana"

+```

+

+Ecco l'equivalente JSON dell'ultima tabella:

+

+```json

+{

+  "frutta": [

+    {

+      "nome": "mela",

+      "geometria": { "forma": "sferica", "nota": "..."},

+      "colore": [

+        { "nome": "rosso", "nota": "..." },

+        { "nome": "verde", "nota": "..." }

+      ]

+    },

+    {

+      "nome": "banana",

+      "colore": [

+        { "nome": "giallo", "nota": "..." }

+      ]

+    }

+  ]

+}

+```

+

+### Altre risorse

+

++ [Repository ufficiale di TOML](https://github.com/toml-lang/toml)

diff --git a/it-it/typescript-it.html.markdown b/it-it/typescript-it.html.markdown
new file mode 100644
index 00000000..b78705c5
--- /dev/null
+++ b/it-it/typescript-it.html.markdown
@@ -0,0 +1,227 @@
+---
+language: TypeScript
+contributors:
+    - ["Philippe Vlérick", "https://github.com/pvlerick"]
+translators:
+    - ["Christian Grasso", "https://grasso.io"]
+filename: learntypescript-it.ts
+lang: it-it
+---
+
+TypeScript è un linguaggio basato su JavaScript che punta a rendere il codice
+più scalabile introducendo concetti quali le classi, i moduli, le interface,
+e i generics.
+Poichè TypeScript è un superset di JavaScript, è possibile sfruttare le sue
+funzionalità anche in progetti esistenti: il codice JavaScript valido è anche
+valido in TypeScript. Il compilatore di TypeScript genera codice JavaScript.
+
+Questo articolo si concentrerà solo sulle funzionalità aggiuntive di TypeScript.
+
+Per testare il compilatore, puoi utilizzare il
+[Playground](http://www.typescriptlang.org/Playground), dove potrai scrivere
+codice TypeScript e visualizzare l'output in JavaScript.
+
+```ts
+// TypeScript ha tre tipi di base
+let completato: boolean = false;
+let righe: number = 42;
+let nome: string = "Andrea";
+
+// Il tipo può essere omesso se è presente un assegnamento a scalari/literal
+let completato = false;
+let righe = 42;
+let nome = "Andrea";
+
+// Il tipo "any" indica che la variabile può essere di qualsiasi tipo
+let qualsiasi: any = 4;
+qualsiasi = "oppure una stringa";
+qualsiasi = false; // o magari un boolean
+
+// Usa la keyword "const" per le costanti
+const numeroViteGatti = 9;
+numeroViteGatti = 1; // Errore
+
+// Per gli array, puoi usare l'apposito tipo o la versione con i generics
+let lista: number[] = [1, 2, 3];
+let lista: Array<number> = [1, 2, 3];
+
+// Per le enumerazioni:
+enum Colore { Rosso, Verde, Blu };
+let c: Colore = Colore.Verde;
+
+// Infine, "void" viene utilizzato per le funzioni che non restituiscono valori
+function avviso(): void {
+  alert("Sono un piccolo avviso fastidioso!");
+}
+
+// Le funzioni supportano la sintassi "a freccia" (lambda) e supportano la type
+// inference, cioè per scalari/literal non c'è bisogno di specificare il tipo
+
+// Tutte le seguenti funzioni sono equivalenti, e il compilatore genererà
+// lo stesso codice JavaScript per ognuna di esse
+let f1 = function (i: number): number { return i * i; }
+// Type inference
+let f2 = function (i: number) { return i * i; }
+// Sintassi lambda
+let f3 = (i: number): number => { return i * i; }
+// Sintassi lambda + type inference
+let f4 = (i: number) => { return i * i; }
+// Sintassi lambda + type inference + sintassi abbreviata (senza return)
+let f5 = (i: number) => i * i;
+
+// Le interfacce sono strutturali, e qualunque oggetto con le stesse proprietà
+// di un'interfaccia è compatibile con essa
+interface Persona {
+  nome: string;
+  // Proprietà opzionale, indicata con "?"
+  anni?: number;
+  // Funzioni
+  saluta(): void;
+}
+
+// Oggetto che implementa l'interfaccia Persona
+// È una Persona valida poichè implementa tutta le proprietà non opzionali
+let p: Persona = { nome: "Bobby", saluta: () => { } };
+// Naturalmente può avere anche le proprietà opzionali:
+let pValida: Persona = { nome: "Bobby", anni: 42, saluta: () => { } };
+// Questa invece NON è una Persona, poichè il tipo di "anni" è sbagliato
+let pNonValida: Persona = { nome: "Bobby", anni: true };
+
+// Le interfacce possono anche descrivere una funzione
+interface SearchFunc {
+  (source: string, subString: string): boolean;
+}
+// I nomi dei parametri non sono rilevanti: vengono controllati solo i tipi
+let ricerca: SearchFunc;
+ricerca = function (src: string, sub: string) {
+  return src.search(sub) != -1;
+}
+
+// Classi - i membri sono pubblici di default
+class Punto {
+  // Proprietà
+  x: number;
+
+  // Costruttore - in questo caso la keyword "public" può generare in automatico
+  // il codice per l'inizializzazione di una variabile.
+  // In questo esempio, verrà creata la variabile y in modo identico alla x, ma
+  // con meno codice. Sono supportati anche i valori di default.
+  constructor(x: number, public y: number = 0) {
+    this.x = x;
+  }
+
+  // Funzioni
+  dist() { return Math.sqrt(this.x * this.x + this.y * this.y); }
+
+  // Membri statici
+  static origine = new Point(0, 0);
+}
+
+// Le classi possono anche implementare esplicitamente delle interfacce.
+// Il compilatore restituirà un errore nel caso in cui manchino delle proprietà. 
+class PersonaDiRiferimento implements Persona {
+    nome: string
+    saluta() {}
+}
+
+let p1 = new Punto(10, 20);
+let p2 = new Punto(25); // y = 0
+
+// Inheritance
+class Punto3D extends Punto {
+  constructor(x: number, y: number, public z: number = 0) {
+    super(x, y); // La chiamata esplicita a super è obbligatoria
+  }
+
+  // Sovrascrittura
+  dist() {
+    let d = super.dist();
+    return Math.sqrt(d * d + this.z * this.z);
+  }
+}
+
+// Moduli - "." può essere usato come separatore per i sottomoduli
+module Geometria {
+  export class Quadrato {
+    constructor(public lato: number = 0) { }
+
+    area() {
+      return Math.pow(this.lato, 2);
+    }
+  }
+}
+
+let s1 = new Geometria.Quadrato(5);
+
+// Alias locale per un modulo
+import G = Geometria;
+
+let s2 = new G.Quadrato(10);
+
+// Generics
+// Classi
+class Tuple<T1, T2> {
+  constructor(public item1: T1, public item2: T2) {
+  }
+}
+
+// Interfacce
+interface Pair<T> {
+  item1: T;
+  item2: T;
+}
+
+// E funzioni
+let pairToTuple = function <T>(p: Pair<T>) {
+  return new Tuple(p.item1, p.item2);
+};
+
+let tuple = pairToTuple({ item1: "hello", item2: "world" });
+
+// Interpolazione con le template string (definite con i backtick)
+let nome = 'Tyrone';
+let saluto = `Ciao ${name}, come stai?`
+// Possono anche estendersi su più righe
+let multiriga = `Questo è un esempio
+di stringa multiriga.`;
+
+// La keyword "readonly" rende un membro di sola lettura
+interface Persona {
+  readonly nome: string;
+  readonly anni: number;
+}
+
+var p1: Persona = { nome: "Tyrone", anni: 42 };
+p1.anni = 25; // Errore, p1.anni è readonly
+
+var p2 = { nome: "John", anni: 60 };
+var p3: Person = p2; // Ok, abbiamo creato una versione readonly di p2
+p3.anni = 35; // Errore, p3.anni è readonly
+p2.anni = 45; // Compila, ma cambia anche p3.anni per via dell'aliasing!
+
+class Macchina {
+  readonly marca: string;
+  readonly modello: string;
+  readonly anno = 2018;
+
+  constructor() {
+    // Possiamo anche assegnare nel constructor
+    this.marca = "Marca sconosciuta";
+    this.modello = "Modello sconosciuto";
+  }
+}
+
+let numeri: Array<number> = [0, 1, 2, 3, 4];
+let altriNumeri: ReadonlyArray<number> = numbers;
+altriNumeri[5] = 5; // Errore, gli elementi sono readonly
+altriNumeri.push(5); // Errore, il metodo push non esiste (modifica l'array)
+altriNumeri.length = 3; // Errore, length è readonly
+numeri = altriNumeri; // Errore, i metodi di modifica non esistono
+```
+
+## Altre risorse
+ * [Sito ufficiale di TypeScript](http://www.typescriptlang.org/)
+ * [Specifica di TypeScript](https://github.com/Microsoft/TypeScript/blob/master/doc/spec.md)
+ * [Anders Hejlsberg - Introducing TypeScript su Channel 9](http://channel9.msdn.com/posts/Anders-Hejlsberg-Introducing-TypeScript)
+ * [TypeScript su GitHub](https://github.com/Microsoft/TypeScript)
+ * [Definitely Typed - definizioni per le librerie](http://definitelytyped.org/)