summaryrefslogtreecommitdiffhomepage
path: root/it-it
diff options
context:
space:
mode:
Diffstat (limited to 'it-it')
-rw-r--r--it-it/bash-it.html.markdown275
-rw-r--r--it-it/brainfuck-it.html.markdown101
-rw-r--r--it-it/c++-it.html.markdown720
-rw-r--r--it-it/coffeescript-it.html.markdown107
-rw-r--r--it-it/elixir-it.html.markdown418
-rw-r--r--it-it/java-it.html.markdown502
-rw-r--r--it-it/json-it.html.markdown62
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."
+}
+```