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

25 files changed, 9295 insertions, 0 deletions

diff --git a/pt-br/brainfuck-pt.html.markdown b/pt-br/brainfuck-pt.html.markdown
new file mode 100644
index 00000000..9e4b458d
--- /dev/null
+++ b/pt-br/brainfuck-pt.html.markdown
@@ -0,0 +1,85 @@
+---
+language: brainfuck
+contributors:
+    - ["Prajit Ramachandran", "http://prajitr.github.io/"]
+    - ["Mathias Bynens", "http://mathiasbynens.be/"]
+translators:
+    - ["Suzane Sant Ana", "http://github.com/suuuzi"]
+    - ["Rodrigo Muniz", "http://github.com/muniz95"]
+lang: pt-br
+---
+
+Brainfuck (em letras minúsculas, exceto no início de frases) é uma linguagem de
+programação Turing-completa extremamente simples com apenas 8 comandos.
+
+```
+Qualquer caractere exceto "><+-.,[]" (sem contar as aspas) é ignorado.
+
+Brainfuck é representado por um vetor com 30 000 células inicializadas em zero
+e um ponteiro de dados que aponta para a célula atual.
+
+Existem 8 comandos:
++ : Incrementa o valor da célula atual em 1.
+- : Decrementa o valor da célula atual em 1.
+> : Move o ponteiro de dados para a célula seguinte (célula à direita).
+< : Move o ponteiro de dados para a célula anterior (célula à esquerda).
+. : Imprime o valor ASCII da célula atual. (ex. 65 = 'A').
+, : Lê um único caractere para a célula atual.
+[ : Se o valor da célula atual for zero, salta para o ] correspondente.
+    Caso contrário, passa para a instrução seguinte.
+] : Se o valor da célula atual for zero, passa para a instrução seguinte.
+    Caso contrário, volta para a instrução relativa ao [ correspondente.
+
+[ e ] formam um ciclo while. Obviamente, devem ser equilibrados.
+
+Vamos ver alguns exemplos básicos em brainfuck:
+
+++++++ [ > ++++++++++ < - ] > +++++ .
+
+Este programa imprime a letra 'A'. Primeiro incrementa a célula #1 para 6.
+A célula #1 será usada num ciclo. Depois é iniciado o ciclo ([) e move-se
+o ponteiro de dados para a célula #2. O valor da célula #2 é incrementado 10
+vezes, move-se o ponteiro de dados de volta para a célula #1, e decrementa-se
+a célula #1. Este ciclo acontece 6 vezes (são necessários 6 decrementos para
+a célula #1 chegar a 0, momento em que se salta para o ] correspondente,
+continuando com a instrução seguinte).
+
+Nesta altura estamos na célula #1, cujo valor é 0, enquanto a célula #2
+tem o valor 60. Movemos o ponteiro de dados para a célula #2, incrementa-se 5
+vezes para um valor final de 65, e então é impresso o valor da célula #2. O valor
+65 corresponde ao caractere 'A' em ASCII, então 'A' é impresso no terminal.
+
+, [ > + < - ] > .
+
+Este programa lê um caractere e copia o seu valor para a célula #1. Um ciclo é
+iniciado. Movemos o ponteiro de dados para a célula #2, incrementamos o valor na
+célula #2, movemos o ponteiro de dados de volta para a célula #1 e finalmente
+decrementamos o valor na célula #1. Isto continua até o valor na célula #1 ser
+igual a 0 e a célula #2 ter o antigo valor da célula #1. Como o ponteiro de
+dados está apontando para a célula #1 no fim do ciclo, movemos o ponteiro para a
+célula #2 e imprimimos o valor em ASCII.
+
+Os espaços servem apenas para tornar o programa mais legível. Podemos escrever
+o mesmo programa da seguinte maneira:
+
+,[>+<-]>.
+
+Tente descobrir o que este programa faz:
+
+,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
+
+Este programa lê dois números e os multiplica.
+
+Basicamente o programa pede dois caracteres ao usuário. Depois é iniciado um
+ciclo exterior controlado pelo valor da célula #1. Movemos o ponteiro de dados
+para a célula #2 e inicia-se o ciclo interior controlado pelo valor da célula
+#2, incrementando o valor da célula #3. Porém existe um problema, no final do
+ciclo interior: a célula #2 tem o valor 0. Para resolver este problema o valor da
+célula #4 é também incrementado e copiado para a célula #2.
+```
+
+E isto é brainfuck. Simples, não? Por divertimento você pode escrever os
+seus próprios programas em brainfuck, ou então escrever um interpretador de
+brainfuck em outra linguagem. O interpretador é relativamente fácil de se
+implementar, mas caso você seja masoquista, tente escrever um interpretador de
+brainfuck… em brainfuck.
diff --git a/pt-br/c++-pt.html.markdown b/pt-br/c++-pt.html.markdown
new file mode 100644
index 00000000..61e267f5
--- /dev/null
+++ b/pt-br/c++-pt.html.markdown
@@ -0,0 +1,590 @@
+---
+language: c++
+filename: learncpp.cpp
+contributors:
+    - ["Steven Basart", "http://github.com/xksteven"]
+    - ["Matt Kline", "https://github.com/mrkline"]
+translators:
+    - ["Miguel Araújo", "https://github.com/miguelarauj1o"]
+lang: pt-br
+---
+
+C++ é uma linguagem de programação de sistemas que,
+[de acordo com seu inventor Bjarne Stroustrup](http://channel9.msdn.com/Events/Lang-NEXT/Lang-NEXT-2014/Keynote),
+foi concebida para
+
+- ser um "C melhor"
+- suportar abstração de dados
+- suportar programação orientada a objetos
+- suportar programação genérica
+
+Embora sua sintaxe pode ser mais difícil ou complexa do que as linguagens mais
+recentes, C++ é amplamente utilizado porque compila para instruções nativas que 
+podem ser executadas diretamente pelo processador e oferece um controlo rígido sobre hardware (como C), enquanto oferece recursos de alto nível, como os 
+genéricos, exceções e classes. Esta combinação de velocidade e funcionalidade 
+faz C++ uma das linguagens de programação mais utilizadas.
+
+```c++
+//////////////////
+// Comparação com C
+//////////////////
+
+// C ++ é quase um super conjunto de C e compartilha sua sintaxe básica para
+// declarações de variáveis, tipos primitivos, e funções. No entanto, C++ varia
+// em algumas das seguintes maneiras:
+
+// A função main() em C++ deve retornar um int, embora void main() é aceita 
+// pela maioria dos compiladores (gcc, bumbum, etc.)
+// Este valor serve como o status de saída do programa.
+// Veja http://en.wikipedia.org/wiki/Exit_status para mais informações.
+
+int main(int argc, char** argv)
+{
+    // Argumentos de linha de comando são passados em pelo argc e argv da mesma
+    // forma que eles estão em C.
+    // argc indica o número de argumentos,
+    // e argv é um array de strings, feito C (char*) representado os argumentos
+    // O primeiro argumento é o nome pelo qual o programa foi chamado.
+    // argc e argv pode ser omitido se você não se importa com argumentos,
+    // dando a assinatura da função de int main()
+
+    // Uma saída de status de 0 indica sucesso.
+    return 0;
+}
+
+// Em C++, caracteres literais são um byte.
+sizeof('c') == 1
+
+// Em C, caracteres literais são do mesmo tamanho que ints.
+sizeof('c') == sizeof(10)
+
+// C++ tem prototipagem estrita
+void func(); // função que não aceita argumentos
+
+// Em C
+void func(); // função que pode aceitar qualquer número de argumentos
+
+// Use nullptr em vez de NULL em C++
+int* ip = nullptr;
+
+// Cabeçalhos padrão C estão disponíveis em C++,
+// mas são prefixados com "c" e não têm sufixo .h
+
+#include <cstdio>
+
+int main()
+{
+    printf("Hello, world!\n");
+    return 0;
+}
+
+///////////////////////
+// Sobrecarga de função
+///////////////////////
+
+// C++ suporta sobrecarga de função
+// desde que cada função tenha parâmetros diferentes.
+
+void print(char const* myString)
+{
+    printf("String %s\n", myString);
+}
+
+void print(int myInt)
+{
+    printf("My int is %d", myInt);
+}
+
+int main()
+{
+    print("Hello"); // Funciona para void print(const char*)
+    print(15); // Funciona para void print(int)
+}
+
+/////////////////////////////
+// Parâmetros padrão de função
+/////////////////////////////
+
+// Você pode fornecer argumentos padrões para uma função se eles não são 
+// fornecidos pelo chamador.
+
+void doSomethingWithInts(int a = 1, int b = 4)
+{
+    // Faça alguma coisa com os ints aqui
+}
+
+int main()
+{
+    doSomethingWithInts();      // a = 1,  b = 4
+    doSomethingWithInts(20);    // a = 20, b = 4
+    doSomethingWithInts(20, 5); // a = 20, b = 5
+}
+
+// Argumentos padrões devem estar no final da lista de argumentos.
+
+void invalidDeclaration(int a = 1, int b) // Erro!
+{
+}
+
+
+/////////////
+// Namespaces (nome de espaços)
+/////////////
+
+// Namespaces fornecem escopos distintos para variável, função e outras
+// declarações. Namespaces podem estar aninhados.
+
+namespace First {
+    namespace Nested {
+        void foo()
+        {
+            printf("This is First::Nested::foo\n");
+        }
+    } // Fim do namespace aninhado
+} // Fim do namespace First
+
+namespace Second {
+    void foo()
+    {
+        printf("This is Second::foo\n")
+    }
+}
+
+void foo()
+{
+    printf("This is global foo\n");
+}
+
+int main()
+{
+    // Assuma que tudo é do namespace "Second" a menos que especificado de 
+    // outra forma.
+    using namespace Second;
+
+    foo(); // imprime "This is Second::foo"
+    First::Nested::foo(); // imprime "This is First::Nested::foo"
+    ::foo(); // imprime "This is global foo"
+}
+
+///////////////
+// Entrada/Saída
+///////////////
+
+// C ++ usa a entrada e saída de fluxos (streams)
+// cin, cout, and cerr representa stdin, stdout, and stderr.
+// << É o operador de inserção e >> é o operador de extração.
+
+#include <iostream> // Inclusão para o I/O streams
+
+using namespace std; // Streams estão no namespace std (biblioteca padrão)
+
+int main()
+{
+   int myInt;
+
+   // Imprime na saída padrão (ou terminal/tela)
+   cout << "Enter your favorite number:\n";
+   // Pega a entrada
+   cin >> myInt;
+
+   // cout também pode ser formatado
+   cout << "Your favorite number is " << myInt << "\n";
+   // imprime "Your favorite number is <myInt>"
+
+    cerr << "Usado para mensagens de erro";
+}
+
+//////////
+// Strings
+//////////
+
+// Strings em C++ são objetos e têm muitas funções de membro
+#include <string>
+
+using namespace std; // Strings também estão no namespace std (bib. padrão)
+
+string myString = "Hello";
+string myOtherString = " World";
+
+// + é usado para concatenação.
+cout << myString + myOtherString; // "Hello World"
+
+cout << myString + " You"; // "Hello You"
+
+// Em C++, strings são mutáveis e têm valores semânticos.
+myString.append(" Dog");
+cout << myString; // "Hello Dog"
+
+
+/////////////
+// Referência
+/////////////
+
+// Além de indicadores como os de C, C++ têm _referências_. Esses são tipos de
+// ponteiro que não pode ser reatribuída uma vez definidos e não pode ser nulo.
+// Eles também têm a mesma sintaxe que a própria variável: Não * é necessário 
+// para _dereferencing_ e & (endereço de) não é usado para atribuição.
+
+using namespace std;
+
+string foo = "I am foo";
+string bar = "I am bar";
+
+
+string& fooRef = foo; // Isso cria uma referência para foo.
+fooRef += ". Hi!"; // Modifica foo através da referência
+cout << fooRef; // Imprime "I am foo. Hi!"
+
+// Não realocar "fooRef". Este é o mesmo que "foo = bar", e foo == "I am bar"
+// depois desta linha.
+
+fooRef = bar;
+
+const string& barRef = bar; // Cria uma referência const para bar.
+// Como C, valores const (e ponteiros e referências) não podem ser modificado.
+barRef += ". Hi!"; // Erro, referência const não pode ser modificada.
+
+//////////////////////////////////////////
+// Classes e programação orientada a objeto
+//////////////////////////////////////////
+
+// Primeiro exemplo de classes
+#include <iostream>
+
+// Declara a classe.
+// As classes são geralmente declarado no cabeçalho arquivos (.h ou .hpp).
+class Dog {
+    // Variáveis de membro e funções são privadas por padrão.
+    std::string name;
+    int weight;
+
+// Todos os membros a seguir este são públicos até que "private:" ou 
+// "protected:" é encontrado.
+public:
+
+    // Construtor padrão
+    Dog();
+
+    // Declarações de função Membro (implementações a seguir)
+    // Note que usamos std :: string aqui em vez de colocar
+    // using namespace std;
+    // acima.
+    // Nunca coloque uma declaração "using namespace" em um cabeçalho.
+    void setName(const std::string& dogsName);
+
+    void setWeight(int dogsWeight);
+
+    // Funções que não modificam o estado do objecto devem ser marcadas como 
+    // const. Isso permite que você chamá-los se for dada uma referência const
+    // para o objeto. Além disso, observe as funções devem ser explicitamente
+    // declarados como _virtual_, a fim de ser substituídas em classes 
+    // derivadas. As funções não são virtuais por padrão por razões de 
+    // performance.
+    
+    virtual void print() const;
+
+    // As funções também podem ser definidas no interior do corpo da classe.
+    // Funções definidas como tal são automaticamente embutidas.
+    void bark() const { std::cout << name << " barks!\n" }
+
+    // Junto com os construtores, C++ fornece destruidores.
+    // Estes são chamados quando um objeto é excluído ou fica fora do escopo.
+    // Isto permite paradigmas poderosos, como RAII
+    // (veja abaixo)
+    // Destruidores devem ser virtual para permitir que as classes de ser 
+    // derivada desta.
+    virtual ~Dog();
+
+}; // Um ponto e vírgula deve seguir a definição de classe.
+
+// Funções membro da classe geralmente são implementados em arquivos .cpp.
+void Dog::Dog()
+{
+    std::cout << "A dog has been constructed\n";
+}
+
+// Objetos (como strings) devem ser passados por referência
+// se você pretende modificá-los, ou com const caso contrário.
+void Dog::setName(const std::string& dogsName)
+{
+    name = dogsName;
+}
+
+void Dog::setWeight(int dogsWeight)
+{
+    weight = dogsWeight;
+}
+
+// Observe que "virtual" só é necessária na declaração, não a definição.
+void Dog::print() const
+{
+    std::cout << "Dog is " << name << " and weighs " << weight << "kg\n";
+}
+
+void Dog::~Dog()
+{
+    cout << "Goodbye " << name << "\n";
+}
+
+int main() {
+    Dog myDog; // imprime "A dog has been constructed"
+    myDog.setName("Barkley");
+    myDog.setWeight(10);
+    myDog.printDog(); // imprime "Dog is Barkley and weighs 10 kg"
+    return 0;
+} // imprime "Goodbye Barkley"
+
+// herança:
+
+// Essa classe herda tudo público e protegido da classe Dog
+class OwnedDog : public Dog {
+
+    void setOwner(const std::string& dogsOwner)
+
+    // Substituir o comportamento da função de impressão de todas OwnedDogs.
+    // Ver http://en.wikipedia.org/wiki/Polymorphism_(computer_science)#Subtyping
+    // Para uma introdução mais geral, se você não estiver familiarizado com o 
+    // polimorfismo subtipo. A palavra-chave override é opcional, mas torna-se 
+    // na verdade você está substituindo o método em uma classe base.
+    void print() const override;
+
+private:
+    std::string owner;
+};
+
+// Enquanto isso, no arquivo .cpp correspondente:
+
+void OwnedDog::setOwner(const std::string& dogsOwner)
+{
+    owner = dogsOwner;
+}
+
+void OwnedDog::print() const
+{
+    Dog::print(); // Chame a função de impressão na classe Dog base de
+    std::cout << "Dog is owned by " << owner << "\n";
+    // Prints "Dog is <name> and weights <weight>"
+    //        "Dog is owned by <owner>"
+}
+
+//////////////////////////////////////////
+// Inicialização e Sobrecarga de Operadores
+//////////////////////////////////////////
+
+// Em C ++, você pode sobrecarregar o comportamento dos operadores, tais como 
+// +, -, *, /, etc. Isto é feito através da definição de uma função que é 
+// chamado sempre que o operador é usado.
+
+#include <iostream>
+using namespace std;
+
+class Point {
+public:
+    // Variáveis membro pode ser dado valores padrão desta maneira.
+    double x = 0;
+    double y = 0;
+
+    // Define um construtor padrão que não faz nada
+    // mas inicializar o Point para o valor padrão (0, 0)
+    Point() { };
+
+    // A sintaxe a seguir é conhecido como uma lista de inicialização
+    // e é a maneira correta de inicializar os valores de membro de classe
+    Point (double a, double b) :
+        x(a),
+        y(b)
+    { /* Não fazer nada, exceto inicializar os valores */ }
+
+    // Sobrecarrega o operador +.
+    Point operator+(const Point& rhs) const;
+
+    // Sobrecarregar o operador +=.
+    Point& operator+=(const Point& rhs);
+
+    // Ele também faria sentido para adicionar os operadores - e -=,
+    // mas vamos pular para sermos breves.
+};
+
+Point Point::operator+(const Point& rhs) const
+{
+    // Criar um novo ponto que é a soma de um e rhs.
+    return Point(x + rhs.x, y + rhs.y);
+}
+
+Point& Point::operator+=(const Point& rhs)
+{
+    x += rhs.x;
+    y += rhs.y;
+    return *this;
+}
+
+int main () {
+    Point up (0,1);
+    Point right (1,0);
+    // Isto chama que o operador ponto +
+    // Ressalte-se a chamadas (função)+ com direito como seu parâmetro...
+    Point result = up + right;
+    // Imprime "Result is upright (1,1)"
+    cout << "Result is upright (" << result.x << ',' << result.y << ")\n";
+    return 0;
+}
+
+/////////////////////////
+// Tratamento de Exceções
+/////////////////////////
+
+// A biblioteca padrão fornece alguns tipos de exceção
+// (see http://en.cppreference.com/w/cpp/error/exception)
+// mas qualquer tipo pode ser jogado como uma exceção
+#include <exception>
+
+// Todas as exceções lançadas dentro do bloco try pode ser capturado por 
+// manipuladores de captura subseqüentes
+try {
+    // Não aloca exceções no heap usando _new_.
+    throw std::exception("A problem occurred");
+}
+// Capturar exceções por referência const se eles são objetos
+catch (const std::exception& ex)
+{
+  std::cout << ex.what();
+// Captura qualquer exceção não capturada pelos blocos _catch_ anteriores
+} catch (...)
+{
+    std::cout << "Exceção desconhecida encontrada";
+    throw; // Re-lança a exceção
+}
+
+///////
+// RAII
+///////
+
+// RAII significa alocação de recursos é de inicialização.
+// Muitas vezes, é considerado o paradigma mais poderoso em C++, e é o 
+// conceito simples que um construtor para um objeto adquire recursos daquele
+// objeto e o destruidor liberá-los.
+
+// Para entender como isso é útil,
+// Considere uma função que usa um identificador de arquivo C:
+void doSomethingWithAFile(const char* filename)
+{
+    // Para começar, assuma que nada pode falhar.
+
+    FILE* fh = fopen(filename, "r"); // Abra o arquivo em modo de leitura.
+
+    doSomethingWithTheFile(fh);
+    doSomethingElseWithIt(fh);
+
+    fclose(fh); // Feche o arquivo.
+}
+
+// Infelizmente, as coisas são levemente complicadas para tratamento de erros.
+// Suponha que fopen pode falhar, e que doSomethingWithTheFile e 
+// doSomethingElseWithIt retornam códigos de erro se eles falharem. (As 
+// exceções são a forma preferida de lidar com o fracasso, mas alguns 
+// programadores, especialmente aqueles com um conhecimento em C, discordam 
+// sobre a utilidade de exceções). Agora temos que verificar cada chamada para 
+// o fracasso e fechar o identificador de arquivo se ocorreu um problema.
+
+bool doSomethingWithAFile(const char* filename)
+{
+    FILE* fh = fopen(filename, "r"); // Abra o arquivo em modo de leitura
+    if (fh == nullptr) // O ponteiro retornado é nulo em caso de falha.
+        reuturn false; // Relate o fracasso para o chamador.
+
+    // Suponha cada função retorne false, se falhar
+    if (!doSomethingWithTheFile(fh)) {
+        fclose(fh); // Feche o identificador de arquivo para que ele não vaze.
+        return false; // Propague o erro.
+    }
+    if (!doSomethingElseWithIt(fh)) {
+        fclose(fh); // Feche o identificador de arquivo para que ele não vaze.
+        return false; // Propague o erro.
+    }
+
+    fclose(fh); // Feche o identificador de arquivo para que ele não vaze.
+    return true; // Indica sucesso
+}
+
+// Programadores C frequentemente limpam isso um pouco usando Goto:
+bool doSomethingWithAFile(const char* filename)
+{
+    FILE* fh = fopen(filename, "r");
+    if (fh == nullptr)
+        reuturn false;
+
+    if (!doSomethingWithTheFile(fh))
+        goto failure;
+
+    if (!doSomethingElseWithIt(fh))
+        goto failure;
+
+    fclose(fh); // Close the file
+    return true; // Indica sucesso
+
+failure:
+    fclose(fh);
+    return false; // Propague o erro.
+}
+
+// Se as funções indicam erros usando exceções,
+// as coisas são um pouco mais limpo, mas ainda abaixo do ideal.
+void doSomethingWithAFile(const char* filename)
+{
+    FILE* fh = fopen(filename, "r"); // Abra o arquivo em modo de leitura.
+    if (fh == nullptr)
+        throw std::exception("Não pode abrir o arquivo.");
+
+    try {
+        doSomethingWithTheFile(fh);
+        doSomethingElseWithIt(fh);
+    }
+    catch (...) {
+        fclose(fh); // Certifique-se de fechar o arquivo se ocorrer um erro.
+        throw; // Em seguida, re-lance a exceção.
+    }
+
+    fclose(fh); // Feche o arquivo
+    // Tudo ocorreu com sucesso!
+}
+
+// Compare isso com o uso de C++ classe fluxo de arquivo (fstream) fstream usa
+// seu destruidor para fechar o arquivo. Lembre-se de cima que destruidores são
+// automaticamente chamado sempre que um objeto cai fora do âmbito.
+void doSomethingWithAFile(const std::string& filename)
+{
+    // ifstream é curto para o fluxo de arquivo de entrada
+    std::ifstream fh(filename); // Abra o arquivo
+
+    // faça alguma coisa com o arquivo
+    doSomethingWithTheFile(fh);
+    doSomethingElseWithIt(fh);
+
+} // O arquivo é automaticamente fechado aqui pelo destructor
+
+// Isto tem _grandes_ vantagens:
+// 1. Não importa o que aconteça,
+//    o recurso (neste caso, o identificador de ficheiro) irá ser limpo.
+//    Depois de escrever o destruidor corretamente,
+//    É _impossível_ esquecer de fechar e vazar o recurso
+// 2. Nota-se que o código é muito mais limpo.
+//    As alças destructor fecham o arquivo por trás das cenas
+//    sem que você precise se preocupar com isso.
+// 3. O código é seguro de exceção.
+//    Uma exceção pode ser jogado em qualquer lugar na função e a limpeza
+//    irá ainda ocorrer.
+
+// Todos códigos C++ usam RAII extensivamente para todos os recursos.
+// Outros exemplos incluem
+// - Memória usa unique_ptr e shared_ptr
+// - Contentores - a lista da biblioteca ligada padrão,
+//   vetor (i.e. array de autodimensionamento), mapas hash, e assim por diante
+//   tudo é automaticamente destruído quando eles saem de escopo
+// - Mutex usa lock_guard e unique_lock
+```
+Leitura Adicional:
+
+Uma referência atualizada da linguagem pode ser encontrada em 
+<http://cppreference.com/w/cpp>
+
+Uma fonte adicional pode ser encontrada em <http://cplusplus.com>
diff --git a/pt-br/c-pt.html.markdown b/pt-br/c-pt.html.markdown
new file mode 100644
index 00000000..451df4f3
--- /dev/null
+++ b/pt-br/c-pt.html.markdown
@@ -0,0 +1,649 @@
+---
+language: c
+filename: learnc.c
+contributors:
+    - ["Adam Bard", "http://adambard.com/"]
+    - ["Árpád Goretity", "http://twitter.com/H2CO3_iOS"]
+translators:
+    - ["João Farias", "https://github.com/JoaoGFarias"]
+lang: pt-br
+filename: c-pt.el
+---
+
+Ah, C. Ainda é **a** linguagem de computação de alta performance.
+
+C é a liguangem de mais baixo nível que a maioria dos programadores
+irão usar, e isso dá a ela uma grande velocidade bruta. Apenas fique
+antento que este manual de gerenciamento de memória e C vai levanter-te
+tão longe quanto você precisa. 
+
+```c
+// Comentários de uma linha iniciam-se com // - apenas disponível a partir do C99
+
+/*
+Comentários de multiplas linhas se parecem com este. 
+Funcionam no C89 também.
+*/
+
+// Constantes: #define <palavra-chave>
+#definie DAY_IN_YEAR 365
+
+//enumarações também são modos de definir constantes.
+enum day {DOM = 1, SEG, TER, QUA, QUI, SEX, SAB};
+// SEG recebe 2 automaticamente, TER recebe 3, etc.
+
+// Cabeçalhos são inclusos com #include
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+// (Nomes dos arquivos entre <colchetes> são cabeçalhos para bibliotecas padrão de C.)
+// Para cabeçalhos próprios, use aspas ao invés de colchetes:
+#include "minha_biblioteca.h"
+
+// Declare assinaturas das funções no início do arquivo .h ou no topo
+// do seu arquivo .c.
+void funcao_1(char c);
+int funcao_2(void);
+
+// Deve-se declarar um 'protótipo de função' antes do main() quando as ocorrências
+// dessas funções estão após sua função main()
+int soma_dois_ints(int x1, int x2); // protótipo de função
+
+// O ponto de entrada do teu programa é uma função
+// chamada main, com tipo de retorno inteiro
+int main() {
+	// Usa-se printf para escrever na tela, 
+	// para "saída formatada"
+	// %d é um inteiro, \n é uma nova linha
+    printf("%d\n", 0); // => Imprime 0
+	// Todos as declarações devem acabar com
+	// ponto e vírgula
+	
+    ///////////////////////////////////////
+    // Tipos
+    ///////////////////////////////////////
+
+    // ints normalmente tem 4 bytes
+    int x_int = 0;
+
+    // shorts normalmente tem 2 bytes
+    short x_short = 0;
+
+    // chars sempre tem um byte
+    char x_char = 0;
+    char y_char = 'y'; // Literais de caracter são cercados por '
+
+    // longs tem entre 4 e 8 bytes; longs long tem garantia
+    // de ter pelo menos 64 bits
+    long x_long = 0;
+    long long x_long_long = 0; 
+
+    // floats são normalmente números de ponto flutuante
+	// com 32 bits
+    float x_float = 0.0;
+
+    // doubles são normalmente números de ponto flutuante
+	// com 64 bits
+    double x_double = 0.0;
+
+    // Tipos inteiros podem ser sem sinal.
+    unsigned short ux_short;
+    unsigned int ux_int;
+    unsigned long long ux_long_long;
+
+	// caracteres dentro de aspas simples são inteiros 
+	// no conjunto de caracteres da máquina.
+    '0' // => 48 na tabela ASCII.
+    'A' // => 65 na tabela ASCII.
+
+	// sizeof(T) devolve o tamanho de uma variável do tipo T em bytes
+	// sizeof(obj) devolve o tamanho de uma expressão (variável, literal, etc.).
+    printf("%zu\n", sizeof(int)); // => 4 (na maioria das máquinas com palavras de 4 bytes)
+
+	// Se o argumento do operador `sizeof` é uma expressão, então seus argumentos
+	// não são avaliados (exceto em VLAs (veja abaixo)).
+	// O valor devolve, neste caso, é uma constante de tempo de compilação. 
+    int a = 1;
+	// size_t é um inteiro sem sinal com pelo menos 2 bytes que representa
+	// o tamanho de um objeto.
+    size_t size = sizeof(a++); // a++ não é avaliada.
+    printf("sizeof(a++) = %zu where a = %d\n", size, a);
+    // imprime "sizeof(a++) = 4 onde a = 1" (quando em uma arquitetura de 32 bits)
+
+	// Arrays precisam ser inicializados com um tamanho concreto
+    char meu_char_array[20]; // Este array ocupa 1 * 20 = 20 bytes
+    int meu_int_array[20]; // Este array ocupa 4 * 20 = 80 bytes
+                           // (assumindo palavras de 4 bytes)
+
+	// Você pode inicializar um array com 0 desta forma:
+    char meu_array[20] = {0};
+
+	// Indexar um array é semelhante a outras linguages
+	// Melhor dizendo, outras linguagens são semelhantes a C
+    meu_array[0]; // => 0
+
+	// Array são mutáveis; são apenas memória!
+    meu_array[1] = 2;
+    printf("%d\n", meu_array[1]); // => 2
+
+	// No C99 (e como uma features opcional em C11), arrays de tamanho variável
+	// VLA (do inglês), podem ser declarados também. O tamanho destes arrays 
+	// não precisam ser uma constante de tempo de compilação:
+    printf("Entre o tamanho do array: "); // Pergunta ao usuário pelo tamanho
+    char buf[0x100];
+    fgets(buf, sizeof buf, stdin);
+
+    // strtoul transforma a string em um inteiro sem sinal
+    size_t size = strtoul(buf, NULL, 10);
+    int var_length_array[size]; // declara o VLA
+    printf("sizeof array = %zu\n", sizeof var_length_array);
+
+	//Uma possível saída para esse programa seria:
+    // > Entre o tamanho do array:: 10
+    // > sizeof array = 40
+
+	// String são apenas arrays de caracteres terminados por um 
+	// byte NUL (0x00), representado em string pelo caracter especial '\0'.
+	// (Não precisamos incluir o byte NUL em literais de string; o compilador
+	// o insere ao final do array para nós.)
+    char uma_string[20] = "Isto é uma string"; 
+	// Observe que 'é' não está na tabela ASCII
+	// A string vai ser salva, mas a saída vai ser estranha
+	// Porém, comentários podem conter acentos 
+    printf("%s\n", uma_string); // %s formata a string
+
+    printf("%d\n", uma_string[16]); // => 0
+    // i.e., byte #17 é 0 (assim como 18, 19, e 20)
+
+	// Se temos caracteres entre aspas simples, temos um caracter literal.
+	// Seu tipo é `int`, *não* `char` (por razões históricas).
+    int cha = 'a'; // ok
+    char chb = 'a'; // ok também (conversão implícita de int para char)
+
+	// Arrays multi-dimensionais:
+    int multi_array[2][5] = {
+        {1, 2, 3, 4, 5},
+        {6, 7, 8, 9, 0}
+    };
+    // Acesso a elementos:
+    int array_int = multi_array[0][2]; // => 3
+
+    ///////////////////////////////////////
+    // Operadores
+    ///////////////////////////////////////
+
+    // Atalho para multiplas declarações:
+    int i1 = 1, i2 = 2; 
+    float f1 = 1.0, f2 = 2.0;
+
+    int a, b, c;
+    a = b = c = 0;
+
+    // Aritimética é óbvia
+    i1 + i2; // => 3
+    i2 - i1; // => 1
+    i2 * i1; // => 2
+    i1 / i2; // => 0 (0.5, porém, é truncado para 0)
+
+    f1 / f2; // => 0.5, mais ou menos epsilon
+    // Números e cálculos de ponto flutuante não são exatos
+
+    // Modulo também existe
+    11 % 3; // => 2
+
+	// Operadores de comparação provavelmente são familiares,
+	// porém não há tipo booleano em C. Usa-se ints no lugar.
+	// (Ou _Bool or bool em C99.)
+	// 0 é falso e qualquer outra coisa é verdadeiro
+	// (Os operadores de comparação devolvem 0 ou 1.)
+    // Comparison operators are probably familiar, but
+    3 == 2; // => 0 (falso)
+    3 != 2; // => 1 (verdadeiro)
+    3 > 2; // => 1
+    3 < 2; // => 0
+    2 <= 2; // => 1
+    2 >= 2; // => 1
+
+	// C não é Python - comparações não se encadeam.
+    int a = 1;
+    // Errado:
+    int entre_0_e_2 = 0 < a < 2;
+    // Correto:
+    int entre_0_e_2 = 0 < a && a < 2;
+
+    // Lógica funciona sobre ints
+    !3; // => 0 (Não lógico)
+    !0; // => 1
+    1 && 1; // => 1 (E lógico)
+    0 && 1; // => 0
+    0 || 1; // => 1 (Ou lógico)
+    0 || 0; // => 0
+
+    //Expressão condicional ( ? : )
+    int a = 5;
+    int b = 10;
+    int z;
+    z = (a > b) ? a : b; // => 10 "se a > b retorne a, senão retorne b." 
+
+    //Operadores de incremento e decremento:
+    char *s = "iLoveC";
+    int j = 0;
+    s[j++]; // => "i". Retorna o j-ésimo item de s E DEPOIS incrementa o valor de j.
+    j = 0; 
+    s[++j]; // => "L". Incrementa o valor de j. E DEPOIS retorna o j-ésimo item de s.
+    // o mesmo com j-- e --j
+
+    // Operadores bit a bit!
+    ~0x0F; // => 0xF0 (negação bit a bit, "complemento de 1")
+    0x0F & 0xF0; // => 0x00 (bit a bit E)
+    0x0F | 0xF0; // => 0xFF (bit a bit OU)
+    0x04 ^ 0x0F; // => 0x0B (bit a bit OU EXCLUSIVO)
+    0x01 << 1; // => 0x02 (bit a bit shift para esquerda (por 1))
+    0x02 >> 1; // => 0x01 (bit a bit shift para direita (por 1))
+
+	// Cuidado quando fizer shift em inteiro com sinal - o seguinte é indefinido:
+	// - Fazer shift sobre um bit de sinal de um inteiro com sinal (int a = 1 << 32)
+	// - Fazer shift a esquerda sobre um número negativo (int a = -1 << 2)
+	// - Fazer shift maior que a largura do tipo de LHS:
+	//   int a = 1 << 32; // Indefinido se int é de tamanho 32 bits
+
+    ///////////////////////////////////////
+    // Estruturas de Controle
+    ///////////////////////////////////////
+
+    if (0) {
+      printf("Nunca rodará\n");
+    } else if (0) {
+      printf("Também nunca rodará\n");
+    } else {
+      printf("Eu serei impresso\n");
+    }
+
+    // Loops while existem
+    int ii = 0;
+    while (ii < 10) { //QUALQUER valor diferente de 0 é verdadeiro
+        printf("%d, ", ii++); // ii++ incrementa o valor de ii APÓS usá-lo
+    } // => imprime "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "
+
+    printf("\n");
+
+    int kk = 0;
+    do {
+        printf("%d, ", kk);
+    } while (++kk < 10); // ++kk incrementa o valor de kk ANTES de usá-lo
+    // => imprime "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "
+
+    printf("\n");
+
+    // Loops for também
+    int jj;
+    for (jj=0; jj < 10; jj++) {
+        printf("%d, ", jj);
+    } // => imprime "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "
+
+    printf("\n");
+
+    // *****NOTAS*****:
+	// Loops e Funções PRECISAM ter um corpo. Se nenhum corpo é necessário:
+    int i;
+    for (i = 0; i <= 5; i++) {
+        ; // Use ponto e vírgula para agir como um corpo (declaração nula)
+    }
+
+	// Criando branchs com escolhas múltiplas: switch()
+    switch (alguma_expressao_integral) {
+    case 0: // labels precisam ser expressões integrais **constantes**
+        faca_algo();
+        break; // Sem break, o controle continua após a label
+    case 1:
+        faca_outra_coisa();
+        break;
+    default:
+        // Se `alguma_expressao_integral` não coincidir com nenhuma label
+        fputs("erro!\n", stderr);
+        exit(-1);
+        break;
+    }
+    
+
+    ///////////////////////////////////////
+    // Cast de tipos
+    ///////////////////////////////////////
+
+	// Todo valor em C tem um tipo, mas você pode fazer um cast de um valor em outro tipo
+	// se você quiser (com algumas restrições).
+
+    int x_hex = 0x01; // Você pode colocar valores hexadecimais em variáveis
+
+	// Cast entre tipos tentará preservar seus valores numéricos
+    printf("%d\n", x_hex); // => Imprime 1
+    printf("%d\n", (short) x_hex); // => Imprime 1
+    printf("%d\n", (char) x_hex); // => Imprime 1
+
+	// Tipos irão ter overflow sem aviso
+    printf("%d\n", (unsigned char) 257); // => 1 (Max char = 255 se char tem 8 bits)
+
+	// Para determinar o valor máximo de um `char`, de um `signed char` e de 
+	// um `unisigned char`, respectivamente, use as macros CHAR_MAX, SCHAR_MAX 
+	// e UCHAR_MAX de <limits.h>
+
+	// Tipos inteiros podem sofrer cast para pontos-flutuantes e vice-versa.
+    printf("%f\n", (float)100); // %f formata um float
+    printf("%lf\n", (double)100); // %lf formata um double
+    printf("%d\n", (char)100.0);
+
+    ///////////////////////////////////////
+    // Ponteiros
+    ///////////////////////////////////////
+
+	// Um ponteiro é uma variável declarada para armazenar um endereço de memória.
+	// Seu declaração irá também dizer o tipo de dados para o qual ela aponta. Você
+	// Pode usar o endereço de memória de suas variáveis, então, brincar com eles.
+
+    int x = 0;
+    printf("%p\n", (void *)&x); // Use & para usar o endereço de uma variável
+    // (%p formata um objeto ponteiro do tipo void *)
+    // => Imprime algum endereço de memória;
+
+	// Ponteiros começam com * na sua declaração
+    int *px, nao_eh_um_ponteiro; // px é um ponteiro para um int
+    px = &x; // armazena o endereço de x em px
+    printf("%p\n", (void *)px); // => Imprime algum endereço de memória
+    printf("%zu, %zu\n", sizeof(px), sizeof(nao_eh_um_ponteiro));
+    // => Imprime "8, 4" em um sistema típico de 64 bits
+
+	// Para pegar um valor no endereço apontado por um ponteiro,
+	// coloque * na frente para de-referenciá-lo.
+	// Nota: sim, é confuso usar '*' _tanto_ para declaração de ponteiro
+	// como para de-referenciá-lo.
+    printf("%d\n", *px); // => Imprime 0, o valor de x
+
+	// Você também pode mudar o valor que o ponteiro está apontando.
+	// Teremo que cercar a de-referência entre parenteses, pois
+	// ++ tem uma precedência maior que *.
+    (*px)++; // Incrementa o valor que px está apontando por 1
+    printf("%d\n", *px); // => Imprime 1
+    printf("%d\n", x); // => Imprime 1
+
+	// Arrays são um boa maneira de alocar um bloco contínuo de memória
+    int x_array[20]; // Declara um array de tamanho 20 (não pode-se mudar o tamanho
+    int xx;
+    for (xx = 0; xx < 20; xx++) {
+        x_array[xx] = 20 - xx;
+    } //Inicializa x_array com 20, 19, 18,... 2, 1
+
+	// Declara um ponteiro do tipo int e inicialize ele para apontar para x_array
+    int* x_ptr = x_array;
+	// x_ptr agora aponta para o primeiro elemento do array (o inteiro 20).
+	// Isto funciona porque arrays são apenas ponteiros para seu primeiros elementos.
+	// Por exemplo, quando um array é passado para uma função ou é atribuído a um
+	// ponteiro, ele transforma-se (convertido implicitamente) em um ponteiro.
+	// Exceções: quando o array é o argumento de um operador `&` (endereço-de):
+    // Exceptions: when the array is the argument of the `&` (address-of) operator:
+    int arr[10];
+    int (*ptr_to_arr)[10] = &arr; // &arr não é do tipo `int *`!
+                                  // É do tipo "ponteiro para array" (de `int`s).
+    // ou quando o array é uma string literal usada para inicializar um array de char:
+    char arr[] = "foobarbazquirk";
+	// ou quando é um argumento dos operadores `sizeof` ou `alignof`:
+    int arr[10];
+    int *ptr = arr; // equivalente a int *ptr = &arr[0];
+    printf("%zu, %zu\n", sizeof arr, sizeof ptr); // provavelmente imprime "40, 4" ou "40, 8"
+
+	// Ponteiros podem ser incrementados ou decrementados baseado no seu tipo
+	// (isto é chamado aritimética de ponteiros
+    printf("%d\n", *(x_ptr + 1)); // => Imprime 19
+    printf("%d\n", x_array[1]); // => Imprime 19
+
+	// Você também pode alocar dinamicamente blocos de memória com a função
+	// da biblioteca padrão malloc, a qual recebe um argumento do tipo size_t
+	// representando o número de bytes a ser alocado (geralmente da heap, apesar de
+	// isto poder não ser verdadeiro em, e.g., sistemas embarcados - o C padrão diz
+	// nada sobre isso).
+    int *my_ptr = malloc(sizeof(*my_ptr) * 20);
+    for (xx = 0; xx < 20; xx++) {
+        *(my_ptr + xx) = 20 - xx; // my_ptr[xx] = 20-xx
+    } //Inicializa a memória com 20, 19, 18, 17... 2, 1 (como ints)
+
+	// Dereferenciar memória que você não alocou cria
+	// "resultados imprevisíveis" - o programa é dito ter um "comportamento indefinido"
+    printf("%d\n", *(my_ptr + 21)); // => Imprime quem-sabe-o-que? Talvez até quebre o programa.
+
+	// Quando termina-se de usar um bloco de memória alocado, você pode liberá-lo,
+	// ou ninguém mais será capaz de usá-lo até o fim da execução
+	// (Isto cham-se "memory leak"):
+    free(my_ptr);
+
+	// Strings são arrays de char, mas elas geralmente são representadas
+	// como um ponteiro para char (com o apontador para o primeiro elemento do array).
+	// É boa prática usar `const char *' quando de-referenciando uma literal string,
+	// dado que elas não deverão ser modificadas (i.e. "foo"[0] = 'a' é ILEGAL.)
+    const char *my_str = "Esta é a minha literal string";
+    printf("%c\n", *my_str); // => 'T'
+
+	// Este não é o caso se a string for um array
+	// (potencialmente inicializado com um literal string)
+	// que reside em uma memória de escrita, como em:
+    char foo[] = "foo";
+    foo[0] = 'a'; // Isto é legal, foo agora contém "aoo"
+
+    funcao_1();
+} // fim da função main
+
+///////////////////////////////////////
+// Funções
+///////////////////////////////////////
+
+//Sintaxe de declaração de funções:
+// <tipo de retorno> <nome da função>(<argumentos>)
+
+int soma_dois_int(int x1, int x2)
+{
+    return x1 + x2; // Use return para retornar um valor
+}
+
+/*
+Funções são chamadas por valor. Quando uma função é chamada, os argumentos passados
+para a função são cópias dos argumento originais (a não ser arrays). Qualquer coisa
+que você faz nos argumentos de uma função não alteram o valor do argumento original
+onde a função foi chamada.
+
+Use ponteiros se você precisa alterar os valores dos argumentos originais
+
+Exemplo: reversão de string in-place
+*/
+
+// Uma função void não retorna valor algum
+void str_reverse(char *str_in)
+{
+    char tmp;
+    int ii = 0;
+    size_t len = strlen(str_in); // `strlen()` é parte da biblioteca padrão C
+    for (ii = 0; ii < len / 2; ii++) {
+        tmp = str_in[ii];
+        str_in[ii] = str_in[len - ii - 1]; // iiº char do final
+        str_in[len - ii - 1] = tmp;
+    }
+}
+
+/*
+char c[] = "Isto é um teste.";
+str_reverse(c);
+printf("%s\n", c); // => ".etset mu é otsI"
+*/
+
+// Se estiver referenciando variáveis externas à função, use a palavra-chave extern.
+int i = 0;
+void testFunc() {
+    extern int i; //i aqui agora está usando a variável externa
+}
+
+// Faça variáveis externas privadas para o código-fonte com static:
+static int i = 0; // Outros arquivos usando testFunc() não podem acessar a variável i
+void testFunc() {
+    extern int i;
+}
+//**Você pode declarar funções como static para torná-las privadas**
+
+
+///////////////////////////////////////
+// Tipos definidos pelo usuário e structs
+///////////////////////////////////////
+
+// Typedefs podem ser usadas para criar apelidos para tipos
+typedef int meu_tipo;
+meu_tipo var_meu_tipo = 0;
+
+// Structs são apenas coleções de dados, os membros são alocados sequencialmente,
+// na ordem que são escritos:
+struct retangulo {
+    int altura;
+    int largura;
+};
+
+// Geralmente não é verdade que
+// sizeof(struct retangulo) == sizeof(int) + sizeof(int)
+// devido ao potencial de preenchimento entre os membros da estrutura
+// (isto é por razões de alinhamento). [1]
+
+void funcao_1()
+{
+    struct retangulo meu_retan;
+
+    // Acesse os membros da estrutura com .
+    meu_retan.altura = 10;
+    meu_retan.largura = 20;
+
+	// Você pode declarar ponteiros para structs
+    struct retangulo *meu_retan_ptr = &meu_retan;
+
+	// Use de-referenciamento para setar os membros da
+	// struct apontada...
+    (*meu_retan_ptr).altura = 30;
+
+	// ... ou ainda melhor: prefira usar o atalho -> para melhorar legibilidade
+    meu_retan_ptr->largura = 10; // O mesmo que (*meu_retan_ptr).largura = 10;
+}
+
+//Você pode aplicar um typedef para uma struct por conveniência
+typedef struct retangulo retan;
+
+int area(retan r)
+{
+    return r.largura * r.altura;
+}
+
+// Se você tiver structus grande, você pode passá-las "por ponteiro" 
+// para evitar cópia de toda a struct:
+int area(const retan *r)
+{
+    return r->largura * r->altura;
+}
+
+///////////////////////////////////////
+// Ponteiros para funções
+///////////////////////////////////////
+/*
+Em tempo de execução, funções são localizadas em endereços de memória
+conhecidos. Ponteiros para funções são como qualquer outro ponteiro
+(apenas guardam endereços de memória), mas podem ser usados para invocar funções
+diretamente e passá-las para por toda parte.
+Entretanto, a sintaxe de definição por ser um pouco confusa.
+
+Exemplo: use str_reverso através de um ponteiro 
+*/	
+void str_reverso_através_ponteiro(char *str_entrada) {
+    // Define uma variável de ponteiro para função, nomeada f.
+    void (*f)(char *); //Assinatura deve ser exatamente igual à função alvo.
+    f = &str_reverso; //Atribue o endereço da função em si (determinado em tempo de execução.
+    // f = str_reverso; Também funciona - função tornam-se ponteiros, assim como arrays
+    (*f)(str_entrada); // Chamando a função através do ponteiro
+    // f(str_entrada); // Esta é uma sintaxe alternativa, mas equivalente.
+}
+
+/*
+Desde que as assinaturas das funções sejam compatíveis, você pode atribuir qualquer
+função ao mesmo ponteiro. Ponteiros para funções são geralmente um typedef por
+simplicidade e legibilidade, como segue:
+*/
+
+typedef void (*minha_função_type)(char *);
+
+// Declarando o ponteiro:
+// ...
+// minha_função_type f; 
+
+//Caracteres especiais:
+'\a' // Alerta (sino)
+'\n' // Nova linha
+'\t' // Tab (justifica texto a esquerda)
+'\v' // Tab vertical
+'\f' // Nova linha (formfeed)
+'\r' // Retorno de carroça
+'\b' // Backspace
+'\0' // Caracter nulo. Geralmente colocado ao final de string em C.
+     //   oi\n\0. \0 é usado por convenção para marcar o fim da string. 
+'\\' // Barra invertida
+'\?' // Interrogação
+'\'' // Aspas simples
+'\"' // Aspas duplas
+'\xhh' // Número hexadecimal. Exemplo: '\xb' = tab vertical
+'\ooo' // Número octal. Exemplo: '\013' = tab vertical
+
+// formatando impressão:
+"%d"    // inteiro
+"%3d"   // inteiro com pelo menos 3 dígitos (justifica texto a direita)
+"%s"    // string
+"%f"    // ponto-flutuante
+"%ld"   // long
+"%3.2f" // ponto-flutuante com pelo menos 3 dígitos a esquerda e 2 a direita
+"%7.4s" // (também pode-se fazer com strings)
+"%c"    // char
+"%p"    // ponteiro
+"%x"    // hexadecimal
+"%o"    // octal
+"%%"    // imprime % 
+
+///////////////////////////////////////
+// Ordem de avaliação
+///////////////////////////////////////
+
+//-----------------------------------------------------------//
+//        Operadores                       | Associatividade //
+//-----------------------------------------------------------//
+// () [] -> .                        | esquerda para direita //
+// ! ~ ++ -- + = *(type)sizeof       | direita para esqureda //
+// * / %                             | esquerda para direita //
+// + -                               | esquerda para direita //
+// << >>                             | esquerda para direita //
+// < <= > >=                         | esquerda para direita //
+// == !=                             | esquerda para direita //
+// &                                 | esquerda para direita //
+// ^                                 | esquerda para direita //
+// |                                 | esquerda para direita //
+// &&                                | esquerda para direita //
+// ||                                | esquerda para direita //
+// ?:                                | direita para esqureda //
+// = += -= *= /= %= &= ^= |= <<= >>= | direita para esqureda //
+// ,                                 | esquerda para direita //
+//-----------------------------------------------------------//
+
+```
+
+## Leitura adicional
+
+É recomendado ter uma cópia de [K&R, aka "The C Programming Language"](https://en.wikipedia.org/wiki/The_C_Programming_Language).
+Este é *o* livro sobre C, escrito pelos criadores da linguage. Mas cuidado - ele é antigo e contém alguns erros (bem,
+ideias que não são consideradas boas hoje) ou práticas mudadas.
+
+Outra boa referência é [Learn C the hard way](http://c.learncodethehardway.org/book/).
+
+Se você tem uma pergunta, leia [compl.lang.c Frequently Asked Questions](http://c-faq.com).
+
+É importante usar espaços e indentação adequadamente e ser consistente com seu estilo de código em geral.
+Código legível é melhor que código 'esperto' e rápido. Para adotar um estilo de código bom e são, veja
+[Linux kernel coding stlye](https://www.kernel.org/doc/Documentation/CodingStyle).
+
+Além disso, Google é teu amigo.
+[1] http://stackoverflow.com/questions/119123/why-isnt-sizeof-for-a-struct-equal-to-the-sum-of-sizeof-of-each-member
diff --git a/pt-br/clojure-pt.html.markdown b/pt-br/clojure-pt.html.markdown
new file mode 100644
index 00000000..7e8b3f7b
--- /dev/null
+++ b/pt-br/clojure-pt.html.markdown
@@ -0,0 +1,384 @@
+---
+language: clojure
+filename: learnclojure-pt.clj
+contributors:
+    - ["Adam Bard", "http://adambard.com/"]
+translators:
+    - ["Mariane Siqueira Machado", "https://twitter.com/mariane_sm"]
+lang: pt-br
+---
+
+Clojure é uma linguagem da família do Lisp desenvolvida para a JVM (máquina virtual Java). Possui uma ênfase muito mais forte em [programação funcional] (https://pt.wikipedia.org/wiki/Programa%C3%A7%C3%A3o_funcional) pura do que Common Lisp, mas inclui diversas utilidades [STM](https://en.wikipedia.org/wiki/Software_transactional_memory) para lidar com estado a medida que isso se torna necessário.
+
+Essa combinação permite gerenciar processamento concorrente de maneira muito simples, e frequentemente de maneira automática.
+
+(Sua versão de clojure precisa ser pelo menos 1.2)
+
+
+```clojure
+; Comentários começam por ponto e vírgula
+
+; Clojure é escrito em "forms", os quais são simplesmente 
+; listas de coisas dentro de parênteses, separados por espaços em branco.
+
+; O "reader" (leitor) de Clojure presume que o primeiro elemento de 
+; uma par de parênteses é uma função ou macro, e que os resto são argumentos.
+
+: A primeira chamada de um arquivo deve ser ns, para configurar o namespace (espaço de nomes)
+(ns learnclojure)
+
+; Alguns exemplos básicos:
+
+; str cria uma string concatenando seus argumentos
+(str "Hello" " " "World") ; => "Hello World"
+
+; Cálculos são feitos de forma direta e intuitiva
+(+ 1 1) ; => 2
+(- 2 1) ; => 1
+(* 1 2) ; => 2
+(/ 2 1) ; => 2
+
+; Você pode comparar igualdade utilizando =
+(= 1 1) ; => true
+(= 2 1) ; => false
+
+; Negação para operações lógicas
+(not true) ; => false
+
+; Aninhar "forms" funciona como esperado
+(+ 1 (- 3 2)) ; = 1 + (3 - 2) => 2
+
+; Tipos
+;;;;;;;;;;;;;
+
+; Clojure usa os tipos de objetos de Java para booleanos, strings e números.
+; Use `class` para inspecioná-los
+(class 1) ; Literais Integer são java.lang.Long por padrão
+(class 1.); Literais Float são java.lang.Double
+(class ""); Strings são sempre com aspas duplas, e são java.lang.String
+(class false) ; Booleanos são java.lang.Boolean
+(class nil); O valor "null" é chamado nil
+
+; Se você quiser criar um lista de literais, use aspa simples para 
+; ela não ser avaliada
+'(+ 1 2) ; => (+ 1 2)
+; (que é uma abreviação de (quote (+ 1 2)))
+
+; É possível avaliar uma lista com aspa simples
+(eval '(+ 1 2)) ; => 3
+
+; Coleções e sequências
+;;;;;;;;;;;;;;;;;;;
+
+; Listas são estruturas encadeadas, enquanto vetores são implementados como arrays.
+; Listas e Vetores são classes Java também!
+(class [1 2 3]); => clojure.lang.PersistentVector
+(class '(1 2 3)); => clojure.lang.PersistentList
+
+; Uma lista é escrita como (1 2 3), mas temos que colocar a aspa 
+; simples para impedir o leitor (reader) de pensar que é uma função.
+; Também, (list 1 2 3) é o mesmo que '(1 2 3)
+
+; "Coleções" são apenas grupos de dados
+; Listas e vetores são ambos coleções:
+(coll? '(1 2 3)) ; => true
+(coll? [1 2 3]) ; => true
+
+; "Sequências" (seqs) são descrições abstratas de listas de dados.
+; Apenas listas são seqs.
+(seq? '(1 2 3)) ; => true
+(seq? [1 2 3]) ; => false
+
+; Um seq precisa apenas prover uma entrada quando é acessada.
+; Portanto, já que seqs podem ser avaliadas sob demanda (lazy) -- elas podem definir séries infinitas:
+(range 4) ; => (0 1 2 3)
+(range) ; => (0 1 2 3 4 ...) (uma série infinita)
+(take 4 (range)) ;  (0 1 2 3)
+
+; Use cons para adicionar um item no início de uma lista ou vetor
+(cons 4 [1 2 3]) ; => (4 1 2 3)
+(cons 4 '(1 2 3)) ; => (4 1 2 3)
+
+; Conj adiciona um item em uma coleção sempre do jeito mais eficiente.
+; Para listas, elas inserem no início. Para vetores, é inserido no final.
+(conj [1 2 3] 4) ; => [1 2 3 4]
+(conj '(1 2 3) 4) ; => (4 1 2 3)
+
+; Use concat para concatenar listas e vetores
+(concat [1 2] '(3 4)) ; => (1 2 3 4)
+
+; Use filter, map para interagir com coleções
+(map inc [1 2 3]) ; => (2 3 4)
+(filter even? [1 2 3]) ; => (2)
+
+; Use reduce para reduzi-los
+(reduce + [1 2 3 4])
+; = (+ (+ (+ 1 2) 3) 4)
+; => 10
+
+; Reduce pode receber um argumento para o valor inicial
+(reduce conj [] '(3 2 1))
+; = (conj (conj (conj [] 3) 2) 1)
+; => [3 2 1]
+
+; Funções
+;;;;;;;;;;;;;;;;;;;;;
+
+; Use fn para criar novas funções. Uma função sempre retorna
+; sua última expressão.
+(fn [] "Hello World") ; => fn
+
+; (É necessário colocar parênteses para chamá-los)
+((fn [] "Hello World")) ; => "Hello World"
+
+; Você pode atribuir valores a variáveis utilizando def
+(def x 1)
+x ; => 1
+
+; Atribua uma função para uma var
+(def hello-world (fn [] "Hello World"))
+(hello-world) ; => "Hello World"
+
+; Você pode abreviar esse processo usando defn
+(defn hello-world [] "Hello World")
+
+; O [] é uma lista de argumentos para um função.
+(defn hello [name]
+  (str "Hello " name))
+(hello "Steve") ; => "Hello Steve"
+
+; Você pode ainda usar essa abreviação para criar funcões:
+(def hello2 #(str "Hello " %1))
+(hello2 "Fanny") ; => "Hello Fanny"
+
+; Vocé pode ter funções multi-variadic, isto é, com um número variável de argumentos
+(defn hello3
+  ([] "Hello World")
+  ([name] (str "Hello " name)))
+(hello3 "Jake") ; => "Hello Jake"
+(hello3) ; => "Hello World"
+
+; Funções podem agrupar argumentos extras em uma seq
+(defn count-args [& args]
+  (str "You passed " (count args) " args: " args))
+(count-args 1 2 3) ; => "You passed 3 args: (1 2 3)"
+
+; Você pode misturar argumentos regulares e argumentos em seq
+(defn hello-count [name & args]
+  (str "Hello " name ", you passed " (count args) " extra args"))
+(hello-count "Finn" 1 2 3)
+; => "Hello Finn, you passed 3 extra args"
+
+
+; Mapas
+;;;;;;;;;;
+
+; Hash maps e array maps compartilham uma mesma interface. Hash maps são mais
+; rápidos para pesquisa mas não mantém a ordem da chave.
+(class {:a 1 :b 2 :c 3}) ; => clojure.lang.PersistentArrayMap
+(class (hash-map :a 1 :b 2 :c 3)) ; => clojure.lang.PersistentHashMap
+
+; Arraymaps pode automaticamente se tornar hashmaps através da maioria das
+; operações se eles ficarem grandes o suficiente, portanto não há necessida de 
+; se preocupar com isso.
+
+;Mapas podem usar qualquer valor que se pode derivar um hash como chave
+
+
+; Mapas podem usar qualquer valor em que se pode derivar um hash como chave, 
+; mas normalmente palavras-chave (keywords) são melhores.
+; Keywords são como strings mas com algumas vantagens.
+(class :a) ; => clojure.lang.Keyword
+
+(def stringmap {"a" 1, "b" 2, "c" 3})
+stringmap  ; => {"a" 1, "b" 2, "c" 3}
+
+(def keymap {:a 1, :b 2, :c 3})
+keymap ; => {:a 1, :c 3, :b 2}
+
+; A propósito, vírgulas são sempre tratadas como espaçoes em branco e não fazem nada.
+
+; Recupere o valor de um mapa chamando ele como uma função
+(stringmap "a") ; => 1
+(keymap :a) ; => 1
+
+; Uma palavra-chave pode ser usada pra recuperar os valores de um mapa
+(:b keymap) ; => 2
+
+; Não tente isso com strings
+;("a" stringmap)
+; => Exception: java.lang.String cannot be cast to clojure.lang.IFn
+
+; Buscar uma chave não presente retorna nil
+(stringmap "d") ; => nil
+
+; Use assoc para adicionar novas chaves para hash-maps
+(def newkeymap (assoc keymap :d 4))
+newkeymap ; => {:a 1, :b 2, :c 3, :d 4}
+
+; Mas lembre-se, tipos em Clojure são sempre imutáveis!
+keymap ; => {:a 1, :b 2, :c 3}
+
+; Use dissoc para remover chaves
+(dissoc keymap :a :b) ; => {:c 3}
+
+; Conjuntos
+;;;;;;
+
+(class #{1 2 3}) ; => clojure.lang.PersistentHashSet
+(set [1 2 3 1 2 3 3 2 1 3 2 1]) ; => #{1 2 3}
+
+; Adicione um membro com conj
+(conj #{1 2 3} 4) ; => #{1 2 3 4}
+
+; Remova um membro com disj
+(disj #{1 2 3} 1) ; => #{2 3}
+
+; Test por existência usando set como função:
+(#{1 2 3} 1) ; => 1
+(#{1 2 3} 4) ; => nil
+
+; Existem muitas outras funções no namespace clojure.sets
+
+; Forms úteis
+;;;;;;;;;;;;;;;;;
+
+; Construções lógicas em Clojure são como macros, e 
+; se parecem com as demais
+(if false "a" "b") ; => "b"
+(if false "a") ; => nil
+
+; Use let para criar um novo escopo associando sîmbolos a valores (bindings)
+(let [a 1 b 2]
+  (> a b)) ; => false
+
+; Agrupe comandos juntos com "do"
+(do
+  (print "Hello")
+  "World") ; => "World" (prints "Hello")
+
+; Funções tem um do implícito
+(defn print-and-say-hello [name]
+  (print "Saying hello to " name)
+  (str "Hello " name))
+(print-and-say-hello "Jeff") ;=> "Hello Jeff" (prints "Saying hello to Jeff")
+
+; Assim como let
+(let [name "Urkel"]
+  (print "Saying hello to " name)
+  (str "Hello " name)) ; => "Hello Urkel" (prints "Saying hello to Urkel")
+
+; Módulos
+;;;;;;;;;;;;;;;
+
+; Use "use" para poder usar todas as funções de um modulo
+(use 'clojure.set)
+
+; Agora nós podemos usar operações com conjuntos
+(intersection #{1 2 3} #{2 3 4}) ; => #{2 3}
+(difference #{1 2 3} #{2 3 4}) ; => #{1}
+
+; Você pode escolher um subconjunto de funções para importar
+(use '[clojure.set :only [intersection]])
+
+; Use require para importar um módulo
+(require 'clojure.string)
+
+; Use / para chamar funções de um módulo
+; Aqui, o módulo é clojure.string e a função é blank?
+(clojure.string/blank? "") ; => true
+
+; Você pode dar para um módulo um nome mais curto no import
+(require '[clojure.string :as str])
+(str/replace "This is a test." #"[a-o]" str/upper-case) ; => "THIs Is A tEst."
+; (#"" denota uma expressão regular literal)
+
+; Você pode usar require (e até "use", mas escolha require) de um namespace utilizando :require.
+; Não é necessário usar aspa simples nos seus módulos se você usar desse jeito.
+(ns test
+  (:require
+    [clojure.string :as str]
+    [clojure.set :as set]))
+
+; Java
+;;;;;;;;;;;;;;;;;
+
+; Java tem uma biblioteca padrão enorme e muito útil, 
+; portanto é importante aprender como utiliza-la.
+
+; Use import para carregar um modulo java
+(import java.util.Date)
+
+; Você pode importar usando ns também.
+(ns test
+  (:import java.util.Date
+           java.util.Calendar))
+
+; Use o nome da clase com um "." no final para criar uma nova instância
+(Date.) ; <a date object>
+
+; Use . para chamar métodos. Ou, use o atalho ".method"
+(. (Date.) getTime) ; <a timestamp>
+(.getTime (Date.)) ; exatamente a mesma coisa.
+
+; Use / para chamar métodos estáticos
+(System/currentTimeMillis) ; <a timestamp> (o módulo System está sempre presente)
+
+; Use doto para pode lidar com classe (mutáveis) de forma mais tolerável
+(import java.util.Calendar)
+(doto (Calendar/getInstance)
+  (.set 2000 1 1 0 0 0)
+  .getTime) ; => A Date. set to 2000-01-01 00:00:00
+
+; STM
+;;;;;;;;;;;;;;;;;
+
+; Software Transactional Memory é o mecanismo que Clojure usa para gerenciar
+; estado persistente. Tem algumas construções em Clojure que o utilizam.
+
+; O atom é o mais simples. Passe pra ele um valor inicial
+(def my-atom (atom {}))
+
+; Atualize o atom com um swap!.
+; swap! pega uma funçnao and chama ela com o valor atual do atom
+; como primeiro argumento, e qualquer argumento restante como o segundo
+(swap! my-atom assoc :a 1) ; Coloca o valor do átomo my-atom como o resultado de  (assoc {} :a 1)
+(swap! my-atom assoc :b 2) ; Coloca o valor do átomo my-atom como o resultado de (assoc {:a 1} :b 2)
+
+; Use '@' para desreferenciar um atom e acessar seu valor
+my-atom  ;=> Atom<#...> (Retorna o objeto do Atom)
+@my-atom ; => {:a 1 :b 2}
+
+; Abaixo um contador simples usando um atom
+(def counter (atom 0))
+(defn inc-counter []
+  (swap! counter inc))
+
+(inc-counter)
+(inc-counter)
+(inc-counter)
+(inc-counter)
+(inc-counter)
+
+@counter ; => 5
+
+; Outras construção STM são refs e agents.
+; Refs: http://clojure.org/refs
+; Agents: http://clojure.org/agents
+```
+
+### Leitura adicional
+
+Esse tutorial está longe de ser exaustivo, mas deve ser suficiente para que você possa começar.
+
+Clojure.org tem vários artigos:
+[http://clojure.org/](http://clojure.org/)
+
+Clojuredocs.org tem documentação com exemplos para quase todas as funções principais (pertecentes ao core):
+[http://clojuredocs.org/quickref/Clojure%20Core](http://clojuredocs.org/quickref/Clojure%20Core)
+
+4Clojure é um grande jeito de aperfeiçoar suas habilidades em Clojure/Programação Funcional:
+[http://www.4clojure.com/](http://www.4clojure.com/)
+
+Clojure-doc.org tem um bom número de artigos para iniciantes:
+[http://clojure-doc.org/](http://clojure-doc.org/)
diff --git a/pt-br/coffeescript-pt.html.markdown b/pt-br/coffeescript-pt.html.markdown
new file mode 100644
index 00000000..8b1094b1
--- /dev/null
+++ b/pt-br/coffeescript-pt.html.markdown
@@ -0,0 +1,106 @@
+---
+language: coffeescript
+contributors:
+  - ["Tenor Biel", "http://github.com/L8D"]
+  - ["Xavier Yao", "http://github.com/xavieryao"]
+translators:
+    - ["Miguel Araújo", "https://github.com/miguelarauj1o"]
+lang: pt-br
+filename: learncoffeescript-pt.coffee
+---
+
+CoffeeScript é uma pequena linguagem que compila um-para-um para o JavaScript 
+equivalente, e não há interpretação em tempo de execução. Como um dos sucessores 
+de JavaScript, CoffeeScript tenta o seu melhor para exibir uma saída legível, 
+bem-impressa e bom funcionamento dos códigos JavaScript em todo o tempo de 
+execução JavaScript.
+
+Veja também [site do CoffeeScript](http://coffeescript.org/), que tem um tutorial 
+completo sobre CoffeeScript.
+
+``` coffeescript
+#CoffeeScript é uma linguagem moderna
+#Segue as tendências de muitas linguagens modernas
+#Assim, os comentários são iguais a Ruby e Python, eles usam símbolos numéricos.
+
+### 
+Os comentários em bloco são como estes, e eles traduzem diretamente para '/ *'s e 
+'* /'s para o código JavaScript que resulta...
+
+Você deveria entender mais de semântica de JavaScript antes de continuar... 
+###
+
+# Tarefa: 
+numero = 42 #=> número var = 42; 
+oposto = true #=> var oposto = true;
+
+# Condições: 
+numero = -42 if oposto #=> if (oposto) {número = -42;}
+
+# Funções: 
+quadrado = (x) -> x * x #=> var quadrado = function (x) {return x * x;}
+
+preencher = (recipiente, líquido = "coffee") ->
+  "Preenchendo o #{recipiente} with #{líquido}..."
+#=>var preencher;
+#
+#preencher = function(recipiente, líquido) {
+#  if (líquido == null) {
+#    líquido = "coffee";
+#  }
+#  return "Preenchendo o " + recipiente + " with " + líquido + "...";
+#};
+
+# Alcances: 
+list = [1 .. 5] #=> lista var = [1, 2, 3, 4, 5];
+
+# Objetos:
+math =
+  root:   Math.sqrt
+  square: square
+  cube:   (x) -> x * square x
+#=> var math = {
+#  "root": Math.sqrt,
+#  "square": square,
+#  "cube": function(x) { return x * square(x); }
+#}
+
+# Splats:
+corrida = (vencedor, corredores...) ->
+  print vencedor, corredores
+#=>corrida = function() {
+#  var corredores, vencedor;
+#  vencedor = arguments[0], corredores = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
+#  return print(vencedor, corredores);
+#};
+
+# Existências:
+alert "Eu sabia!" if elvis?
+#=> if(typeof elvis !== "undefined" && elvis !== null) { alert("Eu sabia!"); }
+
+# Compressão de Matrizes:
+cubes = (math.cube num for num in list) 
+#=>cubes = (function() {
+#   var _i, _len, _results;
+#   _results = [];
+#   for (_i = 0, _len = list.length; _i < _len; _i++) {
+#       num = list[_i];
+#       _results.push(math.cube(num));
+#   }
+#   return _results;
+#  })();
+
+comidas = ['brócolis', 'espinafre', 'chocolate']
+eat alimento for alimento in comidas when alimento isnt 'chocolate'
+#=>comidas = ['brócolis', 'espinafre', 'chocolate'];
+#
+#for (_k = 0, _len2 = comidas.length; _k < _len2; _k++) {
+#  alimento = comidas[_k];
+#  if (alimento !== 'chocolate') {
+#    eat(alimento);
+#  }
+
+## Recursos adicionais
+
+- [Smooth CoffeeScript](http://autotelicum.github.io/Smooth-CoffeeScript/)
+- [CoffeeScript Ristretto](https://leanpub.com/coffeescript-ristretto/read)
\ No newline at end of file
diff --git a/pt-br/common-lisp-pt.html.markdown b/pt-br/common-lisp-pt.html.markdown
new file mode 100644
index 00000000..03a7c15c
--- /dev/null
+++ b/pt-br/common-lisp-pt.html.markdown
@@ -0,0 +1,622 @@
+---
+language: "Common Lisp"
+filename: commonlisp-pt.lisp
+contributors:
+  - ["Paul Nathan", "https://github.com/pnathan"]
+translators:
+  - ["Édipo Luis Féderle", "https://github.com/edipofederle"]
+lang: pt-br
+---
+
+ANSI Common Lisp é uma linguagem de uso geral, multi-paradigma, designada
+para uma variedade de aplicações na indústria. É frequentemente citada
+como uma linguagem de programação programável.
+
+
+O ponto inicial clássico é [Practical Common Lisp e livremente disponível](http://www.gigamonkeys.com/book/)
+
+Outro livro recente e popular é o
+[Land of Lisp](http://landoflisp.com/).
+
+
+```common_lisp
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; 0. Sintaxe
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;; "Form" Geral
+
+
+;; Lisp tem dois pedaços fundamentais de sintaxe: o ATOM e S-expression.
+;; Tipicamente, S-expressions agrupadas são chamadas de `forms`.
+
+
+10  ; um atom; é avaliado para ele mesmo
+
+:THING ;Outro atom; avaliado para o símbolo :thing.
+
+t ; outro atom, denotado true.
+
+(+ 1 2 3 4) ; uma s-expression
+
+'(4 :foo  t)  ;outra s-expression
+
+
+;;; Comentários
+
+;; Comentários de uma única linha começam com ponto e vírgula; usar dois para
+;; comentários normais, três para comentários de seção, e quadro para comentários
+;; em nível de arquivo.
+
+#| Bloco de comentário
+   pode abranger várias linhas e...
+    #|
+       eles podem ser aninhados
+    |#
+|#
+
+;;; Ambiente
+
+;; Existe uma variedade de implementações; a maioria segue o padrão.
+;; CLISP é um bom ponto de partida.
+
+;; Bibliotecas são gerenciadas através do Quicklisp.org's Quicklisp sistema.
+
+;; Common Lisp é normalmente desenvolvido com um editor de texto e um REPL
+;; (Read Evaluate Print Loop) rodando ao mesmo tempo. O REPL permite exploração
+;; interativa do programa como ele é "ao vivo" no sistema.
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; 1. Tipos Primitivos e Operadores
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;; Símbolos
+
+'foo ; => FOO Perceba que um símbolo é automáticamente convertido para maiúscula.
+
+;; Intern manualmente cria um símbolo a partir de uma string.
+
+(intern "AAAA") ; => AAAA
+
+(intern "aaa") ; => |aaa|
+
+;;; Números
+9999999999999999999999 ; inteiro
+#b111                  ; binário => 7
+#o111                  ; octal => 73
+#x111                  ; hexadecimal => 273
+3.14159s0              ; single
+3.14159d0              ; double
+1/2                    ; ratios
+#C(1 2)                ; números complexos
+
+
+;; Funções são escritas como (f x y z ...)
+;; onde f é uma função e x, y, z, ... são operadores
+;; Se você quiser criar uma lista literal de dados, use ' para evitar 
+;; que a lista seja avaliada - literalmente, "quote" os dados.
+'(+ 1 2) ; => (+ 1 2)
+;; Você também pode chamar uma função manualmente:
+(funcall #'+ 1 2 3) ; => 6
+;; O mesmo para operações aritiméticas
+(+ 1 1)              ; => 2
+(- 8 1)              ; => 7
+(* 10 2)             ; => 20
+(expt 2 3)           ; => 8
+(mod 5 2)            ; => 1
+(/ 35 5)             ; => 7
+(/ 1 3)              ; => 1/3
+(+ #C(1 2) #C(6 -4)) ; => #C(7 -2)
+
+                     ;;; Booleans
+t                    ; para true (qualquer valor não nil é true)
+nil                  ; para false - e para lista vazia
+(not nil)            ; => t
+(and 0 t)            ; => t
+(or 0 nil)           ; => 0
+
+                     ;;; Caracteres
+#\A                  ; => #\A
+#\λ                  ; => #\GREEK_SMALL_LETTER_LAMDA
+#\u03BB              ; => #\GREEK_SMALL_LETTER_LAMDA
+
+;;; String são arrays de caracteres com tamanho fixo.
+"Hello, world!"
+"Benjamin \"Bugsy\" Siegel"   ; barra é um escape de caracter
+
+;; String podem ser concatenadas também!
+(concatenate 'string "Hello " "world!") ; => "Hello world!"
+
+;; Uma String pode ser tratada como uma sequência de caracteres
+(elt "Apple" 0) ; => #\A
+
+;; format pode ser usado para formatar strings
+(format nil "~a can be ~a" "strings" "formatted")
+
+;; Impimir é bastante fácil; ~% indica nova linha
+(format t "Common Lisp is groovy. Dude.~%")
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 2. Variáveis
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Você pode criar uma global (escopo dinâmico) usando defparameter
+;; um nome de variável pode conter qualquer caracter, exceto: ()",'`;#|\
+
+;; Variáveis de escopo dinâmico devem ter asteriscos em seus nomes!
+
+(defparameter *some-var* 5)
+*some-var* ; => 5
+
+;; Você pode usar caracteres unicode também.
+(defparameter *AΛB* nil)
+
+
+;; Acessando uma variável anteriormente não ligada é um
+;; comportamento não definido (mas possível). Não faça isso.
+
+;; Ligação local: `me` é vinculado com "dance with you" somente dentro
+;; de (let ... ). Let permite retornar o valor do último `form` no form let.
+
+(let ((me "dance with you"))
+  me)
+;; => "dance with you"
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 3. Estruturas e Coleções
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Estruturas
+(defstruct dog name breed age)
+(defparameter *rover*
+    (make-dog :name "rover"
+              :breed "collie"
+              :age 5))
+*rover* ; => #S(DOG :NAME "rover" :BREED "collie" :AGE 5)
+
+(dog-p *rover*) ; => t  ;; ewww)
+(dog-name *rover*) ; => "rover"
+
+;; Dog-p, make-dog, e dog-name foram todas criadas por defstruct!
+
+;;; Pares
+;; `cons' constroi pares, `car' and `cdr' extrai o primeiro
+;; e o segundo elemento
+(cons 'SUBJECT 'VERB) ; => '(SUBJECT . VERB)
+(car (cons 'SUBJECT 'VERB)) ; => SUBJECT
+(cdr (cons 'SUBJECT 'VERB)) ; => VERB
+
+;;; Listas
+
+;; Listas são estruturas de dados do tipo listas encadeadas, criadas com `cons'
+;; pares e terminam `nil' (ou '()) para marcar o final da lista
+(cons 1 (cons 2 (cons 3 nil))) ; => '(1 2 3)
+;; `list' é um construtor conveniente para listas
+(list 1 2 3) ; => '(1 2 3)
+;; e a quote (') também pode ser usado para um valor de lista literal
+'(1 2 3) ; => '(1 2 3)
+
+;; Ainda pode-se usar `cons' para adicionar um item no começo da lista.
+(cons 4 '(1 2 3)) ; => '(4 1 2 3)
+
+;; Use `append' para - surpreendentemente - juntar duas listas
+(append '(1 2) '(3 4)) ; => '(1 2 3 4)
+
+;; Ou use concatenate -
+
+(concatenate 'list '(1 2) '(3 4))
+
+;; Listas são um tipo muito central, então existe uma grande variedade de
+;; funcionalidades para eles, alguns exemplos:
+(mapcar #'1+ '(1 2 3))             ; => '(2 3 4)
+(mapcar #'+ '(1 2 3) '(10 20 30))  ; => '(11 22 33)
+(remove-if-not #'evenp '(1 2 3 4)) ; => '(2 4)
+(every #'evenp '(1 2 3 4))         ; => nil
+(some #'oddp '(1 2 3 4))           ; => T
+(butlast '(subject verb object))   ; => (SUBJECT VERB)
+
+
+;;; Vetores
+
+;; Vector's literais são arrays de tamanho fixo.
+#(1 2 3) ; => #(1 2 3)
+
+;; Use concatenate para juntar dois vectors
+(concatenate 'vector #(1 2 3) #(4 5 6)) ; => #(1 2 3 4 5 6)
+
+;;; Arrays
+
+;; Ambos vetores e strings são um caso especial de arrays.
+
+;; 2D arrays
+
+(make-array (list 2 2))
+
+;; (make-array '(2 2)) também funciona.
+
+; => #2A((0 0) (0 0))
+
+(make-array (list 2 2 2))
+
+; => #3A(((0 0) (0 0)) ((0 0) (0 0)))
+
+;; Cuidado - os valores de inicialição padrões são
+;; definidos pela implementção. Aqui vai como defini-lós.
+
+(make-array '(2) :initial-element 'unset)
+
+; => #(UNSET UNSET)
+
+;; E, para acessar o element em 1,1,1 -
+(aref (make-array (list 2 2 2)) 1 1 1)
+
+; => 0
+
+;;; Vetores Ajustáveis
+
+;; Vetores ajustáveis tem a mesma representação impressa que os vectores
+;;  de tamanho fixo
+(defparameter *adjvec* (make-array '(3) :initial-contents '(1 2 3)
+      :adjustable t :fill-pointer t))
+      
+*adjvec* ; => #(1 2 3)
+
+;; Adicionando novo elemento
+(vector-push-extend 4 *adjvec*) ; => 3
+
+*adjvec* ; => #(1 2 3 4)
+
+
+
+;;; Ingenuamente, conjuntos são apenas listas:
+
+(set-difference '(1 2 3 4) '(4 5 6 7)) ; => (3 2 1)
+(intersection '(1 2 3 4) '(4 5 6 7)) ; => 4
+(union '(1 2 3 4) '(4 5 6 7))        ; => (3 2 1 4 5 6 7)
+(adjoin 4 '(1 2 3 4))     ; => (1 2 3 4)
+
+;; Mas você irá querer usar uma estrutura de dados melhor que uma lista encadeada.
+;; para performance.
+
+;;; Dicionários são implementados como hash tables
+
+;; Cria um hash table
+(defparameter *m* (make-hash-table))
+
+;; seta um valor
+(setf (gethash 'a *m*) 1)
+
+;; Recupera um valor
+(gethash 'a *m*) ; => 1, t
+
+;; Detalhe - Common Lisp  tem multiplos valores de retorno possíveis. gethash
+;; retorna t no segundo valor se alguma coisa foi encontrada, e nil se não.
+
+;; Recuperando um valor não presente retorna nil
+ (gethash 'd *m*) ;=> nil, nil
+
+;; Você pode fornecer um valor padrão para uma valores não encontrados
+(gethash 'd *m* :not-found) ; => :NOT-FOUND
+
+;; Vamos tratas múltiplos valores de rotorno aqui.
+
+(multiple-value-bind
+      (a b)
+    (gethash 'd *m*)
+  (list a b))
+; => (NIL NIL)
+
+(multiple-value-bind
+      (a b)
+    (gethash 'a *m*)
+  (list a b))
+; => (1 T)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 3. Funções
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Use `lambda' para criar funções anônimas
+;; Uma função sempre retorna um valor da última expressão avaliada.
+;; A representação exata impressão de uma função varia de acordo ...
+
+(lambda () "Hello World") ; => #<FUNCTION (LAMBDA ()) {1004E7818B}>
+
+;; Use funcall para chamar uma função lambda.
+(funcall (lambda () "Hello World")) ; => "Hello World"
+
+;; Ou Apply
+(apply (lambda () "Hello World") nil) ; => "Hello World"
+
+;; "De-anonymize" a função
+(defun hello-world ()
+   "Hello World")
+(hello-world) ; => "Hello World"
+
+;; O () acima é a lista de argumentos da função.
+(defun hello (name)
+   (format nil "Hello, ~a " name))
+
+(hello "Steve") ; => "Hello, Steve"
+
+;; Funções podem ter argumentos opcionais; eles são nil por padrão
+
+(defun hello (name &optional from)
+    (if from
+        (format t "Hello, ~a, from ~a" name from)
+        (format t "Hello, ~a" name)))
+
+ (hello "Jim" "Alpacas") ;; => Hello, Jim, from Alpacas
+
+;; E os padrões podem ser configurados...
+(defun hello (name &optional (from "The world"))
+   (format t "Hello, ~a, from ~a" name from))
+
+(hello "Steve")
+; => Hello, Steve, from The world
+
+(hello "Steve" "the alpacas")
+; => Hello, Steve, from the alpacas
+
+
+;; E é claro, palavras-chaves são permitidas também... frequentemente mais
+;; flexivel que &optional.
+
+(defun generalized-greeter (name &key (from "the world") (honorific "Mx"))
+    (format t "Hello, ~a ~a, from ~a" honorific name from))
+
+(generalized-greeter "Jim")   ; => Hello, Mx Jim, from the world
+
+(generalized-greeter "Jim" :from "the alpacas you met last summer" :honorific "Mr")
+; => Hello, Mr Jim, from the alpacas you met last summer
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 4. Igualdade
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Common Lisp tem um sistema sofisticado de igualdade. Alguns são cobertos aqui.
+
+;; Para número use `='
+(= 3 3.0) ; => t
+(= 2 1) ; => nil
+
+;; para identidade de objeto (aproximadamente) use `eql`
+(eql 3 3) ; => t
+(eql 3 3.0) ; => nil
+(eql (list 3) (list 3)) ; => nil
+
+;; para listas, strings, e para pedaços de vetores use `equal'
+(equal (list 'a 'b) (list 'a 'b)) ; => t
+(equal (list 'a 'b) (list 'b 'a)) ; => nil
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 5. Fluxo de Controle
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;; Condicionais
+
+(if t                ; testa a expressão
+    "this is true"   ; então expressão
+    "this is false") ; senão expressão
+; => "this is true"
+
+;; Em condicionais, todos valores não nulos são tratados como true
+(member 'Groucho '(Harpo Groucho Zeppo)) ; => '(GROUCHO ZEPPO)
+(if (member 'Groucho '(Harpo Groucho Zeppo))
+    'yep
+    'nope)
+; => 'YEP
+
+;; `cond' encadeia uma série de testes para selecionar um resultado
+(cond ((> 2 2) (error "wrong!"))
+      ((< 2 2) (error "wrong again!"))
+      (t 'ok)) ; => 'OK
+
+;; Typecase é um condicional que escolhe uma de seus cláusulas com base do tipo
+;; do seu valor
+
+(typecase 1
+  (string :string)
+  (integer :int))
+
+; => :int
+
+;;; Interação
+
+;; Claro que recursão é suportada:
+
+(defun walker (n)
+  (if (zerop n)
+      :walked
+      (walker (1- n))))
+
+(walker 5) ; => :walked
+
+;; Na maioria das vezes, nós usamos DOTLISO ou LOOP
+
+(dolist (i '(1 2 3 4))
+  (format t "~a" i))
+
+; => 1234
+
+(loop for i from 0 below 10
+      collect i)
+
+; => (0 1 2 3 4 5 6 7 8 9)
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 6. Mutação
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Use `setf' para atribuir um novo valor para uma variável existente. Isso foi
+;; demonstrado anteriormente no exemplo da hash table.
+
+(let ((variable 10))
+    (setf variable 2))
+ ; => 2
+
+
+;; Um bom estilo Lisp é para minimizar funções destrutivas e para evitar 
+;; mutação quando razoável.
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 7. Classes e Objetos
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Sem clases Animal, vamos usar os veículos de transporte de tração
+;; humana mecânicos.
+
+(defclass human-powered-conveyance ()
+  ((velocity
+    :accessor velocity
+    :initarg :velocity)
+   (average-efficiency
+    :accessor average-efficiency
+   :initarg :average-efficiency))
+  (:documentation "A human powered conveyance"))
+
+;; defcalss, seguido do nome, seguido por uma list de superclass,
+;; seguido por um uma 'slot list', seguido por qualidades opcionais como
+;; :documentation
+
+;; Quando nenhuma lista de superclasse é setada, uma lista padrão para
+;; para o objeto padrão é usada. Isso *pode* ser mudado, mas não até você
+;; saber o que está fazendo. Olhe em Art of the Metaobject Protocol
+;; para maiores informações.
+
+(defclass bicycle (human-powered-conveyance)
+  ((wheel-size
+    :accessor wheel-size
+    :initarg :wheel-size
+    :documentation "Diameter of the wheel.")
+   (height
+    :accessor height
+    :initarg :height)))
+
+(defclass recumbent (bicycle)
+  ((chain-type
+    :accessor chain-type
+    :initarg  :chain-type)))
+
+(defclass unicycle (human-powered-conveyance) nil)
+
+(defclass canoe (human-powered-conveyance)
+  ((number-of-rowers
+    :accessor number-of-rowers
+    :initarg :number-of-rowers)))
+
+
+;; Chamando DESCRIBE na classe human-powered-conveyance no REPL dá:
+
+(describe 'human-powered-conveyance)
+
+; COMMON-LISP-USER::HUMAN-POWERED-CONVEYANCE
+;  [symbol]
+;
+; HUMAN-POWERED-CONVEYANCE names the standard-class #<STANDARD-CLASS
+;                                                    HUMAN-POWERED-CONVEYANCE>:
+;  Documentation:
+;    A human powered conveyance
+;  Direct superclasses: STANDARD-OBJECT
+;  Direct subclasses: UNICYCLE, BICYCLE, CANOE
+;  Not yet finalized.
+;  Direct slots:
+;    VELOCITY
+;      Readers: VELOCITY
+;      Writers: (SETF VELOCITY)
+;    AVERAGE-EFFICIENCY
+;      Readers: AVERAGE-EFFICIENCY
+;      Writers: (SETF AVERAGE-EFFICIENCY)
+
+;; Note o comportamento reflexivo disponível para você! Common Lisp é
+;; projetada para ser um sistema interativo.
+
+;; Para definir um métpdo, vamos encontrar o que nossa cirunferência da
+;; roda da bicicleta usando a equação: C = d * pi
+
+(defmethod circumference ((object bicycle))
+  (* pi (wheel-size object)))
+
+;; pi já é definido para a gente em Lisp!
+
+;; Vamos supor que nós descobrimos que o valor da eficiência do número
+;; de remadores em uma canoa é aproximadamente logarítmica. Isso provavelmente
+;; deve ser definido no construtor / inicializador.
+
+;; Veja como initializar sua instância após Common Lisp ter construído isso:
+
+(defmethod initialize-instance :after ((object canoe) &rest args)
+  (setf (average-efficiency object)  (log (1+ (number-of-rowers object)))))
+
+;; Em seguida, para a construção de uma ocorrência e verificar a eficiência média ...
+
+(average-efficiency (make-instance 'canoe :number-of-rowers 15))
+; => 2.7725887
+
+
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 8. Macros
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Macros permitem que você estenda a sintaxe da lingaugem
+
+;; Common Lisp não vem com um loop WHILE - vamos adicionar um.
+;; Se obedecermos nossos instintos 'assembler', acabamos com:
+
+(defmacro while (condition &body body)
+    "Enquanto `condition` é verdadeiro, `body` é executado.
+
+`condition` é testado antes de cada execução do `body`"
+    (let ((block-name (gensym)))
+        `(tagbody
+           (unless ,condition
+               (go ,block-name))
+           (progn
+           ,@body)
+           ,block-name)))
+
+;; Vamos dar uma olhada em uma versão alto nível disto:
+
+
+(defmacro while (condition &body body)
+    "Enquanto `condition` for verdadeira, `body` é executado.
+
+`condition` é testado antes de cada execução do `body`"
+  `(loop while ,condition
+         do
+         (progn
+            ,@body)))
+
+;; Entretanto, com um compilador moderno, isso não é preciso; o LOOP
+;; 'form' compila igual e é bem mais fácil de ler.
+
+;; Noteq ue ``` é usado , bem como `,` e `@`. ``` é um operador 'quote-type'
+;; conhecido como 'quasiquote'; isso permite o uso de `,` . `,` permite "unquoting"
+;; e variáveis. @ interpolará listas.
+
+;; Gensym cria um símbolo único garantido que não existe em outras posições
+;; o sistema. Isto é porque macros são expandidas em tempo de compilação e
+;; variáveis declaradas na macro podem colidir com as variáveis usadas na
+;; código regular.
+
+;; Veja Practical Common Lisp para maiores informações sobre macros.
+```
+
+
+## Leitura Adicional
+
+[Continua em frente com  Practical Common Lisp book.](http://www.gigamonkeys.com/book/)
+
+
+## Créditos
+
+Muitos  agradecimentos ao pessoal de Schema por fornecer um grande ponto de partida
+o que facilitou muito a migração para Common Lisp.
+
+- [Paul Khuong](https://github.com/pkhuong) pelas grandes revisões.
diff --git a/pt-br/elisp-pt.html.markdown b/pt-br/elisp-pt.html.markdown
new file mode 100644
index 00000000..fc2d1e40
--- /dev/null
+++ b/pt-br/elisp-pt.html.markdown
@@ -0,0 +1,359 @@
+---
+language: elisp
+contributors:
+    - ["Bastien Guerry", "http://bzg.fr"]
+translators:
+    - ["Lucas Tadeu Teixeira", "http://ltt.me"]
+lang: pt-br
+filename: learn-emacs-lisp-pt.el
+---
+
+```scheme
+;; Introdução ao Emacs Lisp em 15 minutos (v0.2d)
+;;
+;; Autor: Bastien / @bzg2 / http://bzg.fr
+;;
+;; Antes de começar, leia este texto escrito Peter Norvig:
+;; http://norvig.com/21-days.html
+;;
+;; Agora instale GNU Emacs 24.3:
+;;
+;; Debian: apt-get install emacs (ou veja as instruções da sua distribuição)
+;; OSX: http://emacsformacosx.com/emacs-builds/Emacs-24.3-universal-10.6.8.dmg
+;; Windows: http://ftp.gnu.org/gnu/windows/emacs/emacs-24.3-bin-i386.zip
+;;
+;; Informações mais gerais podem ser encontradas em:
+;; http://www.gnu.org/software/emacs/#Obtaining
+
+;; Aviso importante:
+;;
+;; Realizar este tutorial não danificará seu computador, a menos
+;; que você fique tão irritado a ponto de jogá-lo no chão. Neste caso,
+;; me abstenho de qualquer responsabilidade. Divirta-se!
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; Abra o Emacs.
+;;
+;; Aperte a tecla `q' para ocultar a mensagem de boas vindas.
+;;
+;; Agora olhe para a linha cinza na parte inferior da janela:
+;;
+;; "*scratch*" é o nome do espaço de edição em que você se encontra.
+;; Este espaço de edição é chamado "buffer".
+;;
+;; O buffer de rascunho (i.e., "scratch") é o buffer padrão quando
+;; o Emacs é aberto. Você nunca está editando arquivos: você está
+;; editando buffers que você pode salvar em um arquivo.
+;;
+;; "Lisp interaction" refere-se a um conjunto de comandos disponíveis aqui.
+;;
+;; O Emacs possui um conjunto de comandos embutidos (disponíveis em
+;; qualquer buffer) e vários subconjuntos de comandos disponíveis
+;; quando você ativa um modo específico. Aqui nós utilizamos
+;; `lisp-interaction-mode', que possui comandos para interpretar e navegar
+;; em código Elisp.
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; Pontos e vírgulas iniciam comentários em qualquer parte de uma linha.
+;;
+;; Programas codificados em Elisp são compostos por expressões simbólicas
+;; (conhecidas também por "sexps"):
+(+ 2 2)
+
+;; Esta expressão simbólica significa "Some 2 e 2".
+
+;; "Sexps" são envoltas em parêntese, possivelmente aninhados:
+(+ 2 (+ 1 1))
+
+;; Uma expressão simbólica contém átomos ou outras expressões
+;; simbólicas. Nos exemplos acima, 1 e 2 são átomos;
+;; (+ 2 (+ 1 1)) e (+ 1 1) são expressões simbólicas.
+
+;; No modo `lisp-interaction-mode' você pode interpretar "sexps".
+;; Posicione o cursor logo após o parêntese de fechamento e,
+;; então, segure apertado Ctrl e aperte a tecla j ("C-j", em resumo).
+
+(+ 3 (+ 1 2))
+;;           ^ posicione o cursor aqui
+;; `C-j' => 6
+
+;; `C-j' insere o resultado da interpretação da expressão no buffer.
+
+;; `C-xC-e' exibe o mesmo resultado na linha inferior do Emacs,
+;; chamada de "mini-buffer".  Nós geralmente utilizaremos `C-xC-e',
+;; já que não queremos poluir o buffer com texto desnecessário.
+
+;; `setq' armazena um valor em uma variável:
+(setq my-name "Bastien")
+;; `C-xC-e' => "Bastien" (texto exibido no mini-buffer)
+
+;; `insert' insere "Hello!" na posição em que se encontra seu cursor:
+(insert "Hello!")
+;; `C-xC-e' => "Hello!"
+
+;; Nós executamos `insert' com apenas um argumento ("Hello!"), mas
+;; mais argumentos podem ser passados --  aqui utilizamos dois:
+
+(insert "Hello" " world!")
+;; `C-xC-e' => "Hello world!"
+
+;; Você pode utilizar variávies no lugar de strings:
+(insert "Hello, I am " my-name)
+;; `C-xC-e' => "Hello, I am Bastien"
+
+;; Você pode combinar "sexps" em funções:
+(defun hello () (insert "Hello, I am " my-name))
+;; `C-xC-e' => hello
+
+;; Você pode interpretar chamadas de funções:
+(hello)
+;; `C-xC-e' => Hello, I am Bastien
+
+;; Os parêntesis vazios na definição da função significam que ela
+;; não aceita argumentos. Mas sempre utilizar `my-name' é um tédio!
+;; Vamos dizer à função para aceitar um argumento (o argumento é
+;; chamado "name"):
+
+(defun hello (name) (insert "Hello " name))
+;; `C-xC-e' => hello
+
+;; Agora vamos executar a função com a string "you" como o valor
+;; para seu único parâmetro:
+(hello "you")
+;; `C-xC-e' => "Hello you"
+
+;; Aí sim!
+
+;; Respire um pouco.
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; Agora mude para um novo buffer chamado "*test*":
+
+(switch-to-buffer-other-window "*test*")
+;; `C-xC-e'
+;; => [a tela exibirá duas janelas e o cursor estará no buffer *test*]
+
+;; Posicione o mouse sobre a janela superior e clique com o botão
+;; esquerdo para voltar. Ou você pode utilizar `C-xo' (i.e. segure
+;; ctrl-x e aperte o) para voltar para a outra janela, de forma interativa.
+
+;; Você pode combinar várias "sexps" com `progn':
+(progn
+  (switch-to-buffer-other-window "*test*")
+  (hello "you"))
+;; `C-xC-e'
+;; => [A tela exibirá duas janelas e o cursor estará no buffer *test*]
+
+;; Agora, se você não se importar, pararei de pedir que você aperte
+;; `C-xC-e': faça isso para cada "sexp" que escrevermos.
+
+;; Sempre volte para o buffer *scratch* com o mouse ou `C-xo'.
+
+;; Frequentemente, é útil apagar o conteúdo do buffer:
+(progn
+  (switch-to-buffer-other-window "*test*")
+  (erase-buffer)
+  (hello "there"))
+
+;; Ou voltar para a outra janela:
+(progn
+  (switch-to-buffer-other-window "*test*")
+  (erase-buffer)
+  (hello "you")
+  (other-window 1))
+
+;; Você pode armazenar um valor em uma variável local utilizando `let':
+(let ((local-name "you"))
+  (switch-to-buffer-other-window "*test*")
+  (erase-buffer)
+  (hello local-name)
+  (other-window 1))
+
+;; Neste caso, não é necessário utilizar `progn' já que `let' combina
+;; várias "sexps".
+
+;; Vamos formatar uma string:
+(format "Hello %s!\n" "visitor")
+
+;; %s é um espaço reservado para uma string, substituído por "visitor".
+;; \n é um caractere de nova linha.
+
+;; Vamos refinar nossa função utilizando `format':
+(defun hello (name)
+  (insert (format "Hello %s!\n" name)))
+
+(hello "you")
+
+;; Vamos criar outra função que utilize `let':
+(defun greeting (name)
+  (let ((your-name "Bastien"))
+    (insert (format "Hello %s!\n\nI am %s."
+                    name       ; the argument of the function
+                    your-name  ; the let-bound variable "Bastien"
+                    ))))
+
+;; E executá-la:
+(greeting "you")
+
+;; Algumas funções são interativas:
+(read-from-minibuffer "Enter your name: ")
+
+;; Ao ser interpretada, esta função retorna o que você digitou no prompt.
+
+;; Vamos fazer nossa função `greeting' pedir pelo seu nome:
+(defun greeting (from-name)
+  (let ((your-name (read-from-minibuffer "Enter your name: ")))
+    (insert (format "Hello!\n\nI am %s and you are %s."
+                    from-name ; the argument of the function
+                    your-name ; the let-bound var, entered at prompt
+                    ))))
+
+(greeting "Bastien")
+
+;; Vamos finalizá-la fazendo-a exibir os resultados em outra janela:
+(defun greeting (from-name)
+  (let ((your-name (read-from-minibuffer "Enter your name: ")))
+    (switch-to-buffer-other-window "*test*")
+    (erase-buffer)
+    (insert (format "Hello %s!\n\nI am %s." your-name from-name))
+    (other-window 1)))
+
+;; Agora teste-a:
+(greeting "Bastien")
+
+;; Respire um pouco.
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; Vamos armazenar uma lista de nomes:
+(setq list-of-names '("Sarah" "Chloe" "Mathilde"))
+
+;; Pegue o primeiro elemento desta lista utilizando `car':
+(car list-of-names)
+
+;; Pegue uma lista de todos os elementos, exceto o primeiro, utilizando
+;; `cdr':
+(cdr list-of-names)
+
+;; Adicione um elemento ao início da lista com `push':
+(push "Stephanie" list-of-names)
+
+;; NOTA: `car' e `cdr' não modificam a lista, `push' sim.
+;; Esta é uma diferença importante: algumas funções não têm qualquer
+;; efeito colateral (como `car'), enquanto outras sim (como `push').
+
+;; Vamos executar `hello' para cada elemento em `list-of-names':
+(mapcar 'hello list-of-names)
+
+;; Refine `greeting' para saudar todos os nomes em `list-of-names':
+(defun greeting ()
+    (switch-to-buffer-other-window "*test*")
+    (erase-buffer)
+    (mapcar 'hello list-of-names)
+    (other-window 1))
+
+(greeting)
+
+;; Você se lembra da função `hello' que nós definimos lá em cima? Ela
+;; recebe um argumento, um nome. `mapcar' executa `hello', sucessivamente,
+;; utilizando cada elemento de `list-of-names' como argumento para `hello'.
+
+;; Agora vamos arrumar, um pouco, o que nós temos escrito no buffer:
+
+(defun replace-hello-by-bonjour ()
+    (switch-to-buffer-other-window "*test*")
+    (goto-char (point-min))
+    (while (search-forward "Hello")
+      (replace-match "Bonjour"))
+    (other-window 1))
+
+;; (goto-char (point-min)) vai para o início do buffer.
+;; (search-forward "Hello") busca pela string "Hello".
+;; (while x y) interpreta a(s) sexp(s) y enquanto x retornar algo.
+;; Se x retornar `nil' (nada), nós saímos do laço.
+
+(replace-hello-by-bonjour)
+
+;; Você deveria ver todas as ocorrências de "Hello" no buffer *test*
+;; substituídas por "Bonjour".
+
+;; Você deveria, também, receber um erro: "Search failed: Hello".
+;;
+;; Para evitar este erro, você precisa dizer ao `search-forward' se ele
+;; deveria parar de buscar em algum ponto no buffer, e se ele deveria
+;; falhar de forma silenciosa quando nada fosse encontrado:
+
+;; (search-forward "Hello" nil t) dá conta do recado:
+
+;; O argumento `nil' diz: a busca não está limitada a uma posição.
+;; O argumento `t' diz: falhe silenciosamente quando nada for encontrado.
+
+;; Nós utilizamos esta "sexp" na função abaixo, que não gera um erro:
+
+(defun hello-to-bonjour ()
+    (switch-to-buffer-other-window "*test*")
+    (erase-buffer)
+    ;; Say hello to names in `list-of-names'
+    (mapcar 'hello list-of-names)
+    (goto-char (point-min))
+    ;; Replace "Hello" by "Bonjour"
+    (while (search-forward "Hello" nil t)
+      (replace-match "Bonjour"))
+    (other-window 1))
+
+(hello-to-bonjour)
+
+;; Vamos colorir os nomes:
+
+(defun boldify-names ()
+    (switch-to-buffer-other-window "*test*")
+    (goto-char (point-min))
+    (while (re-search-forward "Bonjour \\(.+\\)!" nil t)
+      (add-text-properties (match-beginning 1)
+                           (match-end 1)
+                           (list 'face 'bold)))
+    (other-window 1))
+
+;; Esta função introduz `re-search-forward': ao invés de buscar
+;; pela string "Bonjour", você busca por um padrão utilizando uma
+;; "expressão regular" (abreviada pelo prefixo "re-").
+
+;; A expressão regular é "Bonjour \\(.+\\)!" e lê-se:
+;; a string "Bonjour ", e
+;; um grupo de               | que é o \\( ... \\)
+;;   quaisquer caracteres    | que é o .
+;;   possivelmente repetidos | que é o +
+;; e a string "!".
+
+;; Preparado? Teste!
+
+(boldify-names)
+
+;; `add-text-properties' adiciona... propriedades de texto, como uma fonte.
+
+;; OK, terminamos por aqui. Feliz Hacking!
+
+;; Se você quiser saber mais sobre uma variável ou função:
+;;
+;; C-h v uma-variável RET
+;; C-h f uma-função RET
+;;
+;; Para ler o manual de Emacs Lisp que vem com o Emacs:
+;;
+;; C-h i m elisp RET
+;;
+;; Para ler uma introdução online ao Emacs Lisp:
+;; https://www.gnu.org/software/emacs/manual/html_node/eintr/index.html
+
+;; Agradecimentos a estas pessoas por seu feedback e sugestões:
+;; - Wes Hardaker
+;; - notbob
+;; - Kevin Montuori
+;; - Arne Babenhauserheide
+;; - Alan Schmitt
+;; - LinXitoW
+;; - Aaron Meurer
+```
diff --git a/pt-br/erlang-pt.html.markdown b/pt-br/erlang-pt.html.markdown
new file mode 100644
index 00000000..a81e5a1f
--- /dev/null
+++ b/pt-br/erlang-pt.html.markdown
@@ -0,0 +1,254 @@
+---
+language: erlang
+filename: learnerlang-pt.erl
+contributors:
+    - ["Giovanni Cappellotto", "http://www.focustheweb.com/"]
+translators:
+    - ["Guilherme Heuser Prestes", "http://twitter.com/gprestes"]
+lang: pt-br
+---
+
+```erlang
+% Símbolo de porcento começa comentários de uma linha.
+
+%% Dois caracteres de porcento devem ser usados para comentar funções.
+
+%%% Três caracteres de porcento devem ser usados para comentar módulos.
+
+% Nós usamos três tipos de pontuação em Erlang.
+% Vírgulas (`,`) separam argumentos em chamadas de função, construtores de
+% dados, e padrões.
+% Pontos finais (`.`) separam totalmente funções e expressões no prompt.
+% Ponto e vírgulas (`;`) separam cláusulas. Nós encontramos cláusulas em
+% vários contextos: definições de função e em expressões com `case`, `if`,
+% `try..catch` e `receive`.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% 1. Variáveis e casamento de padrões.
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+Num = 42.  % Todos nomes de variáveis devem começar com uma letra maiúscula.
+
+% Erlang tem atribuição única de variáveis, se você tentar atribuir um valor
+% diferente à variável `Num`, você receberá um erro.
+Num = 43. % ** exception error: no match of right hand side value 43
+
+% Na maioria das linguagens, `=` denota um comando de atribuição. Em Erlang, no
+% entanto, `=` denota uma operação de casamento de padrão. `Lhs = Rhs` realmente
+% significa isso: avalia o lado direito (Rhs), e então casa o resultado com o
+% padrão no lado esquerdo (Lhs).
+Num = 7 * 6.
+
+% Número de ponto flutuante.
+Pi = 3.14159.
+
+% Átomos são usados para representar diferentes valores constantes não
+% numéricos. Átomos começam com letras minúsculas seguidas por uma sequência de
+% caracteres alfanuméricos ou sinais de subtraço (`_`) ou arroba (`@`).
+Hello = hello.
+OtherNode = example@node.
+
+% Átomos com valores alfanuméricos podem ser escritos colocando aspas por fora
+% dos átomos.
+AtomWithSpace = 'some atom with space'.
+
+% Tuplas são similares a structs em C.
+Point = {point, 10, 45}.
+
+% Se nós queremos extrair alguns valores de uma tupla, nós usamos o operador `=`.
+{point, X, Y} = Point.  % X = 10, Y = 45
+
+% Nós podemos usar `_` para ocupar o lugar de uma variável que não estamos interessados.
+% O símbolo `_` é chamado de variável anônima. Ao contrário de variáveis regulares,
+% diversas ocorrências de _ no mesmo padrão não precisam se amarrar ao mesmo valor.
+Person = {person, {name, {first, joe}, {last, armstrong}}, {footsize, 42}}.
+{_, {_, {_, Who}, _}, _} = Person.  % Who = joe
+
+% Nós criamos uma lista colocando valores separados por vírgula entre colchetes.
+% Cada elemento de uma lista pode ser de qualquer tipo.
+% O primeiro elemento de uma lista é a cabeça da lista. Se removermos a cabeça
+% da lista, o que sobra é chamado de cauda da lista.
+ThingsToBuy = [{apples, 10}, {pears, 6}, {milk, 3}].
+
+% Se `T` é uma lista, então `[H|T]` também é uma lista, com cabeça `H` e cauda `T`.
+% A barra vertical (`|`) separa a cabeça de uma lista de sua cauda.
+% `[]` é uma lista vazia.
+% Podemos extrair elementos de uma lista com uma operação de casamento de
+% padrão. Se temos uma lista não-vazia `L`, então a expressão `[X|Y] = L`, onde
+% `X` e `Y` são variáveis desamarradas, irá extrair a cabeça de uma lista para
+% `X` e a cauda da lista para `Y`.
+[FirstThing|OtherThingsToBuy] = ThingsToBuy.
+% FirstThing = {apples, 10}
+% OtherThingsToBuy = {pears, 6}, {milk, 3}
+
+% Não existe o tipo string em Erlang. Strings são somente listas de inteiros.
+% Strings são representadas dentro de aspas duplas (`"`).
+Name = "Hello".
+[72, 101, 108, 108, 111] = "Hello".
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% 2. Programação sequencial.
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+% Módulos são a unidade básica de código em Erlang. Todas funções que
+% escrevemos são armazenadas em módulos. Módulos são armazenados em arquivos
+% com extensão `.erl`.
+% Módulos devem ser compilados antes que o código possa ser rodado. Um módulo
+% compilado tem a extensão `.beam`.
+-module(geometry).
+-export([area/1]). % lista de funções exportadas de um módulo.
+
+% A função `area` consiste de duas cláusulas. As cláusulas são separadas por um
+% ponto e vírgula, e a cláusula final é terminada por um ponto final.
+% Cada cláusula tem uma cabeça em um corpo; a cabeça consiste de um nome de
+% função seguido por um padrão (entre parêntesis), e o corpo consiste de uma
+% sequência de expressões, que são avaliadas se o padrão na cabeça é um par bem
+% sucedido dos argumentos da chamada. Os padrões são casados na ordem que
+% aparecem na definição da função.
+area({rectangle, Width, Ht}) -> Width * Ht;
+area({circle, R})            -> 3.14159 * R * R.
+
+% Compila o código no arquivo geometry.erl.
+c(geometry).  % {ok,geometry}
+
+% Nós precisamos incluir o nome do módulo junto com o nome da função de maneira
+% a identificar exatamente qual função queremos chamar.
+geometry:area({rectangle, 10, 5}).  % 50
+geometry:area({circle, 1.4}).  % 6.15752
+
+% Em Erlang, duas funções com o mesmo nome e diferentes aridades (números de
+% argumentos) no mesmo módulo representam funções totalmente diferentes.
+-module(lib_misc).
+-export([sum/1]). % exporta a função `sum` de aridade 1 aceitando um argumento: lista de inteiros.
+sum(L) -> sum(L, 0).
+sum([], N)    -> N;
+sum([H|T], N) -> sum(T, H+N).
+
+% Funs são funções "anônimas". Elas são chamadas desta maneira por que elas não
+% têm nome. No entanto podem ser atribuídas a variáveis.
+Double = fun(X) -> 2*X end. % `Double` aponta para uma função anônima com referência: #Fun<erl_eval.6.17052888>
+Double(2).  % 4
+
+% Funções aceitam funs como seus argumentos e podem retornar funs.
+Mult = fun(Times) -> ( fun(X) -> X * Times end ) end.
+Triple = Mult(3).
+Triple(5).  % 15
+
+% Compreensão de lista são expressões que criam listas sem precisar usar funs,
+% maps, ou filtros.
+% A notação `[F(X) || X <- L]` significa "a lista de `F(X)` onde `X` é tomada
+% da lista `L`."
+L = [1,2,3,4,5].
+[2*X || X <- L].  % [2,4,6,8,10]
+% Uma compreensão de lista pode ter geradores e filtros que selecionam
+% subconjuntos dos valores gerados.
+EvenNumbers = [N || N <- [1, 2, 3, 4], N rem 2 == 0]. % [2, 4]
+
+% Sentinelas são contruções que podemos usar para incrementar o poder de
+% casamento de padrão. Usando sentinelas, podemos executar testes simples e
+% comparações nas variáveis em um padrão.
+% Você pode usar sentinelas nas cabeças das definições de função onde eles são
+% introduzidos pela palavra-chave `when`, ou você pode usá-los em qualquer
+% lugar na linguagem onde uma expressão é permitida.
+max(X, Y) when X > Y -> X;
+max(X, Y) -> Y.
+
+% Um sentinela é uma série de expressões sentinelas, separadas por
+% vírgulas (`,`).
+% O sentinela `GuardExpr1, GuardExpr2, ..., GuardExprN` é verdadeiro se todas
+% expressões sentinelas `GuardExpr1, GuardExpr2, ...` forem verdadeiras.
+is_cat(A) when is_atom(A), A =:= cat -> true;
+is_cat(A) -> false.
+is_dog(A) when is_atom(A), A =:= dog -> true;
+is_dog(A) -> false.
+
+% Uma `sequência sentinela` é um sentinela ou uma série de sentinelas separados
+% por ponto e vírgula (`;`). A sequência sentinela `G1; G2; ...; Gn` é
+% verdadeira se pelo menos um dos sentinelas `G1, G2, ...` for verdadeiro.
+is_pet(A) when is_dog(A); is_cat(A) -> true;
+is_pet(A) -> false.
+
+% Registros provêem um método para associar um nome com um elemento particular
+% em uma tupla.
+% Definições de registro podem ser incluídas em arquivos fonte Erlang ou em
+% arquivos com extensão `.hrl`, que então são incluídos em arquivos fonte Erlang.
+-record(todo, {
+  status = reminder,  % Default value
+  who = joe,
+  text
+}).
+
+% Nós temos que ler definições de registro no prompt antes que possamos definir
+% um registro. Nós usamos a função de prompt `rr` (abreviação de read records)
+% para fazer isso.
+rr("records.hrl").  % [todo]
+
+% Criando e atualizando registros:
+X = #todo{}.
+% #todo{status = reminder, who = joe, text = undefined}
+X1 = #todo{status = urgent, text = "Fix errata in book"}.
+% #todo{status = urgent, who = joe, text = "Fix errata in book"}
+X2 = X1#todo{status = done}.
+% #todo{status = done,who = joe,text = "Fix errata in book"}
+
+% Expressões `case`.
+% A função `filter` retorna uma lista de todos elementos `X` em uma lista `L`
+% para qual `P(X)` é verdadeiro.
+filter(P, [H|T]) ->
+  case P(H) of
+    true -> [H|filter(P, T)];
+    false -> filter(P, T)
+  end;
+filter(P, []) -> [].
+filter(fun(X) -> X rem 2 == 0 end, [1, 2, 3, 4]). % [2, 4]
+
+% Expressões `if`.
+max(X, Y) ->
+  if
+    X > Y -> X;
+    X < Y -> Y;
+    true -> nil;
+  end.
+
+% Aviso: pelo menos um dos sentinelas na expressão `if` deve retornar
+% verdadeiro; Caso contrário, uma exceção será levantada.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% 3. Exceções.
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+% Exceções são levantadas pelo sistema quando erros internos são encontrados ou
+% explicitamente em código pela chamada `throw(Exception)`, `exit(Exception)`
+% ou `erlang:error(Exception)`.
+generate_exception(1) -> a;
+generate_exception(2) -> throw(a);
+generate_exception(3) -> exit(a);
+generate_exception(4) -> {'EXIT', a};
+generate_exception(5) -> erlang:error(a).
+
+% Erlang tem dois métodos para capturar uma exceção. Uma é encapsular a chamada
+% para a função que levanta uma exceção dentro de uma expressão `try...catch`.
+catcher(N) ->
+  try generate_exception(N) of
+    Val -> {N, normal, Val}
+  catch
+    throw:X -> {N, caught, thrown, X};
+    exit:X -> {N, caught, exited, X};
+    error:X -> {N, caught, error, X}
+  end.
+
+% O outro é encapsular a chamada em uma expressão `catch`. Quando você captura
+% uma exceção, é convertida em uma tupla que descreve o erro.
+catcher(N) -> catch generate_exception(N).
+
+```
+
+## Referências
+
+* ["Learn You Some Erlang for great good!"](http://learnyousomeerlang.com/)
+* ["Programming Erlang: Software for a Concurrent World" by Joe Armstrong](http://pragprog.com/book/jaerlang2/programming-erlang)
+* [Erlang/OTP Reference Documentation](http://www.erlang.org/doc/)
+* [Erlang - Programming Rules and Conventions](http://www.erlang.se/doc/programming_rules.shtml)
+
diff --git a/pt-br/git-pt.html.markdown b/pt-br/git-pt.html.markdown
new file mode 100644
index 00000000..981da503
--- /dev/null
+++ b/pt-br/git-pt.html.markdown
@@ -0,0 +1,412 @@
+---
+category: tool
+tool: git
+lang: pt-br
+filename: LearnGit.txt
+contributors:
+    - ["Jake Prather", "http://github.com/JakeHP"]
+translators:
+  - ["Suzane Sant Ana", "http://github.com/suuuzi"]
+---
+
+Git é um sistema distribuido de gestão para código fonte e controle de versões.
+
+Funciona através de uma série de registos de estado do projeto e usa esse
+registo para permitir funcionalidades de versionamento e gestão de código
+fonte.
+
+## Conceitos de versionamento
+
+### O que é controle de versão
+
+Controle de versão (*source control*) é um processo de registo de alterações
+a um arquivo ou conjunto de arquivos ao longo do tempo.
+
+### Controle de versão:  Centralizado VS Distribuído
+
+* Controle de versão centralizado foca na sincronização, registo e *backup*
+de arquivos.
+* Controle de versão distribuído foca em compartilhar alterações. Cada
+alteração é associada a um *id* único.
+* Sistemas distribuídos não tem estrutura definida. É possivel ter um sistema
+centralizado ao estilo SVN usando git.
+
+[Informação adicional (EN)](http://git-scm.com/book/en/Getting-Started-About-Version-Control)
+
+### Por que usar git?
+
+* Permite trabalhar offline.
+* Colaborar com outros é fácil!
+* Criar *branches* é fácil!
+* Fazer *merge* é fácil!
+* Git é rápido.
+* Git é flexivel.
+
+## Git - Arquitetura
+
+
+### Repositório
+
+Um conjunto de arquivos, diretórios, registos históricos, *commits* e
+referências. Pode ser descrito como uma estrutura de dados de código fonte
+com a particularidade de cada elemento do código fonte permitir acesso ao
+histórico das suas alterações, entre outras coisas.
+
+Um repositório git é constituido pelo diretório .git e a *working tree*
+
+### Diretório .git (componente do repositório)
+
+O repositório .git contém todas as configurações, *logs*, *branches*,
+referências e outros.
+
+[Lista detalhada (EN)](http://gitready.com/advanced/2009/03/23/whats-inside-your-git-directory.html)
+
+### *Working Tree* (componente do repositório)
+
+A *Working Tree* é basicamente a listagem dos diretórios e arquivos do repositório. É chamada também de diretório do projeto.
+
+### *Index* (componente do diretório .git)
+
+O *Index* é a camada da interface no git. É o elemento que separa
+o diretório do projeto do repositório git. Isto permite aos programadores um
+maior controle sobre o que é registado no repositório git.
+
+### *Commit*
+
+Um *commit** de git é um registo de um cojunto de alterações ou manipulações nos arquivos do projeto.
+Por exemplo, ao adicionar cinco arquivos e remover outros 2, estas alterações
+serão gravadas num *commit* (ou registo). Este *commit* pode então ser enviado
+para outros repositórios ou não!
+
+### *Branch*
+
+Um *branch* é essencialmente uma referência que aponta para o último *commit*
+efetuado. Na medida que são feitos novos commits, esta referência é atualizada
+automaticamente e passa a apontar para o commit mais recente.
+
+### *HEAD* e *head* (componentes do diretório .git)
+
+*HEAD* é a referência que aponta para o *branch* em uso. Um repositório só tem
+uma *HEAD* activa.
+*head* é uma referência que aponta para qualquer *commit*. Um repositório pode
+ter um número indefinido de *heads*
+
+### Recursos conceituais (EN)
+
+* [Git para Cientistas de Computação](http://eagain.net/articles/git-for-computer-scientists/)
+* [Git para Designers](http://hoth.entp.com/output/git_for_designers.html)
+
+## Comandos
+
+### *init*
+
+Cria um repositório Git vazio. As definições, informação guardada e outros do
+repositório git são guardados em uma pasta chamada ".git".
+
+```bash
+$ git init
+```
+
+### *config*
+
+Permite configurar as definições, sejam as definições do repositório, sistema
+ou configurações globais.
+
+```bash
+# Imprime e define algumas variáveis de configuração básicas (global)
+$ git config --global user.email
+$ git config --global user.name
+
+$ git config --global user.email "MyEmail@Zoho.com"
+$ git config --global user.name "My Name"
+```
+
+[Aprenda mais sobre git config. (EN)](http://git-scm.com/docs/git-config)
+
+### help
+
+Para visualizar rapidamente o detalhamento de cada comando ou apenas lembrar da semântica.
+
+```bash
+# Ver rapidamente os comandos disponiveis
+$ git help
+
+# Ver todos os comandos disponiveis
+$ git help -a
+
+# Usar o *help* para um comando especifico
+# git help <comando_aqui>
+$ git help add
+$ git help commit
+$ git help init
+```
+
+### status
+
+Apresenta as diferenças entre o arquivo *index* (a versão corrente
+do repositório) e o *commit* da *HEAD* atual.
+
+
+```bash
+# Apresenta o *branch*, arquivos não monitorados, alterações e outras
+# difereças
+$ git status
+
+# Para aprender mais detalhes sobre git *status*
+$ git help status
+```
+
+### add
+
+Adiciona arquivos ao repositório corrente. Se os arquivos novos não forem
+adicionados através de `git add` ao repositório, então eles não serão
+incluidos nos commits!
+
+```bash
+# adiciona um arquivo no diretório do projeto atual
+$ git add HelloWorld.java
+
+# adiciona um arquivo num sub-diretório
+$ git add /path/to/file/HelloWorld.c
+
+# permite usar expressões regulares!
+$ git add ./*.java
+```
+
+### branch
+
+Gerencia os *branches*. É possível ver, editar, criar e apagar branches com este
+comando.
+
+```bash
+# listar *branches* existentes e remotos
+$ git branch -a
+
+# criar um novo *branch*
+$ git branch myNewBranch
+
+# apagar um *branch*
+$ git branch -d myBranch
+
+# alterar o nome de um *branch*
+# git branch -m <oldname> <newname>
+$ git branch -m myBranchName myNewBranchName
+
+# editar a descrição de um *branch*
+$ git branch myBranchName --edit-description
+```
+
+### checkout
+
+Atualiza todos os arquivos no diretório do projeto para que fiquem iguais
+à versão do index ou do *branch* especificado.
+
+```bash
+# Checkout de um repositório - por padrão para o branch master
+$ git checkout
+# Checkout de um branch especifico
+$ git checkout branchName
+# Cria um novo branch e faz checkout para ele.
+# Equivalente a: "git branch <name>; git checkout <name>"
+$ git checkout -b newBranch
+```
+
+### clone
+
+Clona ou copia um repositório existente para um novo diretório. Também
+adiciona *branches* de monitoramento remoto para cada *branch* no repositório
+clonado o que permite enviar alterações para um *branch* remoto.
+
+```bash
+# Clona learnxinyminutes-docs
+$ git clone https://github.com/adambard/learnxinyminutes-docs.git
+```
+
+### commit
+
+Guarda o conteudo atual do index num novo *commit*. Este *commit* contém
+as alterações feitas e a mensagem criada pelo usuário.
+
+```bash
+# commit com uma mensagem
+$ git commit -m "Added multiplyNumbers() function to HelloWorld.c"
+```
+
+### diff
+
+Apresenta as diferenças entre um arquivo no repositório do projeto, *index*
+e *commits*
+
+```bash
+# Apresenta a diferença entre o diretório atual e o index
+$ git diff
+
+# Apresenta a diferença entre o index e os commits mais recentes
+$ git diff --cached
+
+# Apresenta a diferença entre o diretório atual e o commit mais recente
+$ git diff HEAD
+```
+
+### grep
+
+Permite procurar facilmente num repositório
+
+Configurações opcionais:
+
+```bash
+# Define a apresentação de números de linha nos resultados do grep
+$ git config --global grep.lineNumber true
+
+# Agrupa os resultados da pesquisa para facilitar a leitura
+$ git config --global alias.g "grep --break --heading --line-number"
+```
+
+```bash
+# Pesquisa por "variableName" em todos os arquivos java
+$ git grep 'variableName' -- '*.java'
+
+# Pesquisa por uma linha que contém "arrayListName" e "add" ou "remove"
+$ git grep -e 'arrayListName' --and \( -e add -e remove \)
+```
+
+O Google é seu amigo; para mais exemplos:
+[Git Grep Ninja (EN)](http://travisjeffery.com/b/2012/02/search-a-git-repo-like-a-ninja)
+
+### log
+
+Apresenta commits do repositório.
+
+```bash
+# Apresenta todos os commits
+$ git log
+
+# Apresenta X commits
+$ git log -n 10
+
+# Apresenta apenas commits de merge
+$ git log --merges
+```
+
+### merge
+
+"Merge" junta as alterações de commits externos com o *branch* atual.
+
+```bash
+# Junta o branch especificado com o atual
+$ git merge branchName
+
+# Para gerar sempre um commit ao juntar os branches
+$ git merge --no-ff branchName
+```
+
+### mv
+
+Alterar o nome ou mover um arquivo.
+
+```bash
+# Alterar o nome de um arquivo
+$ git mv HelloWorld.c HelloNewWorld.c
+
+# Mover um arquivo
+$ git mv HelloWorld.c ./new/path/HelloWorld.c
+
+# Forçar a alteração de nome ou mudança local
+# "existingFile" já existe no directório, será sobrescrito.
+$ git mv -f myFile existingFile
+```
+
+### pull
+
+Puxa alterações de um repositório e as junta com outro branch
+
+```bash
+# Atualiza o repositório local, juntando as novas alterações
+# do repositório remoto 'origin' e branch 'master'
+# git pull <remote> <branch>
+# git pull => aplica a predefinição => git pull origin master
+$ git pull origin master
+
+# Juntar alterações do branch remote e fazer rebase commits do branch
+# no repositório local, como: "git pull <remote> <branch>, git rebase <branch>"
+$ git pull origin master --rebase
+```
+
+### push
+
+Enviar e juntar alterações de um branch para o seu branch correspondente
+num repositório remoto.
+
+```bash
+# Envia e junta as alterações de um repositório local
+# para um remoto denominado "origin" no branch "master".
+# git push <remote> <branch>
+# git push => aplica a predefinição => git push origin master
+$ git push origin master
+```
+
+### rebase (cautela!)
+
+Pega em todas as alterações que foram registadas num branch e volta a
+aplicá-las em outro branch.
+*Não deve ser feito rebase de commits que foram enviados para um repositório
+público*
+
+```bash
+# Faz Rebase de experimentBranch para master
+# git rebase <basebranch> <topicbranch>
+$ git rebase master experimentBranch
+```
+
+[Leitura adicional (EN).](http://git-scm.com/book/en/Git-Branching-Rebasing)
+
+### reset (cuidado!)
+
+Restabelece a HEAD atual ao estado definido. Isto permite reverter *merges*,
+*pulls*, *commits*, *adds* e outros. É um comando muito poderoso mas também
+perigoso quando não há certeza do que se está fazendo.
+
+```bash
+# Restabelece a camada intermediária de registo para o último
+# commit (o directório fica sem alterações)
+$ git reset
+
+# Restabelece a camada intermediária de registo para o último commit, e
+# sobrescreve o projeto atual
+$ git reset --hard
+
+# Move a head do branch atual para o commit especificado, sem alterar o projeto.
+# todas as alterações ainda existem no projeto
+$ git reset 31f2bb1
+
+# Inverte a head do branch atual para o commit especificado
+# fazendo com que este esteja em sintonia com o diretório do projeto
+# Remove alterações não registadas e todos os commits após o commit especificado
+$ git reset --hard 31f2bb1
+```
+
+### rm
+
+O oposto de git add, git rm remove arquivos do branch atual.
+
+```bash
+# remove HelloWorld.c
+$ git rm HelloWorld.c
+
+# Remove um arquivo de um sub-directório
+$ git rm /pather/to/the/file/HelloWorld.c
+```
+
+## Informação complementar (EN)
+
+* [tryGit - A fun interactive way to learn Git.](http://try.github.io/levels/1/challenges/1)
+
+* [git-scm - Video Tutorials](http://git-scm.com/videos)
+
+* [git-scm - Documentation](http://git-scm.com/docs)
+
+* [Atlassian Git - Tutorials & Workflows](https://www.atlassian.com/git/)
+
+* [SalesForce Cheat Sheet](https://na1.salesforce.com/help/doc/en/salesforce_git_developer_cheatsheet.pdf)
+
+* [GitGuys](http://www.gitguys.com/)
diff --git a/pt-br/go-pt.html.markdown b/pt-br/go-pt.html.markdown
new file mode 100644
index 00000000..c7339831
--- /dev/null
+++ b/pt-br/go-pt.html.markdown
@@ -0,0 +1,312 @@
+---
+name: Go
+category: language
+language: Go
+filename: learngo-pt.go
+lang: pt-br
+contributors:
+    - ["Sonia Keys", "https://github.com/soniakeys"]
+    - ["Jose Donizetti", "https://github.com/josedonizetti"]
+translators:
+    - ["Nuno Antunes", "https://github.com/ntns"]
+---
+
+A linguagem Go foi criada a partir da necessidade de ver trabalho feito. Não 
+é a última moda em ciências da computação, mas é a mais recente e mais rápida
+forma de resolver os problemas do mundo real.
+
+Tem conceitos familiares de linguagens imperativas com tipagem estática. É 
+rápida a compilar e rápida a executar, acrescentando mecanismos de concorrência
+fáceis de entender para tirar partido dos CPUs multi-core de hoje em dia, e tem
+recursos para ajudar com a programação em larga escala.
+
+Go vem com uma biblioteca padrão exaustiva e uma comunidade entusiasta.
+
+```go
+// Comentário de uma linha
+/* Comentário de
+   várias linhas */
+
+// A cláusula package aparece no início de cada arquivo.
+// Main é um nome especial declarando um executável ao invés de uma biblioteca.
+package main
+
+// A cláusula Import declara os pacotes referenciados neste arquivo.
+import (
+    "fmt"      // Um pacote da biblioteca padrão da linguagem Go
+    "net/http" // Sim, um servidor web!
+    "strconv"  // Conversão de Strings
+)
+
+// Definição de uma função. Main é especial. É o ponto de entrada para o
+// programa executável. Goste-se ou não, a linguagem Go usa chavetas.
+func main() {
+    // A função Println envia uma linha para stdout.
+    // É necessário qualifica-la com o nome do pacote, fmt.
+    fmt.Println("Olá Mundo!")
+
+    // Chama outra função dentro deste pacote.
+    beyondHello()
+}
+
+// As funções declaram os seus parâmetros dentro de parênteses. Se a função
+// não receber quaisquer parâmetros, é obrigatório usar parênteses vazios.
+func beyondHello() {
+    var x int // Declaração de variável. Tem de ser declarada antes de usar.
+    x = 3     // Atribuição de variável.
+    // Declarações "curtas" usam := para inferir o tipo, declarar e atribuir.
+    y := 4
+    sum, prod := learnMultiple(x, y)        // a função retorna dois valores
+    fmt.Println("soma:", sum, "produto:", prod) 
+    learnTypes()                            // continuar a aprender!
+}
+
+// As funções podem receber parâmetros e retornar (vários!) valores.
+func learnMultiple(x, y int) (sum, prod int) {
+    return x + y, x * y // retorna dois valores
+}
+
+// Alguns tipos e literais básicos.
+func learnTypes() {
+    // Declarações "curtas" geralmente servem para o que pretendemos.
+    s := "Aprender Go!" // tipo string 
+
+    s2 := `Uma string em "bruto" 
+pode incluir quebras de linha.` // mesmo tipo string
+
+    // literal não-ASCII. A linguagem Go utiliza de raiz a codificação UTF-8.
+    g := 'Σ' // tipo rune, um alias para int32, que contém um código unicode
+
+    f := 3.14195 // float64, número de vírgula flutuante de 64bit (IEEE-754)
+    c := 3 + 4i  // complex128, representado internamente com dois float64s
+
+    // Declaração de variáveis, com inicialização.
+    var u uint = 7 // inteiro sem sinal, tamanho depende da implementação do Go
+    var pi float32 = 22. / 7
+
+    // Sintaxe de conversão de tipo, com declaração "curta".
+    n := byte('\n') // byte é um alias para uint8
+
+    // Os arrays têm tamanho fixo e definido antes da compilação. 
+    var a4 [4]int           // um array de 4 ints, inicializado com ZEROS
+    a3 := [...]int{3, 1, 5} // um array de 3 ints, inicializado como mostrado
+
+    // As slices têm tamanho dinâmico. Os arrays e as slices têm cada um as
+    // suas vantagens mas o uso de slices é muito mais comum.
+    s3 := []int{4, 5, 9}   // compare com a3. sem reticências aqui
+    s4 := make([]int, 4)   // aloca uma slice de 4 ints, inicializada com ZEROS
+    var d2 [][]float64     // declaração apenas, nada é alocado
+    bs := []byte("uma slice") // sintaxe de conversão de tipos
+
+    p, q := learnMemory() // learnMemory retorna dois apontadores para int.
+    fmt.Println(*p, *q)   // * segue um apontador. isto imprime dois ints.
+
+    // Os maps são um tipo de matriz associativa, semelhante aos tipos hash
+    // ou dictionary que encontramos noutras linguagens.
+    m := map[string]int{"três": 3, "quatro": 4}
+    m["um"] = 1
+
+    // As variáveis não usadas são um erro em Go.
+    // O traço inferior permite "usar" uma variável, mas descarta o seu valor.
+    _, _, _, _, _, _, _, _, _ = s2, g, f, u, pi, n, a3, s4, bs
+    // Enviar para o stdout conta como utilização de uma variável.
+    fmt.Println(s, c, a4, s3, d2, m)
+
+    learnFlowControl() 
+}
+
+// A linguagem Go é totalmente garbage collected. Tem apontadores mas não 
+// permite que os apontadores sejam manipulados com aritmética. Pode-se cometer
+// um erro com um apontador nulo, mas não por incrementar um apontador.
+func learnMemory() (p, q *int) {
+    // A função retorna os valores p e q, que são do tipo apontador para int.
+    p = new(int) // a função new aloca memória, neste caso para um int.
+    // O int alocado é inicializado com o valor 0, p deixa de ser nil.
+    s := make([]int, 20) // alocar 20 ints como um único bloco de memória
+    s[3] = 7             // atribui o valor 7 a um deles
+    r := -2              // declarar outra variável local
+    return &s[3], &r     // & obtém o endereço de uma variável.
+}
+
+func expensiveComputation() int {
+    return 1e6
+}
+
+func learnFlowControl() {
+    // As instruções if exigem o uso de chavetas, e não requerem parênteses.
+    if true {
+        fmt.Println("eu avisei-te")
+    }
+    // A formatação do código-fonte é "estandardizada" através do comando
+    // da linha de comandos "go fmt."
+    if false {
+        // reclamar
+    } else {
+        // exultar
+    }
+    // Preferir o uso de switch em vez de ifs em cadeia.
+    x := 1
+    switch x {
+    case 0:
+    case 1:
+        // os cases não fazem "fall through"
+    case 2:
+        // esta linha só é executada se e só se x=2
+    }
+    // Tal como a instrução if, a instrução for não usa parênteses.
+    for x := 0; x < 3; x++ { // x++ é uma instrução, nunca uma expressão
+        fmt.Println("iteração", x)
+    }
+    // note que, x == 1 aqui.
+
+    // A instrução for é a única para ciclos, mas assume várias formas.
+    for { // ciclo infinito
+        break    // brincadeirinha
+        continue // nunca executado
+    }
+    // O uso de := numa instrução if permite criar uma variável local,
+    // que existirá apenas dentro do bloco if.
+    if y := expensiveComputation(); y > x {
+        x = y
+    }
+    // As funções podem ser closures.
+    xBig := func() bool {
+        return x > 100 // referencia x, declarado acima da instrução switch.
+    }
+    fmt.Println("xBig:", xBig()) // true (1e6 é o último valor de x)
+    x /= 1e5                     // agora temos x == 10 
+    fmt.Println("xBig:", xBig()) // false
+
+    // Quando for mesmo necessário, pode usar o velho goto.
+    goto love
+love:
+
+    learnInterfaces() // Mais coisas interessantes chegando!
+}
+
+// Define Stringer como uma interface consistindo de um método, String.
+type Stringer interface {
+    String() string
+}
+
+// Define pair como uma struct com dois campos ints chamados x e y.
+type pair struct {
+    x, y int
+}
+
+// Define um método para o tipo pair. O tipo pair implementa agora a 
+// interface Stringer.
+func (p pair) String() string { // p é chamado de "receptor"
+    // Sprintf é outra função pública no pacote fmt.
+    // Uso de pontos para referenciar os campos de p.
+    return fmt.Sprintf("(%d, %d)", p.x, p.y)
+}
+
+func learnInterfaces() {
+    // Uma struct pode ser inicializada com os valores dos seus campos dentro
+    // de chavetas, seguindo a mesma ordem com que os campos foram definidos.
+    p := pair{3, 4}
+    fmt.Println(p.String()) // chama o método String de p, que tem tipo pair.
+    var i Stringer          // declara i do tipo interface Stringer.
+    i = p                   // válido, porque pair implementa Stringer
+    // Chama o método String de i, que tem tipo Stringer. Mesmo que acima.
+    fmt.Println(i.String())
+
+    // As funções no pacote fmt chamam o método String para pedir a um objecto
+    // uma representação textual de si mesmo.
+    fmt.Println(p) // mesmo que acima. Println chama o método String.
+    fmt.Println(i) // mesmo que acima.
+
+    learnErrorHandling()
+}
+
+func learnErrorHandling() {
+    // ", ok" forma idiomática usada para saber se algo funcionou ou não.
+    m := map[int]string{3: "três", 4: "quatro"}
+    if x, ok := m[1]; !ok { // ok vai ser false porque 1 não está no map m.
+        fmt.Println("ninguem lá")
+    } else {
+        fmt.Print(x) // x seria o valor, se 1 estivesse no map.
+    }
+    // Um valor de erro comunica mais informação sobre o problema.
+    if _, err := strconv.Atoi("non-int"); err != nil { // _ descarta o valor
+        // imprime "strconv.ParseInt: parsing "non-int": invalid syntax"
+        fmt.Println(err)
+    }
+    // Vamos revisitar as interfaces um pouco mais tarde. Entretanto,
+    learnConcurrency()
+}
+
+// c é um channel, um objecto para comunicação concurrency-safe.
+func inc(i int, c chan int) {
+    c <- i + 1 // <- é operador "enviar" quando um channel aparece à esquerda.
+}
+
+// Vamos usar a função inc para incrementar números de forma concorrente.
+func learnConcurrency() {
+    // A mesma função make usada anteriormente para alocar uma slice.
+    // Make aloca e inicializa slices, maps, e channels.
+    c := make(chan int)
+    // Inicia três goroutines concorrentes. Os números serão incrementados de
+    // forma concorrente, talvez em paralelo se a máquina for capaz e estiver
+    // configurada correctamente. As três goroutines enviam para o mesmo canal.
+    go inc(0, c) // go é a instrução para iniciar uma goroutine.
+    go inc(10, c)
+    go inc(-805, c)
+    // Lê três resultados do channel c e imprime os seus valores.
+    // Não se pode dizer em que ordem os resultados vão chegar!
+    fmt.Println(<-c, <-c, <-c) // channel na direita, <- é operador "receptor".
+
+    cs := make(chan string)       // outro channel, este lida com strings.
+    cc := make(chan chan string)  // channel que lida com channels de strings.
+    go func() { c <- 84 }()       // inicia uma goroutine para enviar um valor
+    go func() { cs <- "palavroso" }() // outra vez, para o channel cs desta vez
+    // A instrução select tem uma sintaxe semelhante à instrução switch mas
+    // cada caso envolve uma operação com channels. Esta instrução seleciona, 
+    // de forma aleatória, um caso que esteja pronto para comunicar.
+    select {
+    case i := <-c: // o valor recebido pode ser atribuído a uma variável
+        fmt.Printf("é um %T", i)
+    case <-cs: // ou o valor recebido pode ser descartado
+        fmt.Println("é uma string")
+    case <-cc: // channel vazio, não se encontra pronto para comunicar.
+        fmt.Println("não aconteceu")
+    }
+    // Neste ponto um valor foi recebido de um dos channels c ou cs. Uma das
+    // duas goroutines iniciadas acima completou, a outra continua bloqueada.
+
+    learnWebProgramming() // Go faz. Você quer faze-lo também.
+}
+
+// Basta apenas uma função do pacote http para iniciar um servidor web.
+func learnWebProgramming() {
+    // O primeiro parâmetro de ListenAndServe é o endereço TCP onde escutar.
+    // O segundo parâmetro é uma interface, especificamente http.Handler.
+    err := http.ListenAndServe(":8080", pair{})
+    fmt.Println(err) // não ignorar erros
+}
+
+// Tornar pair um http.Handler ao implementar o seu único método, ServeHTTP.
+func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+    // Servir dados com um método de http.ResponseWriter
+    w.Write([]byte("Aprendeu Go em Y minutos!"))
+}
+```
+
+## Leitura Recomendada
+
+A principal fonte de informação é o [web site oficial Go](http://golang.org/).
+Lá é possível seguir o tutorial, experimentar de forma iterativa, e ler muito.
+
+A própria especificação da linguagem é altamente recomendada. É fácil de ler e
+incrivelmente curta (em relação ao que é habitual hoje em dia).
+
+Na lista de leitura para os aprendizes de Go deve constar o [código fonte da 
+biblioteca padrão](http://golang.org/src/pkg/). Exaustivamente documentado, é
+a melhor demonstração de código fácil de ler e de perceber, do estilo Go, e da
+sua escrita idiomática. Ou então clique no nome de uma função na [documentação]
+(http://golang.org/pkg/) e veja o código fonte aparecer!
+
+Outra ótima fonte para aprender Go é o [Go by example](https://gobyexample.com/).
+Apesar de ser em inglês, é possível recodificar os exemplos para aprender sobre
+a linguagem.
diff --git a/pt-br/groovy-pt.html.markdown b/pt-br/groovy-pt.html.markdown
new file mode 100644
index 00000000..2ec7d967
--- /dev/null
+++ b/pt-br/groovy-pt.html.markdown
@@ -0,0 +1,435 @@
+---
+language: Groovy
+category: language
+filename: learngroovy.groovy
+contributors:
+    - ["Roberto Pérez Alcolea", "http://github.com/rpalcolea"]
+translators:
+    - ["João Farias", "https://github.com/JoaoGFarias"]
+lang: pt-br
+---
+
+Groovy - Uma linguagem dinâmica para a plataforma Java. [Leia mais aqui.](http://www.groovy-lang.org/)
+
+```groovy
+
+/*
+  Prepara-se:
+
+  1) Instale a máquina virtual de Groovy - http://gvmtool.net/
+  2) Intalse o Groovy: gvm install groovy
+  3) Inicie o console groovy digitando: groovyConsole
+
+*/
+
+// Comentário de uma linha inicia-se com duas barras
+/*
+Comentário de múltiplas linhas são assim.
+*/
+
+// Olá Mundo!
+println "Olá mundo!"
+
+/*
+  Variáveis:
+
+  Você pode atribuir valores a variáveis para uso posterior
+*/
+
+def x = 1
+println x
+
+x = new java.util.Date()
+println x
+
+x = -3.1499392
+println x
+
+x = false
+println x
+
+x = "Groovy!"
+println x
+
+/*
+  Coleções e mapeamentos
+*/
+
+//Criando uma lista vazia
+def tecnologias = []
+
+/*** Adicionando elementos à lista ***/
+
+// Assim como Java
+tecnologias.add("Grails")
+
+// Shift para esquerda adiciona e retorna a lista
+tecnologias << "Groovy"
+
+// Adição de múltiplos elementos
+tecnologias.addAll(["Gradle","Griffon"])
+
+/*** Removendo elementos da lista ***/
+
+// Assim como Java
+tecnologias.remove("Griffon")
+
+// Subtração também funciona
+tecnologias = technologies - 'Grails'
+
+/*** Iterando sobre listas ***/
+
+// Itera sobre os elementos da lista
+tecnologias.each { println "Tecnologias: $it"}
+tecnologias.eachWithIndex { it, i -> println "$i: $it"}
+
+/*** Checando os elementos da lista ***/
+
+//Avalia se a lista contém o elemento 'Groovy'
+contem = tecnologias.contains( 'Groovy' )
+
+// Ou
+contem = 'Groovy' in tecnologias
+
+// Checagem por múltiplos elementos
+tecnologias.containsAll(['Groovy','Grails'])
+
+/*** Ordenando listas ***/
+
+// Ordena a lista (altera a lista in-place)
+tecnologias.sort()
+
+// Para ordenar a lista sem alterar a original
+tecnologiasOrdenadas = tecnologias.sort( false )
+
+/*** Manipulando listas ***/
+
+//Substitue todos os elementos da lista
+Collections.replaceAll(tecnologias, 'Gradle', 'gradle')
+
+//Desorganiza a lista
+Collections.shuffle(tecnologias, new Random())
+
+//Limpa a lista
+technologies.clear()
+
+//Criando um mapeamento vazio
+def devMap = [:]
+
+//Adicionando valores
+devMap = ['nome':'Roberto', 'framework':'Grails', 'linguagem':'Groovy']
+devMap.put('ultimoNome','Perez')
+
+//Iterando sobre os elementos do mapeamento
+devMap.each { println "$it.key: $it.value" }
+devMap.eachWithIndex { it, i -> println "$i: $it"}
+
+//Avalia se um mapeamento contém uma chave
+assert devMap.containsKey('nome')
+
+//Avalia se um mapeamento contém um valor
+assert devMap.containsValue('Roberto')
+
+//Pega as chaves de um mapeamento
+println devMap.keySet()
+
+//Pega os valores de um mapeamento
+println devMap.values()
+
+/*
+  Groovy Beans
+
+  GroovyBeans são JavaBeans com uma sintaxe muito mais simples.
+
+  Quando Groovy é compilado para bytecode, as seguintes regras são usadas:
+
+    * Se o nome é declarado com um modificador de acesso(public, private or
+      protected) então um atributo é gerado.
+
+    * Um nome declarado sem modificador de acesso gera um campo privado com
+      getter e setter públicos (ou seja, uma propriedade).
+
+    * Se uma propriedade é declarada como final, um campo private final é criado
+      e o setter não é gerado.
+
+    * Você pode declarar uma propriedade e também declarar seus próprios getters
+      e setters.
+
+    * Você pode declarar uma propriedade e um campo com o mesmo nome, a propriedade
+      usará este campo.
+
+    * Se você quer uma propriedade private ou protected, você deve prover seus
+      próprios getters e setter, que devem ser declarados como private ou protected.
+
+    * Se você acessar uma propriedade dentro da classe e esta propriedade é definida
+      em tempo de compilação com 'this', implícito ou explícito (por exemplo,
+      this.foo, ou simplesmente foo), Groovy acessará este campo diretamente, sem
+      passar pelo getter ou setter.
+
+    * Se você acessar uma propriedade que não existe usando foo, explicitamente ou
+      implicitamente, então Groovy irá acessar esta propriedade através da meta
+      classe, o que pode falhar em tempo de execução.
+
+*/
+
+class Foo {
+    // propriedade de leitura, apenas
+    final String nome = "Roberto"
+
+    // propriedade de leitura, apenas, com getter e setter públicos
+    String linguagem
+    protected void setLinguagem(String linguagem) { this.linguagem = linguagem }
+
+    // propriedade tipada dinamicamente
+    def ultimoNome
+}
+
+/*
+  Condicionais e loops
+*/
+
+//Groovy suporta a sintaxe if-else
+def x = 3
+
+if(x==1) {
+    println "Um"
+} else if(x==2) {
+    println "Dois"
+} else {
+    println "X é maior que Dois"
+}
+
+//Groovy também suporta o operador ternário
+def y = 10
+def x = (y > 1) ? "functionou" : "falhou"
+assert x == "functionou"
+
+//Loop 'for'
+//Itera sobre um intervalo (range)
+def x = 0
+for (i in 0 .. 30) {
+    x += i
+}
+
+//Itera sobre uma lista
+x = 0
+for( i in [5,3,2,1] ) {
+    x += i
+}
+
+//Itera sobre um array
+array = (0..20).toArray()
+x = 0
+for (i in array) {
+    x += i
+}
+
+//Itera sobre um mapa
+def map = ['name':'Roberto', 'framework':'Grails', 'language':'Groovy']
+x = 0
+for ( e in map ) {
+    x += e.value
+}
+
+/*
+  Operadores
+
+  Sobrecarregamento de Operadores para uma lsita dos operadores comuns que
+  Grooby suporta:
+  http://www.groovy-lang.org/operators.html#Operator-Overloading
+
+  Operadores Groovy úteis
+*/
+//Operador de espalhamento: invoca uma ação sobre todos os itens de um
+//objeto agregador.
+def tecnologias = ['Groovy','Grails','Gradle']
+tecnologias*.toUpperCase() // = to tecnologias.collect { it?.toUpperCase() }
+
+//Operador de navegação segura: usado para evitar NullPointerException.
+def usuario = User.get(1)
+def nomeUsuario = usuario?.nomeUsuario
+
+
+/*
+  Closures
+  Um closure, em Grooby, é como um "bloco de código" ou um ponteiro para método.
+  É um pedação de código que é definido e executado em um momento posterior.
+
+  Mais informação em: http://www.groovy-lang.org/closures.html
+*/
+//Exemplo:
+def clos = { println "Hello World!" }
+
+println "Executando o closure:"
+clos()
+
+//Passando parêmetros para um closure
+def soma = { a, b -> println a+b }
+soma(2,4)
+
+//Closdures por referir-se a variáveis que não estão listadas em sua
+//lista de parêmetros.
+def x = 5
+def multiplicarPor = { num -> num * x }
+println multiplicarPor(10)
+
+// Se você tiver um closure que tem apenas um argumento, você pode omitir
+// o parâmetro na definição do closure
+def clos = { print it }
+clos( "oi" )
+
+/*
+  Groovy pode memorizar resultados de closures [1][2][3]
+*/
+def cl = {a, b ->
+    sleep(3000) //  simula processamento
+    a + b
+}
+
+mem = cl.memoize()
+
+def chamaClosure(a, b) {
+    def inicio = System.currentTimeMillis()
+    mem(a, b)
+    println "Os inputs(a = $a, b = $b) - tomam ${System.currentTimeMillis() - inicio} msecs."
+}
+
+chamaClosure(1, 2)
+chamaClosure(1, 2)
+chamaClosure(2, 3)
+chamaClosure(2, 3)
+chamaClosure(3, 4)
+chamaClosure(3, 4)
+chamaClosure(1, 2)
+chamaClosure(2, 3)
+chamaClosure(3, 4)
+
+/*
+  Expando
+
+  A classe Expando é um bean dinâmico que permite adicionar propriedade e 
+  closures como métodos a uma instância desta classe
+
+  http://mrhaki.blogspot.mx/2009/10/groovy-goodness-expando-as-dynamic-bean.html
+*/
+  def usuario = new Expando(nome:"Roberto")
+  assert 'Roberto' == nome.name
+
+  nome.lastName = 'Pérez'
+  assert 'Pérez' == nome.lastName
+
+  nome.showInfo = { out ->
+      out << "Name: $name"
+      out << ", Last name: $lastName"
+  }
+
+  def sw = new StringWriter()
+  println nome.showInfo(sw)
+
+
+/*
+  Metaprogramação (MOP)
+*/
+
+//Usando a ExpandoMetaClasse para adicionar comportamento
+String.metaClass.testAdd = {
+    println "adicionamos isto"
+}
+
+String x = "teste"
+x?.testAdd()
+
+//Interceptando chamadas a métodos
+class Test implements GroovyInterceptable {
+    def soma(Integer x, Integer y) { x + y }
+
+    def invocaMetodo(String name, args) {
+        System.out.println "Invoca método $name com argumentos: $args"
+    }
+}
+
+def teste = new Test()
+teste?.soma(2,3)
+teste?.multiplica(2,3)
+
+//Groovy suporta propertyMissing para lidar com tentativas de resolução de
+//propriedades.
+class Foo {
+   def propertyMissing(String nome) { nome }
+}
+def f = new Foo()
+
+assertEquals "boo", f.boo
+
+/*
+  TypeChecked e CompileStatic
+  Groovy, por natureza, é e sempre será uma linguagem dinâmica, mas ela também
+  suporta typecheked e compilestatic
+
+  Mais informações: http://www.infoq.com/articles/new-groovy-20
+*/
+//TypeChecked
+import groovy.transform.TypeChecked
+
+void testeMethod() {}
+
+@TypeChecked
+void test() {
+    testeMethod()
+
+    def nome = "Roberto"
+
+    println noomee
+
+}
+
+//Outro exemplo:
+import groovy.transform.TypeChecked
+
+@TypeChecked
+Integer test() {
+    Integer num = "1"
+
+    Integer[] numeros = [1,2,3,4]
+
+    Date dia = numeros[1]
+
+    return "Teste"
+
+}
+
+//Exemplo de CompileStatic :
+import groovy.transform.CompileStatic
+
+@CompileStatic
+int soma(int x, int y) {
+    x + y
+}
+
+assert soma(2,5) == 7
+
+
+```
+
+## Referências
+
+[Groovy documentation](http://www.groovy-lang.org/documentation.html)
+
+[Groovy web console](http://groovyconsole.appspot.com/)
+
+Junte-se a um [grupo de usuários Groovy](http://www.groovy-lang.org/usergroups.html)
+
+## Livro
+
+* [Groovy Goodness] (https://leanpub.com/groovy-goodness-notebook)
+
+* [Groovy in Action] (http://manning.com/koenig2/)
+
+* [Programming Groovy 2: Dynamic Productivity for the Java Developer] (http://shop.oreilly.com/product/9781937785307.do)
+
+[1] http://roshandawrani.wordpress.com/2010/10/18/groovy-new-feature-closures-can-now-memorize-their-results/
+[2] http://www.solutionsiq.com/resources/agileiq-blog/bid/72880/Programming-with-Groovy-Trampoline-and-Memoize
+[3] http://mrhaki.blogspot.mx/2011/05/groovy-goodness-cache-closure-results.html
+
+
+
diff --git a/pt-br/hack-pt.html.markdown b/pt-br/hack-pt.html.markdown
new file mode 100644
index 00000000..7c938149
--- /dev/null
+++ b/pt-br/hack-pt.html.markdown
@@ -0,0 +1,316 @@
+---
+language: Hack
+contributors:
+    - ["Stephen Holdaway", "https://github.com/stecman"]
+    - ["David Lima", "https://github.com/davelima"]
+translators:
+    - ["David Lima", "https://github.com/davelima"]
+lang: pt-br
+filename: learnhack-pt.hh
+---
+
+Hack é uma linguagem baseada no PHP e roda numa máquina virtual chamada HHVM.
+Hack é quase completamente interoperável com códigos PHP existentes e adiciona
+alguns recursos úteis de linguagens estaticamente tipadas.
+
+Somente recursos específicos da linguagem Hack serão abordados aqui. Detalhes
+sobre a sintaxe do PHP estão disponíveis no
+[artigo PHP](http://learnxinyminutes.com/docs/php/) neste site.
+
+```php
+<?hh
+
+// A sintaxe do Hack é ativada apenas em arquivos que comecem com <?hh
+// Marcadores <?hh não podem ser incluídos em páginas HTML, diferente de <?php.
+// Usar o marcador "<?hh //strict" coloca o verificador de tipo no modo estrito.
+
+
+// Indução de tipo de parâmetros escalares
+function repeat(string $palavra, int $contagem)
+{
+    $palavra = trim($palavra);
+    return str_repeat($palavra . ' ', $contagem);
+}
+
+// Indução de tipo para valores de retorno
+function add(...$numeros) : int
+{
+    return array_sum($numeros);
+}
+
+// Funções que não retornam nada são induzidas com "void"
+function truncate(resource $recurso) : void
+{
+    // ...
+}
+
+// Induções de tipo devem permitir nulos de forma explícita
+function identity(?string $stringOuNulo) : ?string
+{
+    return $stringOuNulo;
+}
+
+// Induções de tipo podem ser especificadas em propriedades de classes
+class PropriedadesComTipos
+{
+    public ?string $nome;
+    
+    protected int $id;
+
+    private float $pontuacao = 100.0;
+
+    // O verificador de tipos do Hack reforça que propriedades tipadas devem
+    // ter um valor padrão ou devem ser definidos no construtor
+    public function __construct(int $id)
+    {
+        $this->id = $id;
+    }
+}
+
+
+// Funções anônimas (lambdas)
+$multiplicador = 5;
+array_map($y ==> $y * $multiplicador, [1, 2, 3]);
+
+
+// Genéricos
+class Caixa<T>
+{
+    protected T $dados;
+
+    public function __construct(T $dados) {
+        $this->dados = $dados;
+    }
+
+    public function pegaDados(): T {
+        return $this->dados;
+    }
+}
+
+function abreCaixa(Caixa<int> $caixa) : int
+{
+    return $caixa->pegaDados();
+}
+
+
+// Formas
+//
+// Hack adiciona o conceito de formas para definir arrays com uma estrutura
+// e tipos de dados garantidos
+type Point2D = shape('x' => int, 'y' => int);
+
+function distancia(Point2D $a, Point2D $b) : float
+{
+    return sqrt(pow($b['x'] - $a['x'], 2) + pow($b['y'] - $a['y'], 2));
+}
+
+distancia(
+    shape('x' => -1, 'y' => 5),
+    shape('x' => 2, 'y' => 50)
+);
+
+
+// Pseudônimos de tipos
+//
+// Hack adiciona vários recursos para criação de pseudônimos, tornando tipos complexos
+// mais fáceis de entender
+newtype VectorArray = array<int, Vector<int>>;
+
+// Um tuple contendo dois inteiros
+newtype Point = (int, int);
+
+function adicionaPontos(Point $p1, Point $p2) : Point
+{
+    return tuple($p1[0] + $p2[0], $p1[1] + $p2[1]);
+}
+
+adicionaPontos(
+    tuple(1, 2),
+    tuple(5, 6)
+);
+
+
+// enums em classes
+enum TipoDePista : int
+{
+    Estrada = 0;
+    Rua = 1;
+    Alameda = 2;
+    Avenida = 3;
+}
+
+function getTipoDePista() : TipoDePista
+{
+    return TipoDePista::Alameda;
+}
+
+
+// Especificação de argumentos no construtor (Argument Promotion)
+// 
+// Para evitar que propriedades sejam definidas em mais de um lugar, e
+// construtores que só definem propriedades, o Hack adiciona uma sintaxe para
+// definir as propriedades e o construtor ao mesmo tempo.
+class ArgumentPromotion
+{
+    public function __construct(public string $nome,
+                                protected int $idade,
+                                private bool $legal) {}
+}
+
+class SemArgumentPromotion
+{
+    public string $nome;
+
+    protected int $idade;
+
+    private bool $legal;
+
+    public function __construct(string $nome, int $idade, bool $legal)
+    {
+        $this->nome = $nome;
+        $this->idade = $idade;
+        $this->legal = $legal;
+    }
+}
+
+
+// Multi-tarefas cooperativo
+//
+// Duas novas palavras-chave ("async" e "await") podem ser usadas para
+// trabalhar com multi-tarefas.
+// Obs. Isto não envolve threads - apenas permite a transferência de controle
+async function printCooperativo(int $inicio, int $fim) : Awaitable<void>
+{
+    for ($i = $inicio; $i <= $fim; $i++) { 
+        echo "$i ";
+
+        // Permite que outras tarefas façam algo
+        await RescheduleWaitHandle::create(RescheduleWaitHandle::QUEUE_DEFAULT, 0);
+    }
+}
+
+// Imprime "1 4 7 2 5 8 3 6 9"
+AwaitAllWaitHandle::fromArray([
+    printCooperativo(1, 3),
+    printCooperativo(4, 6),
+    printCooperativo(7, 9)
+])->getWaitHandle()->join();
+
+
+// Atributos
+//
+// Atributos são uma forma de definir metadados para funções.
+// Hack tem alguns atributos especiais que possuem comportamentos úteis.
+
+// O atributo especial __Memoize faz com que o resultado da função fique em cache
+<<__Memoize>>
+function tarefaDemorada() : ?string
+{
+    return file_get_contents('http://exemplo.com');
+}
+
+// O corpo da função só é executado uma vez aqui:
+tarefaDemorada();
+tarefaDemorada();
+
+
+// O atributo especial __ConsistentConstruct faz com que o Hack certifique-se
+// de que a assinatura do construtor seja a mesma em todas as subclasses
+<<__ConsistentConstruct>>
+class FooConsistente
+{
+    public function __construct(int $x, float $y)
+    {
+        // ...
+    }
+
+    public function algumMetodo()
+    {
+        // ...
+    }
+}
+
+class BarConsistente extends FooConsistente
+{
+    public function __construct(int $x, float $y)
+    {
+        // O verificador de tipos do Hack exige que os construtores pai
+        // sejam chamados
+        parent::__construct($x, $y);
+
+        // ...
+    }
+
+    // A anotação __Override é uma anotação opcional que faz com que o
+    // verificador de tipos do Hack sobrescreva um método em uma classe pai
+    // ou um trait. Sem __Override, definir este método causará um erro,
+    // pois ele já foi definido na classe pai (FooConsistente):
+    <<__Override>>
+    public function algumMetodo()
+    {
+        // ...
+    }
+}
+
+class SubclasseFooInvalida extends FooConsistente
+{
+    // Caso o construtor não combine com o construtor da classe pai, o
+    // verificador de tipos acusará um erro:
+    //
+    //  "Este objeto é incompatível com o objeto FooConsistente porque algum(ns)
+    //   dos seus métodos são incompatíveis"
+    //  
+    public function __construct(float $x)
+    {
+        // ...
+    }
+
+    // Usar a anotação __Override em um método que não existe na classe pai
+    // causará um erro do verificador de tipos:
+    //  "SubclasseFooInvalida::outroMetodo() está marcada para sobrescrever;
+    //   nenhuma definição não-privada foi encontrada ou a classe pai foi
+    //   definida em código não-<?hh"
+    //  
+    <<__Override>>
+    public function outroMetodo()
+    {
+        // ...
+    }
+}
+
+
+// Traits podem implementar interfaces (não suportado pelo PHP)
+interface InterfaceGatinho
+{
+    public function brinca() : void;
+}
+
+trait TraitGato implements InterfaceGatinho
+{
+    public function brinca() : void
+    {
+        // ...
+    }
+}
+
+class Samuel
+{
+    use TraitGato;
+}
+
+
+$gato = new Samuel();
+$gato instanceof InterfaceGatinho === true; // True
+
+```
+
+## Mais informações
+
+Visite a [documentação do Hack](http://docs.hhvm.com/manual/en/hacklangref.php)
+para ver explicações detalhadas dos recursos que Hack adiciona ao PHP, ou o [site oficial do Hack](http://hanlang.org/)
+para outras informações.
+
+Visite o [site oficial do HHVM](http://hhvm.com/) para aprender a instalar o HHVM.
+
+Visite [este artigo](http://docs.hhvm.com/manual/en/hack.unsupported.php) para ver
+os recursos do PHP que o Hack não suporta e ver incompatibilidades entre Hack e PHP.
diff --git a/pt-br/haskell-pt.html.markdown b/pt-br/haskell-pt.html.markdown
new file mode 100644
index 00000000..788dc1d2
--- /dev/null
+++ b/pt-br/haskell-pt.html.markdown
@@ -0,0 +1,620 @@
+---
+language: Haskell
+contributors:
+    - ["Adit Bhargava", "http://adit.io"]
+translators:
+    - ["Lucas Tonussi", "http://www.inf.ufsc.br/~tonussi/"]
+lang: pt-br
+filename: learnhaskell-pt.hs
+---
+
+As linguagens funcionais são linguagens de programação com base em avaliação
+de funções matemáticas (expressões), evitando-se o conceito de mudança de
+estado com alteração de dados. Neste aspecto, este paradigma é oposto ao
+paradigma imperativo que se baseia em alterações de estados.
+
+A programação funcional começou no cálculo lambda, que foi base teórica para
+o desenvolvimento deste paradigma de programação.
+
+
+```haskell
+-- Para comentar a linha basta dois traços seguidos.
+
+{- Abre chaves traço e traço fecha chaves cria um campo
+   para comentário em múltiplas linhas.
+-}
+
+----------------------------------------------------
+-- 1. Tipos Primitivos de Dados e Operadores
+----------------------------------------------------
+
+-- Numerais
+
+0 -- 3
+1 -- 1
+2 -- 2 ...
+
+-- Alguns Operadores Fundamentais
+
+7 + 7 -- 7 mais 7
+7 - 7 -- 7 menos 7
+7 * 7 -- 7 vezes 7
+7 / 7 -- 7 dividido por 7
+
+-- Divisões não são inteiras, são fracionádas por padrão da linguagem
+28736 / 82374 -- 0.3488479374559934
+
+
+-- Divisão inteira
+82374 `div` 28736 -- 2
+
+-- Divisão modular
+82374 `mod` 28736 -- 24902
+
+-- Booleanos como tipo primitivo de dado
+True -- Verdadeiro
+False -- Falso
+
+-- Operadores unitário
+not True -- Nega uma verdade
+not False -- Nega uma falácia
+
+
+-- Operadores binários
+7 == 7 -- 7 é igual a 7 ?
+7 /= 7 -- 7 é diferente de 7 ?
+7 < 7 -- 7 é menor que 7 ?
+7 > 7 -- 7 é maior que 7 ?
+
+
+{- Haskell é uma linguagem que tem uma sintáxe bastante familiar na
+   matemática, por exemplo em chamadas de funções você tem:
+
+   NomeFunção ArgumentoA ArgumentoB ArgumentoC ...
+-}
+
+-- Strings e Caractéres
+"Texto entre abre áspas e fecha áspas define uma string"
+'a' -- Caractere
+'A' -- Caractere
+
+'Strings entre aspas simples sobe um erro' -- Erro léxico!
+
+-- Concatenação de Strings
+"StringA" ++ "StringB" -- "StringAStringB"
+
+-- Concatenação de Caracteres
+"haskell" == ['h','a','s','k','e','l','l'] -- True
+"haskell" == 'h':'a':'s':'k':'e':'l':'l':[] -- True
+
+-- Você pode listar uma string pelos seus caractéres
+"AbBbbcAbbcbBbcbcb" !! 0 -- 'A'
+"AbBbbcAbbcbBbcbcb" !! 1 -- 'b'
+"AbBbbcAbbcbBbcbcb" !! 2 -- 'B'
+
+----------------------------------------------------
+-- Listas e Túplas
+----------------------------------------------------
+
+-- A construção de uma lista precisa ser de elementos homogêneos
+[1, 2, 3, 4, 5] -- Homogênea
+[1, a, 2, b, 3] -- Heterogênea (Erro)
+
+-- Haskell permite que você crie sequências
+[1..5]
+
+{- Haskell usa avaliação preguiçosa o que
+   permite você ter listas "infinitas".
+-}
+
+-- Uma lista "infinita" cuja razão é 1
+[1..]
+
+-- O 777º elemento de uma lista de razão 1
+[1..] !! 777 -- 778
+
+-- União de listas [lista_0] ++ [lista_1] ++ [lista_i]
+[1..5] ++ [6..10] ++ [1..4] -- [1,2,3,4,5,6,7,8,9,10,1,2,3,4]
+
+-- Adiciona um cabeçalho a sua lista e desloca a cauda
+0:[1..10] -- [0, 1, 2, 3, 4, 5]
+'a':['a'..'e'] -- "aabcde"
+
+-- Indexação em uma lista
+[0..] !! 5 -- 5
+
+-- Operadores de Listas usuais
+head ['a'..'e'] -- Qual o cabeçalho da lista ?
+tail ['a'..'e'] -- Qual a cauda da lista ?
+init ['a'..'e'] -- Qual a lista menos o último elemento ?
+last ['a'..'e'] -- Qual o último elemento ?
+
+-- Compreensão de Lista (List Comprehension)
+
+{- Uma lista pode ser especificada
+   pela definição de eus elementos.
+   A compreensão de listas é feita
+   com um construtor de listas que
+   utiliza conceitos  e notações
+   da teoria dos conjuntos.
+
+   Exemplo:
+
+   A = { x**2 | X pertence aos Naturais && x é par}
+-}
+
+let par x = mod x 2 == 0
+let constroi_lista = [x * x | x <- [9 ..39], par x]
+-- [100,144,196,256,324,400,484,576,676,784,900,1024,1156,1296,1444]
+
+par 4 -- True
+par 3 -- False
+
+
+-- Listas com regras
+{- Para todo x se x é elemento da lista
+   faça 2 vezes x mas componha a lista
+   com apenas aqueles elementos cujo
+   2*x é maior que 4
+-}
+[x*2 | x <- [1..5], x*2 > 4] -- [6, 8, 10]
+
+-- Tuplas
+("Q", "Gamma", "b", "Sigma", "delta", "q0", "F") -- 7-Tuple Turing Machine
+
+-- Retirando da tupla
+
+{- Com as funções fst (primeiro) e snd (segundo)
+   você só pode enviar por parâmetro uma tupla
+   bi-dimensional ou seja, 2 dimensões == (x,y)
+-}
+
+fst ((2,3), [2,3]) -- (2,3)
+snd ((2,3), [4,3]) -- [4,3]
+
+
+----------------------------------------------------
+-- 3. Funções em Haskell
+----------------------------------------------------
+
+-- Uma função simples que toma duas variáveis
+{- Haskell trabalha em cima de recursão
+   Portanto certifique-se que você
+   Entende como recurssão funciona.
+-}
+
+soma a b = a + b -- Função que vai em um programa.hs
+
+{- Dentro do GHCi (Interpretador Haskell)
+   Você terá que fazer da seguinte maneira-- Podemos criar nos
+
+   Prelude> let soma a b = a + b
+   Prelude> soma 7 7 -- 14
+-}
+
+let constroi_lista = [x * x | x <- [9 ..39], par x]
+
+{- Você pode usar crases para chamar
+   Funcões de maneira diferente
+-}
+
+7 `soma` 7 -- 14
+
+{- Haskell permite que você crie os
+   seus próprios operadores baseados
+   nos já existendes
+-}
+
+let (~/\) a b = a `mod` b
+15^13 ~/\ 432 -- 759375
+
+-- Casamento de Padrões em Tuplas
+coordenadas (x, y) = (x + 13, y - 31)
+
+{- Haskell trabalha com casamento de padrões onde dada
+   um conjunto de funções definidas de diferentes maneiras
+   Haskell vai procurar por aquela que trabalha o seu tipo
+   de entrada.
+-}
+
+-- Guardas "|" É um jeito simples de representar funções recursivas
+
+let fatorial n | n == 0 = 1 | otherwise = fatorial (n - 1) * n -- Teste: fatorial 5
+
+-- Ainda podemos fazer:
+
+let fatorial 0 = 1
+let fatorial n = fatorial (n - 1) * n
+
+{- Podemos criar nossos próprios Mapeadores
+   Onde `primeiro` é o primeiro elemento de
+   uma lista é `resto`  é o resto da lista.
+-}
+
+mapa mapeador _ [] = []
+mapa mapeador (primeiro : resto) = mapeador primeiro : (mapa mapeador resto)
+
+{- Uma função anônima é uma função sem um nome.
+   É uma abstração do cálculo lambda:
+
+   \x -> x + 1
+   λ.x (x + 1)
+
+   Em Haskell Barra Invertida é um jeito para
+   se escrever Lambda (λ). Uma ótima pedida
+   Para entender Haskell e outras linguagens como Lisp
+   É estudar Cálculo Lambda, é um entendimento matemático
+   mais apurado. E do ponto de vista computacional é
+   bastante interessante. Em EXTRAS você encontrará
+   Links para aprender Cálculo Lambda.
+-}
+
+(\x -> x + 1) 4 -- 5
+
+
+{- Algumas vezes é mais conveniente usar expressões lambda
+   do que definir um nome para uma função. Na matemática
+   Nomes são muito simbólicos. Isso acontece bastante
+   quando você estiver trabalhando `map` ou `foldl` / `foldr`
+-}
+
+-- Sem usar expressões anônimas !
+listaSomaUm lst = map somaUm' lst where somaUm' x = x + 1
+
+-- Usando expressões anônimas !
+listaSomaUm' lst = map (\x -> x + 1) lst
+
+----------------------------------------------------
+-- 4. Mais Funções
+----------------------------------------------------
+
+{- Currying: Se você não passar todos os argumentos
+   para uma função, ela irá ser "currificada". O que
+   significa que irá retornar a função que pega o resto
+   dos elementos.
+-}
+
+soma a b = a + b
+foo = soma 10 -- foo ganha a propriedade "currying"
+foo 5 -- 15
+
+-- Outra maneira
+foo = (+10)
+foo 5 -- 15
+
+{- Composição de Funções
+   O (.) encadeia funções! Por exemplo,
+   aqui foo é uma função que recebe um valor.
+   Ela soma 10 a ela, multiplica o resultado por 5
+   e então retorna o resultado final.
+-}
+foo = (*5) . (+10)
+
+-- (5 + 10) * 5 = 75
+foo 5 -- 75
+
+{- Concertando precedência:
+   Haskell tem outra função chamada `$`. Isso altera a precedência
+   de computação. Ou seja Haskell computa o que está sendo sinalizado com $
+   da esquerda para a direita . Você pode usar `.` e `$` para se livrar
+   de parentízação desnecessária.
+-}
+
+(even (fatorial 3)) -- true
+
+-- Usando `.` e `$`
+even . fatorial $ 3 -- true
+
+----------------------------------------------------
+-- 5. Tipos
+----------------------------------------------------
+
+-- Haskell é fortemente tipado e tudo tem uma assinatura típica.
+
+-- Tipos Básicos:
+460 :: Integer
+"music" :: String
+True :: Bool
+
+{- Funções também tem tipos.
+   `not` recebe um booleano e retorna um booleano:
+   not :: Bool -> Bool
+-}
+
+{- Aqui temos uma função que recebe dois argumentos
+   soma :: Integer -> Integer -> Integer
+-}
+
+{- Quando você define um valor em Haskell
+   uma boa prática de programação é escrever
+   o TIPO acima dessa mesma. Como segue:
+-}
+
+double :: Integer -> Integer
+double x = x * 2
+
+----------------------------------------------------
+-- 6. Controle de Fluxo e IF-THEN-ELSE
+----------------------------------------------------
+
+-- Blocos IF-THEN-ELSE
+let valor_alternado = if 144 `mod` 6 == 4 then "acertou" else "errou" -- errou
+
+-- É legal identar quando você tem múltiplos branchs para acontecer
+
+let valor_alternado = if 144 `mod` 6 == 4
+                      then "acertou"
+                      else "errou"
+
+-- Blocos CASE
+
+{- caso <argumento> seja :
+        <ajuda>  -> mostra_ajuda
+        <inicia> -> inicia_programa
+        <_>      -> putStrLn "ExArgumentoInvalido"
+
+    Onde `_` Significa Qualquer Outra Coisa.
+-}
+
+
+case args of
+     "ajuda"  -> mostra_ajuda
+     "inicia" -> inicia_programa
+     _        -> putStrLn "ExArgumentoInvalido"
+
+{- Haskell não funciona na base de loops pois ele é
+   fortemente baseado em funcões recursivas e cálculo lambda
+
+   Use `map` uma função build-in do interpretador
+   para, por exemplo, mapear uma lista:
+-}
+map (*2) [1..5] -- [2, 4, 6, 8, 10]
+
+-- Você pode criar um FOR-LOOP usando map
+let for array funcao = map funcao array
+for [0..5] $ \i -> show i
+
+-- Ou ainda (Pesquise sobre show em Haskell):
+for [0..5] show
+
+
+{- foldl computação é feita esquerda para direita
+   foldr computação é feita  direita para esquerda
+
+   Você pode usar foldl or foldr a fim de reduzir uma lista
+   fold(l||r) <funcao> <valor inicial> <lista>
+-}
+
+-- Fold Left
+foldl (\x y -> 2*x + y) 4 [1,2,3] -- 43
+
+-- Pensando Recursivamente Esquerda-Direita
+(2 * (2 * (2 * 4 + 1) + 2) + 3) -- 43
+
+-- Fold Right
+foldr (\x y -> 2*x + y) 4 [1,2,3] -- 16
+
+-- Pensando Recursivamente Direita-Esquerda
+(2 * 3 + (2 * 2 + (2 * 1 + 4)))
+
+----------------------------------------------------
+-- 7. Declaração de Dados
+----------------------------------------------------
+
+{- Vamos começar definindo um tipo de
+   dado que é uma cor rgb então ela
+   tem valores para vermelho azul e verde
+   ela é composta desses 3 comprimentos
+   Vamos usar `data` e `say` que são built-in:
+
+   Haskell pede que você user letra
+   maiuscula para tipos (types) ou classes (Class)
+
+   Por favor, visite: http://www.haskell.org/haskellwiki/Type
+   E de uma olhada na fórmula genérica de declaração de dados.
+-}
+
+data Cor = Vermelho | Azul | Verde
+
+-- say :: Color -> String
+
+let say Vermelho = "Vermelho"
+let say Azul = "Azul"
+let say Verde = "Verde"
+
+{- O seu tipo de dados por receber parâmetros também
+   vamos com um exemplo usando `data` e a Classe `Maybe`.
+-}
+
+data Maybe a = Nothing | Just a
+
+-- Just e Nothing são todos derivadas de Maybe
+Just "hello" -- tipo `Maybe String`
+Just 1       -- tipo `Maybe Int`
+Nothing      -- tipo `Maybe a` para algum `a`
+
+
+----------------------------------------------------
+-- 8. Mônadas
+----------------------------------------------------
+
+{- As mônadas permitem que o programador construa computações
+   sando os blocos de comando sequenciais, os quais, por sua vez,
+   podem ter outras sequencias de computações. Para entender melhor
+   a classe Monads você precisa ler um pouco mais sobre Classes em
+   Haskell e o polímofirmo ad hoc do Haskell.
+
+   A Classe Mônada padrão em Haskell é a seguinte:
+-}
+
+class Monad m where
+  (>>=)  :: m a -> (a -> m b) -> m b
+  (>>)   :: m a -> m b -> m b
+  return :: m -> m a
+  fail   :: String -> m a
+
+  -- Definição completa mínima:
+  -- (>>=), return
+
+  m >> k = m >>= \_ -> k
+  fail s = error s
+
+{- Como exemplo, a função le_imprime opera com a função ">=" da
+   classe mônada, a qual repassa o retorno obtido com a função
+   getLine para uma função lambda \e qualquer.
+
+   GHC-BASICS
+   Cria um arquivo chamado le_imprime.hs
+   compile: ghc --make -c -O Programa_Haskell_Principal.hs
+   execute: ./Programa_Haskell_Principal
+-}
+
+le_imprime :: IO ()
+le_imprime = getLine >>= \e -> putStrLn e -- le_imprime = getLine >>= putStrLn
+
+{- Mônadas abrem a possibilidade de criar computações
+   no estilo imperativo dentro de um grande programa funcional
+
+   Leis das Mônadas:
+
+   1. return a >>= k  =  k a
+   2. m >>= return  =  m
+   3. m >>= (\x -> k x >>= h)  =  (m >>= k) >>= h
+-}
+
+-- O operador >> é chamada então (p -> q, p então q)
+let m >> n = m >>= \_ -> n
+
+
+----------------------------------------------------
+-- 9. Haskell Entrada/Saída
+----------------------------------------------------
+
+{- Quando um programa Haskell é executado a função `main` é
+   chamada. E ela precisa retornar um valor do tipo IO().
+-}
+
+module Main where
+  main :: IO ()
+  main = putStrLn $ "Oi Glasgow!"
+
+-- Ou simplesmente:
+
+main = putStrLn $ "Oi Glasgow!"
+
+{- putStrLn é do tipo String -> IO()
+
+   É o jeito mais fácil de conseguir E/S se você implementar
+   o seu programa como uma função de String para String.
+
+   A função:
+      interact :: (String -> String) -> IO ()
+   Joga texto, roda a função nela mesma, e imprime a saída
+-}
+
+module Main where
+  contadorLinhas = show . length . lines
+  main = interact contadorLinhas
+
+-- Use a notação `do` para encadear ações. Por exemplo:
+
+diga_oi :: IO ()
+
+diga_oi = do
+
+  putStrLn "Qual eh o seu nome?"
+  name <- getLine
+  putStrLn $ "Oi, " ++ name
+
+main = diga_oi
+
+{- Exercício! Escreva sua própria versão
+   onde irá ler apenas uma linhas de input.
+
+   Vamos entender melhor como `getLine` funciona?
+      getLine :: IO String
+   Pense que o valor do tipo `IO a` representando um
+   programa de computador que irá gerar um valor do tipo `a`
+   quando for ele executado.
+   
+   Nós podemos guardar e reusar isso apenas apontando `<-`.
+   Nós podemos também cria nossas próprias ações do tipo `IO String`
+-}
+
+nova_acao :: IO String
+
+nova_acao = do
+  putStrLn "Uma string curta o bastante."
+  entra1 <- getLine
+  entra2 <- getLine
+  -- return :: String -> IO String
+  return (entra1 ++ "\n" ++ entra2)
+
+{- Nós podemos usar da seguinte maneira
+   como acabamos de usar `getLine`, exemplo:
+-}
+
+main'' = do
+  putStrLn "String A"
+  result <- action
+  putStrLn result
+  putStrLn "String B"
+
+----------------------------------------------------
+-- 9. O Haskell REPL (Read Eval Print Loop)
+----------------------------------------------------
+
+{- Digite dhci no seu terminal
+   para começar o interpretador
+   lembre-se que para definir
+   funções e variáveis em haskell
+   pelo interpretador você precisar
+   iniciar com `let`
+-}
+
+Prelude> let foo = 1.4
+
+-- Você pode ver o tipo de algo usando `:t`:
+
+Prelude> :t foo
+foo :: Double
+```
+
+
+# Extra
+
+Compilador e Interpretador Haskell
+
+* [GHC](http://www.haskell.org/ghc/docs/latest/html/users_guide/index.html)
+* [GHC/GHCi](http://www.haskell.org/haskellwiki/GHC)
+* [Haskell em 5 Passos !!!](http://www.haskell.org/haskellwiki/Haskell_in_5_steps)
+
+Instale Haskell [Aqui!](http://www.haskell.org/platform/).
+
+Aplicações Haskell Muito Interessantes:
+
+* [Música e Som](http://www.haskell.org/haskellwiki/Applications_and_libraries/Music_and_sound)
+* [Haskell SuperCollider Servidor](https://github.com/kaoskorobase/hsc3-server)
+* [Haskell SuperCollider Cliente](http://hackage.haskell.org/package/hsc3)
+* [Física e Matemática](http://www.haskell.org/haskellwiki/Applications_and_libraries/Mathematics)
+* [Jogos](http://www.haskell.org/haskellwiki/Applications_and_libraries/Games)
+* [Bio Informática](http://www.haskell.org/haskellwiki/Applications_and_libraries/Bioinformatics)
+* [Muitos Outras Aplicações](http://www.haskell.org/haskellwiki/Libraries_and_tools)
+
+Comunidade Haskell
+* [Musica das Mônadas](http://www.haskell.org/haskellwiki/Music_of_monads)
+* [Entendendo Mônadas](https://en.wikibooks.org/wiki/Haskell/Understanding_monads)
+
+Tutoriais:
+
+* [Mapeadores](http://www.haskell.org/ghc/docs/6.12.2/html/libraries/containers-0.3.0.0/Data-Map.html)
+* [Aprenda Haskell!](http://haskell.tailorfontela.com.br/chapters)
+* [Fundação Teórica da Linguagem Haskell](http://www.haskell.org/haskellwiki/Lambda_calculus)
+* [Classe Maybe](http://www.haskell.org/haskellwiki/Maybe)
+* [Zvon Referência Haskell](http://www.zvon.org/other/haskell/)
+
+Obtenha Também Haskell Wiki Book [Aqui!](https://en.wikibooks.org/wiki/Haskell)
+
+Leia Sobre As Mônadas [Aqui!](http://www.haskell.org/haskellwiki/Monads)
+
+Livro: Haskell Uma Abordagem Prática - Claudio Cesar de Sá e Márcio Ferreira da Silva
diff --git a/pt-br/hy-pt.html.markdown b/pt-br/hy-pt.html.markdown
new file mode 100644
index 00000000..4230579d
--- /dev/null
+++ b/pt-br/hy-pt.html.markdown
@@ -0,0 +1,176 @@
+---
+language: hy
+filename: learnhy.hy
+contributors:
+    - ["Abhishek L", "http://twitter.com/abhishekl"]
+translators:
+    - ["Miguel Araújo", "https://github.com/miguelarauj1o"]
+lang: pt-br
+---
+
+Hy é um dialeto de Lisp escrito sobre Python. Isto é possível convertendo
+código Hy em árvore sintática abstrata python (ast). Portanto, isto permite
+hy chamar código python nativo e vice-versa.
+
+Este tutorial funciona para hy ≥ 0.9.12
+
+```clojure
+;; Isso dá uma introdução básica em hy, como uma preliminar para o link abaixo
+;; http://try-hy.appspot.com
+;;
+; Comentários em ponto-e-vírgula, como em outros LISPS
+
+;; s-noções básicas de expressão
+; programas Lisp são feitos de expressões simbólicas ou sexps que se assemelham
+(some-function args)
+; agora o essencial "Olá mundo"
+(print "hello world")
+
+;; Tipos de dados simples
+; Todos os tipos de dados simples são exatamente semelhantes aos seus homólogos 
+; em python que
+42 ; => 42
+3.14 ; => 3.14
+True ; => True
+4+10j ; => (4+10j) um número complexo
+
+; Vamos começar com um pouco de aritmética muito simples
+(+ 4 1) ;=> 5
+; o operador é aplicado a todos os argumentos, como outros lisps
+(+ 4 1 2 3) ;=> 10
+(- 2 1) ;=> 1
+(* 4 2) ;=> 8
+(/ 4 1) ;=> 4
+(% 4 2) ;=> 0 o operador módulo
+; exponenciação é representado pelo operador ** como python
+(** 3 2) ;=> 9
+; formas aninhadas vão fazer a coisa esperada
+(+ 2 (* 4 2)) ;=> 10
+; também operadores lógicos e ou não e igual etc. faz como esperado
+(= 5 4) ;=> False
+(not (= 5 4)) ;=> True
+
+;; variáveis
+; variáveis são definidas usando SETV, nomes de variáveis podem usar utf-8, exceto
+; for ()[]{}",'`;#|
+(setv a 42)
+(setv π 3.14159)
+(def *foo* 42)
+;; outros tipos de dados de armazenamento
+; strings, lists, tuples & dicts
+; estes são exatamente os mesmos tipos de armazenamento de python
+"hello world" ;=> "hello world"
+; operações de string funcionam semelhante em python
+(+ "hello " "world") ;=> "hello world"
+; Listas são criadas usando [], a indexação começa em 0
+(setv mylist [1 2 3 4])
+; tuplas são estruturas de dados imutáveis
+(setv mytuple (, 1 2))
+; dicionários são pares de valores-chave
+(setv dict1 {"key1" 42 "key2" 21})
+; :nome pode ser utilizado para definir palavras-chave em hy que podem ser utilizados para as chaves
+(setv dict2 {:key1 41 :key2 20})
+; usar 'get' para obter o elemento em um índice/key
+(get mylist 1) ;=> 2
+(get dict1 "key1") ;=> 42
+; Alternativamente, se foram utilizadas palavras-chave que podem ser chamadas diretamente
+(:key1 dict2) ;=> 41
+
+;; funções e outras estruturas de programa
+; funções são definidas usando defn, o último sexp é devolvido por padrão
+(defn greet [name]
+  "A simple greeting" ; uma docstring opcional
+  (print "hello " name))
+
+(greet "bilbo") ;=> "hello bilbo"
+
+; funções podem ter argumentos opcionais, bem como argumentos-chave
+(defn foolists [arg1 &optional [arg2 2]]
+  [arg1 arg2])
+
+(foolists 3) ;=> [3 2]
+(foolists 10 3) ;=> [10 3]
+
+; funções anônimas são criados usando construtores 'fn' ou 'lambda'
+; que são semelhantes para 'defn'
+(map (fn [x] (* x x)) [1 2 3 4]) ;=> [1 4 9 16]
+
+;; operações de sequência
+; hy tem algumas utils embutidas para operações de sequência, etc.
+; recuperar o primeiro elemento usando 'first' ou 'car'
+(setv mylist [1 2 3 4])
+(setv mydict {"a" 1 "b" 2})
+(first mylist) ;=> 1
+
+; corte listas usando 'slice'
+(slice mylist 1 3) ;=> [2 3]
+
+; obter elementos de uma lista ou dict usando 'get'
+(get mylist 1) ;=> 2
+(get mydict "b") ;=> 2
+; lista de indexação começa a partir de 0, igual em python
+; assoc pode definir elementos em chaves/índices
+(assoc mylist 2 10) ; faz mylist [1 2 10 4]
+(assoc mydict "c" 3) ; faz mydict {"a" 1 "b" 2 "c" 3}
+; há toda uma série de outras funções essenciais que torna o trabalho com 
+; sequências uma diversão
+
+;; Python interop
+;; importação funciona exatamente como em python
+(import datetime)
+(import [functools [partial reduce]]) ; importa fun1 e fun2 do module1
+(import [matplotlib.pyplot :as plt]) ; fazendo uma importação em foo como em bar
+; todos os métodos de python embutidas etc. são acessíveis a partir hy
+; a.foo(arg) is called as (.foo a arg)
+(.split (.strip "hello world  ")) ;=> ["hello" "world"]
+
+;; Condicionais
+; (if condition (body-if-true) (body-if-false)
+(if (= passcode "moria")
+  (print "welcome")
+  (print "Speak friend, and Enter!"))
+
+; aninhe múltiplas cláusulas 'if else if' com cond
+(cond
+ [(= someval 42)
+  (print "Life, universe and everything else!")]
+ [(> someval 42)
+  (print "val too large")]
+ [(< someval 42)
+  (print "val too small")])
+
+; declarações de grupo com 'do', essas são executadas sequencialmente
+; formas como defn tem um 'do' implícito
+(do
+ (setv someval 10)
+ (print "someval is set to " someval)) ;=> 10
+
+; criar ligações lexicais com 'let', todas as variáveis definidas desta forma
+; tem escopo local
+(let [[nemesis {"superman" "lex luther"
+                "sherlock" "moriarty"
+                "seinfeld" "newman"}]]
+  (for [(, h v) (.items nemesis)]
+	(print (.format "{0}'s nemesis was {1}" h v))))
+
+;; classes
+; classes são definidas da seguinte maneira
+(defclass Wizard [object]
+  [[--init-- (fn [self spell]
+             (setv self.spell spell) ; init a mágica attr
+             None)]
+   [get-spell (fn [self]
+              self.spell)]])
+
+;; acesse hylang.org
+```
+
+### Outras Leituras
+
+Este tutorial é apenas uma introdução básica para hy/lisp/python.
+
+Docs Hy: [http://hy.readthedocs.org](http://hy.readthedocs.org)
+
+Repo Hy no Github: [http://github.com/hylang/hy](http://github.com/hylang/hy)
+
+Acesso ao freenode irc com #hy, hashtag no twitter: #hylang
diff --git a/pt-br/java-pt.html.markdown b/pt-br/java-pt.html.markdown
new file mode 100644
index 00000000..a884f273
--- /dev/null
+++ b/pt-br/java-pt.html.markdown
@@ -0,0 +1,435 @@
+---
+
+language: java
+contributors:
+    - ["Jake Prather", "http://github.com/JakeHP"]
+    - ["Madison Dickson", "http://github.com/mix3d"]
+translators:
+    - ["Victor Kléber Santos L. Melo", "http://victormelo.com.br/blog"]
+    - ["Renê Douglas N. de Morais", "mailto:rene.douglas.bsi@gmail.com"]
+lang: pt-br
+filename: LearnJava-pt.java
+
+---
+
+Java é uma linguagem de programação de propósito geral, concorrente, baseada em classes e orientada a objetos.
+[Leia mais aqui](http://docs.oracle.com/javase/tutorial/java/index.html)
+
+```java
+// Comentários de uma linha começam com //
+/*
+Comentários de várias linhas são feitos dessa forma.
+*/
+/**
+Comentários JavaDoc são feitos assim. São usados para descrever a Classe ou os atributos da Classe.
+*/
+
+// Importa a classe ArrayList que está dentro do pacote java.util
+import java.util.ArrayList;
+// Importa todas as classes que estão dentro do pacote java.security
+import java.security.*;
+
+// Cada arquivo .java contém uma classe pública, com o mesmo nome do arquivo.
+public class LearnJava {
+
+    // Um programa precisa ter um método main como um ponto de entrada.
+    public static void main (String[] args) {
+
+        // O System.out.println é usado para imprimir no console
+        System.out.println("Olá Mundo!");
+        System.out.println(
+            "Integer: " + 10 +
+            " Double: " + 3.14 +
+            " Boolean: " + true);
+
+        // Para imprimir sem inserir uma nova lina, use o System.out.print
+        System.out.print("Olá ");
+        System.out.print("Mundo");
+
+
+        ///////////////////////////////////////
+        // Tipos & Variáveis
+        ///////////////////////////////////////
+
+        // Declara-se variáveis usando <tipo> <nome> [
+        // Byte - inteiro de 8 bits com sinal complementado a dois
+        // (-128 <= byte <= 127)
+        byte fooByte = 100;
+
+        // Short - inteiro de 16 bits com sinal complementado a dois
+        // (-32,768 <= short <= 32,767)
+        short fooShort = 10000;
+
+        // Integer - inteiro de 32 bits com sinal complementado a dois
+        // (-2,147,483,648 <= int <= 2,147,483,647)
+        int fooInt = 1;
+
+        // Long - inteiro de 64 bits com sinal complementado a dois
+        // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
+        long fooLong = 100000L;
+        // L é usado para indicar que o valor da variável é do tipo Long;
+        // sem o L, tudo é tratado como inteiro por padrão.
+
+        // Nota: Java não tem tipos sem sinal
+
+        // Float - Ponto Flutuante 32-bits, de precisão simples no padrão IEEE 754
+        float fooFloat = 234.5f;
+        // f é usado para indicar que o valor da variável é do tipo float;
+        // caso contrário, ela é tratada como double.
+
+        // Double - Ponto Flutuante 64-bits, de precisão dupla no padrão IEEE 754
+        double fooDouble = 123.4;
+
+        // Boolean - true & false
+        boolean fooBoolean = true;
+        boolean barBoolean = false;
+
+        // Char - Um caractere Unicode de 16 bits
+        char fooChar = 'A';
+
+        // Usa-se o final para fazer com que a variável seja imutável.
+        final int HORAS_QUE_TRABALHEI_POR_SEMANA = 9001;
+
+        // Strings
+        String fooString = "Aqui está minha String!";
+
+        // \n é um caractere de escape que inicia uma nova linha
+        String barString = "Imprimir em uma nova linha?\nSem problemas!";
+        // \t é um caractere de escape que adiciona um caractere de tabulação
+        String bazString = "Você quer adicionar tabulação?\tSem problemas!";
+        System.out.println(fooString);
+        System.out.println(barString);
+        System.out.println(bazString);
+
+        // Arrays
+        //O tamanho do array precisa ser determinado na sua declaração
+        //O formato para declarar um array é:
+        //<tipo de dado> [] <nome da variável> = new <tipo de dado>[<tamanho do array>];
+        int [] intArray = new int[10];
+        String [] stringArray = new String[1];
+        boolean [] booleanArray = new boolean[100];
+
+        // Outra maneira de declarar e inicializar um array
+        int [] y = {9000, 1000, 1337};
+
+        // Indexando um array - Acessando um elemento
+        System.out.println("intArray no índice 0: " + intArray[0]);
+
+        // O primeiro termo de um array é o 0 e eles são mutáveis.
+        intArray[1] = 1;
+        System.out.println("intArray no índice 1: " + intArray[1]); // => 1
+
+        // Outras estruturas que devem ser vistas
+        // ArrayLists - São parecidos com os arrays, porém oferecem mais funcionalidades
+        //             e o tamanho é mutável.
+        // LinkedLists
+        // Maps
+        // HashMaps
+
+        ///////////////////////////////////////
+        // Operadores
+        ///////////////////////////////////////
+        System.out.println("\n->Operadores");
+
+        int i1 = 1, i2 = 2; // Forma abreviada de escrever múltiplas declarações.
+
+        // Aritmética é feita da forma convencional
+        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 (0.5 arredondado para baixo)
+
+        // Módulo
+        System.out.println("11%3 = "+(11 % 3)); // => 2
+
+        // Operadores de comparação
+        System.out.println("3 == 2? " + (3 == 2)); // => false
+        System.out.println("3 != 2? " + (3 != 2)); // => true
+        System.out.println("3 > 2? " + (3 > 2)); // => true
+        System.out.println("3 < 2? " + (3 < 2)); // => false
+        System.out.println("2 <= 2? " + (2 <= 2)); // => true
+        System.out.println("2 >= 2? " + (2 >= 2)); // => true
+
+        // Operadores bit-a-bit!
+        /*
+        ~       Complemento de um
+        <<      Deslocamento a esquerda com sinal
+        >>      Deslocamento a direita com sinal
+        >>>     Deslocamento a direita sem sinal
+        &       E bit-a-bit
+        |       OU bit-a-bit
+        ^       OU exclusivo bit-a-bit
+        */
+
+        // Incrementações
+        int i = 0;
+        System.out.println("\n->Inc/Dec-rementação");
+        System.out.println(i++); //i = 1. Pós-Incrementação
+        System.out.println(++i); //i = 2. Pre-Incrementação
+        System.out.println(i--); //i = 1. Pós-Decrementação
+        System.out.println(--i); //i = 0. Pre-Decrementação
+
+        ///////////////////////////////////////
+        // Estruturas de Controle
+        ///////////////////////////////////////
+        System.out.println("\n->Estruturas de Controle");
+
+        // Os comandos If são parecidos com o da linguagem C
+        int j = 10;
+        if (j == 10){
+            System.out.println("Eu serei impresso");
+        } else if (j > 10) {
+            System.out.println("Eu não");
+        } else {
+            System.out.println("Eu também não");
+        }
+
+        // O Loop While
+        int fooWhile = 0;
+        while(fooWhile < 100)
+        {
+            //System.out.println(fooWhile);
+            //Incrementando o contador
+            //Iteração feita 99 vezes, fooWhile 0->99
+            fooWhile++;
+        }
+        System.out.println("Valor do fooWhile: " + fooWhile);
+
+        // O Loop Do While
+        int fooDoWhile = 0;
+        do
+        {
+            //System.out.println(fooDoWhile);
+            //Incrementando o contador
+            //Iteração feita 99 vezes, fooDoWhile 0->99
+            fooDoWhile++;
+        }while(fooDoWhile < 100);
+        System.out.println("Valor do fooDoWhile: " + fooDoWhile);
+
+        // O Loop For
+        int fooFor;
+        //estrutura do loop for => for(<operação_de_início>; <condição>; <passo>)
+        for(fooFor=0; fooFor<10; fooFor++){
+            //System.out.println(fooFor);
+            //Iteração feita 10 vezes, fooFor 0->9
+        }
+        System.out.println("Valor do fooFor: " + fooFor);
+        
+        // O Loop For Each 
+        // Itera automaticamente por um array ou lista de objetos.
+        int[] fooList = {1,2,3,4,5,6,7,8,9};
+        //estrutura do loop for each => for(<objeto> : <array_de_objeto>)
+        //lê-se: para cada objeto no array
+        //nota: o tipo do objeto deve ser o mesmo do array.
+        
+        for( int bar : fooList ){
+            //System.out.println(bar);
+            //Itera 9 vezes e imprime 1-9 em novas linhas
+        }
+        
+        // Switch
+        // Um switch funciona com os tipos de dados: byte, short, char e int
+        // Ele também funciona com tipos enumerados (vistos em tipos Enum)
+        // como também a classe String e algumas outras classes especiais
+        // tipos primitivos: Character, Byte, Short e Integer
+        int mes = 3; 
+        String mesString; 
+        switch (mes){ 
+            case 1:
+                    mesString = "Janeiro"; 
+                    break;
+            case 2:
+                    mesString = "Fevereiro"; 
+                    break;
+            case 3:
+                    mesString = "Março"; 
+                    break;
+            default:
+                    mesString = "Algum outro mês"; 
+                    break;
+        }
+        System.out.println("Resultado do Switch: " + mesString);
+        
+        // Condição de forma abreviada.
+        // Você pode usar o operador '?' para atribuições rápidas ou decisões lógicas.
+        // Lê-se "Se (declaração) é verdadeira, use <primeiro valor>
+        // caso contrário, use <segundo valor>".
+        int foo = 5;
+        String bar = (foo < 10) ? "A" : "B";
+        System.out.println(bar); //Imprime A, pois a condição é verdadeira.
+
+
+        ///////////////////////////////////////
+        // Convertendo tipos de dados e Casting
+        ///////////////////////////////////////
+
+        //Conversão de Dados
+
+        //Convertendo String para Inteiro.
+        Integer.parseInt("123");//retorna uma versão inteira de "123".
+
+        //Convertendo Inteiro para String
+        Integer.toString(123);//retorna uma versão String de 123.
+
+        // Para outras conversões confira as seguintes classes
+        // Double
+        // Long
+        // String
+
+        // Casting
+        // Você pode também converter objetos java, há vários detalhes e
+        // lida com alguns conceitos intermediários
+        // Dê uma olhada no link:
+        // http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html
+
+
+        ///////////////////////////////////////
+        // Classes e Métodos
+        ///////////////////////////////////////
+
+        System.out.println("\n->Classes e Métodos"); 
+
+        // (segue a definição da classe Bicicleta) 
+
+        // Use o new para instanciar uma classe
+        Bicicleta caloi = new Bicicleta(); // Objeto caloi criado.
+
+        // Chame os métodos do objeto
+        caloi.aumentarVelocidade(3); // Você deve sempre usar métodos para modificar variáveis
+        caloi.setRitmo(100);
+
+        // toString é uma convenção para mostrar o valor deste objeto.
+        System.out.println("informações de caloi: " + caloi.toString());
+
+    } // Fim do método main
+} // Fim da classe LearnJava
+
+
+// Você pode incluir outras classes que não são públicas num arquivo .java
+
+
+// Sintaxe de declaração de Classe.
+// <public/private/protected> class <nome da classe>{
+//   // atributos, construtores e todos os métodos.
+//   // funções são chamadas de métodos em Java.
+// }
+
+class Bicicleta {
+
+    // Atributos/Variáveis da classe Bicicleta.
+    public int ritmo;          // Public: Pode ser acessada em qualquer lugar.
+    private int velocidade;    // Private: Apenas acessível a classe. 
+    protected int catraca; // Protected: Acessível a classe e suas subclasses.
+    String nome;               // default: Apenas acessível ao pacote. 
+
+    // Construtores são uma forma de criação de classes
+    // Este é o construtor padrão.
+    public Bicicleta() {
+        catraca = 1;
+        ritmo = 50;
+        velocidade = 5;
+        nome = "Bontrager";
+    }
+
+    // Este é um construtor específico (ele contém argumentos).
+    public Bicicleta (int ritmoInicial, int velocidadeInicial, int catracaInicial, String nome) {
+        this.catraca = catracaInicial;
+        this.ritmo = ritmoInicial;
+        this.velocidade = velocidadeInicial;
+        this.nome = nome;
+    }
+
+    // Sintaxe de um método:
+    // <public/private/protected> <tipo de retorno> <nome do método>(<args>) //  
+
+    // Classes em Java costumam implementar métodos getters e setters para seus campos.
+
+    // Sintaxe de declaração de métodos
+    // <escopo> <tipo de retorno> <nome do método>(<args>) //   
+    public int getRitmo() {
+        return ritmo;
+    }
+
+    //  Métodos do tipo void não requerem declaração de retorno.
+    public void setRitmo(int novoValor) {
+        ritmo = novoValor;
+    }
+
+    public void setEquipamento(int novoValor) {
+        catraca = novoValor;
+    }
+
+    public void aumentarVelocidade(int incremento) {
+        velocidade += incremento;
+    }
+
+    public void diminuirVelocidade(int decremento) {
+        velocidade -= decremento;
+    }
+
+    public void setNome(String novoNome) {
+        nome = novoNome;
+    }
+
+    public String getNome() {
+        return nome; // retorna um dado do tipo String.
+    }
+
+    //Método para mostrar os valores dos atributos deste objeto.
+    @Override
+    public String toString() {
+        return "catraca: " + catraca +
+                " ritmo: " + ritmo +
+                " velocidade: " + velocidade +
+                " nome: " + nome;
+    }
+} // fim classe Bicicleta
+
+// Velocipede é uma subclasse de bicicleta.
+class Velocipede extends Bicicleta {
+    // (Velocípedes são bicicletas com rodas dianteiras grandes
+    // Elas não possuem catraca.) 
+
+    public Velocipede(int ritmoInicial, int velocidadeInicial){
+        // Chame o construtor do pai (construtor de Bicicleta) com o comando super.
+        super(ritmoInicial, velocidadeInicial, 0, "PennyFarthing");
+    }
+
+    // Você pode marcar um método que você está substituindo com uma @annotation
+    // Para aprender mais sobre o que são as annotations e sua finalidade
+    // dê uma olhada em: http://docs.oracle.com/javase/tutorial/java/annotations/
+    @Override
+    public void setEquipamento(int catraca) {
+        catraca = 0;
+    }
+
+}
+
+```
+
+## Leitura Recomendada
+
+Os links fornecidos aqui abaixo são apenas para ter uma compreensão do tema, use o Google e encontre exemplos específicos.
+
+Outros tópicos para pesquisar:
+
+* [Tutorial Java para Sun Trail / Oracle](http://docs.oracle.com/javase/tutorial/index.html) 
+
+* [Modificadores de acesso do Java](http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html)
+
+* [Coceitos de Programação Orientada à Objetos](http://docs.oracle.com/javase/tutorial/java/concepts/index.html): 
+    * [Herança](http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html)
+    * [Polimorfismo](http://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html)
+    * [Abstração](http://docs.oracle.com/javase/tutorial/java/IandI/abstract.html)
+
+* [Exceções](http://docs.oracle.com/javase/tutorial/essential/exceptions/index.html)
+
+* [Interfaces](http://docs.oracle.com/javase/tutorial/java/IandI/createinterface.html)
+
+* [Tipos Genéricos](http://docs.oracle.com/javase/tutorial/java/generics/index.html)
+
+* [Conversões de código Java](http://www.oracle.com/technetwork/java/codeconv-138413.html)
+
+Livros:
+
+* [Use a cabeça, Java] (http://www.headfirstlabs.com/books/hfjava/)
diff --git a/pt-br/javascript-pt.html.markdown b/pt-br/javascript-pt.html.markdown
new file mode 100644
index 00000000..406042fa
--- /dev/null
+++ b/pt-br/javascript-pt.html.markdown
@@ -0,0 +1,547 @@
+---
+language: javascript
+contributors:
+    - ["Adam Brenecki", "http://adam.brenecki.id.au"]
+    - ["Ariel Krakowski", "http://www.learneroo.com"]
+translators:
+    - ["Willian Justen", "http://willianjusten.com.br"]
+lang: pt-br
+---
+
+JavaScript foi criada por Brendan Eich, funcionário da Netscape na época, em 1995. Ela
+foi originalmente criada para ser uma linguagem de script para websites,
+complementando o uso de Java para aplicações web mais complexas, mas a sua
+integração com páginas web e seu suporte nativo nos browsers fez com que
+ela se tornasse mais comum que Java no frontend web.
+
+Javascript não é somente limitada a browsers web, existindo o Node.js,
+que é um projeto que fornece um interpretador baseado no motor V8 do Google 
+Chrome e está se tornando cada vez mais famoso.
+
+Feedback são muito apreciados! Você me encontrar em
+[@adambrenecki](https://twitter.com/adambrenecki), ou
+[adam@brenecki.id.au](mailto:adam@brenecki.id.au).
+
+```js
+// Comentários são como em C. Comentários de uma linha começam com duas barras,
+/* e comentários de múltplas linhas começam com barra-asterisco
+   e fecham com asterisco-barra */
+
+// comandos podem ser terminados com  ;
+facaAlgo();
+
+// ... mas eles não precisam ser, o ponto-e-vírgula é automaticamente
+// inserido quando há uma nova linha, exceto alguns casos.
+facaAlgo()
+
+// Como esses casos podem causar resultados inesperados, vamos continuar 
+// a usar ponto-e-vírgula neste guia.
+
+///////////////////////////////////
+// 1. Números, Strings e Operadores
+
+// Javascript tem um tipo de número (que é o 64-bit IEEE 754 double).
+// Doubles tem uma mantissa 52-bit, que é suficiente para guardar inteiros
+// acima de 9✕10¹⁵ precisamente.
+3; // = 3
+1.5; // = 1.5
+
+// A aritmética básica funciona como seria de se esperar.
+1 + 1; // = 2
+0.1 + 0.2; // = 0.30000000000000004
+8 - 1; // = 7
+10 * 2; // = 20
+35 / 5; // = 7
+
+// Inclusive divisão desigual.
+5 / 2; // = 2.5
+
+// Operadores Bitwise também funcionam; quando você faz uma operação bitwise
+// seu float é convertido para um int de até 32 bits.
+1 << 2; // = 4
+
+// A precedência é aplicada com parênteses.
+(1 + 3) * 2; // = 8
+
+// Existem três especiais valores não-é-número-real:
+Infinity; // resultado de 1/0
+-Infinity; // resultado de -1/0
+NaN; // resultado de 0/0
+
+// Existe também o tipo booleano.
+true;
+false;
+
+// Strings são criados com ' ou ".
+'abc';
+"Olá, mundo";
+
+// Negação usa o símbolo !
+!true; // = false
+!false; // = true
+
+// Igualdade é o sinal de ===
+1 === 1; // = true
+2 === 1; // = false
+
+// Desigualdade é o sinal de !==
+1 !== 1; // = false
+2 !== 1; // = true
+
+// Mais comparações
+1 < 10; // = true
+1 > 10; // = false
+2 <= 2; // = true
+2 >= 2; // = true
+
+// Strings são concatenadas com +
+"Olá " + "mundo!"; // = "Olá mundo!"
+
+// e comparadas com < e >
+"a" < "b"; // = true
+
+// A comparação de tipos não é feita com o uso de ==...
+"5" == 5; // = true
+null == undefined; // = true
+
+// ...a menos que use ===
+"5" === 5; // = false
+null === undefined; // = false 
+
+// ...isso pode resultar em comportamentos estranhos...
+13 + !0; // 14
+"13" + !0; // '13true'
+
+// Você pode acessar caracteres de uma String usando o `charAt`
+"Isto é uma String".charAt(0);  // = 'I'
+
+// ...ou usar `substring` para pegar pedaços maiores.
+"Olá mundo".substring(0, 3); // = "Olá"
+
+// `length` é uma propriedade, portanto não use ().
+"Olá".length; // = 3
+
+// Existe também o `null` e o `undefined`.
+null;      // usado para indicar um valor não considerado
+undefined; // usado para indicar um valor que não é a atualmente definido
+           // (entretando `undefined` é considerado de fato um valor
+
+// false, null, undefined, NaN, 0 and "" são valores falsos;
+// qualquer outro valor é verdadeiro
+// Note que 0 é falso e "0" é verdadeiro, até mesmo 0 == "0".
+
+///////////////////////////////////
+// 2. Variáveis, Arrays e Objetos
+
+// Variáveis são declaradas com a palavra-chave `var`. O Javascript é 
+// dinâmicamente tipado, portanto você não precisa especificar o tipo.
+// Atribuições usam um simples caracter de `=`.
+var someVar = 5;
+
+// se você deixar de colocar a palavra-chave var, você não irá receber um erro...
+someOtherVar = 10;
+
+// ...mas sua variável será criada no escopo global, não no escopo em que você
+// definiu ela.
+
+// Variáveis declaradas sem receberem um valor são definidas como `undefined`.
+var someThirdVar; // = undefined
+
+// Existe um shorthand para operações matemáticas em variáveis:
+someVar += 5; // equivalente a someVar = someVar + 5; someVar é 10 agora
+someVar *= 10; // agora someVar é 100
+
+// e um para adição e subtração de 1
+someVar++; // agora someVar é 101
+someVar--; // volta para 100
+
+// Arrays são listas ordenadas de valores, de qualquer tipo.
+var myArray = ["Olá", 45, true];
+
+// Seus membros podem ser acessados usando a sintaxe de colchetes.
+// O indíce de um Array começa pelo 0.
+myArray[1]; // = 45
+
+// Arrays são mutáveis e de tamanho variável.
+myArray.push("World");
+myArray.length; // = 4
+
+// Adicionar/modificar em um índice específico
+myArray[3] = "Hello";
+
+// Objetos de Javascript são equivalentes aos dicionários ou maps de outras
+// linguagens: uma coleção não ordenada de pares chave-valor.
+var myObj = {chave1: "Olá", chave2: "Mundo"};
+
+// Chaves são strings, mas as aspas não são necessárias se elas são
+// identificadores válidos no Javascript. Valores podem ser de qualquer tipo.
+var myObj = {myKey: "myValue", "my other key": 4};
+
+// Atributos de objetos também podem ser acessados com a sintaxe de colchetes.
+myObj["my other key"]; // = 4
+
+// ... ou usando a sintaxe de ponto, passando a chave que é um identificador
+// válido.
+myObj.myKey; // = "myValue"
+
+// Objetos são mutáveis, valores podem ser modificados e novas chaves 
+// adicionadas.
+myObj.myThirdKey = true;
+
+// Se você tentar acessar um valor que não foi determinado ainda, você irá
+// receber `undefined`.
+myObj.myFourthKey; // = undefined
+
+///////////////////////////////////
+// 3. Lógica e Estruturas de Controle
+
+// A sintaxe para essa seção é quase idêntica a maioria das linguagens.
+
+// The `if` structure works as you'd expect.
+// A estrutura `if` funciona como deveria ser.
+var count = 1
+if (count == 3){
+    // executa se count é 3
+} else if (count == 4){
+    // executa se count é 4
+} else {
+    // executa se count não é 3 nem 4
+}
+
+// Como se faz um `while`.
+while (true){
+    // Um loop infinito!
+}
+
+// Os loops do-while são como os loops de while, exceto quando eles sempre
+// executam pelo menos uma vez.
+do {
+    input = getInput();
+} while (!isValid(input))
+
+// The `for` loop is the same as C and Java:
+// initialisation; continue condition; iteration.
+
+// O loop `for` é o mesmo de C e Java:
+// inicialização, condição para continuar; iteração
+for (var i = 0; i < 5; i++){
+    // vai rodar cinco vezes
+}
+
+// && é o `e` lógico , || é o `ou` lógico
+if (house.size == "big" && house.colour == "blue"){
+    house.contains = "bear";
+}
+if (cor == "red" || cor == "blue"){
+    // cor é vermelha OU azul
+}
+
+// && e || "pequeno circuito", é útil para determinar valores padrões.
+var name = otherName || "padrão";
+
+// O `switch` checa pela igualdade com `===`.
+// Use `break` após cada `case`
+grade = 'B';
+switch (grade) {
+  case 'A':
+    console.log("Great job");
+    break;
+  case 'B':
+    console.log("OK job");
+    break;
+  case 'C':
+    console.log("You can do better");
+    break;
+  default:
+    console.log("Oy vey");
+    break;
+}
+
+
+///////////////////////////////////
+// 4. Funções, Escopos e Closures
+
+// Funções Javascript são declaradas com a palavra-chave `function`.
+function myFunction(thing){
+    return thing.toUpperCase();
+}
+myFunction("foo"); // = "FOO"
+
+// Repare que o valor a ser retornado deve começar na mesma linha que
+// a palavra-chave `return`, senão você sempre irá retornar `undefined` 
+// visto que o ponto-e-vírgula é inserido automáticamente nas quebras de 
+// linha. Preste atenção quando usar o estilo Allman.
+function myFunction()
+{
+    return // <- ponto-e-vírgula adicionado automaticamente aqui
+    {
+        thisIsAn: 'object literal'
+    }
+}
+myFunction(); // = undefined
+
+// Funções Javascript são objetos de primeira classe, portanto elas podem
+// ser atribuídas a nomes de variáveis e serem passadas para outras funções
+// como argumentos - por exemplo, quando criamos um manipulador de eventos:
+function myFunction(){
+    // este código será chamado em 5 segundos
+}
+setTimeout(myFunction, 5000);
+// Nota: `setTimeout` não é parte da linguagem Javascript, mas é provido pelos
+// browsers e o Node.js.
+
+// Objetos de funções não precisam nem serem declarados com nome - você pode 
+// escrever a definição de uma função anônima diretamente nos argumentos de 
+// outra função.
+setTimeout(function(){
+    // este código será chamado em 5 segundos
+}, 5000);
+
+// O Javascript tem escopo de função; as funções tem seu próprio escopo, 
+// mas outros blocos não.
+if (true){
+    var i = 5;
+}
+i; // = 5 - não `undefined` como você esperaria numa linguagem de blogo-escopo
+
+// Isso levou a padrão comum chamado de IIFE (Imediately Invoked Function 
+// Expression) ou (Expressão de Função Invocada Imediatamente), que previne
+// que variáveis temporárias vazem para o escopo global.
+(function(){
+    var temporary = 5;
+    // Nós podemos acessar o escopo global definindo o "objeto global", que
+    // no browser vai ser sempre `window`. O objeto global pode ter um nome
+    // diferente para ambiente não-browser como o Node.js.
+    window.permanent = 10;
+})();
+temporary; // levanta um erro de referência inexiste
+permanent; // = 10
+
+// Uma das principais características do Javascript é a closure. Que é
+// uma função definida dentro de outra função, a função interna pode acessar
+// todas as variáveis da função externa, mesmo depois da função de fora
+// finalizar sua execução.
+function sayHelloInFiveSeconds(name){
+    var prompt = "Hello, " + name + "!";
+
+    // Funções internas são colocadas no escopo local por padrão, assim como
+    // se fossem declaradas com `var`. 
+    function inner(){
+        alert(prompt);
+    }
+    setTimeout(inner, 5000);
+    // `setTimeout` é assíncrono, portanto a função `sayHelloInFiveSeconds`
+    // vai sair imediatamente, e o `setTimeout` irá chamar a interna depois.
+    // Entretanto. como a interna é fechada dentro de "sayHelloInFiveSeconds",
+    // a interna permanece podendo acessar a variável `prompt` quando depois
+    // de chamada.
+}
+sayHelloInFiveSeconds("Adam"); // Vai abrir um popup com "Hello, Adam!" em 5s
+
+///////////////////////////////////
+// 5. Mais sobre Objetos; Construtores e Prototypes
+
+// Objetos podem conter funções.
+var myObj = {
+    myFunc: function(){
+        return "Olá mundo!";
+    }
+};
+myObj.myFunc(); // = "Olá mundo!"
+
+// Quando uma função ligada a um objeto é chamada, ela pode acessar o objeto
+// da qual foi ligada usando a palavra-chave `this`. 
+myObj = {
+    myString: "Olá mundo!",
+    myFunc: function(){
+        return this.myString;
+    }
+};
+myObj.myFunc(); // = "Olá mundo!"
+
+// O `this` só funciona para dentro do escopo do objeto, portanto, se chamarmos 
+// um método do objeto fora de seu escopo, este não irá funcionar.
+var myFunc = myObj.myFunc;
+myFunc(); // = undefined
+
+// Inversamente, uma função pode ser atribuída a um objeto e ganhar a acesso
+// através do `this`, até mesmo se ela não for chamada quando foi definida.
+var myOtherFunc = function(){
+    return this.myString.toUpperCase();
+}
+myObj.myOtherFunc = myOtherFunc;
+myObj.myOtherFunc(); // = "OLÁ MUNDO!"
+
+// Nós podemos também especificar um contexto onde a função irá executar, 
+// usando o `call` ou `apply`.
+
+var anotherFunc = function(s){
+    return this.myString + s;
+}
+anotherFunc.call(myObj, " E Olá Lua!"); // = "Olá mundo! E Olá Lua!"
+
+// A função `apply` é praticamente a mesma coisa,  mas ela pega um array
+// como lista de argumentos.
+
+anotherFunc.apply(myObj, [" E Olá Sol!"]); // = "Olá mundo! E Olá Sol!"
+
+// Isto é util quando trabalhamos com uma função que aceita uma sequência de
+// argumentos e você quer passar um array.
+
+Math.min(42, 6, 27); // = 6
+Math.min([42, 6, 27]); // = NaN (uh-oh!)
+Math.min.apply(Math, [42, 6, 27]); // = 6
+
+// Mas, o `call` e `apply` são somente temporários. Quando você quiser que 
+// permaneça sempre no escopo, use `bind`.
+
+var boundFunc = anotherFunc.bind(myObj);
+boundFunc(" E Olá Saturno!"); // = "Olá mundo! E Olá Saturno!"
+
+// `bind` também pode ser usado para parcialmente aplicar (curry) uma função.
+
+var product = function(a, b){ return a * b; }
+var doubler = product.bind(this, 2);
+doubler(8); // = 16
+
+// Quando você invoca uma função com a palavra-chave `new`, um novo objeto
+// é criado, e fica disponível para a função pela palavra-chave `this`. 
+// Funções são desenhadas para serem invocadas como se invocam os construtores.
+
+var MyConstructor = function(){
+    this.myNumber = 5;
+}
+myNewObj = new MyConstructor(); // = {myNumber: 5}
+myNewObj.myNumber; // = 5
+
+// Todo objeto JavaScript possui um `prototype`. Quando você tenta acessar 
+// uma propriedade de um objeto que não existe no objeto atual, o interpretador
+// vai olhar imediatamente para o seu prototype.
+
+// Algumas implementações em JS deixam você acessar o objeto prototype com a 
+// propriedade mágica `__proto__`. Enquanto isso é util para explicar 
+// prototypes, não é parte de um padrão; nós vamos falar de algumas formas de 
+// usar prototypes depois.
+
+var myObj = {
+    myString: "Olá Mundo!"
+};
+var myPrototype = {
+    meaningOfLife: 42,
+    myFunc: function(){
+        return this.myString.toLowerCase()
+    }
+};
+
+myObj.__proto__ = myPrototype;
+myObj.meaningOfLife; // = 42
+
+// This works for functions, too.
+// Isto funciona para funções, também.
+myObj.myFunc(); // = "olá mundo!"
+
+// É claro, se sua propriedade não está em seu prototype, 
+// o prototype do prototype será procurado e por aí vai.
+myPrototype.__proto__ = {
+    myBoolean: true
+};
+myObj.myBoolean; // = true
+
+// Não há cópia envolvida aqui; cada objeto guarda uma referência do
+// prototype. Isso significa que podemos alterar o prototype e nossas mudanças
+// serão refletidas em qualquer lugar.
+myPrototype.meaningOfLife = 43;
+myObj.meaningOfLife; // = 43
+
+
+// Nós mencionamos que o `__proto__` não é uma forma padrão, e não há uma 
+// forma padrão de mudar o prototype de um objeto já existente. Entretanto, 
+// existem duas formas de se criar um objeto com um dado prototype.
+
+// A primeira forma é `Object.create`, que é uma adição recente do JS,
+// e ainda não está disponível em todas as implementações.
+var myObj = Object.create(myPrototype);
+myObj.meaningOfLife; // = 43
+
+// A segunda forma, que funciona em qualquer lugar, é feita com construtores.
+// Construtores tem uma propriedade chamada prototype. Este *não* é o prototype
+// do construtor em si; ao invés disso, ele é o prototype dos novos objetos
+// criados pelo construtor.
+MyConstructor.prototype = {
+    myNumber: 5,
+    getMyNumber: function(){
+        return this.myNumber;
+    }
+};
+var myNewObj2 = new MyConstructor();
+myNewObj2.getMyNumber(); // = 5
+myNewObj2.myNumber = 6
+myNewObj2.getMyNumber(); // = 6
+
+// Tipos originais da linguagem como strings e números também possuem
+// construtores equivalentes. 
+var myNumber = 12;
+var myNumberObj = new Number(12);
+myNumber == myNumberObj; // = true
+
+// Exceto, que eles não são totalmente equivalentes.
+typeof myNumber; // = 'number'
+typeof myNumberObj; // = 'object'
+myNumber === myNumberObj; // = false
+if (0){
+    // O código não vai executar, porque 0 é um valor falso.
+}
+
+// Entretanto, esses objetos encapsulados e as funções originais compartilham
+// um mesmo prototype, portanto você pode adicionar funcionalidades a uma string,
+// por exemplo.
+String.prototype.firstCharacter = function(){
+    return this.charAt(0);
+}
+"abc".firstCharacter(); // = "a"
+
+// Esse fato é usado para criar os chamados `polyfills`, que implementam
+// uma nova característica do Javascript em uma versão mais velha, para que
+// assim funcionem em ambientes mais velhos como browsers ultrapassados.
+
+// Havíamos mencionado que `Object.create` não estava ainda disponível em 
+// todos as implementações, mas nós podemos usá-lo com esse polyfill:
+if (Object.create === undefined){ // don't overwrite it if it exists
+    Object.create = function(proto){
+        // faz um construtor temporário com o prototype certo
+        var Constructor = function(){};
+        Constructor.prototype = proto;
+        // então utiliza o new para criar um objeto prototype apropriado
+        return new Constructor();
+    }
+}
+```
+
+## Leitura Adicional
+
+O [Mozilla Developer
+Network](https://developer.mozilla.org/en-US/docs/Web/JavaScript) dispõe de uma
+excelente documentação sobre Javascript e seu uso nos browsers. E mais, 
+é uma wiki, portanto conforme você vai aprendendo, mais você pode ir ajudando
+os outros compartilhando do seu conhecimento.
+
+[Uma re-introdução do JavaScript pela MDN]
+(https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript)
+cobre muito dos conceitos abordados aqui em mais detalhes. Este guia fala
+somente sobre a linguagem JavaScript em si; se você quiser aprender mais
+sobre e como usar o JavaScript em páginas na web, comece aprendendo sobre
+[Document Object
+Model](https://developer.mozilla.org/en-US/docs/Using_the_W3C_DOM_Level_1_Core)
+
+[Aprenda Javascript por Exemplos e com Desafios](http://www.learneroo.com/modules/64/nodes/350) é uma
+variação desse guia com desafios.
+
+[JavaScript Garden](http://bonsaiden.github.io/JavaScript-Garden/) é um guia 
+profundo de todas as partes do JavaScript.
+
+[JavaScript: The Definitive Guide](http://www.amazon.com/gp/product/0596805527/) é o guia clássico
+/ livro de referência. 
+
+Parte desse artigo foi adaptado do tutorial de Python do Louie Dinh que está
+nesse site e do [Tutorial de JS](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript)
+da Mozilla Developer Network.
diff --git a/pt-br/json-pt.html.markdown b/pt-br/json-pt.html.markdown
new file mode 100644
index 00000000..fc63b126
--- /dev/null
+++ b/pt-br/json-pt.html.markdown
@@ -0,0 +1,62 @@
+---
+language: json
+contributors:
+  - ["Anna Harren", "https://github.com/iirelu"]
+  - ["Marco Scannadinari", "https://github.com/marcoms"]
+translators:
+  - ["Miguel Araújo", "https://github.com/miguelarauj1o"]
+lang: pt-br
+filename: learnjson-pt.json
+---
+
+Como JSON é um formato de intercâmbio de dados, este será, muito provavelmente, o
+"Learn X in Y minutes" mais simples existente.
+
+JSON na sua forma mais pura não tem comentários em reais, mas a maioria dos analisadores 
+aceitarão comentários no estilo C (//, /\* \*/). Para os fins do presente, no entanto, 
+tudo o que é vai ser 100% JSON válido. Felizmente, isso meio que fala por si.
+
+
+```json
+{
+  "chave": "valor",
+  
+  "chaves": "deve ser sempre entre aspas (junto ou separado)",
+  "números": 0,
+  "strings": "Olá, mundo. Todo o padrão UNICODE é permitido, junto com \"escapando\".",
+  "possui booleano?": true,
+  "nada": null,
+
+  "número grande": 1.2e+100,
+
+  "objetos": {
+    "comentário": "A maior parte da sua estrutura virá de objetos.",
+
+    "array": [0, 1, 2, 3, "Arrays podem ter qualquer coisa em si.", 5],
+
+    "outro objeto": {
+      "ccomentário": "Estas coisas podem ser aninhadas, muito úteis."
+    }
+  },
+
+  "tolice": [
+    {
+      "fonte de potássio": ["bananas"]
+    },
+    [
+      [1, 0, 0, 0],
+      [0, 1, 0, 0],
+      [0, 0, 1, "neo"],
+      [0, 0, 0, 1]
+    ]
+  ],
+
+  "estilo alternativo": {
+  "comentário": "verificar isso!"
+  , "posição da vírgula": "não importa - enquanto é antes do valor, então é válido"
+  , "outro comentário": "que bom"
+  },
+
+  "que foi curto": "E, você está feito. Você já sabe tudo que JSON tem para oferecer.".
+}
+```
diff --git a/pt-br/markdown-pt.html.markdown b/pt-br/markdown-pt.html.markdown
new file mode 100644
index 00000000..4030ce3c
--- /dev/null
+++ b/pt-br/markdown-pt.html.markdown
@@ -0,0 +1,251 @@
+---
+language: markdown
+contributors:
+    - ["Dan Turkel", "http://danturkel.com/"]
+translators:
+    - ["Miguel Araújo", "https://github.com/miguelarauj1o"]
+lang: pt-br    
+filename: learnmarkdown-pt.md
+---
+
+Markdown foi criado por John Gruber in 2004. Originado para ser fácil de ler e 
+escrever sintaxe que converte facilmente em HTML (hoje, suporta outros formatos também).
+
+Dê-me feedback tanto quanto você quiser! / Sinta-se livre para a garfar (fork) e 
+puxar o projeto (pull request)
+
+```markdown
+<!-- Markdown é um superconjunto do HTML, de modo que qualquer arvquivo HTML é 
+um arquivo Markdown válido, isso significa que nós podemos usar elementos HTML 
+em Markdown, como o elemento de comentário, e eles não serão afetados pelo analisador
+de remarcação. No entanto, se você criar um elemento HTML em seu arquivo Markdown, você
+não pode usar sintaxe remarcação dentro desse conteúdo do elemento.-->
+
+<!--Markdown também varia de implementação de um analisador para uma próxima.
+Este guia vai tentar esclarecer quando as características são universais, ou quando eles são 
+específico para um determinado parser -->
+
+<!-- Cabeçalhos -->
+<!-- Você pode criar elementos HTML <h1> até <h6> facilmente antecedendo o texto
+que deseja estar nesse elemento por um número de hashes (#) -->
+# Isto é um cabeçalho <h1>
+## Isto é um cabeçalho <h2>
+### Isto é um cabeçalho <h3>
+#### Isto é um cabeçalho <h4>
+##### Isto é um cabeçalho <h5>
+###### Isto é um cabeçalho <h6>
+
+<!-- Markdown também nos fornece duas maneiras alternativas de indicar h1 e h2 -->
+Isto é um cabeçalho h1
+======================
+
+Isto é um cabeçalho h2
+----------------------
+
+<!-- Estilos de texto simples --> 
+<!-- O texto pode ser facilmente denominado como remarcação itálico, negrito ou tachado usando -->
+
+*Este texto está em itálico*
+_E este também está._
+
+**Este texto está em negrito**
+__E este também está._
+
+***Este texto está em negrito e itálico.***
+**_E este também está_**
+*--Danouse! Este também__*
+
+<!-- Em GitHub Flavored Markdown, que é usado para processar arquivos Markdown 
+Github, nós também temos: --> 
+
+~~Este texto é processado com tachado.~~
+
+<!-- Os parágrafos estão uma ou várias linhas adjacentes de texto separadas por 
+uma ou múltiplas linhas em branco. -->
+
+Este é um parágrafo. Eu estou digitando em um parágrafo, não é legal?
+
+Agora, eu estou no parágrado 2.
+... Ainda continuo no parágrafo 2! :)
+
+Eu estou no parágrafo três.
+
+<!-- Se você quiser inserir uma tag HTML <br />, você pode acabar com um parágrafo 
+com dois ou mais espaços e, em seguida, começar um novo parágrafo -->
+
+Termino com dois espaços (destacar-me para vê-los). 
+
+Há um <br /> acima de mim!
+
+<!-- Bloco de citações são fáceis e feito com o caractere >. -->
+
+> Este é um bloco de citação. Você pode 
+> Enrolar manualmente suas linhas e colocar um `>` antes de cada linha ou você pode
+> deixar suas linhas ficarem muito longas e enrolar por conta própria. Não faz diferença, 
+> desde que eles começam com um `>`.
+
+> Você também pode usar mais de um nível 
+>> De recuo? 
+> Como pura é isso?
+
+<!-- Listas --> 
+<!-- As listas não ordenadas podem ser feitas usando asteriscos, positivos ou hífens -->
+
+* Item
+* Item
+* Outro item
+
+ou
+
++ Item
++ Item
++ Outro item
+
+ou
+
+- Item
+- Item
+- Um último item
+
+<!-- Listas ordenadas são feitas com um número seguido por um ponto -->
+
+1. Item um
+2. Item dois
+3. Tem três
+
+<!-- Você não tem poder para rotular os itens corretamente e a remarcação será ainda
+tornar os números em ordem, mas isso pode não ser uma boa idéia -->
+
+1. Item um
+1. Item dois
+1. Item três
+<!-- (Isto é processado da mesma forma que o exemplo acima) -->
+
+<!-- Você também pode usar subtítulos -->
+
+1. Item um
+2. Item dois
+3. Item três
+    * Sub-item
+    * Sub-item
+4. Item quatro
+
+<!-- blocos de código --> 
+<!-- Você pode indicar um bloco de código (que utiliza o elemento <code>) pelo recuo
+uma linha com quatro espaços ou uma guia -->
+
+	Isto é código
+	É assim, sacou?
+
+<!-- Você pode também re-guia (ou adicionar mais quatro espaços adicionais) para o recuo 
+dentro do seu código -->
+
+	my_array.each do |item|
+        puts item
+    end	
+
+<!-- Código embutido pode ser criada usando o caractere de crase ` -->
+
+John não sabia nem o que o função 'goto()' fazia!
+
+<!-- Em Github Flavored Markdown, você pode usar uma sintaxe especial para o código -->
+
+\`\`\`ruby <!-- exceto remover essas barras invertidas quando você faz isso, apenas ```
+ruby! --> 
+def foobar
+    puts "Hello world!"
+end
+\`\`\` <!-- Aqui também, não barras invertidas, apenas ``` -->
+
+<-- O texto acima não requer recuo, mas o Github vai usar a sintaxe 
+destacando do idioma que você especificar após a ``` -->
+
+<!-- Regra Horizontal (<hr />) --> 
+<!-- Regras horizontais são facilmente adicionados com três ou mais asteriscos ou hífens,
+com ou sem espaços. -->
+
+***
+---
+- - - 
+****************
+
+<!-- Links --> 
+<!-- Uma das melhores coisas sobre a remarcação é o quão fácil é fazer ligações. Colocar 
+o texto a ser exibido entre parênteses rígidos [] seguido pela url em parênteses () -->
+
+[Click aqui!](http://test.com/)
+
+<!-- Você também pode adicionar um título link usando aspas dentro dos parênteses -->
+
+[Click aqui!](http://test.com/ "Link para Test.com")
+
+<!-- Caminhos relativos funcionam também. -->
+
+[Ir para música](/música/).
+
+<!-- Markdown também suporta ligações de estilo de referência -->
+
+[Clique neste link] [link1] para mais informações sobre isso!
+[Além disso, verifique este link] [foobar] se você quiser.
+
+[link1]: http://test.com/ "Legal!"
+[foobar]: http://foobar.biz/ "OK!"
+
+<!-- O título também pode estar entre aspas simples ou entre parênteses, ou omitido 
+inteiramente. As referências podem estar em qualquer lugar no documento e os IDs de referência 
+pode ser qualquer um, desde que eles são únicos. -->
+
+<!-- Existe também o "nomear implícita", que permite que você use o texto do link como o id --> 
+
+[Este] [] é um link. 
+
+[este]: http://thisisalink.com/ 
+
+<!-- Mas não são usados normalmente--> 
+
+<!-- Imagens --> 
+<!-- As imagens são feitas da mesma forma que as ligações, mas com um ponto de exclamação na frente! -->
+
+![Este é pairar-texto (texto alternativo) para minha imagem](http://imgur.com/myimage.jpg "Um título opcional") 
+
+<!-- E estilo de referência funciona como esperado --> 
+
+![Este é o pairar-texto.][Myimage] 
+
+[myimage]: relative/urls/legal/image.jpg "se você precisa de um título, é aqui" 
+
+<!-- Miscelânea --> 
+<!-- Auto-links --> 
+
+<http://testwebsite.com/> é equivalente a 
+[http://testwebsite.com/](http://testwebsite.com/) 
+
+<!-- Auto-links para e-mails --> 
+
+<foo@bar.com> 
+
+<!-- Escapando caracteres --> 
+
+Quero digitar * Este texto entre asteriscos *, mas eu não quero que ele seja 
+em itálico, então eu faço o seguinte: \*Este texto entre asteriscos \*.
+
+<!-- Tabelas --> 
+<!-- Tabelas estão disponíveis apenas no Github Flavored Markdown e são ligeiramente 
+complicadas, mas se você realmente quer: -->
+
+| Col1         | Col2     | Col3          |
+| :----------- | :------: | ------------: |
+| esquerda-alin| Centrado | direita-alinh |
+| blah         | blah     | blah          |
+
+<!-- Ou, para os mesmos resultados -->
+
+Col 1 | Col2 | Col3
+:-- | :-: | --:
+Ugh isso é tão feio | faça isto | parar
+
+<!-- O fim! -->
+
+```
+Para mais informações, confira o post oficial de John Gruber de sintaxe [aqui](http://daringfireball.net/projects/markdown/syntax)
+e de Adam Pritchard grande cheatsheet [aqui](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet).
diff --git a/pt-br/perl-pt.html.markdown b/pt-br/perl-pt.html.markdown
new file mode 100644
index 00000000..cc07a2ec
--- /dev/null
+++ b/pt-br/perl-pt.html.markdown
@@ -0,0 +1,166 @@
+---
+name: perl
+category: language
+language: perl
+filename: learnperl-pt.pl
+contributors:
+    - ["Korjavin Ivan", "http://github.com/korjavin"]
+translators:
+    - ["Miguel Araújo", "https://github.com/miguelarauj1o"]
+lang: pt-br
+---
+
+Perl 5 é, uma linguagem de programação altamente capaz, rica em recursos, com mais de 25 anos de desenvolvimento.
+
+Perl 5 roda em mais de 100 plataformas, de portáteis a mainframes e é adequada tanto para prototipagem rápida, quanto em projetos de desenvolvimento em grande escala.
+
+```perl
+# Comentários de uma linha começam com um sinal de número.
+
+#### Tipos de variáveis em Perl
+
+# Variáveis iniciam com um sigilo, que é um símbolo que mostra o tipo.
+# Um nome de variável válido começa com uma letra ou sublinhado,
+# seguido por qualquer número de letras, números ou sublinhados.
+
+### Perl has three main variable types: $scalar, @array, e %hash.
+
+## Scalars
+# Um scalar representa um valor único:
+my $animal = "camelo";
+my $resposta = 42;
+
+# Valores scalar podem ser strings, inteiros ou números ponto-flutuantes e
+# Perl vai automaticamente converter entre eles quando for preciso.
+
+## Arrays
+# Um array representa uma lista de valores:
+my @animais = ("camelo", "vaca", "boi");
+my @números = (23, 42, 69);
+my @misturado   = ("camelo", 42, 1.23);
+
+## Hashes
+# Um hash representa um conjunto de pares chave/valor:
+
+my %fruta_cor = ("maçã", "vermelho", "banana", "amarelo");
+
+# Você pode usar o espaço em branco e o operador "=>" para colocá-los de
+# maneira mais agradável:
+
+my %fruta_cor = (
+  maçã  => "vermelho",
+  banana => "amarelo",
+);
+
+# Scalars, arrays and hashes são documentados mais profundamentes em perldata.
+# (perldoc perldata).
+
+# Mais tipos de dados complexos podem ser construídas utilizando referências,
+# o que permite que você crie listas e hashes dentro de listas e hashes.
+
+#### Condicionais e construtores de iteração
+
+# Perl possui a maioria das construções condicionais e de iteração habituais.
+
+if ($var) {
+  ...
+} elsif ($var eq 'bar') {
+  ...
+} else {
+  ...
+}
+
+unless (condição) {
+  ...
+}
+# Isto é fornecido como uma versão mais legível de "if (!condition)"
+
+# A forma Perlish pós-condição
+print "Yow!" if $zippy;
+print "Nós não temos nenhuma banana" unless $bananas;
+
+#  while
+while (condição) {
+  ...
+}
+
+# for
+for (my $i = 0; $i < $max; $i++) {
+  print "valor é $i";
+}
+
+for (my $i = 0; $i < @elements; $i++) {
+  print "Elemento atual é " . $elements[$i];
+}
+
+for my $element (@elements) {
+  print $element;
+}
+
+# implícito
+
+for (@elements) {
+  print;
+}
+
+#### Expressões regulares
+
+# O suporte a expressões regulares do Perl é ao mesmo tempo amplo e profundo,
+# e é objeto de longa documentação em perlrequick, perlretut, e em outros
+# lugares. No entanto, em suma:
+
+# Casamento simples
+if (/foo/)       { ... }  # verdade se $_ contém "foo"
+if ($a =~ /foo/) { ... }  # verdade se $a contém "foo"
+
+# Substituição simples
+
+$a =~ s/foo/bar/;         # substitui foo com bar em $a
+$a =~ s/foo/bar/g;        # substitui TODAS AS INSTÂNCIAS de foo com bar em $a
+
+#### Arquivos e I/O
+
+# Você pode abrir um arquivo para entrada ou saída usando a função "open()".
+
+open(my $in,  "<",  "input.txt")  ou desistir "Não pode abrir input.txt: $!";
+open(my $out, ">",  "output.txt") ou desistir "Não pode abrir output.txt: $!";
+open(my $log, ">>", "my.log")     ou desistir "Não pode abrir my.log: $!";
+
+# Você pode ler de um arquivo aberto usando o operador "<>". No contexto
+# scalar, ele lê uma única linha do arquivo, e em contexto de lista lê o
+# arquivo inteiro, atribuindo cada linha a um elemento da lista:
+
+my $linha  = <$in>;
+my @linhas = <$in>;
+
+#### Escrevendo subrotinas
+
+# Escrever subrotinas é fácil:
+
+sub logger {
+  my $mensagem = shift;
+
+  open my $arquivo, ">>", "my.log" or die "Não poderia abrir my.log: $!";
+
+  print $arquivo $ensagem;
+}
+
+# Agora nós podemos usar a subrotina como qualquer outra função construída:
+
+logger("Nós temos uma subrotina de log!");
+```
+
+#### Usando módulos Perl
+
+Módulos Perl provê uma lista de recursos para lhe ajudar a evitar redesenhar
+a roda, e tudo isso pode ser baixado do CPAN (http://www.cpan.org/). Um número
+de módulos populares podem ser incluídos com a própria distribuição do Perl.
+
+perlfaq contém questões e respostas relacionadas a muitas tarefas comuns, e frequentemente provê sugestões para um bom números de módulos CPAN.
+
+#### Leitura Adicional
+
+ - [perl-tutorial](http://perl-tutorial.org/)
+ - [Learn at www.perl.com](http://www.perl.org/learn.html)
+ - [perldoc](http://perldoc.perl.org/)
+ - and perl built-in : `perldoc perlintro`
diff --git a/pt-br/php-pt.html.markdown b/pt-br/php-pt.html.markdown
new file mode 100644
index 00000000..0e710742
--- /dev/null
+++ b/pt-br/php-pt.html.markdown
@@ -0,0 +1,700 @@
+---
+language: PHP
+contributors:
+    - ["Malcolm Fell", "http://emarref.net/"]
+    - ["Trismegiste", "https://github.com/Trismegiste"]
+translators:
+    - ["Abdala Cerqueira", "http://abda.la"]
+    - ["Raquel Diniz", "http://twitter.com/raquelrdiniz"]
+lang: pt-br
+filename: learnphp-pt.php
+---
+
+Este documento descreve PHP 5+.
+
+```php
+<?php // O código PHP deve estar incluso na tag <?php
+
+// Se o arquivo PHP só contém código PHP, a melhor prática
+// é omitir a tag de fechamento PHP.
+
+// Duas barras iniciam o comentário de uma linha.
+
+# O hash (aka pound symbol) também inicia, mas // é mais comum
+
+/*
+     O texto envolto por barra-asterisco e asterisco-barra
+     faz um comentário de múltiplas linhas
+*/
+
+// Utilize "echo" ou "print" para imprimir a saída
+print('Olá '); // Imprime "Olá " sem quebra de linha
+
+// () são opcionais para print e echo
+echo "Mundo\n"; // Imprime "Mundo" com quebra de linha
+// (Todas as declarações devem terminar com um ponto e vírgula)
+
+// Qualquer coisa fora da tag <?php é impresso automaticamente
+?>
+Olá mundo novamente!
+<?php
+
+
+/************************************
+ * Tipos e variáveis
+ */
+
+// Variáveis começam com o símbolo $.
+// Um nome de variável válido se inicia com uma letra ou sublinhado,
+// seguido por qualquer quantidade de letras, números ou sublinhados.
+
+// Valores booleanos não diferenciam maiúsculo de minúsculo (case-insensitive)
+$boolean = true;  // ou TRUE ou True
+$boolean = false; // ou FALSE ou False
+
+// Inteiros
+$int1 = 12;   // => 12
+$int2 = -12;  // => -12
+$int3 = 012;  // => 10 (um 0 denota um número octal)
+$int4 = 0x0F; // => 15 (um 0x denota um literal hex)
+
+// Flutuantes - Floats (aka doubles)
+$float = 1.234;
+$float = 1.2e3;
+$float = 7E-10;
+
+// Excluir variável
+unset($int1)
+
+// Aritmética
+$soma      = 1 + 1; // 2
+$diferenca = 2 - 1; // 1
+$produto   = 2 * 2; // 4
+$quociente = 2 / 1; // 2
+
+// Taquigrafia aritmética
+$numero = 0;
+$numero += 1;      // Incrementa $number em 1
+echo $numero++;    // Imprime 1 (incrementa após a avaliação)
+echo ++$numero;    // Imprime 3 (incrementa antes da avaliação)
+$numero /= $float; // Divide e atribui o quociente de $numero
+
+// Strings podem ser colocadas entre aspas simples
+$sgl_quotes = '$String'; // => '$String'
+
+// Evite o uso de aspas duplas, exceto para incorporar outras variáveis
+$dbl_quotes = "Esta é uma $sgl_quotes."; // => 'Esta é uma $String.'
+
+// Os caracteres especiais só são escapados entre aspas duplas
+$escapado    = "Este contém um \t caractere tab.";
+$naoescapado = 'Este contém somente a barra e o t: \t';
+
+// Coloque uma variável entre chaves se necessário
+$dinheiro = "Eu tenho $${numero} no banco.";
+
+// Desde o PHP 5.3, nowdocs podem ser usados para múltiplas linhas sem análise
+$nowdoc = <<<'FIM'
+múltiplas linhas
+string
+FIM;
+
+// Heredocs farão a análise
+$heredoc = <<<FIM
+múltiplas linhas
+$sgl_quotes
+FIM;
+
+// Concatenação de string é feita com .
+echo 'Esta string ' . 'é concatenada';
+
+
+/********************************
+ * Constantes
+ */
+
+// Uma constante é definida usando define()
+// e nunca pode ser mudada durante a execução!
+
+// Um nome de constante válida começa com uma letra ou sublinhado,
+// seguido por qualquer quantidade de letras, números ou sublinhados.
+define("FOO",     "alguma coisa");
+
+// Acesso a uma constante é possível usando diretamente o nome escolhido
+echo 'Isto sairá '.FOO;
+
+
+/********************************
+ * Arrays
+ */
+
+// Todos os arrays em PHP são arrays associativos (hashmaps),
+
+// Funciona com todas as versões do PHP
+$associativo = array('Um' => 1, 'Dois' => 2, 'Tres' => 3);
+
+// PHP 5.4 introduziu uma nova sintaxe
+$associativo = ['Um' => 1, 'Dois' => 2, 'Tres' => 3];
+
+echo $associativo['Um']; // imprime 1
+
+// Uma lista de literais atribui chaves inteiras implicitamente
+$array = ['Um', 'Dois', 'Tres'];
+echo $array[0]; // => "Um"
+
+// Adiciona um elemento no final do array
+$array[] = 'Quatro';
+
+// Remove um elemento do array
+unset($array[3]);
+
+/********************************
+ * Saída
+ */
+
+echo('Olá Mundo!');
+// Imprime Olá Mundo! para stdout.
+// Stdout é uma página web se executado em um navegador.
+
+print('Olá Mundo!'); // O mesmo que o echo
+
+// echo é atualmente um construtor de linguagem, então você pode 
+// remover os parênteses.
+echo 'Olá Mundo!';
+print 'Olá Mundo!'; // O print também é
+
+$paragrafo = 'parágrafo';
+
+echo 100;        // Imprime valores escalares diretamente
+echo $paragrafo; // ou variáveis
+
+// Se a abertura de tags curtas está configurada, ou sua versão do PHP é
+// 5.4.0 ou maior, você pode usar a sintaxe de echo curto
+?>
+<p><?= $paragrafo ?></p>
+<?php
+
+$x = 1;
+$y = 2;
+$x = $y; // $x agora contém o mesmo valor de $y
+$z = &$y;
+// $z agora contém uma referência para $y. Mudando o valor de
+// $z irá mudar o valor de $y também, e vice-versa.
+// $x irá permanecer inalterado com o valor original de $y
+
+echo $x; // => 2
+echo $z; // => 2
+$y = 0;
+echo $x; // => 2
+echo $z; // => 0
+
+// Despeja tipos e valores de variável para o stdout
+var_dump($z); // imprime int(0)
+
+// Imprime variáveis para stdout em formato legível para humanos
+print_r($array); // imprime: Array ( [0] => Um [1] => Dois [2] => Tres )
+
+/********************************
+ * Lógica
+ */
+$a = 0;
+$b = '0';
+$c = '1';
+$d = '1';
+
+// assert lança um aviso se o seu argumento não é verdadeiro
+
+// Estas comparações serão sempre verdadeiras, mesmo que os tipos 
+// não sejam os mesmos.
+assert($a == $b); // igualdade
+assert($c != $a); // desigualdade
+assert($c <> $a); // alternativa para desigualdade
+assert($a < $c);
+assert($c > $b);
+assert($a <= $b);
+assert($c >= $d);
+
+// A seguir, só serão verdadeiras se os valores correspondem e são do mesmo tipo.
+assert($c === $d);
+assert($a !== $d);
+assert(1 == '1');
+assert(1 !== '1');
+
+// As variáveis podem ser convertidas entre tipos, dependendo da sua utilização.
+
+$inteiro = 1;
+echo $inteiro + $inteiro; // => 2
+
+$string = '1';
+echo $string + $string; // => 2 (strings são coagidas para inteiros)
+
+$string = 'one';
+echo $string + $string; // => 0
+// Imprime 0 porque o operador + não pode fundir a string 'um' para um número
+
+// Tipo de fundição pode ser utilizado para tratar uma variável 
+// como um outro tipo
+
+$booleano = (boolean) 1; // => true
+
+$zero = 0;
+$booleano = (boolean) $zero; // => false
+
+// Há também funções dedicadas para fundir a maioria dos tipos
+$inteiro = 5;
+$string = strval($inteiro);
+
+$var = null; // valor Null
+
+
+/********************************
+ * Estruturas de controle
+ */
+
+if (true) {
+    print 'Eu fico impresso';
+}
+
+if (false) {
+    print 'Eu não\'t';
+} else {
+    print 'Eu fico impresso';
+}
+
+if (false) {
+    print 'Não fica impresso';
+} elseif(true) {
+    print 'Fica';
+}
+
+// operadores ternários
+print (false ? 'Não fica impresso' : 'Fica');
+
+$x = 0;
+if ($x === '0') {
+    print 'Não imprime';
+} elseif($x == '1') {
+    print 'Não imprime';
+} else {
+    print 'Imprime';
+}
+
+
+
+// Esta sintaxe alternativa é útil para modelos (templates)
+?>
+
+<?php if ($x): ?>
+Isto é exibido se o teste for verdadeiro.
+<?php else: ?>
+Isto é apresentado caso contrário.
+<?php endif; ?>
+
+<?php
+
+// Use switch para salvar alguma lógica.
+switch ($x) {
+    case '0':
+        print 'Switch faz coerção de tipo';
+        break; // Você deve incluir uma pausa, ou você vai cair
+               // no caso 'dois' e 'tres'
+    case 'dois':
+    case 'tres':
+        // Faz alguma coisa, se a variável é 'dois' ou 'tres'
+        break;
+    default:
+        // Faz algo por padrão
+}
+
+// While, do...while e for são repetições provavelmente familiares
+$i = 0;
+while ($i < 5) {
+    echo $i++;
+}; // Imprime "01234"
+
+echo "\n";
+
+$i = 0;
+do {
+    echo $i++;
+} while ($i < 5); // Imprime "01234"
+
+echo "\n";
+
+for ($x = 0; $x < 10; $x++) {
+    echo $x;
+} // Imprime "0123456789"
+
+echo "\n";
+
+$rodas = ['bicicleta' => 2, 'carro' => 4];
+
+// Repetições foreach podem iterar sobre arrays
+foreach ($rodas as $contador_rodas) {
+    echo $contador_rodas;
+} // Imprime "24"
+
+echo "\n";
+
+// Você pode iterar sobre as chaves, bem como os valores
+foreach ($rodas as $veiculo => $contador_rodas) {
+    echo "O $veiculo tem $contador_rodas rodas";
+}
+
+echo "\n";
+
+$i = 0;
+while ($i < 5) {
+    if ($i === 3) {
+        break; // Sai da repetição
+    }
+    echo $i++;
+} // Imprime "012"
+
+for ($i = 0; $i < 5; $i++) {
+    if ($i === 3) {
+        continue; // Ignora esta iteração da repetição
+    }
+    echo $i;
+} // Imprime "0124"
+
+
+/********************************
+ * Functions
+ */
+
+// Define a função com "function":
+function minha_funcao () {
+  return 'Olá';
+}
+
+echo minha_funcao(); // => "Olá"
+
+// Um nome de função válido começa com uma letra ou sublinhado,
+// seguido por qualquer quantidade de letras, números ou sublinhados.
+
+function adicionar($x, $y = 1) { // $y é opcional e o valor padrão é 1
+  $resultado = $x + $y;
+  return $resultado;
+}
+
+echo adicionar(4); // => 5
+echo adicionar(4, 2); // => 6
+
+// $resultado não é acessível fora da função
+// print $resultado; // Dá uma aviso.
+
+// Desde o PHP 5.3 você pode declarar funções anônimas
+$inc = function ($x) {
+  return $x + 1;
+};
+
+echo $inc(2); // => 3
+
+function foo ($x, $y, $z) {
+  echo "$x - $y - $z";
+}
+
+// Funções podem retornar funções
+function bar ($x, $y) {
+  // Utilize 'use' para trazer variáveis de fora
+  return function ($z) use ($x, $y) {
+    foo($x, $y, $z);
+  };
+}
+
+$bar = bar('A', 'B');
+$bar('C'); // Imprime "A - B - C"
+
+// Você pode chamar funções nomeadas usando strings
+$nome_funcao = 'add';
+echo $nome_funcao(1, 2); // => 3
+// Útil para dinamicamente determinar qual função será executada.
+// Ou utilize call_user_func(callable $callback [, $parameter [, ... ]]);
+
+/********************************
+ * Includes (Incluir)
+ */
+
+<?php
+// PHP dentro de arquivos incluídos também deve começar com uma tag 
+// de abertura do PHP.
+
+include 'meu-arquivo.php';
+// O código meu-arquivo.php já está disponível no escopo atual.
+// Se o arquivo não pode ser incluído (por exemplo, arquivo não encontrado), 
+//um aviso é emitido.
+
+include_once 'meu-arquivo.php';
+// Se o código no meu-arquivo.php foi incluído em outro lugar, ele não vai
+// ser incluído novamente. Isso evita vários erros de declaração de classe
+
+require 'meu-arquivo.php';
+require_once 'meu-arquivo.php';
+// Faz o mesmo que o include(), exceto que o require() irá causar um erro fatal
+// se o arquivo não puder ser incluído
+
+// Conteúdo de meu-include.php:
+<?php
+
+return 'Qualquer coisa que você quiser.';
+// Fim do arquivo
+
+// Includes e requires também podem retornar um valor.
+$valor = include 'meu-include.php';
+
+// Arquivos são incluídos com base no caminho determinado ou,
+// se este não for passado, com base na diretiva de configuração include_path.
+// Se o arquivo não é encontrado no include_path, o include vai finalmente
+// verificar no próprio diretório do script chamado e no diretório
+// de trabalho atual antes de falhar.
+/* */
+
+/********************************
+ * Classes
+ */
+
+// As classes são definidas com a palavra-chave class
+
+class MinhaClasse
+{
+    const MINHA_CONST      = 'valor'; // Uma constante
+
+    static $valorEstatico   = 'estatico';
+
+    // Variáveis estáticas e sua visibilidade
+    public static $valorEstaticoPublico = 'estaticoPublico';
+    // Acessível somente dentro da classe
+    private static $valorEstaticoPrivado = 'estaticoPrivado';
+    // Acessível a partir da classe e subclasses
+    protected static $valorEstaticoProtegido = 'estaticoProtegido';
+
+    // Propriedades devem declarar a sua visibilidade
+    public $propriedade    = 'publica';
+    public $propInstancia;
+    protected $prot = 'protegida'; // Acessível a partir da classe e subclasses
+    private $priv   = 'privada';   // Acessível somente dentro da classe
+
+    // Criar um construtor com o __construct
+    public function __construct($propInstancia) {
+        // Acesse variável de instância utilizando $this
+        $this->propInstancia = $propInstancia;
+    }
+
+    // Métodos são declarados como funções dentro de uma classe
+    public function meuMetodo()
+    {
+        print 'MinhaClasse';
+    }
+
+    //palavra-chave final faz uma função não poder ser sobrescrita
+    final function voceNaoPodeMeSobrescrever()
+    {
+    }
+
+/*
+ * Declarando propriedades ou métodos de classe como estáticos faz deles 
+ * acessíveis sem precisar instanciar a classe. A propriedade declarada
+ * como estática não pode ser acessada com um objeto
+ * instanciado da classe (embora métodos estáticos possam).
+*/
+
+    public static function meuMetodoEstatico()
+    {
+        print 'Eu sou estatico';
+    }
+}
+
+echo MinhaClasse::MINHA_CONST;    // Imprime 'valor';
+echo MinhaClasse::$valorEstatico; // Imprime 'estatico';
+MinhaClasse::meuMetodoEstatico(); // Imprime 'Eu sou estatico';
+
+// Instantiate classes using new
+$minha_classe = new MinhaClasse('Uma propriedade de instância');
+// Os parênteses são opcionais, se não passar algum argumento.
+
+// Acesse membros da classe utilizando ->
+echo $minha_classe->propriedade;  // => "publica"
+echo $minha_classe->instanceProp; // => "Uma propriedade de instância"
+$minha_classe->meuMetodo();       // => "MinhaClasse"
+
+
+// Estender classes usando "extends"
+class MinhaOutraClasse extends MinhaClasse
+{
+    function imprimePropriedadeProtegida()
+    {
+        echo $this->prot;
+    }
+
+    // Sobrescrever um método
+    function meuMetodo()
+    {
+        parent::meuMetodo();
+        print ' > MinhaOutraClasse';
+    }
+}
+
+$minha_outra_classe = new MinhaOutraClasse('Propriedade de instância');
+$minha_outra_classe->imprimePropriedadeProtegida(); // => Prints "protegida"
+$minha_outra_classe->myMethod(); // Prints "MinhaClasse > MinhaOutraClasse"
+
+final class VoceNaoPodeMeEstender
+{
+}
+
+// Você pode usar "métodos mágicos" para criar getters e setters
+class MinhaClasseMapa
+{
+    private $propriedade;
+
+    public function __get($chave)
+    {
+        return $this->$chave;
+    }
+
+    public function __set($chave, $valor)
+    {
+        $this->$chave = $valor;
+    }
+}
+
+$x = new MinhaClasseMapa();
+echo $x->propriedade; // Irá usar o método __get()
+$x->propriedade = 'Algo'; // Irá usar o método __set()
+
+// Classes podem ser abstratas (usando a palavra-chave abstract) ou
+// implementar interfaces (usando a palavra-chave implements).
+// Uma interface é declarada com a palavra-chave interface.
+
+interface InterfaceUm
+{
+    public function fazAlgo();
+}
+
+interface InterfaceDois
+{
+    public function fazOutraCoisa();
+}
+
+// interfaces podem ser estendidas
+interface InterfaceTres extends InterfaceDois
+{
+    public function fazOutroContrato();
+}
+
+abstract class MinhaClasseAbstrata implements InterfaceUm
+{
+    public $x = 'fazAlgo';
+}
+
+class MinhaClasseConcreta extends MinhaClasseAbstrata implements InterfaceDois
+{
+    public function fazAlgo()
+    {
+        echo $x;
+    }
+
+    public function fazOutraCoisa()
+    {
+        echo 'fazOutraCoisa';
+    }
+}
+
+
+// Classes podem implementar mais de uma interface
+class UmaOutraClasse implements InterfaceUm, InterfaceDois
+{
+    public function fazAlgo()
+    {
+        echo 'fazAlgo';
+    }
+
+    public function fazOutraCoisa()
+    {
+        echo 'fazOutraCoisa';
+    }
+}
+
+
+/********************************
+ * Traits (Traços)
+ */
+
+// Traits estão disponíveis a partir de PHP 5.4.0 e 
+// são declarados usando "trait"
+
+trait MeuTraco
+{
+    public function meuMetodoDeTraco()
+    {
+        print 'Eu tenho MeuTraco';
+    }
+}
+
+class MinhaClasseTracada
+{
+    use MeuTraco;
+}
+
+$cls = new MinhaClasseTracada();
+$cls->meuMetodoDeTraco(); // Imprime "Eu tenho MeuTraco"
+
+
+/********************************
+ * Namespaces (Espaço nominal)
+ */
+
+// Esta seção é separada porque a declaração de espaços nominais
+// deve ser a primeira instrução em um arquivo. Vamos fingir, aqui não é o caso
+
+<?php
+
+// Por padrão, as classes existem no espaço nominal global e podem
+// ser explicitamente chamadas com uma barra invertida.
+
+$cls = new \MinhaClasse();
+
+
+
+// Definir o espaço nominal para o arquivo
+namespace Meu\Espaconominal;
+
+class MinhaClasse
+{
+}
+
+// (de outro arquivo)
+$cls = new Meu\Espaconominal\MinhaClasse;
+
+//Ou de dentro de outro espaço nominal.
+namespace Meu\Outro\Espaconominal;
+
+use My\Espaconominal\MinhaClasse;
+
+$cls = new MinhaClasse();
+
+//Ou você pode usar como apelido de espaço nominal;
+
+namespace Meu\Outro\Espaconominal;
+
+use Meu\Espaconominal as OutroEspaconominal;
+
+$cls = new OutroEspaconominal\MinhaClasse();
+
+*/
+
+```
+
+## Mais informações
+
+Visite a [documentação oficial do PHP](http://www.php.net/manual/) 
+para referência e participação da comunidade.
+
+Se você estiver interessado em melhores práticas atualizadas, visite
+[PHP The Right Way](http://www.phptherightway.com/).
+
+Se você está vindo de uma linguagem com bom gerenciamento de pacotes, confira
+[Composer](http://getcomposer.org/).
+
+Para os padrões comuns, visite o Grupo de Interoperabilidade de Framework PHP
+[PSR standards](https://github.com/php-fig/fig-standards).
diff --git a/pt-br/python-pt.html.markdown b/pt-br/python-pt.html.markdown
new file mode 100644
index 00000000..5afd46d0
--- /dev/null
+++ b/pt-br/python-pt.html.markdown
@@ -0,0 +1,509 @@
+---
+language: python
+contributors:
+    - ["Louie Dinh", "http://ldinh.ca"]
+translators:
+    - ["Vilson Vieira", "http://automata.cc"]
+lang: pt-br
+filename: learnpython-pt.py
+---
+
+Python foi criado por Guido Van Rossum no começo dos anos 90. Atualmente é uma
+das linguagens de programação mais populares. Eu me apaixonei por Python, por
+sua clareza de sintaxe. É basicamente pseudocódigo executável.
+
+Comentários serão muito apreciados! Você pode me contactar em
+[@louiedinh](http://twitter.com/louiedinh) ou louiedinh [arroba]
+[serviço de email do google]
+
+Nota: Este artigo usa Python 2.7 especificamente, mas deveria ser aplicável a
+qualquer Python 2.x. Logo haverá uma versão abordando Python 3!
+
+```python
+# Comentários de uma linha começam com cerquilha (ou sustenido)
+""" Strings de várias linhas podem ser escritas
+    usando três ", e são comumente usadas
+    como comentários
+"""
+
+####################################################
+## 1. Tipos de dados primitivos e operadores
+####################################################
+
+# Você usa números normalmente
+3 #=> 3
+
+# Operadores matemáticos são aqueles que você já está acostumado
+1 + 1 #=> 2
+8 - 1 #=> 7
+10 * 2 #=> 20
+35 / 5 #=> 7
+
+# A divisão é um pouco estranha. A divisão de números inteiros arredonda
+# para baixo o resultado, automaticamente
+5 / 2 #=> 2
+
+# Para concertar a divisão, precisamos aprender sobre números de ponto
+# flutuante (conhecidos como 'float').
+2.0     # Isso é um 'float'
+11.0 / 4.0 #=> 2.75 ahhh... muito melhor
+
+# Forçamos a precedência de operadores usando parênteses
+(1 + 3) * 2 #=> 8
+
+# Valores booleanos (ou 'boolean') são também tipos primitivos
+True
+False
+
+# Negamos usando 'not'
+not True #=> False
+not False #=> True
+
+# Testamos igualdade usando '=='
+1 == 1 #=> True
+2 == 1 #=> False
+
+# E desigualdade com '!='
+1 != 1 #=> False
+2 != 1 #=> True
+
+# Mais comparações
+1 < 10 #=> True
+1 > 10 #=> False
+2 <= 2 #=> True
+2 >= 2 #=> True
+
+# As comparações podem ser encadeadas!
+1 < 2 < 3 #=> True
+2 < 3 < 2 #=> False
+
+# Strings são criadas com " ou '
+"Isso é uma string."
+'Isso também é uma string.'
+
+# Strings podem ser somadas (ou melhor, concatenadas)!
+"Olá " + "mundo!" #=> "Olá mundo!"
+
+# Uma string pode ser tratada como uma lista de caracteres
+"Esta é uma string"[0] #=> 'E'
+
+# O caractere % pode ser usado para formatar strings, desta forma:
+"%s podem ser %s" % ("strings", "interpoladas")
+
+# Um jeito novo de formatar strings é usando o método 'format'.
+# Esse método é o jeito mais usado
+"{0} podem ser {1}".format("strings", "formatadas")
+# Você pode usar palavras-chave (ou 'keywords') se você não quiser contar.
+"{nome} quer comer {comida}".format(nome="João", comida="lasanha")
+
+# 'None' é um objeto
+None #=> None
+
+# Não use o operador de igualdade `==` para comparar objetos com 'None'
+# Ao invés disso, use `is`
+"etc" is None #=> False
+None is None  #=> True
+
+# O operador 'is' teste a identidade de um objeto. Isso não é
+# muito útil quando estamos lidando com valores primitivos, mas é
+# muito útil quando lidamos com objetos.
+
+# None, 0, e strings/listas vazias são todas interpretadas como 'False'.
+# Todos os outros valores são 'True'
+0 == False  #=> True
+"" == False #=> True
+
+
+####################################################
+## 2. Variáveis e Coleções
+####################################################
+
+# Imprimir na tela é muito fácil
+print "Eu sou o Python. Prazer em te conhecer!"
+
+
+# Nós não precisamos declarar variáveis antes de usá-las, basta usar!
+alguma_variavel = 5    # A convenção é usar caixa_baixa_com_sobrescritos
+alguma_variavel #=> 5
+
+# Acessar uma variável que não teve nenhum valor atribuído anteriormente é
+# uma exceção.
+# Veja a seção 'Controle' para aprender mais sobre tratamento de exceção.
+outra_variavel  # Gera uma exceção de erro de nome
+
+# 'if' pode ser usado como uma expressão
+"uepa!" if 3 > 2 else 2 #=> "uepa!"
+
+# Listas armazenam sequências de elementos
+lista = []
+# Você pode inicializar uma lista com valores
+outra_lista = [4, 5, 6]
+
+# Adicione elementos no final da lista usando 'append'
+lista.append(1)    # lista é agora [1]
+lista.append(2)    # lista é agora [1, 2]
+lista.append(4)    # lista é agora [1, 2, 4]
+lista.append(3)    # lista é agora [1, 2, 4, 3]
+# Remova elementos do fim da lista usando 'pop'
+lista.pop()        #=> 3 e lista é agora [1, 2, 4]
+# Vamos adicionar o elemento novamente
+lista.append(3)    # lista agora é [1, 2, 4, 3] novamente.
+
+# Acesse elementos de uma lista através de seu índices
+lista[0] #=> 1
+# Acesse o último elemento com índice negativo!
+lista[-1] #=> 3
+
+# Tentar acessar um elemento fora dos limites da lista gera uma exceção
+# do tipo 'IndexError'
+lista[4] # Gera uma exceção 'IndexError'
+
+# Você pode acessar vários elementos ao mesmo tempo usando a sintaxe de
+# limites
+# (Para quem gosta de matemática, isso é um limite fechado/aberto)
+lista[1:3] #=> [2, 4]
+# Você pode omitir o fim se quiser os elementos até o final da lista
+lista[2:] #=> [4, 3]
+# O mesmo para o início
+lista[:3] #=> [1, 2, 4]
+
+# Remova um elemento qualquer de uma lista usando 'del'
+del lista[2] # lista agora é [1, 2, 3]
+
+# Você pode somar listas (obs: as listas originais não são modificadas)
+lista + outra_lista #=> [1, 2, 3, 4, 5, 6]
+
+# Você também pode concatenar usando o método 'extend' (lista será modificada!)
+lista.extend(outra_lista) # Agora lista é [1, 2, 3, 4, 5, 6]
+
+# Para checar se um elemento pertence a uma lista, use 'in'
+1 in lista #=> True
+
+# Saiba quantos elementos uma lista possui com 'len'
+len(lista) #=> 6
+
+
+# Tuplas são iguais a listas, mas são imutáveis
+tup = (1, 2, 3)
+tup[0] #=> 1
+tup[0] = 3  # Isso gera uma exceção do tipo TypeError
+
+# Você pode fazer nas tuplas todas aquelas coisas fez com a lista
+len(tup) #=> 3
+tup + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6)
+tup[:2] #=> (1, 2)
+2 in tup #=> True
+
+# Você pode 'desempacotar' tuplas (ou listas) em variáveis, associando cada
+# elemento da tupla/lista a uma variável correspondente
+a, b, c = (1, 2, 3)     # a agora é 1, b agora é 2, c agora é 3
+# Tuplas são criadas por padrão, mesmo se você não usar parênteses
+d, e, f = 4, 5, 6
+# Sabendo disso, veja só como é fácil trocar os valores de duas variáveis!
+e, d = d, e     # d agora é 5, e agora é 4
+
+
+# Dicionários armazenam 'mapeamentos' (do tipo chave-valor)
+dicionario_vazio = {}
+# Aqui criamos um dicionário já contendo valores
+dicionario = {"um": 1, "dois": 2, "três": 3}
+
+# Acesse valores usando []
+dicionario["um"] #=> 1
+
+# Retorna uma lista com todas as chaves do dicionário
+dicionario.keys() #=> ["três", "dois", "um"]
+# Nota: A ordem das chaves não é garantida.
+# O resultado no seu interpretador não necessariamente será igual a esse.
+
+# Retorna uma lista com todos os valores do dicionário
+dicionario.values() #=> [3, 2, 1]
+# Nota: A mesma nota acima sobre a ordenação é válida aqui.
+
+# Veja se uma chave qualquer está em um dicionário usando 'in'
+"um" in dicionario #=> True
+1 in dicionario #=> False
+
+# Tentar acessar uma chave que não existe gera uma exceção do tipo 'KeyError'
+dicionario["quatro"] # Gera uma exceção KeyError
+
+# Você pode usar o método 'get' para evitar gerar a exceção 'KeyError'.
+# Ao invés de gerar essa exceção, irá retornar 'None' se a chave não existir.
+dicionario.get("um") #=> 1
+dicionario.get("quatro") #=> None
+# O método 'get' suporta um argumento que diz qual valor deverá ser
+# retornado se a chave não existir (ao invés de 'None').
+dicionario.get("um", 4) #=> 1
+dicionario.get("quatro", 4) #=> 4
+
+# O método 'setdefault' é um jeito seguro de adicionar um novo par
+# chave-valor a um dicionário, associando um valor padrão imutável à uma chave
+dicionario.setdefault("cinco", 5) # dicionario["cinco"] é definido como 5
+dicionario.setdefault("cinco", 6) # dicionario["cinco"] ainda é igual a 5
+
+
+# Conjuntos (ou sets) armazenam ... bem, conjuntos
+# Nota: lembre-se que conjuntos não admitem elementos repetidos!
+conjunto_vazio = set()
+# Podemos inicializar um conjunto com valores
+conjunto = set([1, 2, 2, 3, 4]) # conjunto é set([1, 2, 3, 4]), sem repetição!
+
+# Desde o Python 2.7, {} pode ser usado para declarar um conjunto
+conjunto = {1, 2, 2, 3, 4} # => {1 2 3 4}
+
+# Adicione mais ítens a um conjunto com 'add'
+conjunto.add(5) # conjunto agora é {1, 2, 3, 4, 5}
+
+# Calcule a intersecção de dois conjuntos com &
+outro_conj = {3, 4, 5, 6}
+conjunto & outro_conj #=> {3, 4, 5}
+
+# Calcule a união de dois conjuntos com |
+conjunto | outro_conj #=> {1, 2, 3, 4, 5, 6}
+
+# E a diferença entre dois conjuntos com -
+{1,2,3,4} - {2,3,5} #=> {1, 4}
+
+# Veja se um elemento existe em um conjunto usando 'in'
+2 in conjunto #=> True
+10 in conjunto #=> False
+
+
+####################################################
+## 3. Controle
+####################################################
+
+# Para começar, vamos apenas criar uma variável
+alguma_var = 5
+
+# Aqui está uma expressão 'if'. Veja como a identação é importante em Python!
+# Esses comandos irão imprimir "alguma_var é menor que 10"
+if alguma_var > 10:
+    print "some_var é maior que 10."
+elif some_var < 10:    # Esse 'elif' é opcional
+    print "some_var é menor que 10."
+else:           # Esse 'else' também é opcional
+    print "some_var é igual a 10."
+
+
+"""
+Laços (ou loops) 'for' iteram em listas.
+Irá imprimir:
+    cachorro é um mamífero
+    gato é um mamífero
+    rato é um mamífero
+"""
+for animal in ["cachorro", "gato", "rato"]:
+    # Você pode usar % para interpolar strings formatadas
+    print "%s é um mamífero" % animal
+    
+"""
+A função `range(um número)` retorna uma lista de números
+do zero até o número dado.
+Irá imprimir:
+    0
+    1
+    2
+    3
+"""
+for i in range(4):
+    print i
+
+"""
+Laços 'while' executam enquanto uma condição dada for verdadeira.
+Irá imprimir:
+    0
+    1
+    2
+    3
+"""
+x = 0
+while x < 4:
+    print x
+    x += 1  # Isso é um atalho para a expressão x = x + 1
+
+# Tratamos excessões usando o bloco try/except
+# Funciona em Python 2.6 e versões superiores:
+
+try:
+    # Use 'raise' para gerar um erro
+    raise IndexError("Isso é um erro de índice")
+except IndexError as e:
+    pass    # Pass é um operador que não faz nada, deixa passar.
+            # Usualmente você iria tratar a exceção aqui...
+
+
+####################################################
+## 4. Funções
+####################################################
+
+# Use 'def' para definir novas funções
+def soma(x, y):
+    print "x é %s e y é %s" % (x, y)
+    return x + y    # Retorne valores usando 'return'
+
+# Chamando funções com parâmetros
+soma(5, 6) #=> imprime "x é 5 e y é 6" e retorna o valor 11
+
+# Um outro jeito de chamar funções é especificando explicitamente os valores
+# de cada parâmetro com chaves
+soma(y=6, x=5)   # Argumentos com chaves podem vir em qualquer ordem.
+
+# Você pode definir funções que recebem um número qualquer de argumentos
+# (respeitando a sua ordem)
+def varargs(*args):
+    return args
+
+varargs(1, 2, 3) #=> (1,2,3)
+
+
+# Você também pode definir funções que recebem um número qualquer de argumentos
+# com chaves
+def args_com_chaves(**ch_args):
+    return ch_args
+
+# Vamos chamar essa função para ver o que acontece
+args_com_chaves(pe="grande", lago="Ness") #=> {"pe": "grande", "lago": "Ness"}
+
+# Você pode fazer as duas coisas ao mesmo tempo, se desejar
+def todos_args(*args, **ch_wargs):
+    print args
+    print ch_args
+"""
+todos_args(1, 2, a=3, b=4) imprime:
+    (1, 2)
+    {"a": 3, "b": 4}
+"""
+
+# Quando você chamar funções, pode fazer o oposto do que fizemos até agora!
+# Podemos usar * para expandir tuplas de argumentos e ** para expandir
+# dicionários de argumentos com chave.
+args = (1, 2, 3, 4)
+ch_args = {"a": 3, "b": 4}
+todos_args(*args)  # equivalente a todos_args(1, 2, 3, 4)
+todos_args(**ch_args) # equivalente a todos_args(a=3, b=4)
+todos_args(*args, **ch_args) # equivalente a todos_args(1, 2, 3, 4, a=3, b=4)
+
+# Em Python, funções são elementos de primeira ordem (são como objetos, 
+# strings ou números)
+def cria_somador(x):
+    def somador(y):
+        return x + y
+    return somador
+
+soma_10 = cria_somador(10)
+soma_10(3) #=> 13
+
+# Desta forma, existem também funções anônimas
+(lambda x: x > 2)(3) #=> True
+
+# E existem funções de alta ordem por padrão
+map(soma_10, [1,2,3]) #=> [11, 12, 13]
+filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7]
+reduce(lambda x, y: x + y, [3, 4, 5, 6, 7]) #=> 25
+
+# Nós podemos usar compreensão de listas para mapear e filtrar também
+[soma_10(i) for i in [1, 2, 3]]  #=> [11, 12, 13]
+[x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7]
+
+####################################################
+## 5. Classes
+####################################################
+
+# Para criar uma nova classe, devemos herdar de 'object'
+class Humano(object):
+
+    # Um atributo de classe. Ele é compartilhado por todas as instâncias dessa
+    # classe
+    especie = "H. sapiens"
+
+    # Definimos um inicializador básico
+    def __init__(self, nome):
+        # Atribui o valor de argumento dado a um atributo da instância
+        self.nome = nome
+
+    # Um método de instância. Todos os métodos levam 'self' como primeiro
+    # argumento
+    def diga(self, msg):
+       return "%s: %s" % (self.nome, msg)
+
+    # Um método de classe é compartilhado por todas as instâncias
+    # Eles são chamados passando o nome da classe como primeiro argumento
+    @classmethod
+    def get_especie(cls):
+        return cls.especie
+
+    # Um método estático é chamado sem uma referência a classe ou instância
+    @staticmethod
+    def ronca():
+        return "*arrrrrrr*"
+
+
+# Instancie uma classe
+i = Humano(nome="Ivone")
+print i.diga("oi")     # imprime "Ivone: oi"
+
+j = Human("Joel")
+print j.say("olá")  #prints out "Joel: olá"
+
+# Chame nosso método de classe
+i.get_especie() #=> "H. sapiens"
+
+# Modifique um atributo compartilhado
+Humano.especie = "H. neanderthalensis"
+i.get_especie() #=> "H. neanderthalensis"
+j.get_especie() #=> "H. neanderthalensis"
+
+# Chame o método estático
+Humano.ronca() #=> "*arrrrrrr*"
+
+
+####################################################
+## 6. Módulos
+####################################################
+
+# Você pode importar módulos
+import math
+print math.sqrt(16) #=> 4
+
+# Você pode importar funções específicas de um módulo
+from math import ceil, floor
+print ceil(3.7)  #=> 4.0
+print floor(3.7) #=> 3.0
+
+# Você também pode importar todas as funções de um módulo
+# Atenção: isso não é recomendado!
+from math import *
+
+# Você pode usar apelidos para os módulos, encurtando seus nomes
+import math as m
+math.sqrt(16) == m.sqrt(16) #=> True
+
+# Módulos em Python são apenas arquivos Python. Você
+# pode escrever o seu próprio módulo e importá-lo. O nome do
+# módulo será o mesmo que o nome do arquivo.
+
+# Você pode descobrir quais funções e atributos
+# estão definidos em um módulo qualquer.
+import math
+dir(math)
+
+
+```
+
+## Pronto para mais?
+
+### Online e gratuito
+
+* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
+* [Dive Into Python](http://www.diveintopython.net/)
+* [The Official Docs](http://docs.python.org/2.6/)
+* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
+* [Python Module of the Week](http://pymotw.com/2/)
+
+### Livros impressos
+
+* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20)
+* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20)
+* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20)
+
diff --git a/pt-br/ruby-pt.html.markdown b/pt-br/ruby-pt.html.markdown
new file mode 100644
index 00000000..89a051d4
--- /dev/null
+++ b/pt-br/ruby-pt.html.markdown
@@ -0,0 +1,387 @@
+---
+language: ruby
+lang: pt-br
+filename: learnruby-pt.rb
+contributors:
+  - ["Bruno Henrique - Garu", "http://garulab.com"]
+translators:
+  - ["Katyanna Moura", "https://twitter.com/amelie_kn"]
+---
+
+```ruby
+# Isso é um comentário
+
+=begin
+Isso é um comentário multilinha
+Ninguém os usa
+Você não deve usar também
+=end
+
+# Primeiro e principal: Tudo é um objeto.
+
+# Números são objetos
+
+3.class #=> Fixnum
+
+3.to_s #=> "3"
+
+
+# Um pouco de aritmética básica
+
+1 + 1 #=> 2
+8 - 1 #=> 7
+10 * 2 #=> 20
+35 / 5 #=> 7
+
+# Aritmética é apenas açúcar sintático
+# para chamar um método de um objeto
+1.+(3) #=> 4
+10.* 5 #=> 50
+
+# Valores especiais são objetos
+nil # Nada para ver aqui
+true # verdadeiro
+false # falso
+
+nil.class #=> NilClass
+true.class #=> TrueClass
+false.class #=> FalseClass
+
+# Igualdade
+1 == 1 #=> true
+2 == 1 #=> false
+
+# Desigualdade
+1 != 1 #=> false
+2 != 1 #=> true
+!true  #=> false
+!false #=> true
+
+# além de 'false', 'nil' é o único outro valor falso
+
+!nil   #=> true
+!false #=> true
+!0     #=> false
+
+# Mais comparações
+1 < 10 #=> true
+1 > 10 #=> false
+2 <= 2 #=> true
+2 >= 2 #=> true
+
+# Strings são objects
+
+'Eu sou uma string'.class #=> String
+"Eu também sou uma string".class #=> String
+
+placeholder = "usar interpolação de string"
+"Eu posso #{placeholder} quando estiver usando aspas duplas"
+#=> "Eu posso usar insterpolação de string quando estiver usando aspas duplas"
+
+# imprime para output (saída)
+puts "Estou imprimindo"
+
+# Variáveis
+x = 25 #=> 25
+x #=> 25
+
+# Note que uma atribuição retorna o valor atribuido
+# Isso significa que você pode fazer múltiplas atribuições:
+
+x = y = 10 #=> 10
+x #=> 10
+y #=> 10
+
+# Por convenção, use snake_case para nomes de variáveis
+snake_case = true
+
+# Use nomes de variáveis descritivos
+caminho_para_a_raiz_do_projeto = '/bom/nome/'
+caminho = '/nome/ruim/'
+
+# Símbolos (são objetos)
+# Símbolos são imutáveis, são constantes reutilizáveis representadadas
+# internamente por um valor inteiro. Eles são frequentemente usados no
+# lugar de strings para transmitir com eficiência os valores específicos
+# e significativos
+
+:pendente.class #=> Symbol
+
+status = :pendente
+
+status == :pendente #=> true
+
+status == 'pendente' #=> false
+
+status == :aprovado #=> false
+
+# Arrays
+
+# Isso é um array
+[1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
+
+# Arrays podem conter diferentes tipos de itens
+
+array = [1, "Oi", false] #=> => [1, "Oi", false]
+
+# Arrays podem ser indexados
+# a partir do começo
+array[0] #=> 1
+array[12] #=> nil
+
+# Como aritmética, o acesso via [var]
+# é apenas açúcar sintático
+# para chamar o método [] de um objeto
+array.[] 0 #=> 1
+array.[] 12 #=> nil
+
+# a partir do final
+array[-1] #=> 5
+
+# Com um índice de começo e fim
+array[2, 4] #=> [3, 4, 5]
+
+# Ou com um intervalo de valores
+array[1..3] #=> [2, 3, 4]
+
+# Adicionar a um array como este
+array << 6 #=> [1, 2, 3, 4, 5, 6]
+
+# Hashes são o principal dicionário de Ruby com pares de chaves(keys)/valor(value).
+# Hashes são simbolizados com chaves "{}"
+hash = {'cor' => 'verde', 'numero' => 5}
+
+hash.keys #=> ['cor', 'numero']
+
+# Hashes podem ser rapidamente pesquisados pela chave (key)
+hash['cor'] #=> 'verde'
+hash['numero'] #=> 5
+
+# Procurar em um hash por uma chave que não existe retorna nil:
+hash['nada aqui'] #=> nil
+
+# Interar sobre hashes com o método #each:
+hash.each do |k, v|
+  puts "#{k} is #{v}"
+end
+
+hash.each do |k, v|
+  puts "#{k} é #{v}"
+end
+
+# Desde o Ruby 1.9, temos uma sintaxe especial quando usamos símbolos como chaves (keys)
+
+novo_hash = {defcon: 3, acao: true}
+
+novo_hash.keys #=> [:defcon, :acao]
+
+# Dica: Tanto Arrays quanto Hashes são Enumerable.
+# Eles compartilham um monte de métodos úteis como each, map, count e mais
+
+# Estruturas de controle
+
+if true
+  "Se verdadeiro"
+elsif false
+ "else if, opcional"
+else
+ "else, também é opcional"
+end
+
+for contador in 1..5
+  puts "interação #{contador}"
+end
+#=> contador 1
+#=> contador 2
+#=> contador 3
+#=> contador 4
+#=> contador 5
+
+# PORÉM
+# Ninguém usa para loops
+# Use "each" em vez, dessa forma:
+
+(1..5).each do |contador|
+  puts "interação #{contador}"
+end
+#=> contador 1
+#=> contador 2
+#=> contador 3
+#=> contador 4
+#=> contador 5
+
+contador = 1
+while contador <= 5 do
+  puts "interação #{contador}"
+  contador += 1
+end
+#=> contador 1
+#=> contador 2
+#=> contador 3
+#=> contador 4
+#=> contador 5
+
+grau = 'B'
+
+case grau
+when 'A'
+  puts "Um longo caminho a percorrer, pequeno gafanhoto"
+when 'B'
+  puts "Melhor sorte da próxima vez"
+when 'C'
+  puts "Você pode fazer melhor"
+when 'D'
+  puts "Scraping through"
+when 'F'
+  puts "Você falhou"
+else
+  puts "Alternative grading system, eh?"
+end
+
+# Funções
+
+def dobrar(x)
+  x * 2
+end
+
+# Funções (e todos os blocos) retornam implicitamente o valor da última linha
+dobrar(2) #=> 4
+
+# Parênteses são opicionais onde o resultado é claro
+dobrar 3 #=> 6
+
+dobrar dobrar 3 #=> 12
+
+def somar(x,y)
+  x + y
+end
+
+# Argumentos de métodos são separados por uma vírgula
+somar 3, 4 #=> 7
+
+somar(3,4), 5 #=> 12
+
+# yield
+# Todos os métodos possuem implicitamente um paramêntro opcional que é um bloco
+# ele pode ser chamado com a palavra chave 'yield'
+
+def ao_redor
+  puts "{"
+  yield
+  puts "}"
+end
+
+ao_redor { puts 'Olá mundo' }
+
+# {
+# Olá mundo
+# }
+
+
+# Define uma classe com a palavra chave 'class'
+
+class Humano
+
+  # Uma variável de classe. Ela é compartilhada por todas as instâncias dessa classe
+  @@especies = "H. sapiens"
+
+  # Inicialização básica (contructor)
+  def initialize(nome, idade=0)
+    # Atribui o argumento para a variável de instancia "nome" do objeto
+    @nome = nome
+    # Se a idade não for passada, nós definimos um valor padrão na lista de argumentos
+    @idade = idade
+  end
+
+  # Método básico para atribuir valor
+  def nome=(nome)
+    @nome = nome
+  end
+
+  # Método básico de resgatar valor
+  def nome
+    @nome
+  end
+
+  # Um método de classe usa a palavra chave self para se defenciar dos métodos de instância.
+  # Ele só pode ser chamado na classe, não na instancia
+  def self.diz(msg)
+    puts "#{msg}"
+  end
+
+  def especies
+    @@especies
+  end
+
+end
+
+
+# Instanciando uma classe
+jim = Humano.new("Jim Halpert")
+
+dwight = Humano.new("Dwight K. Schrute")
+
+# Vamos chamar um par de métodos
+jim.especies #=> "H. sapiens"
+
+jim.nome #=> "Jim Halpert"
+
+jim.nome = "Jim Halpert II" #=> "Jim Halpert II"
+
+jim.nome #=> "Jim Halpert II"
+
+dwight.especies #=> "H. sapiens"
+
+dwight.nome #=> "Dwight K. Schrute"
+
+# Chamar o método de classe
+Humano.diz("Oi") #=> "Oi"
+
+# Uma classe também é objeto em Ruby. Então uma classe pode possuir variável de instância
+# Variáveis de classe são compartilhadas entre a classe e todos os seus descendentes.
+
+
+# Classe base
+class Humano
+  @@foo = 0
+
+  def self.foo
+    @@foo
+  end
+
+  def self.foo=(value)
+    @@foo = value
+  end
+end
+
+#  classe filha
+class Trabalhador < Humano
+end
+
+Humano.foo # 0
+Trabalhador.foo # 0
+
+Humano.foo = 2 # 2
+Trabalhador.foo # 2
+
+# Uma variável de instância não é compartilhada por suas classes decendentes.
+
+class Humano
+  @bar = 0
+
+  def self.bar
+    @bar
+  end
+
+  def self.bar=(value)
+    @bar = value
+  end
+end
+
+class Doutor < Humano
+end
+
+Humano.bar # 0
+Doutor.bar # nil
+
+```
diff --git a/pt-br/swift-pt.html.markdown b/pt-br/swift-pt.html.markdown
new file mode 100644
index 00000000..e840b8cf
--- /dev/null
+++ b/pt-br/swift-pt.html.markdown
@@ -0,0 +1,500 @@
+---
+language: swift
+contributors:
+    - ["Grant Timmerman", "http://github.com/grant"]
+    - ["Christopher Bess", "http://github.com/cbess"]
+translators:
+    - ["Mariane Siqueira Machado", "https://twitter.com/mariane_sm"]
+lang: pt-br
+filename: learnswift.swift
+---
+
+Swift é uma linguagem de programação para desenvolvimento de aplicações no iOS e OS X criada pela Apple. Criada para
+coexistir com Objective-C e para ser mais resiliente a código com erros, Swift foi apresentada em 2014 na Apple's
+developer conference WWDC. Foi construída com o compilador LLVM já incluído no Xcode 6 beta.
+
+O livro oficial [Swift Programming Language] (https://itunes.apple.com/us/book/swift-programming-language/id881256329) da
+Apple já está disponível via IBooks (apenas em inglês).
+
+Confira também o tutorial completo de Swift da Apple [getting started guide](https://developer.apple.com/library/prerelease/ios/referencelibrary/GettingStarted/RoadMapiOS/index.html), também disponível apenas em inglês.
+
+```swift
+// importa um módulo
+import UIKit
+
+//
+// MARK: Noções básicas
+//
+
+// Xcode supporta anotações para seu código e lista elas na barra de atalhos
+// MARK: Marca uma sessão
+// TODO: Faça algo logo
+// FIXME: Conserte esse código
+
+println("Hello, world")
+
+// Valores em variáveis (var) podem ter seu valor alterado depois de declarados.
+// Valores em constantes (let) NÃO podem ser alterados depois de declarados.
+
+var myVariable = 42
+let øπΩ = "value" // nomes de variáveis em unicode
+let π = 3.1415926
+let convenience = "keyword" // nome de variável contextual
+let weak = "keyword"; let override = "another keyword" // comandos podem ser separados por uma ponto e vírgula
+let `class` = "keyword" // Crases permitem que palavras-chave seja usadas como nome de variáveis
+let explicitDouble: Double = 70
+let intValue = 0007 // 7
+let largeIntValue = 77_000 // 77000
+let label = "some text " + String(myVariable) // Coerção
+let piText = "Pi = \(π), Pi 2 = \(π * 2)" // Interpolação de strings
+
+// Constrói valores específicos
+// Utiliza configuração de build -D
+#if false
+    println("Not printed")
+    let buildValue = 3
+#else
+    let buildValue = 7
+#endif
+println("Build value: \(buildValue)") // Build value: 7
+
+/*
+    Optionals fazem parte da linguagem e permitem que você armazene um
+    valor `Some` (algo) ou `None` (nada).
+
+    Como Swift requer que todas as propriedades tenham valores, até mesmo nil deve
+    ser explicitamente armazenado como um valor Optional.
+
+    Optional<T> é uma enum.
+*/
+var someOptionalString: String? = "optional" // Pode ser nil
+// o mesmo acima, mas ? é um operador pós-fixado (açúcar sintático)
+var someOptionalString2: Optional<String> = "optional"
+
+if someOptionalString != nil {
+    // Eu não sou nil
+    if someOptionalString!.hasPrefix("opt") {
+        println("has the prefix")
+    }
+
+    let empty = someOptionalString?.isEmpty
+}
+someOptionalString = nil
+
+// Optional implicitamente desempacotado (unwrapped)
+var unwrappedString: String! = "Valor é esperado."
+// o mesmo acima, mas ? é um operador pósfixado (açúcar sintático)
+var unwrappedString2: ImplicitlyUnwrappedOptional<String> = "Valor é esperado."
+
+if let someOptionalStringConstant = someOptionalString {
+    // Tem `Some` (algum) valor, não nil
+    if !someOptionalStringConstant.hasPrefix("ok") {
+        // não possui o prefixo
+    }
+}
+
+// Swift tem suporte para armazenar um valor de qualquer tipo.
+// AnyObject == id
+// Ao contrário de Objective-C `id`, AnyObject funciona com qualquer valor (Class, Int, struct, etc)
+var anyObjectVar: AnyObject = 7
+anyObjectVar = "Mudou o valor para string, não é uma boa prática, mas é possível."
+
+/*
+Comentário aqui
+    /*
+        Comentários aninhados também são suportados
+    */
+*/
+
+//
+// MARK: Coleções
+//
+
+/*
+    Tipos Array e Dicionário são structs. Portanto `let` e `var`
+    também indicam se são mutáveis (var) ou imutáveis (let) quando declarados
+    com esses tipos.
+*/
+
+// Array
+var shoppingList = ["catfish", "water", "lemons"]
+shoppingList[1] = "bottle of water"
+let emptyArray = [String]() // imutável
+var emptyMutableArray = [String]() // mutável
+
+
+// Dicionário
+var occupations = [
+    "Malcolm": "Captain",
+    "kaylee": "Mechanic"
+]
+occupations["Jayne"] = "Public Relations"
+let emptyDictionary = [String: Float]() // imutável
+var emptyMutableDictionary = [String: Float]() // mutável
+
+
+//
+// MARK: Controle de fluxo
+//
+
+// laço for (array)
+let myArray = [1, 1, 2, 3, 5]
+for value in myArray {
+    if value == 1 {
+        println("One!")
+    } else {
+        println("Not one!")
+    }
+}
+
+// laço for (dicionário)
+var dict = ["one": 1, "two": 2]
+for (key, value) in dict {
+    println("\(key): \(value)")
+}
+
+// laço for (alcance)
+for i in -1...shoppingList.count {
+    println(i)
+}
+shoppingList[1...2] = ["steak", "peacons"]
+// use ..< para excluir o último número
+
+// laço while (enquanto)
+var i = 1
+while i < 1000 {
+    i *= 2
+}
+
+// laço do-while
+do {
+    println("hello")
+} while 1 == 2
+
+// Switch
+let vegetable = "red pepper"
+switch vegetable {
+case "celery":
+    let vegetableComment = "Add some raisins and make ants on a log."
+case "cucumber", "watercress":
+    let vegetableComment = "That would make a good tea sandwich."
+case let x where x.hasSuffix("pepper"):
+    let vegetableComment = "Is it a spicy \(x)?"
+default: // required (in order to cover all possible input)
+    let vegetableComment = "Everything tastes good in soup."
+}
+
+
+//
+// MARK: Funções
+//
+
+// Funções são tipos de primeira classe, o que significa que eles podem ser aninhados
+// em funções e podem ser passados como parâmetros
+
+// Funções Swift com cabeçalhos doc (formato como reStructedText)
+/**
+Uma operação de saudação
+
+- Um bullet em documentos
+- Outro bullet
+
+:param: nome A nome
+:param: dia A dia
+:returns: Uma string contendo o nome e o dia.
+*/
+func greet(name: String, day: String) -> String {
+    return "Hello \(name), today is \(day)."
+}
+greet("Bob", "Tuesday")
+
+// Função que retorna múltiplos items em uma tupla
+func getGasPrices() -> (Double, Double, Double) {
+    return (3.59, 3.69, 3.79)
+}
+let pricesTuple = getGasPrices()
+let price = pricesTuple.2 // 3.79
+// Ignore valores de Tuplas (ou outros valores) usando _ (underscore)
+let (_, price1, _) = pricesTuple // price1 == 3.69
+println(price1 == pricesTuple.1) // true
+println("Gas price: \(price)")
+
+// Número variável de argumentos
+func setup(numbers: Int...) {
+    // é um array
+    let number = numbers[0]
+    let argCount = numbers.count
+}
+
+// Passando e retornando funções
+func makeIncrementer() -> (Int -> Int) {
+    func addOne(number: Int) -> Int {
+        return 1 + number
+    }
+    return addOne
+}
+var increment = makeIncrementer()
+increment(7)
+
+// passagem por referência
+func swapTwoInts(inout a: Int, inout b: Int) {
+    let tempA = a
+    a = b
+    b = tempA
+}
+var someIntA = 7
+var someIntB = 3
+swapTwoInts(&someIntA, &someIntB)
+println(someIntB) // 7
+
+
+//
+// MARK: Closures
+//
+var numbers = [1, 2, 6]
+
+// Funções são casos especiais de closures ({})
+
+// Exemplo de closure.
+// `->` separa argumentos e tipo de retorno
+// `in` separa o cabeçalho do closure do seu corpo
+numbers.map({
+    (number: Int) -> Int in
+    let result = 3 * number
+    return result
+})
+
+// Quando o tipo é conhecido, como abaixo, nós podemos fazer o seguinte
+numbers = numbers.map({ number in 3 * number })
+// Ou até mesmo isso
+//numbers = numbers.map({ $0 * 3 })
+
+print(numbers) // [3, 6, 18]
+
+// Closure restante
+numbers = sorted(numbers) { $0 > $1 }
+
+print(numbers) // [18, 6, 3]
+
+// Super atalho, já que o operador < infere os tipos
+
+numbers = sorted(numbers, < )
+
+print(numbers) // [3, 6, 18]
+
+//
+// MARK: Estruturas
+//
+
+// Estruturas e classes tem funcionalidades muito similares
+struct NamesTable {
+    let names: [String]
+
+    // Custom subscript
+    subscript(index: Int) -> String {
+        return names[index]
+    }
+}
+
+// Estruturas possuem um inicializador auto-gerado automático (implícito)
+let namesTable = NamesTable(names: ["Me", "Them"])
+//let name = namesTable[2]
+//println("Name is \(name)") // Name is Them
+
+//
+// MARK: Classes
+//
+
+// Classes, Estruturas e seus membros possuem três níveis de modificadores de acesso
+// Eles são: internal (default), public, private
+
+public class Shape {
+    public func getArea() -> Int {
+        return 0;
+    }
+}
+
+// Todos os métodos e propriedades de uma classe são públicos.
+// Se você só precisa armazenar dados em um objeto estruturado, use `struct`
+
+internal class Rect: Shape {
+    var sideLength: Int = 1
+
+    // Getter e setter personalizado
+    private var perimeter: Int {
+        get {
+            return 4 * sideLength
+        }
+        set {
+            // `newValue` é uma variável implicita disponível para os setters
+            sideLength = newValue / 4
+        }
+    }
+
+    // Carregue uma propriedade sob demanda (lazy)
+    // subShape permanece nil (não inicializado) até seu getter ser chamado
+    lazy var subShape = Rect(sideLength: 4)
+
+    // Se você não precisa de um getter e setter personalizado,
+    // mas ainda quer roda código antes e depois de configurar
+    // uma propriedade, você  pode usar `willSet` e `didSet`
+    var identifier: String = "defaultID" {
+        // o argumento `willSet` será o nome da variável para o novo valor
+        willSet(someIdentifier) {
+            print(someIdentifier)
+        }
+    }
+
+    init(sideLength: Int) {
+        self.sideLength = sideLength
+         // sempre chame super.init por último quand inicializar propriedades personalizadas (custom)
+        super.init()
+    }
+
+    func shrink() {
+        if sideLength > 0 {
+            --sideLength
+        }
+    }
+
+    override func getArea() -> Int {
+        return sideLength * sideLength
+    }
+}
+
+// Uma classe básica `Square` que estende `Rect`
+class Square: Rect {
+    convenience init() {
+        self.init(sideLength: 5)
+    }
+}
+
+var mySquare = Square()
+print(mySquare.getArea()) // 25
+mySquare.shrink()
+print(mySquare.sideLength) // 4
+
+// Compara instâncias, não é o mesmo que == o qual compara objetos
+if mySquare === mySquare {
+    println("Yep, it's mySquare")
+}
+
+
+//
+// MARK: Enums
+//
+
+// Enums podem opcionalmente ser de um tipo específico ou não.
+// Podem conter métodos do mesmo jeito que classes.
+
+enum Suit {
+    case Spades, Hearts, Diamonds, Clubs
+    func getIcon() -> String {
+        switch self {
+        case .Spades: return "♤"
+        case .Hearts: return "♡"
+        case .Diamonds: return "♢"
+        case .Clubs: return "♧"
+        }
+    }
+}
+
+
+//
+// MARK: Protocolos
+//
+
+// `protocol` pode requerer que os tipos que se adequam tenham
+// propriedades de instância, métodos, operadores e subscripts.
+protocol ShapeGenerator {
+    var enabled: Bool { get set }
+    func buildShape() -> Shape
+}
+
+// Protocolos declarados com @objc permitem funções opcionais,
+// que permitem verificar a confomidade
+@objc protocol TransformShape {
+    optional func reshaped()
+    optional func canReshape() -> Bool
+}
+
+class MyShape: Rect {
+    var delegate: TransformShape?
+
+    func grow() {
+        sideLength += 2
+
+        if let allow = self.delegate?.canReshape?() {
+            // test for delegate then for method
+            // testa por delegação e então por método
+            self.delegate?.reshaped?()
+        }
+    }
+}
+
+
+//
+// MARK: Outros
+//
+
+// `extension`s: Adicionam uma funcionalidade extra para um tipo já existente.
+
+// Square agora "segue" o protocolo `Printable`
+extension Square: Printable {
+    var description: String {
+        return "Area: \(self.getArea()) - ID: \(self.identifier)"
+    }
+}
+
+println("Square: \(mySquare)")
+
+// Você pode também estender tipos embutidos (built-in)
+extension Int {
+    var customProperty: String {
+        return "This is \(self)"
+    }
+
+    func multiplyBy(num: Int) -> Int {
+        return num * self
+    }
+}
+
+println(7.customProperty) // "This is 7"
+println(14.multiplyBy(2)) // 42
+
+// Generics: Similar com Java e C#. Use a palavra-chave `where` para
+// especificar os requisitos do generics.
+
+func findIndex<T: Equatable>(array: [T], valueToFind: T) -> Int? {
+    for (index, value) in enumerate(array) {
+        if value == valueToFind {
+            return index
+        }
+    }
+    return nil
+}
+let foundAtIndex = findIndex([1, 2, 3, 4], 3)
+println(foundAtIndex == 2) // true
+
+// Operadores:
+// Operadores personalizados (custom) podem começar com os seguintes caracteres:
+//      / = - + * % < > ! & | ^ . ~
+// ou
+// Unicode math, símbolo, seta, e caracteres tipográficos ou de desenho.
+prefix operator !!! {}
+
+// Um operador de prefixo que triplica o comprimento do lado do quadrado
+// quando usado
+prefix func !!! (inout shape: Square) -> Square {
+    shape.sideLength *= 3
+    return shape
+}
+
+// valor atual
+println(mySquare.sideLength) // 4
+
+// Troca o comprimento do lado usando um operador personalizado !!!, aumenta o lado por 3
+!!!mySquare
+println(mySquare.sideLength) // 12
+
+```
diff --git a/pt-br/visualbasic-pt.html.markdown b/pt-br/visualbasic-pt.html.markdown
new file mode 100644
index 00000000..76cca567
--- /dev/null
+++ b/pt-br/visualbasic-pt.html.markdown
@@ -0,0 +1,285 @@
+---
+language: Visual Basic
+contributors:
+    - ["Brian Martin", "http://brianmartin.biz"]
+translators:
+    - ["AdrianoJP", "https://github.com/AdrianoJP"]
+lang: pt-br
+filename: learnvisualbasic-pt.vb
+---
+
+```vb
+Module Module1
+
+module Module1
+
+    Sub Main ()
+        ' Uma visão geral de console de aplicativos do Visual Basic antes de 
+        ' mergulharmos mais profundamente na linguagem
+        ' Aspas simples começam comentários.
+        ' Para Navegar este tutorial dentro do compilador do Visual Basic, 
+        ' eu criei um sistema de navegação.
+        ' Este sistema de navegação vai ser explicado conforme avançarmos no
+        ' tutorial, e você vai entender o que isso significa.
+        Console.Title = (" Saiba X em Y Minutes" )
+        Console.WriteLine ( "NAVEGAÇÃO" ) 'Mostrar
+        Console.ForegroundColor = ConsoleColor.Green
+        Console.WriteLine ("1. Saída Olá Mundo" )
+        Console.WriteLine ("2. Entrada Olá Mundo" )
+        Console.WriteLine ("3. Cálculando números inteiros " )
+        Console.WriteLine ("4. Calculando números decimais " )
+        Console.WriteLine ("5 . Calculadora de Trabalho " )
+        Console.WriteLine ("6. Usando Do While Loops " )
+        Console.WriteLine ("7. Usando Para While Loops " )
+        Console.WriteLine ("8 . Declarações condicionais " )
+        Console.WriteLine ("9. Selecione uma bebida" )
+        Console.WriteLine ("50 . About" )
+        Console.WriteLine ("Por favor, escolha um número da lista acima " )
+        Seleção Dim As String = Console.ReadLine
+        Select A seleção dos casos
+            Caso "1" 'Output HelloWorld
+                Console.clear () ' Limpa a aplicação e abre o sub privado
+                HelloWorldOutput () ' Nome Private Sub, Abre Private Sub
+            Caso "2" 'Olá entrada
+                Console.clear ( )
+                HelloWorldInput ( )
+            Caso de "3" 'Calculando Números Inteiros
+                Console.clear ( )
+                CalculatingWholeNumbers ( )
+            Caso "4" ' Números decimais Calculting
+                Console.clear ( )
+                CalculatingDecimalNumbers ( )
+            Caso "5" ' Calcculator Trabalho
+                Console.clear ( )
+                WorkingCalculator ( )
+            Caso "6" 'Usando Do While Loops
+                Console.clear ( )
+                UsingDoWhileLoops ( )
+            Caso de "7" 'Usando pois enquanto Loops
+                Console.clear ( )
+                UsingForLoops ( )
+            Caso "8" ' Instruções condicionais
+                Console.clear ( )
+                ConditionalStatement ( )
+            Caso "9" "Declaração If / Else
+                Console.clear ( )
+                IfElseStatement () ' Selecione uma bebida
+            Caso "50" 'Quem caixa de msg
+                Console.clear ( )
+                Console.Title = (" Saiba X em Y Minutos :: Quem " )
+                MsgBox (" Este tutorial é de Brian Martin ( @ BrianMartinn " )
+                Console.clear ( )
+                Main ()
+                Console.ReadLine ()
+
+        End Select
+    End Sub
+
+    ' Um - Eu estou usando números para ajudar com a navegação acima quando eu voltar
+    ' depois de construí-lo .
+
+    " Nós usamos subs privadas para separar diferentes seções do programa.
+    Private Sub HelloWorldOutput ()
+        ' Título de aplicativo do console
+        Console.Title = " Olá Mundo Ouput | Saiba X em Y Minutes"
+        'Use Console.Write ("") ou Console.WriteLine ("") para imprimir saídas.
+        " Seguido por Console.Read () alternativamente Console.ReadLine ()
+        ' Console.ReadLine () imprime a saída para o console.
+        Console.WriteLine ( "Olá Mundo" )
+        Console.ReadLine ()
+    End Sub
+
+    ' Dois
+    Private Sub HelloWorldInput ()
+        Console.Title = " Olá Mundo YourName | Saiba X em Y Minutes"
+        ' Variáveis
+        'Os dados inseridos por um usuário precisa ser armazenada .
+        ' As variáveis ​​também começar com um Dim e terminar com um Como VariableType .
+
+        ' Neste tutorial, nós queremos saber o que o seu nome, e faça o programa
+        ' Responder ao que é dito.
+        Nome de usuário Dim As String
+        " Nós usamos string como string é uma variável de texto baseado .
+        Console.WriteLine (" Olá, Qual é o seu nome? ") ' Peça ao usuário seu nome.
+        username = Console.ReadLine () ' armazena o nome usuários.
+        Console.WriteLine (" Olá " + nome do usuário) " A saída é Olá ' Seu nome '
+        Console.ReadLine () ' Outsputs acima.
+        ' O código acima irá lhe fazer uma pergunta seguiu imprimindo sua resposta.
+        " Outras variáveis ​​incluem Integer e usamos inteiro para números inteiros.
+    End Sub
+
+    "Três
+    Sub CalculatingWholeNumbers particulares ()
+        Console.Title = " Cálculo de Números Inteiros | Saiba X em Y Minutes"
+        Console.Write ("Primeiro número:") 'Digite um número inteiro, 1, 2, 50, 104 ect
+        Dim a As Integer = Console.ReadLine ()
+        Console.Write ("Segundo número:") 'Enter segundo número inteiro.
+        Dim b As Integer = Console.ReadLine ()
+        Dim c As Integer = a + b
+        Console.WriteLine ( c)
+        Console.ReadLine ()
+        " O texto acima é uma calculadora simples
+    End Sub
+
+    'Quatro
+    Sub CalculatingDecimalNumbers particulares ()
+        Console.Title = " Calculando com duplo | Saiba X em Y Minutes"
+        ' Claro que gostaria de ser capaz de somar decimais .
+        " Por isso, poderia mudar o acima de Integer para Double.
+
+        " Digite um número inteiro , 1,2 , 2,4 , 50,1 , 104,9 ect
+        Console.Write ("Primeiro número:")
+        Dim a As Double = Console.ReadLine
+        Console.Write ("Segundo número:") 'Enter segundo número inteiro.
+        Dim b As Double = Console.ReadLine
+        Dim c As Double = a + b
+        Console.WriteLine ( c)
+        Console.ReadLine ()
+        " Portanto, o programa acima pode adicionar até 1,1-2,2
+    End Sub
+
+    ' Cinco
+    Private Sub WorkingCalculator ()
+        Console.Title = " A Calculadora de Trabalho | Saiba X em Y Minutes"
+        " No entanto, se você gostaria que a calculadora para subtrair, dividir , múltiplos e
+        ' somar.
+        ' Copie e cole o código acima novamente .
+        Console.Write ("Primeiro número:")
+        Dim a As Double = Console.ReadLine
+        Console.Write ("Segundo número:") 'Enter segundo número inteiro.
+        Dim b As Integer = Console.ReadLine
+        Dim c As Integer = a + b
+        Dim d As Integer = a * b
+        Dim e As Integer = a - b
+        Dim f As Integer = a / b
+
+        " Ao adicionar as linhas abaixo , somos capazes de calcular a subtração ,
+        ' multply bem como dividir os valores de a e b
+        Console.Gravar ( a.ToString ( ) + " + " + b.ToString ( ) )
+        'Queremos pad as respostas para a esquerda por três espaços.
+        Console.WriteLine (" =" + c.ToString.PadLeft (3) )
+        Console.Gravar ( a.ToString ( ) + " * " + b.ToString ( ) )
+        Console.WriteLine (" =" + d.ToString.PadLeft (3) )
+        Console.Gravar ( a.ToString ( ) + " - " + b.ToString ( ) )
+        Console.WriteLine (" =" + e.ToString.PadLeft (3) )
+        Console.Write ( a.ToString () + "/" + b.ToString ())
+        Console.WriteLine (" =" + e.ToString.PadLeft (3) )
+        Console.ReadLine ()
+
+    End Sub
+
+    ' Seis
+    Sub UsingDoWhileLoops particulares ()
+        ' Assim como o sub privado anterior
+        ' Desta vez, perguntar se o usuário deseja continuar ( Sim ou Não ? )
+        ' Estamos usando Do While Loop , como não temos certeza se o usuário quer usar o
+        'programa mais de uma vez .
+        Console.Title = " UsingDoWhileLoops | Saiba X em Y Minutes"
+        Dim resposta As String ' Nós usamos a variável " String" como a resposta é um texto
+        Do ' Começamos o programa com
+            Console.Write ("Primeiro número:")
+            Dim a As Double = Console.ReadLine
+            Console.Write ("Segundo número:")
+            Dim b As Integer = Console.ReadLine
+            Dim c As Integer = a + b
+            Dim d As Integer = a * b
+            Dim e As Integer = a - b
+            Dim f As Integer = a / b
+
+            Console.Gravar ( a.ToString ( ) + " + " + b.ToString ( ) )
+            Console.WriteLine (" =" + c.ToString.PadLeft (3) )
+            Console.Gravar ( a.ToString ( ) + " * " + b.ToString ( ) )
+            Console.WriteLine (" =" + d.ToString.PadLeft (3) )
+            Console.Gravar ( a.ToString ( ) + " - " + b.ToString ( ) )
+            Console.WriteLine (" =" + e.ToString.PadLeft (3) )
+            Console.Write ( a.ToString () + "/" + b.ToString ())
+            Console.WriteLine (" =" + e.ToString.PadLeft (3) )
+            Console.ReadLine ()
+            ' Faça a pergunta , se o usuário deseja continuar? Infelizmente,
+            "é sensível a maiúsculas.
+            Console.Write ( "Deseja continuar? (Sim / não )")
+            " O programa pega a variável e imprime e começa de novo.
+            answer = Console.ReadLine
+        " O comando para a variável para trabalhar seria , neste caso, " sim "
+        Loop While resposta = "yes"
+
+    End Sub
+
+    ' Sete
+    Sub UsingForLoops particulares ()
+        ' Às vezes, o programa só precisa ser executado uma vez.
+        " Neste programa vamos estar em contagem regressiva a partir de 10.
+
+        Console.Title = " Usando Para Loops | Saiba X em Y Minutes"
+        'Declare variável e qual o número que deve contar para baixo na etapa 1,
+        ' Passo -2, -3 Passo ect.
+        Para i As Integer = 10 para 0 passo -1
+            Console.WriteLine ( i.ToString ) ' Imprime o valor do contador
+        Next i ' Calcular novo valor
+        Console.WriteLine ( "Start ") ' Vamos começar o bebê programa !
+        Console.ReadLine () ' POW ! - Talvez eu fiquei um pouco animado, então :)
+    End Sub
+
+    ' Oito
+    Private Sub ConditionalStatement ()
+        Console.Title = " Instruções condicionais | Saiba X em Y Minutes"
+        UserName Dim As String = Console.ReadLine
+        Console.WriteLine (" Olá, Qual é o seu nome? ") ' Peça ao usuário seu nome.
+        username = Console.ReadLine () ' armazena o nome usuários.
+        Se userName = " Adam " Então
+            Console.WriteLine (" Olá Adam " )
+            Console.WriteLine (" Obrigado por criar este site útil " )
+            Console.ReadLine ()
+        outro
+            Console.WriteLine (" Olá " + nome do usuário)
+            Console.WriteLine (" Você check-out www.learnxinyminutes.com " )
+            Console.ReadLine () ' Fins e imprime a declaração acima .
+        End If
+    End Sub
+
+    'Nove
+    Private Sub IfElseStatement ()
+    Console.Title = "Se Declaração / Else | Saiba X em Y Minutes"
+        'Às vezes é importante ter em conta mais de duas alternativas.
+        'Às vezes, há um bom número de outros.
+        'Quando este for o caso , mais do que uma if seria necessária .
+        'Uma instrução if é ótimo para máquinas de venda automática . Quando o usuário digita um código.
+        ' A1 , A2, A3 , ect para selecionar um item.
+        'Todas as opções podem ser combinadas em uma única if.
+
+        Seleção Dim Valor String = Console.ReadLine ' para a seleção
+            Console.WriteLine (" A1. Para Soda " )
+            Console.WriteLine (" A2. Para Fanta " )
+            Console.WriteLine (" A3 . Para Guaraná" )
+            Console.WriteLine (" A4. Para Coca Diet" )
+            Console.ReadLine ()
+            Se a seleção = "A1" Então
+                Console.WriteLine (" soda " )
+                Console.ReadLine ()
+            Seleção ElseIf = " A2 " Então
+                Console.WriteLine (" fanta " )
+                Console.ReadLine ()
+            Seleção ElseIf = " A3 " Então
+                Console.WriteLine ( "guaraná" )
+                Console.ReadLine ()
+            Seleção ElseIf = " A4 " Então
+                Console.WriteLine ( "coca diet" )
+                Console.ReadLine ()
+            outro
+                Console.WriteLine (" Por favor seleccione um produto" )
+                Console.ReadLine ()
+            End If
+
+    End Sub
+
+End Module
+
+```
+
+##Referências
+
+Aprendi Visual Basic no aplicativo de console. Isso me permitiu entender os princípios da programação de computador para continuar a aprender outras linguagens de programação facilmente.
+
+Eu criei um tutorial mais aprofundado do <a href="http://www.vbbootcamp.co.uk/" Title="Visual Basic Tutorial">Visual Basic</a> para aqueles que gostariam de saber mais.
+
+Toda a sintaxe deste tutorial é válida. Copie e cole o código no compilador do Visual Basic e execute (com o F5) o programa.
diff --git a/pt-br/xml-pt.html.markdown b/pt-br/xml-pt.html.markdown
new file mode 100644
index 00000000..f347f8ef
--- /dev/null
+++ b/pt-br/xml-pt.html.markdown
@@ -0,0 +1,133 @@
+---
+language: xml
+filename: learnxml-pt.xml
+contributors:
+    - ["João Farias", "https://github.com/JoaoGFarias"]
+translators:
+    - ["Miguel Araújo", "https://github.com/miguelarauj1o"]
+lang: pt-br
+---
+
+XML é uma linguagem de marcação projetada para armazenar e transportar dados.
+
+Ao contrário de HTML, XML não especifica como exibir ou formatar os dados, 
+basta carregá-lo.
+
+* Sintaxe XML
+
+```xml
+<!-- Comentários em XML são feitos desta forma -->
+
+<?xml version="1.0" encoding="UTF-8"?>
+<livraria>
+	<livro category="COZINHA">
+		<titulo lang="en">Everyday Italian</titulo>
+		<autor>Giada De Laurentiis</autor>
+		<year>2005</year>
+		<preco>30.00</preco>
+	</livro>
+	<livro category="CRIANÇAS">
+		<titulo lang="en">Harry Potter</titulo>
+		<autor>J K. Rowling</autor>
+		<year>2005</year>
+		<preco>29.99</preco>
+	</livro>
+	<livro category="WEB">
+		<titulo lang="en">Learning XML</titulo>
+		<autor>Erik T. Ray</autor>
+		<year>2003</year>
+		<preco>39.95</preco>
+	</livro>
+</livraria>
+
+<!-- Um típico arquivo XML é mostrado acima.
+	Ele começa com uma declaração, informando alguns metadados (opcional).
+	
+	XML usa uma estrutura de árvore. Acima, o nó raiz é "Livraria", que tem
+	três nós filhos, todos os 'Livros'. Esses nós tem mais nós filhos, 
+	e assim por diante...
+	
+	Nós são criados usando tags abre/fecha, filhos são justamente os nós que 
+	estão entre estes nós. -->
+
+
+<!-- XML traz dois tipos de dados:
+	1 - Atributos -> Isso é metadados sobre um nó.
+			Normalmente, o parser XML usa esta informação para armazenar os dados
+			corretamente. Caracteriza-se por aparecer em parênteses dentro da tag 
+			de abertura.
+	2 - Elementos -> É dados puros.
+			Isso é o que o analisador irá recuperar a partir do arquivo XML. 
+			Elementos aparecem entre as tags de abertura e fechamento, 
+			sem parênteses. -->
+			
+	
+<!-- Abaixo, um elemento com dois atributos -->
+<arquivo type="gif" id="4293">computer.gif</arquivo>
+
+
+```
+
+* Documento bem formatado x Validação
+
+Um documento XML é bem formatado se estiver sintaticamente correto.No entanto,
+é possível injetar mais restrições no documento, utilizando definições de 
+documentos, tais como DTD e XML Schema.
+
+Um documento XML que segue uma definição de documento é chamado válido, sobre 
+esse documento.
+
+Com esta ferramenta, você pode verificar os dados XML fora da lógica da aplicação.
+
+```xml
+
+<!-- Abaixo, você pode ver uma versão simplificada do documento livraria,
+com a adição de definição DTD.-->
+
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE note SYSTEM "livraria.dtd">
+<livraria>
+	<livro category="COOKING">
+		<titulo >Everyday Italian</titulo>
+		<preco>30.00</preco>
+	</livro>
+</livraria>
+
+<!-- Este DTD poderia ser algo como:-->
+
+<!DOCTYPE note
+[
+<!ELEMENT livraria (livro+)>
+<!ELEMENT livro (titulo,preco)>
+<!ATTLIST livro category CDATA "Literature">
+<!ELEMENT titulo (#PCDATA)>
+<!ELEMENT preco (#PCDATA)>
+]>
+
+
+<!-- O DTD começa com uma declaração.
+	Na sequência, o nó raiz é declarado, o que requer uma ou mais crianças nós 
+	'Livro'. Cada 'Livro' deve conter exatamente um 'titulo' e um 'preco' e um 
+	atributo chamado "categoria", com "Literatura", como o valor padrão.
+	Os nós "título" e "preço" contêm um conjunto de dados de caráter analisados.-->
+
+<!-- O DTD poderia ser declarado dentro do próprio arquivo XML .-->
+
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!DOCTYPE note
+[
+<!ELEMENT livraria (livro+)>
+<!ELEMENT livro (titulo,preco)>
+<!ATTLIST livro category CDATA "Literature">
+<!ELEMENT titulo (#PCDATA)>
+<!ELEMENT preco (#PCDATA)>
+]>
+
+<livraria>
+	<livro category="COOKING">
+		<titulo >Everyday Italian</titulo>
+		<preco>30.00</preco>
+	</livro>
+</livraria>
+```