Merge remote-tracking branch 'adambard/master' into adambard/master-cn

7 files changed, 2185 insertions, 0 deletions

diff --git a/it-it/bash-it.html.markdown b/it-it/bash-it.html.markdown
new file mode 100644
index 00000000..f892845f
--- /dev/null
+++ b/it-it/bash-it.html.markdown
@@ -0,0 +1,275 @@
+---
+category: tool
+tool: bash
+contributors:
+    - ["Max Yankov", "https://github.com/golergka"]
+    - ["Darren Lin", "https://github.com/CogBear"]
+    - ["Alexandre Medeiros", "http://alemedeiros.sdf.org"]
+    - ["Denis Arh", "https://github.com/darh"]
+    - ["akirahirose", "https://twitter.com/akirahirose"]
+    - ["Anton Strömkvist", "http://lutic.org/"]
+    - ["Rahil Momin", "https://github.com/iamrahil"]
+    - ["Gregrory Kielian", "https://github.com/gskielian"]
+filename: LearnBash.sh
+translators:
+    - ["Robert Margelli", "http://github.com/sinkswim/"]
+lang: it-it
+---
+
+Bash è il nome della shell di unix, la quale è stata distribuita anche come shell del sistema oprativo GNU e la shell di default su Linux e Mac OS X.
+Quasi tutti gli esempi sottostanti possono fare parte di uno shell script o eseguiti direttamente nella shell.
+
+[Per saperne di piu'.](http://www.gnu.org/software/bash/manual/bashref.html)
+
+```bash
+#!/bin/bash
+# La prima riga dello script è lo shebang il quale dice al sistema come eseguire
+# lo script: http://it.wikipedia.org/wiki/Shabang
+# Come avrai già immaginato, i commenti iniziano con #. Lo shebang stesso è un commento.
+
+# Semplice esempio ciao mondo:
+echo Ciao mondo!
+
+# Ogni comando inizia su una nuova riga, o dopo un punto e virgola:
+echo 'Questa è la prima riga'; echo 'Questa è la seconda riga'
+
+# Per dichiarare una variabile:
+VARIABILE="Una stringa"
+
+# Ma non così:
+VARIABILE = "Una stringa"
+# Bash stabilirà che VARIABILE è un comando da eseguire e darà un errore
+# perchè non esiste.
+
+# Usare la variabile:
+echo $VARIABILE
+echo "$VARIABILE"
+echo '$VARIABILE'
+# Quando usi la variabile stessa - assegnala, esportala, oppure — scrivi
+# il suo nome senza $. Se vuoi usare il valore della variabile, devi usare $.
+# Nota che ' (singolo apice) non espande le variabili!
+
+# Sostituzione di stringhe nelle variabili
+echo ${VARIABILE/Una/A}
+# Questo sostituirà la prima occorrenza di "Una" con "La"
+
+# Sottostringa di una variabile
+echo ${VARIABILE:0:7}
+# Questo ritornerà solamente i primi 7 caratteri
+
+# Valore di default per la variabile
+echo ${FOO:-"ValoreDiDefaultSeFOOMancaOÈ Vuoto"}
+# Questo funziona per null (FOO=), stringa vuota (FOO=""), zero (FOO=0) ritorna 0
+
+# Variabili builtin:
+# Ci sono delle variabili builtin molto utili, come
+echo "Valore di ritorno dell'ultimo programma eseguito: $?"
+echo "PID dello script: $$"
+echo "Numero di argomenti: $#"
+echo "Argomenti dello script: $@"
+echo "Argomenti dello script separati in variabili distinte: $1 $2..."
+
+# Leggere un valore di input:
+echo "Come ti chiami?"
+read NOME # Nota che non abbiamo dovuto dichiarare una nuova variabile
+echo Ciao, $NOME!
+
+# Classica struttura if:
+# usa 'man test' per maggiori informazioni sulle condizionali
+if [ $NOME -ne $USER ]
+then
+    echo "Il tuo nome non è lo username"
+else
+    echo "Il tuo nome è lo username"
+fi
+
+# C'è anche l'esecuzione condizionale
+echo "Sempre eseguito" || echo "Eseguito solo se la prima condizione fallisce"
+echo "Sempre eseguito" && echo "Eseguito solo se la prima condizione NON fallisce"
+
+# Per usare && e || con l'if, c'è bisogno di piu' paia di parentesi quadre:
+if [ $NOME == "Steve" ] && [ $ETA -eq 15 ]
+then
+    echo "Questo verrà eseguito se $NOME è Steve E $ETA è 15."
+fi
+
+if [ $NOME == "Daniya" ] || [ $NOME == "Zach" ]
+then
+    echo "Questo verrà eseguito se $NAME è Daniya O Zach."
+fi
+
+# Le espressioni sono nel seguente formato:
+echo $(( 10 + 5 ))
+
+# A differenza di altri linguaggi di programmazione, bash è una shell - quindi lavora nel contesto
+# della cartella corrente. Puoi elencare i file e le cartelle nella cartella
+# corrente con il comando ls:
+ls
+
+# Questi comandi hanno opzioni che controllano la loro esecuzione:
+ls -l # Elenca tutti i file e le cartelle su una riga separata
+
+# I risultati del comando precedente possono essere passati al comando successivo come input.
+# Il comando grep filtra l'input con il pattern passato. Ecco come possiamo elencare i
+# file .txt nella cartella corrente:
+ls -l | grep "\.txt"
+
+# Puoi redirezionare l'input e l'output del comando (stdin, stdout, e stderr).
+# Leggi da stdin finchè ^EOF$ e sovrascrivi hello.py con le righe
+# comprese tra "EOF":
+cat > hello.py << EOF
+#!/usr/bin/env python
+from __future__ import print_function
+import sys
+print("#stdout", file=sys.stdout)
+print("#stderr", file=sys.stderr)
+for line in sys.stdin:
+    print(line, file=sys.stdout)
+EOF
+
+# Esegui hello.py con diverse redirezioni stdin, stdout, e stderr:
+python hello.py < "input.in"
+python hello.py > "output.out"
+python hello.py 2> "error.err"
+python hello.py > "output-and-error.log" 2>&1
+python hello.py > /dev/null 2>&1
+# Lo output error sovrascriverà il file se esiste,
+# se invece vuoi appendere usa ">>":
+python hello.py >> "output.out" 2>> "error.err"
+
+# Sovrascrivi output.txt, appendi a error.err, e conta le righe:
+info bash 'Basic Shell Features' 'Redirections' > output.out 2>> error.err
+wc -l output.out error.err
+
+# Esegui un comando e stampa il suo file descriptor (esempio: /dev/fd/123)
+# vedi: man fd
+echo <(echo "#ciaomondo")
+
+# Sovrascrivi output.txt con "#helloworld":
+cat > output.out <(echo "#helloworld")
+echo "#helloworld" > output.out
+echo "#helloworld" | cat > output.out
+echo "#helloworld" | tee output.out >/dev/null
+
+# Pulisci i file temporanei verbosamente (aggiungi '-i' per la modalità interattiva)
+rm -v output.out error.err output-and-error.log
+
+# I comandi possono essere sostituiti con altri comandi usando $( ):
+# Il comando seguente mostra il numero di file e cartelle nella
+# cartella corrente.
+echo "Ci sono $(ls | wc -l) oggetti qui."
+
+# Lo stesso puo' essere usato usando backticks `` ma non possono essere innestati - il modo migliore
+# è usando $( ).
+echo "Ci sono `ls | wc -l` oggetti qui."
+
+# Bash utilizza uno statemente case che funziona in maniera simile allo switch in Java e C++:
+case "$VARIABILE" in 
+    #Lista di pattern per le condizioni che vuoi soddisfare
+    0) echo "C'è uno zero.";;
+    1) echo "C'è un uno.";;
+    *) echo "Non è null.";;
+esac
+
+# I cicli for iterano per ogni argomento fornito:
+# I contenuti di $VARIABILE sono stampati tre volte.
+for VARIABILE in {1..3}
+do
+    echo "$VARIABILE"
+done
+
+# O scrivilo con il "ciclo for tradizionale":
+for ((a=1; a <= 3; a++))
+do
+    echo $a
+done
+
+# Possono essere usati anche per agire su file..
+# Questo eseguirà il comando 'cat' su file1 e file2
+for VARIABILE in file1 file2
+do
+    cat "$VARIABILE"
+done
+
+# ..o dall'output di un comando
+# Questo eseguirà cat sull'output di ls.
+for OUTPUT in $(ls)
+do
+    cat "$OUTPUT"
+done
+
+# while loop:
+while [ true ]
+do
+    echo "corpo del loop..."
+    break
+done
+
+# Puoi anche definire funzioni
+# Definizione:
+function foo ()
+{
+    echo "Gli argomenti funzionano come gli argomenti dello script: $@"
+    echo "E: $1 $2..."
+    echo "Questa è una funzione"
+    return 0
+}
+
+# o semplicemente
+bar ()
+{
+    echo "Un altro modo per dichiarare funzioni!"
+    return 0
+}
+
+# Per chiamare la funzione
+foo "Il mio nome è" $NOME
+
+# Ci sono un sacco di comandi utili che dovresti imparare:
+# stampa le ultime 10 righe di file.txt
+tail -n 10 file.txt
+# stampa le prime 10 righe di file.txt
+head -n 10 file.txt
+# ordina le righe di file.txt
+sort file.txt
+# riporta o ometti le righe ripetute, con -d le riporta
+uniq -d file.txt
+# stampa solamente la prima colonna prima del carattere ','
+cut -d ',' -f 1 file.txt
+# sostituisce ogni occorrenza di 'okay' con 'great' in file.txt (compatible con le regex)
+sed -i 's/okay/great/g' file.txt
+# stampa su stdout tutte le righe di file.txt che soddisfano una certa regex
+# L'esempio stampa le righe che iniziano con "foo" e che finiscono con "bar"
+grep "^foo.*bar$" file.txt
+# passa l'opzione "-c" per stampare invece il numero delle righe che soddisfano la regex
+grep -c "^foo.*bar$" file.txt
+# se vuoi letteralmente cercare la stringa,
+# e non la regex, usa fgrep (o grep -F)
+fgrep "^foo.*bar$" file.txt 
+
+
+# Leggi la documentazione dei builtin di bash con il builtin 'help' di bash:
+help
+help help
+help for
+help return
+help source
+help .
+
+# Leggi la manpage di bash con man
+apropos bash
+man 1 bash
+man bash
+
+# Leggi la documentazione con info (? per help)
+apropos info | grep '^info.*('
+man info
+info info
+info 5 info
+
+# Leggi la documentazione di bash:
+info bash
+info bash 'Bash Features'
+info bash 6
+info --apropos bash
+```
diff --git a/it-it/brainfuck-it.html.markdown b/it-it/brainfuck-it.html.markdown
new file mode 100644
index 00000000..4999d7e6
--- /dev/null
+++ b/it-it/brainfuck-it.html.markdown
@@ -0,0 +1,101 @@
+---
+
+language: brainfuck
+contributors:
+    - ["Prajit Ramachandran", "http://prajitr.github.io/"]
+    - ["Mathias Bynens", "http://mathiasbynens.be/"]
+translators:
+    - ["Ivan Sala", "http://slavni96.github.io/"]
+lang: it-it
+
+---
+
+Brainfuck è un linguaggio di programmazione estremamente minimale,
+ma è ingrado di rappresentare completamente una macchina di turnig,
+e sfrutta solo 8 caratteri.
+[Per saperne di più](http://it.wikipedia.org/wiki/Brainfuck)
+
+```
+
+Qualsiasi carattere che non sia "><+-.,[]" (escludendo gli apici) 
+viene ignorato.
+Branfuck è caratterizzato da un array (vettore) di 30,000 celle 
+inizializzare a zero, e un puntatore che punta alla cella corrente.
+
+Vi sono solo otto comando:
++ : Incrementa il valore della cella attuale di uno.
+- : Decrementa il valore della cella attuale di uno.
+> : Sposta il puntatore sulla cella seguente (prossima a destra).
+< : Sposta il puntatore sulla cella precendete (precedente a sinistra).
+. : Stampa il valore in ASCII della cella corrente. (es: 65 = 'A')
+, : Legge un singolo carattere come input per la cella corrente.
+[ : Se il valore della cella corrente è zero, conclude il ciclo 
+    andando alla sua corrispondente ].
+    Altrimenti, passa alla prossima istruzione.
+] : Se il valore della cella corrente è zero, passa alla prossima istruzione.
+    Altrimenti torna indetro fino alla [ corrispondente. 
+
+[ e ] creano un loop (while). Ovviamente dovranno essere bilanciati.
+Per ogni [ dovrà corrispondere una ]
+
+Alcuni semplici esempi di programmi scritti in Brainfuck:
+
+++++++ [ > ++++++++++ < - ] > +++++ .
+
+Questo programma stampa in output la lettera 'A'. Priam incrementa
+la cella #1 fino a 6, Quindi la cella #1 viene usata per crare un ciclo.
+Poi, entra in un loop ([) e si sposta alla cella #2.
+Incrementa la cella #2 10 volte, e torna alla cella #1, e la decrementa.
+Questo avviene 6 volte (servono che la cella #1 venga decrementata 6 volte
+per raggiungere lo 0. Quindi passa alla corrispondente ] e prosegue).
+
+A questo punto, siamo sulla cella #1, che ha valore 0, 
+la cella #2 ha valore 60 (6*10). Ci spostiamo sulla cella #2, incrementiamo
+per 5 volte, e otteniamo il valore 65, quindi stampaimo il valore della cella
+#2 (.).
+65 è 'A' in ASCII, quindi alla fine viene stampata 'A'.
+
+
+, [ > + < - ] > .
+
+Questo programma legge un carattere come input dall'utente, 
+quindi salva il carattere dentro la cella #1.
+In seguito, incominca a ciclare.
+Si sposta alla cella #², e increementa il valore della cella (#2).
+Quindi torna alla cella #1, e decrementa il valore della cella (#1).
+Questo continua fino a quando la cella #²1 diventa 0, e quindi la cella #2
+avrà il valore iniziale della cella #1.
+Infine, visto che ci troviamo sulla cella #1 alla fine del ciclo, si sposta
+sulla cella #2 e stampa il valore in ASCII.
+
+Gli spazi nel codice sovrastante, sono presenti solo a scopo di ottenere
+una maggiore leggibilità, si poteva anche scrivere senza:
+
+,[>+<-]>.
+
+Proviamo, adesso, a capire cosa fa invece questo programma:
+
+,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
+
+Prende due numeri in input e quindi li moltiplica.
+
+Prima prende in input i due numeri (,>,<), quindi inizia un cilclo
+basandosi sulla cella #1.
+Quindi si sposta sulla cella #2, e inizia un altro ciclo condizionato
+dal valore della cella #2, incrementando la cella #3.
+Arrivati a questo punto abbiamo un problema: alla fine del ciclo interno
+la cella #2 ha valore 0. In questo caso, quando il ciclo esterno rifarà
+partire il ciclo interno, non funzionerà più perchè la cella #2 ha valore 0.
+Per ovviare a questo problema, oltre alla cella 3, incrementiamo anche la cella
+#4, e alla fine di ogni ciclo interno copiala il valore della cella #4 
+nella cella #2, in modo che il ciclo interno 
+possa essere eseguito una altra volta.
+Alla fine la cella #3 contiene il risultato.
+```
+
+E questo è brainfuck...Non è difficele, vero? 
+Per divertimento adesso puoi scrivere i tuoi programmi in brainfuck,
+oppure puoi scrivere un interprete brainfuck in un altro linguaggio.
+L'interprete è abbastanza semplice da implementare, ma se sei veramente
+masochista prova ad implementare un interprete brainfuck in...
+brainfuck.
diff --git a/it-it/c++-it.html.markdown b/it-it/c++-it.html.markdown
new file mode 100644
index 00000000..e7e1d89e
--- /dev/null
+++ b/it-it/c++-it.html.markdown
@@ -0,0 +1,720 @@
+---
+language: c++
+filename: learncpp-it.cpp
+contributors:
+    - ["Steven Basart", "http://github.com/xksteven"]
+    - ["Matt Kline", "https://github.com/mrkline"]
+translators:
+    - ["Robert Margelli", "http://github.com/sinkswim/"]
+lang: it-it
+---
+
+Il C++ è un linguaggio di programmazione il quale,
+[secondo il suo inventore Bjarne Stroustrup](http://channel9.msdn.com/Events/Lang-NEXT/Lang-NEXT-2014/Keynote),
+è stato progettato per
+
+- essere un "miglior C"
+- supportare l'astrazione dei dati
+- supportare la programmazione orientata agli oggetti
+- supportare la programmazione generica
+
+Nonostante la sintassi possa risultare più difficile o complessa di linguaggi più recenti,
+è usato in maniera vasta poichè viene compilato in istruzioni macchina che possono
+essere eseguite direttamente dal processore ed offre un controllo stretto sull'hardware (come il linguaggio C)
+ed allo stesso tempo offre caratteristiche ad alto livello come i generici, le eccezioni, e le classi.
+Questa combinazione di velocità e funzionalità rende il C++
+uno dei più utilizzati linguaggi di programmazione.
+
+```c++
+//////////////////
+// Confronto con il C
+//////////////////
+
+// Il C++ è _quasi_ un superset del C e con esso condivide la sintassi di base per
+// la dichiarazione di variabili, tipi primitivi, e funzioni.
+
+// Proprio come nel C, l'inizio del programma è una funzione chiamata
+// main con un intero come tipo di ritorno,
+// Questo valore serve come stato d'uscita del programma.
+// Vedi http://it.wikipedia.org/wiki/Valore_di_uscita per maggiori informazioni.
+int main(int argc, char** argv)
+{
+    // Gli argomenti a linea di comando sono passati tramite argc e argv così come
+    // avviene in C.
+    // argc indica il numero di argomenti,
+    // e argv è un array di stringhe in stile-C (char*)
+    // che rappresenta gli argomenti.
+    // Il primo argomento è il nome che è stato assegnato al programma.
+    // argc e argv possono essere omessi se non hai bisogno di argomenti,
+    // in questa maniera la funzione avrà int main() come firma.
+
+    // Lo stato di uscita 0 indica successo.
+    return 0;
+}
+
+// Tuttavia, il C++ varia nei seguenti modi:
+
+// In C++, i caratteri come letterali sono da un byte.
+sizeof('c') == 1
+
+// In C, i caratteri come letterali sono della stessa dimensione degli interi.
+sizeof('c') == sizeof(10)
+
+
+// C++ ha prototipizzazione rigida
+void func(); // funziona che non accetta argomenti
+
+// In C
+void func(); // funzione che può accettare un qualsiasi numero di argomenti
+
+// Usa nullptr invece di NULL in C++
+int* ip = nullptr;
+
+// Gli header C standard sono disponibili in C++,
+// ma sono prefissati con "c" e non hanno il suffisso ".h".
+#include <cstdio>
+
+int main()
+{
+    printf("Ciao, mondo!\n");
+    return 0;
+}
+
+///////////////////////////////
+// Overloading per le funzioni
+//////////////////////////////
+
+// Il C++ supporta l'overloading per le funzioni
+// sia dato che ogni funzione accetta parametri diversi.
+
+void print(char const* myString)
+{
+    printf("Stringa %s\n", myString);
+}
+
+void print(int myInt)
+{
+    printf("Il mio int è %d", myInt);
+}
+
+int main()
+{
+    print("Ciao"); // Viene chiamata void print(const char*)
+    print(15); //  Viene chiamata void print(int)
+}
+
+////////////////////////
+// Argomenti di default
+///////////////////////
+
+// Puoi fornire argomenti di default per una funzione
+// se non sono forniti dal chiamante.
+
+void faiQualcosaConInteri(int a = 1, int b = 4)
+{
+    // fai qualcosa con gli interi qui
+}
+
+int main()
+{
+    faiQualcosaConInteri();      // a = 1,  b = 4
+    faiQualcosaConInteri(20);    // a = 20, b = 4
+    faiQualcosaConInteri(20, 5); // a = 20, b = 5
+}
+
+// Gli argomenti di default devono essere alla fine della lista degli argomenti.
+
+void dichiarazioneInvalida(int a = 1, int b) // Errore!
+{
+}
+
+
+/////////////
+// Namespaces
+/////////////
+
+// I namespaces forniscono visibilità separata per dichiarazioni di variabili, funzioni,
+// ed altro.
+// I namespaces possono essere annidati.
+
+namespace Primo {
+    namespace Annidato {
+        void foo()
+        {
+            printf("Questa è Primo::Annidato::foo\n");
+        }
+    } // fine di namespace Annidato
+} // fine di namespace Primo
+
+namespace Secondo {
+    void foo()
+    {
+        printf("Questa è Secondo::foo\n")
+    }
+}
+
+void foo()
+{
+    printf("Questa è foo globale\n");
+}
+
+int main()
+{
+    // Assume che tutto venga dal namespace "Secondo"
+    // a meno che non venga dichiarato altrimenti.
+    using namespace Secondo;
+
+    foo(); // stampa "Questa è Secondo::foo"
+    Primo::Annidato::foo(); // stampa "Questa è Primo::Annidato::foo"
+    ::foo(); // stampa "Questa è foo globale"
+}
+
+///////////////
+// Input/Output
+///////////////
+
+// L'input e l'output in C++ utilizza gli streams
+// cin, cout, e cerr i quali rappresentano stdin, stdout, e stderr.
+// << è l'operatore di inserzione >> è l'operatore di estrazione.
+
+#include <iostream> // Include gli streams di I/O
+
+using namespace std; // Gli streams sono nel namespace std (libreria standard)
+
+int main()
+{
+   int myInt;
+
+   // Stampa su stdout (o terminalee/schermo)
+   cout << "Inserisci il tuo numero preferito:\n";
+   // Prende l'input
+   cin >> myInt;
+
+   // cout può anche essere formattato
+   cout << "Il tuo numero preferito è " << myInt << "\n";
+   // stampa "Il tuo numero preferito è <myInt>"
+
+    cerr << "Usato per messaggi di errore";
+}
+
+////////////
+// Stringhe
+///////////
+
+// Le stringhe in C++ sono oggetti ed hanno molte funzioni membro
+#include <string>
+
+using namespace std; // Anche le stringhe sono contenute nel namespace std (libreria standard)
+
+string myString = "Ciao";
+string myOtherString = " Mondo";
+
+// + è usato per la concatenazione.
+cout << myString + myOtherString; // "Ciao Mondo"
+
+cout << myString + " Bella"; // "Ciao Bella"
+
+// le stringhe in C++ possono essere modificate.
+myString.append(" Mario");
+cout << myString; // "Ciao Mario"
+
+
+///////////////
+// Riferimenti
+//////////////
+
+// Oltre ai puntatori come quelli in C,
+// il C++ ha i _riferimenti_.
+// Questi non sono tipi puntatori che non possono essere riassegnati una volta settati
+// e non possono essere null.
+// Inoltre, essi hanno la stessa sintassi della variabile stessa:
+// * non è necessario per la dereferenziazione e
+// & ("indirizzo di") non è usato per l'assegnamento.
+
+using namespace std;
+
+string foo = "Io sono foo";
+string bar = "Io sono bar";
+
+
+string& fooRef = foo; // Questo crea un riferimento a foo.
+fooRef += ". Ciao!"; // Modifica foo attraverso il riferimento
+cout << fooRef; // Stampa "Io sono foo. Ciao!"
+
+// Non riassegna "fooRef". Questo è come scrivere "foo = bar", e
+//   foo == "Io sono bar"
+// dopo questa riga.
+fooRef = bar;
+
+const string& barRef = bar; // Crea un riferimento const a bar.
+// Come in C, i valori const (i puntatori e i riferimenti) non possono essere modificati.
+barRef += ". Ciao!"; // Errore, i riferimenti const non possono essere modificati.
+
+//////////////////////////////////////////////////
+// Classi e programmazione orientata agli oggetti
+/////////////////////////////////////////////////
+
+// Primo esempio delle classi
+#include <iostream>
+
+// Dichiara una classe.
+// Le classi sono in genere dichiara in un header file (.h o .hpp).
+class Cane {
+    // Variabili e funzioni membro sono private di default.
+    std::string nome;
+    int peso;
+
+// Tutti i membri dopo questo sono pubblici (public)
+// finchè "private:" o "protected:" non compaiono.
+public:
+
+    // Costruttore di default
+    Cane();
+
+    // Dichiarazioni di funzioni membro (le implentazioni sono a seguito)
+    // Nota che stiamo usando std::string invece di porre
+    // using namespace std;
+    // sopra.
+    // Mai usare uno statement "using namespace" in uno header.
+    void impostaNome(const std::string& nomeCane);
+
+    void impostaPeso(int pesoCane);
+
+    // Le funzioni che non modificano lo stato dell'oggetto
+    // dovrebbero essere marcate come const.
+    // Questo permette di chiamarle con un riferimento const all'oggetto.
+    // Inoltre, nota che le funzioni devono essere dichiarate espliciamente come _virtual_
+    // per essere sovrascritte in classi derivate.
+    // Le funzioni non sono virtual di default per motivi di performance.
+    virtual void print() const;
+
+    // Le funzioni possono essere definite anche all'interno del corpo della classe.
+    // Le funzioni definite in questo modo sono automaticamente inline.
+    void abbaia() const { std::cout << nome << " abbaia!\n"; }
+
+    // Assieme con i costruttori, il C++ fornisce i distruttori.
+    // Questi sono chiamati quando un oggetto è rimosso o esce dalla visibilità.
+    // Questo permette paradigmi potenti come il RAII
+    // (vedi sotto)
+    // I distruttori devono essere virtual per permettere a classi di essere derivate da questa.
+    virtual ~Dog();
+
+}; // Un punto e virgola deve seguire la definizione della funzione
+
+// Le funzioni membro di una classe sono generalmente implementate in files .cpp .
+void Cane::Cane()
+{
+    std::cout << "Un cane è stato costruito\n";
+}
+
+// Gli oggetti (ad esempio le stringhe) devono essere passati per riferimento
+// se li stai modificando o come riferimento const altrimenti.
+void Cane::impostaNome(const std::string& nomeCane)
+{
+    nome = nomeCane;
+}
+
+void Cane::impostaPeso(int pesoCane)
+{
+    peso = pesoCane;
+}
+
+// Notare che "virtual" è solamente necessario nelle dichiarazioni, non nelle definizioni.
+void Cane::print() const
+{
+    std::cout << "Il cane è " << nome << " e pesa " << peso << "kg\n";
+}
+
+void Cane::~Cane()
+{
+    cout << "Ciao ciao " << nome << "\n";
+}
+
+int main() {
+    Cane myDog; // stampa "Un cane è stato costruito"
+    myDog.impostaNome("Barkley");
+    myDog.impostaPeso(10);
+    myDog.print(); // stampa "Il cane è Barkley e pesa 10 kg"
+    return 0;
+} // stampa "Ciao ciao Barkley"
+
+// Ereditarietà:
+
+// Questa classe eredita tutto ciò che è public e protected dalla classe Cane
+class MioCane : public Cane {
+
+    void impostaProprietario(const std::string& proprietarioCane)
+
+    // Sovrascrivi il comportamento della funzione print per tutti i MioCane. Vedi
+    // http://it.wikipedia.org/wiki/Polimorfismo_%28informatica%29
+    // per una introduzione più generale se non sei familiare con
+    // il polimorfismo.
+    // La parola chiave override è opzionale ma fa sì che tu stia effettivamente
+    // sovrascrivendo il metodo nella classe base.
+    void print() const override;
+
+private:
+    std::string proprietario;
+};
+
+// Nel frattempo, nel file .cpp corrispondente:
+
+void MioCane::impostaProprietario(const std::string& proprietarioCane)
+{
+    proprietario = proprietarioCane;
+}
+
+void MioCane::print() const
+{
+    Cane::print(); // Chiama la funzione print nella classe base Cane
+    std::cout << "Il cane è di " << proprietario << "\n";
+    // stampa "Il cane è <nome> e pesa <peso>"
+    //        "Il cane è di <proprietario>"
+}
+
+///////////////////////////////////////////////////
+// Inizializzazione ed Overloading degli Operatori
+//////////////////////////////////////////////////
+
+// In C++ puoi sovrascrivere il comportamento di operatori come +, -, *, /, ecc...
+// Questo è possibile definendo una funzione che viene chiamata
+// ogniqualvolta l'operatore è usato.
+
+#include <iostream>
+using namespace std;
+
+class Punto {
+public:
+    // Così si assegna alle variabili membro un valore di default.
+    double x = 0;
+    double y = 0;
+
+    // Definisce un costruttore di default che non fa nulla
+    // ma inizializza il Punto ai valori di default (0, 0)
+    Punto() { };
+
+    // La sintassi seguente è nota come lista di inizializzazione
+    // ed è il modo appropriato di inizializzare i valori membro della classe
+    Punto (double a, double b) :
+        x(a),
+        y(b)
+    { /* Non fa nulla eccetto inizializzare i valori */ }
+
+    // Sovrascrivi l'operatore +.
+    Punto operator+(const Punto& rhs) const;
+
+    // Sovrascrivi l'operatore +=
+    Punto& operator+=(const Punto& rhs);
+
+    // Avrebbe senso aggiungere gli operatori - e -=,
+    // ma li saltiamo per rendere la guida più breve.
+};
+
+Punto Punto::operator+(const Punto& rhs) const
+{
+    // Crea un nuovo punto come somma di questo e di rhs.
+    return Punto(x + rhs.x, y + rhs.y);
+}
+
+Punto& Punto::operator+=(const Punto& rhs)
+{
+    x += rhs.x;
+    y += rhs.y;
+    return *this;
+}
+
+int main () {
+    Punto su (0,1);
+    Punto destro (1,0);
+    // Questo chiama l'operatore + di Punto
+    // Il Punto su chiama la funzione + con destro come argomento
+    Punto risultato = su + destro;
+    // Stampa "Risultato è spostato in (1,1)"
+    cout << "Risultato è spostato (" << risultato.x << ',' << risultato.y << ")\n";
+    return 0;
+}
+
+/////////////////
+// Templates
+////////////////
+
+// Generalmente i templates in C++ sono utilizzati per programmazione generica, anche se
+// sono molto più potenti dei costrutti generici in altri linguaggi. Inoltre,
+// supportano specializzazione esplicita e parziale, classi in stile funzionale,
+// e sono anche complete per Turing.
+
+// Iniziamo con il tipo di programmazione generica con cui forse sei familiare. Per
+// definire una classe o una funzione che prende un parametro di un dato tipo:
+template<class T>
+class Box {
+    // In questa classe, T può essere usato come qualsiasi tipo.
+    void inserisci(const T&) { ... }
+};
+
+// Durante la compilazione, il compilatore in effetti genera copie di ogni template
+// con i parametri sostituiti, e così la definizione completa della classe deve essere
+// presente ad ogni invocazione. Questo è il motivo per cui vedrai le classi template definite
+// interamente in header files.
+
+// Per instanziare una classe template sullo stack:
+Box<int> intBox;
+
+// e puoi usarla come aspettato:
+intBox.inserisci(123);
+
+//Puoi, ovviamente, innestare i templates:
+Box<Box<int> > boxOfBox;
+boxOfBox.inserisci(intBox);
+
+// Fino al C++11, devi porre uno spazio tra le due '>', altrimenti '>>'
+// viene visto come l'operatore di shift destro.
+
+// Qualche volta vedrai
+// template<typename T>
+// invece. La parole chiavi 'class' e 'typename' sono _generalmente_
+// intercambiabili in questo caso. Per una spiegazione completa, vedi
+// http://en.wikipedia.org/wiki/Typename
+// (si, quella parola chiave ha una sua pagina di Wikipedia propria).
+
+// Similmente, una funzione template:
+template<class T>
+void abbaiaTreVolte(const T& input)
+{
+    input.abbaia();
+    input.abbaia();
+    input.abbaia();
+}
+
+// Nota che niente è specificato relativamente al tipo di parametri. Il compilatore
+// genererà  e poi verificherà il tipo di ogni invocazione del template, così che
+// la funzione di cui sopra funzione con ogni tipo 'T' che ha const 'abbaia' come metodo!
+
+Cane fluffy;
+fluffy.impostaNome("Fluffy")
+abbaiaTreVolte(fluffy); // Stampa "Fluffy abbaia" tre volte.
+
+// I parametri template non devono essere classi:
+template<int Y>
+void stampaMessaggio() {
+  cout << "Impara il C++ in " << Y << " minuti!" << endl;
+}
+
+// E poi esplicitamente specializzare i template per avere codice più efficiente. Ovviamente,
+// la maggior parte delle casistiche reali non sono così triviali.
+// Notare che avrai comunque bisogna di dichiarare la funzione (o classe) come un template
+// anche se hai esplicitamente specificato tutti i parametri.
+template<>
+void stampaMessaggio<10>() {
+  cout << "Impara il C++ più velocemente in soli 10 minuti!" << endl;
+}
+
+printMessage<20>();  // Stampa "impara il C++ in 20 minuti!"
+printMessage<10>();  // Stampa "Impara il C++ più velocemente in soli 10 minuti!"                                   
+                                        
+////////////////////////////
+// Gestione delle eccezioni
+///////////////////////////
+
+// La libreria standard fornisce un paio di tipi d'eccezioni
+// (vedi http://en.cppreference.com/w/cpp/error/exception)
+// ma ogni tipo può essere lanciato come eccezione
+#include <exception>
+
+// Tutte le eccezioni lanciate all'interno del blocco _try_ possono essere catturate dai successivi 
+// handlers _catch_.
+try {
+    // Non allocare eccezioni nello heap usando _new_.
+    throw std::exception("È avvenuto un problema");
+}
+// Cattura le eccezioni come riferimenti const se sono oggetti
+catch (const std::exception& ex)
+{
+  std::cout << ex.what();
+// Cattura ogni eccezioni non catturata dal blocco _catch_ precedente
+} catch (...)
+{
+    std::cout << "Catturata un'eccezione sconosciuta";
+    throw; // Rilancia l'eccezione
+}
+
+///////
+// RAII
+///////
+
+// RAII sta per Resource Allocation Is Initialization.
+// Spesso viene considerato come il più potente paradigma in C++.
+// È un concetto semplice: un costruttore di un oggetto
+// acquisisce le risorse di tale oggetto ed il distruttore le rilascia.
+
+// Per comprendere come questo sia vantaggioso,
+// consideriamo una funzione che usa un gestore di file in C:
+void faiQualcosaConUnFile(const char* nomefile)
+{
+    // Per cominciare, assumiamo che niente possa fallire.
+
+    FILE* fh = fopen(nomefile, "r"); // Apri il file in modalità lettura.
+
+    faiQualcosaConIlFile(fh);
+    faiQualcosAltroConEsso(fh);
+
+    fclose(fh); // Chiudi il gestore di file.
+}
+
+// Sfortunatamente, le cose vengono complicate dalla gestione degli errori.
+// Supponiamo che fopen fallisca, e che faiQualcosaConUnFile e
+// faiQualcosAltroConEsso ritornano codici d'errore se falliscono.
+// (Le eccezioni sono la maniera preferita per gestire i fallimenti,
+//  ma alcuni programmatori, specialmente quelli con un passato in C,
+//  non sono d'accordo con l'utilità delle eccezioni).
+// Adesso dobbiamo verificare che ogni chiamata per eventuali fallimenti e chiudere il gestore di file
+// se un problema è avvenuto.
+bool faiQualcosaConUnFile(const char* nomefile)
+{
+    FILE* fh = fopen(nomefile, "r"); // Apre il file in modalità lettura
+    if (fh == nullptr) // Il puntatore restituito è null in caso di fallimento.
+        return false; // Riporta il fallimento al chiamante.
+
+    // Assumiamo che ogni funzione ritorni false se ha fallito
+    if (!faiQualcosaConIlFile(fh)) {
+        fclose(fh); // Chiude il gestore di file così che non sprechi memoria.
+        return false; // Propaga l'errore.
+    }
+    if (!faiQualcosAltroConEsso(fh)) {
+        fclose(fh); // Chiude il gestore di file così che non sprechi memoria.
+        return false; // Propaga l'errore.
+    }
+
+    fclose(fh); // Chiudi il gestore di file così che non sprechi memoria.
+    return true; // Indica successo
+}
+
+// I programmatori C in genere puliscono questa procedura usando goto:
+bool faiQualcosaConUnFile(const char* nomefile)
+{
+    FILE* fh = fopen(nomefile, "r");
+    if (fh == nullptr)
+        return false;
+
+    if (!faiQualcosaConIlFile(fh))
+        goto fallimento;
+
+    if (!faiQualcosAltroConEsso(fh))
+        goto fallimento;
+
+    fclose(fh); // Chiude il file
+    return true; // Indica successo
+
+fallimento:
+    fclose(fh);
+    return false; // Propaga l'errore
+}
+
+// Se le funzioni indicano errori usando le eccezioni,
+// le cose sono un pò più pulite, ma sono sempre sub-ottimali.
+void faiQualcosaConUnFile(const char* nomefile)
+{
+    FILE* fh = fopen(nomefile, "r"); // Apre il file in modalità lettura
+    if (fh == nullptr)
+        throw std::exception("Non è stato possibile aprire il file.").
+
+    try {
+        faiQualcosaConIlFile(fh);
+        faiQualcosAltroConEsso(fh);
+    }
+    catch (...) {
+        fclose(fh); // Fai sì che il file venga chiuso se si ha un errore.
+        throw; // Poi rilancia l'eccezione.
+    }
+
+    fclose(fh); // Chiudi il file
+    // Tutto è andato bene
+}
+
+// Confronta questo con l'utilizzo della classe C++ file stream (fstream)
+// fstream usa i distruttori per chiudere il file.
+// Come detto sopra, i distruttori sono automaticamente chiamati
+// ogniqualvolta un oggetto esce dalla visibilità.
+void faiQualcosaConUnFile(const std::string& nomefile)
+{
+    // ifstream è l'abbreviazione di input file stream
+    std::ifstream fh(nomefile); // Apre il file
+
+    // Fai qualcosa con il file
+    faiQualcosaConIlFile(fh);
+    faiQualcosAltroConEsso(fh);
+
+} // Il file viene chiuso automaticamente chiuso qui dal distruttore
+
+// Questo ha vantaggi _enormi_:
+// 1. Può succedere di tutto ma
+//    la risorsa (in questo caso il file handler) verrà ripulito.
+//    Una volta che scrivi il distruttore correttamente,
+//    È _impossibile_ scordarsi di chiudere l'handler e sprecare memoria.
+// 2. Nota che il codice è molto più pulito.
+//    Il distruttore gestisce la chiusura del file dietro le scene
+//    senza che tu debba preoccupartene.
+// 3. Il codice è sicuro da eccezioni.
+//    Una eccezione può essere lanciata in qualunque punto nella funzione e la ripulitura
+//    avverrà lo stesso.
+
+// Tutto il codice C++ idiomatico usa RAII in maniera vasta su tutte le risorse.
+// Esempi aggiuntivi includono
+// - Utilizzo della memoria con unique_ptr e shared_ptr
+// - I contenitori - la lista della libreria standard,
+//   vettori (i.e. array auto-aggiustati), mappe hash, e così via
+//   sono tutti automaticamente distrutti con i loro contenuti quando escono dalla visibilità.
+// - I mutex usano lock_guard e unique_lock
+
+///////////////////////
+// Roba divertente
+//////////////////////
+
+// Aspetti del C++ che potrebbero sbalordire i nuovi arrivati (e anche qualche veterano).
+// Questa sezione è, sfortunatamente, selvaggiamente incompleta; il C++ è uno dei linguaggi
+// più facili con cui puoi spararti da solo nel piede.
+
+// Puoi sovrascrivere metodi privati!
+class Foo {
+  virtual void bar();
+};
+class FooSub : public Foo {
+  virtual void bar();  // sovrascrive Foo::bar!
+};
+
+
+// 0 == false == NULL (la maggior parte delle volte)!
+bool* pt = new bool;
+*pt = 0;  // Setta il valore puntato da 'pt' come falso.
+pt = 0;  // Setta 'pt' al puntatore null. Entrambe le righe vengono compilate senza warnings.
+
+// nullptr dovrebbe risolvere alcune di quei problemi:
+int* pt2 = new int;
+*pt2 = nullptr;  // Non compila
+pt2 = nullptr;  // Setta pt2 a null.
+
+// Ma in qualche modo il tipo 'bool' è una eccezione (questo è per rendere compilabile `if (ptr)`.
+*pt = nullptr;  // Questo compila, anche se '*pt' è un bool! 
+
+
+// '=' != '=' != '='!
+// Chiama Foo::Foo(const Foo&) o qualche variante del costruttore di copia.
+Foo f2;
+Foo f1 = f2;
+
+// Chiama Foo::Foo(const Foo&) o qualche variante, ma solo copie di 'Foo' che fanno parte di
+// 'fooSub'. Ogni altro membro di 'fooSub' viene scartato. Questo comportamento
+// orribile viene chiamato "object slicing."
+FooSub fooSub;
+Foo f1 = fooSub;
+
+// Chiama Foo::operator=(Foo&) o una sua variante.
+Foo f1;
+f1 = f2;
+
+```
+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>
diff --git a/it-it/coffeescript-it.html.markdown b/it-it/coffeescript-it.html.markdown
new file mode 100644
index 00000000..16eb9bd4
--- /dev/null
+++ b/it-it/coffeescript-it.html.markdown
@@ -0,0 +1,107 @@
+---
+language: coffeescript
+contributors:
+  - ["Luca 'Kino' Maroni", "http://github.com/kino90"]
+  - ["Tenor Biel", "http://github.com/L8D"]
+  - ["Xavier Yao", "http://github.com/xavieryao"]
+filename: coffeescript-it.coffee
+lang: it-it
+---
+
+CoffeeScript è un piccolo linguaggio che compila direttamente nell'equivalente
+JavaScript, non c'è nessuna interpretazione a runtime. Come possibile 
+successore di Javascript, CoffeeScript fa il suo meglio per restituire 
+un codice leggibile, ben stampato e performante in ogni ambiente JavaScript.
+
+Guarda anche [il sito di CoffeeScript](http://coffeescript.org/), che ha una 
+guida completa a CoffeeScript.
+
+```coffeescript
+# CoffeeScript è un linguaggio hipster.
+# Segue le mode di alcuni linguaggi moderni.
+# Quindi i commenti sono come quelli di Ruby e Python, usano il cancelletto.
+
+###
+I blocchi di commenti sono definiti con tre cancelletti, che vengono tradotti 
+direttamente in `/*` e `*/` nel codice JavaScript risultante.
+
+Prima di continuare devi conoscere la maggior parte
+delle semantiche JavaScript.
+###
+
+# Assegnamento:
+numero   = 42 #=> var numero = 42;
+contrario = true #=> var contrario = true;
+
+# Condizioni:
+numero = -42 if contrario #=> if(contrario) { numero = -42; }
+
+# Funzioni:
+quadrato = (x) -> x * x #=> var quadrato = function(x) { return x * x; }
+
+riempi = (contenitore, liquido = "caffè") ->
+  "Sto riempiendo #{contenitore} con #{liquido}..."
+#=>var riempi;
+#
+#riempi = function(contenitore, liquido) {
+#  if (liquido == null) {
+#    liquido = "caffè";
+#  }
+#  return "Sto riempiendo " + contenitore + " con " + liquido + "...";
+#};
+
+# Intervalli:
+lista = [1..5] #=> var lista = [1, 2, 3, 4, 5];
+
+# Oggetti:
+matematica =
+  radice:   Math.sqrt
+  quadrato: quadrato
+  cubo:   (x) -> x * quadrato x
+#=> var matematica = {
+#  "radice": Math.sqrt,
+#  "quadrato": quadrato,
+#  "cubo": function(x) { return x * quadrato(x); }
+#}
+
+# Splats:
+gara = (vincitore, partecipanti...) ->
+  print vincitore, partecipanti
+#=>gara = function() {
+#  var partecipanti, vincitore;
+#  vincitore = arguments[0], partecipanti = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
+#  return print(vincitore, partecipanti);
+#};
+
+# Esistenza:
+alert "Lo sapevo!" if elvis?
+#=> if(typeof elvis !== "undefined" && elvis !== null) { alert("Lo sapevo!"); }
+
+# Comprensione degli Array:
+cubi = (matematica.cubo num for num in lista) 
+#=>cubi = (function() {
+#	var _i, _len, _results;
+#	_results = [];
+# 	for (_i = 0, _len = lista.length; _i < _len; _i++) {
+#		num = lista[_i];
+#		_results.push(matematica.cubo(num));
+#	}
+#	return _results;
+#  })();
+
+cibi = ['broccoli', 'spinaci', 'cioccolato']
+mangia cibo for cibo in cibi when cibo isnt 'cioccolato'
+#=>cibi = ['broccoli', 'spinaci', 'cioccolato'];
+#
+#for (_k = 0, _len2 = cibi.length; _k < _len2; _k++) {
+#  cibo = cibi[_k];
+#  if (cibo !== 'cioccolato') {
+#    mangia(cibo);
+#  }
+#}
+```
+
+## Altre risorse
+
+- [Smooth CoffeeScript](http://autotelicum.github.io/Smooth-CoffeeScript/)
+- [CoffeeScript Ristretto](https://leanpub.com/coffeescript-ristretto/read)
diff --git a/it-it/elixir-it.html.markdown b/it-it/elixir-it.html.markdown
new file mode 100644
index 00000000..f5d0c172
--- /dev/null
+++ b/it-it/elixir-it.html.markdown
@@ -0,0 +1,418 @@
+---
+language: elixir
+contributors:
+    - ["Luca 'Kino' Maroni", "https://github.com/kino90"]
+    - ["Joao Marques", "http://github.com/mrshankly"]
+    - ["Dzianis Dashkevich", "https://github.com/dskecse"]
+filename: learnelixir-it.ex
+lang: it-it
+---
+
+Elixir è un linguaggio funzionale moderno, costruito sulla VM Erlang.
+È totalmente compatibile con Erlang, ma con una sintassi più standard
+e molte altre funzionalità.
+
+```elixir
+
+# I commenti su una riga iniziano con un cancelletto.
+
+# Non esistono commenti multilinea,
+# ma puoi concatenare più commenti.
+
+# 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 
+# elixir correttamente.
+
+## ---------------------------
+## -- Tipi di base
+## ---------------------------
+
+# Numeri
+3    # intero (Integer)
+0x1F # intero
+3.0  # decimale (Float)
+
+# Atomi, che sono literals, una costante con un nome. Iniziano con `:`.
+:ciao # atomo (Atom)
+
+# Tuple che sono salvate in celle di memoria contigue.
+{1,2,3} # tupla (Tuple)
+
+# Possiamo accedere ad un elemento di una tupla con la funzione `elem`:
+elem({1, 2, 3}, 0) #=> 1
+
+# Liste, che sono implementate come liste concatenate (o linked list).
+[1,2,3] # lista (List)
+
+# Possiamo accedere alla testa (head) e alla coda (tail) delle liste così:
+[testa | coda] = [1,2,3]
+testa #=> 1
+coda #=> [2,3]
+
+# In Elixir, proprio come in Erlang, il simbolo `=` denota pattern matching e
+# non un assegnamento.
+#
+# Questo significa che la parte sinistra (pattern) viene confrontata alla
+# parte destra.
+#
+# Questo spiega il funzionamento dell'esempio dell'accesso alla lista di prima.
+
+# Un pattern match darà errore quando le parti non combaciano, ad esempio se
+# 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 
+<<1,2,3>> # binari (Binary)
+
+# Stringhe e liste di caratteri
+"ciao" # stringa (String)
+'ciao' # lista di caratteri (List)
+
+# Stringhe multilinea
+"""
+Sono una stringa
+multi-linea.
+"""
+#=> "Sono una stringa\nmulti-linea.\n"
+
+# Le stringhe sono tutte codificate in UTF-8:
+"cìaò" 
+#=> "cìaò"
+
+# le stringhe in realtà sono dei binari, e le liste di caratteri sono liste.
+<<?a, ?b, ?c>> #=> "abc"
+[?a, ?b, ?c]   #=> 'abc'
+
+# `?a` in elixir restituisce il valore ASCII della lettera `a`
+?a #=> 97
+
+# Per concatenare liste si usa `++`, per binari si usa `<>`
+[1,2,3] ++ [4,5]     #=> [1,2,3,4,5]
+'ciao ' ++ 'mondo'  #=> 'ciao mondo'
+
+<<1,2,3>> <> <<4,5>> #=> <<1,2,3,4,5>>
+"ciao " <> "mondo"  #=> "ciao mondo"
+
+# Gli intervalli sono rappresentati come `inizio..fine` (estremi inclusi)
+1..10 #=> 1..10 (Range)
+minore..maggiore = 1..10 # Puoi fare pattern matching anche sugli intervalli
+[minore, maggiore] #=> [1, 10]
+
+## ---------------------------
+## -- Operatori
+## ---------------------------
+
+# Un po' di matematica
+1 + 1  #=> 2
+10 - 5 #=> 5
+5 * 2  #=> 10
+10 / 2 #=> 5.0
+
+# In elixir l'operatore `/` restituisce sempre un decimale.
+
+# Per fare una divisione intera si usa `div`
+div(10, 2) #=> 5
+
+# Per ottenere il resto di una divisione si usa `rem`
+rem(10, 3) #=> 1
+
+# Ci sono anche gli operatori booleani: `or`, `and` e `not`.
+# Questi operatori si aspettano un booleano come primo argomento.
+true and true #=> true
+false or true #=> true
+# 1 and true    #=> ** (ArgumentError) argument error
+
+# Elixir fornisce anche `||`, `&&` e `!` che accettano argomenti
+# di qualsiasi tipo. 
+# Tutti i valori tranne `false` e `nil` saranno valutati come true.
+1 || true  #=> 1
+false && 1 #=> false
+nil && 20  #=> nil
+!true #=> false
+
+# Per i confronti abbiamo: `==`, `!=`, `===`, `!==`, `<=`, `>=`, `<` e `>`
+1 == 1 #=> true
+1 != 1 #=> false
+1 < 2  #=> true
+
+# `===` e `!==` sono più rigidi quando si confrontano interi e decimali:
+1 == 1.0  #=> true
+1 === 1.0 #=> false
+
+# Possiamo anche confrontare tipi di dato diversi:
+1 < :ciao #=> true
+
+# L'ordine generale è definito sotto:
+# numeri < atomi < riferimenti < funzioni < porte < pid < tuple < liste 
+#   < stringhe di bit
+
+# Per citare Joe Armstrong su questo: "L'ordine non è importante,
+# ma è importante che sia definito un ordine."
+
+## ---------------------------
+## -- Controllo di flusso
+## ---------------------------
+
+# espressione `se` (`if`)
+if false do
+  "Questo non si vedrà mai"
+else
+  "Questo sì"
+end
+
+# c'è anche un `se non` (`unless`)
+unless true do
+  "Questo non si vedrà mai"
+else
+  "Questo sì"
+end
+
+# 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:
+case {:uno, :due} do
+  {:quattro, :cinque} ->
+    "Questo non farà match"
+  {:uno, x} ->
+    "Questo farà match e binderà `x` a `:due`"
+  _ ->
+    "Questo farà match con qualsiasi valore"
+end
+
+# Solitamente si usa `_` se non si ha bisogno di utilizzare un valore.
+# Ad esempio, se ci serve solo la testa di una lista:
+[testa | _] = [1,2,3]
+testa #=> 1
+
+# Per aumentare la leggibilità possiamo usarlo in questo modo:
+[testa | _coda] = [:a, :b, :c]
+testa #=> :a
+
+# `cond` ci permette di verificare più condizioni allo stesso momento.
+# Usa `cond` invece di innestare più espressioni `if`.
+cond do
+  1 + 1 == 3 ->
+    "Questa stringa non si vedrà mai"
+  2 * 5 == 12 ->
+    "Nemmeno questa"
+  1 + 2 == 3 ->
+    "Questa sì!"
+end
+
+# È pratica comune mettere l'ultima condizione a `true`, che farà sempre match
+cond do
+  1 + 1 == 3 ->
+    "Questa stringa non si vedrà mai"
+  2 * 5 == 12 ->
+    "Nemmeno questa"
+  true ->
+    "Questa sì! (essenzialmente funziona come un else)"
+end
+
+# `try/catch` si usa per gestire i valori lanciati (throw), 
+# Supporta anche una clausola `after` che è invocata in ogni caso.
+try do
+  throw(:ciao)
+catch
+  message -> "Ho ricevuto #{message}."
+after
+  IO.puts("Io sono la clausola 'after'.")
+end
+#=> Io sono la clausola 'after'
+# "Ho ricevuto :ciao"
+
+## ---------------------------
+## -- Moduli e Funzioni
+## ---------------------------
+
+# Funzioni anonime (notare il punto)
+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, 
+# sono indicate dalla parola chiave `when`:
+f = fn
+  x, y when x > 0 -> x + y
+  x, y -> x * y
+end
+
+f.(1, 3)  #=> 4
+f.(-1, 3) #=> -3
+
+# Elixir fornisce anche molte funzioni, disponibili nello scope corrente.
+is_number(10)    #=> true
+is_list("ciao") #=> false
+elem({1,2,3}, 0) #=> 1
+
+# Puoi raggruppare delle funzioni all'interno di un modulo.
+# All'interno di un modulo usa `def` per definire le tue funzioni.
+defmodule Matematica do
+  def somma(a, b) do
+    a + b
+  end
+
+  def quadrato(x) do
+    x * x
+  end
+end
+
+Matematica.somma(1, 2)  #=> 3
+Matematica.quadrato(3) #=> 9
+
+# 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 
+# altri moduli, una funziona privata può essere invocata solo localmente.
+defmodule MatematicaPrivata do
+  def somma(a, b) do
+    esegui_somma(a, b)
+  end
+
+  defp esegui_somma(a, b) do
+    a + b
+  end
+end
+
+MatematicaPrivata.somma(1, 2)    #=> 3
+# MatematicaPrivata.esegui_somma(1, 2) #=> ** (UndefinedFunctionError)
+
+# Anche le dichiarazioni di funzione supportano guardie e condizioni multiple:
+defmodule Geometria do
+  def area({:rettangolo, w, h}) do
+    w * h
+  end
+
+  def area({:cerchio, r}) when is_number(r) do
+    3.14 * r * r
+  end
+end
+
+Geometria.area({:rettangolo, 2, 3}) #=> 6
+Geometria.area({:cerchio, 3})       #=> 28.25999999999999801048
+# Geometria.area({:cerchio, "non_un_numero"})
+#=> ** (FunctionClauseError) no function clause matching in Geometria.area/1
+
+# A causa dell'immutabilità dei dati, la ricorsione è molto frequente in elixir
+defmodule Ricorsione do
+  def somma_lista([testa | coda], accumulatore) do
+    somma_lista(coda, accumulatore + testa)
+  end
+
+  def somma_lista([], accumulatore) do
+    accumulatore
+  end
+end
+
+Ricorsione.somma_lista([1,2,3], 0) #=> 6
+
+# I moduli di Elixir supportano attributi. Ci sono degli attributi incorporati
+# e puoi anche aggiungerne di personalizzati.
+defmodule Modulo do
+  @moduledoc """
+  Questo è un attributo incorporato in un modulo di esempio.
+  """
+
+  @miei_dati 100 # Questo è un attributo personalizzato .
+  IO.inspect(@miei_dati) #=> 100
+end
+
+## ---------------------------
+## -- Strutture ed Eccezioni
+## ---------------------------
+
+
+# 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
+end
+
+luca = %Persona{ nome: "Luca", eta: 24, altezza: 185 }
+#=> %Persona{eta: 24, altezza: 185, nome: "Luca"}
+
+# Legge al valore di 'nome'
+luca.nome #=> "Luca"
+
+# Modifica il valore di eta
+luca_invecchiato = %{ luca | eta: 25 }
+#=> %Persona{eta: 25, altezza: 185, nome: "Luca"}
+
+# Il blocco `try` con la parola chiave `rescue` è usato per gestire le eccezioni
+try do
+  raise "un errore"
+rescue
+  RuntimeError -> "Salvato un errore di Runtime"
+  _error -> "Questo salverà da qualsiasi errore"
+end
+
+# Tutte le eccezioni hanno un messaggio
+try do
+  raise "un errore"
+rescue
+  x in [RuntimeError] ->
+    x.message
+end
+
+## ---------------------------
+## -- 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.
+
+# Per creare un nuovo processo si usa la funzione `spawn`, che riceve una
+# funzione come argomento.
+f = fn -> 2 * 2 end #=> #Function<erl_eval.20.80484245>
+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, 
+# oltre ad inviarli. Questo è realizzabile con `receive`:
+defmodule Geometria do
+  def calcolo_area do
+    receive do
+      {:rettangolo, w, h} ->
+        IO.puts("Area = #{w * h}")
+        calcolo_area()
+      {:cerchio, r} ->
+        IO.puts("Area = #{3.14 * r * r}")
+        calcolo_area()
+    end
+  end
+end
+
+# Compila il modulo e crea un processo che esegue `calcolo_area` nella shell
+pid = spawn(fn -> Geometria.calcolo_area() end) #=> #PID<0.40.0>
+
+# 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}
+
+send pid, {:cerchio, 2}
+#=> Area = 12.56000000000000049738
+#   {:cerchio,2}
+
+# Anche la shell è un processo. Puoi usare `self` per ottenere il pid corrente
+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/)
+* ["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
+* ["Programming Erlang: Software for a Concurrent World"](https://pragprog.com/book/jaerlang2/programming-erlang) di Joe Armstrong
diff --git a/it-it/java-it.html.markdown b/it-it/java-it.html.markdown
new file mode 100644
index 00000000..6eabd61f
--- /dev/null
+++ b/it-it/java-it.html.markdown
@@ -0,0 +1,502 @@
+---
+language: java
+filename: LearnJava-it.java
+contributors:
+    - ["Jake Prather", "http://github.com/JakeHP"]
+    - ["Madison Dickson", "http://github.com/mix3d"]
+translators:
+    - ["Ivan Sala","http://github.com/slavni96"]
+lang: it-it
+---
+
+Java è un linguaggio di programmazione orientato ad oggetti,
+concorrente, basato su classi e adatto a svariati scopi. 
+[Per saperne di più](http://docs.oracle.com/javase/tutorial/java/index.html)
+
+```java
+// I commenti su singola linea incominciano con //
+/*
+I commenti su piu' linee invece sono cosi'
+*/
+/**
+I commenti per la documentazione JavaDoc si fanno cosi'.
+Vengono usati per descrivere una classe o alcuni suoi attributi.
+*/
+
+// Per importare la classe ArrayList conenuta nel package java.util
+import java.util.ArrayList;
+// Per importare tutte le classi contenute nel package java.security
+import java.security.*;
+
+// Ogni file .java contiene una classe pubblica, con lo stesso nome del file
+public class LearnJava {
+
+    // Un programma deve avere un metodo main come punto di partenza
+    // Ma si possono creare anche file senza main, che però per essere usati
+    // devono essere richiamati da altri file.
+    public static void main (String[] args) {
+
+        // Per stampare a schermo si usa System.out.println
+        System.out.println("Ciao Mondo!");
+        System.out.println(
+            "Intero [integer]: " + 10 +
+            " Reale [double]: " + 3.14 +
+            " Booleano [boolean]: " + true);
+
+        // Se non si vuole andare a capo, si puo' usare System.out.print
+        System.out.print("Ciao ");
+        System.out.print("Mondo ");
+
+
+        ///////////////////////////////////////
+        // Tipi e Variabili
+        ///////////////////////////////////////
+        // Si dichiara una variabile usando <tipo> <nome>
+        // Byte - variabile intera da 8 bit con segno
+        // (-128 <= byte <= 127)
+        byte fooByte = 100;
+
+        // Short - variabile intera da 18 bit con segno
+        // (-32,768 <= short <= 32,767)
+        short fooShort = 10000;
+
+        // Integer - variabile intera da 32 bit con segno
+        // (-2,147,483,648 <= int <= 2,147,483,647)
+        int fooInt = 1;
+
+        // Long - variabile da 64 bit intera con segno
+        // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
+        long fooLong = 100000L;
+        // L viene usato per specificare che il valore dalla variabile
+        // e' di tipo "Long", qualsiasi variabile che non viene contrassegnata
+        // e' trattata di base come un intero.
+
+        // Nota: Java non dispone di variabili senza segno
+
+        // Float - variabile piu' precisa, con virgola [numeri reali]
+        // di grandezza 32 bit
+        float fooFloat = 234.5f;
+        // f e' usato per specificare che la variabile e'' di tipo "float"
+        // altrimenti di default viene trattata come un "dobule"
+
+        // Double - ancora piu' precisione la si puo' ottenere con una variabile
+        // Double, con granzezza di 64 bit.
+        double fooDouble = 123.4;
+
+        // Boolean - vero & falso
+        boolean fooBoolean = true;
+        boolean barBoolean = false;
+
+        // Char - un singolo carattere con grandezza 16 bit
+        char fooChar = 'A';
+
+        // final - Costanti, non possono essere riassegnate ad un altro oggetto
+        final int ORE_LAVORATIVE_DI_UNA_SETTIMANA = 9001;
+
+        // String - Stringhe, array di caratteri
+        String fooString = "Ecco una stringa!";
+
+        // \n e' un carattere speciale che permette di andare a capo.
+        String barString = "Andare a capo?\nNessun problema!";
+        // \t e' un carattere speciale che permette di aggiungere un 'Tab'
+        String bazString = "Vuoi inserire tab?\tNessun problema";
+        System.out.println(fooString);
+        System.out.println(barString);
+        System.out.println(bazString);
+
+        // Vettori [array]
+        //La lunghezza del vettore deve essere decisa quando viene istanziato
+        //Si puo' dichiarare come segue:
+        //<tipodato> [] <nomevariabile> = new <tipodato>[<grandezza vettore>];
+        //<tipodato> <nomevariabile>[] = new <tipodato>[<grandezza vettore>];
+        int [] intArray = new int[10];
+        String [] stringArray = new String[1];
+        boolean boolArray [] = new boolean[100];
+
+        // Un altro modo per dichiarare & inizializzare un vettore
+        int [] y = {9000, 1000, 1337};
+        String nomi [] = {"Andrea", "Bob", "Pippo", "Susan"};
+        boolean bools[] = new boolean[] {true, false, false};
+	
+	// I vettori vengono indicizzati a parire dallo 0
+        System.out.println("intArray @ 0: " + intArray[0]);
+
+        // e' possibile un accesso diretto ad un elemento
+        intArray[1] = 1;
+        System.out.println("intArray @ 1: " + intArray[1]); // => 1
+
+        // Altro da vedere:
+        // Liste di array - come i vettori ma piu' funzionali
+        // e la loro grandezza puo' variare in corso di esecuzione
+        // Liste concatenate di memoria
+
+        ///////////////////////////////////////
+        // Operatori
+        ///////////////////////////////////////
+        System.out.println("\n->Operatori");
+
+        int i1 = 1, i2 = 2; // Dichiarazone multipla in contemporanea
+
+        // L'aritmetica e' 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
+        System.out.println("1/2 = " + (i1 / i2)); // => 0 
+            // (con 0.5 arrotonda per difetto)
+
+        // Modulo
+        System.out.println("11%3 = "+(11 % 3)); // => 2
+
+        // Operatori di confronto
+        System.out.println("3 == 2? " + (3 == 2)); // => falso
+        System.out.println("3 != 2? " + (3 != 2)); // => vero
+        System.out.println("3 > 2? " + (3 > 2)); // => vero
+        System.out.println("3 < 2? " + (3 < 2)); // => falso
+        System.out.println("2 <= 2? " + (2 <= 2)); // => vero
+        System.out.println("2 >= 2? " + (2 >= 2)); // => vero
+
+        // Operatori binari orientati ai bit
+        // effettuano le operazioni logiche confrontando, i bit degli operandi:
+        /*
+        ~       complemento 
+        <<      shift sinistro con segno
+        >>      shift destro con segno
+        >>>     shift destro senza segno
+        &       AND Binario Bitwise AND
+        ^       OR Esclusivo
+        |       OR Incusivo
+        */
+
+        // Incrementare e Decrementare
+        int i = 0;
+        System.out.println("\n->Incrementare/Decrementare");
+        // Gli operatori ++ e -- incrementano e decrementano rispettivamente di 1.
+        // Se posizionati prima della variabile, incrementano, quindi riportano.
+        // Se si trovano dopo la variabile, riporano, e quindi incrementano. 
+        System.out.println(i++); //i = 1, Stampa 0 (post-incremento)
+        System.out.println(++i); //i = 2, Stampa 2 (pre-incremento)
+        System.out.println(i--); //i = 1, Stampa 2 (post-decremento)
+        System.out.println(--i); //i = 0, Stampa 0 (pre-decremento)
+
+        ///////////////////////////////////////
+        // Strutture di controllo
+        ///////////////////////////////////////
+        System.out.println("\n->Strutture di controllo");
+
+        // La dichiarazione dell'If e'' C-like.
+        int j = 10;
+        if (j == 10){
+            System.out.println("Io vengo stampato");
+        } else if (j > 10) {
+            System.out.println("Io no");
+        } else {
+            System.out.println("E io neppure");
+        }
+
+        // Struttura While
+        int fooWhile = 0;
+        while(fooWhile < 100)
+        {
+            //System.out.println(fooWhile);
+            //Incrementa il contatore
+            //Si ripete per 100 volte, fooWhile 0,1,2...99
+            fooWhile++;
+        }
+        System.out.println("Valore di fooWhile: " + fooWhile);
+
+        // Struttura Do While
+        int fooDoWhile = 0;
+        do
+        {
+            //System.out.println(fooDoWhile);
+            //Incrementa il contaore
+            //Si repete per 99 volte, fooDoWhile 0->99
+            fooDoWhile++;
+        }while(fooDoWhile < 100);
+        System.out.println("Valore di fooWhile: " + fooDoWhile);
+
+        // Struttura For
+        int fooFor;
+        //Struttura For => for(<Situazione iniziale>; <Condizione>; <passo>)
+        for(fooFor=0; fooFor<10; fooFor++){
+            //System.out.println(fooFor);
+            //Itera 10 volte, fooFor 0->9
+        }
+        System.out.println("Valore di fooFor: " + fooFor);
+
+        // Struttura For Each
+        // Una iterazione automatica attraverso un array o una lista di oggetti
+        int[] fooList = {1,2,3,4,5,6,7,8,9};
+        //struttura for each => for(<oggetto> : <oggetto dell'attay>)
+        //si legge: per ogni oggetto dell'array fai...
+        //Nota: il tipo dell'oggetto deve essere uguale a quello dell'array
+
+        for( int bar : fooList ){
+            //System.out.println(bar);
+            //Itera 9 volte e stampa 1-9 andando a capo.
+        }
+
+        // Struttura Switch Case
+        // La struttura switch lavora con byte, short, char e int.
+        // Se funziona con i char funzionera ovviamente anche con le stringhe.
+        int mese = 3;
+        String stringaMese;
+        switch (mese){
+            case 1:
+                    stringaMese = "Genneio";
+                    break;
+            case 2:
+                    stringaMese = "Febbraio";
+                    break;
+            case 3:
+                    stringaMese = "Marzo";
+                    break;
+            default:
+                    stringaMese = "Altri mesi";
+                    break;
+        }
+        System.out.println("Risultato del costrutto switch: " + stringaMese);
+
+        // Condizioni brevi
+        // Si puo' usare l'operatore '?' per un rapido assegnamento
+        // o per operazioni logiche.
+        // Si legge: 
+        // Se (condizione) e' 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.
+
+
+        /////////////////////////////////////////
+        // Convertire i tipi di tati e Typcasting
+        /////////////////////////////////////////
+
+        // Convertire tipi di dati
+
+        // Stringhe ad interi
+        Integer.parseInt("123");//Riporta una versione intera di "123"
+
+        // Interi a Stringhe
+        Integer.toString(123);//Riporta la stringa "123"
+        // Per altre conversioni guarda le seguenti classi
+        // Double
+        // Long
+        // String
+
+        // Typecasting
+        // Vi sono molti dettagli che non si possono spiegare qui, 
+        // java dispone di una ottima documentazione
+        // Sentiti libero di leggerla
+        // http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html
+
+
+        ///////////////////////////////////////
+        // Classi e funzioni
+        ///////////////////////////////////////
+
+        System.out.println("\n->Classi & Funzioni");
+
+        // (Di seguito la definizione della classe Bicicletta)
+
+        // Instanziare una nuova classe
+        Bicicletta percorso = new Bicicletta();
+
+        // Chiamare metodi
+        percorso.accellera(3); // Si usano sempre metodi set... get...
+        percorso.setCadenza(100);
+
+        // toString riporta la rappresenzazione dell'oggetto 
+        // come se fosse una stringa
+        System.out.println("percorso info: " + percorso.toString());
+
+    } // Fine metodo main
+} // Fine classe LearnJava
+
+
+// Si possono inculdere altre anche delle classi non pubbliche (private)
+// oltre a quella pubblica principale, in un file .java
+
+// Sintassi per dichiarare una classe:
+// <public/private/protected> class <Nome classe>{
+//    //dati, variabili, costruttori, funzioni, tutto qua.
+//    //le funzioni sono chiamate come i metodi.
+// }
+
+class Bicicletta {
+
+    // Variabili della bicicletta
+    public int cadenza; 
+      // Public: Puo' essere richiamato da qualsiasi classe
+    private int velocita; 
+      // Private: e'' accessibile solo dalla classe dove e'' stato inizializzato
+    protected int ingranaggi; 
+      // Protected: e'' visto sia dalla classe che dalle sottoclassi
+    String nome; 
+      // default: e'' accessibile sono all'interno dello stesso package
+
+    // I costruttori vengono usati per creare variabili
+    // Questo e'' un costruttore
+    public Bicicletta() {
+        ingranaggi = 1;
+        cadenza = 50;
+        velocita = 5;
+        nome = "Bontrager";
+    }
+
+    // Questo e'' un costruttore che richiede parametri
+    public Bicicletta(int cadenza, int velocita, int ingranaggi, String nome) {
+        this.ingranaggi = ingranaggi;
+        this.cadenza = cadenza;
+        this.velocita = velocita;
+        this.nome = nome;
+    }
+
+    // Sintassi delle funzioni:
+    // <public/private/protected> <tipo di ritorino> <nome della funzione>(<parametri>)
+
+    // Le classi in java spesso implementano delle funzioni o metodo
+    // 'get...' o 'set...' 
+
+    // Dichiarazione di un metodo
+    // <scope> <tipo di ritorno> <nome del metodo>(<parametri>)
+    public int getCandenza() {
+        return cadenza;
+    }
+
+    // i medodi (void) non necessitano di riportare un valore
+    public void setCadenza(int nuovoValore) {
+        cadenza = nuovoValore;
+    }
+
+    public void setIngranaggi(int nuovoValore) {
+        ingranaggi = nuovoValore;
+    }
+
+    public void accellera(int incrementa) {
+        velocita += incrementa;
+    }
+
+    public void decellera(int decrementa) {
+        velocita -= decrementa;
+    }
+
+    public void setNome(String nuovoNome) {
+        nome = nuovoNome;
+    }
+
+    public String getNome() {
+        return nome;
+    }
+
+    //Medoto per visualizzare gli attributi dell'oggetto
+    @Override
+    public String toString() {
+        return "Ingranaggi: " + ingranaggi +
+                " Cadenza: " + cadenza +
+                " Velocita: " + velocita +
+                " Nome: " + nome;
+    }
+} // Fine classe bicicletta
+
+// PennyFarthing e'' una sottoclasse della bicicletta
+class PennyFarthing extends Bicicletta {
+    // (Sono quelle biciclette con un unica ruota enorme
+    // Non hanno ingranaggi.)
+
+    public PennyFarthing(int cadenzaIniziale, int velocitaIniziale){
+        // Richiamo il costruttore del padre con super
+        super(cadenzaIniziale, velocitaIniziale, 0, "PennyFarthing");
+    }
+
+    // Bisogna contrassegnre un medodo che si sta riscrivendo 
+    // con una @annotazione
+    // Per saperne di piu' sulle annotazioni
+    // Vedi la guida: http://docs.oracle.com/javase/tutorial/java/annotations/
+    @Override
+    public void setIngranaggi(int ingranaggi) {
+        ingranaggi = 0;
+    }
+
+}
+/*
+//Interfacce
+//Sintassi per dichiarare una interfaccia
+//<livello di accesso> interface <nome dell'interfaccia> extends <super-interfaccia> {
+//    	//Costanti
+//		//Dichiarazioni dei metodi
+//}
+
+//Esempi- Cibo:
+interface Commestibile {
+	public void mangia(); 
+        //Ogni classe che implementa questa interfaccia
+        //deve implementare questo metodo.
+        }
+interface Digeribile {
+	public void digerisci();
+}
+
+//Possiamo quindi creare una classe che implementa entrambe le interfaccie
+class Frutta implements Commestibile, Digestibile {
+	public void mangia() {
+		//...
+	}
+
+	public void digerisci() {
+		//... 
+	}
+}
+
+//In Java si puo' estendere solo una classe, ma si possono implementare 
+//piu' interfaccie, per esempio:
+class ClasseEsempio extends AltraClasse implements PrimaInterfaccia, SecondaInterfaccia {
+	public void MetodoPrimaInterfaccia() {
+
+	}
+
+	public void MetodoSecondaInterfaccia() {
+
+	}
+}
+*/
+```
+## Letture future
+
+I link di seguito sono solo per capire l'argomento, cerca pure su Google degli esempi specifici
+
+
+**Guida ufficiale di Oracle [solo in inglese]**:
+
+* [Java Tutorial Trail from Sun / Oracle](http://docs.oracle.com/javase/tutorial/index.html)
+
+* [Java Access level modifiers](http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html)
+
+* [Object-Oriented Programming Concepts](http://docs.oracle.com/javase/tutorial/java/concepts/index.html):
+    * [Inheritance](http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html)
+    * [Polymorphism](http://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html)
+    * [Abstraction](http://docs.oracle.com/javase/tutorial/java/IandI/abstract.html)
+
+* [Exceptions](http://docs.oracle.com/javase/tutorial/essential/exceptions/index.html)
+
+* [Interfaces](http://docs.oracle.com/javase/tutorial/java/IandI/createinterface.html)
+
+* [Generics](http://docs.oracle.com/javase/tutorial/java/generics/index.html)
+
+* [Java Code Conventions](http://www.oracle.com/technetwork/java/codeconv-138413.html)
+
+
+**Tutorial Online [in inglese]**
+
+* [Learneroo.com - Learn Java](http://www.learneroo.com)
+
+* [Codingbat.com](http://codingbat.com/java)
+
+
+**Libri [in italiano]** :
+
+* [Java la guida completa](http://www.amazon.it/Java-guida-completa-Herbert-Schildt/dp/8838667667/ref=sr_1_1?ie=UTF8&qid=1393422296&sr=8-1&keywords=java)
+
+* [Thinking in java](http://www.amazon.it/Thinking-Java-1-Bruce-Eckel/dp/8871923030/ref=sr_1_8?ie=UTF8&qid=1393422296&sr=8-8&keywords=java)
+
+* [Manuale di Java 7](http://www.amazon.com/gp/product/0071606300)
diff --git a/it-it/json-it.html.markdown b/it-it/json-it.html.markdown
new file mode 100644
index 00000000..0c401753
--- /dev/null
+++ b/it-it/json-it.html.markdown
@@ -0,0 +1,62 @@
+---
+
+language: json
+contributors:
+  	- ["Anna Harren", "https://github.com/iirelu"]
+  	- ["Marco Scannadinari", "https://github.com/marcoms"]
+translators:
+    - ["Robert Margelli", "http://github.com/sinkswim/"]
+lang: it-it
+
+---
+
+Dato che JSON è un formato per lo scambio di dati estremamente semplice, questo sarà con molta probabilità
+il più semplice Learn X in Y Minutes.
+
+Nella sua forma più pura JSON non ha commenti, ma molti parser accettano
+commenti in stile C (//, /\* \*/). Per lo scopo prefissato, tuttavia, tutto sarà
+100% JSON valido. Fortunatamente, si spiega da sè.
+
+```json
+{
+  "chiave": "valore",
+  
+  "chiavi": "devono sempre essere racchiuse tra doppi apici",
+  "numeri": 0,
+  "stringhe": "Ciaø, møndø. Tutti gli unicode sono permessi, assieme con l \"escaping\".",
+  "ha booleani?": true,
+  "il nulla": null,
+
+  "numero grande": 1.2e+100,
+
+  "oggetti": {
+    "commento": "La maggior parte della tua struttura viene dagli oggetti.",
+
+    "array": [0, 1, 2, 3, "Gli array possono contenere qualsiasi cosa.", 5],
+
+    "un altro oggetto": {
+      "commento": "Queste cose possono essere annidate, molto utile."
+    }
+  },
+
+  "sciocchezze": [
+    {
+      "sorgenti di potassio": ["banane"]
+    },
+    [
+      [1, 0, 0, 0],
+      [0, 1, 0, 0],
+      [0, 0, 1, "neo"],
+      [0, 0, 0, 1]
+    ]
+  ],
+  
+  "stile alternativo": {
+    "commento": "Guarda quà!"
+  , "posizione della virgola": "non conta - fintantochè è prima del valore, allora è valida"
+  , "un altro commento": "che bello"
+  },
+
+  "è stato molto breve": "Ed hai finito. Adesso sai tutto cio che JSON ha da offrire."
+}
+```