9 files changed, 852 insertions, 9 deletions

diff --git a/it-it/asciidoc-it.html.markdown b/it-it/asciidoc-it.html.markdown
new file mode 100644
index 00000000..47a57349
--- /dev/null
+++ b/it-it/asciidoc-it.html.markdown
@@ -0,0 +1,135 @@
+---
+language: asciidoc
+contributors:
+    - ["Ryan Mavilia", "http://unoriginality.rocks/"]
+    - ["Abel Salgado Romero", "https://twitter.com/abelsromero"]
+translators:
+    - ["Ale46", "https://github.com/ale46"]
+lang: it-it
+filename: asciidoc-it.md
+---
+
+AsciiDoc è un linguaggio di markup simile a Markdown e può essere usato per qualsiasi cosa, dai libri ai blog. Creato nel 2002 da Stuart Rackman, questo linguaggio è semplice ma permette un buon numero di personalizzazioni.
+
+Intestazione Documento
+
+Le intestazioni sono opzionali e possono contenere linee vuote. Deve avere almeno una linea vuota rispetto al contenuto.
+
+Solo titolo
+
+```
+= Titolo documento
+
+Prima frase del documento.
+```
+
+Titolo ed Autore
+
+```
+= Titolo documento
+Primo Ultimo <first.last@learnxinyminutes.com>
+
+Inizio del documento
+```
+
+Autori multipli
+
+```
+= Titolo Documento
+John Doe <john@go.com>; Jane Doe<jane@yo.com>; Black Beard <beardy@pirate.com>
+
+Inizio di un documento con autori multipli.
+```
+
+Linea di revisione (richiede una linea autore)
+
+```
+= Titolo documento V1
+Potato Man <chip@crunchy.com>
+v1.0, 2016-01-13
+
+Questo articolo sulle patatine sarà divertente.
+```
+
+Paragrafi
+
+```
+Non hai bisogno di nulla di speciale per i paragrafi.
+
+Aggiungi una riga vuota tra i paragrafi per separarli.
+
+Per creare una riga vuota aggiungi un +
+e riceverai una interruzione di linea!
+```
+
+Formattazione Testo
+
+```
+_underscore crea corsivo_
+*asterischi per il grassetto*
+*_combinali per maggiore divertimento_*
+`usa i ticks per indicare il monospazio`
+`*spaziatura fissa in grassetto*`
+```
+
+Titoli di sezione
+
+```
+= Livello 0 (può essere utilizzato solo nell'intestazione del documento)
+
+== Livello 1 <h2>
+
+=== Livello 2 <h3>
+
+==== Livello 3 <h4>
+
+===== Livello 4 <h5>
+
+```
+
+Liste
+
+Per creare un elenco puntato, utilizzare gli asterischi.
+
+```
+* foo
+* bar
+* baz
+```
+
+Per creare un elenco numerato usa i periodi.
+
+```
+. item 1
+. item 2
+. item 3
+```
+
+È possibile nidificare elenchi aggiungendo asterischi o periodi aggiuntivi fino a cinque volte.
+
+```
+* foo 1
+** foo 2
+*** foo 3
+**** foo 4
+***** foo 5
+
+. foo 1
+.. foo 2
+... foo 3
+.... foo 4
+..... foo 5
+```
+
+## Ulteriori letture
+
+Esistono due strumenti per elaborare i documenti AsciiDoc:
+
+1. [AsciiDoc](http://asciidoc.org/): implementazione Python originale, disponibile nelle principali distribuzioni Linux. Stabile e attualmente in modalità di manutenzione.
+2. [Asciidoctor](http://asciidoctor.org/): implementazione alternativa di Ruby, utilizzabile anche da Java e JavaScript. In fase di sviluppo attivo, mira ad estendere la sintassi AsciiDoc con nuove funzionalità e formati di output.
+
+I seguenti collegamenti sono relativi all'implementazione di `Asciidoctor`:
+
+* [Markdown - AsciiDoc comparazione sintassi](http://asciidoctor.org/docs/user-manual/#comparison-by-example): confronto affiancato di elementi di Markdown e AsciiDoc comuni.
+* [Per iniziare](http://asciidoctor.org/docs/#get-started-with-asciidoctor): installazione e guide rapide per il rendering di documenti semplici.
+* [Asciidoctor Manuale Utente](http://asciidoctor.org/docs/user-manual/): manuale completo con riferimento alla sintassi, esempi, strumenti di rendering, tra gli altri.
diff --git a/it-it/c++-it.html.markdown b/it-it/c++-it.html.markdown
index b4f9c50e..449aebfb 100644
--- a/it-it/c++-it.html.markdown
+++ b/it-it/c++-it.html.markdown
@@ -1130,7 +1130,6 @@ compl 4    // Effettua il NOT bit-a-bit
 ```
 Letture consigliate:
 
-Un riferimento aggiornato del linguaggio può essere trovato qui
-<http://cppreference.com/w/cpp>
-
-Risorse addizionali possono essere trovate qui <http://cplusplus.com>
+* Un riferimento aggiornato del linguaggio può essere trovato qui [CPP Reference](http://cppreference.com/w/cpp).
+* Risorse addizionali possono essere trovate qui [CPlusPlus](http://cplusplus.com).
+* Un tutorial che copre le basi del linguaggio e l'impostazione dell'ambiente di codifica è disponibile su [TheChernoProject - C ++](https://www.youtube.com/playlist?list=PLlrATfBNZ98dudnM48yfGUldqGD0S4FFb).
diff --git a/it-it/dynamic-programming-it.html.markdown b/it-it/dynamic-programming-it.html.markdown
new file mode 100644
index 00000000..9c7bd9b6
--- /dev/null
+++ b/it-it/dynamic-programming-it.html.markdown
@@ -0,0 +1,55 @@
+---
+category: Algorithms & Data Structures
+name: Dynamic Programming
+contributors:
+    - ["Akashdeep Goel", "http://github.com/akashdeepgoel"]
+translators:
+    - ["Ale46", "https://github.com/ale46"]
+lang: it-it
+---
+
+# Programmazione dinamica
+
+## Introduzione
+
+La programmazione dinamica è una tecnica potente utilizzata per risolvere una particolare classe di problemi, come vedremo. L'idea è molto semplice, se hai risolto un problema con l'input dato, salva il risultato come riferimento futuro, in modo da evitare di risolvere nuovamente lo stesso problema.
+
+Ricordate sempre!
+"Chi non ricorda il passato è condannato a ripeterlo"
+
+## Modi per risolvere questi problemi
+
+1. *Top-Down* : Inizia a risolvere il problema specifico suddividendolo. Se vedi che il problema è già stato risolto, rispondi semplicemente con la risposta già salvata. Se non è stato risolto, risolvilo e salva la risposta. Di solito è facile da pensare e molto intuitivo. Questo è indicato come Memoization.
+
+2. *Bottom-Up* : Analizza il problema e vedi l'ordine in cui i sotto-problemi sono risolti e inizia a risolvere dal sottoproblema banale, verso il problema dato. In questo processo, è garantito che i sottoproblemi vengono risolti prima di risolvere il problema. Si parla di programmazione dinamica.
+
+## Esempio di programmazione dinamica
+
+Il problema di "Longest Increasing Subsequence" consiste nel trovare la sottosequenza crescente più lunga di una determinata sequenza. Data una sequenza `S= {a1 , a2 , a3, a4, ............., an-1, an }` dobbiamo trovare il sottoinsieme più lungo tale che per tutti gli `j` e gli `i`,  `j<i` nel sotto-insieme `aj<ai`.
+Prima di tutto dobbiamo trovare il valore delle sottosequenze più lunghe (LSi) ad ogni indice i con l'ultimo elemento della sequenza che è ai. Quindi il più grande LSi sarebbe la sottosequenza più lunga nella sequenza data. Per iniziare LSi viene inizializzato ad 1, dato che ai è un element della sequenza (Ultimo elemento). Quindi per tutti gli `j` tale che `j<i` e `aj<ai`, troviamo il più grande LSj e lo aggiungiamo a LSi. Quindi l'algoritmo richiede un tempo di *O(n2)*.
+
+Pseudo-codice per trovare la lunghezza della sottosequenza crescente più lunga:
+Questa complessità degli algoritmi potrebbe essere ridotta usando una migliore struttura dei dati piuttosto che una matrice. La memorizzazione dell'array predecessore e della variabile come `largest_sequences_so_far` e il suo indice farebbero risparmiare molto tempo.
+
+Un concetto simile potrebbe essere applicato nel trovare il percorso più lungo nel grafico aciclico diretto.
+
+```python
+for i=0 to n-1
+    LS[i]=1
+    for j=0 to i-1
+        if (a[i] >  a[j] and LS[i]<LS[j])
+            LS[i] = LS[j]+1
+for i=0 to n-1
+    if (largest < LS[i])
+```
+
+### Alcuni famosi problemi DP
+
+- Floyd Warshall Algorithm - Tutorial e Codice sorgente in C del programma: [http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code]()
+- Integer Knapsack Problem - Tutorial e Codice sorgente in C del programma: [http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem]()
+- Longest Common Subsequence - Tutorial e Codice sorgente in C del programma: [http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence]()
+
+
+## Risorse online
+
+* [codechef](https://www.codechef.com/wiki/tutorial-dynamic-programming)
diff --git a/it-it/go-it.html.markdown b/it-it/go-it.html.markdown
index e49ccd79..797f6b0b 100644
--- a/it-it/go-it.html.markdown
+++ b/it-it/go-it.html.markdown
@@ -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 abbia termine.
+	// La parola chiave "defer" inserisce una funzione in una lista.
+	// La lista contenente tutte le chiamate a funzione viene eseguita DOPO
+	// il return finale della funzione che le circonda.
 	defer fmt.Println("le istruzioni 'deferred' sono eseguite in ordine inverso (LIFO).")
 	defer fmt.Println("\nQuesta riga viene stampata per prima perché")
     // defer viene usato di solito per chiudere un file, così la funzione che
-    // chiude il file viene messa vicino a quella che lo apre.
+    // chiude il file, preceduta da "defer", viene messa vicino a quella che lo apre.
 	return true
 }
 
diff --git a/it-it/html-it.html.markdown b/it-it/html-it.html.markdown
index 471019a1..8f7391a2 100644
--- a/it-it/html-it.html.markdown
+++ b/it-it/html-it.html.markdown
@@ -1,6 +1,6 @@
 ---
 language: html
-filename: learnhtml-it.html
+filename: learnhtml-it.txt
 contributors:
     - ["Christophe THOMAS", "https://github.com/WinChris"]
 translators:
@@ -112,7 +112,7 @@ Questo articolo riguarda principalmente la sintassi HTML ed alcuni suggerimenti
 
 ## Uso
 
-HTML è scritto in files che finiscono con `.html`.
+HTML è scritto in files che finiscono con `.html` o `.htm`. Il "MIME type" è `text/html`.
 
 ## Per saperne di più
 
diff --git a/it-it/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/pyqt-it.html.markdown b/it-it/pyqt-it.html.markdown
new file mode 100644
index 00000000..855a0c75
--- /dev/null
+++ b/it-it/pyqt-it.html.markdown
@@ -0,0 +1,85 @@
+---
+category: tool
+tool: PyQT
+filename: learnpyqt.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/qt-it.html.markdown b/it-it/qt-it.html.markdown
new file mode 100644
index 00000000..4543818f
--- /dev/null
+++ b/it-it/qt-it.html.markdown
@@ -0,0 +1,161 @@
+---
+category: tool
+tool: Qt Framework
+language: c++
+filename: learnqt.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/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)