Merge remote-tracking branch 'upstream/master' into master

33 files changed, 2840 insertions, 1494 deletions

diff --git a/pt-br/awk-pt.html.markdown b/pt-br/awk-pt.html.markdown
index 9bf770fd..70d0a01c 100644
--- a/pt-br/awk-pt.html.markdown
+++ b/pt-br/awk-pt.html.markdown
@@ -317,8 +317,8 @@ a > 0 {
 
 # Aqui está um exemplo rápido de um script simples, o tipo de coisa que o AWK
 # é perfeito para fazer. Ele irá ler um nome da entrada padrão e depois
-imprimirá a média de idade de todos com esse primeiro nome. Digamos que você
-forneça como argumento o nome de um arquivo com esses dados:
+# imprimirá a média de idade de todos com esse primeiro nome. Digamos que você
+# forneça como argumento o nome de um arquivo com esses dados:
 
 # Bob Jones 32
 # Jane Doe 22
diff --git a/pt-br/bash-pt.html.markdown b/pt-br/bash-pt.html.markdown
index 3a48d994..988e8e7d 100644
--- a/pt-br/bash-pt.html.markdown
+++ b/pt-br/bash-pt.html.markdown
@@ -33,7 +33,7 @@ diretamente no shell.
 # Exemplo simples de hello world:
 echo Hello World!
 
-# Cada comando começa com uma nova linha, ou após um ponto virgula:
+# Cada comando começa com uma nova linha, ou após um ponto e vírgula:
 echo 'Essa é a primeira linha'; echo 'Essa é a segunda linha'
 
 # A declaração de variáveis é mais ou menos assim
@@ -41,14 +41,14 @@ Variavel="Alguma string"
 
 # Mas não assim:
 Variavel = "Alguma string"
-# Bash interpretará Variavel como um comando e tentará executar e lhe retornar
+# Bash interpretará Variavel como um comando e tentará executar e lhe retornará
 # um erro porque o comando não pode ser encontrado.
 
 # Ou assim:
 Variavel= 'Alguma string'
-# Bash interpretará 'Alguma string' como um comando e tentará executar e lhe retornar
-# um erro porque o comando não pode ser encontrado. (Nesse caso a a parte 'Variavel=' 
-# é vista com uma declaração de variável valida apenas para o escopo do comando 'Uma string').
+# Bash interpretará 'Alguma string' como um comando e tentará executar e lhe retornará
+# um erro porque o comando não pôde ser encontrado. (Nesse caso a a parte 'Variavel=' 
+# é vista com uma declaração de variável válida apenas para o escopo do comando 'Uma string').
 
 # Usando a variável:
 echo $Variavel
@@ -65,15 +65,15 @@ echo ${Variavel/Alguma/Uma}
 # Substring de uma variável
 Tamanho=7
 echo ${Variavel:0:Tamanho}
-# Isso retornará apenas os 7 primeiros caractéres da variável
+# Isso retornará apenas os 7 primeiros caracteres da variável
 
 # Valor padrão de uma variável
 echo ${Foo:-"ValorPadraoSeFooNaoExistirOuEstiverVazia"}
 # Isso funciona para nulo (Foo=) e (Foo=""); zero (Foo=0) retorna 0.
-# Note que isso apenas retornar o valor padrão e não mudar o valor da variável.
+# Note que isso apenas retornará o valor padrão e não mudará o valor da variável.
 
 # Variáveis internas
-# Tem algumas variáveis internas bem uteis, como
+# Tem algumas variáveis internas bem úteis, como
 echo "O ultimo retorno do programa: $?"
 echo "PID do script: $$"
 echo "Numero de argumentos passados para o script $#"
@@ -86,7 +86,7 @@ read Nome # Note que nós não precisamos declarar a variável
 echo Ola, $Nome
 
 # Nós temos a estrutura if normal:
-# use 'man test' para mais infomações para as condicionais
+# use 'man test' para mais informações para as condicionais
 if [ $Nome -ne $USER ]
 then
 	echo "Seu nome não é o seu username"
@@ -109,7 +109,7 @@ then
 	echo "Isso vai rodar se $Nome é Daniela ou Jose."
 fi
 
-# Expressões são denotadas com o seguinte formato
+# Expressões são escritas com o seguinte formato
 echo $(( 10 + 5))
 
 # Diferentemente das outras linguagens de programação, bash é um shell, então ele 
@@ -118,9 +118,9 @@ echo $(( 10 + 5))
 ls
 
 #Esse comando tem opções que controlam sua execução
-ls -l # Lista todo arquivo e diretorio em linhas separadas
+ls -l # Lista todo arquivo e diretório em linhas separadas
 
-# Os resultados do comando anterior pode ser passado para outro comando como input.
+# Os resultados do comando anterior podem ser passados para outro comando como input.
 # O comando grep filtra o input com o padrão passado. É assim que listamos apenas
 # os arquivos .txt no diretório atual:
 ls -l | grep "\.txt"
@@ -165,7 +165,7 @@ echo "#helloworld" | tee output.out > /dev/null
 rm -v output.out error.err output-and-error.log
 
 # Comando podem ser substituídos por outros comandos usando $( ):
-# O comando a seguir mostra o número de arquivos e diretórios no diretorio atual
+# O comando a seguir mostra o número de arquivos e diretórios no diretório atual
 echo "Existem $(ls | wc -l) itens aqui."
 
 # O mesmo pode ser feito usando crase `` mas elas não podem ser aninhadas - dá se 
@@ -241,14 +241,14 @@ head -n 10 arquivo.txt
 sort arquivo.txt
 # reporta ou omite as linhas repetidas, com -d você as reporta
 uniq -d arquivo.txt
-# exibe apenas a primeira coluna após o caráctere ','
+# exibe apenas a primeira coluna após o caractere ','
 cut -d ',' -f 1 arquivo.txt
 # substitui todas as ocorrencias de 'okay' por 'legal' em arquivo.txt (é compativel com regex)
 sed -i 's/okay/legal/g' file.txt
 # exibe para o stdout todas as linhas do arquivo.txt que encaixam com o regex
 # O exemplo exibe linhas que começam com "foo" e terminam com "bar"
 grep "^foo.*bar$" arquivo.txt
-# passe a opção "-c" para ao invês de imprimir o numero da linha que bate com o regex
+# passe a opção "-c" para ao invés de imprimir o número da linha que bate com o regex
 grep -c "^foo.*bar$" arquivo.txt
 # se você quer literalmente procurar por uma string,
 # e não pelo regex, use fgrep (ou grep -F)
diff --git a/pt-br/c-pt.html.markdown b/pt-br/c-pt.html.markdown
index e1c27958..4e55f068 100644
--- a/pt-br/c-pt.html.markdown
+++ b/pt-br/c-pt.html.markdown
@@ -8,6 +8,7 @@ translators:
     - ["João Farias", "https://github.com/JoaoGFarias"]
     - ["Elton Viana", "https://github.com/eltonvs"]
     - ["Cássio Böck", "https://github.com/cassiobsilva"]
+    - ["Heitor P. de Bittencourt", "https://github.com/heitorPB/"]
 lang: pt-br
 filename: c-pt.el
 ---
@@ -641,7 +642,7 @@ typedef void (*minha_função_type)(char *);
 Este é *o* livro sobre C, escrito pelos criadores da linguagem. Mas cuidado - ele é antigo e contém alguns erros (bem,
 ideias que não são mais consideradas boas) ou práticas ultrapassadas.
 
-Outra boa referência é [Learn C the hard way](http://c.learncodethehardway.org/book/).
+Outra boa referência é [Learn C the hard way](http://learncodethehardway.org/c/).
 
 Se você tem uma pergunta, leia [compl.lang.c Frequently Asked Questions](http://c-faq.com).
 
diff --git a/pt-br/clojure-macros-pt.html.markdown b/pt-br/clojure-macros-pt.html.markdown
index d56840e0..c686bb80 100644
--- a/pt-br/clojure-macros-pt.html.markdown
+++ b/pt-br/clojure-macros-pt.html.markdown
@@ -13,15 +13,15 @@ do Clojure lhe dá acesso a toda a extensão da linguagem
 para escrever rotinas de geração de código chamados "macros". Macros fornecem uma poderosa forma de adequar a linguagem 
 às suas necessidades.
 
-Pórem Tenha cuidado. É considerado má pratica escrever uma macro quando uma função vai fazer. Use uma macro apenas 
-quando você precisar do controle sobre quando ou se os argumentos para um formulário será avaliado.
+Pórem, tenha cuidado. É considerado má pratica escrever uma macro quando uma função vai fazer. Use uma macro apenas 
+quando você precisar de controle sobre quando ou se os argumentos de um formulário serão avaliados.
 
 Você vai querer estar familiarizado com Clojure. Certifique-se de entender tudo em 
-[Clojure em Y Minutos](/docs/clojure/).
+[Aprenda Clojure em Y Minutos](/docs/clojure/).
 
 ```clojure
-;; Defina uma macro utilizando defmacro. Sua macro deve ter como saida uma lista que possa
-;; ser avaliada como codigo Clojure.
+;; Defina uma macro utilizando defmacro. Sua macro deve ter como saída uma lista que possa
+;; ser avaliada como código Clojure.
 ;;
 ;; Essa macro é a mesma coisa que se você escrever (reverse "Hello World")
 (defmacro my-first-macro []
@@ -33,14 +33,14 @@ Você vai querer estar familiarizado com Clojure. Certifique-se de entender tudo
 (macroexpand '(my-first-macro))
 ;; -> (#<core$reverse clojure.core$reverse@xxxxxxxx> "Hello World")
 
-;; Você pode avaliar o resultad de macroexpand diretamente:
+;; Você pode avaliar o resultado de macroexpand diretamente:
 (eval (macroexpand '(my-first-macro)))
 ; -> (\d \l \o \r \W \space \o \l \l \e \H)
 
-;; mas você deve usar esse mais suscinto, sintax como de função:
+;; mas você deve usar essa sintaxe mais sucinta e familiar a funções:
 (my-first-macro)  ; -> (\d \l \o \r \W \space \o \l \l \e \H)
 
-;; Você pode tornar as coisas mais faceis pra você, utilizando a sintaxe de citação mais suscinta
+;; Você pode tornar as coisas mais fáceis pra você, utilizando a sintaxe de citação mais suscinta
 ;; para criar listas nas suas macros:
 (defmacro my-first-quoted-macro []
   '(reverse "Hello World"))
diff --git a/pt-br/clojure-pt.html.markdown b/pt-br/clojure-pt.html.markdown
index b88d4eec..e40b8fe7 100644
--- a/pt-br/clojure-pt.html.markdown
+++ b/pt-br/clojure-pt.html.markdown
@@ -5,12 +5,13 @@ contributors:
     - ["Adam Bard", "http://adambard.com/"]
 translators:
     - ["Mariane Siqueira Machado", "https://twitter.com/mariane_sm"]
+    - ["Ygor Sad", "https://github.com/ysads"]
 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.
+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 diversos recursos [STM](https://en.wikipedia.org/wiki/Software_transactional_memory) para lidar com estado e mutabilidade, caso isso seja necessário.
 
-Essa combinação permite gerenciar processamento concorrente de maneira muito simples, e frequentemente de maneira automática.
+Essa combinação permite gerenciar processamento concorrente de maneira muito simples - frequentemente, de modo automático.
 
 (Sua versão de clojure precisa ser pelo menos 1.2)
 
@@ -18,367 +19,552 @@ Essa combinação permite gerenciar processamento concorrente de maneira muito s
 ```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.
+; Código Clojure é escrito em formas - 'forms', em inglês. Tais estruturas são
+; simplesmente listas de valores encapsuladas 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.
+; Ao interpretar um código em Clojure, o interpretador ou leitor - do inglês 'reader' - assume
+; que o primeiro valor dentro de uma forma é uma função ou macro, de modo que os demais valores
+; são seus argumentos. Isso se deve ao fato de que Clojure, por ser uma derivação de Lisp,
+; usa notação prefixa (ou polonesa).
 
-: A primeira chamada de um arquivo deve ser ns, para configurar o namespace (espaço de nomes)
+; Num arquivo, a primeira chamada deve ser sempre para a função ns,
+; que é responsável por definir em qual namespace o código em questão
+; deve ser alocado
 (ns learnclojure)
 
 ; Alguns exemplos básicos:
 
-; str cria uma string concatenando seus argumentos
-(str "Hello" " " "World") ; => "Hello World"
+; Aqui, str é uma função e "Olá" " " e "Mundo" são seus argumentos. O que ela faz é criar
+; uma string concatenando seus argumentos.
+(str "Olá" " " "Mundo") ; => "Olá Mundo"
 
-; Cálculos são feitos de forma direta e intuitiva
+; Note que espaços em branco separam os argumentos de uma função. Opcionalmente vírgulas
+; podem ser usadas, se você quiser.
+(str, "Olá", " ", "Mundo") ; => "Olá Mundo"
+
+; As operações matemáticas básicas usam os operadores de sempre
 (+ 1 1) ; => 2
 (- 2 1) ; => 1
 (* 1 2) ; => 2
 (/ 2 1) ; => 2
 
-; Você pode comparar igualdade utilizando =
+; Esses operadores aceitam um número arbitrário de argumentos
+(+ 2 2 2) ; = 2 + 2 + 2 => 6
+(- 5 1 1) ; = 5 - 1 - 1 => 3
+(* 3 3 3 3) ; = 3 * 3 * 3 * 3 => 81
+
+; Para verificar se dois valores são iguais, o operador = pode ser usado
 (= 1 1) ; => true
 (= 2 1) ; => false
 
-; Negação para operações lógicas
-(not true) ; => false
+; Para saber se dois valores são diferentes
+(not= 1 2) ; => true
+(not (= 1 2)) ; => true
 
-; Aninhar "forms" funciona como esperado
+; Conforme vimos acima, é possível aninhar duas formas
 (+ 1 (- 3 2)) ; = 1 + (3 - 2) => 2
+(* (- 3 2) (+ 1 2)) ; = (3 - 2) * (1 + 2) => 3
+
+; Se a leitura ficar comprometida, as fórmulas também podem ser escritas em múltiplas linhas
+(* (- 3 2)
+   (+ 1 2)) ; => 3
+(*
+ (- 3 2)
+ (+ 1 2)) ; => 3
+
 
 ; 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
+; Por ter interoperabilidade com Java, Clojure usa os tipos de objetos de Java para booleanos,
+; strings e números. Para descobrir qual o tipo de um valor, você pode usar a função `class`:
+(class 1234) ; Literais Integer são java.lang.Long por padrão
+(class 1.50) ; Literais Float são java.lang.Double
+(class "oi") ; Strings sempre usam 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)))
+; Tenha cuidado, ao dividir valores inteiros:
+(= (/ 1 2)
+   (/ 1.0 2.0)) ; => false
+
+(class (/ 1 2)) ; => clojure.lang.Ratio
+(class (/ 1.0 2.0)) ; => java.lang.Double
+
+; Aqui temos uma diferença em relação a Java, pois valores nulos são representados por `nil`
+(class nil) ; nil
 
-; É 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
+; Os dois tipos básicos de coleção são listas - "list" em inglês - e vetores - "vectors"
+; no original. A principal diferença entre eles se
+; dá pela implementação:
+; - Vetores são implementados como arrays
+; - Listas são listas ligadas
+(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)
+; Outra forma de declarar listas é usando a função list
+(list 1 2 3) ; => '(1 2 3)
 
-; "Coleções" são apenas grupos de dados
-; Listas e vetores são ambos coleções:
+; Clojure classifica conjuntos de dados de duas maneiras
+
+; "Coleções" são grupos simples de dados
+; Tanto listas quanto vetores são 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.
+; Sequências - ou seqs - são conjuntos de dados com avaliação "lazy"
+; 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)
+; Ter avaliação lazy significa que uma seq somente precisa prover uma informação quando
+; ela for requisitada. Isso permite às seqs representar listas infinitas.
+(range) ; => (0 1 2 3 4 ...)
+(cycle [1 2]) ; => (1 2 1 2 1 2 ...)
+(take 4 (range)) ; => (0 1 2 3)
 
-; Use cons para adicionar um item no início de uma lista ou vetor
+; A função cons é usada para adicionar um item ao 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.
+; Já conj adiciona um item em uma coleção sempre do jeito mais eficiente.
+; Em listas, isso significa inserir no início. Já em vetores, ao 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
+; Concatenação de coleções pode ser feita usando concat. Note que ela sempre gera uma
+; seq como resultado e está sujeita a problemas de perfomance em coleções grandes, por
+; conta da natureza lazy das seqs.
+(concat '(1 2) [3 4]) ; => (1 2 3 4)
 (concat [1 2] '(3 4)) ; => (1 2 3 4)
 
-; Use filter, map para interagir com coleções
+; Outra forma de concatenar coleções é usando into. Ela não está sujeita a problemas
+; com a avaliação lazy, mas o resultado final da ordem e do tipo dos argumentos passados
+(into [1 2] '(3 4)) ; => [1 2 3 4]
+(into '(1 2) [3 4]) ; => (4 3 1 2)
+
+; Note que em into a ordem dos parâmetros influencia a coleção final.
+(into [1 2] '(3 4)) ; => (1 2 3 4)
+(into '(1 2) [3 4]) ; => (4 3 1 2)
+
+; As funções filter e map podem ser usadas para interagir com as coleções. Repare que
+; elas sempre retornam seqs, independentemente do tipo do seu argumento.
 (map inc [1 2 3]) ; => (2 3 4)
-(filter even? [1 2 3]) ; => (2)
+(filter even? [1 2 3 4]) ; => (2 4)
+
+; Use reduce reduzir coleções a um único valor. Também é possível passar um argumento
+; para o valor inicial das operações
+(reduce + [1 2 3]) ; = (+ (+ (+ 1 2) 3) 4) => 10
+(reduce + 10 [1 2 3 4]) ; = (+ (+ (+ (+ 10 1) 2) 3) 4) => 20
+(reduce conj [] '(3 2 1)) ; = (conj (conj (conj [] 3) 2) 1) => [3 2 1]
+
+; Reparou na semelhança entre listas e as chamadas de código Clojure? Isso se deve ao
+; fato de que todo código clojure é escrito usando listas. É por isso que elas sempre
+; são declaradas com o caracter ' na frente. Dessa forma o interpretador não tenta
+; avaliá-las.
+'(+ 2 3) ; cria uma lista com os elementos +, 2 e 3
+(+ 2 3) ; o interpretador chama a função + passando como argumentos 2 e 3
 
-; Use reduce para reduzi-los
-(reduce + [1 2 3 4])
-; = (+ (+ (+ 1 2) 3) 4)
-; => 10
+; Note que ' é apenas uma abreviação para a função quote.
+(quote (1 2 3)) ; => '(1 2 3)
+
+; É possível passar uma lista para que o interpretador a avalie. Note que isso está
+; sujeito ao primeiro elemento da lista ser um literal com um nome de uma função válida.
+(eval '(+ 2 3)) ; => 5
+(eval '(1 2 3)) ; dá erro pois o interpretador tenta chamar a função 1, que não existe
 
-; 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
+; Use fn para criar novas funções. Uma função sempre retorna sua última expressão.
+(fn [] "Olá Mundo") ; => fn
+
+; Para executar suas funções, é preciso chamá-las, envolvendo-as em parênteses.
+((fn [] "Olá Mundo")) ; => "Olá Mundo"
+
+; Como isso não é muito prático, você pode nomear funções atribuindo elas a literais.
+; Isso torna muito mais fácil chamá-las:
+(def ola-mundo (fn [] "Olá Mundo")) ; => fn
+(ola-mundo) ; => "Olá Mundo"
 
-; (É necessário colocar parênteses para chamá-los)
-((fn [] "Hello World")) ; => "Hello World"
+; Você pode abreviar esse processo usando defn:
+(defn ola-mundo [] "Olá Mundo")
 
-; Você pode atribuir valores a variáveis utilizando def
-(def x 1)
-x ; => 1
+; Uma função pode receber uma lista de argumentos:
+(defn ola
+  [nome]
+  (str "Olá " nome))
+(ola "Jonas") ; => "Olá Jonas"
 
-; Atribua uma função para uma var
-(def hello-world (fn [] "Hello World"))
-(hello-world) ; => "Hello World"
+; É possível criar funções que recebam multivariadas, isto é, que aceitam números
+; diferentes de argumentos:
+(defn soma
+  ([] 0)
+  ([a] a)
+  ([a b] (+ a b)))
 
-; Você pode abreviar esse processo usando defn
-(defn hello-world [] "Hello World")
+(soma) ; => 0
+(soma 1) ; => 1
+(soma 1 2) ; => 3
 
-; O [] é uma lista de argumentos para um função.
-(defn hello [name]
-  (str "Hello " name))
-(hello "Steve") ; => "Hello Steve"
+; Funções podem agrupar argumentos extras em uma seq:
+(defn conta-args
+  [& args]
+  (str "Você passou " (count args) " argumentos: " args))
+(conta-args 1 2 3 4) ; => "Você passou 4 argumentos: (1 2 3 4)"
 
-; Você pode ainda usar essa abreviação para criar funcões:
-(def hello2 #(str "Hello " %1))
-(hello2 "Fanny") ; => "Hello Fanny"
+; Você pode misturar argumentos regulares e argumentos em seq:
+(defn ola-e-conta
+  [nome & args]
+  (str "Olá " nome ", você passou " (count args) " argumentos extras"))
+(ola-e-conta "Maria" 1 2 3 4) ; => "Olá Maria, você passou 4 argumentos extras"
 
-; 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)"
+; Nos exemplos acima usamos def para associar nomes a funções, mas poderíamos usá-lo
+; para associar nomes a quaisquer valores:
+(def xis :x)
+xis ; => :x
 
-; 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"
+; Inclusive, tais literais podem possuir alguns caracteres não usuais em outras linguagens:
+(def *num-resposta* 42)
+(def conexao-ativa? true)
+(def grito-de-medo! "AAAAAAA")
+(def ->vector-vazio [])
+
+; É possível, inclusive, criar apelidos a nomes que já existem:
+(def somar! soma)
+(somar! 41 1) ; => 42 
+
+; Uma forma rápida de criar funções é por meio de funções anônimas. Elas são ótimas
+; para manipulação de coleções e seqs, já que podem ser passadas para map, filter
+; e reduce. Nessas funções, % é substituído por cada um dos items na seq ou na coleção:
+(filter #(not= % nil) ["Joaquim" nil "Maria" nil "Antônio"]) ; => ("Joaquim" "Maria" "Antônio")
+(map #(* % (+ % 2)) [1 2]) ; => (3 8)
 
 
 ; 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.
+; Existem dois tipos de mapas: hash maps e array maps. Ambos compartilham uma mesma
+; interface e funções. Hash maps são mais rápidos para retornar dados, mas não mantém
+; as chaves ordenadas.
 (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
+; Clojure converte automaticamente array maps em hash maps, por meio da maioria das
+; funções de manipulação de mapas, caso eles fiquem grandes o suficiente. Não é
+; preciso se preocupar com isso.
 
-
-; 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.
+; Chaves podem ser qualquer valor do qual possa ser obtido um hash, mas normalmente
+; usam-se keywords como chave, por possuírem algumas vantagens.
 (class :a) ; => clojure.lang.Keyword
 
-(def stringmap {"a" 1, "b" 2, "c" 3})
-stringmap  ; => {"a" 1, "b" 2, "c" 3}
+; Keywords são como strings, porém, duas keywords de mesmo valor são sempre armazenadas
+; na mesma posição de memória, o que as torna mais eficientes.
+(identical? :a :a) ; => true
+(identical? (String. "a") (String. "a")) ; => false
 
-(def keymap {:a 1, :b 2, :c 3})
-keymap ; => {:a 1, :c 3, :b 2}
+(def mapa-strings {"a" 1 "b" 2 "c" 3})
+mapa-strings ; => {"a" 1, "b" 2, "c" 3}
 
-; A propósito, vírgulas são sempre tratadas como espaçoes em branco e não fazem nada.
+(def mapa-keywords {:a 1 :b 2 :c 3})
+mapa-keywords ; => {:a 1, :c 3, :b 2}
 
-; Recupere o valor de um mapa chamando ele como uma função
-(stringmap "a") ; => 1
-(keymap :a) ; => 1
+; Você pode usar um mapa como função para recuperar um valor dele:
+(mapa-strings "a") ; => 1
+(mapa-keywords :a) ; => 1
 
-; Uma palavra-chave pode ser usada pra recuperar os valores de um mapa
-(:b keymap) ; => 2
+; Se a chave buscada for uma keyword, ela também pode ser usada como função para recuperar 
+; valores. Note que isso não funciona com strings.
+(:b mapa-keywords) ; => 2
+("b" mapa-strings) ; => java.lang.String cannot be cast to clojure.lang.IFn
 
-; Não tente isso com strings
-;("a" stringmap)
-; => Exception: java.lang.String cannot be cast to clojure.lang.IFn
+; Se você buscar uma chave que não existe, Clojure retorna nil:
+(mapa-strings "d") ; => nil
 
-; Buscar uma chave não presente retorna nil
-(stringmap "d") ; => nil
+; Use assoc para adicionar novas chaves em um mapa.
+(def mapa-keywords-estendido (assoc mapa-keywords :d 4))
+mapa-keywords-estendido ; => {:a 1, :b 2, :c 3, :d 4}
 
-; 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 que tipos em Clojure são sempre imutáveis! Isso significa que o mapa
+; inicial continua com as mesmas informações e um novo mapa, com mais dados, é criado
+; a partir dele
+mapa-keywords ; => {:a 1, :b 2, :c 3}
 
-; Mas lembre-se, tipos em Clojure são sempre imutáveis!
-keymap ; => {:a 1, :b 2, :c 3}
+; assoc também pode ser usado para atualizar chaves:
+(def outro-mapa-keywords (assoc mapa-keywords :a 0))
+outro-mapa-keywords ; => {:a 0, :b 2, :c 3}
 
 ; Use dissoc para remover chaves
-(dissoc keymap :a :b) ; => {:c 3}
+(dissoc mapa-keywords :a :b) ; => {:c 3}
+
+; Mapas também são coleções - mas não seqs!
+(coll? mapa-keywords) ; => true
+(seq? mapa-keywords) ; => false
+
+; É possível usar filter, map e qualquer outra função de coleções em mapas.
+; Porém a cada iteração um vetor no formato [chave valor] vai ser passado como
+; argumento. Por isso é conveniente usar funções anônimas.
+(filter #(odd? (second %)) mapa-keywords) ; => ([:a 1] [:c 3])
+(map #(inc (second %)) mapa-keywords) ; => (2 3 4)
 
 ; Conjuntos
 ;;;;;;
 
-(class #{1 2 3}) ; => clojure.lang.PersistentHashSet
+; Conjuntos são um tipo especial de coleções que não permitem elementos repetidos.
+; Eles podem ser criados com #{} ou com a função set.
 (set [1 2 3 1 2 3 3 2 1 3 2 1]) ; => #{1 2 3}
+(class #{1 2 3}) ; => clojure.lang.PersistentHashSet
 
-; Adicione um membro com conj
-(conj #{1 2 3} 4) ; => #{1 2 3 4}
+; Note que nem sempre um set vai armazenar seus elementos na ordem esperada.
+(def meu-conjunto #{1 2 3})
+meu-conjunto ; => #{1 3 2}
 
-; Remova um membro com disj
-(disj #{1 2 3} 1) ; => #{2 3}
+; Adição funciona normalmente com conj.
+(conj meu-conjunto 4) ; => #{1 4 3 2}
 
-; Test por existência usando set como função:
-(#{1 2 3} 1) ; => 1
-(#{1 2 3} 4) ; => nil
+; Remoção, no entanto, precisa ser feita com disj:
+(disj meu-conjunto 1) ; => #{3 2}
 
-; Existem muitas outras funções no namespace clojure.sets
+; Para saber se um elemento está em um conjunto, use-o como função. Nesse aspecto
+; conjuntos funcionam de maneira semelhante a mapas.
+(meu-conjunto 1) ; => 1
+(meu-conjunto 4) ; => nil
 
-; 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
+; Condicionais e blocos
+;;;;;;;;;;;;;;;;;
 
-; Use let para criar um novo escopo associando sîmbolos a valores (bindings)
+; Você pode usar um bloco let para criar um escopo local, no qual estarão disponíveis
+; os nomes que você definir:
 (let [a 1 b 2]
-  (> a b)) ; => false
+  (+ a b)) ; => 3
 
-; Agrupe comandos juntos com "do"
-(do
-  (print "Hello")
-  "World") ; => "World" (prints "Hello")
+(let [cores {:yellow "Amarelo" :blue "Azul"}
+      nova-cor :red
+      nome-cor "Vermelho"]
+  (assoc cores nova-cor nome-cor)) ; => {:yellow "Amarelo", :blue "Azul", :red "Vermelho"}
 
-; 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")
+; Formas do tipo if aceitam três argumentos: a condição de teste, o comando a ser
+; executado caso a condição seja positiva; e o comando para o caso de ela ser falsa.
+(if true "a" "b") ; => "a"
+(if false "a" "b") ; => "b"
+
+; Opcionalmente você pode não passar o último argumento, mas se a condição for falsa
+; o if vai retornar nil. 
+(if false "a") ; => nil
+
+; A forma if somente aceita um comando para ser executado em cada caso. Se você
+; precisar executar mais comandos, você pode usar a função do:
+(if true
+  (do
+    (print "Olá ")
+    (print "Mundo"))) ; => escreve "Olá Mundo" na saída
+
+; Se você só deseja tratar o caso de sua condição ser verdadeira, o comando when é
+; uma alternativa melhor. Seu comportamento é idêntico a um if sem condição negativa.
+; Uma de suas vantagens é permitir a execução de vários comandos sem exigir do:
+(when true "a") ; => "a"
+(when true
+  (print "Olá ")
+  (print "Mundo")) ; => também escreve "Olá Mundo" na saída
+
+; Isso ocorre porque when possui um bloco do implícito. O mesmo se aplica a funções e
+; comandos let:
+(defn escreve-e-diz-xis
+  [nome]
+  (print "Diga xis, " nome)
+  (str "Olá " nome))
+(escreve-e-diz-xis "João") ;=> "Olá João", além de escrever "Diga xis, João" na saída.
+
+(let [nome "Nara"]
+  (print "Diga xis, " nome)
+  (str "Olá " nome)) ;=> "Olá João", além de escrever "Diga xis, João" na saída.
 
-; 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
+; Você pode usar a função use para carregar todas as funções de um módulo.
 (use 'clojure.set)
 
-; Agora nós podemos usar operações com conjuntos
+; Agora nós podemos usar operações de conjuntos definidas nesse módulo:
 (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
+; Isso porém não é uma boa prática pois dificulta saber de qual módulo cada função
+; veio, além de expor o código a conflitos de nomes, caso dois módulos diferentes
+; definam funções com o mesmo nome. A melhor forma de referenciar módulos é por meio
+; de require:
 (require 'clojure.string)
 
-; Use / para chamar funções de um módulo
+; Com isso podemos chamar as funções de clojure.string usando o operador /
 ; 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
+; Porém isso não é muito prático, por isso é possível dar para um nome mais curto para
+; o módulo ao carregá-lo:
 (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)
+(str/replace "alguém quer teste?" #"[aeiou]" str/upper-case) ; => "AlgUém qUEr tEstE?"
 
-; 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.
+; Nesse exemplo usamos também a construção #"", que delimita uma expressão regular.
+
+; É possível carregar outros módulos direto na definição do namespace. Note que nesse
+; contexto não é preciso usar ' antes do vetor que define a importação do módulo.
 (ns test
   (:require
     [clojure.string :as str]
     [clojure.set :as set]))
 
+
+; Operadores thread
+;;;;;;;;;;;;;;;;;
+
+; Uma das funções mais interessantes de clojure são os operadores -> e ->> - respectivamente
+; thread-first e thread-last macros. Elas permitem o encadeamento de chamadas de funções,
+; sendo perfeitas para melhorar a legibilidade em transformações de dados.
+
+; -> usa o resultado de uma chamada como o primeiro argumento da chamada à função seguinte:
+(-> "  uMa   StRIng com! aLG_uNs  ##problemas. "
+    (str/replace #"[!#_]" "")
+    (str/replace #"\s+" " ")
+    str/trim          ; se a função só aceitar um argumento, não é preciso usar parênteses
+    (str/lower-case)) ; => "uma string com alguns problemas."
+
+; Na thread uma string com vários problemas foi passada como primeiro argumento à função
+; str/replace, que criou uma nova string, a partir da original, porém somente com caracteres
+; alfabéticos. Essa nova string foi passada como primeiro argumento para a chamada str/replace
+; seguinte, que criou uma nova string sem espaços duplos. Essa nova string foi então passada
+; como primeiro argumento para str/trim, que removeu espaços de seu início e fim, passando essa
+; última string para str/lower-case, que a converteu para caracteres em caixa baixa.
+
+; ->> é equivalente a ->, porém o retorno de cada função é passado como último argumento da
+; função seguinte. Isso é particularmente útil para lidar com seqs, já que as funções que
+; as manipulam sempre as tomam como último argumento.
+(->> '(1 2 3 4)
+     (filter even?) ; => '(2 4)
+     (map inc)      ; => '(3 5)
+     (reduce *))    ; => 15
+
+
 ; Java
 ;;;;;;;;;;;;;;;;;
 
-; Java tem uma biblioteca padrão enorme e muito útil, 
-; portanto é importante aprender como utiliza-la.
+; A biblioteca padrão de Java é enorme e possui inúmeros algoritmos e estruturas de
+; dados já implementados. Por isso é bastante conveniente saber como usá-la dentro
+; de Clojure.
 
-; Use import para carregar um modulo java
+; Use import para carregar um módulo Java.
 (import java.util.Date)
 
-; Você pode importar usando ns também.
+; Você pode importar classes Java dentro de ns também:
 (ns test
   (:import java.util.Date
-           java.util.Calendar))
+           java.util.Calendar
+           java.util.ArrayList))
 
 ; Use o nome da clase com um "." no final para criar uma nova instância
-(Date.) ; <a date object>
+(def instante (Date.))
+(class instante) => ; java.util.Date
+
+; Para chamar um método, use o operador . com o nome do método. Outra forma é
+; usar simplesmente .<nome do método>
+(. instante getTime) ; => retorna um inteiro representando o instante
+(.getTime instante) ; => exatamente o mesmo que acima
+
+; Para chamar métodos estáticos dentro de classes Java, use /
+(System/currentTimeMillis) ; => retorna um timestamp
 
-; Use . para chamar métodos. Ou, use o atalho ".method"
-(. (Date.) getTime) ; <a timestamp>
-(.getTime (Date.)) ; exatamente a mesma coisa.
+; Note que não é preciso importar o módulo System, pois ele está sempre presente
 
-; Use / para chamar métodos estáticos
-(System/currentTimeMillis) ; <a timestamp> (o módulo System está sempre presente)
+; Caso queira submeter uma instância de uma classe mutável a uma sequência de operações,
+; você pode usar a função doto. Ela é funciona de maneira semelhante à função -> - ou
+; thread-first -, exceto pelo fato de que ele opera com valores mutáveis.
+(doto (java.util.ArrayList.)
+  (.add 11)
+  (.add 3)
+  (.add 7)
+  (java.util.Collections/sort)) ; => #<ArrayList [3, 7, 11]>
 
-; 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.
+; Até aqui usamos def para associar nomes a valores. Isso, no entanto, possui algumas
+; limitações, já que, uma vez definido essa associação, não podemos alterar o valor
+; para o qual um nome aponta. Isso significa que nomes definidos com def não se
+; comportam como as variáveis de outras linguagens.
 
-; O atom é o mais simples. Passe pra ele um valor inicial
-(def my-atom (atom {}))
+; Para lidar com estado persistente e mutação de valores, Clojure usa o mecanismo Software
+; Transactional Memory. O atom é o mais simples de todos. Passe pra ele um valor inicial e
+; e ele criará um objeto que é seguro de atualizar:
+(def atom-mapa (atom {}))
 
-; Atualize o atom com um swap!.
-; swap! pega uma função e 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)
+; Para acessar o valor de um atom, você pode usar a função deref ou o operador @: 
+@atom-mapa ; => {}
+(deref atom-mapa) ; => {}
 
-; Use '@' para desreferenciar um atom e acessar seu valor
-my-atom  ;=> Atom<#...> (Retorna o objeto do Atom)
-@my-atom ; => {:a 1 :b 2}
+; Para mudar o valor de um atom, você deve usar a função swap!
+; O que ela faz é chamar a função passada usando o atom como seu primeiro argumento. Com
+; isso, ela altera o valor do atom de maneira segura. 
+(swap! atom-mapa assoc :a 1) ; Atribui a atom-mapa o resultado de (assoc {} :a 1)
+(swap! atom-mapa assoc :b 2) ; Atribui a atom-mapa o resultado de (assoc {:a 1} :b 2)
 
-; Abaixo um contador simples usando um atom
-(def counter (atom 0))
-(defn inc-counter []
-  (swap! counter inc))
+; Observe que essas chamadas alteraram de fato o valor de atom-mapa. Seu novo valor é:
+@atom-mapa ; => {:a 1 :b 2}
 
-(inc-counter)
-(inc-counter)
-(inc-counter)
-(inc-counter)
-(inc-counter)
+; Isso é diferente de fazer:
+(def atom-mapa-2 (atom {}))
+(def atom-mapa-3 (assoc @atom-mapa-2 :a 1))
 
-@counter ; => 5
+; Nesse exemplo, atom-mapa-2 permanece com o seu valor original e é gerado um novo mapa,
+; atom-mapa-3, que contém o valor de atom-mapa-2 atualizado. Note que atom-mapa-3 é um
+; simples mapa, e não uma instância de um atom
+@atom-mapa-2 ; => {}
+atom-mapa-3 ; => {:a 1}
 
-; Outras construção STM são refs e agents.
+(class atom-mapa-2) ; => clojure.lang.Atom
+(class atom-mapa-3) ; => clojure.lang.PersistentArrayMap
+
+; A ideia é que o valor do atom só será atualizado se, após ser executada a função passada
+; para swap!, o atom ainda estiver com o mesmo valor de antes. Isto é, se durante a execução
+; da função alguém alterar o valor do atom, swap! reexecutará a função recebida usando o valor
+; atual do átoma como argumento.
+
+; Isso é ótimo em situações nas quais é preciso garantir a consistência de algum valor - tais
+; como sistemas bancários e sites de compra. Para mais exemplos e informações sobre outras
+; construções STM:
+
+; Exemplos e aplicações: https://www.braveclojure.com/zombie-metaphysics/
 ; 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.
+Esse tutorial está longe de ser completo, mas deve ser suficiente para que você possa dar seus primeiros passos em Clojure.
+Caso queira aprender mais:
 
-Clojure.org tem vários artigos:
+* 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):
+* Brave Clojure possui um e-book que explora em profundidade diversos recursos de clojure, incluindo ótimos exemplos:
+[https://www.braveclojure.com/](https://www.braveclojure.com/)
+
+* 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:
+* 4clojure possui alguns problemas e desafios interessantes para quem quiser treinar clojure ou programação funcional:
 [http://www.4clojure.com/](http://www.4clojure.com/)
 
-Clojure-doc.org tem um bom número de artigos para iniciantes:
+* clojure-doc.org tem um bom número de artigos para iniciantes:
 [http://clojure-doc.org/](http://clojure-doc.org/)
+
+Clojure for the Brave and True é um livro de introdução ao Clojure e possui uma versão gratuita online:
+[https://www.braveclojure.com/clojure-for-the-brave-and-true/](https://www.braveclojure.com/clojure-for-the-brave-and-true/)
diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown
index 2ff59296..384ca325 100644
--- a/pt-br/csharp-pt.html.markdown
+++ b/pt-br/csharp-pt.html.markdown
@@ -78,15 +78,17 @@ namespace Learning.CSharp
             short fooShort = 10000;
             ushort fooUshort = 10000;
 
-            // Integer - 32-bit integer
+            // Integer - inteiro de 32 bits 
             int fooInt = 1; // (-2,147,483,648 <= int <= 2,147,483,647)
             uint fooUint = 1; // (0 <= uint <= 4,294,967,295)
-
+            //Números por padrão são int ou uint, dependendo do tamanho.
+            
             // Long - 64-bit integer
             long fooLong = 100000L; // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
             ulong fooUlong = 100000L; // (0 <= ulong <= 18,446,744,073,709,551,615)
-            // Numbers default to being int or uint depending on size.
-            // L is used to denote that this variable value is of type long or ulong
+            
+            // Números por padrão são int ou uint dependendo do tamanho.
+            // L é usado para denotar que o valor da variável é do tipo long ou ulong.
 
             // Double - Double-precision 64-bit IEEE 754 Floating Point
             double fooDouble = 123.4; // Precision: 15-16 digits
@@ -308,25 +310,26 @@ on a new line! ""Wow!"", the masses cried";
             }
 
             ///////////////////////////////////////
-            // Converting Data Types And Typecasting
+            // Convertendo Data Types e Typecasting
             ///////////////////////////////////////
 
-            // Converting data
+            // Convertendo dados
+
+            // Converter String para Integer
 
-            // Convert String To Integer
-            // this will throw a FormatException on failure
-            int.Parse("123");//returns an integer version of "123"
+            // isso vai jogar um erro FormatException quando houver falha
+            int.Parse("123");//retorna uma verão em Integer da String "123"
 
-            // try parse will default to type default on failure
-            // in this case: 0
+            // try parse vai ir por padrão para o typo default quando houver uma falha
+            // nesse caso: 0
             int tryInt;
-            if (int.TryParse("123", out tryInt)) // Function is boolean
+            if (int.TryParse("123", out tryInt)) // Função booleana
                 Console.WriteLine(tryInt);       // 123
 
-            // Convert Integer To String
-            // Convert class has a number of methods to facilitate conversions
+            // Converter Integer para String
+            // A classe Convert possuí métodos para facilitar as conversões
             Convert.ToString(123);
-            // or
+            // ou
             tryInt.ToString();
 
             // Casting
@@ -407,12 +410,12 @@ on a new line! ""Wow!"", the masses cried";
             return result;
         }
 
-        // You can narrow down the objects that are passed in
+        // Você pode pode restringir os objetos que são passados
         public static void IterateAndPrint<T>(T toPrint) where T: IEnumerable<int>
         {
-            // We can iterate, since T is a IEnumerable
+            // Nos podemos iterar, desde que T seja um "IEnumerable"
             foreach (var item in toPrint)
-                // Item is an int
+                // Item é um inteiro
                 Console.WriteLine(item.ToString());
         }
 
@@ -720,9 +723,9 @@ on a new line! ""Wow!"", the masses cried";
             _speed -= decrement;
         }
 
-        // properties get/set values
-        // when only data needs to be accessed, consider using properties.
-        // properties may have either get or set, or both
+        // propriedade recupera e/ou atribui valores (get/set). 
+        // quando os dados precisam apenas ser acessados, considere o uso de propriedades.
+        // uma propriedade pode ter "get" ou "set", ou ambos.
         private bool _hasTassles; // private variable
         public bool HasTassles // public accessor
         {
diff --git a/pt-br/css-pt.html.markdown b/pt-br/css-pt.html.markdown
index c73669d0..e6dea5b8 100644
--- a/pt-br/css-pt.html.markdown
+++ b/pt-br/css-pt.html.markdown
@@ -14,15 +14,15 @@ translators:
 lang: pt-br
 ---
 
-Nos primeiros dias da web não havia elementos visuais, apenas texto puro. Mas com maior desenvolvimento de navegadores da web, páginas web totalmente visuais também se tornou comum.
+No início da web não havia elementos visuais, apenas texto puro. Mas com maior desenvolvimento de navegadores da web, páginas web totalmente visuais também se tornaram comuns.
 
-CSS ajuda a manter a separação entre o conteúdo (HTML) e o look-and-feel de uma página web.
+CSS ajuda a manter a separação entre o conteúdo (HTML) e o visual de uma página web.
 
 CSS permite atingir diferentes elementos em uma página HTML e atribuir diferentes propriedades visuais para eles.
 
-Este guia foi escrito para CSS2, embora CSS3 está rapidamente se tornando popular.
+Este guia foi escrito para CSS2, embora CSS3 esteja rapidamente se tornando popular.
 
-**NOTA:** Porque CSS produz resultados visuais, a fim de aprender, você precisa tentar de tudo em um playground CSS como [dabblet](http://dabblet.com/).
+**NOTA:** Porque CSS produz resultados visuais, a fim de aprender, você precisa treinar em um playground CSS como [dabblet](http://dabblet.com/).
 O foco principal deste artigo é sobre a sintaxe e algumas dicas gerais.
 
 ```css
@@ -42,7 +42,7 @@ Abaixo um elemento de exemplo:
 <div class='class1 class2' id='anID' attr='value' otherAttr='pt-br foo bar' />
 */
 
-/* Você pode direciona-lo usando uma das suas classes CSS */
+/* Você pode direcioná-lo usando uma das suas classes CSS */
 .class1 { }
 
 /* ou ambas as classes! */
@@ -82,9 +82,9 @@ classe div.some [attr $ = 'ue'] {}
 /* Você pode selecionar um elemento que é filho de outro elemento */
 div.some-parent> .class-name {}
 
-/* Ou um descendente de um outro elemento. As crianças são os descendentes diretos de
-   seu elemento pai, apenas um nível abaixo da árvore. Pode ser qualquer descendentes
-   nivelar por baixo da árvore. */
+/* Ou um descendente de um outro elemento. Os filhos são os descendentes diretos de
+   seu elemento pai, apenas um nível abaixo da árvore. Pode ser quaisquer descendentes
+   nivelados por baixo da árvore. */
 div.some-parent class-name {}
 
 /* Atenção: o mesmo seletor sem espaço tem um outro significado.
@@ -97,7 +97,7 @@ div.some-parent.class-name {}
 /* Ou qualquer irmão que o precede */
 .i am-qualquer-elemento antes ~ .Este elemento {}
 
-/* Existem alguns selectores chamado pseudo classes que podem ser usados para selecionar um
+/* Existem alguns seletores chamados pseudo classes que podem ser usados para selecionar um
    elemento quando ele está em um determinado estado */
 
 /* Por exemplo, quando o cursor passa sobre um elemento */
@@ -118,7 +118,7 @@ seletor:first-child {}
 /* Qualquer elemento que é o último filho de seu pai */
 seletor:last-child {}
 
-/* Assim como pseudo classes, pseudo elementos permitem que você estilo certas partes de um documento */
+/* Assim como pseudo classes, pseudo elementos permitem que você estilize certas partes de um documento */
 
 /* Corresponde a um primeiro filho virtual do elemento selecionado */
 seletor::before {}
@@ -127,10 +127,10 @@ seletor::before {}
 seletor::after {}
 
 /* Nos locais apropriados, um asterisco pode ser utilizado como um curinga para selecionar todos
-   elemento */
+   os elementos */
 * {} /* */ Todos os elementos
 .parent * {} /* */ todos os descendentes
-.parent> * {} /* */ todas as crianças
+.parent> * {} /* */ todos os filhos
 
 /* ####################
    ## PROPRIEDADES
@@ -141,7 +141,7 @@ seletor {
     /* Unidades de comprimento pode ser absoluta ou relativa. */
 
     /* Unidades relativas */
-    width: 50%; /* Percentagem de largura elemento pai */
+    width: 50%; /* Percentagem de largura do elemento pai */
     font-size: 2em; /* Múltiplos de font-size original de elemento */
     font-size: 2rem; /* Ou do elemento raiz font-size */
     font-size: 2vw; /* Múltiplos de 1% da largura da janela de exibição (CSS 3) */
@@ -181,7 +181,7 @@ seletor {
 
 ## Uso
 
-Guardar uma folha de estilo CSS com a extensão `.css`.
+Salvar uma folha de estilo CSS com a extensão `.css`.
 
 ```xml
 <!-- Você precisa incluir o arquivo css no da sua página <head>. Isto é o
@@ -200,7 +200,7 @@ Guardar uma folha de estilo CSS com a extensão `.css`.
 
 ## Precedência ou Cascata
 
-Um elemento pode ser alvo de vários seletores e pode ter um conjunto de propriedades em que mais de uma vez. Nestes casos, uma das regras tem precedência sobre os outros. Geralmente, uma regra em um seletor mais específico têm precedência sobre um menos específico, e uma regra que ocorre mais tarde na folha de estilo substitui uma anterior.
+Um elemento pode ser alvo de vários seletores e pode ter um conjunto de propriedades em que mais de uma vez. Nestes casos, uma das regras tem precedência sobre as outras. Geralmente, uma regra em um seletor mais específico têm precedência sobre um menos específico, e uma regra que ocorre mais tarde na folha de estilo substitui uma anterior.
 
 Este processo é chamado de cascata, portanto, as Fichas de nome de estilo em cascata.
 
@@ -279,7 +279,7 @@ Muitos smartphones e tablets tentarão renderizar a página como se estivesse nu
 
 ## Compatibilidade
 
-A maior parte dos recursos do CSS 2 (e muitos em CSS 3) estão disponíveis em todos os navegadores e dispositivos. Mas é sempre boa prática para verificar antes de usar um novo recurso.
+A maior parte dos recursos do CSS 2 (e muitos em CSS 3) estão disponíveis em todos os navegadores e dispositivos. Mas é sempre boa prática verificar antes de usar um novo recurso.
 
 ## Recursos
 
diff --git a/pt-br/cypher-pt.html.markdown b/pt-br/cypher-pt.html.markdown
index 9b60f771..d4400148 100644
--- a/pt-br/cypher-pt.html.markdown
+++ b/pt-br/cypher-pt.html.markdown
@@ -101,7 +101,7 @@ path = shortestPath( (user)-[:KNOWS*..5]-(other) )
 Crie consultas
 ---
 
-Create a new node
+Crie um novo nó
 ```
 CREATE (a:Person {name:"Théo Gauchoux"})
 RETURN a
diff --git a/pt-br/elisp-pt.html.markdown b/pt-br/elisp-pt.html.markdown
index fc2d1e40..aa611097 100644
--- a/pt-br/elisp-pt.html.markdown
+++ b/pt-br/elisp-pt.html.markdown
@@ -111,7 +111,7 @@ filename: learn-emacs-lisp-pt.el
 (hello)
 ;; `C-xC-e' => Hello, I am Bastien
 
-;; Os parêntesis vazios na definição da função significam que ela
+;; Os parênteses vazios na definição da função significam que ela
 ;; não aceita argumentos. Mas sempre utilizar `my-name' é um tédio!
 ;; Vamos dizer à função para aceitar um argumento (o argumento é
 ;; chamado "name"):
diff --git a/pt-br/elixir-pt.html.markdown b/pt-br/elixir-pt.html.markdown
index f8c56101..4ba78f52 100644
--- a/pt-br/elixir-pt.html.markdown
+++ b/pt-br/elixir-pt.html.markdown
@@ -40,7 +40,7 @@ e muitos outros recursos.
 # Tuplas que são guardadas contiguamente em memória.
 {1,2,3} # tupla
 
-# Podemos acessar um elemento de uma tupla om a função `elem`:
+# Podemos acessar um elemento de uma tupla com a função `elem`:
 elem({1, 2, 3}, 0) #=> 1
 
 # Listas que são implementadas como listas ligadas.
diff --git a/pt-br/fsharp-pt.html.markdown b/pt-br/fsharp-pt.html.markdown
new file mode 100644
index 00000000..55966cda
--- /dev/null
+++ b/pt-br/fsharp-pt.html.markdown
@@ -0,0 +1,639 @@
+---
+language: F#
+filename: learnfsharp-pt.fs
+contributors:
+    - ["Scott Wlaschin", "http://fsharpforfunandprofit.com"]
+    - ["Adelar da Silva Queiróz", "https://adelarsq.github.io"]
+lang: pt-br
+---
+
+F# é uma linguagem de propósito geral funcional e orientada a objetos. É livre, de código aberto e executa em Linux, Mac, Windows e outros.
+
+Possui um sistema de tipagem poderoso que evita muitos erros em tempo de compilação. Para isto utilizando inferência de tipos, o que a faz se comportar como uma linguagem dinâmica.
+
+A sintaxe é diferente das linguagens do estilo C (C, C#, Java, etc):
+
+* Chaves não são usadas para delimitar blocos de código. Ao invés disso é utilizada indentação (semelhante ao Python).
+* Espaços em branco são usados para separar parâmetros, ao invés de vírgulas.
+
+Se você deseja executar o código abaixo, copie e cole em [https://try.fsharp.org](https://try.fsharp.org), que é um REPL online.
+
+```fsharp
+
+// comentários de linhas únicas usam barras duplas
+(* comentários de linhas múltiplas usam o par (* . . . *)
+
+-fim do comentário de linhas múltiplas- *)
+
+// ================================================
+// Sintaxe básica
+// ================================================
+
+// ------ "Variáveis" (mas não exatamente) ------
+// A palavra reservada "let" define um valor imutável
+let myInt = 5
+let myFloat = 3.14
+let myString = "hello"           // note que nenhum tipo é necessário
+
+// ------ Listas ------
+let twoToFive = [2; 3; 4; 5]     // Colchetes criam uma lista com
+                                 // ponto e vírgula como delimitadores
+let oneToFive = 1 :: twoToFive   // :: cria uma lista com um novo primeiro elemento
+// O resultado é [1; 2; 3; 4; 5]
+let zeroToFive = [0; 1] @ twoToFive   // @ concatena duas listas
+
+// IMPORTANTE: vírgulas nunca são usadas como delimitadores, somente ponto e vírgula!
+
+// ------ Funções ------
+// A palavra chave "let" também define nomes para funções.
+let square x = x * x          // Note que não são usados parêntesis
+square 3                      // Agora executando a função. Também sem parêntesis
+
+let add x y = x + y           // Não use add (x,y)! Isto significa algo
+                              // completamente diferente.
+add 2 3                       // Agora execute a função.
+
+// para definir uma função de múltiplas linhas apenas use indentação. Nenhum ponto e vírgula é necessário
+let evens list =
+   let isEven x = x % 2 = 0   // Define "isEven"como uma sub função. Note
+                              // que o operador de igualdade é um simples "=".
+   List.filter isEven list    // List.filter é uma função da biblioteca padrão
+                              // com dois parâmetros: uma função que retorna boolean
+                              // e uma lista para verificar
+
+evens oneToFive               // Agora executando a função
+
+// Usando parênteses é possível deixar mais clara a precedência. Neste exemplo,
+// "map" é usado primeiro, com dois argumentos, então executa "sum" no resultado.
+// Sem os parênteses, "List.map" seria passado como uma argumento para List.sum
+let sumOfSquaresTo100 =
+   List.sum ( List.map square [1..100] )
+
+// É possível redirecionar a saída de uma operação para a próxima usando pipe ("|>")
+// Redirecimento de dados é algo comum em F#, similar a pipes Unix.
+
+// Aqui é a mesma função sumOfSquares escrita com pipe
+let sumOfSquaresTo100piped =
+   [1..100] |> List.map square |> List.sum  // "square" foi definido anteriormente
+
+// você pode definir lambdas (funções anônimas) usando a palavra reservada "fun"
+let sumOfSquaresTo100withFun =
+   [1..100] |> List.map (fun x -> x * x) |> List.sum
+
+// Em F# não há a palavra chave "return". Funções sempre
+// retornam o valor da última expressão usada.
+
+// ------ Casamento de padrões (Pattern Matching) ------
+// Match..with.. é um poderoso case/switch.
+let simplePatternMatch =
+   let x = "a"
+   match x with
+    | "a" -> printfn "x is a"
+    | "b" -> printfn "x is b"
+    | _ -> printfn "x is something else"   // sublinhado combina com qualquer coisa
+
+// F# não permite null por padrão -- deve-se usar um Option
+// e então efetuar um casamento de padrão.
+// Some(..) e None são análogos a Nullable
+let validValue = Some(99)
+let invalidValue = None
+
+// Neste exemplo, match..with casa com "Some" e "None",
+// e também desconstrói o valor em "Some" ao mesmo tempo.
+let optionPatternMatch input =
+   match input with
+    | Some i -> printfn "input is an int=%d" i
+    | None -> printfn "input is missing"
+
+optionPatternMatch validValue
+optionPatternMatch invalidValue
+
+// ------ Escrevando na tela ------
+// As funções printf/printfn são similares às
+// Console.Write/WriteLine encontradas no C#.
+printfn "Printing an int %i, a float %f, a bool %b" 1 2.0 true
+printfn "A string %s, and something generic %A" "hello" [1; 2; 3; 4]
+
+// Exitem também as funções sprintf/sprintfn para formatação de dados
+// em uma string, semelhante à String.Format do C#.
+
+// ================================================
+// Mais sobre funções
+// ================================================
+
+// F# é uma liguagem verdadeiramente funcional -- funções fazem
+// parte das classes e podem ser combinadas facilmente para criar
+// poderosos construtores
+
+// Módulos podem usar um grupo de funções
+// É necessário usar indentação para defini-las.
+module FunctionExamples =
+
+    // define uma função de soma
+    let add x y = x + y
+
+    // básico uso de uma função
+    let a = add 1 2
+    printfn "1 + 2 = %i" a
+
+    // aplicação parcial de parâmetros
+    let add42 = add 42
+    let b = add42 1
+    printfn "42 + 1 = %i" b
+
+    // composição para combinar funções
+    let add1 = add 1
+    let add2 = add 2
+    let add3 = add1 >> add2
+    let c = add3 7
+    printfn "3 + 7 = %i" c
+
+    // funções de alta ordem
+    [1..10] |> List.map add3 |> printfn "new list is %A"
+
+    // listas de funções e mais
+    let add6 = [add1; add2; add3] |> List.reduce (>>)
+    let d = add6 7
+    printfn "1 + 2 + 3 + 7 = %i" d
+
+// ================================================
+// Listas e coleções
+// ================================================
+
+// Existem três tipos de coleções ordenadas:
+// * Listas são o tipo mais básico de coleção imutável;
+// * Arrays são mutáveis e mais eficientes;
+// * Sequences são lazy e infinitas (semelhante a enumerator).
+//
+// Outras coleções incluem maps e conjuntos imutáveis
+// mais todas as coleções padrões do .NET
+
+module ListExamples =
+
+    // listas usam colchetes
+    let list1 = ["a"; "b"]
+    let list2 = "c" :: list1    // :: é usado para adicionar um elemento no início da lista
+    let list3 = list1 @ list2   // @ é o operador de concatenação
+
+    // list comprehensions (generators)
+    let squares = [for i in 1..10 do yield i * i]
+
+    // Um gerador de números primos
+    // - este usa a notação custa para casamento de padrões
+    // - (p::xs) significa 'primeiro :: cauda' da lista, e pode ser escrito como p :: xs
+    //   isto significa que casa 'p' (o primeiro item da lista), e xs recebe o resto da lista
+    //   que é chamdo de 'cons pattern'
+    // - usa a palavra chave 'rec', que é necessária quando se usa recursão
+    let rec sieve = function
+        | (p::xs) -> p :: sieve [ for x in xs do if x % p > 0 then yield x ]
+        | []      -> []
+    let primes = sieve [2..50]
+    printfn "%A" primes
+
+    // casamento de padrões (pattern matching) com listas
+    let listMatcher aList =
+        match aList with
+        | [] -> printfn "the list is empty"
+        | [first] -> printfn "the list has one element %A " first
+        | [first; second] -> printfn "list is %A and %A" first second
+        | first :: _ -> printfn "the list has more than two elements, first element %A" first
+
+    listMatcher [1; 2; 3; 4]
+    listMatcher [1; 2]
+    listMatcher [1]
+    listMatcher []
+
+    // recursão usando listas
+    let rec sum aList =
+        match aList with
+        | [] -> 0
+        | x::xs -> x + sum xs
+    sum [1..10]
+
+    // -----------------------------------------
+    // Funções da biblioteca padrão
+    // -----------------------------------------
+
+    // mapas
+    let add3 x = x + 3
+    [1..10] |> List.map add3
+
+    // filtros
+    let even x = x % 2 = 0
+    [1..10] |> List.filter even
+
+    // muito mais -- veja a documentação
+
+module ArrayExamples =
+
+    // arrays usam colchetes com barra vertical
+    let array1 = [| "a"; "b" |]
+    let first = array1.[0]        // acesso por índice usando ponto
+
+    // casamento de padrões (pattern matching) para arrays é feito da mesma forma que de listas
+    let arrayMatcher aList =
+        match aList with
+        | [| |] -> printfn "the array is empty"
+        | [| first |] -> printfn "the array has one element %A " first
+        | [| first; second |] -> printfn "array is %A and %A" first second
+        | _ -> printfn "the array has more than two elements"
+
+    arrayMatcher [| 1; 2; 3; 4 |]
+
+    // As funções da biblioteca padrão são as mesmas que para List
+
+    [| 1..10 |]
+    |> Array.map (fun i -> i + 3)
+    |> Array.filter (fun i -> i % 2 = 0)
+    |> Array.iter (printfn "value is %i. ")
+
+
+module SequenceExamples =
+
+    // sequências usam chaves
+    let seq1 = seq { yield "a"; yield "b" }
+
+    // sequências podem usar yield e
+    // podem conter subsequencias
+    let strange = seq {
+        // "yield" adiciona um elemento
+        yield 1; yield 2;
+
+        // "yield!" adiciona uma subsequencia
+        yield! [5..10]
+        yield! seq {
+            for i in 1..10 do
+              if i % 2 = 0 then yield i }}
+    // teste
+    strange |> Seq.toList
+
+    // Sequências podem ser criadas usando "unfold"
+    // Este é um exemplo da série de Fibonacci
+    let fib = Seq.unfold (fun (fst,snd) ->
+        Some(fst + snd, (snd, fst + snd))) (0,1)
+
+    // teste
+    let fib10 = fib |> Seq.take 10 |> Seq.toList
+    printf "first 10 fibs are %A" fib10
+
+
+// ================================================
+// Tipos de dados
+// ================================================
+
+module DataTypeExamples =
+
+    // Todos os dados são imutáveis por padrão
+
+    // Tuplas são uma forma rápida de reprentar n elementos de tipos anônimos
+    // -- Use a vírgula para criar uma tupla
+    let twoTuple = 1, 2
+    let threeTuple = "a", 2, true
+
+    // Casamento de padrões (pattern match) para desconstruir
+    let x, y = twoTuple  // atribui x = 1, y = 2
+
+    // ------------------------------------
+    // O tipo registro possui nomes nos campos
+    // ------------------------------------
+
+    // Use "type" com chaves para definir um registro
+    type Person = {First:string; Last:string}
+
+    // Use "let" com chaves para criar um registro
+    let person1 = {First="John"; Last="Doe"}
+
+    // Casamento de padrões para desconstruir
+    let {First = first} = person1    // atribui first="John"
+
+    // ------------------------------------
+    // Tipos union (variantes) possuem um conjunto de escolhas
+    // Somente um caso pode ser válido por vez.
+    // ------------------------------------
+
+    // Use "type" com barra/pipe para definir um union
+    type Temp =
+        | DegreesC of float
+        | DegreesF of float
+
+    // Use qualquer dos tipos para criar um
+    let temp1 = DegreesF 98.6
+    let temp2 = DegreesC 37.0
+
+    // Casamento de padrões deve cobrir todos os tipos de definidos para desconstruir
+    let printTemp = function
+       | DegreesC t -> printfn "%f degC" t
+       | DegreesF t -> printfn "%f degF" t
+
+    printTemp temp1
+    printTemp temp2
+
+    // ------------------------------------
+    // Tipos recursivos
+    // ------------------------------------
+
+    // Tipos podem ser combinados recursivamente de formas complexas
+    // sem ter que criar subclasses
+    type Employee =
+      | Worker of Person
+      | Manager of Employee list
+
+    let jdoe = {First="John"; Last="Doe"}
+    let worker = Worker jdoe
+
+    // ------------------------------------
+    // Modelando com tipos
+    // ------------------------------------
+
+    // Tipos union são muito bons para modelagem de estados sem usar flags
+    type EmailAddress =
+        | ValidEmailAddress of string
+        | InvalidEmailAddress of string
+
+    let trySendEmail email =
+        match email with // casamento de padrões
+        | ValidEmailAddress address -> ()   // envia
+        | InvalidEmailAddress address -> () // não envia
+
+    // A combinação de tipos union e registros juntos
+    // provê uma grande fundação para DDD (Domain Driven Design).
+    // Você pode criar centenas de pequenos tipos que refletem
+    // exatamente o seu domínio.
+
+    type CartItem = { ProductCode: string; Qty: int }
+    type Payment = Payment of float
+    type ActiveCartData = { UnpaidItems: CartItem list }
+    type PaidCartData = { PaidItems: CartItem list; Payment: Payment}
+
+    type ShoppingCart =
+        | EmptyCart  // nenhum dado
+        | ActiveCart of ActiveCartData
+        | PaidCart of PaidCartData
+
+    // ------------------------------------
+    // Comportamento padrão para tipos
+    // ------------------------------------
+
+    // Tipos padrões possuem um padrão já definido, não precisando de codificação nenhuma.
+    // * Imutáveis
+    // * Impressão formatada para depuração
+    // * Igualdade e comparação
+    // * Serialização
+
+    // Impressão formatada usando %A
+    printfn "twoTuple=%A,\nPerson=%A,\nTemp=%A,\nEmployee=%A"
+             twoTuple person1 temp1 worker
+
+    // Igualdade e comparação padrão.
+    // Um exemplo com cartas:
+    type Suit = Club | Diamond | Spade | Heart
+    type Rank = Two | Three | Four | Five | Six | Seven | Eight
+                | Nine | Ten | Jack | Queen | King | Ace
+
+    let hand = [ Club, Ace; Heart, Three; Heart, Ace;
+                 Spade, Jack; Diamond, Two; Diamond, Ace ]
+
+    // ordenando
+    List.sort hand |> printfn "sorted hand is (low to high) %A"
+    List.max hand |> printfn "high card is %A"
+    List.min hand |> printfn "low card is %A"
+
+
+// ================================================
+// Padrões ativos (Active patterns)
+// ================================================
+
+module ActivePatternExamples =
+
+    // F# possui um tipo especial de casamento de padrões chamado "padrões ativos" ("active patterns")
+    // onde o padrão pode ser interpretado ou detectado dinamicamente.
+
+    // parêntesis e barra são a sintaxe para "padrões ativos"
+
+    // Você pode usar "elif" ao invés de "else if" em expressões condicionais.
+    // Elas são equivalentes em F#
+
+    // por exemplo, defina um "padrão ativo" para tratar tipos de caracteres...
+    let (|Digit|Letter|Whitespace|Other|) ch =
+       if System.Char.IsDigit(ch) then Digit
+       elif System.Char.IsLetter(ch) then Letter
+       elif System.Char.IsWhiteSpace(ch) then Whitespace
+       else Other
+
+    // ... e então use ele para interpretar de forma bem mais simples
+    let printChar ch =
+      match ch with
+      | Digit -> printfn "%c is a Digit" ch
+      | Letter -> printfn "%c is a Letter" ch
+      | Whitespace -> printfn "%c is a Whitespace" ch
+      | _ -> printfn "%c is something else" ch
+
+    // imprima a lista
+    ['a'; 'b'; '1'; ' '; '-'; 'c'] |> List.iter printChar
+
+    // ------------------------------------------------
+    // FizzBuzz usando padrões ativos (active patterns)
+    // ------------------------------------------------
+
+    // É possível criar casamento de padrões parcial também
+    // Apenas use sublinhado para a definição, e retorne Some se casado.
+    let (|MultOf3|_|) i = if i % 3 = 0 then Some MultOf3 else None
+    let (|MultOf5|_|) i = if i % 5 = 0 then Some MultOf5 else None
+
+    // a função principal
+    let fizzBuzz i =
+      match i with
+      | MultOf3 & MultOf5 -> printf "FizzBuzz, "
+      | MultOf3 -> printf "Fizz, "
+      | MultOf5 -> printf "Buzz, "
+      | _ -> printf "%i, " i
+
+    // teste
+    [1..20] |> List.iter fizzBuzz
+
+// ================================================
+// Expressividade
+// ================================================
+
+module AlgorithmExamples =
+
+    // F# possui uma alta razão sinais/ruídos, assim o código
+    // é lido praticamento como se descreve o algoritmo
+
+    // ------ Exemplo: defina uma função que faça soma dos quadrados ------
+    let sumOfSquares n =
+       [1..n]              // 1) pega todos os números de 1 a n
+       |> List.map square  // 2) eleva ao quadrado cada um
+       |> List.sum         // 3) soma os resultados
+
+    // teste
+    sumOfSquares 100 |> printfn "Sum of squares = %A"
+
+    // ------ Examplo: defina uma função de ordenação ------
+    let rec sort list =
+       match list with
+       // Se a lista está vazia
+       | [] ->
+            []                            // retorna a lista vazia
+       // Se a lista não está vazia
+       | firstElem::otherElements ->      // pega o primeiro elemento
+            let smallerElements =         // extrai os elementos menores
+                otherElements             // dos restantes
+                |> List.filter (fun e -> e < firstElem)
+                |> sort                   // e ordena eles
+            let largerElements =          // extrai os elementos maiores
+                otherElements             // dos restantes
+                |> List.filter (fun e -> e >= firstElem)
+                |> sort                   // e ordena eles
+            // Combine as 3 partes em uma nova lista e retorne ela
+            List.concat [smallerElements; [firstElem]; largerElements]
+
+    // teste
+    sort [1; 5; 23; 18; 9; 1; 3] |> printfn "Sorted = %A"
+
+// ================================================
+// Código assíncrono
+// ================================================
+
+module AsyncExample =
+
+    // F# possui suporte a funcionalidades para ajudar a escrever código assíncrono
+    // sem tornar o código difícil de manter ("pyramid of doom")
+    //
+    // O seguinte exemplo efetua download de um conjunto de páginas em paralelo.
+
+    open System.Net
+    open System
+    open System.IO
+    open Microsoft.FSharp.Control.CommonExtensions
+
+    // Obtém o conteúdo de cara página de forma assíncrona
+    let fetchUrlAsync url =
+        async {   // a palavra chave "async" e chaves
+                  // criam um objeto assíncrono
+            let req = WebRequest.Create(Uri(url))
+            use! resp = req.AsyncGetResponse()
+                // use! é uma atribuição assíncrona
+            use stream = resp.GetResponseStream()
+                // "use" dispara automaticamente close()
+                // no recurso no fim do escopo
+            use reader = new IO.StreamReader(stream)
+            let html = reader.ReadToEnd()
+            printfn "finished downloading %s" url
+            }
+
+    // uma lista de sites para fazer download
+    let sites = ["http://www.bing.com";
+                 "http://www.google.com";
+                 "http://www.microsoft.com";
+                 "http://www.amazon.com";
+                 "http://www.yahoo.com"]
+
+    // efetue
+    sites
+    |> List.map fetchUrlAsync  // cria uma lista de tarefas assíncronas
+    |> Async.Parallel          // coloca as tarefas para executarem em paralelo
+    |> Async.RunSynchronously  // inicia cada uma
+
+// ================================================
+// Compatibilidade com .NET
+// ================================================
+
+module NetCompatibilityExamples =
+
+    // F# pode pode fazer praticamente tudo que C# pode fazer, e integra
+    // de forma simples com bibliotecas .NET e Mono
+
+    // ------- usando uma função de uma biblioteca existente -------
+
+    let (i1success, i1) = System.Int32.TryParse("123");
+    if i1success then printfn "parsed as %i" i1 else printfn "parse failed"
+
+    // ------- Implementando interfaces de forma simples! -------
+
+    // cria um novo objeto que implementa IDisposable
+    let makeResource name =
+       { new System.IDisposable
+         with member this.Dispose() = printfn "%s disposed" name }
+
+    let useAndDisposeResources =
+        use r1 = makeResource "first resource"
+        printfn "using first resource"
+        for i in [1..3] do
+            let resourceName = sprintf "\tinner resource %d" i
+            use temp = makeResource resourceName
+            printfn "\tdo something with %s" resourceName
+        use r2 = makeResource "second resource"
+        printfn "using second resource"
+        printfn "done."
+
+    // ------- Código orientado a objetos -------
+
+    // F# também possui suporte a orientação a objetos.
+    // Possui suporte a classes, herança, métodos virtuais, etc.
+
+    // interface com tipo genérico
+    type IEnumerator<'a> =
+        abstract member Current : 'a
+        abstract MoveNext : unit -> bool
+
+    // classe base abstrata com métodos virtuais
+    [<AbstractClass>]
+    type Shape() =
+        // propriedades somente leitura
+        abstract member Width : int with get
+        abstract member Height : int with get
+        // método não virtual
+        member this.BoundingArea = this.Height * this.Width
+        // método virtual com implementação base
+        abstract member Print : unit -> unit
+        default this.Print () = printfn "I'm a shape"
+
+    // classe concreta que herda da classe base e sobrescreve
+    type Rectangle(x:int, y:int) =
+        inherit Shape()
+        override this.Width = x
+        override this.Height = y
+        override this.Print ()  = printfn "I'm a Rectangle"
+
+    // testes
+    let r = Rectangle(2, 3)
+    printfn "The width is %i" r.Width
+    printfn "The area is %i" r.BoundingArea
+    r.Print()
+
+    // ------- métodos de extensão -------
+
+    // Assim como em C#, F# pode extender classes já existentes com métodos de extensão.
+    type System.String with
+       member this.StartsWithA = this.StartsWith "A"
+
+    // testes
+    let s = "Alice"
+    printfn "'%s' starts with an 'A' = %A" s s.StartsWithA
+
+    // ------- eventos  -------
+
+    type MyButton() =
+        let clickEvent = new Event<_>()
+
+        [<CLIEvent>]
+        member this.OnClick = clickEvent.Publish
+
+        member this.TestEvent(arg) =
+            clickEvent.Trigger(this, arg)
+
+    // teste
+    let myButton = new MyButton()
+    myButton.OnClick.Add(fun (sender, arg) ->
+            printfn "Click event with arg=%O" arg)
+
+    myButton.TestEvent("Hello World!")
+
+```
+
+## Mais Informações
+
+Para mais demonstrações de F# acesse [why use F#](http://fsharpforfunandprofit.com/why-use-fsharp/).
+
+Leia mais sobre F# em [fsharp.org](http://fsharp.org/) e [dotnet's F# page](https://dotnet.microsoft.com/languages/fsharp).
diff --git a/pt-br/groovy-pt.html.markdown b/pt-br/groovy-pt.html.markdown
index aed23df1..3acfce21 100644
--- a/pt-br/groovy-pt.html.markdown
+++ b/pt-br/groovy-pt.html.markdown
@@ -14,10 +14,10 @@ Groovy - Uma linguagem dinâmica para a plataforma Java. [Leia mais aqui.](http:
 ```groovy
 
 /*
-  Prepara-se:
+  Prepare-se:
 
   1) Instale a máquina virtual de Groovy - http://gvmtool.net/
-  2) Intalse o Groovy: gvm install groovy
+  2) Instale o Groovy: gvm install groovy
   3) Inicie o console groovy digitando: groovyConsole
 
 */
@@ -104,7 +104,7 @@ tecnologiasOrdenadas = tecnologias.sort( false )
 
 /*** Manipulando listas ***/
 
-//Substitue todos os elementos da lista
+//Substitui todos os elementos da lista
 Collections.replaceAll(tecnologias, 'Gradle', 'gradle')
 
 //Desorganiza a lista
@@ -159,7 +159,7 @@ println devMap.values()
       usará este campo.
 
     * Se você quer uma propriedade private ou protected, você deve prover seus
-      próprios getters e setter, que devem ser declarados como private ou protected.
+      próprios getters e setters, que devem ser declarados como private ou protected.
 
     * Se você acessar uma propriedade dentro da classe e esta propriedade é definida
       em tempo de compilação com 'this', implícito ou explícito (por exemplo,
@@ -236,7 +236,7 @@ assert x.equals("Roberto Grails Groovy ")
 /*
   Operadores
 
-  Sobrecarregamento de Operadores para uma lsita dos operadores comuns que
+  Sobrecarga de Operadores para uma lista dos operadores comuns que
   Grooby suporta:
   http://www.groovy-lang.org/operators.html#Operator-Overloading
 
@@ -254,7 +254,7 @@ def nomeUsuario = usuario?.nomeUsuario
 
 /*
   Closures
-  Um closure, em Grooby, é como um "bloco de código" ou um ponteiro para método.
+  Um closure, em Groovy, é como um "bloco de código" ou um ponteiro para método.
   É um pedação de código que é definido e executado em um momento posterior.
 
   Mais informação em: http://www.groovy-lang.org/closures.html
@@ -269,7 +269,7 @@ clos()
 def soma = { a, b -> println a+b }
 soma(2,4)
 
-//Closdures por referir-se a variáveis que não estão listadas em sua
+//Closures podem referir-se a variáveis que não estão listadas em sua
 //lista de parêmetros.
 def x = 5
 def multiplicarPor = { num -> num * x }
@@ -309,7 +309,7 @@ chamaClosure(3, 4)
 /*
   Expando
 
-  A classe Expando é um bean dinâmico que permite adicionar propriedade e 
+  A classe Expando é um bean dinâmico que permite adicionar propriedades e 
   closures como métodos a uma instância desta classe
 
   http://mrhaki.blogspot.mx/2009/10/groovy-goodness-expando-as-dynamic-bean.html
diff --git a/pt-br/haskell-pt.html.markdown b/pt-br/haskell-pt.html.markdown
index 181aa471..c55a4c03 100644
--- a/pt-br/haskell-pt.html.markdown
+++ b/pt-br/haskell-pt.html.markdown
@@ -41,7 +41,7 @@ o desenvolvimento deste paradigma de programação.
 7 * 7 -- 7 vezes 7
 7 / 7 -- 7 dividido por 7
 
--- Divisões não são inteiras, são fracionádas por padrão da linguagem
+-- Divisões não são inteiras, são fracionadas por padrão da linguagem
 28736 / 82374 -- 0.3488479374559934
 
 
@@ -67,7 +67,7 @@ not False -- Nega uma falácia
 7 > 7 -- 7 é maior que 7 ?
 
 
-{- Haskell é uma linguagem que tem uma sintáxe bastante familiar na
+{- Haskell é uma linguagem que tem uma sintaxe bastante familiar na
    matemática, por exemplo em chamadas de funções você tem:
 
    NomeFunção ArgumentoA ArgumentoB ArgumentoC ...
diff --git a/pt-br/javascript-pt.html.markdown b/pt-br/javascript-pt.html.markdown
index ed4a6ff3..e38804f3 100644
--- a/pt-br/javascript-pt.html.markdown
+++ b/pt-br/javascript-pt.html.markdown
@@ -2,7 +2,7 @@
 language: javascript
 filename: javascript-pt.js
 contributors:
-    - ["Adam Brenecki", "http://adam.brenecki.id.au"]
+    - ["Leigh Brenecki", "https://leigh.net.au"]
     - ["Ariel Krakowski", "http://www.learneroo.com"]
 translators:
     - ["Willian Justen", "http://willianjusten.com.br"]
@@ -20,8 +20,8 @@ que é um projeto que fornece um interpretador baseado no motor V8 do Google
 Chrome e está se tornando cada vez mais famoso.
 
 Feedback são muito apreciados! Você me encontrar em
-[@adambrenecki](https://twitter.com/adambrenecki), ou
-[adam@brenecki.id.au](mailto:adam@brenecki.id.au).
+[@ExcitedLeigh](https://twitter.com/ExcitedLeigh), ou
+[l@leigh.net.au](mailto:l@leigh.net.au).
 
 ```js
 // Comentários são como em C. Comentários de uma linha começam com duas barras,
@@ -361,7 +361,7 @@ myObj.myFunc(); // = "Olá mundo!"
 var myFunc = myObj.myFunc;
 myFunc(); // = undefined
 
-// Inversamente, uma função pode ser atribuída a um objeto e ganhar a acesso
+// Inversamente, uma função pode ser atribuída à um objeto e ganhar a acesso
 // através do `this`, até mesmo se ela não for chamada quando foi definida.
 var myOtherFunc = function(){
     return this.myString.toUpperCase();
@@ -416,7 +416,7 @@ myNewObj.myNumber; // = 5
 // vai olhar imediatamente para o seu prototype.
 
 // Algumas implementações em JS deixam você acessar o objeto prototype com a 
-// propriedade mágica `__proto__`. Enquanto isso é util para explicar 
+// propriedade mágica `__proto__`. Enquanto isso é útil para explicar 
 // prototypes, não é parte de um padrão; nós vamos falar de algumas formas de 
 // usar prototypes depois.
 
@@ -489,7 +489,7 @@ if (0){
 }
 
 // Entretanto, esses objetos encapsulados e as funções originais compartilham
-// um mesmo prototype, portanto você pode adicionar funcionalidades a uma string,
+// um mesmo prototype, portanto você pode adicionar funcionalidades à uma string,
 // por exemplo.
 String.prototype.firstCharacter = function(){
     return this.charAt(0);
diff --git a/pt-br/julia-pt.html.markdown b/pt-br/julia-pt.html.markdown
index 48d97e58..52675bf5 100644
--- a/pt-br/julia-pt.html.markdown
+++ b/pt-br/julia-pt.html.markdown
@@ -8,7 +8,7 @@ translators:
 lang: pt-br
 ---
 
-Julia é uma linguagem homoiconic funcional focada na computação tecnica. Ao mesmo tempo que ela tem todo o poder dos homoiconic macros, funções de primeira classe, e controle de baixo nivel, Julia é tão facil para aprender e usar quanto Python.
+Julia é uma linguagem homoicônica funcional focada na computação técnica. Ao mesmo tempo que ela tem todo o poder dos macros homoicônicos, funções de primeira classe, e controle de baixo nível, Julia é tão fácil para aprender e usar quanto Python.
 
 Este tutorial é baseado no Julia 0.3.
 
@@ -104,7 +104,7 @@ println("Eu sou Julia. Prazer em conhece-lo!")
 ## 2. Variáveis e coleções
 ####################################################
 
-#Você não declara variáveis antes de atribui-lás.
+#Você não declara variáveis antes de atribui-las.
 some_var = 5 # => 5
 some_var # => 5
 
diff --git a/pt-br/kotlin-pt.html.markdown b/pt-br/kotlin-pt.html.markdown
index 7c3313fc..bbe8c0d1 100644
--- a/pt-br/kotlin-pt.html.markdown
+++ b/pt-br/kotlin-pt.html.markdown
@@ -70,7 +70,7 @@ fun olaMundo(val nome : String) {
     println(umaStringModelo)
 
     /*
-    Para uma variável receber null deve-se explicitamente declara-la
+    Para uma variável receber null deve-se explicitamente declará-la
     como anulável.
     A declaração de anulável é realizada incluindo uma "?" ao fim do tipo.
     Pode-se acessar uma variável anulável usando o operador "?."
@@ -166,7 +166,7 @@ fun olaMundo(val nome : String) {
 
     /*
     Classes de dados são um modo sucinto de criar classes que servem apenas
-    para guardas informações.
+    para guardar informações.
     Os métodos "hashCode", "equals" e "toString" são gerados automaticamente.
     */
     data class ExemploClasseDados (val x: Int, val y: Int, val z: Int)
diff --git a/pt-br/latex-pt.html.markdown b/pt-br/latex-pt.html.markdown
index 103af28e..58586522 100644
--- a/pt-br/latex-pt.html.markdown
+++ b/pt-br/latex-pt.html.markdown
@@ -62,7 +62,7 @@ Svetlana Golubeva}
 
 \newpage
 
-% Muitos artigos de pesquisa possuem um resumo, e pode-se isar comandos
+% Muitos artigos de pesquisa possuem um resumo, e pode-se usar comandos
 % predefinidos para isso.
 % Isso deve aparecer em sua ordem lógica, portanto, após o topo,
 % mas antes das seções principais do corpo.
diff --git a/pt-br/lua-pt.html.markdown b/pt-br/lua-pt.html.markdown
new file mode 100644
index 00000000..0c75da26
--- /dev/null
+++ b/pt-br/lua-pt.html.markdown
@@ -0,0 +1,423 @@
+---
+language: Lua
+contributors:
+    - ["Tyler Neylon", "http://tylerneylon.com/"]
+filename: learnlua.lua
+translators:
+    - ["Iaan Mesquita", "https://github.com/ianitow"]
+lang: pt-br
+---
+
+```lua
+-- Dois hífens começam um comentário de uma linha.
+
+--[[
+     Adicionar dois [  ] (colchetes) criam um comentário
+     de múltiplas linhas.
+--]]
+
+----------------------------------------------------
+-- 1. Variáveis e fluxo de controle.
+----------------------------------------------------
+
+num = 42  -- Todos os números são doubles.
+-- Não se preocupe, doubles de 64-bits contém 52 bits para
+-- armazenar corretamente valores int; a precisão da máquina
+-- não é um problema para ints que são < 52 bits.
+
+s = 'alternados'  -- String são imutáveis, como em Python.
+t = "Aspas duplas também são válidas"
+u = [[ Dois colchetes
+       começam e terminam
+       strings de múltiplas linhas.]]
+t = nil  -- Torna t undefined(indefinido); Lua tem um Garbage Collector.
+
+-- Blocos são representados com palavras do/end:
+while num < 50 do
+  num = num + 1  -- Sem operadores do tipo ++ ou +=
+end
+
+--Cláusula If :
+if num > 40 then
+  print('over 40')
+elseif s ~= 'walternate' then  -- ~= signfica não é igual.
+  -- Para fazer checagem use == como em Python; Funciona para comparar strings também.
+  io.write('not over 40\n')  -- Padrão para saídas.
+else
+  -- Variáveis são globais por padrão.
+  thisIsGlobal = 5  -- Camel case é o comum.
+
+  -- Como fazer variáveis locais:
+  local line = io.read()  -- Leia a proxima linha de entrada.
+
+  -- Para concatenação de strings use o operador .. :
+  print('Winter is coming, ' .. line)
+end
+
+-- Variáveis indefinidas são do tipo nil.
+-- Isso não é um erro:
+foo = anUnknownVariable  -- Agora foo = nil.
+
+aBoolValue = false
+
+-- Apenas nil e false são do tipo falso; 0 e '' são verdadeiros!
+if not aBoolValue then print('twas false') end
+
+-- 'or' e 'and' são operadores lógicos.
+-- Esse operador em C/JS a?b:c , em lua seria o mesmo que:
+ans = aBoolValue and 'yes' or 'no'  --> 'no'
+
+karlSum = 0
+for i = 1, 100 do  -- O intervalo inclui inicio e fim.
+  karlSum = karlSum + i
+end
+
+-- Use "100, 1, -1" para um intervalo que diminui:
+fredSum = 0
+for j = 100, 1, -1 do fredSum = fredSum + j end
+
+-- Em geral, o intervalo é começo, fim[, etapas].
+
+-- Outro construtor de loop:
+repeat
+  print('A estrada do futuro.')
+  num = num - 1
+until num == 0
+
+
+----------------------------------------------------
+-- 2. Funções.
+----------------------------------------------------
+
+function fib(n)
+  if n < 2 then return 1 end
+  return fib(n - 2) + fib(n - 1)
+end
+
+-- Closures e Funções anônimas são permitidas:
+function adder(x)
+  -- O retorno da função é criado quando adder é
+  -- chamado, e ele sabe o valor de x:
+  return function (y) return x + y end
+end
+a1 = adder(9)
+a2 = adder(36)
+print(a1(16))  --> 25
+print(a2(64))  --> 100
+
+-- Retornos, chamadas de funções e atribuições, todos eles trabalham
+-- com listas que podem ter tamanhos incompatíveis.
+-- Receptores incompatpiveis serão nil;
+-- Destinos incompatíveis serão descartados.
+
+x, y, z = 1, 2, 3, 4
+-- Agora x = 1, y = 2, z = 3, e 4 é jogado fora.
+
+function bar(a, b, c)
+  print(a, b, c)
+  return 4, 8, 15, 16, 23, 42
+end
+
+x, y = bar('zaphod')  --> imprime "zaphod  nil nil"
+-- Agora x = 4, y = 8, os valores 15...42 foram descartados.
+
+-- Funções são de primeira-classe, portanto podem ser local/global.
+-- Estes exemplos são equivalentes:
+function f(x) return x * x end
+f = function (x) return x * x end
+
+-- Logo, estes são equivalentes também:
+local function g(x) return math.sin(x) end
+local g; g  = function (x) return math.sin(x) end
+--  'local g' essa declaração de auto-referência é válida.
+
+-- A propósito, as funções de trigonometria trabalham em radianos.
+
+-- Chamadas de função com apenas um parâmetro de string não precisam de parênteses:
+print 'hello'  -- Funciona perfeitamente.
+
+
+----------------------------------------------------
+-- 3. Tabelas.
+----------------------------------------------------
+
+-- Tabelas = A unica estrutura de dados composta em Lua;
+--          elas são matrizes associativas.
+-- Semelhantes aos arrays de PHP ou objetos de javascript, eles são:
+-- hash-lookup(chave:valor) que também podem ser usados como listas.
+
+-- Usando tabelas como dicionário / mapas:
+
+-- Dicionários literais tem strings como chaves por padrão:
+t = {key1 = 'value1', key2 = false}
+
+-- As chaves do tipo string podem usar notação de ponto,semelhante a javascript:
+print(t.key1)  -- Imprime 'value1'.
+t.newKey = {}  -- Adiciona um novo par chave/valor.
+t.key2 = nil   -- Remove key2 da tabela.
+
+-- Qualquer notação literal (não-nulo) pode ser uma chave:
+u = {['@!#'] = 'qbert', [{}] = 1729, [6.28] = 'tau'}
+print(u[6.28])  -- imprime "tau"
+
+-- A correspondência de chave é basicamente o valor para números
+-- e strings, mas por identidade para tabelas.
+a = u['@!#']  -- Agora a = 'qbert'.
+b = u[{}]     -- Nós esperavamso o resultado 1729, mas ele é nil:
+-- b = nil já que a busca falha. Ela falha
+-- porque a chave que usamos não é a mesma que o objeto
+-- como aquele que usamos para guardar o valor original. Por isso
+-- strings & numeros são chaves mais recomendadas.
+
+-- Uma chamada de função de apenas um paramêtro de tabela, não precisa de parênteses:
+
+function h(x) print(x.key1) end
+h{key1 = 'Sonmi~451'}  -- Imprime 'Sonmi~451'.
+
+for key, val in pairs(u) do  -- Iteração de tabela.
+  print(key, val)
+end
+
+-- _G é uma tabela especial que guarda tudo que é global.
+print(_G['_G'] == _G)  -- Imprime 'true'.
+
+-- Usando tabelas como listas / arrays:
+
+-- Listas literais com chaves int implícitas:
+v = {'value1', 'value2', 1.21, 'gigawatts'}
+for i = 1, #v do  -- #v é o tamanho de v
+  print(v[i])  -- Índices começam em 1 !! MUITO LOCO!
+end
+-- Uma 'list' não é um tipo real. v é apenas uma tabela
+-- com chaves int consecutivas, tratando ela como uma lista.
+
+----------------------------------------------------
+-- 3.1 Metatabelas e metamétodos.
+----------------------------------------------------
+
+-- Uma tabela pode ter uma metatabela que fornece à tabela
+-- um compotamento de sobrecarga de operador. Depois veremos
+-- como metatabelas suportam o comportamento do Javascript-prototype.
+
+f1 = {a = 1, b = 2}  -- Representa uma fração de a/b.
+f2 = {a = 2, b = 3}
+
+-- Isso falharia:
+-- s = f1 + f2
+
+metafraction = {}
+function metafraction.__add(f1, f2)
+  sum = {}
+  sum.b = f1.b * f2.b
+  sum.a = f1.a * f2.b + f2.a * f1.b
+  return sum
+end
+
+setmetatable(f1, metafraction)
+setmetatable(f2, metafraction)
+
+s = f1 + f2  -- chama __add(f1, f2) na metatabela de f1
+
+-- f1, f2 não tem chave para sua metatabela, ao contrário de
+-- prototypes em javascript, então você deve recuperá-lo com
+-- getmetatable(f1). A metatabela é uma tabela normal
+-- com chaves que Lua reconhece, como __add.
+
+-- Mas a proxima linha irá falhar porque s não tem uma metatabela:
+-- t = s + s
+-- O padrão de Classes abaixo consertam esse problema.
+
+-- Uma __index em uma metatable sobrecarrega pesquisas de ponto:
+defaultFavs = {animal = 'gru', food = 'donuts'}
+myFavs = {food = 'pizza'}
+setmetatable(myFavs, {__index = defaultFavs})
+eatenBy = myFavs.animal  -- Funciona! obrigado, metatabela.
+
+-- As pesquisas diretas de tabela que falham tentarão pesquisar novamente usando
+-- o __index da metatabela, e isso é recursivo.
+
+-- Um valor de __index também pode ser uma function(tbl, key)
+-- para pesquisas mais personalizadas.
+
+-- Valores do tipo __index,add, .. são chamados de metamétodos.
+-- Uma lista completa com os metamétodos.
+
+-- __add(a, b)                     para a + b
+-- __sub(a, b)                     para a - b
+-- __mul(a, b)                     para a * b
+-- __div(a, b)                     para a / b
+-- __mod(a, b)                     para a % b
+-- __pow(a, b)                     para a ^ b
+-- __unm(a)                        para -a
+-- __concat(a, b)                  para a .. b
+-- __len(a)                        para #a
+-- __eq(a, b)                      para a == b
+-- __lt(a, b)                      para a < b
+-- __le(a, b)                      para a <= b
+-- __index(a, b)  <fn or a table>  para a.b
+-- __newindex(a, b, c)             para a.b = c
+-- __call(a, ...)                  para a(...)
+
+----------------------------------------------------
+-- 3.2 Tabelas como Classes e sua herança.
+----------------------------------------------------
+
+-- Classes não são disseminadas; existem maneiras diferentes
+-- para fazer isso usando tabelas e metamétodos...
+
+-- A explicação para este exemplo está logo abaixo.
+
+Dog = {}                                   -- 1.
+
+function Dog:new()                         -- 2.
+  newObj = {sound = 'woof'}                -- 3.
+  self.__index = self                      -- 4.
+  return setmetatable(newObj, self)        -- 5.
+end
+
+function Dog:makeSound()                   -- 6.
+  print('I say ' .. self.sound)
+end
+
+mrDog = Dog:new()                          -- 7.
+mrDog:makeSound()  -- 'I say woof'         -- 8.
+
+-- 1. Dog atua como uma classe; mas na verdade, é uma tabela.
+-- 2. function tablename:fn(...) é a mesma coisa que
+--    function tablename.fn(self, ...)
+--    O : apenas adiciona um primeiro argumento chamado self.
+--    Leia 7 & 8 abaixo para ver como self obtém seu valor.
+-- 3. newObj será uma instância da classe Dog.
+-- 4. self = a classe que que foi instanciada. Regularmente
+--    self = Dog, mas a herança pode mudar isso.
+--    newObj recebe as funções de self como se tivessimos definido em ambos
+--    a metatabela de newObj e self __index para self.
+-- 5. Lembre-se: setmetatable retorna seu primeiro argumento definido.
+-- 6. O : funciona como em 2, mas desta vez esperamos que
+--    self seja uma instância já instanciada da classe.
+-- 7. Igual a Dog.new(Dog), logo self = Dog no new().
+-- 8. Igual a mrDog.makeSound(mrDog); self = mrDog.
+
+----------------------------------------------------
+
+-- Heranças exemplos:
+
+LoudDog = Dog:new()                           -- 1.
+
+function LoudDog:makeSound()
+  s = self.sound .. ' '                       -- 2.
+  print(s .. s .. s)
+end
+
+seymour = LoudDog:new()                       -- 3.
+seymour:makeSound()  -- 'woof woof woof'      -- 4.
+
+-- 1. LoudDog recebe os metodos e variáveis de Dog.
+-- 2. self tem uma chave 'sound' vindo de new(), veja o 3.
+-- 3. Mesma coisa que LoudDog.new(LoudDog), convertido para
+--    Dog.new(LoudDog) como LoudDog não tem uma chave 'new',
+--    mas tem uma chave __index = Dog na sua metatabela o
+--    resultado será: a metabela de seymour é a LoudDog, e
+--    LoudDog.__index = LoudDog. Então seymour.key será
+--    = seymour.key, LoudDog.key, Dog.key,seja qual for a primeira
+--    chave fornecida.
+-- 4. A chave 'makeSound' foi encontrada em LoudDog; isto
+--    é a mesma coisa que LoudDog.makeSound(seymour).
+
+-- Se precisar de, uma subclasse de new() como uma base:
+function LoudDog:new()
+  newObj = {}
+  -- define newObj
+  self.__index = self
+  return setmetatable(newObj, self)
+end
+
+----------------------------------------------------
+-- 4. Módulos.
+----------------------------------------------------
+
+
+--[[ Estou comentando esta seção, então o resto
+--   desse script é executável.
+```
+
+```lua
+-- Suponhamos que o arquivo mod.lua se pareça com isso:
+local M = {}
+
+local function sayMyName()
+  print('Hrunkner')
+end
+
+function M.sayHello()
+  print('Why hello there')
+  sayMyName()
+end
+
+return M
+
+-- Outro arquivo pode usar as funcionalidades de mod.lua:
+local mod = require('mod')  -- Roda o arquivo mod.lua.
+
+-- require é a forma que usamos para incluir módulos.
+-- require atua como:     (se não for cacheado; veja abaixo)
+local mod = (function ()
+  <contents of mod.lua>
+end)()
+-- É como se mod.lua fosse um corpo de uma função, então
+-- os locais dentro de mod.lua são invisíveis fora dele.
+
+-- Isso irá funcionar porque mod aqui = M dentro de mod.lua:
+mod.sayHello()  -- Diz olá para Hrunkner.
+
+-- Isso aqui é errado; sayMyName existe apenas em mod.lua:
+mod.sayMyName()  -- erro
+
+-- valores retornados de require são armazenados em cache para que um arquivo seja
+-- execute no máximo uma vez, mesmo quando é exigidos várias vezes.
+
+-- Suponhamos que mod2.lua contém "print('Hi!')".
+local a = require('mod2')  -- Imprime Hi!
+local b = require('mod2')  -- Não imprime;pois a=b.
+
+-- dofile é parecido com require, porém sem cacheamento:
+dofile('mod2.lua')  --> Hi!
+dofile('mod2.lua')  --> Hi! (roda novamente)
+
+-- loadfile carrega um arquivo lua, porém não o executa.
+f = loadfile('mod2.lua')  -- Chame f() para executar.
+
+-- loadstring é um loadfile para strings.
+g = loadstring('print(343)')  -- Retorna uma função.
+g()  -- Imprime 343; nada foi impresso antes disso.
+
+--]]
+
+```
+
+## Referências
+
+Fiquei bastante animado para aprender Lua pois consegui fazer jogos
+com a <a href="http://love2d.org/">Love 2D engine de jogos</a>.
+
+Eu comecei com <a href="http://nova-fusion.com/2012/08/27/lua-for-programmers-part-1/">BlackBulletIV's para programadores LUA</a>.
+Em seguida, eu li a documentação oficial <a href="https://www.lua.org/manual/5.1/pt/index.html#contents">Programando em Lua</a>.
+É assim que se começa.
+
+Pode ser útil conferir <a href="http://lua-users.org/files/wiki_insecure/users/thomasl/luarefv51.pdf">Uma pequena referencia sobre LUA</a> em lua-users.org.
+
+Os principais tópicos não cobertos, são as bibliotecas padrões:
+
+- <a href="http://lua-users.org/wiki/StringLibraryTutorial">Biblioteca de strings</a>
+- <a href="http://lua-users.org/wiki/TableLibraryTutorial">Biblioteca de tabelas</a>
+- <a href="http://lua-users.org/wiki/MathLibraryTutorial">Biblioteca de matemática</a>
+- <a href="http://lua-users.org/wiki/IoLibraryTutorial">Biblioteca de entrada/saída</a>
+- <a href="http://lua-users.org/wiki/OsLibraryTutorial">Biblioteca do sistema operacional</a>
+
+A propósito, todo este arquivo é um código LUA válido, salve-o como
+aprenda.lua e rode-o com "lua aprenda.lua" !
+
+Este guia foi escrito pela primeira vez por tylerneylon.com, e agora
+também disponível em <a href="https://gist.github.com/tylerneylon/5853042">github gist</a>. E também em português.
+
+Se divirta com lua
diff --git a/pt-br/markdown-pt.html.markdown b/pt-br/markdown-pt.html.markdown
index c2aa515d..dc50cac1 100644
--- a/pt-br/markdown-pt.html.markdown
+++ b/pt-br/markdown-pt.html.markdown
@@ -4,6 +4,9 @@ contributors:
     - ["Dan Turkel", "http://danturkel.com/"]
 translators:
     - ["Miguel Araújo", "https://github.com/miguelarauj1o"]
+    - ["Gabriele Luz", "https://github.com/gabrieleluz"]
+    - ["Monique Baptista", "https://github.com/bfmonique"]
+
 lang: pt-br    
 filename: learnmarkdown-pt.md
 ---
@@ -11,40 +14,50 @@ filename: learnmarkdown-pt.md
 Markdown foi criado por John Gruber in 2004. Originado para ser fácil de ler e 
 escrever sintaxe que converte facilmente em HTML (hoje, suporta outros formatos também).
 
-Dê-me feedback tanto quanto você quiser! / Sinta-se livre para a garfar (fork) e 
+Dê-me feedback tanto quanto você quiser! / Sinta-se livre para fazer uma bifurcação (fork) e 
 puxar o projeto (pull request)
 
+## Elementos HTML
+Markdown é um superconjunto do HTML, de modo que qualquer arvquivo HTML é 
+um arquivo Markdown válido.
 ```md
-<!-- Markdown é um superconjunto do HTML, de modo que qualquer arvquivo HTML é 
-um arquivo Markdown válido, isso significa que nós podemos usar elementos HTML 
+<!-- Markdown é um superconjunto do HTML, de modo que qualquer arquivo HTML é 
+um arquivo Markdown válido. Isso significa que nós podemos usar elementos HTML 
 em Markdown, como o elemento de comentário, e eles não serão afetados pelo analisador
 de remarcação. No entanto, se você criar um elemento HTML em seu arquivo Markdown, você
-não pode usar sintaxe remarcação dentro desse conteúdo do elemento.-->
+não pode usar sintaxe de remarcação dentro desse conteúdo do elemento.-->
+
+<!--A maneira como o Markdown é analisado varia de software para software.
+Este guia vai tentar esclarecer quando as características são universais, ou quando eles são específicos para um determinado interpretador -->
+
 
-<!--Markdown também varia de implementação de um analisador para uma próxima.
-Este guia vai tentar esclarecer quando as características são universais, ou quando eles são 
-específico para um determinado parser -->
+## Cabeçalhos
+
+Você pode criar elementos HTML `<h1>` até `<h6>` facilmente antecedendo o texto
+que deseja estar nesse elemento por um número de hashes (#)
 
-<!-- Cabeçalhos -->
-<!-- Você pode criar elementos HTML <h1> até <h6> facilmente antecedendo o texto
-que deseja estar nesse elemento por um número de hashes (#) -->
 # Isto é um cabeçalho <h1>
 ## Isto é um cabeçalho <h2>
 ### Isto é um cabeçalho <h3>
 #### Isto é um cabeçalho <h4>
 ##### Isto é um cabeçalho <h5>
 ###### Isto é um cabeçalho <h6>
+```
 
-<!-- Markdown também nos fornece duas maneiras alternativas de indicar h1 e h2 -->
+Markdown também nos fornece duas maneiras alternativas de indicar h1 e h2
+
+```md
 Isto é um cabeçalho h1
 ======================
 
 Isto é um cabeçalho h2
 ----------------------
+```
 
-<!-- Estilos de texto simples --> 
-<!-- O texto pode ser facilmente denominado como remarcação itálico, negrito ou tachado usando -->
+## Estilos de texto simples
+O texto pode ser facilmente denominado como marcação itálico, negrito ou tachado usando:
 
+```md
 *Este texto está em itálico*
 _E este também está._
 
@@ -54,43 +67,55 @@ __E este também está._
 ***Este texto está em negrito e itálico.***
 **_E este também está_**
 *--Danouse! Este também__*
+```
 
-<!-- Em GitHub Flavored Markdown, que é usado para processar arquivos Markdown 
-GitHub, nós também temos: --> 
+Em GitHub Flavored Markdown, que é usado para processar arquivos Markdown 
+GitHub, nós também temos:
 
+```md
 ~~Este texto é processado com tachado.~~
+```
 
-<!-- Os parágrafos estão uma ou várias linhas adjacentes de texto separadas por 
-uma ou múltiplas linhas em branco. -->
+## Parágrafos
+Os parágrafos estão uma ou várias linhas adjacentes de texto separadas por 
+uma ou múltiplas linhas em branco.
 
+```md
 Este é um parágrafo. Eu estou digitando em um parágrafo, não é legal?
 
-Agora, eu estou no parágrado 2.
+Agora, eu estou no parágrafo 2.
 ... Ainda continuo no parágrafo 2! :)
 
 Eu estou no parágrafo três.
+```
 
-<!-- Se você quiser inserir uma tag HTML <br />, você pode acabar com um parágrafo 
-com dois ou mais espaços e, em seguida, começar um novo parágrafo -->
+Se você quiser inserir uma tag HTML `<br />`, você pode acabar com um parágrafo 
+com dois ou mais espaços e, em seguida, começar um novo parágrafo
 
+```md
 Termino com dois espaços (destacar-me para vê-los). 
 
 Há um <br /> acima de mim!
+```
+
 
-<!-- Bloco de citações são fáceis e feito com o caractere >. -->
+Bloco de citações são fáceis e feito com o caractere >.
 
+```md
 > Este é um bloco de citação. Você pode 
-> Enrolar manualmente suas linhas e colocar um `>` antes de cada linha ou você pode
-> deixar suas linhas ficarem muito longas e enrolar por conta própria. Não faz diferença, 
+> Quebrar manualmente suas linhas e colocar um `>` antes de cada linha ou você pode
+> deixar suas linhas ficarem muito longas e quebrarem por conta própria. Não faz diferença, 
 > desde que eles começam com um `>`.
+	
 
 > Você também pode usar mais de um nível 
->> De recuo? 
-> Como pura é isso?
+>> De recuo?
+```
 
-<!-- Listas --> 
-<!-- As listas não ordenadas podem ser feitas usando asteriscos, positivos ou hífens -->
+## Listas
+As listas não ordenadas podem ser feitas usando asteriscos, positivos ou hífens
 
+```md
 * Item
 * Item
 * Outro item
@@ -106,146 +131,202 @@ ou
 - Item
 - Item
 - Um último item
+```
 
-<!-- Listas ordenadas são feitas com um número seguido por um ponto -->
+Listas ordenadas são feitas com um número seguido por um ponto.
 
+```md
 1. Item um
 2. Item dois
-3. Tem três
+3. Item três
+```
 
-<!-- Você não tem poder para rotular os itens corretamente e a remarcação será ainda
-tornar os números em ordem, mas isso pode não ser uma boa idéia -->
+<!-- Você não tem poder para rotular os itens corretamente e a remarcação ainda deixará os 
+itens em ordem, mas isso pode não ser uma boa idéia -->
 
+
+```md
 1. Item um
 1. Item dois
 1. Item três
-<!-- (Isto é processado da mesma forma que o exemplo acima) -->
+```
+(Isto é processado da mesma forma que o exemplo acima)
 
-<!-- Você também pode usar subtítulos -->
+Você também pode usar sublistas
 
+```md
 1. Item um
 2. Item dois
 3. Item três
     * Sub-item
     * Sub-item
 4. Item quatro
+```
+
+Existem também listas de tarefas. Isso cria checkboxes (caixas de seleção) de HTML
+
+```md
+As caixas abaixo sem o 'x' são checkboxes HTML desmarcadas
+- [ ] Primeira tarefa a completar
+- [ ] Segunda tarefa a completar
+A caixa de seleção abaixo será exibida como uma checkbox HTML marcada
+- [x] Essa tarefa foi completa
+
+```
 
-<!-- blocos de código --> 
-<!-- Você pode indicar um bloco de código (que utiliza o elemento <code>) pelo recuo
-uma linha com quatro espaços ou uma guia -->
 
+## Blocos de código
+Você pode indicar um bloco de código (que utiliza o elemento `<code>`) pelo recuo
+uma linha com quatro espaços ou uma guia
+```md
 	Isto é código
 	É assim, sacou?
+	
+```
 
-<!-- Você pode também re-guia (ou adicionar mais quatro espaços adicionais) para o recuo 
-dentro do seu código -->
+Você pode também re-guia (ou adicionar mais quatro espaços adicionais) para o recuo 
+dentro do seu código
 
+```md
 	my_array.each do |item|
         puts item
     end	
+ ```
 
-<!-- Código embutido pode ser criada usando o caractere de crase ` -->
+Código embutido pode ser criada usando o caractere de crase `` ` ``
 
-John não sabia nem o que o função 'goto()' fazia!
-
-<!-- Em GitHub Flavored Markdown, você pode usar uma sintaxe especial para o código -->
+```md
+John não sabia nem o que o função `goto()` fazia!
+```
 
+Em GitHub Flavored Markdown, você pode usar uma sintaxe especial para o código
+```md
+	``` ruby
+	def foobar
+    	puts "Hello world!"
+	end
+	```
+```
+=======
 \`\`\`ruby <!-- exceto remover essas barras invertidas quando você faz isso, apenas ```
 ruby! --> 
 def foobar
     puts "Hello world!"
 end
-\`\`\` <!-- Aqui também, não barras invertidas, apenas ``` -->
+\`\`\` <!-- Aqui também, não use barras invertidas, apenas ``` -->
 
-<-- O texto acima não requer recuo, mas o GitHub vai usar a sintaxe 
-destacando do idioma que você especificar após a ``` -->
+O texto acima não requer recuo, além disso o GitHub vai usar a sintaxe highlight da linguagem que você especificar após a \`\`\`.
 
-<!-- Regra Horizontal (<hr />) --> 
-<!-- Regras horizontais são facilmente adicionados com três ou mais asteriscos ou hífens,
-com ou sem espaços. -->
+## Linha Horizontal
+Linhas horizontais são facilmente adicionados com três ou mais asteriscos ou hífens,
+com ou sem espaços.
 
+```md
 ***
 ---
 - - - 
 ****************
+```
 
-<!-- Links --> 
-<!-- Uma das melhores coisas sobre a remarcação é o quão fácil é fazer ligações. Colocar 
-o texto a ser exibido entre parênteses rígidos [] seguido pela url em parênteses () -->
+## Links
+Uma das melhores coisas sobre a marcação é o quão fácil é fazer ligações. Colocar 
+o texto a ser exibido entre parênteses rígidos [] seguido pela url em parênteses ()
 
+```md
 [Click aqui!](http://test.com/)
+```
 
-<!-- Você também pode adicionar um título link usando aspas dentro dos parênteses -->
+Você também pode adicionar um título link usando aspas dentro dos parênteses
 
+```md
 [Click aqui!](http://test.com/ "Link para Test.com")
+```
 
-<!-- Caminhos relativos funcionam também. -->
+Caminhos relativos funcionam também.
 
+```md
 [Ir para música](/música/).
+```
 
-<!-- Markdown também suporta ligações de estilo de referência -->
+Markdown também suporta ligações de estilo de referência
 
+```md
 [Clique neste link] [link1] para mais informações sobre isso!
 [Além disso, verifique este link] [foobar] se você quiser.
 
 [link1]: http://test.com/ "Legal!"
 [foobar]: http://foobar.biz/ "OK!"
+```
 
-<!-- O título também pode estar entre aspas simples ou entre parênteses, ou omitido 
+O título também pode estar entre aspas simples ou entre parênteses, ou omitido 
 inteiramente. As referências podem estar em qualquer lugar no documento e os IDs de referência 
-pode ser qualquer um, desde que eles são únicos. -->
+pode ser qualquer um, desde que eles são únicos.
 
-<!-- Existe também o "nomear implícita", que permite que você use o texto do link como o id --> 
+Existe também a "nomeação implicita", que permite que você use o texto do link como o id
 
+```md
 [Este] [] é um link. 
 
 [este]: http://thisisalink.com/ 
+```
 
-<!-- Mas não são usados normalmente--> 
+Mas não são usados normalmente
 
-<!-- Imagens --> 
-<!-- As imagens são feitas da mesma forma que as ligações, mas com um ponto de exclamação na frente! -->
+## Imagens
+As imagens são feitas da mesma forma que as ligações, mas com um ponto de exclamação na frente!
 
+```md
 ![Este é pairar-texto (texto alternativo) para minha imagem](http://imgur.com/myimage.jpg "Um título opcional") 
+```
 
-<!-- E estilo de referência funciona como esperado --> 
+E estilo de referência funciona como esperado
 
+```md
 ![Este é o pairar-texto.][Myimage] 
 
 [myimage]: relative/urls/legal/image.jpg "se você precisa de um título, é aqui" 
+```
 
-<!-- Miscelânea --> 
-<!-- Auto-links --> 
+## Miscelânea 
+### Auto-links 
 
+```md
 <http://testwebsite.com/> é equivalente a 
 [http://testwebsite.com/](http://testwebsite.com/) 
+```
 
-<!-- Auto-links para e-mails --> 
+### Auto-links para e-mails
 
+```md
 <foo@bar.com> 
+```
 
-<!-- Escapando caracteres --> 
+### Escapando caracteres
 
 Quero digitar * Este texto entre asteriscos *, mas eu não quero que ele seja 
 em itálico, então eu faço o seguinte: \*Este texto entre asteriscos \*.
 
-<!-- Tabelas --> 
-<!-- Tabelas estão disponíveis apenas no GitHub Flavored Markdown e são ligeiramente 
-complicadas, mas se você realmente quer: -->
+### Tabelas 
+Tabelas estão disponíveis apenas no GitHub Flavored Markdown e são ligeiramente 
+complicadas, mas se você realmente quer:
+```md
 
 | Col1         | Col2     | Col3          |
 | :----------- | :------: | ------------: |
 | esquerda-alin| Centrado | direita-alinh |
 | blah         | blah     | blah          |
+```
 
-<!-- Ou, para os mesmos resultados -->
+Ou, para os mesmos resultados 
 
+```md
 Col 1 | Col2 | Col3
 :-- | :-: | --:
 Ugh isso é tão feio | faça isto | parar
+```
 
-<!-- O fim! -->
+Fim!
 
-```
+---
 Para mais informações, confira o post oficial de John Gruber de sintaxe [aqui](http://daringfireball.net/projects/markdown/syntax)
 e de Adam Pritchard grande cheatsheet [aqui](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet).
diff --git a/pt-br/matlab-pt.html.markdown b/pt-br/matlab-pt.html.markdown
index 5ed6b7ba..fae17bca 100644
--- a/pt-br/matlab-pt.html.markdown
+++ b/pt-br/matlab-pt.html.markdown
@@ -356,7 +356,7 @@ disp(a) % Imprime o valor da variável a
 disp('Olá Mundo') % Imprime a string
 fprintf % Imprime na janela de comandos com mais controle
 
-% Estruturas Condicionais (os parênteses são opicionais, porém uma boa prática)
+% Estruturas Condicionais (os parênteses são opcionais, porém uma boa prática)
 if (a > 15)
 	disp('Maior que 15')
 elseif (a == 23)
diff --git a/pt-br/pascal-pt.html.markdown b/pt-br/pascal-pt.html.markdown
index 3a37271a..72302695 100644
--- a/pt-br/pascal-pt.html.markdown
+++ b/pt-br/pascal-pt.html.markdown
@@ -4,6 +4,7 @@ filename: learnpascal-pt.pas
 contributors:
     - ["Ganesha Danu", "https://github.com/blinfoldking"]
     - ["Keith Miyake", "https//github.com/kaymmm"]
+    - ["Raul Almeida", "https://github.com/almeidaraul"]
 translators:
     - ["Raul Almeida", "https://github.com/almeidaraul"]
 lang: pt-br
@@ -157,7 +158,7 @@ BEGIN
     r := int; // um real pode receber um valor inteiro (mas não o contrário)
 
     c := str[1]; //acessando elementos de um vetor: vetor[índice do elemento]
-    str := 'hello' + 'world'; //concatenção de strings
+    str := 'hello' + 'world'; //concatenação de strings
 
     my_str[0] := 'a'; { só se pode atribuir valores a vetores elemento 
 						por elemento (não o vetor inteiro de uma vez) }
diff --git a/pt-br/perl-pt.html.markdown b/pt-br/perl-pt.html.markdown
index 217861f9..55a10626 100644
--- a/pt-br/perl-pt.html.markdown
+++ b/pt-br/perl-pt.html.markdown
@@ -10,9 +10,9 @@ translators:
 lang: pt-br
 ---
 
-Perl 5 é, uma linguagem de programação altamente capaz, rica em recursos, com mais de 25 anos de desenvolvimento.
+Perl é, uma linguagem de programação altamente capaz, rica em recursos, com mais de 25 anos de desenvolvimento.
 
-Perl 5 roda em mais de 100 plataformas, de portáteis a mainframes e é adequada tanto para prototipagem rápida, quanto em projetos de desenvolvimento em grande escala.
+Perl roda em mais de 100 plataformas, de portáteis a mainframes e é adequada tanto para prototipagem rápida, quanto em projetos de desenvolvimento em grande escala.
 
 ```perl
 # Comentários de uma linha começam com um sinal de número.
diff --git a/pt-br/php-pt.html.markdown b/pt-br/php-pt.html.markdown
index 8a1c956e..e55f1100 100644
--- a/pt-br/php-pt.html.markdown
+++ b/pt-br/php-pt.html.markdown
@@ -20,7 +20,7 @@ Este documento descreve PHP 5+.
 
 // Duas barras iniciam o comentário de uma linha.
 
-# O hash (aka pound symbol) também inicia, mas // é mais comum.
+# O hash (conhecido como "pound symbol") também inicia, mas // é mais comum.
 
 /*
      O texto envolto por barra-asterisco e asterisco-barra
diff --git a/pt-br/python-pt.html.markdown b/pt-br/python-pt.html.markdown
index 82b70117..3f9c54c1 100644
--- a/pt-br/python-pt.html.markdown
+++ b/pt-br/python-pt.html.markdown
@@ -1,29 +1,36 @@
 ---
-language: python
+language: Python
 contributors:
-    - ["Louie Dinh", "http://ldinh.ca"]
+    - ["Louie Dinh", "http://pythonpracticeprojects.com"]
+    - ["Steven Basart", "http://github.com/xksteven"]
+    - ["Andre Polykanine", "https://github.com/Oire"]
+    - ["Zachary Ferguson", "http://github.com/zfergus2"]
 translators:
-    - ["Vilson Vieira", "http://automata.cc"]
+    - ["Paulo Henrique Rodrigues Pinheiro", "http://www.sysincloud.it"]
+    - ["Monique Baptista", "https://github.com/bfmonique"]
 lang: pt-br
 filename: learnpython-pt.py
 ---
 
-Python foi criado por Guido Van Rossum no começo dos anos 90. Atualmente é uma
-das linguagens de programação mais populares. Eu me apaixonei por Python, por
-sua clareza de sintaxe. É basicamente pseudocódigo executável.
+Python foi criada por Guido Van Rossum nos anos 1990. Ela é atualmente uma
+das linguagens mais populares existentes. Eu me apaixonei por
+Python por sua clareza sintática. É praticamente pseudocódigo executável.
 
-Comentários serão muito apreciados! Você pode me contactar em
-[@louiedinh](http://twitter.com/louiedinh) ou louiedinh [arroba]
-[serviço de email do google]
+Opniões são muito bem vindas. Você pode encontrar-me em
+[@louiedinh](http://twitter.com/louiedinh) ou louiedinh [em]
+[serviço de e-mail do google].
 
-Nota: Este artigo usa Python 2.7 especificamente, mas deveria ser aplicável a
-qualquer Python 2.x. Logo haverá uma versão abordando Python 3!
+Observação: Este artigo trata de Python 3 especificamente. Verifique
+[aqui](http://learnxinyminutes.com/docs/pt-br/python-pt/) se você pretende
+aprender o velho Python 2.7.
 
 ```python
-# Comentários de uma linha começam com cerquilha (ou sustenido)
+
+# Comentários em uma única linha começam com uma cerquilha (também conhecido por sustenido).
+
 """ Strings de várias linhas podem ser escritas
     usando três ", e são comumente usadas
-    como comentários
+    como comentários.
 """
 
 ####################################################
@@ -31,287 +38,385 @@ qualquer Python 2.x. Logo haverá uma versão abordando Python 3!
 ####################################################
 
 # Você usa números normalmente
-3 #=> 3
-
-# Operadores matemáticos são aqueles que você já está acostumado
-1 + 1 #=> 2
-8 - 1 #=> 7
-10 * 2 #=> 20
-35 / 5 #=> 7
-
-# A divisão é um pouco estranha. A divisão de números inteiros arredonda
-# para baixo o resultado, automaticamente
-5 / 2 #=> 2
+3  # => 3
 
-# Para concertar a divisão, precisamos aprender sobre números de ponto
-# flutuante (conhecidos como 'float').
-2.0     # Isso é um 'float'
-11.0 / 4.0 #=> 2.75 ahhh... muito melhor
+# Matemática é como você espera que seja
+1 + 1   # => 2
+8 - 1   # => 7
+10 * 2  # => 20
 
-# Forçamos a precedência de operadores usando parênteses
-(1 + 3) * 2 #=> 8
+# Números são inteiros por padrão, exceto na divisão, que retorna número
+# de ponto flutuante (float).
+35 / 5  # => 7.0
 
-# Valores booleanos (ou 'boolean') são também tipos primitivos
-True
-False
+# O resultado da divisão inteira arredonda para baixo tanto para números
+# positivos como para negativos.
+5 // 3       # => 1
+5.0 // 3.0   # => 1.0 # funciona em float também
+-5 // 3      # => -2
+-5.0 // 3.0  # => -2.0
 
-# Negamos usando 'not'
-not True #=> False
-not False #=> True
+# Quando você usa um float, o resultado é float.
+3 * 2.0  # => 6.0
 
-# Testamos igualdade usando '=='
-1 == 1 #=> True
-2 == 1 #=> False
+# operador módulo
+7 % 3  # => 1
 
-# E desigualdade com '!='
-1 != 1 #=> False
-2 != 1 #=> True
-
-# Mais comparações
-1 < 10 #=> True
-1 > 10 #=> False
-2 <= 2 #=> True
-2 >= 2 #=> True
+# Exponenciação (x**y, x elevado à potência y)
+2**4  # => 16
 
-# As comparações podem ser encadeadas!
-1 < 2 < 3 #=> True
-2 < 3 < 2 #=> False
+# Determine a precedência usando parênteses
+(1 + 3) * 2  # => 8
 
-# Strings são criadas com " ou '
-"Isso é uma string."
-'Isso também é uma string.'
+# Valores lógicos são primitivos (Atenção à primeira letra maiúscula)
+True
+False
 
-# Strings podem ser somadas (ou melhor, concatenadas)!
-"Olá " + "mundo!" #=> "Olá mundo!"
+# negação lógica com not
+not True   # => False
+not False  # => True
 
-# Uma string pode ser tratada como uma lista de caracteres
-"Esta é uma string"[0] #=> 'E'
+# Operadores lógicos
+# Observe que "and" e "or" são sensíveis a maiúsculas e minúsculas
+True and False  # => False
+False or True   # => True
 
-# O caractere % pode ser usado para formatar strings, desta forma:
-"%s podem ser %s" % ("strings", "interpoladas")
+# Observe a utilização de operadores lógicos com números inteiros
+0 and 2     # => 0
+-5 or 0     # => -5
+0 == False  # => True
+2 == True   # => False
+1 == True   # => True
 
-# Um jeito novo de formatar strings é usando o método 'format'.
-# Esse método é o jeito mais usado
-"{0} podem ser {1}".format("strings", "formatadas")
-# Você pode usar palavras-chave (ou 'keywords') se você não quiser contar.
-"{nome} quer comer {comida}".format(nome="João", comida="lasanha")
+# Igualdade é ==
+1 == 1  # => True
+2 == 1  # => False
 
-# 'None' é um objeto
-None #=> None
+# Diferença é !=
+1 != 1  # => False
+2 != 1  # => True
 
-# Não use o operador de igualdade `==` para comparar objetos com 'None'
-# Ao invés disso, use `is`
-"etc" is None #=> False
-None is None  #=> True
+# Mais comparações
+1 < 10  # => True
+1 > 10  # => False
+2 <= 2  # => True
+2 >= 2  # => True
+
+# Comparações podem ser agrupadas
+1 < 2 < 3  # => True
+2 < 3 < 2  # => False
+
+# 'is' verifica se duas variáveis representam o mesmo endereço
+# na memória; '==' verifica se duas variáveis têm o mesmo valor
+a = [1, 2, 3, 4]  # Referência a uma nova lista, [1, 2, 3, 4]
+b = a             # b referencia o que está referenciado por a
+b is a            # => True, a e b referenciam o mesmo objeto
+b == a            # => True, objetos a e b tem o mesmo conteúdo
+b = [1, 2, 3, 4]  # Referência a uma nova lista, [1, 2, 3, 4]
+b is a            # => False, a e b não referenciam o mesmo objeto
+b == a            # => True, objetos a e b tem o mesmo conteúdo
 
-# O operador 'is' teste a identidade de um objeto. Isso não é
-# muito útil quando estamos lidando com valores primitivos, mas é
-# muito útil quando lidamos com objetos.
+# Strings são criadas com " ou '
+"Isto é uma string."
+'Isto também é uma string.'
 
-# None, 0, e strings/listas vazias são todas interpretadas como 'False'.
-# Todos os outros valores são 'True'
-0 == False  #=> True
-"" == False #=> True
+# Strings também podem ser somadas! Mas tente não fazer isso.
+"Olá " + "mundo!"  # => "Olá mundo!"
+# Strings podem ser somadas sem usar o '+'
+"Olá " "mundo!"    # => "Olá mundo!"
 
+# Uma string pode ser manipulada como se fosse uma lista de caracteres
+"Isso é uma string"[0]  # => 'I'
 
-####################################################
-## 2. Variáveis e Coleções
-####################################################
+# .format pode ser usado para formatar strings, dessa forma:
+"{} podem ser {}".format("Strings", "interpoladas")  # => "Strings podem ser interpoladas"
 
-# Imprimir na tela é muito fácil
-print "Eu sou o Python. Prazer em te conhecer!"
+# Você pode repetir os argumentos para digitar menos.
+"Seja ágil {0}, seja rápido {0}, salte sobre o {1} {0}".format("Jack", "castiçal")
+# => "Seja ágil Jack, seja rápido Jack, salte sobre o castiçal Jack."
 
+# Você pode usar palavras-chave se quiser contar.
+"{nome} quer comer {comida}".format(nome="Beto", comida="lasanha")  # => "Beto quer comer lasanha"
 
-# Nós não precisamos declarar variáveis antes de usá-las, basta usar!
-alguma_variavel = 5    # A convenção é usar caixa_baixa_com_sobrescritos
-alguma_variavel #=> 5
+# Se você precisa executar seu código Python3 com um interpretador Python 2.5 ou acima, você pode usar a velha forma para formatação de texto:
+"%s podem ser %s da forma %s" % ("Strings", "interpoladas", "antiga")  # => "Strings podem ser interpoladas da forma antiga"
 
-# Acessar uma variável que não teve nenhum valor atribuído anteriormente é
-# uma exceção.
-# Veja a seção 'Controle' para aprender mais sobre tratamento de exceção.
-outra_variavel  # Gera uma exceção de erro de nome
 
-# 'if' pode ser usado como uma expressão
-"uepa!" if 3 > 2 else 2 #=> "uepa!"
+# None é um objeto
+None  # => None
 
-# Listas armazenam sequências de elementos
-lista = []
-# Você pode inicializar uma lista com valores
-outra_lista = [4, 5, 6]
+# Não use o operador de igualdade "==" para comparar objetos com None
+# Use "is" para isso. Ele checará pela identidade dos objetos.
+"etc" is None  # => False
+None is None   # => True
 
-# Adicione elementos no final da lista usando 'append'
-lista.append(1)    # lista é agora [1]
-lista.append(2)    # lista é agora [1, 2]
-lista.append(4)    # lista é agora [1, 2, 4]
-lista.append(3)    # lista é agora [1, 2, 4, 3]
-# Remova elementos do fim da lista usando 'pop'
-lista.pop()        #=> 3 e lista é agora [1, 2, 4]
-# Vamos adicionar o elemento novamente
-lista.append(3)    # lista agora é [1, 2, 4, 3] novamente.
+# None, 0, e strings/listas/dicionários vazios todos retornam False.
+# Qualquer outra coisa retorna True
+bool(0)   # => False
+bool("")  # => False
+bool([])  # => False
+bool({})  # => False
 
-# Acesse elementos de uma lista através de seu índices
-lista[0] #=> 1
-# Acesse o último elemento com índice negativo!
-lista[-1] #=> 3
 
-# Tentar acessar um elemento fora dos limites da lista gera uma exceção
-# do tipo 'IndexError'
-lista[4] # Gera uma exceção 'IndexError'
-
-# Você pode acessar vários elementos ao mesmo tempo usando a sintaxe de
-# limites
-# (Para quem gosta de matemática, isso é um limite fechado/aberto)
-lista[1:3] #=> [2, 4]
-# Você pode omitir o fim se quiser os elementos até o final da lista
-lista[2:] #=> [4, 3]
-# O mesmo para o início
-lista[:3] #=> [1, 2, 4]
+####################################################
+## 2. Variáveis e coleções
+####################################################
 
-# Remova um elemento qualquer de uma lista usando 'del'
-del lista[2] # lista agora é [1, 2, 3]
+# Python tem uma função print
+print("Eu sou o Python. Prazer em conhecer!")  # => Eu sou o Python. Prazer em conhecer!
+
+# Por padrão a função print também imprime o caractere de nova linha ao final.
+# Use o argumento opcional end para mudar o caractere final.
+print("Olá, Mundo", end="!")  # => Olá, Mundo!
+
+# Forma simples para capturar dados de entrada via console
+input_string_var = input("Digite alguma coisa: ") # Retorna o que foi digitado em uma string
+# Observação: Em versões antigas do Python, o método input() era chamado raw_input()
+
+# Não é necessário declarar variáveis antes de iniciá-las
+# É uma convenção usar letras_minúsculas_com_sublinhados
+alguma_variavel = 5
+alguma_variavel  # => 5
+
+# Acessar uma variável que não tenha sido inicializada gera uma exceção.
+# Veja Controle de Fluxo para aprender mais sobre tratamento de exceções.
+alguma_variavel_nao_inicializada  # Gera a exceção NameError
+
+# Listas armazenam sequências
+li = []
+# Você pode iniciar uma lista com valores
+outra_li = [4, 5, 6]
+
+# Adicione conteúdo ao fim da lista com append
+li.append(1)    # li agora é [1]
+li.append(2)    # li agora é [1, 2]
+li.append(4)    # li agora é [1, 2, 4]
+li.append(3)    # li agora é [1, 2, 4, 3]
+# Remova do final da lista com pop
+li.pop()        # => 3 e agora li é [1, 2, 4]
+# Vamos colocá-lo lá novamente!
+li.append(3)    # li agora é [1, 2, 4, 3] novamente.
+
+# Acesse uma lista da mesma forma que você faz com um array
+li[0]   # => 1
+# Acessando o último elemento
+li[-1]  # => 3
+
+# Acessar além dos limites gera um IndexError
+li[4]  # Gera o IndexError
+
+# Você pode acessar vários elementos com a sintaxe de limites
+# Inclusivo para o primeiro termo, exclusivo para o segundo
+li[1:3]   # => [2, 4]
+# Omitindo o final
+li[2:]    # => [4, 3]
+# Omitindo o início
+li[:3]    # => [1, 2, 4]
+# Selecione cada segunda entrada
+li[::2]   # => [1, 4]
+# Tenha uma cópia em ordem invertida da lista
+li[::-1]  # => [3, 4, 2, 1]
+# Use qualquer combinação dessas para indicar limites complexos
+# li[inicio:fim:passo]
+
+# Faça uma cópia profunda de um nível usando limites
+li2 = li[:]  # => li2 = [1, 2, 4, 3] mas (li2 is li) resultará em False.
+
+# Apague elementos específicos da lista com "del"
+del li[2]  # li agora é [1, 2, 3]
+
+# Você pode somar listas
+# Observação: valores em li e other_li não são modificados.
+li + other_li  # => [1, 2, 3, 4, 5, 6]
+
+# Concatene listas com "extend()"
+li.extend(other_li)  # Agora li é [1, 2, 3, 4, 5, 6]
+
+# Verifique se algo existe na lista com "in"
+1 in li  # => True
+
+# Examine  tamanho com "len()"
+len(li)  # => 6
+
+
+# Tuplas são como l istas, mas imutáveis.
+tup = (1, 2, 3)
+tup[0]      # => 1
+tup[0] = 3  # Gera um TypeError
+
+# Observe que uma tupla de tamanho um precisa ter uma vírgula depois do
+# último elemento mas tuplas de outros tamanhos, mesmo vazias, não precisa,.
+type((1))   # => <class 'int'>
+type((1,))  # => <class 'tuple'>
+type(())    # => <class 'tuple'>
+
+# Você pode realizar com tuplas a maior parte das operações que faz com listas
+len(tup)         # => 3
+tup + (4, 5, 6)  # => (1, 2, 3, 4, 5, 6)
+tup[:2]          # => (1, 2)
+2 in tup         # => True
+
+# Você pode desmembrar tuplas (ou listas) em variáveis.
+a, b, c = (1, 2, 3)  # a é 1, b é 2 e c é 3
+# Por padrão, tuplas são criadas se você não coloca parêntesis.
+d, e, f = 4, 5, 6
+# Veja como é fácil permutar dois valores
+e, d = d, e  # d é 5, e é 4
 
-# Você pode somar listas (obs: as listas originais não são modificadas)
-lista + outra_lista #=> [1, 2, 3, 4, 5, 6]
+# Dicionários armazenam mapeamentos
+empty_dict = {}
+# Aqui está um dicionário preenchido na definição da referência
+filled_dict = {"um": 1, "dois": 2, "três": 3}
 
-# Você também pode concatenar usando o método 'extend' (lista será modificada!)
-lista.extend(outra_lista) # Agora lista é [1, 2, 3, 4, 5, 6]
+# Observe que chaves para dicionários devem ser tipos imutáveis. Isto é para
+# assegurar que a chave pode ser convertida para uma valor hash constante para
+# buscas rápidas.
+# Tipos imutáveis incluem inteiros, flotas, strings e tuplas.
+invalid_dict = {[1,2,3]: "123"}  # => Gera um TypeError: unhashable type: 'list'
+valid_dict = {(1,2,3):[1,2,3]}   # Já os valores, podem ser de qualquer tipo.
 
-# Para checar se um elemento pertence a uma lista, use 'in'
-1 in lista #=> True
+# Acesse valores com []
+filled_dict["um"]  # => 1
 
-# Saiba quantos elementos uma lista possui com 'len'
-len(lista) #=> 6
+# Acesse todas as chaves como um iterável com "keys()". É necessário encapsular
+# a chamada com um list() para transformá-las em uma lista. Falaremos sobre isso
+# mais adiante. Observe que a ordem de uma chave de dicionário não é garantida.
+# Por isso, os resultados aqui apresentados podem não ser exatamente como os
+# aqui apresentados.
+list(filled_dict.keys())  # => ["três", "dois", "um"]
 
 
-# Tuplas são iguais a listas, mas são imutáveis
-tup = (1, 2, 3)
-tup[0] #=> 1
-tup[0] = 3  # Isso gera uma exceção do tipo TypeError
-
-# Você pode fazer nas tuplas todas aquelas coisas fez com a lista
-len(tup) #=> 3
-tup + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6)
-tup[:2] #=> (1, 2)
-2 in tup #=> True
-
-# Você pode 'desempacotar' tuplas (ou listas) em variáveis, associando cada
-# elemento da tupla/lista a uma variável correspondente
-a, b, c = (1, 2, 3)     # a agora é 1, b agora é 2, c agora é 3
-# Tuplas são criadas por padrão, mesmo se você não usar parênteses
-d, e, f = 4, 5, 6
-# Sabendo disso, veja só como é fácil trocar os valores de duas variáveis!
-e, d = d, e     # d agora é 5, e agora é 4
+# Acesse todos os valores de um iterável com "values()". Novamente, é
+# necessário encapsular ele com list() para não termos um iterável, e sim os
+# valores. Observe que, como foi dito acima, a ordem dos elementos não é
+# garantida.
+list(filled_dict.values())  # => [3, 2, 1]
 
 
-# Dicionários armazenam 'mapeamentos' (do tipo chave-valor)
-dicionario_vazio = {}
-# Aqui criamos um dicionário já contendo valores
-dicionario = {"um": 1, "dois": 2, "três": 3}
+# Verifique a existência de chaves em um dicionário com "in"
+"um" in filled_dict  # => True
+1 in filled_dict      # => False
 
-# Acesse valores usando []
-dicionario["um"] #=> 1
+# Acessar uma chave inexistente gera um KeyError
+filled_dict["quatro"]  # KeyError
 
-# Retorna uma lista com todas as chaves do dicionário
-dicionario.keys() #=> ["três", "dois", "um"]
-# Nota: A ordem das chaves não é garantida.
-# O resultado no seu interpretador não necessariamente será igual a esse.
+# Use o método "get()" para evitar um KeyError
+filled_dict.get("um")      # => 1
+filled_dict.get("quatro")     # => None
+# O método get permite um parâmetro padrão para quando não existir a chave
+filled_dict.get("um", 4)   # => 1
+filled_dict.get("quatro", 4)  # => 4
 
-# Retorna uma lista com todos os valores do dicionário
-dicionario.values() #=> [3, 2, 1]
-# Nota: A mesma nota acima sobre a ordenação é válida aqui.
+# "setdefault()" insere em dicionário apenas se a dada chave não existir
+filled_dict.setdefault("cinco", 5)  # filled_dict["cinco"] tem valor 5
+filled_dict.setdefault("cinco", 6)  # filled_dict["cinco"] continua 5
 
-# Veja se uma chave qualquer está em um dicionário usando 'in'
-"um" in dicionario #=> True
-1 in dicionario #=> False
+# Inserindo em um dicionário
+filled_dict.update({"quatro":4})  # => {"um": 1, "dois": 2, "três": 3, "quatro": 4}
+#filled_dict["quatro"] = 4        #outra forma de inserir em um dicionário
 
-# Tentar acessar uma chave que não existe gera uma exceção do tipo 'KeyError'
-dicionario["quatro"] # Gera uma exceção KeyError
+# Remova chaves de um dicionário com del
+del filled_dict["um"]  # Remove a chave "um" de filled_dict
 
-# Você pode usar o método 'get' para evitar gerar a exceção 'KeyError'.
-# Ao invés de gerar essa exceção, irá retornar 'None' se a chave não existir.
-dicionario.get("um") #=> 1
-dicionario.get("quatro") #=> None
-# O método 'get' suporta um argumento que diz qual valor deverá ser
-# retornado se a chave não existir (ao invés de 'None').
-dicionario.get("um", 4) #=> 1
-dicionario.get("quatro", 4) #=> 4
 
-# O método 'setdefault' é um jeito seguro de adicionar um novo par
-# chave-valor a um dicionário, associando um valor padrão imutável à uma chave
-dicionario.setdefault("cinco", 5) # dicionario["cinco"] é definido como 5
-dicionario.setdefault("cinco", 6) # dicionario["cinco"] ainda é igual a 5
+# Armazenamento em sets... bem, são conjuntos
+empty_set = set()
+# Inicializa um set com alguns valores. Sim, ele parece um dicionário. Desculpe.
+some_set = {1, 1, 2, 2, 3, 4}  # some_set agora é {1, 2, 3, 4}
 
+# Da mesma forma que chaves em um dicionário, elementos de um set devem ser
+# imutáveis.
+invalid_set = {[1], 1}  # => Gera um TypeError: unhashable type: 'list'
+valid_set = {(1,), 1}
 
-# Conjuntos (ou sets) armazenam ... bem, conjuntos
-# Nota: lembre-se que conjuntos não admitem elementos repetidos!
-conjunto_vazio = set()
-# Podemos inicializar um conjunto com valores
-conjunto = set([1, 2, 2, 3, 4]) # conjunto é set([1, 2, 3, 4]), sem repetição!
+# Pode definir novas variáveis para um conjunto
+filled_set = some_set
 
-# Desde o Python 2.7, {} pode ser usado para declarar um conjunto
-conjunto = {1, 2, 2, 3, 4} # => {1 2 3 4}
+# Inclua mais um item no set
+filled_set.add(5)  # filled_set agora é {1, 2, 3, 4, 5}
 
-# Adicione mais ítens a um conjunto com 'add'
-conjunto.add(5) # conjunto agora é {1, 2, 3, 4, 5}
+# Faça interseção de conjuntos com &
+other_set = {3, 4, 5, 6}
+filled_set & other_set  # => {3, 4, 5}
 
-# Calcule a intersecção de dois conjuntos com &
-outro_conj = {3, 4, 5, 6}
-conjunto & outro_conj #=> {3, 4, 5}
+# Faça união de conjuntos com |
+filled_set | other_set  # => {1, 2, 3, 4, 5, 6}
 
-# Calcule a união de dois conjuntos com |
-conjunto | outro_conj #=> {1, 2, 3, 4, 5, 6}
+# Faça a diferença entre conjuntos com -
+{1, 2, 3, 4} - {2, 3, 5}  # => {1, 4}
 
-# E a diferença entre dois conjuntos com -
-{1,2,3,4} - {2,3,5} #=> {1, 4}
+# Verifique a existência em um conjunto com in
+2 in filled_set   # => True
+10 in filled_set  # => False
 
-# Veja se um elemento existe em um conjunto usando 'in'
-2 in conjunto #=> True
-10 in conjunto #=> False
 
 
 ####################################################
-## 3. Controle
+## 3. Controle de fluxo e iteráveis
 ####################################################
 
-# Para começar, vamos apenas criar uma variável
-alguma_var = 5
+# Iniciemos um variável
+some_var = 5
 
-# Aqui está uma expressão 'if'. Veja como a identação é importante em Python!
-# Esses comandos irão imprimir "alguma_var é menor que 10"
-if alguma_var > 10:
-    print "some_var é maior que 10."
-elif some_var < 10:    # Esse 'elif' é opcional
-    print "some_var é menor que 10."
-else:           # Esse 'else' também é opcional
-    print "some_var é igual a 10."
+# Aqui está uma expressão if. Indentação é significante em python!
+# imprime "somevar é menor que10"
+if some_var > 10:
+    print("some_var é absolutamente maior que 10.")
+elif some_var < 10:    # Esta cláusula elif é opcional.
+    print("some_var é menor que 10.")
+else:                  # Isto também é opcional.
+    print("some_var é, de fato, 10.")
 
 
 """
-Laços (ou loops) 'for' iteram em listas.
-Irá imprimir:
+Laços for iteram sobre listas
+imprime:
     cachorro é um mamífero
     gato é um mamífero
     rato é um mamífero
 """
 for animal in ["cachorro", "gato", "rato"]:
-    # Você pode usar % para interpolar strings formatadas
-    print "%s é um mamífero" % animal
-    
+    # Você pode usar format() para interpolar strings formatadas
+    print("{} é um mamífero".format(animal))
+
 """
-A função `range(um número)` retorna uma lista de números
-do zero até o número dado.
-Irá imprimir:
+"range(número)" retorna um iterável de números
+de zero até o número escolhido
+imprime:
     0
     1
     2
     3
 """
 for i in range(4):
-    print i
+    print(i)
+
+"""
+"range(menor, maior)" gera um iterável de números
+começando pelo menor até o maior
+imprime:
+    4
+    5
+    6
+    7
+"""
+for i in range(4, 8):
+    print(i)
 
 """
-Laços 'while' executam enquanto uma condição dada for verdadeira.
-Irá imprimir:
+"range(menor, maior, passo)" retorna um iterável de números
+começando pelo menor número até o maior númeno, pulando de
+passo em passo. Se o passo não for indicado, o valor padrão é um.
+imprime:
+    4
+    6
+"""
+for i in range(4, 8, 2):
+    print(i)
+"""
+
+Laços while executam até que a condição não seja mais válida.
+imprime:
     0
     1
     2
@@ -319,143 +424,221 @@ Irá imprimir:
 """
 x = 0
 while x < 4:
-    print x
-    x += 1  # Isso é um atalho para a expressão x = x + 1
-
-# Tratamos excessões usando o bloco try/except
-# Funciona em Python 2.6 e versões superiores:
+    print(x)
+    x += 1  # Maneira mais curta para for x = x + 1
 
+# Lide com exceções com um bloco try/except
 try:
-    # Use 'raise' para gerar um erro
-    raise IndexError("Isso é um erro de índice")
+    # Use "raise" para gerar um erro
+    raise IndexError("Isto é um erro de índice")
 except IndexError as e:
-    pass    # Pass é um operador que não faz nada, deixa passar.
-            # Usualmente você iria tratar a exceção aqui...
+    pass                 # Pass é um não-operador. Normalmente você usa algum código de recuperação aqui.
+except (TypeError, NameError):
+    pass                 # Varias exceções podem ser gerenciadas, se necessário.
+else:                    # Cláusula opcional para o bloco try/except. Deve estar após todos os blocos de exceção.
+    print("Tudo certo!")   # Executa apenas se o código em try não gera exceção
+finally:                 #  Sempre é executado
+    print("Nós podemos fazer o código de limpeza aqui.")
+
+# Ao invés de try/finally para limpeza você pode usar a cláusula with
+with open("myfile.txt") as f:
+    for line in f:
+        print(line)
+
+# Python provê uma abstração fundamental chamada Iterável.
+# Um iterável é um objeto que pode ser tratado como uma sequência.
+# O objeto retornou a função range, um iterável.
+
+filled_dict = {"um": 1, "dois": 2, "três": 3}
+our_iterable = filled_dict.keys()
+print(our_iterable)  # => range(1,10). Esse é um objeto que implementa nossa interface iterável.
+
+# Nós podemos percorrê-la.
+for i in our_iterable:
+    print(i)  # Imprime um, dois, três
+
+# Mas não podemos acessar os elementos pelo seu índice.
+our_iterable[1]  # Gera um TypeError
+
+# Um iterável é um objeto que sabe como criar um iterador.
+our_iterator = iter(our_iterable)
+
+# Nosso iterador é um objeto que pode lembrar o estado enquanto nós o percorremos.
+# Nós acessamos o próximo objeto com "next()".
+next(our_iterator)  # => "um"
+
+# Ele mantém o estado enquanto nós o percorremos.
+next(our_iterator)  # => "dois"
+next(our_iterator)  # => "três"
+
+# Após o iterador retornar todos os seus dados, ele gera a exceção StopIterator
+next(our_iterator)  # Gera StopIteration
+
+# Você pode capturar todos os elementos de um iterador aplicando list() nele.
+list(filled_dict.keys())  # => Retorna ["um", "dois", "três"]
 
 
 ####################################################
 ## 4. Funções
 ####################################################
 
-# Use 'def' para definir novas funções
-def soma(x, y):
-    print "x é %s e y é %s" % (x, y)
-    return x + y    # Retorne valores usando 'return'
+# Use "def" para criar novas funções.
+def add(x, y):
+    print("x é {} e y é {}".format(x, y))
+    return x + y  # Retorne valores com a cláusula return
 
 # Chamando funções com parâmetros
-soma(5, 6) #=> imprime "x é 5 e y é 6" e retorna o valor 11
+add(5, 6)  # => imprime "x é 5 e y é 6" e retorna 11
 
-# Um outro jeito de chamar funções é especificando explicitamente os valores
-# de cada parâmetro com chaves
-soma(y=6, x=5)   # Argumentos com chaves podem vir em qualquer ordem.
+# Outro meio de chamar funções é com argumentos nomeados
+add(y=6, x=5)  # Argumentos nomeados podem aparecer em qualquer ordem.
 
-# Você pode definir funções que recebem um número qualquer de argumentos
-# (respeitando a sua ordem)
+# Você pode definir funções que pegam um número variável de argumentos
+# posicionais
 def varargs(*args):
     return args
 
-varargs(1, 2, 3) #=> (1,2,3)
+varargs(1, 2, 3)  # => (1, 2, 3)
 
+# Você pode definir funções que pegam um número variável de argumentos nomeados
+# também
+def keyword_args(**kwargs):
+    return kwargs
 
-# Você também pode definir funções que recebem um número qualquer de argumentos
-# com chaves
-def args_com_chaves(**ch_args):
-    return ch_args
+# Vamos chamá-lo para ver o que acontece
+keyword_args(peh="grande", lago="ness")  # => {"peh": "grande", "lago": "ness"}
 
-# Vamos chamar essa função para ver o que acontece
-args_com_chaves(pe="grande", lago="Ness") #=> {"pe": "grande", "lago": "Ness"}
 
-# Você pode fazer as duas coisas ao mesmo tempo, se desejar
-def todos_args(*args, **ch_wargs):
-    print args
-    print ch_args
+# Você pode fazer ambos simultaneamente, se você quiser
+def all_the_args(*args, **kwargs):
+    print(args)
+    print(kwargs)
 """
-todos_args(1, 2, a=3, b=4) imprime:
+all_the_args(1, 2, a=3, b=4) imprime:
     (1, 2)
     {"a": 3, "b": 4}
 """
 
-# Quando você chamar funções, pode fazer o oposto do que fizemos até agora!
-# Podemos usar * para expandir tuplas de argumentos e ** para expandir
-# dicionários de argumentos com chave.
+# Quando chamar funções, você pode fazer o oposto de args/kwargs!
+# Use * para expandir tuplas e use ** para expandir dicionários!
 args = (1, 2, 3, 4)
-ch_args = {"a": 3, "b": 4}
-todos_args(*args)  # equivalente a todos_args(1, 2, 3, 4)
-todos_args(**ch_args) # equivalente a todos_args(a=3, b=4)
-todos_args(*args, **ch_args) # equivalente a todos_args(1, 2, 3, 4, a=3, b=4)
-
-# Em Python, funções são elementos de primeira ordem (são como objetos, 
-# strings ou números)
-def cria_somador(x):
-    def somador(y):
+kwargs = {"a": 3, "b": 4}
+all_the_args(*args)            # equivalente a foo(1, 2, 3, 4)
+all_the_args(**kwargs)         # equivalente a foo(a=3, b=4)
+all_the_args(*args, **kwargs)  # equivalente a foo(1, 2, 3, 4, a=3, b=4)
+
+# Retornando múltiplos valores (com atribuição de tuplas)
+def swap(x, y):
+    return y, x  # Retorna múltiplos valores como uma tupla sem os parêntesis.
+                 # (Observação: os parêntesis foram excluídos mas podem estar
+                 # presentes)
+
+x = 1
+y = 2
+x, y = swap(x, y)     # => x = 2, y = 1
+# (x, y) = swap(x,y)  # Novamente, os parêntesis foram excluídos mas podem estar presentes.
+
+# Escopo de função
+x = 5
+
+def setX(num):
+    # A variável local x não é a mesma variável global x
+    x = num    # => 43
+    print (x)  # => 43
+
+def setGlobalX(num):
+    global x
+    print (x)  # => 5
+    x = num    # variável global x agora é 6
+    print (x)  # => 6
+
+setX(43)
+setGlobalX(6)
+
+
+# Python tem funções de primeira classe
+def create_adder(x):
+    def adder(y):
         return x + y
-    return somador
+    return adder
+
+add_10 = create_adder(10)
+add_10(3)   # => 13
 
-soma_10 = cria_somador(10)
-soma_10(3) #=> 13
+# Também existem as funções anônimas
+(lambda x: x > 2)(3)                  # => True
+(lambda x, y: x ** 2 + y ** 2)(2, 1)  # => 5
 
-# Desta forma, existem também funções anônimas
-(lambda x: x > 2)(3) #=> True
+# TODO - Fix for iterables
+# Existem funções internas de alta ordem
+map(add_10, [1, 2, 3])          # => [11, 12, 13]
+map(max, [1, 2, 3], [4, 2, 1])  # => [4, 2, 3]
 
-# E existem funções de alta ordem por padrão
-map(soma_10, [1,2,3]) #=> [11, 12, 13]
-filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7]
-reduce(lambda x, y: x + y, [3, 4, 5, 6, 7]) #=> 25
+filter(lambda x: x > 5, [3, 4, 5, 6, 7])  # => [6, 7]
 
-# Nós podemos usar compreensão de listas para mapear e filtrar também
-[soma_10(i) for i in [1, 2, 3]]  #=> [11, 12, 13]
-[x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7]
+# Nós podemos usar compreensão de lista para interessantes mapas e filtros
+# Compreensão de lista armazena a saída como uma lista que pode ser uma lista
+# aninhada
+[add_10(i) for i in [1, 2, 3]]         # => [11, 12, 13]
+[x for x in [3, 4, 5, 6, 7] if x > 5]  # => [6, 7]
 
 ####################################################
 ## 5. Classes
 ####################################################
 
-# Para criar uma nova classe, devemos herdar de 'object'
-class Humano(object):
 
-    # Um atributo de classe. Ele é compartilhado por todas as instâncias dessa
-    # classe
-    especie = "H. sapiens"
-
-    # Definimos um inicializador básico
-    def __init__(self, nome):
-        # Atribui o valor de argumento dado a um atributo da instância
-        self.nome = nome
+# Nós usamos o operador "class" para ter uma classe
+class Human:
 
-    # Um método de instância. Todos os métodos levam 'self' como primeiro
+    # Um atributo de classe. Ele é compartilhado por todas as instâncias dessa
+    # classe.
+    species = "H. sapiens"
+
+    # Construtor básico, é chamado quando esta classe é instanciada.
+    # Note que dois sublinhados no início e no final de uma identificados
+    # significa objetos ou atributos que são usados pelo python mas vivem em
+    # um namespace controlado pelo usuário. Métodos (ou objetos ou atributos)
+    # como: __init__, __str__, __repr__, etc. são chamados métodos mágicos (ou
+    # algumas vezes chamados métodos dunder - "double underscore")
+    # Você não deve usar nomes assim por sua vontade.
+    def __init__(self, name):
+        @ Atribui o argumento ao atributo da  instância
+        self.name = name
+
+    # Um método de instância. Todos os métodos tem "self" como primeiro
     # argumento
-    def diga(self, msg):
-       return "%s: %s" % (self.nome, msg)
+    def say(self, msg):
+        return "{name}: {message}".format(name=self.name, message=msg)
 
     # Um método de classe é compartilhado por todas as instâncias
-    # Eles são chamados passando o nome da classe como primeiro argumento
+    # Eles são chamados com a classe requisitante como primeiro argumento
     @classmethod
-    def get_especie(cls):
-        return cls.especie
+    def get_species(cls):
+        return cls.species
 
     # Um método estático é chamado sem uma referência a classe ou instância
     @staticmethod
-    def ronca():
-        return "*arrrrrrr*"
+    def grunt():
+        return "*grunt*"
 
 
 # Instancie uma classe
-i = Humano(nome="Ivone")
-print i.diga("oi")     # imprime "Ivone: oi"
+i = Human(name="Ian")
+print(i.say("oi"))     # imprime "Ian: oi"
 
 j = Human("Joel")
-print j.say("olá")  #prints out "Joel: olá"
+print(j.say("olá"))  # imprime "Joel: olá"
 
-# Chame nosso método de classe
-i.get_especie() #=> "H. sapiens"
+# Chama nosso método de classe
+i.get_species()  # => "H. sapiens"
 
-# Modifique um atributo compartilhado
-Humano.especie = "H. neanderthalensis"
-i.get_especie() #=> "H. neanderthalensis"
-j.get_especie() #=> "H. neanderthalensis"
+# Altera um atributo compartilhado
+Human.species = "H. neanderthalensis"
+i.get_species()  # => "H. neanderthalensis"
+j.get_species()  # => "H. neanderthalensis"
 
-# Chame o método estático
-Humano.ronca() #=> "*arrrrrrr*"
+# Chama o método estático
+Human.grunt()    # => "*grunt*"
 
 
 ####################################################
@@ -464,46 +647,100 @@ Humano.ronca() #=> "*arrrrrrr*"
 
 # Você pode importar módulos
 import math
-print math.sqrt(16) #=> 4.0
+print(math.sqrt(16))  # => 4.0
 
-# Você pode importar funções específicas de um módulo
+# Você pode importar apenas funções específicas de um módulo
 from math import ceil, floor
-print ceil(3.7)  #=> 4.0
-print floor(3.7) #=> 3.0
+print(ceil(3.7))   # => 4.0
+print(floor(3.7))  # => 3.0
 
-# Você também pode importar todas as funções de um módulo
-# Atenção: isso não é recomendado!
+# Você pode importar todas as funções de um módulo para o namespace atual
+# Atenção: isso não é recomendado
 from math import *
 
-# Você pode usar apelidos para os módulos, encurtando seus nomes
+# Você pode encurtar o nome dos módulos
 import math as m
-math.sqrt(16) == m.sqrt(16) #=> True
+math.sqrt(16) == m.sqrt(16)  # => True
 
-# Módulos em Python são apenas arquivos Python. Você
-# pode escrever o seu próprio módulo e importá-lo. O nome do
-# módulo será o mesmo que o nome do arquivo.
+# Módulos python são apenas arquivos python comuns. Você
+# pode escrever os seus, e importá-los. O nome do
+# módulo é o mesmo nome do arquivo.
 
-# Você pode descobrir quais funções e atributos
-# estão definidos em um módulo qualquer.
+# Você pode procurar que atributos e funções definem um módulo.
 import math
 dir(math)
 
 
+####################################################
+## 7. Avançado
+####################################################
+
+# Geradores podem ajudar você a escrever código "preguiçoso"
+def double_numbers(iterable):
+    for i in iterable:
+        yield i + i
+
+# Um gerador cria valores conforme necessário.
+# Ao invés de gerar e retornar todos os valores de uma só vez ele cria um em
+# cada interação. Isto significa que valores maiores que 15 não serão
+# processados em double_numbers.
+# Nós usamos um sublinhado ao final do nome das variáveis quando queremos usar
+# um nome que normalmente colide com uma palavra reservada do python.
+range_ = range(1, 900000000)
+# Multiplica por 2 todos os números até encontrar um resultado >= 30
+for i in double_numbers(range_):
+    print(i)
+    if i >= 30:
+        break
+
+
+# Decoradores
+# Neste exemplo beg encapsula say
+# beg irá chamar say. Se say_please é verdade então ele irá mudar a mensagem
+# retornada
+from functools import wraps
+
+
+def beg(target_function):
+    @wraps(target_function)
+    def wrapper(*args, **kwargs):
+        msg, say_please = target_function(*args, **kwargs)
+        if say_please:
+            return "{} {}".format(msg, "Por favor! Eu sou pobre :(")
+        return msg
+
+    return wrapper
+
+
+@beg
+def say(say_please=False):
+    msg = "Você me paga uma cerveja?"
+    return msg, say_please
+
+
+print(say())                # Você me paga uma cerveja?
+print(say(say_please=True)) # Você me paga uma cerveja? Por favor! Eu sou pobre :(
 ```
 
 ## Pronto para mais?
 
-### Online e gratuito
+### Free Online
 
+* [Automate the Boring Stuff with Python](https://automatetheboringstuff.com)
 * [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
 * [Dive Into Python](http://www.diveintopython.net/)
-* [The Official Docs](http://docs.python.org/2.6/)
+* [Ideas for Python Projects](http://pythonpracticeprojects.com)
+* [The Official Docs](http://docs.python.org/3/)
 * [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
-* [Python Module of the Week](http://pymotw.com/2/)
+* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182)
+* [Python Course](http://www.python-course.eu/index.php)
+* [First Steps With Python](https://realpython.com/learn/python-first-steps/)
+* [A curated list of awesome Python frameworks, libraries and software](https://github.com/vinta/awesome-python)
+* [30 Python Language Features and Tricks You May Not Know About](http://sahandsaba.com/thirty-python-language-features-and-tricks-you-may-not-know.html)
+* [Official Style Guide for Python](https://www.python.org/dev/peps/pep-0008/)
 
-### Livros impressos
+### Dead Tree
 
 * [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20)
 * [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20)
 * [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20)
-
diff --git a/pt-br/python3-pt.html.markdown b/pt-br/python3-pt.html.markdown
deleted file mode 100644
index b72c732a..00000000
--- a/pt-br/python3-pt.html.markdown
+++ /dev/null
@@ -1,746 +0,0 @@
----
-language: python3
-contributors:
-    - ["Louie Dinh", "http://pythonpracticeprojects.com"]
-    - ["Steven Basart", "http://github.com/xksteven"]
-    - ["Andre Polykanine", "https://github.com/Oire"]
-    - ["Zachary Ferguson", "http://github.com/zfergus2"]
-translators:
-    - ["Paulo Henrique Rodrigues Pinheiro", "http://www.sysincloud.it"]
-lang: pt-br
-filename: learnpython3-pt.py
----
-
-Python foi criado por Guido Van Rossum nos anos 1990. Ele é atualmente uma
-das mais populares linguagens em existência. Eu fiquei morrendo de amor
-pelo Python por sua clareza sintática. É praticamente pseudocódigo executável.
-
-Suas opiniões são grandemente apreciadas. Você pode encontrar-me em
-[@louiedinh](http://twitter.com/louiedinh) ou louiedinh [em]
-[serviço de e-mail do google].
-
-Observação: Este artigo trata de Python 3 especificamente. Verifique
-[aqui](http://learnxinyminutes.com/docs/pt-br/python-pt/) se você pretende
-aprender o velho Python 2.7.
-
-```python
-
-# Comentários em uma única linha começam com uma cerquilha (também conhecido por sustenido).
-
-""" Strings de várias linhas podem ser escritas
-    usando três ", e são comumente usadas
-    como comentários.
-"""
-
-####################################################
-## 1. Tipos de dados primitivos e operadores
-####################################################
-
-# Você usa números normalmente
-3  # => 3
-
-# Matemática é como você espera que seja
-1 + 1   # => 2
-8 - 1   # => 7
-10 * 2  # => 20
-
-# Números inteiros por padrão, exceto na divisão, que retorna número
-# de ponto flutuante (float).
-35 / 5  # => 7.0
-
-# O resultado da divisão inteira arredonda para baixo tanto para números
-# positivos como para negativos.
-5 // 3       # => 1
-5.0 // 3.0   # => 1.0 # funciona em float também
--5 // 3      # => -2
--5.0 // 3.0  # => -2.0
-
-# Quando você usa um float, o resultado é float.
-3 * 2.0  # => 6.0
-
-# operador módulo
-7 % 3  # => 1
-
-# Exponenciação (x**y, x elevado à potência y)
-2**4  # => 16
-
-# Determine a precedência usando parêntesis
-(1 + 3) * 2  # => 8
-
-# Valores lógicos são primitivos (Atenção à primeira letra maiúscula)
-True
-False
-
-# negação lógica com not
-not True   # => False
-not False  # => True
-
-# Operadores lógicos
-# Observe que "and" e "or" são sensíveis a maiúsculas e minúsculas
-True and False  # => False
-False or True   # => True
-
-# Observe a utilização de operadores lógicos com números inteiros
-0 and 2     # => 0
--5 or 0     # => -5
-0 == False  # => True
-2 == True   # => False
-1 == True   # => True
-
-# Igualdade é ==
-1 == 1  # => True
-2 == 1  # => False
-
-# Diferença é !=
-1 != 1  # => False
-2 != 1  # => True
-
-# Mais comparações
-1 < 10  # => True
-1 > 10  # => False
-2 <= 2  # => True
-2 >= 2  # => True
-
-# Comparações podem ser agrupadas
-1 < 2 < 3  # => True
-2 < 3 < 2  # => False
-
-# (operador 'is' e operador '==') is verifica se duas variáveis
-# referenciam um mesmo objeto, mas == verifica se as variáveis
-# apontam para o mesmo valor.
-a = [1, 2, 3, 4]  # Referência a uma nova lista, [1, 2, 3, 4]
-b = a             # b referencia o que está referenciado por a
-b is a            # => True, a e b referenciam o mesmo objeto
-b == a            # => True, objetos a e b tem o mesmo conteúdo
-b = [1, 2, 3, 4]  # Referência a uma nova lista, [1, 2, 3, 4]
-b is a            # => False, a e b não referenciam o mesmo objeto
-b == a            # => True, objetos a e b tem o mesmo conteúdo
-
-# Strings são criadas com " ou '
-"Isto é uma string."
-'Isto também é uma string.'
-
-# Strings também podem ser somadas! Mas tente não fazer isso.
-"Olá " + "mundo!"  # => "Olá mundo!"
-# Strings podem ser somadas sem usar o '+'
-"Olá " "mundo!"    # => "Olá mundo!"
-
-# Uma string pode ser manipulada como se fosse uma lista de caracteres
-"Isso é uma string"[0]  # => 'I'
-
-# .format pode ser usado para formatar strings, dessa forma:
-"{} podem ser {}".format("Strings", "interpoladas")  # => "Strings podem ser interpoladas"
-
-# Você pode repetir os argumentos para digitar menos.
-"Seja ágil {0}, seja rápido {0}, salte sobre o {1} {0}".format("Jack", "castiçal")
-# => "Seja ágil Jack, seja rápido Jack, salte sobre o castiçal Jack."
-
-# Você pode usar palavras-chave se quiser contar.
-"{nome} quer comer {comida}".format(nome="Beto", comida="lasanha")  # => "Beto quer comer lasanha"
-
-# Se você precisa executar seu código Python3 com um interpretador Python 2.5 ou acima, você pode usar a velha forma para formatação de texto:
-"%s podem ser %s da forma %s" % ("Strings", "interpoladas", "antiga")  # => "Strings podem ser interpoladas da forma antiga"
-
-
-# None é um objeto
-None  # => None
-
-# Não use o operador de igualdade "==" para comparar objetos com None
-# Use "is" para isso. Ele checará pela identidade dos objetos.
-"etc" is None  # => False
-None is None   # => True
-
-# None, 0, e strings/listas/dicionários vazios todos retornam False.
-# Qualquer outra coisa retorna True
-bool(0)   # => False
-bool("")  # => False
-bool([])  # => False
-bool({})  # => False
-
-
-####################################################
-## 2. Variáveis e coleções
-####################################################
-
-# Python tem uma função print
-print("Eu sou o Python. Prazer em conhecer!")  # => Eu sou o Python. Prazer em conhecer!
-
-# Por padrão a função print também imprime o caractere de nova linha ao final.
-# Use o argumento opcional end para mudar o caractere final.
-print("Olá, Mundo", end="!")  # => Olá, Mundo!
-
-# Forma simples para capturar dados de entrada via console
-input_string_var = input("Digite alguma coisa: ") # Retorna o que foi digitado em uma string
-# Observação: Em versões antigas do Python, o método input() era chamado raw_input()
-
-# Não é necessário declarar variáveis antes de iniciá-las
-# È uma convenção usar letras_minúsculas_com_sublinhados
-alguma_variavel = 5
-alguma_variavel  # => 5
-
-# Acessar uma variável que não tenha sido inicializada gera uma exceção.
-# Veja Controle de Fluxo para aprender mais sobre tratamento de exceções.
-alguma_variavel_nao_inicializada  # Gera a exceção NameError
-
-# Listas armazenam sequencias
-li = []
-# Você pode iniciar com uma lista com alguns valores
-outra_li = [4, 5, 6]
-
-# Adicionar conteúdo ao fim da lista com append
-li.append(1)    # li agora é [1]
-li.append(2)    # li agora é [1, 2]
-li.append(4)    # li agora é [1, 2, 4]
-li.append(3)    # li agora é [1, 2, 4, 3]
-# Remover do final da lista com pop
-li.pop()        # => 3 e agora li é [1, 2, 4]
-# Vamos colocá-lo lá novamente!
-li.append(3)    # li agora é [1, 2, 4, 3] novamente.
-
-# Acessar uma lista da mesma forma que você faz com um array
-li[0]   # => 1
-# Acessa o último elemento
-li[-1]  # => 3
-
-# Acessando além dos limites gera um IndexError
-li[4]  # Gera o IndexError
-
-# Você pode acessar vários elementos com a sintaxe de limites
-# (É um limite fechado, aberto pra você que gosta de matemática.)
-li[1:3]   # => [2, 4]
-# Omitindo o final
-li[2:]    # => [4, 3]
-# Omitindo o início
-li[:3]    # => [1, 2, 4]
-# Selecione cada segunda entrada
-li[::2]   # => [1, 4]
-# Tenha uma cópia em ordem invertida da lista
-li[::-1]  # => [3, 4, 2, 1]
-# Use qualquer combinação dessas para indicar limites complexos
-# li[inicio:fim:passo]
-
-# Faça uma cópia profunda de um nível usando limites
-li2 = li[:]  # => li2 = [1, 2, 4, 3] mas (li2 is li) resultará em False.
-
-# Apague elementos específicos da lista com "del"
-del li[2]  # li agora é [1, 2, 3]
-
-# Você pode somar listas
-# Observação: valores em li e other_li não são modificados.
-li + other_li  # => [1, 2, 3, 4, 5, 6]
-
-# Concatene listas com "extend()"
-li.extend(other_li)  # Agora li é [1, 2, 3, 4, 5, 6]
-
-# Verifique se algo existe na lista com "in"
-1 in li  # => True
-
-# Examine  tamanho com "len()"
-len(li)  # => 6
-
-
-# Tuplas são como l istas, mas imutáveis.
-tup = (1, 2, 3)
-tup[0]      # => 1
-tup[0] = 3  # Gera um TypeError
-
-# Observe que uma tupla de tamanho um precisa ter uma vírgula depois do
-# último elemento mas tuplas de outros tamanhos, mesmo vazias, não precisa,.
-type((1))   # => <class 'int'>
-type((1,))  # => <class 'tuple'>
-type(())    # => <class 'tuple'>
-
-# Você pode realizar com tuplas a maior parte das operações que faz com listas
-len(tup)         # => 3
-tup + (4, 5, 6)  # => (1, 2, 3, 4, 5, 6)
-tup[:2]          # => (1, 2)
-2 in tup         # => True
-
-# Você pode desmembrar tuplas (ou listas) em variáveis.
-a, b, c = (1, 2, 3)  # a é 1, b é 2 e c é 3
-# Por padrão, tuplas são criadas se você não coloca parêntesis.
-d, e, f = 4, 5, 6
-# Veja como é fácil permutar dois valores
-e, d = d, e  # d é 5, e é 4
-
-# Dicionários armazenam mapeamentos
-empty_dict = {}
-# Aqui está um dicionário preenchido na definição da referência
-filled_dict = {"um": 1, "dois": 2, "três": 3}
-
-# Observe que chaves para dicionários devem ser tipos imutáveis. Isto é para
-# assegurar que a chave pode ser convertida para uma valor hash constante para
-# buscas rápidas.
-# Tipos imutáveis incluem inteiros, flotas, strings e tuplas.
-invalid_dict = {[1,2,3]: "123"}  # => Gera um TypeError: unhashable type: 'list'
-valid_dict = {(1,2,3):[1,2,3]}   # Já os valores, podem ser de qualquer tipo.
-
-# Acesse valores com []
-filled_dict["um"]  # => 1
-
-# Acesse todas as chaves como um iterável com "keys()". É necessário encapsular
-# a chamada com um list() para transformá-las em uma lista. Falaremos sobre isso
-# mais adiante. Observe que a ordem de uma chave de dicionário não é garantida.
-# Por isso, os resultados aqui apresentados podem não ser exatamente como os
-# aqui apresentados.
-list(filled_dict.keys())  # => ["três", "dois", "um"]
-
-
-# Acesse todos os valores de um iterável com "values()". Novamente, é
-# necessário encapsular ele com list() para não termos um iterável, e sim os
-# valores. Observe que, como foi dito acima, a ordem dos elementos não é
-# garantida.
-list(filled_dict.values())  # => [3, 2, 1]
-
-
-# Verifique a existência de chaves em um dicionário com "in"
-"um" in filled_dict  # => True
-1 in filled_dict      # => False
-
-# Acessar uma chave inexistente gera um KeyError
-filled_dict["quatro"]  # KeyError
-
-# Use o método "get()" para evitar um KeyError
-filled_dict.get("um")      # => 1
-filled_dict.get("quatro")     # => None
-# O método get permite um parâmetro padrão para quando não existir a chave
-filled_dict.get("um", 4)   # => 1
-filled_dict.get("quatro", 4)  # => 4
-
-# "setdefault()" insere em dicionário apenas se a dada chave não existir
-filled_dict.setdefault("cinco", 5)  # filled_dict["cinco"] tem valor 5
-filled_dict.setdefault("cinco", 6)  # filled_dict["cinco"] continua 5
-
-# Inserindo em um dicionário
-filled_dict.update({"quatro":4})  # => {"um": 1, "dois": 2, "três": 3, "quatro": 4}
-#filled_dict["quatro"] = 4        #outra forma de inserir em um dicionário
-
-# Remova chaves de um dicionário com del
-del filled_dict["um"]  # Remove a chave "um" de filled_dict
-
-
-# Armazenamento em sets... bem, são conjuntos
-empty_set = set()
-# Inicializa um set com alguns valores. Sim, ele parece um dicionário. Desculpe.
-some_set = {1, 1, 2, 2, 3, 4}  # some_set agora é {1, 2, 3, 4}
-
-# Da mesma forma que chaves em um dicionário, elementos de um set devem ser
-# imutáveis.
-invalid_set = {[1], 1}  # => Gera um TypeError: unhashable type: 'list'
-valid_set = {(1,), 1}
-
-# Pode definir novas variáveis para um conjunto
-filled_set = some_set
-
-# Inclua mais um item no set
-filled_set.add(5)  # filled_set agora é {1, 2, 3, 4, 5}
-
-# Faça interseção de conjuntos com &
-other_set = {3, 4, 5, 6}
-filled_set & other_set  # => {3, 4, 5}
-
-# Faça união de conjuntos com |
-filled_set | other_set  # => {1, 2, 3, 4, 5, 6}
-
-# Faça a diferença entre conjuntos com -
-{1, 2, 3, 4} - {2, 3, 5}  # => {1, 4}
-
-# Verifique a existência em um conjunto com in
-2 in filled_set   # => True
-10 in filled_set  # => False
-
-
-
-####################################################
-## 3. Controle de fluxo e iteráveis
-####################################################
-
-# Iniciemos um variável
-some_var = 5
-
-# Aqui está uma expressão if. Indentação é significante em python!
-# imprime "somevar é menor que10"
-if some_var > 10:
-    print("some_var é absolutamente maior que 10.")
-elif some_var < 10:    # Esta cláusula elif é opcional.
-    print("some_var é menor que 10.")
-else:                  # Isto também é opcional.
-    print("some_var é, de fato, 10.")
-
-
-"""
-Laços for iteram sobre listas
-imprime:
-    cachorro é um mamífero
-    gato é um mamífero
-    rato é um mamífero
-"""
-for animal in ["cachorro", "gato", "rato"]:
-    # Você pode usar format() para interpolar strings formatadas
-    print("{} é um mamífero".format(animal))
-
-"""
-"range(número)" retorna um iterável de números
-de zero até o número escolhido
-imprime:
-    0
-    1
-    2
-    3
-"""
-for i in range(4):
-    print(i)
-
-"""
-"range(menor, maior)" gera um iterável de números
-começando pelo menor até o maior
-imprime:
-    4
-    5
-    6
-    7
-"""
-for i in range(4, 8):
-    print(i)
-
-"""
-"range(menor, maior, passo)" retorna um iterável de números
-começando pelo menor número até o maior númeno, pulando de
-passo em passo. Se o passo não for indicado, o valor padrão é um.
-imprime:
-    4
-    6
-"""
-for i in range(4, 8, 2):
-    print(i)
-"""
-
-Laços while executam até que a condição não seja mais válida.
-imprime:
-    0
-    1
-    2
-    3
-"""
-x = 0
-while x < 4:
-    print(x)
-    x += 1  # Maneira mais curta para for x = x + 1
-
-# Lide com exceções com um bloco try/except
-try:
-    # Use "raise" para gerar um erro
-    raise IndexError("Isto é um erro de índice")
-except IndexError as e:
-    pass                 # Pass é um não-operador. Normalmente você usa algum código de recuperação aqui.
-except (TypeError, NameError):
-    pass                 # Varias exceções podem ser gerenciadas, se necessário.
-else:                    # Cláusula opcional para o bloco try/except. Deve estar após todos os blocos de exceção.
-    print("Tudo certo!")   # Executa apenas se o código em try não gera exceção
-finally:                 #  Sempre é executado
-    print("Nós podemos fazer o código de limpeza aqui.")
-
-# Ao invés de try/finally para limpeza você pode usar a cláusula with
-with open("myfile.txt") as f:
-    for line in f:
-        print(line)
-
-# Python provê uma abstração fundamental chamada Iterável.
-# Um iterável é um objeto que pode ser tratado como uma sequência.
-# O objeto retornou a função range, um iterável.
-
-filled_dict = {"um": 1, "dois": 2, "três": 3}
-our_iterable = filled_dict.keys()
-print(our_iterable)  # => range(1,10). Esse é um objeto que implementa nossa interface iterável.
-
-# Nós podemos percorrê-la.
-for i in our_iterable:
-    print(i)  # Imprime um, dois, três
-
-# Mas não podemos acessar os elementos pelo seu índice.
-our_iterable[1]  # Gera um TypeError
-
-# Um iterável é um objeto que sabe como criar um iterador.
-our_iterator = iter(our_iterable)
-
-# Nosso iterador é um objeto que pode lembrar o estado enquanto nós o percorremos.
-# Nós acessamos o próximo objeto com "next()".
-next(our_iterator)  # => "um"
-
-# Ele mantém o estado enquanto nós o percorremos.
-next(our_iterator)  # => "dois"
-next(our_iterator)  # => "três"
-
-# Após o iterador retornar todos os seus dados, ele gera a exceção StopIterator
-next(our_iterator)  # Gera StopIteration
-
-# Você pode capturar todos os elementos de um iterador aplicando list() nele.
-list(filled_dict.keys())  # => Retorna ["um", "dois", "três"]
-
-
-####################################################
-## 4. Funções
-####################################################
-
-# Use "def" para criar novas funções.
-def add(x, y):
-    print("x é {} e y é {}".format(x, y))
-    return x + y  # Retorne valores com a cláusula return
-
-# Chamando funções com parâmetros
-add(5, 6)  # => imprime "x é 5 e y é 6" e retorna 11
-
-# Outro meio de chamar funções é com argumentos nomeados
-add(y=6, x=5)  # Argumentos nomeados podem aparecer em qualquer ordem.
-
-# Você pode definir funções que pegam um número variável de argumentos
-# posicionais
-def varargs(*args):
-    return args
-
-varargs(1, 2, 3)  # => (1, 2, 3)
-
-# Você pode definir funções que pegam um número variável de argumentos nomeados
-# também
-def keyword_args(**kwargs):
-    return kwargs
-
-# Vamos chamá-lo para ver o que acontece
-keyword_args(peh="grande", lago="ness")  # => {"peh": "grande", "lago": "ness"}
-
-
-# Você pode fazer ambos simultaneamente, se você quiser
-def all_the_args(*args, **kwargs):
-    print(args)
-    print(kwargs)
-"""
-all_the_args(1, 2, a=3, b=4) imprime:
-    (1, 2)
-    {"a": 3, "b": 4}
-"""
-
-# Quando chamar funções, você pode fazer o oposto de args/kwargs!
-# Use * para expandir tuplas e use ** para expandir dicionários!
-args = (1, 2, 3, 4)
-kwargs = {"a": 3, "b": 4}
-all_the_args(*args)            # equivalente a foo(1, 2, 3, 4)
-all_the_args(**kwargs)         # equivalente a foo(a=3, b=4)
-all_the_args(*args, **kwargs)  # equivalente a foo(1, 2, 3, 4, a=3, b=4)
-
-# Retornando múltiplos valores (com atribuição de tuplas)
-def swap(x, y):
-    return y, x  # Retorna múltiplos valores como uma tupla sem os parêntesis.
-                 # (Observação: os parêntesis foram excluídos mas podem estar
-                 # presentes)
-
-x = 1
-y = 2
-x, y = swap(x, y)     # => x = 2, y = 1
-# (x, y) = swap(x,y)  # Novamente, os parêntesis foram excluídos mas podem estar presentes.
-
-# Escopo de função
-x = 5
-
-def setX(num):
-    # A variável local x não é a mesma variável global x
-    x = num    # => 43
-    print (x)  # => 43
-
-def setGlobalX(num):
-    global x
-    print (x)  # => 5
-    x = num    # variável global x agora é 6
-    print (x)  # => 6
-
-setX(43)
-setGlobalX(6)
-
-
-# Python tem funções de primeira classe
-def create_adder(x):
-    def adder(y):
-        return x + y
-    return adder
-
-add_10 = create_adder(10)
-add_10(3)   # => 13
-
-# Também existem as funções anônimas
-(lambda x: x > 2)(3)                  # => True
-(lambda x, y: x ** 2 + y ** 2)(2, 1)  # => 5
-
-# TODO - Fix for iterables
-# Existem funções internas de alta ordem
-map(add_10, [1, 2, 3])          # => [11, 12, 13]
-map(max, [1, 2, 3], [4, 2, 1])  # => [4, 2, 3]
-
-filter(lambda x: x > 5, [3, 4, 5, 6, 7])  # => [6, 7]
-
-# Nós podemos usar compreensão de lista para interessantes mapas e filtros
-# Compreensão de lista armazena a saída como uma lista que pode ser uma lista
-# aninhada
-[add_10(i) for i in [1, 2, 3]]         # => [11, 12, 13]
-[x for x in [3, 4, 5, 6, 7] if x > 5]  # => [6, 7]
-
-####################################################
-## 5. Classes
-####################################################
-
-
-# Nós usamos o operador "class" para ter uma classe
-class Human:
-
-    # Um atributo de classe. Ele é compartilhado por todas as instâncias dessa
-    # classe.
-    species = "H. sapiens"
-
-    # Construtor básico, é chamado quando esta classe é instanciada.
-    # Note que dois sublinhados no início e no final de uma identificados
-    # significa objetos ou atributos que são usados pelo python mas vivem em
-    # um namespace controlado pelo usuário. Métodos (ou objetos ou atributos)
-    # como: __init__, __str__, __repr__, etc. são chamados métodos mágicos (ou
-    # algumas vezes chamados métodos dunder - "double underscore")
-    # Você não deve usar nomes assim por sua vontade.
-    def __init__(self, name):
-        @ Atribui o argumento ao atributo da  instância
-        self.name = name
-
-    # Um método de instância. Todos os métodos tem "self" como primeiro
-    # argumento
-    def say(self, msg):
-        return "{name}: {message}".format(name=self.name, message=msg)
-
-    # Um método de classe é compartilhado por todas as instâncias
-    # Eles são chamados com a classe requisitante como primeiro argumento
-    @classmethod
-    def get_species(cls):
-        return cls.species
-
-    # Um método estático é chamado sem uma referência a classe ou instância
-    @staticmethod
-    def grunt():
-        return "*grunt*"
-
-
-# Instancie uma classe
-i = Human(name="Ian")
-print(i.say("oi"))     # imprime "Ian: oi"
-
-j = Human("Joel")
-print(j.say("olá"))  # imprime "Joel: olá"
-
-# Chama nosso método de classe
-i.get_species()  # => "H. sapiens"
-
-# Altera um atributo compartilhado
-Human.species = "H. neanderthalensis"
-i.get_species()  # => "H. neanderthalensis"
-j.get_species()  # => "H. neanderthalensis"
-
-# Chama o método estático
-Human.grunt()    # => "*grunt*"
-
-
-####################################################
-## 6. Módulos
-####################################################
-
-# Você pode importar módulos
-import math
-print(math.sqrt(16))  # => 4.0
-
-# Você pode importar apenas funções específicas de um módulo
-from math import ceil, floor
-print(ceil(3.7))   # => 4.0
-print(floor(3.7))  # => 3.0
-
-# Você pode importar todas as funções de um módulo para o namespace atual
-# Atenção: isso não é recomendado
-from math import *
-
-# Você pode encurtar o nome dos módulos
-import math as m
-math.sqrt(16) == m.sqrt(16)  # => True
-
-# Módulos python são apenas arquivos python comuns. Você
-# pode escrever os seus, e importá-los. O nome do
-# módulo é o mesmo nome do arquivo.
-
-# Você pode procurar que atributos e funções definem um módulo.
-import math
-dir(math)
-
-
-####################################################
-## 7. Avançado
-####################################################
-
-# Geradores podem ajudar você a escrever código "preguiçoso"
-def double_numbers(iterable):
-    for i in iterable:
-        yield i + i
-
-# Um gerador cria valores conforme necessário.
-# Ao invés de gerar e retornar todos os valores de uma só vez ele cria um em
-# cada interação. Isto significa que valores maiores que 15 não serão
-# processados em double_numbers.
-# Nós usamos um sublinhado ao final do nome das variáveis quando queremos usar
-# um nome que normalmente colide com uma palavra reservada do python.
-range_ = range(1, 900000000)
-# Multiplica por 2 todos os números até encontrar um resultado >= 30
-for i in double_numbers(range_):
-    print(i)
-    if i >= 30:
-        break
-
-
-# Decoradores
-# Neste exemplo beg encapsula say
-# beg irá chamar say. Se say_please é verdade então ele irá mudar a mensagem
-# retornada
-from functools import wraps
-
-
-def beg(target_function):
-    @wraps(target_function)
-    def wrapper(*args, **kwargs):
-        msg, say_please = target_function(*args, **kwargs)
-        if say_please:
-            return "{} {}".format(msg, "Por favor! Eu sou pobre :(")
-        return msg
-
-    return wrapper
-
-
-@beg
-def say(say_please=False):
-    msg = "Você me paga uma cerveja?"
-    return msg, say_please
-
-
-print(say())                # Você me paga uma cerveja?
-print(say(say_please=True)) # Você me paga uma cerveja? Por favor! Eu sou pobre :(
-```
-
-## Pronto para mais?
-
-### Free Online
-
-* [Automate the Boring Stuff with Python](https://automatetheboringstuff.com)
-* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
-* [Dive Into Python](http://www.diveintopython.net/)
-* [Ideas for Python Projects](http://pythonpracticeprojects.com)
-* [The Official Docs](http://docs.python.org/3/)
-* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
-* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182)
-* [Python Course](http://www.python-course.eu/index.php)
-* [First Steps With Python](https://realpython.com/learn/python-first-steps/)
-* [A curated list of awesome Python frameworks, libraries and software](https://github.com/vinta/awesome-python)
-* [30 Python Language Features and Tricks You May Not Know About](http://sahandsaba.com/thirty-python-language-features-and-tricks-you-may-not-know.html)
-* [Official Style Guide for Python](https://www.python.org/dev/peps/pep-0008/)
-
-### Dead Tree
-
-* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20)
-* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20)
-* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20)
diff --git a/pt-br/pythonlegacy-pt.html.markdown b/pt-br/pythonlegacy-pt.html.markdown
new file mode 100644
index 00000000..572bb787
--- /dev/null
+++ b/pt-br/pythonlegacy-pt.html.markdown
@@ -0,0 +1,509 @@
+---
+language: Python 2 (legacy)
+contributors:
+    - ["Louie Dinh", "http://ldinh.ca"]
+translators:
+    - ["Vilson Vieira", "http://automata.cc"]
+lang: pt-br
+filename: learnpythonlegacy-pt.py
+---
+
+Python foi criado por Guido Van Rossum no começo dos anos 90. Atualmente é uma
+das linguagens de programação mais populares. Eu me apaixonei por Python, por
+sua clareza de sintaxe. É basicamente pseudocódigo executável.
+
+Comentários serão muito apreciados! Você pode me contactar em
+[@louiedinh](http://twitter.com/louiedinh) ou louiedinh [arroba]
+[serviço de email do google]
+
+Nota: Este artigo usa Python 2.7 especificamente, mas deveria ser aplicável a
+qualquer Python 2.x. Logo haverá uma versão abordando Python 3!
+
+```python
+# Comentários de uma linha começam com cerquilha (ou sustenido)
+""" Strings de várias linhas podem ser escritas
+    usando três ", e são comumente usadas
+    como comentários
+"""
+
+####################################################
+## 1. Tipos de dados primitivos e operadores
+####################################################
+
+# Você usa números normalmente
+3 #=> 3
+
+# Operadores matemáticos são aqueles que você já está acostumado
+1 + 1 #=> 2
+8 - 1 #=> 7
+10 * 2 #=> 20
+35 / 5 #=> 7
+
+# A divisão é um pouco estranha. A divisão de números inteiros arredonda
+# para baixo o resultado, automaticamente
+5 / 2 #=> 2
+
+# Para concertar a divisão, precisamos aprender sobre números de ponto
+# flutuante (conhecidos como 'float').
+2.0     # Isso é um 'float'
+11.0 / 4.0 #=> 2.75 ahhh... muito melhor
+
+# Forçamos a precedência de operadores usando parênteses
+(1 + 3) * 2 #=> 8
+
+# Valores booleanos (ou 'boolean') são também tipos primitivos
+True
+False
+
+# Negamos usando 'not'
+not True #=> False
+not False #=> True
+
+# Testamos igualdade usando '=='
+1 == 1 #=> True
+2 == 1 #=> False
+
+# E desigualdade com '!='
+1 != 1 #=> False
+2 != 1 #=> True
+
+# Mais comparações
+1 < 10 #=> True
+1 > 10 #=> False
+2 <= 2 #=> True
+2 >= 2 #=> True
+
+# As comparações podem ser encadeadas!
+1 < 2 < 3 #=> True
+2 < 3 < 2 #=> False
+
+# Strings são criadas com " ou '
+"Isso é uma string."
+'Isso também é uma string.'
+
+# Strings podem ser somadas (ou melhor, concatenadas)!
+"Olá " + "mundo!" #=> "Olá mundo!"
+
+# Uma string pode ser tratada como uma lista de caracteres
+"Esta é uma string"[0] #=> 'E'
+
+# O caractere % pode ser usado para formatar strings, desta forma:
+"%s podem ser %s" % ("strings", "interpoladas")
+
+# Um jeito novo de formatar strings é usando o método 'format'.
+# Esse método é o jeito mais usado
+"{0} podem ser {1}".format("strings", "formatadas")
+# Você pode usar palavras-chave (ou 'keywords') se você não quiser contar.
+"{nome} quer comer {comida}".format(nome="João", comida="lasanha")
+
+# 'None' é um objeto
+None #=> None
+
+# Não use o operador de igualdade `==` para comparar objetos com 'None'
+# Ao invés disso, use `is`
+"etc" is None #=> False
+None is None  #=> True
+
+# O operador 'is' teste a identidade de um objeto. Isso não é
+# muito útil quando estamos lidando com valores primitivos, mas é
+# muito útil quando lidamos com objetos.
+
+# None, 0, e strings/listas vazias são todas interpretadas como 'False'.
+# Todos os outros valores são 'True'
+0 == False  #=> True
+"" == False #=> True
+
+
+####################################################
+## 2. Variáveis e Coleções
+####################################################
+
+# Imprimir na tela é muito fácil
+print "Eu sou o Python. Prazer em te conhecer!"
+
+
+# Nós não precisamos declarar variáveis antes de usá-las, basta usar!
+alguma_variavel = 5    # A convenção é usar caixa_baixa_com_sobrescritos
+alguma_variavel #=> 5
+
+# Acessar uma variável que não teve nenhum valor atribuído anteriormente é
+# uma exceção.
+# Veja a seção 'Controle' para aprender mais sobre tratamento de exceção.
+outra_variavel  # Gera uma exceção de erro de nome
+
+# 'if' pode ser usado como uma expressão
+"uepa!" if 3 > 2 else 2 #=> "uepa!"
+
+# Listas armazenam sequências de elementos
+lista = []
+# Você pode inicializar uma lista com valores
+outra_lista = [4, 5, 6]
+
+# Adicione elementos no final da lista usando 'append'
+lista.append(1)    # lista é agora [1]
+lista.append(2)    # lista é agora [1, 2]
+lista.append(4)    # lista é agora [1, 2, 4]
+lista.append(3)    # lista é agora [1, 2, 4, 3]
+# Remova elementos do fim da lista usando 'pop'
+lista.pop()        #=> 3 e lista é agora [1, 2, 4]
+# Vamos adicionar o elemento novamente
+lista.append(3)    # lista agora é [1, 2, 4, 3] novamente.
+
+# Acesse elementos de uma lista através de seu índices
+lista[0] #=> 1
+# Acesse o último elemento com índice negativo!
+lista[-1] #=> 3
+
+# Tentar acessar um elemento fora dos limites da lista gera uma exceção
+# do tipo 'IndexError'
+lista[4] # Gera uma exceção 'IndexError'
+
+# Você pode acessar vários elementos ao mesmo tempo usando a sintaxe de
+# limites
+# (Para quem gosta de matemática, isso é um limite fechado/aberto)
+lista[1:3] #=> [2, 4]
+# Você pode omitir o fim se quiser os elementos até o final da lista
+lista[2:] #=> [4, 3]
+# O mesmo para o início
+lista[:3] #=> [1, 2, 4]
+
+# Remova um elemento qualquer de uma lista usando 'del'
+del lista[2] # lista agora é [1, 2, 3]
+
+# Você pode somar listas (obs: as listas originais não são modificadas)
+lista + outra_lista #=> [1, 2, 3, 4, 5, 6]
+
+# Você também pode concatenar usando o método 'extend' (lista será modificada!)
+lista.extend(outra_lista) # Agora lista é [1, 2, 3, 4, 5, 6]
+
+# Para checar se um elemento pertence a uma lista, use 'in'
+1 in lista #=> True
+
+# Saiba quantos elementos uma lista possui com 'len'
+len(lista) #=> 6
+
+
+# Tuplas são iguais a listas, mas são imutáveis
+tup = (1, 2, 3)
+tup[0] #=> 1
+tup[0] = 3  # Isso gera uma exceção do tipo TypeError
+
+# Você pode fazer nas tuplas todas aquelas coisas fez com a lista
+len(tup) #=> 3
+tup + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6)
+tup[:2] #=> (1, 2)
+2 in tup #=> True
+
+# Você pode 'desempacotar' tuplas (ou listas) em variáveis, associando cada
+# elemento da tupla/lista a uma variável correspondente
+a, b, c = (1, 2, 3)     # a agora é 1, b agora é 2, c agora é 3
+# Tuplas são criadas por padrão, mesmo se você não usar parênteses
+d, e, f = 4, 5, 6
+# Sabendo disso, veja só como é fácil trocar os valores de duas variáveis!
+e, d = d, e     # d agora é 5, e agora é 4
+
+
+# Dicionários armazenam 'mapeamentos' (do tipo chave-valor)
+dicionario_vazio = {}
+# Aqui criamos um dicionário já contendo valores
+dicionario = {"um": 1, "dois": 2, "três": 3}
+
+# Acesse valores usando []
+dicionario["um"] #=> 1
+
+# Retorna uma lista com todas as chaves do dicionário
+dicionario.keys() #=> ["três", "dois", "um"]
+# Nota: A ordem das chaves não é garantida.
+# O resultado no seu interpretador não necessariamente será igual a esse.
+
+# Retorna uma lista com todos os valores do dicionário
+dicionario.values() #=> [3, 2, 1]
+# Nota: A mesma nota acima sobre a ordenação é válida aqui.
+
+# Veja se uma chave qualquer está em um dicionário usando 'in'
+"um" in dicionario #=> True
+1 in dicionario #=> False
+
+# Tentar acessar uma chave que não existe gera uma exceção do tipo 'KeyError'
+dicionario["quatro"] # Gera uma exceção KeyError
+
+# Você pode usar o método 'get' para evitar gerar a exceção 'KeyError'.
+# Ao invés de gerar essa exceção, irá retornar 'None' se a chave não existir.
+dicionario.get("um") #=> 1
+dicionario.get("quatro") #=> None
+# O método 'get' suporta um argumento que diz qual valor deverá ser
+# retornado se a chave não existir (ao invés de 'None').
+dicionario.get("um", 4) #=> 1
+dicionario.get("quatro", 4) #=> 4
+
+# O método 'setdefault' é um jeito seguro de adicionar um novo par
+# chave-valor a um dicionário, associando um valor padrão imutável à uma chave
+dicionario.setdefault("cinco", 5) # dicionario["cinco"] é definido como 5
+dicionario.setdefault("cinco", 6) # dicionario["cinco"] ainda é igual a 5
+
+
+# Conjuntos (ou sets) armazenam ... bem, conjuntos
+# Nota: lembre-se que conjuntos não admitem elementos repetidos!
+conjunto_vazio = set()
+# Podemos inicializar um conjunto com valores
+conjunto = set([1, 2, 2, 3, 4]) # conjunto é set([1, 2, 3, 4]), sem repetição!
+
+# Desde o Python 2.7, {} pode ser usado para declarar um conjunto
+conjunto = {1, 2, 2, 3, 4} # => {1 2 3 4}
+
+# Adicione mais ítens a um conjunto com 'add'
+conjunto.add(5) # conjunto agora é {1, 2, 3, 4, 5}
+
+# Calcule a intersecção de dois conjuntos com &
+outro_conj = {3, 4, 5, 6}
+conjunto & outro_conj #=> {3, 4, 5}
+
+# Calcule a união de dois conjuntos com |
+conjunto | outro_conj #=> {1, 2, 3, 4, 5, 6}
+
+# E a diferença entre dois conjuntos com -
+{1,2,3,4} - {2,3,5} #=> {1, 4}
+
+# Veja se um elemento existe em um conjunto usando 'in'
+2 in conjunto #=> True
+10 in conjunto #=> False
+
+
+####################################################
+## 3. Controle
+####################################################
+
+# Para começar, vamos apenas criar uma variável
+alguma_var = 5
+
+# Aqui está uma expressão 'if'. Veja como a identação é importante em Python!
+# Esses comandos irão imprimir "alguma_var é menor que 10"
+if alguma_var > 10:
+    print "some_var é maior que 10."
+elif some_var < 10:    # Esse 'elif' é opcional
+    print "some_var é menor que 10."
+else:           # Esse 'else' também é opcional
+    print "some_var é igual a 10."
+
+
+"""
+Laços (ou loops) 'for' iteram em listas.
+Irá imprimir:
+    cachorro é um mamífero
+    gato é um mamífero
+    rato é um mamífero
+"""
+for animal in ["cachorro", "gato", "rato"]:
+    # Você pode usar % para interpolar strings formatadas
+    print "%s é um mamífero" % animal
+    
+"""
+A função `range(um número)` retorna uma lista de números
+do zero até o número dado.
+Irá imprimir:
+    0
+    1
+    2
+    3
+"""
+for i in range(4):
+    print i
+
+"""
+Laços 'while' executam enquanto uma condição dada for verdadeira.
+Irá imprimir:
+    0
+    1
+    2
+    3
+"""
+x = 0
+while x < 4:
+    print x
+    x += 1  # Isso é um atalho para a expressão x = x + 1
+
+# Tratamos excessões usando o bloco try/except
+# Funciona em Python 2.6 e versões superiores:
+
+try:
+    # Use 'raise' para gerar um erro
+    raise IndexError("Isso é um erro de índice")
+except IndexError as e:
+    pass    # Pass é um operador que não faz nada, deixa passar.
+            # Usualmente você iria tratar a exceção aqui...
+
+
+####################################################
+## 4. Funções
+####################################################
+
+# Use 'def' para definir novas funções
+def soma(x, y):
+    print "x é %s e y é %s" % (x, y)
+    return x + y    # Retorne valores usando 'return'
+
+# Chamando funções com parâmetros
+soma(5, 6) #=> imprime "x é 5 e y é 6" e retorna o valor 11
+
+# Um outro jeito de chamar funções é especificando explicitamente os valores
+# de cada parâmetro com chaves
+soma(y=6, x=5)   # Argumentos com chaves podem vir em qualquer ordem.
+
+# Você pode definir funções que recebem um número qualquer de argumentos
+# (respeitando a sua ordem)
+def varargs(*args):
+    return args
+
+varargs(1, 2, 3) #=> (1,2,3)
+
+
+# Você também pode definir funções que recebem um número qualquer de argumentos
+# com chaves
+def args_com_chaves(**ch_args):
+    return ch_args
+
+# Vamos chamar essa função para ver o que acontece
+args_com_chaves(pe="grande", lago="Ness") #=> {"pe": "grande", "lago": "Ness"}
+
+# Você pode fazer as duas coisas ao mesmo tempo, se desejar
+def todos_args(*args, **ch_wargs):
+    print args
+    print ch_args
+"""
+todos_args(1, 2, a=3, b=4) imprime:
+    (1, 2)
+    {"a": 3, "b": 4}
+"""
+
+# Quando você chamar funções, pode fazer o oposto do que fizemos até agora!
+# Podemos usar * para expandir tuplas de argumentos e ** para expandir
+# dicionários de argumentos com chave.
+args = (1, 2, 3, 4)
+ch_args = {"a": 3, "b": 4}
+todos_args(*args)  # equivalente a todos_args(1, 2, 3, 4)
+todos_args(**ch_args) # equivalente a todos_args(a=3, b=4)
+todos_args(*args, **ch_args) # equivalente a todos_args(1, 2, 3, 4, a=3, b=4)
+
+# Em Python, funções são elementos de primeira ordem (são como objetos, 
+# strings ou números)
+def cria_somador(x):
+    def somador(y):
+        return x + y
+    return somador
+
+soma_10 = cria_somador(10)
+soma_10(3) #=> 13
+
+# Desta forma, existem também funções anônimas
+(lambda x: x > 2)(3) #=> True
+
+# E existem funções de alta ordem por padrão
+map(soma_10, [1,2,3]) #=> [11, 12, 13]
+filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7]
+reduce(lambda x, y: x + y, [3, 4, 5, 6, 7]) #=> 25
+
+# Nós podemos usar compreensão de listas para mapear e filtrar também
+[soma_10(i) for i in [1, 2, 3]]  #=> [11, 12, 13]
+[x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7]
+
+####################################################
+## 5. Classes
+####################################################
+
+# Para criar uma nova classe, devemos herdar de 'object'
+class Humano(object):
+
+    # Um atributo de classe. Ele é compartilhado por todas as instâncias dessa
+    # classe
+    especie = "H. sapiens"
+
+    # Definimos um inicializador básico
+    def __init__(self, nome):
+        # Atribui o valor de argumento dado a um atributo da instância
+        self.nome = nome
+
+    # Um método de instância. Todos os métodos levam 'self' como primeiro
+    # argumento
+    def diga(self, msg):
+       return "%s: %s" % (self.nome, msg)
+
+    # Um método de classe é compartilhado por todas as instâncias
+    # Eles são chamados passando o nome da classe como primeiro argumento
+    @classmethod
+    def get_especie(cls):
+        return cls.especie
+
+    # Um método estático é chamado sem uma referência a classe ou instância
+    @staticmethod
+    def ronca():
+        return "*arrrrrrr*"
+
+
+# Instancie uma classe
+i = Humano(nome="Ivone")
+print i.diga("oi")     # imprime "Ivone: oi"
+
+j = Human("Joel")
+print j.say("olá")  #prints out "Joel: olá"
+
+# Chame nosso método de classe
+i.get_especie() #=> "H. sapiens"
+
+# Modifique um atributo compartilhado
+Humano.especie = "H. neanderthalensis"
+i.get_especie() #=> "H. neanderthalensis"
+j.get_especie() #=> "H. neanderthalensis"
+
+# Chame o método estático
+Humano.ronca() #=> "*arrrrrrr*"
+
+
+####################################################
+## 6. Módulos
+####################################################
+
+# Você pode importar módulos
+import math
+print math.sqrt(16) #=> 4.0
+
+# Você pode importar funções específicas de um módulo
+from math import ceil, floor
+print ceil(3.7)  #=> 4.0
+print floor(3.7) #=> 3.0
+
+# Você também pode importar todas as funções de um módulo
+# Atenção: isso não é recomendado!
+from math import *
+
+# Você pode usar apelidos para os módulos, encurtando seus nomes
+import math as m
+math.sqrt(16) == m.sqrt(16) #=> True
+
+# Módulos em Python são apenas arquivos Python. Você
+# pode escrever o seu próprio módulo e importá-lo. O nome do
+# módulo será o mesmo que o nome do arquivo.
+
+# Você pode descobrir quais funções e atributos
+# estão definidos em um módulo qualquer.
+import math
+dir(math)
+
+
+```
+
+## Pronto para mais?
+
+### Online e gratuito
+
+* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
+* [Dive Into Python](http://www.diveintopython.net/)
+* [The Official Docs](http://docs.python.org/2.6/)
+* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
+* [Python Module of the Week](http://pymotw.com/2/)
+
+### Livros impressos
+
+* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20)
+* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20)
+* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20)
+
diff --git a/pt-br/sass-pt.html.markdown b/pt-br/sass-pt.html.markdown
index 3d91f1ca..28df3c59 100644
--- a/pt-br/sass-pt.html.markdown
+++ b/pt-br/sass-pt.html.markdown
@@ -56,19 +56,19 @@ body {
 }
 
 
-/ * Este é muito mais fácil de manter do que ter de mudar a cor
-cada vez que aparece em toda a sua folha de estilo. * /
+/* Este é muito mais fácil de manter do que ter de mudar a cor
+cada vez que aparece em toda a sua folha de estilo. */
 
 
 
 
-/*Mixins
+/* Mixins
 ==============================*/
 
 
 
-/* Se você achar que você está escrevendo o mesmo código para mais de um
-elemento, você pode querer armazenar esse código em um mixin.
+/* Se você achar que está escrevendo o mesmo código para mais de um
+elemento, você pode armazenar esse código em um mixin.
 
 Use a diretiva '@mixin', além de um nome para o seu mixin. */
 
@@ -87,7 +87,7 @@ div {
 	background-color: $primary-color;
 }
 
-/* Apoś compilar ficaria assim: */
+/* Após compilar ficaria assim: */
 div {
 	display: block;
 	margin-left: auto;
@@ -128,7 +128,7 @@ div {
 
 
 
-/*Funções
+/* Funções
 ==============================*/
 
 
@@ -138,6 +138,7 @@ div {
 
 /* Funções pode ser chamado usando seu nome e passando o
     argumentos necessários */
+    
 body {
   width: round(10.25px);
 }
@@ -156,14 +157,14 @@ body {
   background-color: rgba(0, 0, 0, 0.75);
 }
 
-/* Você também pode definir suas próprias funções. As funções são muito semelhantes aos
-   mixins. Ao tentar escolher entre uma função ou um mixin, lembre-
-   que mixins são os melhores para gerar CSS enquanto as funções são melhores para
-   lógica que pode ser usado em todo o seu código Sass. Os exemplos
-   seção Operadores Math 'são candidatos ideais para se tornar um reutilizável
-   função. */
+/* Você também pode definir suas próprias funções. As funções são muito semelhantes 
+   aos mixins. Ao tentar escolher entre uma função ou um mixin, lembre
+   que mixins são os melhores para gerar CSS enquanto as funções são melhores para
+   lógica que pode ser usado em todo o seu código Sass. Os exemplos na 
+   seção "Operações Math" são candidatos ideais para se tornar um função 
+   reutilizável. */
 
-/* Esta função terá um tamanho de destino eo tamanho do pai e calcular
+/* Esta função terá um tamanho de destino e o tamanho do pai (parent), calcular
    e voltar a percentagem */
 
 @function calculate-percentage($target-size, $parent-size) {
@@ -220,21 +221,21 @@ $main-content: calculate-percentage(600px, 960px);
   border-color: #22df56;
 }
 
-/* Ampliando uma declaração CSS é preferível a criação de um mixin
-   por causa da maneira agrupa as classes que todos compartilham
+/* Ao ampliar uma declaração CSS é preferível a criação de um mixin,
+   por causa da maneira em que agrupa as classes com todos que compartilham
    o mesmo estilo base. Se isso for feito com um mixin, a largura,
    altura, e a borda seria duplicado para cada instrução que
    o chamado mixin. Enquanto isso não irá afetar o seu fluxo de trabalho, será
-   adicionar inchaço desnecessário para os arquivos criados pelo compilador Sass. */
+   adicionado inchaço desnecessário para os arquivos criados pelo compilador Sass. */
 
 
 
-/*Assentamento
+/* Assentamento
 ==============================*/
 
 
 
-/ * Sass permite seletores ninhos dentro seletores * /
+/* Sass permite seletores ninhos dentro seletores */
 
 ul {
 	list-style-type: none;
@@ -245,7 +246,7 @@ ul {
 	}
 }
 
-/* '&' será substituído pelo selector pai. */
+/* '&' será substituído pelo selector pai (parent). */
 /* Você também pode aninhar pseudo-classes. */
 /* Tenha em mente que o excesso de nidificação vai fazer seu código menos sustentável.
 Essas práticas também recomendam não vai mais de 3 níveis de profundidade quando nidificação.
@@ -290,7 +291,7 @@ ul li a {
 
 
 
-/*Parciais e Importações
+/* Parciais e Importações
 ==============================*/
 
 
@@ -313,7 +314,7 @@ ol {
 /* Sass oferece @import que pode ser usado para importar parciais em um arquivo.
    Isso difere da declaração CSS @import tradicional, que faz
    outra solicitação HTTP para buscar o arquivo importado. Sass converte os
-   importadas arquivo e combina com o código compilado. */
+   arquivo importados e combina com o código compilado. */
 
 @import 'reset';
 
@@ -322,7 +323,7 @@ body {
   font-family: Helvetica, Arial, Sans-serif;
 }
 
-/* Compiles to: */
+/* Compila para: */
 
 html, body, ul, ol {
   margin: 0;
@@ -336,14 +337,14 @@ body {
 
 
 
-/*Placeholder Selectors
+/* Placeholder Selectors
 ==============================*/  
 
 
-/* Os espaços reservados são úteis na criação de uma declaração CSS para ampliar. Se você
-   queria criar uma instrução CSS que foi usado exclusivamente com @extend,
-   Você pode fazer isso usando um espaço reservado. Espaços reservados começar com um '%' em vez
-   de '.' ou '#'. Espaços reservados não aparece no CSS compilado. * /
+/* Os Placeholders são úteis na criação de uma declaração CSS para ampliar. Se você
+   deseja criar uma instrução CSS que foi usado exclusivamente com @extend,
+   você pode fazer isso usando um Placeholder. Placeholder começar com um '%' em vez
+   de '.' ou '#'. Placeholder não aparece no CSS compilado. */
 
 %content-window {
   font-size: 14px;
@@ -372,14 +373,14 @@ body {
 
 
 
-/*Operações Math
-============================== * /
+/* Operações Math
+============================== */
 
 
 /* Sass fornece os seguintes operadores: +, -, *, /, e %. estes podem
-   ser úteis para calcular os valores diretamente no seu Sass arquivos em vez
-   de usar valores que você já calculados pela mão. Abaixo está um exemplo
-   de uma criação de um projeto simples de duas colunas. * /
+   ser úteis para calcular os valores diretamente no seu arquivos Sass em vez
+   de usar valores que você já calculados manualmente. O exemplo abaixo é
+   de um projeto simples de duas colunas. */
 
 $content-area: 960px;
 $main-content: 600px;
diff --git a/pt-br/self-pt.html.markdown b/pt-br/self-pt.html.markdown
index 2fb2953b..eb821474 100644
--- a/pt-br/self-pt.html.markdown
+++ b/pt-br/self-pt.html.markdown
@@ -147,7 +147,7 @@ o objeto '10' no slot 'x' e retornará o objeto original"
 
 # Protótipos
 
-Não existem classes em Self. A maneira de obter um objeto é encontrar um protótipo e copia-lo.
+Não existem classes em Self. A maneira de obter um objeto é encontrar um protótipo e copiá-lo.
 
 ```
 | d |
diff --git a/pt-br/stylus-pt.html.markdown b/pt-br/stylus-pt.html.markdown
index 804fa806..40c3c02c 100755
--- a/pt-br/stylus-pt.html.markdown
+++ b/pt-br/stylus-pt.html.markdown
@@ -132,7 +132,7 @@ body {
   background-color: $primary-color
 }
 
-/* Apoś compilar ficaria assim: */
+/* Após compilar ficaria assim: */
 div {
 	display: block;
 	margin-left: auto;
@@ -184,13 +184,13 @@ button
 /* Funções
 ==============================*/
 
-/* Funções no Stylus permitem fazer uma variedade de tarefas, como por exemplo, menipular algum dado. */
+/* Funções no Stylus permitem fazer uma variedade de tarefas, como por exemplo, manipular algum dado. */
 
 body {
   background darken(#0088DD, 50%) // Escurece a cor #0088DD em 50%
 }
 
-/** Criando sua própria função */
+/* Criando sua própria função */
 somar(a, b)
   a + b
 
@@ -221,7 +221,7 @@ for <val-name> [, <key-name>] in <expression>
 
 for $item in (1..2) /* Repete o bloco 12 vezes */
   .col-{$item}
-    width ($item / 12) * 100% /* Calcula a largula pelo número da coluna*
+    width ($item / 12) * 100% /* Calcula a largura pelo número da coluna*
 
 ```
 
diff --git a/pt-br/typescript-pt.html.markdown b/pt-br/typescript-pt.html.markdown
index 077aa2cc..ed76959c 100644
--- a/pt-br/typescript-pt.html.markdown
+++ b/pt-br/typescript-pt.html.markdown
@@ -10,11 +10,11 @@ lang: pt-br
 
 Typescript é uma linguagem que visa facilitar o desenvolvimento de aplicações em grande escala escritos em JavaScript.
 Typescript acrescenta conceitos comuns como classes, módulos, interfaces, genéricos e (opcional) tipagem estática para JavaScript.
-É um super conjunto de JavaScript: todo o código JavaScript é o código do texto dactilografado válido para que possa ser adicionados diretamente a qualquer projeto. O compilador emite typescript JavaScript.
+É um super conjunto de JavaScript: todo o código JavaScript é TypeScript válido então ele pode ser adicionado diretamente a qualquer projeto. O compilador emite TypeScript JavaScript.
 
-Este artigo irá se concentrar apenas em texto datilografado sintaxe extra, ao contrário de [JavaScript](javascript-pt.html.markdown).
+Este artigo irá se concentrar apenas na sintaxe extra do TypeScript, ao contrário de [JavaScript](javascript-pt.html.markdown).
 
-Para testar compilador do texto datilografado, de cabeça para o [Parque](http://www.typescriptlang.org/Playground), onde você vai ser capaz de escrever código, ter auto conclusão e ver diretamente o JavaScript emitida.
+Para testar o compilador TypeScript, vá para o [Playground](http://www.typescriptlang.org/Playground), onde você vai ser capaz de escrever código, ter auto conclusão e ver diretamente o JavaScript emitido.
 
 ```js
 // Existem 3 tipos básicos no TypeScript
@@ -22,7 +22,7 @@ var isDone: boolean = false;
 var lines: number = 42;
 var name: string = "Anders";
 
-// Quando é impossível saber, há o "Qualquer" tipo
+// Quando é impossível saber, há o tipo "Qualquer"
 var notSure: any = 4;
 notSure = "maybe a string instead";
 notSure = false; // Ok, definitivamente um boolean
@@ -44,13 +44,13 @@ function bigHorribleAlert(): void {
 // Funções são cidadãos de primeira classe, apoiar a sintaxe lambda "seta gordura" e
 // Tipo de uso inferência
 
-// A seguir são equivalentes, a mesma assinatura será inferido pelo
-// Compilador, e mesmo JavaScript será emitido
+// A seguir são equivalentes, a mesma assinatura será inferida pelo
+// Compilador, e o mesmo JavaScript será emitido
 var f1 = function(i: number): number { return i * i; }
-// Tipo de retorno inferida
+// Tipo de retorno inferido
 var f2 = function(i: number) { return i * i; }
 var f3 = (i: number): number => { return i * i; }
-// Tipo de retorno inferida
+// Tipo de retorno inferido
 var f4 = (i: number) => { return i * i; }
 // Tipo de retorno inferido, one-liner significa nenhuma palavra-chave retorno necessário
 var f5 = (i: number) =>  i * i;
@@ -65,7 +65,7 @@ interface Person {
   move(): void;
 }
 
-// Objeto que implementa a "Pessoa" Interface
+// Objeto que implementa a Interface "Pessoa"
 // Pode ser tratado como uma pessoa desde que tem o nome e mover propriedades
 var p: Person = { name: "Bobby", move: () => {} };
 // Os objetos que têm a propriedade opcional:
@@ -88,7 +88,7 @@ class Point {
   // Propriedades
     x: number;
 
-    // Construtor - the public/private keywords in this context will generate
+    // Construtor - as palavras-chave public/private nesse contexto irão gerar
     // o código clichê para a propriedade e a inicialização no
     // construtor.
     // Neste exemplo, "y" será definida como "X" é, mas com menos código
diff --git a/pt-br/vim-pt.html.markdown b/pt-br/vim-pt.html.markdown
index d7617bbe..cc304381 100644
--- a/pt-br/vim-pt.html.markdown
+++ b/pt-br/vim-pt.html.markdown
@@ -5,6 +5,7 @@ contributors:
     - ["RadhikaG", "https://github.com/RadhikaG"]
 translators:
     - ["David Lima", "https://github.com/davelima"]
+    - ["Raul Almeida", "https://github.com/almeidaraul"]
 lang: pt-br
 filename: LearnVim-pt.txt
 ---
@@ -24,6 +25,7 @@ para agilizar a navegação para pontos específicos no arquivo, além de ediç�
     :w               # Salva o arquivo atual
     :wq              # Salva o arquivo e fecha o vim
     :q!              # Fecha o vim e descarta as alterações no arquivo
+                     # ! depois de qualquer comando força a sua execução
                      # ! *força* :q a executar, fechando o vim sem salvar antes
     :x               # Salva o arquivo e fecha o vim (atalho para :wq)
 
@@ -158,7 +160,15 @@ Alguns exemplos importantes de 'Verbos', 'Modificadores' e 'Nomes':
     :earlier 15m     # Reverte o documento para como ele estava há 15 minutos atrás
     :later 15m       # Reverte o comando acima
     ddp              # Troca linhas consecutivas de posição, dd e depois p
+    xp               # Permuta caractere atual e o seguinte
+    Xp               # Permuta caractere atual e o anterior
     .                # Repete a última ação
+
+    # Em geral, o usuário pode associar um comando em maísculas (exemplo: D) com
+    # "executar este comando até o final da linha"
+
+    # Usar a tecla de um comando duas vezes geralmente significa executar este 
+    # comando sobre toda a linha (exemplo: dd apaga a linha inteira)
 ```
 
 ## Macros
@@ -172,6 +182,7 @@ exatamente a mesma sequencia de ações e comandos na seleção atual.
     qa               # Inicia a gravação de uma macro chamado 'a'
     q                # Para a gravação
     @a               # Executa a macro
+    @@               # Executa a última macro executada
 ```
 
 ### Configurando o ~/.vimrc
diff --git a/pt-br/whip-pt.html.markdown b/pt-br/whip-pt.html.markdown
index 7bdeec25..b11faf28 100644
--- a/pt-br/whip-pt.html.markdown
+++ b/pt-br/whip-pt.html.markdown
@@ -71,7 +71,7 @@ false
 (= 1 1) ; => true
 (equal 2 1) ; => false
 
-; Por exemplo, inigualdade pode ser verificada combinando as funções
+; Por exemplo, desigualdade pode ser verificada combinando as funções
 ;`not` e `equal`.
 (! (= 2 1)) ; => true
 
diff --git a/pt-br/yaml-pt.html.markdown b/pt-br/yaml-pt.html.markdown
index 0b71877e..21e9b4bb 100644
--- a/pt-br/yaml-pt.html.markdown
+++ b/pt-br/yaml-pt.html.markdown
@@ -1,7 +1,7 @@
 ---
 language: yaml
 contributors:
-  - ["Adam Brenecki", "https://github.com/adambrenecki"]
+  - ["Leigh Brenecki", "https://github.com/adambrenecki"]
 translators:
   - ["Rodrigo Russo", "https://github.com/rodrigozrusso"]
 filename: learnyaml-pt.yaml
@@ -11,10 +11,10 @@ lang: pt-br
 YAML é uma linguagem de serialização de dados projetado para ser diretamente gravável e
 legível por seres humanos.
 
-É um superconjunto de JSON, com a adição de indentação e quebras de linhas sintaticamente significativas, como Python. Ao contrário de Python, entretanto, YAML não permite o caracter literal tab para identação.
+É um superconjunto de JSON, com a adição de identação e quebras de linhas sintaticamente significativas, como Python. Ao contrário de Python, entretanto, YAML não permite o caracter literal tab para identação.
 
 ```yaml
-# Commentários em YAML são como este.
+# Comentários em YAML são como este.
 
 ###################
 # TIPOS ESCALARES #
@@ -33,7 +33,7 @@ chave com espaco: valor
 porem: "Uma string, entre aspas."
 "Chaves podem estar entre aspas tambem.": "É útil se você quiser colocar um ':' na sua chave."
 
-# Seqüências de várias linhas podem ser escritos como um 'bloco literal' (utilizando |),
+# Seqüências de várias linhas podem ser escritas como um 'bloco literal' (utilizando |),
 # ou em um 'bloco compacto' (utilizando '>').
 bloco_literal: |
     Todo esse bloco de texto será o valor da chave 'bloco_literal',
@@ -76,7 +76,7 @@ um_mapa_aninhado:
 # também permite tipos de coleção de chaves, mas muitas linguagens de programação
 # vão reclamar.
 
-# Sequências (equivalente a listas ou arrays) semelhante à isso:
+# Sequências (equivalente a listas ou arrays) semelhante a isso:
 uma_sequencia:
     - Item 1
     - Item 2
@@ -118,7 +118,7 @@ datetime: 2001-12-15T02: 59: 43.1Z
 datetime_com_espacos 2001/12/14: 21: 59: 43.10 -5
 Data: 2002/12/14
 
-# A tag !!binary indica que a string é na verdade um base64-encoded (condificado)
+# A tag !!binary indica que a string é na verdade um base64-encoded (codificado)
 # representação de um blob binário.
 gif_file: !!binary |
     R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5