summaryrefslogtreecommitdiffhomepage
path: root/pt-br
diff options
context:
space:
mode:
Diffstat (limited to 'pt-br')
-rw-r--r--pt-br/brainfuck-pt.html.markdown84
-rw-r--r--pt-br/c++-pt.html.markdown590
-rw-r--r--pt-br/clojure-pt.html.markdown384
-rw-r--r--pt-br/common-lisp-pt.html.markdown622
-rw-r--r--pt-br/git-pt.html.markdown312
-rw-r--r--pt-br/hy-pt.html.markdown176
-rw-r--r--pt-br/swift-pt.html.markdown500
-rw-r--r--pt-br/xml-pt.html.markdown133
8 files changed, 2650 insertions, 151 deletions
diff --git a/pt-br/brainfuck-pt.html.markdown b/pt-br/brainfuck-pt.html.markdown
new file mode 100644
index 00000000..c7ce55ee
--- /dev/null
+++ b/pt-br/brainfuck-pt.html.markdown
@@ -0,0 +1,84 @@
+---
+language: brainfuck
+contributors:
+ - ["Prajit Ramachandran", "http://prajitr.github.io/"]
+ - ["Mathias Bynens", "http://mathiasbynens.be/"]
+translators:
+ - ["Suzane Sant Ana", "http://github.com/suuuzi"]
+lang: pt-br
+---
+
+Brainfuck (em letras minúsculas, eceto 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 vaor 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..61625ebe
--- /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ê está modificando-os ou referência const se você não é.
+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/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/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/git-pt.html.markdown b/pt-br/git-pt.html.markdown
index 6d2a55cd..981da503 100644
--- a/pt-br/git-pt.html.markdown
+++ b/pt-br/git-pt.html.markdown
@@ -1,110 +1,119 @@
---
category: tool
tool: git
+lang: pt-br
+filename: LearnGit.txt
contributors:
- ["Jake Prather", "http://github.com/JakeHP"]
translators:
- - ["Miguel Araújo", "https://github.com/miguelarauj1o"]
-lang: pt-br
-filename: learngit-pt.txt
+ - ["Suzane Sant Ana", "http://github.com/suuuzi"]
---
-Git é um sistema de controle de versão distribuído e de gerenciamento de código-fonte.
+Git é um sistema distribuido de gestão para código fonte e controle de versões.
-Ele faz isso através de uma série de momentos instantâneos de seu projeto, e ele funciona
-com esses momentos para lhe fornecer a funcionalidade para a versão e
-gerenciar o seu código-fonte.
+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.
-## Versionando Conceitos
+## Conceitos de versionamento
-### O que é controle de versão?
+### O que é controle de versão
-O controle de versão é um sistema que registra alterações em um arquivo ou conjunto
-de arquivos, ao longo do tempo.
+Controle de versão (*source control*) é um processo de registo de alterações
+a um arquivo ou conjunto de arquivos ao longo do tempo.
-### Versionamento Centralizado VS Versionamento Distribuído
+### Controle de versão: Centralizado VS Distribuído
-* Controle de versão centralizado concentra-se na sincronização, controle e backup de arquivos.
-* Controle de versão distribuído concentra-se na partilha de mudanças. Toda mudança tem um ID único.
-* Sistemas Distribuídos não têm estrutura definida. Você poderia facilmente ter um estilo SVN,
-sistema centralizado, com git.
+* 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](http://git-scm.com/book/en/Getting-Started-About-Version-Control)
+[Informação adicional (EN)](http://git-scm.com/book/en/Getting-Started-About-Version-Control)
-### Porque usar o Git?
+### Por que usar git?
-* Possibilidade de trabalhar offline
-* Colaborar com os outros é fácil!
-* Ramificação é fácil
-* Mesclagem é fácil
-* Git é rápido
-* Git é flexível.
+* Permite trabalhar offline.
+* Colaborar com outros é fácil!
+* Criar *branches* é fácil!
+* Fazer *merge* é fácil!
+* Git é rápido.
+* Git é flexivel.
+
+## Git - Arquitetura
-## Arquitetura Git
### Repositório
-Um conjunto de arquivos, diretórios, registros históricos, cometes, e cabeças. Imagine-o
-como uma estrutura de dados de código-fonte, com o atributo que cada "elemento" do
-código-fonte dá-lhe acesso ao seu histórico de revisão, entre outras coisas.
+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 é composto do diretório git. e árvore de trabalho.
+Um repositório git é constituido pelo diretório .git e a *working tree*
### Diretório .git (componente do repositório)
-O diretório git. contém todas as configurações, registros, galhos, cabeça(HEAD) e muito mais.
-[Lista Detalhada](http://gitready.com/advanced/2009/03/23/whats-inside-your-git-directory.html)
+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)
-### Árvore de trabalho (componente do repositório)
+### *Working Tree* (componente do repositório)
-Esta é, basicamente, os diretórios e arquivos no seu repositório. Ele é muitas vezes referida
-como seu diretório de trabalho.
+A *Working Tree* é basicamente a listagem dos diretórios e arquivos do repositório. É chamada também de diretório do projeto.
-### Índice (componente do diretório .git)
+### *Index* (componente do diretório .git)
-O Índice é a área de teste no git. É basicamente uma camada que separa a sua árvore de trabalho
-a partir do repositório Git. Isso dá aos desenvolvedores mais poder sobre o que é enviado para o
-repositó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.
-### Comete (commit)
+### *Commit*
-A commit git é um instantâneo de um conjunto de alterações ou manipulações a sua árvore de trabalho.
-Por exemplo, se você adicionou 5 imagens, e removeu outros dois, estas mudanças serão contidas
-em um commit (ou instantâneo). Esta confirmação pode ser empurrado para outros repositórios, ou não!
+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!
-### Ramo (branch)
+### *Branch*
-Um ramo é, essencialmente, um ponteiro que aponta para o último commit que você fez. Como
-você se comprometer, este ponteiro irá atualizar automaticamente e apontar para o último commit.
+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.
-### Cabeça (HEAD) e cabeça (head) (componente do diretório .git)
+### *HEAD* e *head* (componentes do diretório .git)
-HEAD é um ponteiro que aponta para o ramo atual. Um repositório tem apenas 1 * ativo * HEAD.
-head é um ponteiro que aponta para qualquer commit. Um repositório pode ter qualquer número de commits.
+*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
+### Recursos conceituais (EN)
-* [Git para Cientistas da Computação](http://eagain.net/articles/git-for-computer-scientists/)
+* [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
+### *init*
-Criar um repositório Git vazio. As configurações do repositório Git, informações armazenadas,
-e mais são armazenados em um diretório (pasta) com o nome ". git".
+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
+### *config*
-Para configurar as definições. Quer seja para o repositório, o próprio sistema, ou
-configurações globais.
+Permite configurar as definições, sejam as definições do repositório, sistema
+ou configurações globais.
```bash
-# Impressão e definir algumas variáveis ​​de configuração básica (global)
+# Imprime e define algumas variáveis de configuração básicas (global)
$ git config --global user.email
$ git config --global user.name
@@ -112,22 +121,21 @@ $ git config --global user.email "MyEmail@Zoho.com"
$ git config --global user.name "My Name"
```
-[Saiba mais sobre o git config.](http://git-scm.com/docs/git-config)
+[Aprenda mais sobre git config. (EN)](http://git-scm.com/docs/git-config)
### help
-Para lhe dar um acesso rápido a um guia extremamente detalhada de cada comando. ou
-apenas dar-lhe um rápido lembrete de algumas semânticas.
+Para visualizar rapidamente o detalhamento de cada comando ou apenas lembrar da semântica.
```bash
-# Rapidamente verificar os comandos disponíveis
+# Ver rapidamente os comandos disponiveis
$ git help
-# Confira todos os comandos disponíveis
+# Ver todos os comandos disponiveis
$ git help -a
-# Ajuda específica de comando - manual do usuário
-# git help <command_here>
+# Usar o *help* para um comando especifico
+# git help <comando_aqui>
$ git help add
$ git help commit
$ git help init
@@ -135,85 +143,89 @@ $ git help init
### status
-Para mostrar as diferenças entre o arquivo de índice (basicamente o trabalho de
-copiar/repo) e a HEAD commit corrente.
+Apresenta as diferenças entre o arquivo *index* (a versão corrente
+do repositório) e o *commit* da *HEAD* atual.
+
```bash
-# Irá exibir o ramo, os arquivos não monitorados, as alterações e outras diferenças
+# Apresenta o *branch*, arquivos não monitorados, alterações e outras
+# difereças
$ git status
-# Para saber outras "tid bits" sobre git status
+# Para aprender mais detalhes sobre git *status*
$ git help status
```
### add
-Para adicionar arquivos para a atual árvore/directory/repo trabalho. Se você não
-der `git add` nos novos arquivos para o trabalhando árvore/diretório, eles não serão
-incluídos em commits!
+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
-# Adicionar um arquivo no seu diretório de trabalho atual
+# adiciona um arquivo no diretório do projeto atual
$ git add HelloWorld.java
-# Adicionar um arquivo em um diretório aninhado
+# adiciona um arquivo num sub-diretório
$ git add /path/to/file/HelloWorld.c
-# Suporte a expressões regulares!
+# permite usar expressões regulares!
$ git add ./*.java
```
### branch
-Gerenciar seus ramos. Você pode visualizar, editar, criar, apagar ramos usando este comando.
+Gerencia os *branches*. É possível ver, editar, criar e apagar branches com este
+comando.
```bash
-# Lista ramos e controles remotos existentes
+# listar *branches* existentes e remotos
$ git branch -a
-# Criar um novo ramo
+# criar um novo *branch*
$ git branch myNewBranch
-# Apagar um ramo
+# apagar um *branch*
$ git branch -d myBranch
-# Renomear um ramo
+# alterar o nome de um *branch*
# git branch -m <oldname> <newname>
$ git branch -m myBranchName myNewBranchName
-# Editar a descrição de um ramo
+# editar a descrição de um *branch*
$ git branch myBranchName --edit-description
```
### checkout
-Atualiza todos os arquivos na árvore de trabalho para corresponder à versão no
-índice, ou árvore especificada.
+Atualiza todos os arquivos no diretório do projeto para que fiquem iguais
+à versão do index ou do *branch* especificado.
```bash
-# Finalizar um repo - padrão de ramo mestre
+# Checkout de um repositório - por padrão para o branch master
$ git checkout
-# Checa um ramo especificado
+# Checkout de um branch especifico
$ git checkout branchName
-# Criar um novo ramo e mudar para ela, como: "<nome> git branch; git checkout <nome>"
+# Cria um novo branch e faz checkout para ele.
+# Equivalente a: "git branch <name>; git checkout <name>"
$ git checkout -b newBranch
```
### clone
-Clones, ou cópias, de um repositório existente para um novo diretório. Ele também adiciona
-filiais remotas de rastreamento para cada ramo no repo clonado, que permite que você empurre
-a um ramo remoto.
+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
-# Clone learnxinyminutes-docs
+# Clona learnxinyminutes-docs
$ git clone https://github.com/adambard/learnxinyminutes-docs.git
```
### commit
-Armazena o conteúdo atual do índice em um novo "commit". Este commit contém
-as alterações feitas e uma mensagem criada pelo utilizador.
+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
@@ -222,170 +234,170 @@ $ git commit -m "Added multiplyNumbers() function to HelloWorld.c"
### diff
-Mostra as diferenças entre um arquivo no diretório, o índice de trabalho e commits.
+Apresenta as diferenças entre um arquivo no repositório do projeto, *index*
+e *commits*
```bash
-# Mostrar diferença entre o seu diretório de trabalho e o índice.
+# Apresenta a diferença entre o diretório atual e o index
$ git diff
-# Mostrar diferenças entre o índice e o commit mais recente.
+# Apresenta a diferença entre o index e os commits mais recentes
$ git diff --cached
-# Mostrar diferenças entre o seu diretório de trabalho e o commit mais recente.
+# Apresenta a diferença entre o diretório atual e o commit mais recente
$ git diff HEAD
```
### grep
-Permite procurar rapidamente um repositório.
+Permite procurar facilmente num repositório
Configurações opcionais:
```bash
-# Obrigado ao Travis Jeffery por isto
-# Configure os números de linha a serem mostrados nos resultados de busca grep
+# Define a apresentação de números de linha nos resultados do grep
$ git config --global grep.lineNumber true
-# Fazer resultados de pesquisa mais legível, incluindo agrupamento
+# Agrupa os resultados da pesquisa para facilitar a leitura
$ git config --global alias.g "grep --break --heading --line-number"
```
```bash
-# Procure por "variableName" em todos os arquivos java
+# Pesquisa por "variableName" em todos os arquivos java
$ git grep 'variableName' -- '*.java'
-# Procure por uma linha que contém "arrayListName" e "adicionar" ou "remover"
-$ git grep -e 'arrayListName' --and \( -e add -e remove \)
+# Pesquisa por uma linha que contém "arrayListName" e "add" ou "remove"
+$ git grep -e 'arrayListName' --and \( -e add -e remove \)
```
-Google é seu amigo; para mais exemplos
-[Git Grep Ninja](http://travisjeffery.com/b/2012/02/search-a-git-repo-like-a-ninja)
+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
-Mostrar commits para o repositório.
+Apresenta commits do repositório.
```bash
-# Mostrar todos os commits
+# Apresenta todos os commits
$ git log
-# Mostrar um número X de commits
+# Apresenta X commits
$ git log -n 10
-# Mostrar somente commits mesclados
+# Apresenta apenas commits de merge
$ git log --merges
```
### merge
-"Merge" em mudanças de commits externos no branch atual.
+"Merge" junta as alterações de commits externos com o *branch* atual.
```bash
-# Mesclar o ramo especificado para o atual.
+# Junta o branch especificado com o atual
$ git merge branchName
-# Gera sempre uma mesclagem commit ao mesclar
+# Para gerar sempre um commit ao juntar os branches
$ git merge --no-ff branchName
```
### mv
-Renomear ou mover um arquivo
+Alterar o nome ou mover um arquivo.
```bash
-# Renomear um arquivo
+# Alterar o nome de um arquivo
$ git mv HelloWorld.c HelloNewWorld.c
# Mover um arquivo
$ git mv HelloWorld.c ./new/path/HelloWorld.c
-# Força renomear ou mover
-# "ExistingFile" já existe no diretório, será substituído
+# 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 de um repositório e se funde com outro ramo.
+Puxa alterações de um repositório e as junta com outro branch
```bash
-# Atualize seu repo local, através da fusão de novas mudanças
-# A partir da "origem" remoto e ramo "master (mestre)".
+# Atualiza o repositório local, juntando as novas alterações
+# do repositório remoto 'origin' e branch 'master'
# git pull <remote> <branch>
-# git pull => implícito por padrão => git pull origin master
+# git pull => aplica a predefinição => git pull origin master
$ git pull origin master
-# Mesclar em mudanças de ramo remoto e rebase
-# Ramo commita em seu repo local, como: "git pull <remote> <branch>, git rebase <branch>"
+# 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
-Empurre e mesclar as alterações de uma ramificação para uma remota e ramo.
+Enviar e juntar alterações de um branch para o seu branch correspondente
+num repositório remoto.
```bash
-# Pressione e mesclar as alterações de um repo local para um
-# Chamado remoto "origem" e ramo de "mestre".
+# 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 => implícito por padrão => git push origin master
+# git push => aplica a predefinição => git push origin master
$ git push origin master
-
-# Para ligar atual filial local com uma filial remota, bandeira add-u:
-$ git push -u origin master
-# Agora, a qualquer hora que você quer empurrar a partir desse mesmo ramo local, uso de atalho:
-$ git push
```
-### rebase (CAUTELA)
+### rebase (cautela!)
-Tire todas as alterações que foram commitadas em um ramo, e reproduzi-las em outro ramo.
-* Não rebase commits que você tenha empurrado a um repo público *.
+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
-# Rebase experimentBranch para mestre
+# Faz Rebase de experimentBranch para master
# git rebase <basebranch> <topicbranch>
$ git rebase master experimentBranch
```
-[Leitura Adicional.](http://git-scm.com/book/en/Git-Branching-Rebasing)
+[Leitura adicional (EN).](http://git-scm.com/book/en/Git-Branching-Rebasing)
-### reset (CAUTELA)
+### reset (cuidado!)
-Repor o atual HEAD de estado especificado. Isto permite-lhe desfazer fusões (merge),
-puxa (push), commits, acrescenta (add), e muito mais. É um grande comando, mas também
-perigoso se não saber o que se está fazendo.
+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
-# Repor a área de teste, para coincidir com o último commit (deixa diretório inalterado)
+# Restabelece a camada intermediária de registo para o último
+# commit (o directório fica sem alterações)
$ git reset
-# Repor a área de teste, para coincidir com o último commit, e substituir diretório trabalhado
+# Restabelece a camada intermediária de registo para o último commit, e
+# sobrescreve o projeto atual
$ git reset --hard
-# Move a ponta ramo atual para o especificado commit (deixa diretório inalterado)
-# Todas as alterações ainda existem no diretório.
+# 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
-# Move a ponta ramo atual para trás, para o commit especificado
-# E faz o jogo dir trabalho (exclui mudanças não commitadas e todos os commits
-# Após o commit especificado).
+# 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 do git add, git rm remove arquivos da atual árvore de trabalho.
+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 diretório aninhado
+# Remove um arquivo de um sub-directório
$ git rm /pather/to/the/file/HelloWorld.c
```
-# # Mais informações
+## Informação complementar (EN)
* [tryGit - A fun interactive way to learn Git.](http://try.github.io/levels/1/challenges/1)
@@ -398,5 +410,3 @@ $ git rm /pather/to/the/file/HelloWorld.c
* [SalesForce Cheat Sheet](https://na1.salesforce.com/help/doc/en/salesforce_git_developer_cheatsheet.pdf)
* [GitGuys](http://www.gitguys.com/)
-
-* [Git - guia prático](http://rogerdudler.github.io/git-guide/index.pt_BR.html) \ No newline at end of file
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/swift-pt.html.markdown b/pt-br/swift-pt.html.markdown
new file mode 100644
index 00000000..72a57e4a
--- /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...) {
+ // its an 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/xml-pt.html.markdown b/pt-br/xml-pt.html.markdown
new file mode 100644
index 00000000..40ddbc3a
--- /dev/null
+++ b/pt-br/xml-pt.html.markdown
@@ -0,0 +1,133 @@
+---
+language: xml
+filename: learnxml.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>
+``` \ No newline at end of file