Merge branch 'master' of https://github.com/torgeek/learnxinyminutes-docs

27 files changed, 5314 insertions, 515 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/bash-it.html.markdown b/it-it/bash-it.html.markdown
index efc47969..cfe58f30 100644
--- a/it-it/bash-it.html.markdown
+++ b/it-it/bash-it.html.markdown
@@ -63,7 +63,7 @@ echo ${Variabile}
 # Sotto ci sono altri esempi che analizzano l'uso dell'espansione dei parametri.
 
 # Sostituzione di stringhe nelle variabili
-echo ${Variabile/Una/A}
+echo ${Variabile/Una/La}
 # Questo sostituirà la prima occorrenza di "Una" con "La"
 
 # Sottostringa di una variabile
@@ -140,6 +140,25 @@ then
     echo "Questo verrà eseguito se $Nome è Daniya O Zach."
 fi
 
+# C'è anche l'operatore `=~`, che serve per confrontare una stringa con un'espressione regolare:
+Email=me@example.com
+if [[ "$Email" =~ [a-z]+@[a-z]{2,}\.(com|net|org) ]]
+then
+    echo "Email valida!"
+fi
+# L'operatore =~ funziona solo dentro alle doppie parentesi quadre [[ ]],
+# che hanno un comportamento leggermente diverso rispetto alle singole [ ].
+# Se vuoi approfondire, visita questo link (in inglese):
+# http://www.gnu.org/software/bash/manual/bashref.html#Conditional-Constructs
+
+# Usando `alias`, puoi definire nuovi comandi o modificare quelli già esistenti.
+# Ad esempio, così puoi ridefinire il comando ping per inviare solo 5 pacchetti
+alias ping='ping -c 5'
+# "Scavalca" l'alias e usa il comando vero, utilizzando il backslash
+\ping 192.168.1.1
+# Stampa la lista di tutti gli alias
+alias -p
+
 # Le espressioni sono nel seguente formato:
 echo $(( 10 + 5 ))
 
diff --git a/it-it/bf-it.html.markdown b/it-it/bf-it.html.markdown
index a79710d0..97e5b88e 100644
--- a/it-it/bf-it.html.markdown
+++ b/it-it/bf-it.html.markdown
@@ -1,5 +1,6 @@
 ---
 language: bf
+filename: learnbf-it.bf
 contributors:
     - ["Prajit Ramachandran", "http://prajitr.github.io/"]
     - ["Mathias Bynens", "http://mathiasbynens.be/"]
diff --git a/it-it/c++-it.html.markdown b/it-it/c++-it.html.markdown
index 4af30176..449aebfb 100644
--- a/it-it/c++-it.html.markdown
+++ b/it-it/c++-it.html.markdown
@@ -461,7 +461,7 @@ void Cane::print() const
 
 Cane::~Cane()
 {
-    cout << "Ciao ciao " << nome << "\n";
+    std::cout << "Ciao ciao " << nome << "\n";
 }
 
 int main() {
@@ -647,7 +647,7 @@ void stampaMessaggio<10>() {
 
 printMessage<20>();  // Stampa "impara il C++ in 20 minuti!"
 printMessage<10>();  // Stampa "Impara il C++ più velocemente in soli 10 minuti!"                                   
-                                        
+
 ////////////////////////////
 // Gestione delle eccezioni
 ///////////////////////////
@@ -658,7 +658,7 @@ printMessage<10>();  // Stampa "Impara il C++ più velocemente in soli 10 minuti
 #include <exception>
 #include <stdexcept>
 
-// Tutte le eccezioni lanciate all'interno del blocco _try_ possono essere catturate dai successivi 
+// Tutte le eccezioni lanciate all'interno del blocco _try_ possono essere catturate dai successivi
 // handlers _catch_.
 try {
     // Non allocare eccezioni nello heap usando _new_.
@@ -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/elixir-it.html.markdown b/it-it/elixir-it.html.markdown
index 60301b1a..48afe0c8 100644
--- a/it-it/elixir-it.html.markdown
+++ b/it-it/elixir-it.html.markdown
@@ -24,7 +24,7 @@ e molte altre funzionalità.
 # Per usare la shell di elixir usa il comando `iex`.
 # Compila i tuoi moduli con il comando `elixirc`.
 
-# Entrambi i comandi dovrebbero già essere nel tuo PATH se hai installato 
+# Entrambi i comandi dovrebbero già essere nel tuo PATH se hai installato
 # elixir correttamente.
 
 ## ---------------------------
@@ -65,7 +65,7 @@ coda #=> [2,3]
 # le tuple hanno dimensione differente.
 # {a, b, c} = {1, 2} #=> ** (MatchError) no match of right hand side value: {1,2}
 
-# Ci sono anche i binari 
+# Ci sono anche i binari
 <<1,2,3>> # binari (Binary)
 
 # Stringhe e liste di caratteri
@@ -80,7 +80,7 @@ multi-linea.
 #=> "Sono una stringa\nmulti-linea.\n"
 
 # Le stringhe sono tutte codificate in UTF-8:
-"cìaò" 
+"cìaò"
 #=> "cìaò"
 
 # le stringhe in realtà sono dei binari, e le liste di caratteri sono liste.
@@ -124,10 +124,11 @@ rem(10, 3) #=> 1
 # Questi operatori si aspettano un booleano come primo argomento.
 true and true #=> true
 false or true #=> true
-# 1 and true    #=> ** (ArgumentError) argument error
+# 1 and true
+#=> ** (BadBooleanError) expected a boolean on left-side of "and", got: 1
 
 # Elixir fornisce anche `||`, `&&` e `!` che accettano argomenti
-# di qualsiasi tipo. 
+# di qualsiasi tipo.
 # Tutti i valori tranne `false` e `nil` saranno valutati come true.
 1 || true  #=> 1
 false && 1 #=> false
@@ -147,7 +148,7 @@ nil && 20  #=> nil
 1 < :ciao #=> true
 
 # L'ordine generale è definito sotto:
-# numeri < atomi < riferimenti < funzioni < porte < pid < tuple < liste 
+# numeri < atomi < riferimenti < funzioni < porte < pid < tuple < liste
 #   < stringhe di bit
 
 # Per citare Joe Armstrong su questo: "L'ordine non è importante,
@@ -171,7 +172,7 @@ else
   "Questo sì"
 end
 
-# Ti ricordi il pattern matching? 
+# Ti ricordi il pattern matching?
 # Moltre strutture di controllo di flusso in elixir si basano su di esso.
 
 # `case` ci permette di confrontare un valore a diversi pattern:
@@ -214,7 +215,7 @@ cond do
     "Questa sì! (essenzialmente funziona come un else)"
 end
 
-# `try/catch` si usa per gestire i valori lanciati (throw), 
+# `try/catch` si usa per gestire i valori lanciati (throw),
 # Supporta anche una clausola `after` che è invocata in ogni caso.
 try do
   throw(:ciao)
@@ -235,7 +236,7 @@ quadrato = fn(x) -> x * x end
 quadrato.(5) #=> 25
 
 # Accettano anche guardie e condizioni multiple.
-# le guardie ti permettono di perfezionare il tuo pattern matching, 
+# le guardie ti permettono di perfezionare il tuo pattern matching,
 # sono indicate dalla parola chiave `when`:
 f = fn
   x, y when x > 0 -> x + y
@@ -265,13 +266,13 @@ end
 Matematica.somma(1, 2)  #=> 3
 Matematica.quadrato(3) #=> 9
 
-# Per compilare il modulo 'Matematica' salvalo come `matematica.ex` e usa 
+# Per compilare il modulo 'Matematica' salvalo come `matematica.ex` e usa
 # `elixirc`.
 # nel tuo terminale: elixirc matematica.ex
 
 # All'interno di un modulo possiamo definire le funzioni con `def` e funzioni
 # private con `defp`.
-# Una funzione definita con `def` è disponibile per essere invocata anche da 
+# Una funzione definita con `def` è disponibile per essere invocata anche da
 # altri moduli, una funziona privata può essere invocata solo localmente.
 defmodule MatematicaPrivata do
   def somma(a, b) do
@@ -286,7 +287,11 @@ end
 MatematicaPrivata.somma(1, 2)    #=> 3
 # MatematicaPrivata.esegui_somma(1, 2) #=> ** (UndefinedFunctionError)
 
-# Anche le dichiarazioni di funzione supportano guardie e condizioni multiple:
+# Anche le dichiarazioni di funzione supportano guardie e condizioni multiple.
+# Quando viene chiamata una funzione dichiarata con più match, solo la prima
+# che matcha viene effettivamente invocata.
+# Ad esempio: chiamando area({:cerchio, 3}) vedrà invocata la seconda definizione
+# di area mostrata sotto, non la prima:
 defmodule Geometria do
   def area({:rettangolo, w, h}) do
     w * h
@@ -322,16 +327,25 @@ defmodule Modulo do
   Questo è un attributo incorporato in un modulo di esempio.
   """
 
-  @miei_dati 100 # Questo è un attributo personalizzato .
+  @miei_dati 100 # Questo è un attributo personalizzato.
   IO.inspect(@miei_dati) #=> 100
 end
 
+# L'operatore pipe |> permette di passare l'output di una espressione
+# come primo parametro di una funzione.
+# Questo facilita operazioni quali pipeline di operazioni, composizione di
+# funzioni, ecc.
+Range.new(1,10)
+|> Enum.map(fn x -> x * x end)
+|> Enum.filter(fn x -> rem(x, 2) == 0 end)
+#=> [4, 16, 36, 64, 100]
+
 ## ---------------------------
 ## -- Strutture ed Eccezioni
 ## ---------------------------
 
 
-# Le Strutture (Structs) sono estensioni alle mappe che portano 
+# Le Strutture (Structs) sono estensioni alle mappe che portano
 # valori di default, garanzia alla compilazione e polimorfismo in Elixir.
 defmodule Persona do
   defstruct nome: nil, eta: 0, altezza: 0
@@ -367,7 +381,7 @@ end
 ## -- Concorrenza
 ## ---------------------------
 
-# Elixir si basa sul modello degli attori per la concorrenza. 
+# Elixir si basa sul modello degli attori per la concorrenza.
 # Tutto ciò di cui abbiamo bisogno per scrivere programmi concorrenti in elixir
 # sono tre primitive: creare processi, inviare messaggi e ricevere messaggi.
 
@@ -379,12 +393,12 @@ spawn(f) #=> #PID<0.40.0>
 # `spawn` restituisce un pid (identificatore di processo). Puoi usare questo
 # pid per inviare messaggi al processo.
 # Per passare messaggi si usa l'operatore `send`.
-# Perché tutto questo sia utile dobbiamo essere capaci di ricevere messaggi, 
+# Perché tutto questo sia utile dobbiamo essere capaci di ricevere messaggi,
 # oltre ad inviarli. Questo è realizzabile con `receive`:
 
 # Il blocco `receive do` viene usato per mettersi in ascolto di messaggi
 # ed elaborarli quando vengono ricevuti. Un blocco `receive do` elabora
-# un solo messaggio ricevuto: per fare elaborazione multipla di messaggi, 
+# un solo messaggio ricevuto: per fare elaborazione multipla di messaggi,
 # una funzione con un blocco `receive do` al suo intero dovrà chiamare
 # ricorsivamente sé stessa per entrare di nuovo nel blocco `receive do`.
 defmodule Geometria do
@@ -405,7 +419,7 @@ pid = spawn(fn -> Geometria.calcolo_area() end) #=> #PID<0.40.0>
 # Alternativamente
 pid = spawn(Geometria, :calcolo_area, [])
 
-# Invia un messaggio a `pid` che farà match su un pattern nel blocco in receive 
+# Invia un messaggio a `pid` che farà match su un pattern nel blocco in receive
 send pid, {:rettangolo, 2, 3}
 #=> Area = 6
 #   {:rettangolo,2,3}
@@ -421,7 +435,7 @@ self() #=> #PID<0.27.0>
 ## Referenze
 
 * [Getting started guide](http://elixir-lang.org/getting_started/1.html) dalla [pagina web ufficiale di elixir](http://elixir-lang.org)
-* [Documentazione Elixir](http://elixir-lang.org/docs/master/)
+* [Documentazione Elixir](https://elixir-lang.org/docs.html)
 * ["Programming Elixir"](https://pragprog.com/book/elixir/programming-elixir) di Dave Thomas
 * [Elixir Cheat Sheet](http://media.pragprog.com/titles/elixir/ElixirCheat.pdf)
 * ["Learn You Some Erlang for Great Good!"](http://learnyousomeerlang.com/) di Fred Hebert
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
new file mode 100644
index 00000000..8f7391a2
--- /dev/null
+++ b/it-it/html-it.html.markdown
@@ -0,0 +1,121 @@
+---
+language: html
+filename: learnhtml-it.txt
+contributors:
+    - ["Christophe THOMAS", "https://github.com/WinChris"]
+translators:
+    - ["Ale46", "http://github.com/Ale46/"]
+lang: it-it
+---
+
+HTML sta per HyperText Markup Language (linguaggio a marcatori per ipertesti).
+È un linguaggio che consente di scrivere pagine web per il world wide web.
+È un linguaggio di markup, che permette di scrivere pagine web usando del codice che indica come il testo ed i dati devono essere mostrati.
+Infatti, i files html sono semplici file di testo.
+Cos'è il markup? È un metodo per organizzare i dati della pagina circondandoli con tag di apertura e tag di chiusura.
+Questo markup serve a dare significato al testo che racchiude.
+Come altri linguaggi di programmazione, HTML ha molte versioni. Qui discuteremo di HTML5.
+
+**NOTA :**  Puoi testare i differenti tags ed elementi man mano che prosegui nel tutorial in un sito come [codepen](http://codepen.io/pen/) per vedere i loro effetti, capire come lavorano e familiarizzare con il linguaggio.
+Questo articolo riguarda principalmente la sintassi HTML ed alcuni suggerimenti utili.
+
+
+```html
+<!-- I commenti sono racchiusi come in questa riga! -->
+
+<!-- #################### I Tags #################### -->
+
+<!-- Ecco un esempio di file HTML che andremo ad analizzare. -->
+
+<!doctype html>
+	<html>
+		<head>
+			<title>Il mio sito</title>
+		</head>
+		<body>
+			<h1>Ciao, mondo!</h1>
+			<a href = "http://codepen.io/anon/pen/xwjLbZ">Vieni a vedere ciò che mostra</a>
+			<p>Questo è un paragrafo.</p>
+			<p>Questo è un altro paragrafo.</p>
+			<ul>
+				<li>Questo è un elemento di un elenco non numerato (elenco puntato)</li>
+				<li>Questo è un altro elemento</li>
+				<li>E questo è l'ultimo elemento dell'elenco</li>
+			</ul>
+		</body>
+	</html>
+
+<!-- Un file HTML inizia sempre indicando al browser che la pagina è HTML. -->
+<!doctype html>
+
+<!-- Dopo questo, inizia aprendo un tag <html>. -->
+<html>
+
+<!-- che sarà chiuso alla fine del file con </html>. -->
+</html>
+
+<!-- Nulla dovrebbe apparire dopo questo tag finale. -->
+
+<!-- All'interno (tra i tag di apertura e chiusura <html> </html>) troviamo: -->
+
+<!-- Un'intestazione definita da <head> (deve essere chiusa con </head>). -->
+<!-- L'intestazione contiene alcune descrizioni e informazioni aggiuntive non visualizzate; questi sono i metadati. -->
+
+<head>
+	<title>Il mio sito</title> <!-- Il tag <title> indica al browser il titolo da mostrare nella barra del titolo della finestra del browser e nel nome della scheda. -->
+</head>
+
+<!-- Dopo la sezione <head>, troviamo il tag - <body> -->
+<!-- Fino a questo punto, niente di ciò che abbiamo descritto verrà visualizzato nella finestra del browser. -->
+<!-- Dobbiamo riempire il corpo con il contenuto da visualizzare. -->
+
+<body>
+	<h1>Ciao, mondo!</h1> <!-- Il tag h1 crea un titolo. -->
+	<!-- Ci sono anche sottotitoli a <h1> dal più importante (h2) al più preciso (h6). -->
+	<a href = "http://codepen.io/anon/pen/xwjLbZ">Vieni a vedere ciò che mostra</a> <!-- un collegamento ipertestuale all'URL fornito dall'attributo href="" -->
+	<p>Questo è un paragrafo.</p> <!-- Il tag <p> ci permette di includere del testo nella pagina html. -->
+	<p>Questo è un altro paragrafo.</p>
+	<ul> <!-- Il tag <ul> crea un elenco puntato. -->
+	<!-- Per avere un elenco numerato, invece, usiamo <ol> che restituisce 1. per il primo elemento, 2. per il secondo, etc. -->
+		<li>Questo è un elemento in un elenco non elencato (elenco puntato)</li>
+		<li>Questo è un altro elemento</li>
+		<li>E questo è l'ultimo elemento dell'elenco</li>
+	</ul>
+</body>
+
+<!-- E questo è tutto, creare un file HTML può essere molto semplice. -->
+
+<!-- Ma è possibile aggiungere molti altri tipi di tag HTML. -->
+
+<!-- Per inserire un'immagine. -->
+<img src="http://i.imgur.com/XWG0O.gif"/> <!-- La fonte dell'immagine viene indicata usando l'attributo src="" -->
+<!-- La fonte può essere un URL o persino un percorso di un file sul tuo computer. -->
+
+<!-- È anche possibile creare una tabella. -->
+
+<table> <!-- Apriamo un elemento <table>. -->
+	<tr> <!-- <tr> ci permette di creare una riga. -->
+		<th>Prima intestazione</th> <!-- <th> ci permette di dare un titolo ad una colonna della tabella. -->
+		<th>Seconda intestazione</th>
+	</tr>
+	<tr>
+		<td>prima riga, prima colonna</td> <!-- <td> ci permette di creare una cella della tabella. -->
+		<td>prima riga, seconda colonna</td>
+	</tr>
+	<tr>
+		<td>seconda riga, prima colonna</td>
+		<td>seconda riga, seconda colonna</td>
+	</tr>
+</table>
+
+```
+
+## Uso
+
+HTML è scritto in files che finiscono con `.html` o `.htm`. Il "MIME type" è `text/html`.
+
+## Per saperne di più
+
+* [wikipedia](https://it.wikipedia.org/wiki/HTML)
+* [HTML tutorial](https://developer.mozilla.org/it/docs/Web/HTML)
+* [W3School](http://www.w3schools.com/html/html_intro.asp)
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..1d776535
--- /dev/null
+++ b/it-it/javascript-it.html.markdown
@@ -0,0 +1,617 @@
+---
+language: javascript
+contributors:
+    - ["Leigh Brenecki", "https://leigh.net.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/json-it.html.markdown b/it-it/json-it.html.markdown
index 379bad73..e1e16c42 100644
--- a/it-it/json-it.html.markdown
+++ b/it-it/json-it.html.markdown
@@ -1,5 +1,6 @@
 ---
 language: json
+filename: learnjson-it.json
 contributors:
   - ["Anna Harren", "https://github.com/iirelu"]
   - ["Marco Scannadinari", "https://github.com/marcoms"]
diff --git a/it-it/logtalk-it.html.markdown b/it-it/logtalk-it.html.markdown
new file mode 100644
index 00000000..5cc53e6f
--- /dev/null
+++ b/it-it/logtalk-it.html.markdown
@@ -0,0 +1,553 @@
+---
+language: Logtalk
+filename: learnlogtalk-it.lgt
+contributors:
+    - ["Paulo Moura", "http://github.com/pmoura"]
+translators:
+    - ["Ugo Chirico", "https://github.com/ugochirico"]
+lang: it-it
+---
+
+Logtalk è un linguaggio di programmazione logica orientata agli oggetti che estende il linguaggio Prolog con le moderne tecniche di Object-Oriented Programming quali incapsulamento, ereditarietà e riutilizzo del codice, senza compromettere le caratteristiche di programmazione dichiarativa del Prolog. Logtalk è implementato in codice altamente portabile e utilizza i più moderni standard di conformità del Prolog rispetto al compilatore backend.
+
+Per mantenere una dimensione ragionevole, questo tutorial presuppone necessariamente che il lettore abbia una conoscenza del linguaggio Prolog ed è inoltre focalizzato esclusivamente sulla descrizione delle caratteristiche object-oriented di Logtalk.
+
+# Sintassi
+
+Logtalk utilizza la sintassi standard del linguaggio Prolog con l'aggiunta di un paio di operatori e di alcune direttive per una curva di apprendimento morbida e per assicurare ampia portabilità. Una conseguenza importante è che il codice Prolog può essere facilmente incapsulato in oggetti con poche o nessuna modifica. Inoltre, Logtalk può interpretare come oggetti Logtalk, in modo trasparente, la maggior parte dei moduli Prolog già esistenti.
+
+I principali operatori sono:
+
+* `::/2` - per inviare un messaggio ad un oggetto
+* `::/1` - per inviare un messaggio a se stesso _self_ (cioè all'oggetto che riceverà il messaggio)
+* `^^/1` - _super_ per chiamare un predicato ereditato o importato
+
+Alcune delle più importanti entità e direttive saranno introdotte nelle sezioni successive.
+
+# Entità e Ruoli
+
+Logtalk tratta gli oggetti, i protocolli e le categorie come entità di prima classe. I rapporti tra le entità definiscono i _patterns of code reuse_ ossia i modelli di riutilizzo del codice e i  _roles_ ossia i ruoli svolti da tali entità. Ad esempio, quando un oggetto istanzia un altro oggetto, il primo oggetto assume il ruolo di istanza e il secondo oggetto assume il ruolo di classe. Una relazione di tipo _extends_ tra due oggetti implica che entrambi gli oggetti svolgano il ruolo di prototipi, in cui uno di loro estende l'altro, che diventa quindi suo prototipo padre.
+
+# Definizione di un oggetto
+
+Un oggetto incapsula le dichiarazioni e le definizioni dei predicati. Gli oggetti possono essere creati in modo dinamico, ma di solito sono dichiarati come statici e definiti nel codice sorgente. Un singolo file sorgente può contenere un qualsiasi numero di definizioni di entità. Ecco un semplice oggetto `list` che definisce un membro pubblico `member/2`:
+
+```logtalk
+:- object(list).
+
+	:- public(member/2).
+	member(Head, [Head| _]).
+	member(Head, [_| Tail]) :-
+		member(Head, Tail).
+
+:- end_object.
+```
+
+# 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):
+
+```logtalk
+?- {list}.
+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:
+
+```logtalk
+?- list::member(X, [1,2,3]).
+X = 1 ;
+X = 2 ;
+X = 3
+yes
+```
+
+Analogamente alla programmazione object-oriented, logtalk consente anche l'Incapsulamento. 
+Un predicato può essere dichiarata pubblico, protetto o privato. Può anche essere _local_ quando non esiste una direttiva specifica per esso all'interno dello scope. Per esempio:
+
+```logtalk
+:- object(scopes).
+
+	:- private(bar/0).
+	bar.
+
+	local.
+
+:- end_object.
+```
+
+Assumendo che l'oggetto è salvato nel file `scopes.lgt`:
+
+```logtalk
+?- {scopes}.
+yes
+
+?- catch(scopes::bar, Error, true).
+Error = error(
+	permission_error(access, private_predicate, bar/0),
+	logtalk(scopes::bar, user)
+)
+yes
+
+?- catch(scopes::local, Error, true).
+Error = error(
+	existence_error(predicate_declaration, local/0),
+	logtalk(scopes::local, user)
+)
+yes
+```
+
+Quando il predicato in un messaggio non è noto per l'oggetto (il ruolo dell'oggetto determina le procedure di ricerca), si ha un errore.
+Per esempio:
+
+```logtalk
+?- catch(scopes::unknown, Error, true).
+Error = error(
+	existence_error(predicate_declaration, unknown/0),
+	logtalk(scopes::unknown, user)
+)
+yes
+```
+
+Un punto fondamentale da capire è che le direttive che specificano il predicato nello scope specificano la semantica di chiamata (_calling_) del predicato, e non la semantica di definizione (_definition_). Ad esempio, se un oggetto ha il ruolo di una classe e dichiara un predicato privato, tale predicato può essere definito nelle sue sottoclassi e nelle istanze * ma * può essere chiamato solo nelle sue istanza (_from_) dalla classe.
+
+# Definizione e implementazione di un protocollo
+
+Un Protocollo contiene le dichiarazioni dei predicati che possono essere implementati da un qualsivoglia numero di oggetti e categorie:
+
+```logtalk
+:- protocol(listp).
+
+	:- public(member/2).
+
+:- end_protocol.
+
+:- object(list,
+	implements(listp)).
+
+	member(Head, [Head| _]).
+	member(Head, [_| Tail]) :-
+		member(Head, Tail).
+
+:- end_object.
+```
+
+Lo scope dei predicati di un protocollo può essere ristretto usando implementazioni protected e private. Ad esempio:
+
+```logtalk
+:- object(stack,
+	implements(private::listp)).
+
+:- end_object.
+```
+
+Difatti, tutte le relazioni tra entità (nella direttiva di apertura di un entità) possono essere definite come public (default), protected, o private.
+
+# Prototipi
+
+Un oggetto senza una istanza o senza una relazione di specializzazione con un altro oggetto interpreta il ruolo di prototipo. Un prototipo può estendere un altro oggetto, il suo prototipo genitore.
+
+```logtalk
+% clyde, our prototypical elephant
+:- object(clyde).
+
+	:- public(color/1).
+	color(grey).
+
+	:- public(number_of_legs/1).
+	number_of_legs(4).
+
+:- end_object.
+
+% fred, another elephant, is like clyde, except that he's white
+:- object(fred,
+	extends(clyde)).
+
+	color(white).
+
+:- end_object.
+```
+
+Per rispondere ad un messaggio inviato ad un oggetto che ha il ruolo di prototipo, si cerca prima una risposta nel prototipo stesso e se il prototipo non sa rispondere si passa all'eventuale prototipo genitore (se esiste):
+
+```logtalk
+?- fred::number_of_legs(N).
+N = 4
+yes
+
+?- fred::color(C).
+C = white
+yes
+```
+
+Un messaggio è valido se il relativo predicato è dichiarato in un oggetto (e se il mittente è nel campo di applicazione), ma fallirà, piuttosto che lanciare un errore, se il predicato non è definito. Questa è chiamata la _closed-world assumption_. Ad esempio, si consideri il seguente oggetto, salvato in un file `foo.lgt`:
+
+```logtalk
+:- object(foo).
+
+	:- public(bar/0).
+
+:- end_object.
+```
+
+Caricando il file e cercando di chiamare il predicato `bar/0` questo fallisce come previsto. Si noti che ciò è diverso dal chiamare un predicato sconosciuto _unknown_, che invece genera un errore:
+
+```logtalk
+?- {foo}.
+yes
+
+?- foo::bar.
+no
+
+?- catch(foo::baz, Error, true).
+Error = error(
+	existence_error(predicate_declaration, baz/0),
+	logtalk(foo::baz, user)
+)
+yes
+```
+
+# Classi e istanze
+
+Per definire gli oggetti nei ruoli di classi e/o istanze, un oggetto deve avere almeno un istanziazione o una relazione di specializzazione con un altro oggetto. Gli oggetti che hanno il ruolo di meta-classi possono essere utilizzati quando abbiamo bisogno di usare una classe come se fosse un'istanza. Il seguente esempio mostra come creare dinamicamente nuovi oggetti in fase di esecuzione:
+
+```logtalk
+% a simple, generic, metaclass defining a new/2 predicate for its instances
+:- object(metaclass,
+	instantiates(metaclass)).
+
+	:- public(new/2).
+	new(Instance, Clauses) :-
+		self(Class),
+		create_object(Instance, [instantiates(Class)], [], Clauses).
+
+:- end_object.
+
+% a simple class defining age/1 and name/1 predicate for its instances
+:- object(person,
+	instantiates(metaclass)).
+
+	:- public([
+		age/1, name/1
+	]).
+
+	% a default value for age/1
+	age(42).
+
+:- end_object.
+
+% a static instance of the class person
+:- object(john,
+	instantiates(person)).
+
+	name(john).
+	age(12).
+
+:- end_object.
+```
+
+Nel rispondere ad un messaggio inviato ad un oggetto ha assunto il ruolo di istanza, tal messaggio viene convalidato partendo dalla sua classe e andando a ritroso nella gerarchia, se necessario, fino alle sue superclassi. Supponendo che il messaggio sia valido, allora si cerca una risposta a partire dall'istanza stessa:
+
+```logtalk
+?- person::new(Instance, [name(paulo)]).
+Instance = o1
+yes
+
+?- o1::name(Name).
+Name = paulo
+yes
+
+?- o1::age(Age).
+Age = 42
+yes
+
+?- john::age(Age).
+Age = 12
+yes
+```
+
+# Categorie
+
+Una categoria è un'unità atomica di codice riutilizzabile. Una categoria è usata per incapsulare una insieme coesivo (_cohesive_) di dichiarazioni e di definizioni di predicato ed è atta ad implementare una singola (_single_) funzionalità che può essere importata in qualsiasi oggetto. Una categoria può quindi essere concepita come il concetto duale di protocollo. Nel seguente esempio, si definiscono prima le categorie che rappresentano i motori di auto e poi si importano tali categorie negli oggetti auto:
+
+```logtalk
+% a protocol describing engine characteristics
+:- protocol(carenginep).
+
+	:- public([
+		reference/1,
+		capacity/1,
+		cylinders/1,
+		horsepower_rpm/2,
+		bore_stroke/2,
+		fuel/1
+	]).
+
+:- end_protocol.
+
+% a typical engine defined as a category
+:- category(classic,
+	implements(carenginep)).
+
+	reference('M180.940').
+	capacity(2195).
+	cylinders(6).
+	horsepower_rpm(94, 4800).
+	bore_stroke(80, 72.8).
+	fuel(gasoline).
+
+:- end_category.
+
+% a souped up version of the previous engine
+:- category(sport,
+	extends(classic)).
+
+	reference('M180.941').
+	horsepower_rpm(HP, RPM) :-
+		^^horsepower_rpm(ClassicHP, ClassicRPM),	% "super" call
+		HP is truncate(ClassicHP*1.23),
+		RPM is truncate(ClassicRPM*0.762).
+
+:- end_category.
+
+% with engines (and other components), we may start "assembling" some cars
+:- object(sedan,
+	imports(classic)).
+
+:- end_object.
+
+:- object(coupe,
+	imports(sport)).
+
+:- end_object.
+```
+
+Le Categorie sono compilate in modo indipendente e, quindi, consentono l'importazione di oggetti da aggiornare mediante il semplice aggiornamento delle categorie importate, senza richiedere pertanto la ricompilazione dell'oggetto. Le Categorie forniscono anche la _runtime transparency_,  cioè il protocollo della categoria si aggiunge al protocollo degli oggetti che importano tale categoria:
+
+```logtalk
+?- sedan::current_predicate(Predicate).
+Predicate = reference/1 ;
+Predicate = capacity/1 ;
+Predicate = cylinders/1 ;
+Predicate = horsepower_rpm/2 ;
+Predicate = bore_stroke/2 ;
+Predicate = fuel/1
+yes
+```
+
+# Hot patching
+
+Le categorie possono essere anche usate per modificare gli oggetti al volo (_hot-patch_). Una categoria può aggiungere nuovi predicati ad un oggetto e/o sostituire le definizioni dei predicati dell'oggetto. Ad esempio, si consideri il seguente oggetto:
+
+```logtalk
+:- object(buggy).
+
+	:- public(p/0).
+	p :- write(foo).
+
+:- end_object.
+```
+
+Si supponga che l'oggetto stampi la stringa sbagliata quando riceve il messaggio `p/0`:
+
+```logtalk
+?- {buggy}.
+yes
+
+?- buggy::p.
+foo
+yes
+```
+
+Se il codice sorgente dell'oggetto non è disponibile e bisogna correggere l'applicazione che sta eseguendo il codice dell'oggetto, si può semplicemente definire una categoria che corregge il predicato non corretto:
+
+```logtalk
+:- category(patch,
+	complements(buggy)).
+
+	% fixed p/0 def
+	p :- write(bar).
+
+:- end_category.
+```
+
+Dopo la compilazione e il caricamento della categoria nell'applicazione in esecuzione si ottiene:
+
+```logtalk
+?- {patch}.
+yes
+
+?- buggy::p.
+bar
+yes
+```
+
+Poiché l'hot-patching pregiudica forzatamente l'incapsulamento, un apposito flag di compilazione `complementary` può essere impostato (a livello globale o per un singolo oggetto) per consentire, limitare o prevenire l'hot-patching.
+
+# Oggetti Parametrici e Categorie
+
+Gli oggetti e le categorie possono essere parametrizzati utilizzando come identificativo un compound-term al posto di un atomo. Oggetti e parametri di una categoria sono variabili logiche _logical variables_ condivise con tutti i predicati incapsulati. Ecco un esempio con cerchi geometrici:
+
+```logtalk
+:- object(circle(_Radius, _Color)).
+
+	:- public([
+		area/1, perimeter/1
+	]).
+
+	area(Area) :-
+		parameter(1, Radius),
+		Area is pi*Radius*Radius.
+
+	perimeter(Perimeter) :-
+		parameter(1, Radius),
+		Perimeter is 2*pi*Radius.
+
+:- end_object.
+```
+
+Oggetti parametrici possono essere utilizzati come qualsiasi altro oggetto e di solito forniscono i valori da assegnare ai parametri quando si invia un messaggio:
+
+```logtalk
+?- circle(1.23, blue)::area(Area).
+Area = 4.75291
+yes
+```
+
+Gli oggetti parametrici forniscono anche un modo semplice per associare un insieme di predicati con un semplice predicato Prolog. Fatti Prolog possono essere interpretati come oggetti proxy parametrici ( _parametric object proxies_) quando hanno lo stesso funtore e arietà degli identificatori di oggetti parametrici. Per lavorare con i proxy viene fornita una sintassi maneggevole. Per esempio, si prendano le seguenti clausole per il predicato `circle/2`:
+
+```logtalk
+circle(1.23, blue).
+circle(3.71, yellow).
+circle(0.39, green).
+circle(5.74, black).
+circle(8.32, cyan).
+```
+
+Con queste clausole, si può facilmente calcolare, ad esempio, un elenco con le aree di tutti i cerchi:
+
+```logtalk
+?- findall(Area, {circle(_, _)}::area(Area), Areas).
+Areas = [4.75291, 43.2412, 0.477836, 103.508, 217.468]
+yes
+```
+
+In pratica, il costrutto `{Goal}::Message` prova il goal `Goal`, instanziando le variabili interne e inviando un messaggio `Message` al termine risultante.
+
+# Eventi and monitor
+
+Logtalk supporta l'_event-driven programming_ mediante la definizione di eventi e di monitor. Un evento è semplicemente l'invio di un messaggio ad un oggetto. Un monitor è un gestore di un evento. L'evento (con l'invio di un messaggio) è un'attività atomica, ed è preceduta da un evento _before_ e da un evento _after_. Il monitor gestisce tali eventi mediante i predicati, `before/3` e `after/3`, che sono chiamati rispettivamente prima e dopo il verificarsi dell'evento. Un monitor può inoltre interrogare, registrare e cancellare un evento nel registro eventi a livello di sistema il quale che associa gli eventi con i monitor. Ad esempio, un semplice tracer per ogni messaggio inviato utilizzando il costrutto `::/2` può essere definito come:
+
+```logtalk
+:- object(tracer,
+	implements(monitoring)).    % built-in protocol for event handlers
+
+	:- initialization(define_events(_, _, _, _, tracer)).
+
+	before(Object, Message, Sender) :-
+		write('call: '), writeq(Object), write(' <-- '), writeq(Message),
+		write(' from '), writeq(Sender), nl.
+
+	after(Object, Message, Sender) :-
+		write('exit: '), writeq(Object), write(' <-- '), writeq(Message),
+		write(' from '), writeq(Sender), nl.
+
+:- end_object.
+```
+
+Supponendo che l'oggetto `tracer` e l'oggetto `list` definito in precedenza siano stati già compilati e caricati, si possono osservare i gestori di eventi in azione durante l'invio di un messaggio:
+
+```logtalk
+?- list::member(X, [1,2,3]).
+
+call: list <-- member(X, [1,2,3]) from user
+exit: list <-- member(1, [1,2,3]) from user
+X = 1 ;
+exit: list <-- member(2, [1,2,3]) from user
+X = 2 ;
+exit: list <-- member(3, [1,2,3]) from user
+X = 3
+yes
+```
+
+Gli eventi possono essere impostati e cancellati dinamicamente in fase di esecuzione chiamando i predicati predefiniti `define_events/5` e` abolish_events/5` .
+
+La programmazione event-driven può essere vista come una forma di _computational reflection_. Si noti però che gli eventi sono generati solo quando si utilizza il costrutto di controllo per l'invio di messaggi `::/2`.
+
+# Espressioni lambda
+
+Logtalk supporta anche le espressioni lambda. I parametri della espressioni lambda sono rappresentati mediante una lista con l'operatore infisso `(>>)/2` che collega i parametri alla relativa lambda espressione. Ecco alcuni semplici esempi di che usano i meta-predicati.
+
+
+```logtalk
+?- {library(metapredicates_loader)}.
+yes
+
+?- meta::map([X,Y]>>(Y is 2*X), [1,2,3], Ys).
+Ys = [2,4,6]
+yes
+```
+
+Logtalk supporta anche il _currying_:
+
+```logtalk
+?- meta::map([X]>>([Y]>>(Y is 2*X)), [1,2,3], Ys).
+Ys = [2,4,6]
+yes
+```
+
+Infine, le variabili libere Lambda possono essere espresso usando la sintassi estesa `{Free1, ...}/[Parameter1, ...]>>Lambda`.
+
+# Macro
+
+I Termini e goal nel file sorgente possono essere _estesi_ al momento della compilazione specificando una hook ad un oggetto (_hook object_) che definisce le regole di riscrittura dei termini e riscrittura dei quesiti. Ad esempio, si consideri il seguente oggetto semplice, salvato nel file `source.lgt`:
+
+```logtalk
+:- object(source).
+
+	:- public(bar/1).
+	bar(X) :- foo(X).
+
+	foo(a). foo(b). foo(c).
+
+:- end_object.
+```
+
+Si supponga il seguente hook all'oggetto, salvato nel file `my_macros.lgt`, che estende le clausole e chiama il predicato locale  `foo/1`:
+
+```logtalk
+:- object(my_macros,
+	implements(expanding)).    % built-in protocol for expanding predicates
+
+	term_expansion(foo(Char), baz(Code)) :-
+		char_code(Char, Code). % standard built-in predicate
+
+	goal_expansion(foo(X), baz(X)).
+
+:- end_object.
+```
+
+Dopo aver caricato il file contenente la macro, si può espandere il nostro file sorgente usando il flag del compilatore `hook`:
+
+```logtalk
+?- logtalk_load(my_macros), logtalk_load(source, [hook(my_macros)]).
+yes
+
+?- source::bar(X).
+X = 97 ;
+X = 98 ;
+X = 99
+true
+```
+
+La libreria Logtalk fornisce infine il supporto per combinare hook agli oggetti utilizzando diversi modi (ad esempio, definendo una pipeline di espansioni).
+
+
+# Maggiori informazioni
+
+Visita il [Sito web di Logtalk (en)](http://logtalk.org) per maggiori informazioni.
diff --git a/it-it/markdown.html.markdown b/it-it/markdown.html.markdown
index b006dbb4..b0a123f1 100644
--- a/it-it/markdown.html.markdown
+++ b/it-it/markdown.html.markdown
@@ -2,41 +2,65 @@
 language: markdown
 contributors:
     - ["Dan Turkel", "http://danturkel.com/"]
+    - ["Jacob Ward", "http://github.com/JacobCWard/"]
 translators:
     - ["Jacopo Andrea Giola", "http://geekpanda.net"]
+    - ["Ale46", "https://github.com/Ale46"]
 filename: markdown-it.md
 lang: it-it
 ---
 
 Markdown è stato creato da John Gruber nel 2004. Il suo scopo è quello di essere una sintassi facile da leggere e scrivere, e che può essere convertita in HTML (ad oggi anche in molti altri formati).
 
-Mandate tutto il feedback che volete! / Sentitevi liberi di forkare o di mandare pull request!
-
+Markdown varia nelle sue implementazioni da un parser all'altro. Questa guida cercherà di chiarire quali caratteristiche esistono a livello globale o quando sono disponibili solo per un determinato parser.
+
+- [Elementi HTML](#elementi-html)
+- [Titoli](#titoli)
+- [Stili di testo semplici](#stili-di-testo-semplici)
+- [Paragrafi](#paragrafi)
+- [Liste](#liste)
+- [Estratti di codice](#estratti-di-codice)
+- [Linea orizzontale](#linea-orizzontale)
+- [Links](#links)
+- [Immagini](#immagini)
+- [Miscellanea](#miscellanea)
+
+## Elementi HTML
+Markdown è un superset di HTML, quindi ogni file HTML è a sua volta un file Markdown valido.
+
+```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 
+all'interno del contenuto dell'elemento. -->
+```
 
-```markdown
-<!-- Markdown è un superset di HTML, quindi ogni file HTML è a sua volta un file Markdown valido. 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 all'interno del contenuto dell'elemento. -->
+## Titoli
 
-<!-- L'implementazione di Markdown inoltre cambia da parser a parser. In questa guida cercheremo di indicare quando una feature è universale e quando sono specifiche ad un certo parser. -->
+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
 
-<!-- Titoli -->
-<!-- Potete creare gli elementi HTML da <h1> ad <h6> facilmente, basta che inseriate un egual numero di caratteri cancelletto (#) prima del testo che volete all'interno dell'elemento -->
+```md
 # Questo è un <h1>
 ## Questo è un <h2>
 ### Questo è un <h3>
 #### Questo è un <h4>
 ##### Questo è un <h5>
 ###### Questo è un <h6>
+```
+Markdown inoltre fornisce due alternative per indicare gli elementi h1 e h2
 
-<!-- Markdown inoltre fornisce due alternative per indicare gli elementi h1 e h2 -->
+```md
 Questo è un h1
 ==============
 
 Questo è un h2
 --------------
+```
 
-<!-- Stili di testo semplici -->
-<!-- Il testo può essere stilizzato in corsivo o grassetto usando markdown -->
+## Stili di testo semplici
+Il testo può essere stilizzato in corsivo o grassetto usando markdown
 
+```md
 *Questo testo è in corsivo.*
 _Come pure questo._
 
@@ -46,30 +70,38 @@ __Come pure questo.__
 ***Questo testo è stilizzato in entrabmi i modi.***
 **_Come questo!_**
 *__E questo!__*
+```
 
-<!-- In Github Flavored Markdown, che è utilizzato per renderizzare i file markdown su
-Github, è presente anche lo stile barrato -->
+In Github Flavored Markdown, che è utilizzato per renderizzare i file markdown su Github, è presente anche lo stile barrato:
 
+```md
 ~~Questo testo è barrato.~~
+```
+## Paragrafi
 
-<!-- I paragrafi sono uno o più linee di testo addiacenti separate da una o più righe vuote. -->
+```md
+I paragrafi sono una o più linee di testo adiacenti separate da una o più righe vuote.
 
-Qeusto è un paragrafo. Sto scrivendo in un paragrafo, non è divertente?
+Questo è un paragrafo. Sto scrivendo in un paragrafo, non è divertente?
 
 Ora sono nel paragrafo 2.
 Anche questa linea è nel paragrafo 2!
 
 
 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. -->
+Se volete inserire l'elemento HTML `<br />`, potete terminare la linea con due o più spazi e poi iniziare un nuovo paragrafo.
 
+```md
 Questa frase finisce con due spazi (evidenziatemi per vederli).  
 
 C'è un <br /> sopra di me!
+```
 
-<!-- Le citazioni sono semplici da inserire, basta usare il carattere >. -->
+Le citazioni sono semplici da inserire, basta usare il carattere >.
 
+```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 `>`.
@@ -78,9 +110,12 @@ C'è un <br /> sopra di me!
 >>  di indentazione!
 > Quanto è comodo?
 
-<!-- Liste -->
-<!-- Le liste non ordinate possono essere inserite usando gli asterischi, il simbolo più o dei trattini -->
+```
 
+## Liste
+Le liste non ordinate possono essere inserite usando gli asterischi, il simbolo più o dei trattini
+
+```md
 * Oggetto
 * Oggetto
 * Altro oggetto
@@ -96,149 +131,180 @@ oppure
 - Oggetto
 - Oggetto
 - Un ultimo oggetto
+```
 
-<!-- Le liste ordinate invece, sono inserite con un numero seguito da un punto. -->
+Le liste ordinate invece, sono inserite con un numero seguito da un punto.
 
+```md
 1. Primo oggetto
 2. Secondo oggetto
 3. Terzo oggetto
+```
 
-<!-- Non dovete nemmeno mettere i numeri nell'ordine giusto, markdown li visualizzerà comunque nell'ordine corretto, anche se potrebbe non essere una buona idea. -->
+Non dovete nemmeno mettere i numeri nell'ordine giusto, markdown li visualizzerà comunque nell'ordine corretto, anche se potrebbe non essere una buona idea.
 
+```md
 1. Primo oggetto
 1. Secondo oggetto
 1. Terzo oggetto
-<!-- (Questa lista verrà visualizzata esattamente come quella dell'esempio prima) -->
+```
+(Questa lista verrà visualizzata esattamente come quella dell'esempio prima)
 
-<!-- Potete inserire anche sotto liste -->
+Potete inserire anche sotto liste
 
+```md
 1. Primo oggetto
 2. Secondo oggetto
 3. Terzo oggetto
     * Sotto-oggetto
     * Sotto-oggetto
 4. Quarto oggetto
+```
 
-<!-- Sono presenti anche le task list. In questo modo è possibile creare checkbox in HTML. -->
+Sono presenti anche le task list. In questo modo è possibile creare checkbox in HTML.
 
+```md
 I box senza la 'x' sono checkbox HTML ancora da completare.
 - [ ] Primo task da completare.
 - [ ] Secondo task che deve essere completato.
 Il box subito sotto è una checkbox HTML spuntata.
 - [x] Questo task è stato completato.
+```
+## Estratti di codice
 
-<!-- Estratti di codice -->
-<!-- Potete inserire un estratto di codice (che utilizza l'elemento <code>) indentando una linea con quattro spazi oppure con un carattere tab -->
+Potete inserire un estratto di codice (che utilizza l'elemento `<code>`) indentando una linea con quattro spazi oppure con un carattere tab.
 
+```md
     Questa è una linea di codice
     Come questa
+```
 
-<!-- Potete inoltre inserire un altro tab (o altri quattro spazi) per indentare il vostro codice -->
+Potete inoltre inserire un altro tab (o altri quattro spazi) per indentare il vostro codice
 
+```md
     my_array.each do |item|
         puts item
     end
+```
 
-<!-- Codice inline può essere inserito usando il carattere backtick ` -->
+Codice inline può essere inserito usando il carattere backtick `
 
+```md
 Giovanni non sapeva neppure a cosa servisse la funzione `go_to()`!
+```
 
-<!-- In Github Flavored Markdown, potete inoltre usare una sintassi speciale per il codice -->
-
-\`\`\`ruby <!-- In realtà dovete rimuovere i backslash, usate solo ```ruby ! -->
+In Github Flavored Markdown, potete inoltre usare una sintassi speciale per il codice
+<pre>
+<code class="highlight">&#x60;&#x60;&#x60;ruby
 def foobar
     puts "Hello world!"
 end
-\`\`\` <!-- Anche qui, niente backslash, solamente ``` -->
-
-<!-- Se usate questa sintassi, il testo non richiederà di essere indentanto, inoltre Github userà la  syntax highlighting del linguaggio specificato dopo i ``` iniziali -->
+&#x60;&#x60;&#x60;</code></pre>
+Se usate questa sintassi, il testo non richiederà di essere indentato, inoltre Github userà l'evidenziazione della sintassi del linguaggio specificato dopo i \`\`\` iniziali
 
-<!-- Linea orizzontale (<hr />) -->
-<!-- Le linee orizzontali sono inserite facilemtne usanto tre o più asterischi o trattini senza spazi consecutivi e senza spazi. -->
+## Linea orizzontale
+Le linee orizzontali (`<hr/>`) sono inserite facilmente usanto tre o più asterischi o trattini, con o senza spazi. 
 
+```md
 ***
 ---
 - - -
 ****************
+```
 
-<!-- Link -->
-<!-- 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 () -->
+## 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 ()
 
+```md
 [Cliccami!](http://test.com/)
+```
 
-<!-- Potete inoltre aggiungere al link un titolo mettendolo fra doppie apici dopo il link -->
+Potete inoltre aggiungere al link un titolo mettendolo fra doppi apici dopo il link
 
+```md
 [Cliccami!](http://test.com/ "Link a Test.com")
+```
 
-<!-- La sintassi funziona anche i path relativi. -->
+La sintassi funziona anche con i path relativi.
 
+```md
 [Vai a musica](/music/).
+```
 
-<!-- Markdown supporta inoltre anche la possibilità di aggiungere i link facendo riferimento ad altri punti del testo -->
-
+Markdown supporta inoltre anche la possibilità di aggiungere i link facendo riferimento ad altri punti del testo.
+```md
 [Apri questo link][link1] per più informazioni!
 [Guarda anche questo link][foobar] se ti va.
 
 [link1]: http://test.com/ "Bello!"
 [foobar]: http://foobar.biz/ "Va bene!"
+```
+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.
 
-<!-- Il 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 -->
-
+Esiste anche un "identificativo implicito" che vi permette di usare il testo del link come id.
+```md
 [Questo][] è un link.
 
 [Questo]: http://thisisalink.com/
+```
+Ma non è comunemente usato.
 
-<!-- Ma non è comunemente usato. -->
-
-<!-- Immagini -->
-<!-- Le immagini sono inserite come i link ma con un punto esclamativo inserito prima delle parentesi quadre! -->
+## Immagini
+Le immagini sono inserite come i link ma con un punto esclamativo inserito prima delle parentesi quadre!
 
+```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 -->
+E la modalità a riferimento funziona esattamente come ci si aspetta
 
+```md
 ![Questo è il testo alternativo.][myimage]
 
 [myimage]: relative/urls/cool/image.jpg "Se vi serve un titolo, lo mettete qui"
+```
+## Miscellanea 
+### Auto link
 
-<!-- Miscellanea -->
-<!-- Auto link -->
-
+```md
 <http://testwebsite.com/> è equivalente ad
 [http://testwebsite.com/](http://testwebsite.com/)
+```
+### Auto link per le email
 
-<!-- Auto link per le email -->
-
+```md
 <foo@bar.com>
+```
+### Caratteri di escaping
 
-<!-- Caratteri di escaping -->
-
+```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 -->
+### Combinazioni di tasti
+In Github Flavored Markdown, potete utilizzare il tag `<kbd>` per raffigurare i tasti della tastiera.
 
+```md
 Il tuo computer è crashato? Prova a premere
 <kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>Canc</kbd>
+```
 
-<!-- Tabelle -->
-<!-- Le tabelle sono disponibili solo in Github Flavored Markdown e sono leggeremente complesse, ma se proprio volete inserirle fate come segue: -->
+### Tabelle
+Le tabelle sono disponibili solo in Github Flavored Markdown e sono leggeremente complesse, ma se proprio volete inserirle fate come segue:
 
+```md
 | Col1                 | Col2     | Col3               |
 | :------------------- | :------: | -----------------: |
 | Allineato a sinistra | Centrato | Allineato a destra |
 | blah                 | blah     | blah               |
+```
+oppure, per lo stesso risultato
 
-<!-- oppure, per lo stesso risultato -->
-
+```md
 Col 1 | Col2 | Col3
 :-- | :-: | --:
 È una cosa orrenda | fatela | finire in fretta
-
-<!-- Finito! -->
-
 ```
 
+---
 Per altre informazioni, leggete il post ufficiale di John Gruber sulla sintassi [qui](http://daringfireball.net/projects/markdown/syntax) e il magnifico cheatsheet di Adam Pritchard [qui](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet).
diff --git a/it-it/matlab-it.html.markdown b/it-it/matlab-it.html.markdown
index aeb42658..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)
 
@@ -217,7 +216,7 @@ A .* B % Moltiplica ogni elemento di A per il corrispondente elemento di B
 % l'altra (il cui nome termina con m) agisce sull'intera matrice.
 exp(A) % Calcola l'esponenziale di ogni elemento
 expm(A) % Calcola la matrice esponenziale
-sqrt(A) % Calcola la radice quadrata di ogni elementotake the square root of each element
+sqrt(A) % Calcola la radice quadrata di ogni elemento
 sqrtm(A) % Trova la matrice di cui A nè è la matrice quadrata
 
 
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 71f6dc1c..de7bb0ed 100644
--- a/it-it/python-it.html.markdown
+++ b/it-it/python-it.html.markdown
@@ -1,98 +1,89 @@
 ---
-language: python
+language: Python
+filename: learnpython-it.py
 contributors:
-    - ["Louie Dinh", "http://ldinh.ca"]
-    - ["Amin Bandali", "http://aminbandali.com"]
+    - ["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"]
-filename: learnpython.py
+    - ["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
+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]
+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.
 
-Nota: questo articolo è riferito a Python 2.7 in modo specifico, ma dovrebbe andar
-bene anche per Python 2.x. Python 2.7 sta raggiungendo il "fine vita", ovvero non sarà
-più supportato nel 2020. Quindi è consigliato imparare Python utilizzando Python 3.
-Per maggiori informazioni su Python 3.x, dai un'occhiata al [tutorial di Python 3](http://learnxinyminutes.com/docs/python3/).
+Feedback sono altamente apprezzati! Potete contattarmi su [@louiedinh](http://twitter.com/louiedinh) oppure [at] [google's email service]
 
-E' possibile anche scrivere codice compatibile sia con Python 2.7 che con Python 3.x,
-utilizzando [il modulo `__future__`](https://docs.python.org/2/library/__future__.html) di Python.
-Il modulo `__future__` permette di scrivere codice in Python 3, che può essere eseguito
-utilizzando Python 2: cosa aspetti a vedere il tutorial di Python 3?
+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 commenti
+    come documentazione
 """
 
 ####################################################
 ## 1. Tipi di dati primitivi ed Operatori
 ####################################################
 
-# Hai i numeri
+# Ci sono i numeri
 3  # => 3
 
 # La matematica è quello che vi aspettereste
-1 + 1  # => 2
-8 - 1  # => 7
+1 + 1   # => 2
+8 - 1   # => 7
 10 * 2  # => 20
-35 / 5  # => 7
-
-# La divisione è un po' complicata. E' una divisione fra interi in cui viene 
-# restituito in automatico il risultato intero.
-5 / 2  # => 2
-
-# Per le divisioni con la virgola abbiamo bisogno di parlare delle variabili floats.
-2.0     # Questo è un float
-11.0 / 4.0  # => 2.75 ahhh...molto meglio
+35 / 5  # => 7.0
 
-# Il risultato di una divisione fra interi troncati positivi e negativi
-5 // 3     # => 1
-5.0 // 3.0 # => 1.0 # funziona anche per i floats
--5 // 3  # => -2
--5.0 // 3.0 # => -2.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
 
-# E' possibile importare il modulo "division" (vedi la sezione 6 di questa guida, Moduli)
-# per effettuare la divisione normale usando solo '/'.
-from __future__ import division
-11/4    # => 2.75  ...divisione normale
-11//4   # => 2 ...divisione troncata
+# Il risultato di una divisione è sempre un numero decimale (float)
+10.0 / 3  # => 3.3333333333333335
 
 # Operazione Modulo
-7 % 3 # => 1
+7 % 3  # => 1
 
 # Elevamento a potenza (x alla y-esima potenza)
-2**4 # => 16
+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
+True and False  # => False
+False or True   # => True
 
 # Note sull'uso di operatori Bool con interi
-0 and 2 #=> 0
--5 or 0 #=> -5
-0 == False #=> True
-2 == True #=> False
-1 == True #=> True
-
-# nega con not
-not True  # => False
-not False  # => True
+# 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
@@ -112,37 +103,46 @@ not False  # => True
 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!
-"Ciao " + "mondo!"  # => Ciao mondo!"
-# Le stringhe possono essere sommate anche senza '+'
-"Ciao " "mondo!"  # => Ciao mondo!"
-
-# ... oppure moltiplicate
-"Hello" * 3  # => "HelloHelloHello"
+# 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'
 
-# Per sapere la lunghezza di una stringa
+# Puoi conoscere la lunghezza di una stringa
 len("Questa è una stringa")  # => 20
 
-# Formattazione delle stringhe con %
-# Anche se l'operatore % per le stringe sarà deprecato con Python 3.1, e verrà rimosso
-# successivamente, può comunque essere utile sapere come funziona
-x = 'mela'
-y = 'limone'
-z = "La cesta contiene una %s e un %s" % (x,y)
+# .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"
 
-# Un nuovo modo per fomattare le stringhe è il metodo format.
-# Questo metodo è quello consigliato
-"{} è un {}".format("Questo", "test")
-"{0} possono essere {1}".format("le stringhe", "formattate")
-# Puoi usare delle parole chiave se non vuoi contare
-"{nome} vuole mangiare {cibo}".format(nome="Bob", cibo="lasagna")
+# 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
@@ -150,57 +150,54 @@ None  # => None
 # Non usare il simbolo di uguaglianza "==" per comparare oggetti a None
 # Usa "is" invece
 "etc" is None  # => False
-None is None  # => True
-
-# L'operatore 'is' testa l'identità di un oggetto. Questo non è
-# molto utile quando non hai a che fare con valori primitivi, ma lo è
-# quando hai a che fare con oggetti.
- 
-# Qualunque oggetto può essere usato nei test booleani
-# I seguenti valori sono considerati falsi:
-#     - None
-#     - Lo zero, come qualunque tipo numerico (quindi 0, 0L, 0.0, 0.j)
-#     - Sequenze vuote (come '', (), [])
-#     - Contenitori vuoti (tipo {}, set())
-#     - Istanze di classi definite dall'utente, che soddisfano certi criteri
-#       vedi: https://docs.python.org/2/reference/datamodel.html#object.__nonzero__
-#       
-# Tutti gli altri valori sono considerati veri: la funzione bool() usata su di loro, ritorna True.
-bool(0)  # => False
-bool("")  # => 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 di stampa
-print "Sono Python. Piacere di conoscerti!" # => Sono Python. Piacere di conoscerti!
+# 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 = raw_input("Inserisci del testo: ") # Ritorna i dati letti come stringa
-variabile_input = input("Inserisci del testo: ") # Interpreta i dati letti come codice python
-# Attenzione: bisogna stare attenti quando si usa input()
-# Nota: In python 3, input() è deprecato, e raw_input() si chiama input()
+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
-una_variabile = 5    # Convenzionalmente si usa caratteri_minuscoli_con_underscores
-una_variabile  # => 5
+# 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.
-un_altra_variabile  # Genera un errore di nome
+# 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
-# E' l'equivalente dell'operatore ternario in C
+# È l'equivalente dell'operatore ternario in C
 "yahoo!" if 3 > 2 else 2  # => "yahoo!"
 
-# Liste immagazzinano sequenze
+# Le liste immagazzinano sequenze
 li = []
 # Puoi partire con una lista pre-riempita
-altra_li = [4, 5, 6]
+other_li = [4, 5, 6]
 
-# Aggiungi cose alla fine di una lista con append
+# 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]
@@ -212,14 +209,10 @@ li.append(3)    # li ora è [1, 2, 4, 3] di nuovo.
 
 # Accedi ad una lista come faresti con un array
 li[0]  # => 1
-# Assegna nuovo valore agli indici che sono già stati inizializzati con =
-li[0] = 42
-li[0]  # => 42
-li[0] = 1  # Nota: è resettato al valore iniziale
 # Guarda l'ultimo elemento
 li[-1]  # => 3
 
-# Guardare al di fuori dei limiti è un IndexError
+# Guardare al di fuori dei limiti genera un IndexError
 li[4]  # Genera IndexError
 
 # Puoi guardare gli intervalli con la sintassi slice (a fetta).
@@ -236,14 +229,11 @@ 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]
-# Puoi sommare le liste
-li + altra_li   # => [1, 2, 3, 4, 5, 6]
-# Nota: i valori per li ed altra_li non sono modificati.
-
-# Concatena liste con "extend()"
-li.extend(altra_li)   # Ora li è [1, 2, 3, 4, 5, 6]
 
 # Rimuove la prima occorrenza di un elemento
 li.remove(2)  # Ora li è [1, 3, 4, 5, 6]
@@ -252,10 +242,17 @@ 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
+ 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
 
@@ -263,93 +260,112 @@ li.index(7)  # Emette un ValueError, poichè 7 non è contenuto nella lista
 len(li)   # => 6
 
 
-# Tuple sono come le liste ma immutabili.
+# Le tuple sono come le liste ma immutabili.
 tup = (1, 2, 3)
-tup[0]   # => 1
+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
+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 and c è ora 3
+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
-
+e, d = d, e             # d è ora 5 ed e è ora 4
 
-# Dizionari immagazzinano mappature
-empty_dict = {}
-# Questo è un dizionario pre-riempito
+# 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}
 
-# Accedi ai valori con []
+# 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
 
-# Ottieni tutte le chiavi come una lista con "keys()"
-filled_dict.keys()   # => ["tre", "due", "uno"]
+# 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"]
 
-# Ottieni tutt i valori come una lista con "values()"
-filled_dict.values()   # => [3, 2, 1]
-# Nota - Come sopra riguardo l'ordinamento delle chiavi.
 
-# Ottieni tutte le coppie chiave-valore, sotto forma di lista di tuple, utilizzando "items()"
-filled_dicts.items()    # => [("uno", 1), ("due", 2), ("tre", 3)]
+# 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
+1 in filled_dict       # => False
 
-# Cercando una chiave non esistente è un KeyError
+# 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
+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
-# nota che filled_dict.get("quattro") è ancora => None
-# (get non imposta il valore nel dizionario)
 
-# imposta il valore di una chiave con una sintassi simile alle liste
-filled_dict["quattro"] = 4  # ora, filled_dict["quattro"] => 4
 
-# "setdefault()" aggiunge al dizionario solo se la chiave data non è presente
-filled_dict.setdefault("five", 5)  # filled_dict["five"] è impostato a 5
-filled_dict.setdefault("five", 6)  # filled_dict["five"] è ancora 5
+# "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
 
-# Sets immagazzina ... sets (che sono come le liste, ma non possono contenere doppioni)
-empty_set = set()
-# Inizializza un "set()" con un po' di valori
-some_set = set([1, 2, 2, 3, 4])   # some_set è ora set([1, 2, 3, 4])
+# Rimuovi una chiave da un dizionario con del
+del filled_dict["uno"]  # Rimuove la chiave "uno" dal dizionario
 
-# l'ordine non è garantito, anche se a volta può sembrare ordinato
-another_set = set([4, 3, 2, 2, 1])  # another_set è ora set([1, 2, 3, 4])
+# 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}
 
-# Da Python 2.7, {} può essere usato per dichiarare un set
-filled_set = {1, 2, 2, 3, 4}   # => {1, 2, 3, 4}
+# 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 elementi ad un set
-filled_set.add(5)   # filled_set è ora {1, 2, 3, 4, 5}
+# 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}
-filled_set & other_set   # => {3, 4, 5}
+some_set & other_set  # => {3, 4, 5}
 
 # Fai unioni su set con |
-filled_set | other_set   # => {1, 2, 3, 4, 5, 6}
+some_set | other_set  # => {1, 2, 3, 4, 5, 6}
 
 # Fai differenze su set con -
-{1, 2, 3, 4} - {2, 3, 5}   # => {1, 4}
+{1, 2, 3, 4} - {2, 3, 5}  # => {1, 4}
 
 # Effettua la differenza simmetrica con ^
 {1, 2, 3, 4} ^ {2, 3, 5}  # => {1, 4, 5}
@@ -361,65 +377,77 @@ filled_set | other_set   # => {1, 2, 3, 4, 5, 6}
 {1, 2} <= {1, 2, 3} # => True
 
 # Controlla l'esistenza in un set con in
-2 in filled_set   # => True
-10 in filled_set   # => False
+2 in some_set   # => True
+10 in some_set  # => False
+
 
 
 ####################################################
-## 3. Control Flow
+## 3. Control Flow e oggetti Iterabili
 ####################################################
 
-# Dichiariamo una variabile
+# Dichiariamo  una variabile
 some_var = 5
 
 # Questo è un controllo if. L'indentazione è molto importante in python!
-# stampa "some_var è più piccola di 10"
+# 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 è decisamente più grande di 10."
-elif some_var < 10:    # Questa clausola elif è opzionale.
-    print "some_var è più piccola di 10."
-else:           # Anche questo è opzionale.
-    print "some_var è precisamente 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
-stampa:
+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 {0} per interpolare le stringhe formattate. (Vedi di seguito.)
-    print "{0} è un mammifero".format(animale)
+    # 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
-stampa:
+"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
+    print(i)
 
 """
-"range(lower, upper)" restituisce una lista di numeri
-dal più piccolo (lower) al più grande (upper)
-stampa:
+"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
+    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
-stampa:
+Il seguente codice scriverà:
     0
     1
     2
@@ -427,28 +455,62 @@ stampa:
 """
 x = 0
 while x < 4:
-    print x
+    print(x)
     x += 1  # Forma compatta per x = x + 1
 
-# Gestisci le eccezioni con un blocco try/except
-
-# Funziona da Python 2.6 in su:
+# Gestione delle eccezioni con un blocco try/except
 try:
     # Usa "raise" per generare un errore
-    raise IndexError("Questo è un errore di indice")
+    raise IndexError("Questo è un IndexError")
 except IndexError as e:
-    pass    # Pass è solo una non-operazione. Solitamente vorrai fare un recupero.
+    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 seguire tutti i blocchi except
-    print "Tutto ok!"   # Viene eseguita solo se il codice dentro try non genera eccezioni
+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"
+    print("Possiamo liberare risorse qui")
 
-# Invece di try/finally per liberare risorse puoi usare il metodo with
+# 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
+        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
@@ -456,23 +518,20 @@ with open("myfile.txt") as f:
 
 # Usa "def" per creare nuove funzioni
 def aggiungi(x, y):
-    print "x è {0} e y è {1}".format(x, y)
-    return x + y    # Restituisce valori con il metodo return
+    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)   # => stampa "x è 5 e y è 6" e restituisce 11
+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)   # Le parole chiave come argomenti possono arrivare in ogni ordine.
+aggiungi(y=6, x=5)  # In questo modo non è necessario rispettare l'ordine degli argomenti
 
-
-# Puoi definire funzioni che accettano un numero variabile di argomenti posizionali
-# che verranno interpretati come tuple usando il *
+# Puoi definire funzioni che accettano un numero non definito di argomenti
 def varargs(*args):
     return args
 
-varargs(1, 2, 3)   # => (1, 2, 3)
-
+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 **
@@ -485,8 +544,8 @@ 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
+    print(args)
+    print(kwargs)
 """
 all_the_args(1, 2, a=3, b=4) stampa:
     (1, 2)
@@ -494,38 +553,44 @@ all_the_args(1, 2, a=3, b=4) stampa:
 """
 
 # Quando chiami funzioni, puoi fare l'opposto di args/kwargs!
-# Usa * per sviluppare gli argomenti posizionale ed usa ** per espandere gli argomenti parola chiave
+# 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)
-
-# puoi passare args e kwargs insieme alle altre funzioni che accettano args/kwargs
-# sviluppandoli, rispettivamente, con * e **
-def pass_all_the_args(*args, **kwargs):
-    all_the_args(*args, **kwargs)
-    print varargs(*args)
-    print keyword_args(**kwargs)
-
-# Funzioni Scope
+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 è uguale alla variabile globale x
-    x = num # => 43
-    print x # => 43
+    # 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
+    print(x)   # => 5
+    x = num    # la variabile globable x è ora 6
+    print(x)   # => 6
 
 set_x(43)
 set_global_x(6)
 
-# Python ha funzioni di prima classe
+
+# Python ha "first class functions"
 def create_adder(x):
     def adder(y):
         return x + y
@@ -535,204 +600,381 @@ 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
+(lambda x: x > 2)(3)                  # => True
+(lambda x, y: x ** 2 + y ** 2)(2, 1)  # => 5
 
-# Esse sono incluse in funzioni di alto livello
-map(add_10, [1, 2, 3])   # => [11, 12, 13]
-map(max, [1, 2, 3], [4, 2, 1])   # => [4, 2, 3]
+# È 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]
 
-filter(lambda x: x > 5, [3, 4, 5, 6, 7])   # => [6, 7]
+list(filter(lambda x: x > 5, [3, 4, 5, 6, 7]))  # => [6, 7]
 
-# Possiamo usare la comprensione delle liste per mappe e filtri
-[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]
+# 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 in 'abc'}  # => {'d', 'e', 'f'}
+{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. Classi
+## 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 una sottoclasse da un oggetto per avere una classe.
-class Human(object):
+# Usiamo l'istruzione "class" per creare una classe
+class Human:
 
-    # Un attributo della classe. E' condiviso da tutte le istanze delle classe
+    # Un attributo della classe. E' condiviso tra tutte le istanze delle classe
     species = "H. sapiens"
 
-    # Costruttore base, richiamato quando la classe viene inizializzata.
-    # Si noti che il doppio leading e gli underscore finali denotano oggetti
-    # o attributi che sono usati da python ma che vivono nello spazio dei nome controllato
-    # dall'utente. Non dovresti usare nomi di questo genere.
+    # 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
+        self._age = 0
 
     # Un metodo dell'istanza. Tutti i metodi prendo "self" come primo argomento
     def say(self, msg):
-        return "{0}: {1}".format(self.name, 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 chiamate con la classe chiamante come primo argomento
+    # Sono chiamati con la classe chiamante come primo argomento
     @classmethod
     def get_species(cls):
         return cls.species
 
-    # Un metodo statico è chiamato senza una classe od una istanza di riferimento
+    # Un metodo statico è chiamato senza classe o istanza di riferimento
     @staticmethod
     def grunt():
         return "*grunt*"
 
-    # Una proprietà è come un metodo getter.
-    # Trasforma il metodo age() in un attributo in sola lettura, che ha lo stesso nome
+    # 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 la proprietà
+    # Questo metodo permette di modificare una property
     @age.setter
     def age(self, age):
         self._age = age
 
-    # Questo metodo permette di cancellare la proprietà
+    # Questo metodo permette di cancellare una property
     @age.deleter
     def age(self):
         del self._age
 
-# Instanziare una classe
-i = Human(name="Ian")
-print i.say("hi")     # stampa "Ian: hi"
+# 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
 
-j = Human("Joel")
-print j.say("hello")  # stampa "Joel: hello"
 
-# Chiamare metodi della classe
-i.get_species()   # => "H. sapiens"
+####################################################
+## 6.1 Ereditarietà  (Inheritance)
+####################################################
 
-# Cambiare l'attributo condiviso
-Human.species = "H. neanderthalensis"
-i.get_species()   # => "H. neanderthalensis"
-j.get_species()   # => "H. neanderthalensis"
+# L'ereditarietà consente di definire nuove classi figlio che ereditano metodi e
+# variabili dalla loro classe genitore.
 
-# Chiamare il metodo condiviso
-Human.grunt()   # => "*grunt*"
+# 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.
 
-# Aggiorna la proprietà
-i.age = 42
+# Per importare le funzioni da altri file usa il seguente formato 
+# from "nomefile-senza-estensione" import "funzione-o-classe"
 
-# Ritorna il valore della proprietà
-i.age # => 42
+from human import Human
 
-# Cancella la proprietà
-del i.age
-i.age  # => Emette un AttributeError
+# 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)
 
-####################################################
-## 6. Moduli
-####################################################
+    #Le classi figlio possono sovrascrivere gli attributi dei loro genitori
+    species = 'Superhuman'
 
-# Puoi importare moduli
-import math
-print math.sqrt(16)  # => 4
+    # 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":
 
-# Puoi ottenere specifiche funzione da un modulo
-from math import ceil, floor
-print ceil(3.7)  # => 4.0
-print floor(3.7)   # => 3.0
+    def __init__(self, name, movie=False,
+                 superpowers=["super strength", "bulletproofing"]):
 
-# Puoi importare tutte le funzioni da un modulo
-# Attenzione: questo non è raccomandato
-from math import *
+        # aggiungi ulteriori attributi della classe
+        self.fictional = True
+        self.movie = movie
+        self.superpowers = superpowers
 
-# Puoi abbreviare i nomi dei moduli
-import math as m
-math.sqrt(16) == m.sqrt(16)   # => True
-# puoi anche verificare che le funzioni sono equivalenti
-from math import sqrt
-math.sqrt == m.sqrt == sqrt  # => True
+        # 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)
 
-# 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.
+    # Sovrascrivere il metodo "sing"
+    def sing(self):
+        return 'Dun, dun, DUN!'
 
-# Potete scoprire quali funzioni e attributi
-# definiscono un modulo
-import math
-dir(math)
+    # Aggiungi un ulteriore metodo dell'istanza
+    def boast(self):
+        for power in self.superpowers:
+            print("I wield the power of {pow}!".format(pow=power))
 
-# 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
 
+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))
 
 ####################################################
-## 7. Avanzate
+## 6.2 Ereditarietà multipla
 ####################################################
 
-# Generatori
-# Un generatore appunto "genera" valori solo quando vengono richiesti,
-# invece di memorizzarli tutti subito fin dall'inizio
+# Un'altra definizione di classe
+# bat.py
+class Bat:
 
-# Il metodo seguente (che NON è un generatore) raddoppia tutti i valori e li memorizza
-# dentro `double_arr`. Se gli oggetti iterabili sono grandi, il vettore risultato
-# potrebbe diventare enorme!
-def double_numbers(iterable):
-    double_arr = []
-    for i in iterable:
-        double_arr.append(i + i)
+    species = 'Baty'
 
-# Eseguendo il seguente codice, noi andiamo a raddoppiare prima tutti i valori, e poi
-# li ritorniamo tutti e andiamo a controllare la condizione
-for value in double_numbers(range(1000000)):  # `test_senza_generatore`
-    print value
-    if value > 5:
-        break
+    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'
 
-# Invece, potremmo usare un generatore per "generare" il valore raddoppiato non
-# appena viene richiesto
-def double_numbers_generator(iterable):
+    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
 
-# Utilizzando lo stesso test di prima, stavolta però con un generatore, ci permette
-# di iterare sui valori e raddoppiarli uno alla volta, non appena vengono richiesti dalla
-# logica del programma. Per questo, non appena troviamo un valore > 5, usciamo dal ciclo senza
-# bisogno di raddoppiare la maggior parte dei valori del range (MOLTO PIU VELOCE!)
-for value in double_numbers_generator(xrange(1000000)):  # `test_generatore`
-    print value
-    if value > 5:
+# 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
 
-# Nota: hai notato l'uso di `range` in `test_senza_generatore` e `xrange` in `test_generatore`?
-# Proprio come `double_numbers_generator` è la versione col generatore di `double_numbers`
-# Abbiamo `xrange` come versione col generatore di `range`
-# `range` ritorna un array di 1000000 elementi
-# `xrange` invece genera 1000000 valori quando lo richiediamo/iteriamo su di essi
-
-# Allo stesso modo della comprensione delle liste, puoi creare la comprensione
-# dei generatori.
+# 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)  # stampa -1 -2 -3 -4 -5
+    print(x)  # prints -1 -2 -3 -4 -5 to console/terminal
 
-# Puoi anche fare il cast diretto di una comprensione di generatori ad una lista.
+# 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 include say
-# Beg chiamerà say. Se say_please è True allora cambierà il messaggio
-# ritornato
+# In questo esempio "beg" avvolge/wrappa  "say". 
+# Se say_please è True, cambierà il messaggio restituito.
 from functools import wraps
 
 def beg(target_function):
@@ -752,8 +994,8 @@ def say(say_please=False):
     return msg, say_please
 
 
-print say()  # Puoi comprarmi una birra?
-print say(say_please=True)  # Puoi comprarmi una birra? Per favore! Sono povero :(
+print(say())                 # Puoi comprarmi una birra?
+print(say(say_please=True))  # Puoi comprarmi una birra? Per favore! Sono povero :(
 ```
 
 ## Pronto per qualcosa di più?
@@ -761,18 +1003,14 @@ print say(say_please=True)  # Puoi comprarmi una birra? Per favore! Sono povero
 ### Gratis Online
 
 * [Automate the Boring Stuff with Python](https://automatetheboringstuff.com)
-* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
-* [Dive Into Python](http://www.diveintopython.net/)
-* [The Official Docs](http://docs.python.org/2/)
+* [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 Module of the Week](http://pymotw.com/2/)
-* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182)
+* [Python Course](http://www.python-course.eu/index.php)
 * [First Steps With Python](https://realpython.com/learn/python-first-steps/)
-* [LearnPython](http://www.learnpython.org/)
-* [Fullstack Python](https://www.fullstackpython.com/)
-
-### Libri cartacei
-
-* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20)
-* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20)
-* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20)
+* [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/pythonlegacy-it.html.markdown b/it-it/pythonlegacy-it.html.markdown
new file mode 100644
index 00000000..4c8b2a17
--- /dev/null
+++ b/it-it/pythonlegacy-it.html.markdown
@@ -0,0 +1,778 @@
+---
+language: Python 2 (legacy)
+filename: learnpythonlegacy-it.py
+contributors:
+    - ["Louie Dinh", "http://ldinh.ca"]
+    - ["Amin Bandali", "http://aminbandali.com"]
+    - ["Andre Polykanine", "https://github.com/Oire"]
+    - ["evuez", "http://github.com/evuez"]
+translators:
+    - ["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 2.7 in modo specifico, ma dovrebbe andar
+bene anche per Python 2.x. Python 2.7 sta raggiungendo il "fine vita", ovvero non sarà
+più supportato nel 2020. Quindi è consigliato imparare Python utilizzando Python 3.
+Per maggiori informazioni su Python 3.x, dai un'occhiata al [tutorial di Python 3](http://learnxinyminutes.com/docs/python/).
+
+E' possibile anche scrivere codice compatibile sia con Python 2.7 che con Python 3.x,
+utilizzando [il modulo `__future__`](https://docs.python.org/2/library/__future__.html) di Python.
+Il modulo `__future__` permette di scrivere codice in Python 3, che può essere eseguito
+utilizzando Python 2: cosa aspetti a vedere il tutorial di Python 3?
+
+```python
+
+# I commenti su una sola linea iniziano con un cancelletto
+
+""" Più stringhe possono essere scritte
+    usando tre ", e sono spesso usate
+    come commenti
+"""
+
+####################################################
+## 1. Tipi di dati primitivi ed Operatori
+####################################################
+
+# Hai i numeri
+3  # => 3
+
+# La matematica è quello che vi aspettereste
+1 + 1  # => 2
+8 - 1  # => 7
+10 * 2  # => 20
+35 / 5  # => 7
+
+# La divisione è un po' complicata. E' una divisione fra interi in cui viene 
+# restituito in automatico il risultato intero.
+5 / 2  # => 2
+
+# Per le divisioni con la virgola abbiamo bisogno di parlare delle variabili floats.
+2.0     # Questo è un float
+11.0 / 4.0  # => 2.75 ahhh...molto meglio
+
+# Il risultato di una divisione fra interi troncati positivi e negativi
+5 // 3     # => 1
+5.0 // 3.0 # => 1.0 # funziona anche per i floats
+-5 // 3  # => -2
+-5.0 // 3.0 # => -2.0
+
+# E' possibile importare il modulo "division" (vedi la sezione 6 di questa guida, Moduli)
+# per effettuare la divisione normale usando solo '/'.
+from __future__ import division
+11/4    # => 2.75  ...divisione normale
+11//4   # => 2 ...divisione troncata
+
+# Operazione Modulo
+7 % 3 # => 1
+
+# Elevamento a potenza (x alla y-esima potenza)
+2**4 # => 16
+
+# Forzare le precedenze con le parentesi
+(1 + 3) * 2  # => 8
+
+# 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
+0 and 2 #=> 0
+-5 or 0 #=> -5
+0 == False #=> True
+2 == True #=> False
+1 == True #=> True
+
+# nega con not
+not True  # => False
+not False  # => 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
+
+# Le stringhe sono create con " o '
+"Questa è una stringa."
+'Anche questa è una stringa.'
+
+# Anche le stringhe possono essere sommate!
+"Ciao " + "mondo!"  # => Ciao mondo!"
+# Le stringhe possono essere sommate anche senza '+'
+"Ciao " "mondo!"  # => Ciao mondo!"
+
+# ... oppure moltiplicate
+"Hello" * 3  # => "HelloHelloHello"
+
+# Una stringa può essere considerata come una lista di caratteri
+"Questa è una stringa"[0]  # => 'Q'
+
+# Per sapere la lunghezza di una stringa
+len("Questa è una stringa")  # => 20
+
+# Formattazione delle stringhe con %
+# Anche se l'operatore % per le stringe sarà deprecato con Python 3.1, e verrà rimosso
+# successivamente, può comunque essere utile sapere come funziona
+x = 'mela'
+y = 'limone'
+z = "La cesta contiene una %s e un %s" % (x,y)
+
+# Un nuovo modo per fomattare le stringhe è il metodo format.
+# Questo metodo è quello consigliato
+"{} è un {}".format("Questo", "test")
+"{0} possono essere {1}".format("le stringhe", "formattate")
+# Puoi usare delle parole chiave se non vuoi contare
+"{nome} vuole mangiare {cibo}".format(nome="Bob", cibo="lasagna")
+
+# 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
+
+# L'operatore 'is' testa l'identità di un oggetto. Questo non è
+# molto utile quando non hai a che fare con valori primitivi, ma lo è
+# quando hai a che fare con oggetti.
+ 
+# Qualunque oggetto può essere usato nei test booleani
+# I seguenti valori sono considerati falsi:
+#     - None
+#     - Lo zero, come qualunque tipo numerico (quindi 0, 0L, 0.0, 0.j)
+#     - Sequenze vuote (come '', (), [])
+#     - Contenitori vuoti (tipo {}, set())
+#     - Istanze di classi definite dall'utente, che soddisfano certi criteri
+#       vedi: https://docs.python.org/2/reference/datamodel.html#object.__nonzero__
+#       
+# Tutti gli altri valori sono considerati veri: la funzione bool() usata su di loro, ritorna True.
+bool(0)  # => False
+bool("")  # => False
+
+
+####################################################
+## 2. Variabili e Collections
+####################################################
+
+# Python ha una funzione di stampa
+print "Sono Python. Piacere di conoscerti!" # => Sono Python. Piacere di conoscerti!
+
+# Un modo semplice per ricevere dati in input dalla riga di comando
+variabile_stringa_input = raw_input("Inserisci del testo: ") # Ritorna i dati letti come stringa
+variabile_input = input("Inserisci del testo: ") # Interpreta i dati letti come codice python
+# Attenzione: bisogna stare attenti quando si usa input()
+# Nota: In python 3, input() è deprecato, e raw_input() si chiama input()
+
+# Non c'è bisogno di dichiarare una variabile per assegnarle un valore
+una_variabile = 5    # Convenzionalmente si usa caratteri_minuscoli_con_underscores
+una_variabile  # => 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.
+un_altra_variabile  # Genera un errore di nome
+
+# if può essere usato come un'espressione
+# E' l'equivalente dell'operatore ternario in C
+"yahoo!" if 3 > 2 else 2  # => "yahoo!"
+
+# Liste immagazzinano sequenze
+li = []
+# Puoi partire con una lista pre-riempita
+altra_li = [4, 5, 6]
+
+# Aggiungi cose 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
+# Assegna nuovo valore agli indici che sono già stati inizializzati con =
+li[0] = 42
+li[0]  # => 42
+li[0] = 1  # Nota: è resettato al valore iniziale
+# Guarda l'ultimo elemento
+li[-1]  # => 3
+
+# Guardare al di fuori dei limiti è 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]
+
+# Rimuovi arbitrariamente elementi da una lista con "del"
+del li[2]   # li è ora [1, 2, 3]
+# Puoi sommare le liste
+li + altra_li   # => [1, 2, 3, 4, 5, 6]
+# Nota: i valori per li ed altra_li non sono modificati.
+
+# Concatena liste con "extend()"
+li.extend(altra_li)   # Ora li è [1, 2, 3, 4, 5, 6]
+
+# 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
+
+# Controlla l'esistenza di un valore in una lista con "in"
+1 in li   # => True
+
+# Esamina la lunghezza con "len()"
+len(li)   # => 6
+
+
+# Tuple sono come le liste ma immutabili.
+tup = (1, 2, 3)
+tup[0]   # => 1
+tup[0] = 3  # Genera un TypeError
+
+# 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 and 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
+
+
+# Dizionari immagazzinano mappature
+empty_dict = {}
+# Questo è un dizionario pre-riempito
+filled_dict = {"uno": 1, "due": 2, "tre": 3}
+
+# Accedi ai valori con []
+filled_dict["uno"]   # => 1
+
+# Ottieni tutte le chiavi come una lista con "keys()"
+filled_dict.keys()   # => ["tre", "due", "uno"]
+# Nota - Nei dizionari l'ordine delle chiavi non è garantito.
+# Il tuo risultato potrebbe non essere uguale a questo.
+
+# Ottieni tutt i valori come una lista con "values()"
+filled_dict.values()   # => [3, 2, 1]
+# Nota - Come sopra riguardo l'ordinamento delle chiavi.
+
+# Ottieni tutte le coppie chiave-valore, sotto forma di lista di tuple, utilizzando "items()"
+filled_dicts.items()    # => [("uno", 1), ("due", 2), ("tre", 3)]
+
+# 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 è 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
+# nota che filled_dict.get("quattro") è ancora => None
+# (get non imposta il valore nel dizionario)
+
+# imposta il valore di una chiave con una sintassi simile alle liste
+filled_dict["quattro"] = 4  # ora, filled_dict["quattro"] => 4
+
+# "setdefault()" aggiunge al dizionario solo se la chiave data non è presente
+filled_dict.setdefault("five", 5)  # filled_dict["five"] è impostato a 5
+filled_dict.setdefault("five", 6)  # filled_dict["five"] è ancora 5
+
+
+# Sets immagazzina ... sets (che sono come le liste, ma non possono contenere doppioni)
+empty_set = set()
+# Inizializza un "set()" con un po' di valori
+some_set = set([1, 2, 2, 3, 4])   # some_set è ora set([1, 2, 3, 4])
+
+# l'ordine non è garantito, anche se a volta può sembrare ordinato
+another_set = set([4, 3, 2, 2, 1])  # another_set è ora set([1, 2, 3, 4])
+
+# Da Python 2.7, {} può essere usato per dichiarare un set
+filled_set = {1, 2, 2, 3, 4}   # => {1, 2, 3, 4}
+
+# Aggiungere elementi ad un set
+filled_set.add(5)   # filled_set è ora {1, 2, 3, 4, 5}
+
+# Fai intersezioni su un set con &
+other_set = {3, 4, 5, 6}
+filled_set & other_set   # => {3, 4, 5}
+
+# Fai unioni su set con |
+filled_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 filled_set   # => True
+10 in filled_set   # => False
+
+
+####################################################
+## 3. Control Flow
+####################################################
+
+# Dichiariamo una variabile
+some_var = 5
+
+# Questo è un controllo if. L'indentazione è molto importante in python!
+# stampa "some_var è più piccola di 10"
+if some_var > 10:
+    print "some_var è decisamente più grande di 10."
+elif some_var < 10:    # Questa clausola elif è opzionale.
+    print "some_var è più piccola di 10."
+else:           # Anche questo è opzionale.
+    print "some_var è precisamente 10."
+
+
+"""
+I cicli for iterano sulle liste
+stampa:
+    cane è un mammifero
+    gatto è un mammifero
+    topo è un mammifero
+"""
+for animale in ["cane", "gatto", "topo"]:
+    # Puoi usare {0} per interpolare le stringhe formattate. (Vedi di seguito.)
+    print "{0} è un mammifero".format(animale)
+
+"""
+"range(numero)" restituisce una lista di numeri
+da zero al numero dato
+stampa:
+    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)
+stampa:
+    4
+    5
+    6
+    7
+"""
+for i in range(4, 8):
+    print i
+
+"""
+I cicli while vengono eseguiti finchè una condizione viene a mancare
+stampa:
+    0
+    1
+    2
+    3
+"""
+x = 0
+while x < 4:
+    print x
+    x += 1  # Forma compatta per x = x + 1
+
+# Gestisci le eccezioni con un blocco try/except
+
+# Funziona da Python 2.6 in su:
+try:
+    # Usa "raise" per generare un errore
+    raise IndexError("Questo è un errore di indice")
+except IndexError as e:
+    pass    # Pass è solo una non-operazione. Solitamente vorrai fare un recupero.
+except (TypeError, NameError):
+    pass    # Eccezioni multiple possono essere gestite tutte insieme, se necessario.
+else:   # Clausola opzionale al blocco try/except. Deve seguire 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"
+
+# Invece di try/finally per liberare risorse puoi usare il metodo with
+with open("myfile.txt") as f:
+    for line in f:
+        print line
+
+####################################################
+## 4. Funzioni
+####################################################
+
+# Usa "def" per creare nuove funzioni
+def aggiungi(x, y):
+    print "x è {0} e y è {1}".format(x, y)
+    return x + y    # Restituisce valori con il metodo return
+
+# Chiamare funzioni con parametri
+aggiungi(5, 6)   # => stampa "x è 5 e y è 6" e restituisce 11
+
+# Un altro modo per chiamare funzioni  è con parole chiave come argomenti
+aggiungi(y=6, x=5)   # Le parole chiave come argomenti possono arrivare in ogni ordine.
+
+
+# Puoi definire funzioni che accettano un numero variabile di argomenti posizionali
+# che verranno interpretati come tuple usando il *
+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)
+
+# puoi passare args e kwargs insieme alle altre funzioni che accettano args/kwargs
+# sviluppandoli, rispettivamente, con * e **
+def pass_all_the_args(*args, **kwargs):
+    all_the_args(*args, **kwargs)
+    print varargs(*args)
+    print keyword_args(**kwargs)
+
+# Funzioni Scope
+x = 5
+
+def set_x(num):
+    # La variabile locale x non è uguale alla 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 funzioni di prima classe
+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
+
+# Esse sono incluse in funzioni di alto livello
+map(add_10, [1, 2, 3])   # => [11, 12, 13]
+map(max, [1, 2, 3], [4, 2, 1])   # => [4, 2, 3]
+
+filter(lambda x: x > 5, [3, 4, 5, 6, 7])   # => [6, 7]
+
+# Possiamo usare la comprensione delle liste per mappe e filtri
+[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 in 'abc'}  # => {'d', 'e', 'f'}
+{x: x**2 for x in range(5)}  # => {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
+
+
+####################################################
+## 5. Classi
+####################################################
+
+# Usiamo una sottoclasse da un oggetto per avere una classe.
+class Human(object):
+
+    # Un attributo della classe. E' condiviso da tutte le istanze delle classe
+    species = "H. sapiens"
+
+    # Costruttore base, richiamato quando la classe viene inizializzata.
+    # Si noti che il doppio leading e gli underscore finali denotano oggetti
+    # o attributi che sono usati da python ma che vivono nello spazio dei nome controllato
+    # dall'utente. Non dovresti usare nomi di questo genere.
+    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):
+        return "{0}: {1}".format(self.name, msg)
+
+    # Un metodo della classe è condiviso fra tutte le istanze
+    # Sono chiamate con la classe chiamante come primo argomento
+    @classmethod
+    def get_species(cls):
+        return cls.species
+
+    # Un metodo statico è chiamato senza una classe od una istanza di riferimento
+    @staticmethod
+    def grunt():
+        return "*grunt*"
+
+    # Una proprietà è come un metodo getter.
+    # Trasforma il metodo age() in un attributo in sola lettura, che ha lo stesso nome
+    @property
+    def age(self):
+        return self._age
+
+    # Questo metodo permette di modificare la proprietà
+    @age.setter
+    def age(self, age):
+        self._age = age
+
+    # Questo metodo permette di cancellare la proprietà
+    @age.deleter
+    def age(self):
+        del self._age
+
+# Instanziare una classe
+i = Human(name="Ian")
+print i.say("hi")     # stampa "Ian: hi"
+
+j = Human("Joel")
+print j.say("hello")  # stampa "Joel: hello"
+
+# Chiamare metodi della classe
+i.get_species()   # => "H. sapiens"
+
+# Cambiare l'attributo condiviso
+Human.species = "H. neanderthalensis"
+i.get_species()   # => "H. neanderthalensis"
+j.get_species()   # => "H. neanderthalensis"
+
+# Chiamare il metodo condiviso
+Human.grunt()   # => "*grunt*"
+
+# Aggiorna la proprietà
+i.age = 42
+
+# Ritorna il valore della proprietà
+i.age # => 42
+
+# Cancella la proprietà
+del i.age
+i.age  # => Emette un AttributeError
+
+
+####################################################
+## 6. Moduli
+####################################################
+
+# 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
+# puoi anche verificare che le funzioni sono equivalenti
+from math import sqrt
+math.sqrt == m.sqrt == sqrt  # => 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
+# definiscono 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
+
+
+####################################################
+## 7. Avanzate
+####################################################
+
+# Generatori
+# Un generatore appunto "genera" valori solo quando vengono richiesti,
+# invece di memorizzarli tutti subito fin dall'inizio
+
+# Il metodo seguente (che NON è un generatore) raddoppia tutti i valori e li memorizza
+# dentro `double_arr`. Se gli oggetti iterabili sono grandi, il vettore risultato
+# potrebbe diventare enorme!
+def double_numbers(iterable):
+    double_arr = []
+    for i in iterable:
+        double_arr.append(i + i)
+
+# Eseguendo il seguente codice, noi andiamo a raddoppiare prima tutti i valori, e poi
+# li ritorniamo tutti e andiamo a controllare la condizione
+for value in double_numbers(range(1000000)):  # `test_senza_generatore`
+    print value
+    if value > 5:
+        break
+
+# Invece, potremmo usare un generatore per "generare" il valore raddoppiato non
+# appena viene richiesto
+def double_numbers_generator(iterable):
+    for i in iterable:
+        yield i + i
+
+# Utilizzando lo stesso test di prima, stavolta però con un generatore, ci permette
+# di iterare sui valori e raddoppiarli uno alla volta, non appena vengono richiesti dalla
+# logica del programma. Per questo, non appena troviamo un valore > 5, usciamo dal ciclo senza
+# bisogno di raddoppiare la maggior parte dei valori del range (MOLTO PIU VELOCE!)
+for value in double_numbers_generator(xrange(1000000)):  # `test_generatore`
+    print value
+    if value > 5:
+        break
+
+# Nota: hai notato l'uso di `range` in `test_senza_generatore` e `xrange` in `test_generatore`?
+# Proprio come `double_numbers_generator` è la versione col generatore di `double_numbers`
+# Abbiamo `xrange` come versione col generatore di `range`
+# `range` ritorna un array di 1000000 elementi
+# `xrange` invece genera 1000000 valori quando lo richiediamo/iteriamo su di essi
+
+# Allo stesso modo della comprensione delle liste, puoi creare la comprensione
+# dei generatori.
+values = (-x for x in [1,2,3,4,5])
+for x in values:
+    print(x)  # stampa -1 -2 -3 -4 -5
+
+# Puoi anche fare il cast diretto di una comprensione di generatori ad una lista.
+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 include say
+# Beg chiamerà say. Se say_please è True allora cambierà il messaggio
+# ritornato
+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)
+* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
+* [Dive Into Python](http://www.diveintopython.net/)
+* [The Official Docs](http://docs.python.org/2/)
+* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
+* [Python Module of the Week](http://pymotw.com/2/)
+* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182)
+* [First Steps With Python](https://realpython.com/learn/python-first-steps/)
+* [LearnPython](http://www.learnpython.org/)
+* [Fullstack Python](https://www.fullstackpython.com/)
+
+### Libri cartacei
+
+* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20)
+* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20)
+* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20)
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
new file mode 100644
index 00000000..a834e899
--- /dev/null
+++ b/it-it/rst-it.html.markdown
@@ -0,0 +1,111 @@
+---
+language: restructured text (RST)
+filename: restructuredtext-it.rst
+contributors:
+    - ["DamienVGN", "https://github.com/martin-damien"]
+    - ["Andre Polykanine", "https://github.com/Oire"]
+translators:
+    - ["Ale46", "https://github.com/Ale46"]
+    - ["Chris54721", "https://chris54721.net"]
+lang: it-it
+---
+
+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).
+
+## Installazione
+
+Per usare Restructured Text, sarà necessario installare [Python](http://www.python.org) ed il pacchetto `docutils`.
+
+`docutils` può essere installato da riga di comando:
+
+```bash
+$ easy_install docutils
+```
+
+Oppure, se hai `pip` installato sul tuo sistema:
+
+```bash
+$ pip install docutils
+```
+
+
+## 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
+
+===============================================================================
+I titoli principali sono scritti utilizzando caratteri di uguale, sopra e sotto
+===============================================================================
+
+Si noti che devono esserci tanti caratteri di uguale quanti caratteri del titolo.
+
+Anche i titoli normali usano caratteri di uguale, ma solo sotto
+===============================================================
+
+I sottotitoli usano i trattini
+------------------------------
+
+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 () ``.
+
+Le liste sono semplici come in Markdown:
+
+- primo articolo
+- Secondo elemento
+     - Sottoelemento
+
+oppure
+
+* Primo elemento
+* Secondo elemento
+     * Sottoelemento
+
+Le tabelle sono molto semplici da inserire:
+
+=========== ========
+Stato       Capitale
+=========== ========
+Francia     Parigi
+Giappone    Tokio
+=========== ========
+
+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 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)
+- 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:
+
+```bash
+$ rst2html miofile.rst output.html
+```
+
+*Nota : In alcuni sistemi il comando potrebbe essere rst2html.py*
+
+Ma ci sono applicazioni più complesse che utilizzano il formato RST:
+
+- [Pelican](http://blog.getpelican.com/), un generatore di siti statici
+- [Sphinx](http://sphinx-doc.org/), un generatore di documentazione
+- e molti altri
+
+
+## Letture
+
+- [Riferimento ufficiale rapido](http://docutils.sourceforge.net/docs/user/rst/quickref.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/sql-it.html.markdown b/it-it/sql-it.html.markdown
new file mode 100644
index 00000000..7db2eec1
--- /dev/null
+++ b/it-it/sql-it.html.markdown
@@ -0,0 +1,112 @@
+---
+language: SQL
+filename: learnsql-it.sql
+contributors:
+  - ["Bob DuCharme", "http://bobdc.com/"]
+translators:
+  - ["Christian Grasso", "https://grasso.io"]
+lang: it-it
+---
+
+Structured Query Language (SQL) è un linguaggio standard ISO per la creazione e la gestione
+di database organizzati in un insieme di tabelle. Le diverse implementazioni aggiungono
+spesso le proprie estensioni al linguaggio base ([confronto tra le diverse implementazioni](http://troels.arvin.dk/db/rdbms/))
+
+Le diverse implementazioni forniscono inoltre un prompt per inserire in modo interattivo i comandi
+o eseguire il contenuto di uno script.
+
+I comandi di seguito lavorano sul [database di esempio MySQL](https://dev.mysql.com/doc/employee/en/)
+disponibile su [GitHub](https://github.com/datacharmer/test_db). I file .sql contengono liste di comandi
+simili a quelli mostrati di seguito, che creano e riempiono delle tabelle con dati di un'azienda fittizia.
+Il comando per eseguire questi script può variare in base all'implementazione in uso.
+
+
+```sql
+-- I commenti iniziano con due trattini. Ogni comando va terminato con il punto e virgola
+
+-- SQL è case-insensitive per quanto riguarda i comandi; in genere si
+-- preferisce scriverli in maiuscolo per distinguerli dai nomi di 
+-- database, tabelle e colonne
+
+-- Crea ed elimina un database. I nomi di database e tabelle sono case-sensitive
+CREATE DATABASE someDatabase;
+DROP DATABASE someDatabase;
+
+-- Lista dei database disponibili
+SHOW DATABASES;
+
+-- Attiva uno specifico database
+USE employees;
+
+-- Seleziona tutte le righe e le colonne dalla tabella departments
+SELECT * FROM departments;
+
+-- Seleziona tutte le righe della tabella departments, 
+-- ma solo le colonne dept_no e dept_name. 
+-- È possibile suddividere i comandi su più righe.
+SELECT dept_no,
+       dept_name FROM departments;
+
+-- Seleziona solo le prime 5 righe della tabella departments. 
+SELECT * FROM departments LIMIT 5;
+
+-- Ottiene la colonna dept_name della tabella departments
+-- solo per le righe il cui valore di dept_name contiene 'en'. 
+SELECT dept_name FROM departments WHERE dept_name LIKE '%en%';
+
+-- Ottiene tutte le colonne della tabella departments
+-- solo per le righe che hanno un dept_name formato da una 'S'
+-- seguita esattamente da altri 4 caratteri
+SELECT * FROM departments WHERE dept_name LIKE 'S____';
+
+-- Seleziona i valori di title dalla tabella titles eliminando i duplicati
+SELECT DISTINCT title FROM titles;
+
+-- Come sopra, ma i valori sono ordinati alfabeticamente
+SELECT DISTINCT title FROM titles ORDER BY title;
+
+-- Mostra il numero di righe della tabella departments
+SELECT COUNT(*) FROM departments;
+
+-- Mostra il numero di righe della tabella departments
+-- il cui valore di dept_name contiene 'en'.
+SELECT COUNT(*) FROM departments WHERE dept_name LIKE '%en%';
+
+-- Un JOIN tra più tabelle: la tabella titles contiene gli 
+-- incarichi lavorativi associati ad un certo numero di impiegato.
+-- Con il JOIN utilizziamo il numero di impiegato per ottenere
+-- le informazioni ad esso associate nella tabella employees.
+-- (Inoltre selezioniamo solo le prime 10 righe)
+
+SELECT employees.first_name, employees.last_name,
+       titles.title, titles.from_date, titles.to_date
+FROM titles INNER JOIN employees ON
+       employees.emp_no = titles.emp_no LIMIT 10;
+
+-- Mostra tutte le tabelle di tutti i database.
+-- Spesso le implementazioni forniscono degli shortcut per questo comando
+SELECT * FROM INFORMATION_SCHEMA.TABLES
+WHERE TABLE_TYPE='BASE TABLE';
+
+-- Crea una tabella tablename1, con due colonne, per il database in uso.
+-- Per le colonne specifichiamo il tipo di dato (stringa di max 20 caratteri)
+CREATE TABLE tablename1 (fname VARCHAR(20), lname VARCHAR(20));
+
+-- Inserisce una riga nella tabella tablename1. I valori devono essere
+-- appropriati per la definizione della tabella
+INSERT INTO tablename1 VALUES('Richard','Mutt');
+
+-- In tablename1, modifica il valore di fname a 'John'
+-- in tutte le righe che hanno come lname 'Mutt'. 
+UPDATE tablename1 SET fname='John' WHERE lname='Mutt';
+
+-- Elimina tutte le righe di tablename1
+-- il cui lname inizia per 'M'.
+DELETE FROM tablename1 WHERE lname like 'M%';
+
+-- Elimina tutte le righe della tabella tablename1
+DELETE FROM tablename1;
+
+-- Elimina la tabella tablename1
+DROP TABLE tablename1;
+```
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/)
diff --git a/it-it/zfs-it.html.markdown b/it-it/zfs-it.html.markdown
new file mode 100644
index 00000000..c1307e67
--- /dev/null
+++ b/it-it/zfs-it.html.markdown
@@ -0,0 +1,361 @@
+---
+category: tool
+tool: zfs
+contributors:
+    - ["sarlalian", "http://github.com/sarlalian"]
+translators:
+    - ["Christian Grasso","https://grasso.io"]
+filename: LearnZfs-it.txt
+lang: it-it
+---
+
+
+[ZFS](http://open-zfs.org/wiki/Main_Page) è un sistema di storage che combina file system
+tradizionali e volume manager in un unico strumento. ZFS utilizza della terminologia
+specifica, diversa da quella usata da altri sistemi di storage, ma le sue funzioni lo
+rendono un ottimo tool per gli amministratori di sistema.
+
+
+## Concetti base di ZFS
+
+### Virtual Device
+
+Un VDEV è simile a un dispositivo gestito da una scheda RAID. Esistono diversi tipi di
+VDEV che offrono diversi vantaggi, tra cui ridondanza e velocità. In generale,
+i VDEV offrono una maggiore affidabilità rispetto alle schede RAID. Si sconsiglia di
+utilizzare ZFS insieme a RAID, poichè ZFS è fatto per gestire direttamente i dischi fisici.
+
+Tipi di VDEV:
+
+* stripe (disco singolo, senza ridondanza)
+* mirror (mirror su più dischi)
+* raidz
+	* raidz1 (parity a 1 disco, simile a RAID 5)
+	* raidz2 (parity a 2 dischi, simile a RAID 6)
+	* raidz3 (parity a 3 dischi)
+* disk
+* file (non consigliato in production poichè aggiunge un ulteriore filesystem)
+
+I dati vengono distribuiti tra tutti i VDEV presenti nella Storage Pool, per cui un maggior
+numero di VDEV aumenta le operazioni al secondo (IOPS).
+
+### Storage Pool
+
+Le Storage Pool di ZFS sono un'astrazione del livello inferiore (VDEV) e consentono di
+separare il filesystem visibile agli utenti dal layout reale dei dischi.
+
+### Dataset
+
+I dataset sono simili ai filesystem tradizionali, ma con molte più funzioni che rendono
+vantaggioso l'utilizzo di ZFS. I dataset supportano il [Copy on Write](https://en.wikipedia.org/wiki/Copy-on-write)
+gli snapshot, la gestione delle quota, compressione e deduplicazione.
+
+
+### Limiti
+
+Una directory può contenere fino a 2^48 file, ognuno dei quali di 16 exabyte.
+Una storage pool può contenere fino a 256 zettabyte (2^78), e può essere distribuita
+tra 2^64 dispositivi. Un singolo host può avere fino a 2^64 storage pool.
+
+
+## Comandi
+
+### Storage Pool
+
+Azioni:
+
+* List (lista delle pool)
+* Status (stato)
+* Destroy (rimozione)
+* Get/Set (lettura/modifica proprietà)
+
+Lista delle zpool
+
+```bash
+# Crea una zpool raidz
+$ zpool create bucket raidz1 gpt/zfs0 gpt/zfs1 gpt/zfs2
+
+# Lista delle zpool
+$ zpool list
+NAME    SIZE  ALLOC   FREE  EXPANDSZ   FRAG    CAP  DEDUP  HEALTH  ALTROOT
+zroot   141G   106G  35.2G         -    43%    75%  1.00x  ONLINE  -
+
+# Informazioni dettagliate su una zpool
+$ zpool list -v zroot
+NAME                                     SIZE  ALLOC   FREE  EXPANDSZ   FRAG    CAP  DEDUP HEALTH  ALTROOT
+zroot                                    141G   106G  35.2G         -    43%    75%  1.00x ONLINE  -
+  gptid/c92a5ccf-a5bb-11e4-a77d-001b2172c655   141G   106G  35.2G         -    43%    75%
+```
+
+Stato delle zpool
+
+```bash
+# Informazioni sullo stato delle zpool
+$ zpool status
+  pool: zroot
+ state: ONLINE
+  scan: scrub repaired 0 in 2h51m with 0 errors on Thu Oct  1 07:08:31 2015
+config:
+
+        NAME                                          STATE     READ WRITE CKSUM
+        zroot                                         ONLINE       0     0     0
+          gptid/c92a5ccf-a5bb-11e4-a77d-001b2172c655  ONLINE       0     0     0
+
+errors: No known data errors
+
+# "Scrubbing" (correzione degli errori)
+$ zpool scrub zroot
+$ zpool status -v zroot
+  pool: zroot
+ state: ONLINE
+  scan: scrub in progress since Thu Oct 15 16:59:14 2015
+        39.1M scanned out of 106G at 1.45M/s, 20h47m to go
+        0 repaired, 0.04% done
+config:
+
+        NAME                                          STATE     READ WRITE CKSUM
+        zroot                                         ONLINE       0     0     0
+          gptid/c92a5ccf-a5bb-11e4-a77d-001b2172c655  ONLINE       0     0     0
+
+errors: No known data errors
+```
+
+Proprietà delle zpool
+
+```bash
+
+# Proprietà di una zpool (gestite dal sistema o dall'utente)
+$ zpool get all zroot
+NAME   PROPERTY                       VALUE                          SOURCE
+zroot  size                           141G                           -
+zroot  capacity                       75%                            -
+zroot  altroot                        -                              default
+zroot  health                         ONLINE                         -
+...
+
+# Modifica di una proprietà
+$ zpool set comment="Dati" zroot
+$ zpool get comment
+NAME   PROPERTY  VALUE  SOURCE
+tank   comment   -      default
+zroot  comment   Dati   local
+```
+
+Rimozione di una zpool
+
+```bash
+$ zpool destroy test
+```
+
+
+### Dataset
+
+Azioni:
+
+* Create
+* List
+* Rename
+* Delete 
+* Get/Set (proprietà)
+
+Creazione dataset
+
+```bash
+# Crea un dataset
+$ zfs create tank/root/data
+$ mount | grep data
+tank/root/data on /data (zfs, local, nfsv4acls)
+
+# Crea un sottodataset
+$ zfs create tank/root/data/stuff
+$ mount | grep data
+tank/root/data on /data (zfs, local, nfsv4acls)
+tank/root/data/stuff on /data/stuff (zfs, local, nfsv4acls)
+
+
+# Crea un volume
+$ zfs create -V zroot/win_vm
+$ zfs list zroot/win_vm
+NAME                 USED  AVAIL  REFER  MOUNTPOINT
+tank/win_vm         4.13G  17.9G    64K  -
+```
+
+Lista dei dataset
+
+```bash
+# Lista dei dataset
+$ zfs list
+NAME                                                                       USED  AVAIL  REFER  MOUNTPOINT
+zroot                                                                      106G  30.8G   144K  none
+zroot/ROOT                                                                18.5G  30.8G   144K  none
+zroot/ROOT/10.1                                                              8K  30.8G  9.63G  /
+zroot/ROOT/default                                                        18.5G  30.8G  11.2G  /
+zroot/backup                                                              5.23G  30.8G   144K  none
+zroot/home                                                                 288K  30.8G   144K  none
+...
+
+# Informazioni su un dataset
+$ zfs list zroot/home
+NAME         USED  AVAIL  REFER  MOUNTPOINT
+zroot/home   288K  30.8G   144K  none
+
+# Lista degli snapshot
+$ zfs list -t snapshot
+zroot@daily-2015-10-15                                                                  0      -   144K  -
+zroot/ROOT@daily-2015-10-15                                                             0      -   144K  -
+zroot/ROOT/default@daily-2015-10-15                                                     0      -  24.2G  -
+zroot/tmp@daily-2015-10-15                                                           124K      -   708M  -
+zroot/usr@daily-2015-10-15                                                              0      -   144K  -
+zroot/home@daily-2015-10-15                                                             0      -  11.9G  -
+zroot/var@daily-2015-10-15                                                           704K      -  1.42G  -
+zroot/var/log@daily-2015-10-15                                                       192K      -   828K  -
+zroot/var/tmp@daily-2015-10-15                                                          0      -   152K  -
+```
+
+Rinominare un dataset
+
+```bash
+$ zfs rename tank/root/home tank/root/old_home
+$ zfs rename tank/root/new_home tank/root/home
+```
+
+Eliminare un dataset
+
+```bash
+# I dataset non possono essere eliminati se hanno degli snapshot
+$ zfs destroy tank/root/home
+```
+
+Lettura/modifica proprietà
+
+```bash
+# Tutte le proprietà di un dataset
+$ zfs get all  zroot/usr/home                                                                                              │157 # Create Volume
+NAME            PROPERTY              VALUE                  SOURCE                                                                          │158 $ zfs create -V zroot/win_vm
+zroot/home      type                  filesystem             -                                                                               │159 $ zfs list zroot/win_vm
+zroot/home      creation              Mon Oct 20 14:44 2014  -                                                                               │160 NAME                 USED  AVAIL  REFER  MOUNTPOINT
+zroot/home      used                  11.9G                  -                                                                               │161 tank/win_vm         4.13G  17.9G    64K  -
+zroot/home      available             94.1G                  -                                                                               │162 ```
+zroot/home      referenced            11.9G                  -                                                                               │163
+zroot/home      mounted               yes                    -
+...
+
+# Proprietà specifica
+$ zfs get compression zroot/usr/home
+NAME            PROPERTY     VALUE     SOURCE
+zroot/home      compression  off       default
+
+# Modifica di una proprietà
+$ zfs set compression=gzip-9 mypool/lamb
+
+# Specifiche proprietà per tutti i dataset
+$ zfs list -o name,quota,reservation
+NAME                                                               QUOTA  RESERV
+zroot                                                               none    none
+zroot/ROOT                                                          none    none
+zroot/ROOT/default                                                  none    none
+zroot/tmp                                                           none    none
+zroot/usr                                                           none    none
+zroot/home                                                          none    none
+zroot/var                                                           none    none
+...
+```
+
+
+### Snapshot
+
+Gli snapshot sono una delle funzioni più importanti di ZFS:
+
+* Lo spazio occupato è la differenza tra il filesystem e l'ultimo snapshot
+* Il tempo di creazione è di pochi secondi
+* Possono essere ripristinati alla velocità di scrittura del disco
+* Possono essere automatizzati molto semplicemente
+
+Azioni:
+
+* Create
+* Delete
+* Rename
+* Access
+* Send / Receive
+* Clone
+
+
+Creazione di uno snapshot
+
+```bash
+# Crea uno snapshot di un singolo dataset
+zfs snapshot tank/home/sarlalian@now
+
+# Crea uno snapshot di un dataset e dei suoi sottodataset
+$ zfs snapshot -r tank/home@now
+$ zfs list -t snapshot
+NAME                       USED  AVAIL  REFER  MOUNTPOINT
+tank/home@now                 0      -    26K  -
+tank/home/sarlalian@now       0      -   259M  -
+tank/home/alice@now           0      -   156M  -
+tank/home/bob@now             0      -   156M  -
+...
+```
+
+Eliminazione di uno snapshot
+
+```bash
+# Elimina uno snapshot
+$ zfs destroy tank/home/sarlalian@now
+
+# Elimina uno snapshot ricorsivamente
+$ zfs destroy -r tank/home/sarlalian@now
+
+```
+
+Rinominare uno snapshot
+
+```bash
+$ zfs rename tank/home/sarlalian@now tank/home/sarlalian@today
+$ zfs rename tank/home/sarlalian@now today
+
+$ zfs rename -r tank/home@now @yesterday
+```
+
+Accedere ad uno snapshot
+
+```bash
+# Utilizzare il comando cd come per una directory
+$ cd /home/.zfs/snapshot/
+```
+
+Invio e ricezione
+
+```bash
+# Backup di uno snapshot su un file
+$ zfs send tank/home/sarlalian@now | gzip > backup_file.gz
+
+# Invia uno snapshot ad un altro dataset
+$ zfs send tank/home/sarlalian@now | zfs recv backups/home/sarlalian
+
+# Invia uno snapshot ad un host remoto
+$ zfs send tank/home/sarlalian@now | ssh root@backup_server 'zfs recv tank/home/sarlalian'
+
+# Invia l'intero dataset e i suoi snapshot ad un host remoto
+$ zfs send -v -R tank/home@now | ssh root@backup_server 'zfs recv tank/home'
+```
+
+Clonare gli snapshot
+
+```bash
+# Clona uno snapshot
+$ zfs clone tank/home/sarlalian@now tank/home/sarlalian_new
+
+# Rende il clone indipendente dallo snapshot originale
+$ zfs promote tank/home/sarlalian_new
+```
+
+### Letture aggiuntive (in inglese)
+
+* [BSDNow's Crash Course on ZFS](http://www.bsdnow.tv/tutorials/zfs)
+* [FreeBSD Handbook on ZFS](https://www.freebsd.org/doc/en_US.ISO8859-1/books/handbook/zfs.html)
+* [BSDNow's Crash Course on ZFS](http://www.bsdnow.tv/tutorials/zfs)
+* [Oracle's Tuning Guide](http://www.oracle.com/technetwork/articles/servers-storage-admin/sto-recommended-zfs-settings-1951715.html)
+* [OpenZFS Tuning Guide](http://open-zfs.org/wiki/Performance_tuning)
+* [FreeBSD ZFS Tuning Guide](https://wiki.freebsd.org/ZFSTuningGuide)