56 files changed, 1579 insertions, 471 deletions

diff --git a/pt-br/amd-pt.html.markdown b/pt-br/amd-pt.html.markdown
index 40c7cd09..886cb253 100644
--- a/pt-br/amd-pt.html.markdown
+++ b/pt-br/amd-pt.html.markdown
@@ -19,6 +19,7 @@ módulos de forma síncrona fica sujeito a problemas de performance, usabilidade
 debugging e problemas de acesso em requisições cross-domain.
 
 ### Conceito básico
+
 ```javascript
 // O básico da API de AMD consiste de nada mais que dois métodos: `define` e `require`
 // e isso é tudo sobre a definição de módulo e consumo:
@@ -122,6 +123,7 @@ define(['daos/coisas', 'modules/algunsHelpers'], function(coisasDao, helpers){
   return AlgumaClasse;
 });
 ```
+
 Para alterar o comportamento padrão de mapeamento de caminho de pastas utilize
 `requirejs.config(configObj)` em seu `main.js`:
 
@@ -141,6 +143,7 @@ require(['jquery', 'coolLibFromBower', 'modules/algunsHelpers'], function($, coo
   coolLib.facaAlgoDoidoCom(helpers.transform($('#foo')));
 });
 ```
+
 Apps baseados em `require.js` geralmente terão um único ponto de acesso (`main.js`) que é passado à tag script do `require.js` como um data-attribute. Ele vai ser automaticamente carregado e executado com o carregamento da página:
 
 ```html
@@ -162,16 +165,19 @@ Muitas pessoas preferem usar AMD para sanar a organização do código durante o
 `require.js` vem com um script chamado `r.js` (que você vai provavelmente rodar em node.js, embora Rhino suporte também) que você pode analisar o gráfico de dependências de seu projeto, e fazer em um único arquivo contendo todos os seus módulos (corretamente nomeados), minificados e prontos para serem consumidos.
 
 Instale-o utilizando `npm`:
+
 ```shell
 $ npm install requirejs -g
 ```
 
 Agora você pode alimentá-lo com um arquivo de configuração:
+
 ```shell
 $ r.js -o app.build.js
 ```
 
 Para o nosso exemplo acima a configuração pode ser essa:
+
 ```javascript
 /* file : app.build.js */
 ({
@@ -188,6 +194,7 @@ Para o nosso exemplo acima a configuração pode ser essa:
 ```
 
 Para usar o arquivo gerado, em produção, simplesmente troque o `data-main`:
+
 ```html
 <script src="require.js" data-main="app/main-built"></script>
 ```
diff --git a/pt-br/asciidoc-pt.html.markdown b/pt-br/asciidoc-pt.html.markdown
index b12c0693..17b6baaa 100644
--- a/pt-br/asciidoc-pt.html.markdown
+++ b/pt-br/asciidoc-pt.html.markdown
@@ -5,7 +5,7 @@ contributors:
 translators:
     - ["David Lima", "https://github.com/davelima"]
 lang: pt-br
-filename: asciidoc-pt.md
+filename: asciidoc-pt.adoc
 ---
 
 AsciiDoc é uma linguagem de marcação similar ao Markdown e pode ser
@@ -86,7 +86,6 @@ Título de seções
 ==== Nível 3 <h4>
 
 ===== Nível 4 <h5>
-
 ```
 
 Listas
diff --git a/pt-br/asymptotic-notation-pt.html.markdown b/pt-br/asymptotic-notation-pt.html.markdown
index b70d26b7..e7dc1b20 100644
--- a/pt-br/asymptotic-notation-pt.html.markdown
+++ b/pt-br/asymptotic-notation-pt.html.markdown
@@ -62,6 +62,7 @@ Função Quadrática - an^2 + bn + c
 Função Polinomial - an^z + . . . + an^2 + a*n^1 + a*n^0, onde *z* é uma constante
 Função Exponencial -  a^n, onde a é alguma constante
 ```
+
 Estas são as funções básicas de crescimento usadas em várias notações. A lista
  começa com a de crescimento mais lento (logarítmica, a de execução mais rápida)
 e segue para a de crescimento mais rápido (exponencial, de execução mais lenta).
diff --git a/pt-br/awk-pt.html.markdown b/pt-br/awk-pt.html.markdown
index 597b0e7a..d54081a3 100644
--- a/pt-br/awk-pt.html.markdown
+++ b/pt-br/awk-pt.html.markdown
@@ -202,7 +202,7 @@ function string_functions(    localvar, arr) {
     # Ambas retornam o número de instâncias substituídas
     localvar = "fooooobar"
     sub("fo+", "Meet me at the ", localvar) # localvar => "Meet me at the bar"
-    gsub("e", ".", localvar) # localvar => "m..t m. at th. bar"
+    gsub("e", ".", localvar) # localvar => "M..t m. at th. bar"
 
     # Localiza um texto que casa com uma expressão regular
     # index() faz a mesma coisa, mas não permite uma expressão regular
@@ -368,7 +368,6 @@ END {
     if (nlines)
         print "A média da idade para " name " é " sum / nlines
 }
-
 ```
 
 Leituras adicionais (em inglês):
diff --git a/pt-br/bc-pt.html.markdown b/pt-br/bc-pt.html.markdown
new file mode 100644
index 00000000..f3f25601
--- /dev/null
+++ b/pt-br/bc-pt.html.markdown
@@ -0,0 +1,105 @@
+---
+language: bc
+contributors:
+    - ["Btup"]
+translators:
+    - ["David Lima", "https://github.com/davelima"]
+lang: pt-br
+filename: learnbc-pt.bc
+---
+```c
+/*Este é um comentário
+multi-linhas*/
+# Este é um comentário de uma única linha! (em bc GNU).
+
+    /*1. Variáveis e estruturas de controle*/
+num = 45 /*Todas as variáveis apenas salvam dados do tipo double, e
+    você não pode salvar strings diretamente em constantes.*/
+num 45; /*Você pode adicionar ponto-e-vírgula após cada linha.
+    Isto é opcional*/
+/*Blocos são denotados usando os operadores {} (similar ao C):*/
+while(num < 50) {
+    num += 1 /*equivalente a num=num+1.
+    a = a op b é equivalente a a op= b.*/
+}
+/*E existem os operadores ++ (incrementar) e -- (decrementar).*/
+/* Existem 3 tipos especiais de variáveis:
+scale: define a escala de números double.
+ibase: define a base de da entrada.
+obase: define a base da saída.
+*/
+/*Cláusulas If:*/
+hora = read() /*Lê a entrada de um número*/
+
+if(hora < 12) { /*Os operadores são idênticos ao C.*/
+    print "Bom dia\n" /*"print" imprime strings ou variáveis
+	separados por vírgula (,).*/
+} else if(hora == 12) {
+    print "Olá\n"
+    /*Para escapar strings, inicie a string com \.
+    Para deixar o escape de strings mais claros,
+    aqui está uma lista simplificada das strings escapadas
+    que funcionarão com bc:
+    \b: backspace
+    \c: carriage return (enter)
+    \n: newline (nova linha)
+    \t: tab
+    \\: backslash (barra inertida)*/
+} else {
+    /*Variáveis são globais por padrão.*/
+    istoEGlobal = 5
+    /*Para tornar uma variável local, use a palavra-chave "auto" em uma função.*/
+}
+
+/*Todas as variáveis por padrão tem o valor 0*/
+num = variavelEmBranco /*num é igual a 0.*/
+
+/*Assim como no C, "0" é considerado "false"*/
+if(!num) {print "false\n"}
+
+/*Diferente do C, bc não tem o operador ?:. Por exemplo,
+este bloco de código causaria um erro:
+a = (num) ? 1 : 0
+Entretanto, você pode simular da seguinte forma:
+a = (num) && (1) || (0) /*&& é "E", || é "OU"*/
+*/
+
+/*Loops For*/
+num = 0
+for(i = 1; i <= 100; i++) {/*Similar ao loop For do C.*/
+    num += i
+}
+
+    /*2.Funções e arrays*/
+define fac(n) { /*para definir uma função, use "define".*/
+    if(n == 1 || n == 0) {
+        return 1 /*retorna um valor*/
+    }
+    return n * fac(n - 1) /*recursão é permitido*/
+}
+
+/*Closures e funções anônimas não são permitidas*/
+
+num = fac(4) /*24*/
+
+/*Exemplo de variáveis locais:*/
+define x(n) {
+    auto x
+    x = 1
+    return n + x
+}
+x(3) /*4*/
+print x /*A variável "x" não será acessível de fora da função*/
+/*Arrays são equivalentes aos arrays em C.*/
+for(i = 0; i <= 3; i++) {
+    a[i] = 1
+}
+/*Para acessar um array, faça assim:*/
+print a[0], " ", a[1], " ", a[2], " ", a[3], "\n"
+quit /*Adicione essa linha no final do código
+para garantir que o programa encerre. Essa linha é opcional.*/ 
+```
+
+Aproveite bem essa simples calculadora! (Ou essa linguagem de programação, para ser exato.)
+
+Este programa inteiro foi escrito em GNU bc. Para rodá-lo, use ```bc learnbc-pt.bc```
diff --git a/pt-br/binary-search-pt.html.markdown b/pt-br/binary-search-pt.html.markdown
index d3060506..9b08601c 100644
--- a/pt-br/binary-search-pt.html.markdown
+++ b/pt-br/binary-search-pt.html.markdown
@@ -32,8 +32,8 @@ elementos, retornar -1.
 Busca Linear: O (n)               Tempo Linear
 
 Busca Binária: O ( log(n) )		   Tempo Logarítmico
-
 ```
+
 ```
 def busca(arr, x):
  
@@ -43,8 +43,8 @@ def busca(arr, x):
             return i
  
     return -1
-
 ```
+
 ## Algoritmo de Busca Binária
 
 O pré-requisito básico para que uma busca binária funcione é que os dados que se
@@ -64,7 +64,6 @@ direito do elemento do meio. Portanto nós pulamos para a metade direita.
 4) Senão (x é menor) pulamos para a metade esquerda.
 
 Essa é a ideia da implementação recursiva da busca binária.
-
 ```
 
 ### Considerações Finais
diff --git a/pt-br/c++-pt.html.markdown b/pt-br/c++-pt.html.markdown
index 7d8b75f1..dec5866e 100644
--- a/pt-br/c++-pt.html.markdown
+++ b/pt-br/c++-pt.html.markdown
@@ -363,7 +363,7 @@ void OwnedDog::print() const
 {
     Dog::print(); // Chame a função de impressão na classe Dog base de
     std::cout << "Dog is owned by " << owner << "\n";
-    // Prints "Dog is <name> and weights <weight>"
+    // Imprime "Dog is <name> and weights <weight>"
     //        "Dog is owned by <owner>"
 }
 
@@ -607,6 +607,7 @@ h=sum<double>(f,g);
 
 // Deste modo, não precisamos fazer overload nas funções! (:
 ```
+
 Leitura Adicional:
 
 * Uma referência atualizada da linguagem pode ser encontrada em [CPP Reference](http://cppreference.com/w/cpp).
diff --git a/pt-br/c-pt.html.markdown b/pt-br/c-pt.html.markdown
index c3f62bc6..72877e84 100644
--- a/pt-br/c-pt.html.markdown
+++ b/pt-br/c-pt.html.markdown
@@ -384,7 +384,6 @@ int main() {
 	// Por exemplo, quando um array é passado para uma função ou é atribuído a um
 	// ponteiro, ele transforma-se (convertido implicitamente) em um ponteiro.
 	// Exceções: quando o array é o argumento de um operador `&` (endereço-de):
-    // Exceptions: when the array is the argument of the `&` (address-of) operator:
     int arr[10];
     int (*ptr_to_arr)[10] = &arr; // &arr não é do tipo `int *`!
                                   // É do tipo "ponteiro para array" (de `int`s).
@@ -632,7 +631,6 @@ typedef void (*minha_função_type)(char *);
 // = += -= *= /= %= &= ^= |= <<= >>= | direita para esqureda //
 // ,                                 | esquerda para direita //
 //-----------------------------------------------------------//
-
 ```
 
 ## Leitura adicional
diff --git a/pt-br/clojure-macros-pt.html.markdown b/pt-br/clojure-macros-pt.html.markdown
index c686bb80..1db3fdea 100644
--- a/pt-br/clojure-macros-pt.html.markdown
+++ b/pt-br/clojure-macros-pt.html.markdown
@@ -141,7 +141,6 @@ Você vai querer estar familiarizado com Clojure. Certifique-se de entender tudo
 
 (inline-2 (1 + (3 / 2) - (1 / 2) + 1))
 ; -> 3 (Na verdade, 3N, desde que o numero ficou convertido em uma fração racional com /
-
 ```
 
 ### Leitura adicional
diff --git a/pt-br/common-lisp-pt.html.markdown b/pt-br/common-lisp-pt.html.markdown
index c22cfd8e..b0755bc7 100644
--- a/pt-br/common-lisp-pt.html.markdown
+++ b/pt-br/common-lisp-pt.html.markdown
@@ -20,7 +20,6 @@ Outro livro recente e popular é o
 
 
 ```lisp
-
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;; 0. Sintaxe
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown
index 87e5b3a4..d464a639 100644
--- a/pt-br/csharp-pt.html.markdown
+++ b/pt-br/csharp-pt.html.markdown
@@ -252,7 +252,7 @@ on a new line! ""Wow!"", the masses cried";
             {
                 // Inicia a interação 100 vezes, fooDoWhile 0->99
                 if (false)
-                    continue; // pule a intereção atual para apróxima
+                    continue; // pule a intereção atual para a próxima
 
                 fooDoWhile++;
 
@@ -269,7 +269,7 @@ on a new line! ""Wow!"", the masses cried";
 
             // For Each Loop
             // Estrutura do foreach  => foreach(<Tipo Iterador> <Nome do Iterador> in <enumerable>)
-            // O laço foreach  percorre sobre qualquer objeto que implementa IEnumerable ou IEnumerable<T>
+            // O laço foreach percorre sobre qualquer objeto que implementa IEnumerable ou IEnumerable<T>
             // Toda a coleção de tipos  (Array, List, Dictionary...) no .Net framework
             // implementa uma ou mais destas interfaces.
             // (O ToCharArray() pode ser removido, por que uma string também implementa IEnumerable)
diff --git a/pt-br/css-pt.html.markdown b/pt-br/css-pt.html.markdown
index e4f55276..4c52942a 100644
--- a/pt-br/css-pt.html.markdown
+++ b/pt-br/css-pt.html.markdown
@@ -8,33 +8,36 @@ contributors:
     - ["Connor Shea", "https://github.com/connorshea"]
     - ["Deepanshu Utkarsh", "https://github.com/duci9y"]
 translators:
+    - ["Adaías Magdiel", "https://adaiasmagdiel.com/"]
     - ["Gabriel Gomes", "https://github.com/gabrielgomesferraz"]
     - ["Gabriele Luz", "https://github.com/gabrieleluz"]
-
 lang: pt-br
 ---
 
-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 visual de uma página web.
+Páginas web são feitas utilizando HTML para demarcar o conteúdo.
+O CSS (Cascading Style Sheets) é uma linguagem separada que é responsável
+especificamente pela **aparência** da página.
 
-CSS permite atingir diferentes elementos em uma página HTML e atribuir diferentes propriedades visuais para eles.
+Códigos CSS são construídos utilizando várias regras estáticas. Cada regra aceita um ou mais *seletores*
+e aplica *valores* específicos de propriedades visuais. Essas propriedades são aplicadas
+nos elementos da página indicados pelos seletores.
 
-Este guia foi escrito para CSS2, embora CSS3 esteja rapidamente se tornando popular.
+Este guia foi escrito com o CSS 2 em mente, complementado pelas novas
+funcionalidades do CSS 3.
 
-**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.
+**NOTA:** Devido ao fato do CSS produzir resultados visuais, a fim de aprender, você precisa treinar em um playground CSS como [dabblet](http://dabblet.com/).
+O foco principal deste artigo é a sintaxe e algumas dicas gerais.
 
 ```css
-/* Comentários aparecem dentro do slash-asterisk, tal como esta linha!
-   Não há "comentários de uma linha"; este é o único estilo de comentário * /
+/* Comentários aparecem dentro de blocos com / e *, tal como esta linha!
+   Não há "comentários de uma linha"; este é o único estilo de comentário. * /
 
 /* ####################
    ## SELETORES
    #################### */
 
-/* O seletor é usado para direcionar um elemento em uma página.
-   seletor { propriedade: valor; / * Mais propriedades ... * / }
+/* O seletor é usado para selecionar um elemento em uma página. */
+seletor { propriedade: valor; /* Mais propriedades... */ }
 
 /*
 Abaixo um elemento de exemplo:
@@ -42,63 +45,62 @@ Abaixo um elemento de exemplo:
 <div class='class1 class2' id='anID' attr='value' otherAttr='pt-br foo bar' />
 */
 
-/* Você pode direcioná-lo usando uma das suas classes CSS */
+/* Você pode seleciona-lo usando uma das suas classes CSS */
 .class1 { }
 
-/* ou ambas as classes! */
+/* Ou ambas as classes! */
 .class1.class2 { }
 
-/* ou o seu nome */
+/* Ou o seu nome */
 div { }
 
-/* ou o seu id */
+/* Ou o seu id */
 #anID { }
 
-/* ou utilizando o fator de que tem um atributo!*/
-[attr] { font-size:smaller; }
+/* Ou através de um dos seus atributos! */
+[attr] { font-size: smaller; }
 
-/* ou que o atributo tem um valor específico */
-[attr='value'] { font-size:smaller; }
+/* Ou utilizando um atributo com um valor específico */
+[attr='value'] { font-size: smaller; }
 
-/* começa com um valor (CSS 3) */
+/* Um atributo que começa com um valor (CSS 3) */
 [attr^='val'] { font-size:smaller; }
 
-/* ou terminando com um valor (CSS 3) */
-[attr$='ue'] { font-size:smaller; }
-
+/* Ou termina com um valor (CSS 3) */
+[attr$='ue'] { font-size: smaller; }
 
 /* Ou contém um valor em uma lista separada por espaços */
-[otherAttr ~ = 'foo'] {}
-[otherAttr ~ = 'bar'] {}
+[otherAttr~='foo'] {}
+[otherAttr~='bar'] {}
 
 /* Ou contém um valor em uma lista separada por hífen, ou seja, "-" (U + 002D) */
-[otherAttr | = 'en'] {font-size: smaller; }
+[otherAttr|='pt'] {font-size: smaller; }
 
 
-/* Você pode concatenar diferentes seletores para criar um seletor mais estreito. Não
-   colocar espaços entre eles. */
-classe div.some [attr $ = 'ue'] {}
+/* Você pode combinar diferentes seletores para criar um seletor mais específica. Lembre-se
+   de não colocar espaço entre eles */
+div.some-class[attr$='ue'] {}
 
-/* Você pode selecionar um elemento que é filho de outro elemento */
-div.some-parent> .class-name {}
+/* Você pode selecionar um elemento que está diretamento dentro de outro elemento */
+div.some-parent > .class-name {}
 
-/* 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 {}
+/* Ou um descendente desse elemento. Os filhos são os descendentes diretos de
+  um elemento pai, apenas um nível abaixo. Da seguinte forma, você pode seleciona qualquer
+  elemento que esteja dentro do elemento principal. */
+div.some-parent .class-name {}
 
 /* Atenção: o mesmo seletor sem espaço tem um outro significado.
-   Você consegue adivinhar o que? */
+   Dessa forma você estará selecionando um elemento que contenha as duas classes. */
 div.some-parent.class-name {}
 
-/* Você também pode selecionar um elemento com base em seu irmão adjacente */
-.i am just-antes + .Este elemento {}
+/* Você também pode selecionar um elemento com base em seu irmão mais próximo */
+.i-am-just-before + .this-element {}
 
 /* Ou qualquer irmão que o precede */
-.i am-qualquer-elemento antes ~ .Este elemento {}
+.i-am-any-element-before ~ .this-element { }
 
-/* Existem alguns seletores chamados pseudo classes que podem ser usados para selecionar um
-   elemento quando ele está em um determinado estado */
+/* 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 */
 seletor:hover {}
@@ -112,10 +114,10 @@ seletor:link {}
 /* Ou um elemento em foco */
 seletor:focus {}
 
-/* Qualquer elemento que é o primeiro filho de seu pai */
+/* Qualquer elemento que é o primeiro filho */
 seletor:first-child {}
 
-/* Qualquer elemento que é o último filho de seu pai */
+/* Qualquer elemento que é o último filho */
 seletor:last-child {}
 
 /* Assim como pseudo classes, pseudo elementos permitem que você estilize certas partes de um documento */
@@ -126,88 +128,91 @@ seletor::before {}
 /* Corresponde a um último filho virtual do elemento selecionado */
 seletor::after {}
 
-/* Nos locais apropriados, um asterisco pode ser utilizado como um curinga para selecionar todos
-   os elementos */
-* {} /* */ Todos os elementos
-.parent * {} /* */ todos os descendentes
-.parent> * {} /* */ todos os filhos
+/* Nos locais apropriados, um asterisco pode ser utilizado como um curinga para selecionar
+   todos os elementos */
+
+* {} /* Todos os elementos */
+.parent * {} /* todos os descendentes */
+.parent > * {} /* todos os filhos */
 
 /* ####################
-   ## PROPRIEDADES
-   #################### */
+   ## PROPRIEDADES
+   #################### */
 
 seletor {
-
-    /* Unidades de comprimento pode ser absoluta ou relativa. */
-
-    /* Unidades relativas */
-    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) */
-    font-size: 2vh; /* Ou a sua altura */
-    font-size: 2vmin; /* Qualquer um de VH ou um VW é menor */
-    font-size: 2vmax; /* Ou superior */
-
-    /* Unidades absolutas */
-    width: 200px; /* píxeis */
-    font-size: 20pt; /* Pontos */
-    width: 5cm; /* Centímetros */
-    min-width: 50mm; /* Milímetros */
-    max-width: 5 polegadas; /* Polegadas */
-
-    /* Cores */
-    color: # F6E; /* Formato hexadecimal curto */
-    color: # FF66EE; /* Formato hexadecimal longo */
-    color: tomato; /* Uma cor nomeada */
-    color: rgb (255, 255, 255); /* Como valores rgb */
-    color: RGB (10%, 20%, 50%); /* Como porcentagens rgb */
-    color: rgba (255, 0, 0, 0,3); /* Como valores RGBA (CSS 3) NOTA: 0 <a <1 */
-    color: transparent; /* Equivale a definir o alfa a 0 */
-    color: HSL (0, 100%, 50%); /* Como porcentagens HSL (CSS 3) */
-    color: HSLA (0, 100%, 50%, 0,3); /* Como porcentagens HSLA com alfa */
-
-    /* Imagens como fundos de elementos */
-    background-image: url (/img-path/img.jpg); /* Citações dentro url () opcional */
-
-    /* Fontes */
-    font-family: Arial;
-    /* Se o nome da família de fonte tem um espaço, deve ser citado */
-    font-family: "Courier New";
-    /* Se o primeiro não for encontrada, o navegador usa o próximo, e assim por diante */
-    font-family: "Courier New", Trebuchet, Arial, sans-serif;
+    /* Unidades de comprimento pode ser absoluta ou relativa. */
+
+    /* Unidades relativas */
+    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) */
+    font-size: 2vh; /* Ou a sua altura */
+    font-size: 2vmin; /* Qualquer um de VH ou um VW é menor */
+    font-size: 2vmax; /* Ou superior */
+
+    /* Unidades absolutas */
+    width: 200px; /* Píxeis */
+    font-size: 20pt; /* Pontos */
+    width: 5cm; /* Centímetros */
+    min-width: 50mm; /* Milímetros */
+    max-width: 5 polegadas; /* Polegadas */
+
+    /* Cores */
+    color: #F6E; /* Formato hexadecimal curto */
+    color: #FF66EE; /* Formato hexadecimal longo */
+    color: tomato; /* Uma cor nomeada */
+    color: rgb(255, 255, 255); /* Como valores rgb */
+    color: RGB(10%, 20%, 50%); /* Como porcentagens rgb */
+    color: rgba(255, 0, 0, 0,3); /* Como valores RGBA (CSS 3) NOTA: 0 <a <1 */
+    color: transparent; /* Equivale a definir o alfa a 0 */
+    color: HSL(0, 100%, 50%); /* Como porcentagens HSL (CSS 3) */
+    color: HSLA(0, 100%, 50%, 0,3); /* Como porcentagens HSLA com alfa */
+
+    /* Imagens como fundos de elementos */
+    background-image: url(/img-path/img.jpg); /* O uso das aspas dentro de url() é opcional */
+
+    /* Fontes */
+    font-family: Arial;
+    /* Se o nome da família de fonte tem um espaço, deve estar entre aspas */
+    font-family: "Courier New";
+    /* Se o primeiro não for encontrada, o navegador usa a próxima, e assim por diante */
+    font-family: "Courier New", Trebuchet, Arial, sans-serif;
 }
 ```
 
 ## Uso
 
-Salvar uma folha de estilo CSS com a extensão `.css`.
+Salve o arquivo de estilos CSS com a extensão `.css`.
 
-```xml
-<!-- Você precisa incluir o arquivo css no da sua página <head>. Isto é o
-     método recomendado. Consulte http://stackoverflow.com/questions/8284365 -->
-<link rel='stylesheet' type='text/css' href='path/to/style.css' />
+```html
+<!-- Você precisa incluir o arquivo css dentro da tag <head>. Esse é o
+     método recomendado. Consulte http://stackoverflow.com/questions/8284365 -->
+<link rel="stylesheet" type="text/css" href="path/to/style.css" />
 
-<!-- Você também pode incluir alguns CSS inline na sua marcação. -->
+<!-- Você também pode incluir alguns CSS inline no seu HTML. -->
 <style>
-   a { color: purple; }
+    a { color: purple; }
 </style>
 
-<!-- Ou diretamente definir propriedades CSS no elemento. -->
+<!-- Ou definir propriedades CSS diretamente no elemento. -->
 <div style="border: 1px solid red;">
 </div>
 ```
 
 ## 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 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.
+Um elemento pode ser alvo de vários seletores e pode ter um conjunto de propriedades que
+são adicionados 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.
+Este processo é chamado de cascata, daí vem o nome: Cascading Style Sheets (Folhas de Estilo em Cascata).
 
 Dado o seguinte CSS:
 
 ```css
-/* UMA */
+/* A */
 p.class1[attr="value"]
 
 /* B */
@@ -225,20 +230,22 @@ p { property: value !important; }
 
 e a seguinte marcação:
 
-```xml
+```html
 <p style='/*F*/ property:value;' class='class1 class2' attr='value' />
 ```
 
-A precedência de estilo é a seguinte. Lembre-se, a precedência é para cada  **propriedade**, não para todo o bloco.
+A precedência de estilo é a seguinte: Lembre-se, a precedência se aplica a
+cada **propriedade**, não ao bloco como um todo.
 
-* `E` tem a precedência mais alta por causa de uma palavra-chave`!important`. É recomendável que você evitar seu uso.
-* `F` é a próxima, porque é um estilo interno.
-* `A` é a próxima, porque é mais" específico "do que qualquer outra coisa. Tem 3 especificadores: O nome do elemento `p`, o seu `class1` classe, um atributo `attr='value'`.
-* `C` está próximo, mesmo que ele tenha a mesma especificidade que `B`. Isso é porque ele aparece depois de `B`.
-* `B` é o próximo.
-* `D` é a última.
+* `E` tem a precedência mais alta por causa de uma palavra-chave`!important`. É recomendado evitar seu uso.
+* `F` é o seguinte, porque é um estilo interno.
+* `A` é o seguinte, porque é "mais específico" do que os outros. Tem 3 especificadores: O nome do elemento `p`, a sua classe `class1` e um atributo `attr="value"`.
+* `C` é o seguinte, mesmo que ele tenha a mesma especificidade que `B`. Isso acontece porque ele aparece logo após o `B`.
+* `B` é o seguinte.
+* `D` é o último.
 
 ## Media Queries
+
 Media queries são recursos do CSS3 que permitem especificar quando determinadas regras de CSS devem ser aplicadas; é possível aplicar regras diferentes quando a página é impressa, quando a tela possui determinadas dimensões ou densidade de pixels e quando é lida por um leitor de tela. Media queries não adicionam especificidade ao seletor.
 
 ```css
@@ -265,7 +272,8 @@ h1 {
   }
 }
 ```
-Media queries podem incluir os seguintes atributos: `width`, `height`, `device-width`, `device-height`, `orientation`, `aspect-ratio`, `device-aspect-ratio`, `color`, `color-index`, `monochrome`, `resolution`, `scan`, `grid`. A maioria desses atributos pode ser prefixada com `min-` ou `max-`.
+
+Media queries podem incluir os seguintes atributos: `width`, `height`, `device-width`, `device-height`, `orientation`, `aspect-ratio`, `device-aspect-ratio`, `color`, `color-index`, `monochrome`, `resolution`, `scan` e `grid`. A maioria desses atributos pode ser prefixada com `min-` ou `max-`.
 
 O atributo `resolution` não é suportado em dispositivos mais antigos. Em vez disso, use `device-pixel-ratio`.
 
@@ -279,20 +287,22 @@ 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 verificar antes de usar um novo recurso.
+A maioria dos recursos do CSS 2 (e muitos do CSS 3) está disponível em todos os navegadores
+e dispositivos.
 
-## Recursos
+## Recursos Adicionais
 
 * Para executar uma verificação de compatibilidade rápida, [CanIUse](http://caniuse.com).
 * CSS Playground [Dabblet](http://dabblet.com/).
-* [Documentação CSS Mozilla Developer Rede](https://developer.mozilla.org/en-US/docs/Web/CSS)
-* [Codrops 'Referência CSS](http://tympanus.net/codrops/css_reference/)
+* [Documentação CSS Mozilla Developer](https://developer.mozilla.org/en-US/docs/Web/CSS)
+* [Codrops Referência CSS](http://tympanus.net/codrops/css_reference/)
+* [DevTips CSS Basics](https://www.youtube.com/playlist?list=PLqGj3iMvMa4IOmy04kDxh_hqODMqoeeCy) (Tutorials)
 
 ## Leitura adicional
 
 * [Entendendo Estilo Precedência em CSS: Especificidade, Herança, e o Cascade](http://www.vanseodesign.com/css/css-specificity-inheritance-cascaade/)
 * [Selecionando elementos usando atributos](https://css-tricks.com/almanac/selectors/a/attribute/)
 * [QuirksMode CSS](http://www.quirksmode.org/css/)
-* [Z-Index - O empilhamento context](https://developer.mozilla.org/en-US/docs/Web/Guide/CSS/Understanding_z_index/The_stacking_context)
-* [SASS](http://sass-lang.com/) e [Less](http://lesscss.org/) para CSS pré-processamento
+* [Z-Index - O contexto de empilhamento](https://developer.mozilla.org/en-US/docs/Web/Guide/CSS/Understanding_z_index/The_stacking_context)
+* [SASS](http://sass-lang.com/) e [Less](http://lesscss.org/) para pré-processamento do CSS
 * [CSS-Tricks](https://css-tricks.com)
diff --git a/pt-br/cypher-pt.html.markdown b/pt-br/cypher-pt.html.markdown
index d4400148..713036cd 100644
--- a/pt-br/cypher-pt.html.markdown
+++ b/pt-br/cypher-pt.html.markdown
@@ -94,7 +94,6 @@ path = shortestPath( (user)-[:KNOWS*..5]-(other) )
 
 // Navegação de árvore
 (root)<-[:PARENT*]-(leaf:Category)-[:ITEM]->(data:Product)
-
 ```
 
 
@@ -102,13 +101,16 @@ Crie consultas
 ---
 
 Crie um novo nó
+
 ```
 CREATE (a:Person {name:"Théo Gauchoux"})
 RETURN a
 ```
+
 *`RETURN` permite ter um resultado após a consulta. Pode ser múltiplo, como `RETURN a, b`.*
 
 Crie um novo relacionamento (com 2 novos nós)
+
 ```
 CREATE (a:Person)-[k:KNOWS]-(b:Person)
 RETURN a,k,b
@@ -118,36 +120,42 @@ Consultas que casam
 ---
 
 Casam todos os nós
+
 ```
 MATCH (n)
 RETURN n
 ```
 
 Casam nós por label
+
 ```
 MATCH (a:Person)
 RETURN a
 ```
 
 Casam nós por label e propriedade
+
 ```
 MATCH (a:Person {name:"Théo Gauchoux"})
 RETURN a
 ```
 
 Casam nós de acordo com os relacionamentos (não direcionados)
+
 ```
 MATCH (a)-[:KNOWS]-(b)
 RETURN a,b
 ```
 
 Casam nós de acordo com os relacionamentos (direcionados)
+
 ```
 MATCH (a)-[:MANAGES]->(b)
 RETURN a,b
 ```
 
 Casam nós com um cláusula `WHERE`
+
 ```
 MATCH (p:Person {name:"Théo Gauchoux"})-[s:LIVES_IN]->(city:City)
 WHERE s.since = 2015
@@ -155,6 +163,7 @@ RETURN p,state
 ```
 
 Você pode usa a cláusula `MATCH WHERE` com a cláusula `CREATE`
+
 ```
 MATCH (a), (b)
 WHERE a.name = "Jacquie" AND b.name = "Michel"
@@ -166,6 +175,7 @@ Atualizar consultas
 ---
 
 Atualizar uma propriedade específica de um nó
+
 ```
 MATCH (p:Person)
 WHERE p.name = "Théo Gauchoux"
@@ -173,6 +183,7 @@ SET p.age = 23
 ```
 
 Substituir todas as propriedades de um nó
+
 ```
 MATCH (p:Person)
 WHERE p.name = "Théo Gauchoux"
@@ -180,6 +191,7 @@ SET p = {name: "Michel", age: 23}
 ```
 
 Adicionar nova propriedade a um nó
+
 ```
 MATCH (p:Person)
 WHERE p.name = "Théo Gauchoux"
@@ -187,6 +199,7 @@ SET p + = {studies: "IT Engineering"}
 ```
 
 Adicione um label a um nó
+
 ```
 MATCH (p:Person)
 WHERE p.name = "Théo Gauchoux"
@@ -198,6 +211,7 @@ Excluir consultas
 ---
 
 Excluir um nó específico (os relacionamentos vinculados devem ser excluídos antes)
+
 ```
 MATCH (p:Person)-[relationship]-()
 WHERE p.name = "Théo Gauchoux"
@@ -205,14 +219,17 @@ DELETE relationship, p
 ```
 
 Remover uma propriedade em um nó específico
+
 ```
 MATCH (p:Person)
 WHERE p.name = "Théo Gauchoux"
 REMOVE p.age
 ```
+
 *Prestar atenção à palavra chave `REMOVE`, não é `DELETE` !*
 
 Remover um label de um nó específico
+
 ```
 MATCH (p:Person)
 WHERE p.name = "Théo Gauchoux"
@@ -220,11 +237,13 @@ DELETE p:Person
 ```
 
 Excluir o banco de dados inteiro
+
 ```
 MATCH (n)
 OPTIONAL MATCH (n)-[r]-()
 DELETE n, r
 ```
+
 *Sério, é o `rm -rf /` do Cypher !*
 
 
diff --git a/pt-br/d-pt.html.markdown b/pt-br/d-pt.html.markdown
new file mode 100644
index 00000000..cb664643
--- /dev/null
+++ b/pt-br/d-pt.html.markdown
@@ -0,0 +1,261 @@
+---
+language: D
+filename: learnd-pt.d
+contributors:
+    - ["Nick Papanastasiou", "www.nickpapanastasiou.github.io"]
+translators:
+    - ["Julio Vanzelli", "https://github.com/JulioVanzelli"]
+lang: pt-br
+---
+
+```d
+// Você sabe o que está por vir...
+module hello;
+
+import std.stdio;
+
+// args é opcional
+void main(string[] args) {
+    writeln("Hello, World!");
+}
+```
+
+Se você é como eu e passa muito tempo na Internet, é provável que tenha ouvido
+sobre [D] (http://dlang.org/). A linguagem de programação D é moderna, de uso geral,
+linguagem multiparadigma com suporte para tudo, desde recursos de baixo nível até
+abstrações expressivas de alto nível.
+
+D é desenvolvido ativamente por um grande grupo de pessoas super-inteligentes e é liderado por
+[Walter Bright] (https://en.wikipedia.org/wiki/Walter_Bright) e
+[Andrei Alexandrescu] (https://en.wikipedia.org/wiki/Andrei_Alexandrescu).
+Com tudo isso fora do caminho, vamos dar uma olhada em alguns exemplos!
+
+```d
+import std.stdio;
+
+void main() {
+
+    // Condicionais e loops funcionam como esperado.
+    for(int i = 0; i < 10000; i++) {
+        writeln(i);
+    }
+
+    // 'auto' pode ser usado para inferir tipos.
+    auto n = 1;
+
+    // literais numéricos podem usar '_' como um separador de dígitos para maior clareza.
+    while(n < 10_000) {
+        n += n;
+    }
+
+    do {
+        n -= (n / 2);
+    } while(n > 0);
+
+    // Por e enquanto são bons, mas em D-land preferimos loops 'foreach'.
+    // O '..' cria um intervalo contínuo, incluindo o primeiro valor
+    // mas excluindo o último.
+    foreach(n; 1..1_000_000) {
+        if(n % 2 == 0)
+            writeln(n);
+    }
+
+    // Há também 'foreach_reverse' quando você deseja fazer um loop para trás.
+    foreach_reverse(n; 1..int.max) {
+        if(n % 2 == 1) {
+            writeln(n);
+        } else {
+            writeln("No!");
+        }
+    }
+}
+```
+
+Podemos definir novos tipos com `struct`,` class`, `union` e` enum`. Estruturas e uniões
+são passados para funções por valor(ou seja, copiados) e as classes são passadas por referência. Além disso,
+podemos usar modelos para parametrizar tudo isso em tipos e valores!
+
+```d
+// Aqui, 'T' é um parâmetro de tipo. Pense '<T>' em C++/C#/Java.
+struct LinkedList(T) {
+    T data = null;
+
+    // Usar '!' para instanciar um tipo parametrizado. Mais uma vez, pense '<T>'.
+    LinkedList!(T)* next;
+}
+
+class BinTree(T) {
+    T data = null;
+
+    // Se houver apenas um parâmetro de modelo, podemos omitir os parênteses.
+    BinTree!T left;
+    BinTree!T right;
+}
+
+enum Day {
+    Sunday,
+    Monday,
+    Tuesday,
+    Wednesday,
+    Thursday,
+    Friday,
+    Saturday,
+}
+
+// Use o alias para criar abreviações para tipos.
+alias IntList = LinkedList!int;
+alias NumTree = BinTree!double;
+
+// Também podemos criar modelos de funções!
+T max(T)(T a, T b) {
+    if(a < b)
+        return b;
+
+    return a;
+}
+
+// Use a palavra-chave ref para garantir a passagem por referência. Ou seja, mesmo que 'a' 
+// e 'b' sejam tipos de valor, eles sempre serão passados por referência a 'swap ()'.
+void swap(T)(ref T a, ref T b) {
+    auto temp = a;
+
+    a = b;
+    b = temp;
+}
+
+// Com os modelos, também podemos parametrizar valores, não apenas tipos.
+class Matrix(uint m, uint n, T = int) {
+    T[m] rows;
+    T[n] columns;
+}
+
+auto mat = new Matrix!(3, 3); // O tipo 'T' foi padronizado como 'int'.
+```
+
+Falando em aulas, vamos falar sobre propriedades por um segundo. Uma propriedade
+é aproximadamente uma função que pode agir como um valor I, para que possamos
+ter a sintaxe das estruturas POD (`structure.x = 7`) com a semântica de
+métodos getter e setter (`object.setX (7)`)!
+
+```d
+// Considere uma classe parametrizada nos tipos 'T' e 'U'.
+class MyClass(T, U) {
+    T _data;
+    U _other;
+}
+
+// E os métodos "getter" e "setter", assim:
+class MyClass(T, U) {
+    T _data;
+    U _other;
+
+    // Os construtores sempre são chamados de 'this'.
+    this(T t, U u) {
+        // This will call the setter methods below.
+        data = t;
+        other = u;
+    }
+
+    // getters
+    @property T data() {
+        return _data;
+    }
+
+    @property U other() {
+        return _other;
+    }
+
+    // setters
+    @property void data(T t) {
+        _data = t;
+    }
+
+    @property void other(U u) {
+        _other = u;
+    }
+}
+
+// E nós os usamos desta maneira:
+void main() {
+    auto mc = new MyClass!(int, string)(7, "seven");
+
+    // Importe o módulo 'stdio' da biblioteca padrão para gravar no 
+    // console (as importações podem ser locais para um escopo).
+    import std.stdio;
+
+    // Ligue para os getters para buscar os valores.
+    writefln("Earlier: data = %d, str = %s", mc.data, mc.other);
+
+    // Ligue para os setters para atribuir novos valores.
+    mc.data = 8;
+    mc.other = "eight";
+
+    // Ligue para os getters novamente para buscar os novos valores.
+    writefln("Later: data = %d, str = %s", mc.data, mc.other);
+}
+```
+
+Com propriedades, podemos adicionar qualquer quantidade de lógica para
+nossos métodos getter e setter, e mantenha a sintaxe limpa de
+acessando membros diretamente!
+
+Outras guloseimas orientadas a objetos à nossa disposição,
+incluem interfaces, classes abstratas,
+e métodos de substituição. D faz herança como Java:
+Estenda uma classe, implemente quantas interfaces você desejar.
+
+Vimos as instalações OOP de D, mas vamos mudar de marcha. D oferece
+programação funcional com funções de primeira classe, `pura`
+funções e dados imutáveis. Além disso, todos os seus favoritos
+algoritmos funcionais (mapear, filtrar, reduzir e amigos) podem ser
+encontrado no maravilhoso módulo `std.algorithm`!
+
+```d
+import std.algorithm : map, filter, reduce;
+import std.range : iota; // cria uma gama exclusiva de final
+
+void main() {
+    // Queremos imprimir a soma de uma lista de quadrados de ints pares 
+    // de 1 a 100. Fácil!
+
+    // Basta passar expressões lambda como parâmetros de modelo!
+    // Você pode passar qualquer função que desejar, mas as lambdas são convenientes aqui.
+    auto num = iota(1, 101).filter!(x => x % 2 == 0)
+                           .map!(y => y ^^ 2)
+                           .reduce!((a, b) => a + b);
+
+    writeln(num);
+}
+```
+
+Observe como conseguimos construir um bom pipeline haskelliano para calcular num?
+Isso se deve a uma inovação em D, conhecida como Uniform Function Call Syntax (UFCS).
+Com o UFCS, podemos optar por escrever uma chamada de função como método
+ou chamada de função grátis! Walter escreveu um bom artigo sobre isso
+[aqui.] (http://www.drdobbs.com/cpp/uniform-function-call-syntax/232700394)
+Em resumo, você pode chamar funções cujo primeiro parâmetro
+é de algum tipo A em qualquer expressão do tipo A como método.
+
+Eu gosto de paralelismo. Alguém mais gosta de paralelismo? Com certeza. Vamos fazer um pouco!
+
+```d
+// Digamos que queremos preencher uma matriz grande com a raiz quadrada de todos 
+// os números inteiros consecutivos começando de 1 (até o tamanho da matriz), e queremos 
+// fazer isso simultaneamente, aproveitando o número de núcleos que temos 
+// disponível.
+
+import std.stdio;
+import std.parallelism : parallel;
+import std.math : sqrt;
+
+void main() {
+    // Crie sua grande variedade
+    auto arr = new double[1_000_000];
+
+    // Use um índice, acesse todos os elementos da matriz por referência (porque vamos 
+    // mudar cada elemento) e apenas chame paralelo na matriz!
+    foreach(i, ref elem; parallel(arr)) {
+        elem = sqrt(i + 1.0);
+    }
+}
+```
diff --git a/pt-br/dart-pt.html.markdown b/pt-br/dart-pt.html.markdown
index 6aff1ac3..8fa176b9 100644
--- a/pt-br/dart-pt.html.markdown
+++ b/pt-br/dart-pt.html.markdown
@@ -495,7 +495,6 @@ main() {
     example27, example28, example29, example30
     ].forEach((ef) => ef());
 }
-
 ```
 
 ## Continue lendo
diff --git a/pt-br/elixir-pt.html.markdown b/pt-br/elixir-pt.html.markdown
index 4ba78f52..083a3fa4 100644
--- a/pt-br/elixir-pt.html.markdown
+++ b/pt-br/elixir-pt.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: elixir
+language: Elixir
 contributors:
     - ["Joao Marques", "http://github.com/mrshankly"]
     - ["Dzianis Dashkevich", "https://github.com/dskecse"]
@@ -14,13 +14,12 @@ Elixir é uma linguagem funcional moderna construída no topo da Erlang VM.
 e muitos outros recursos.
 
 ```elixir
-
 # Comentários de linha única começam com um símbolo de número.
 
 # Não há comentários de múltiplas linhas,
 # mas você pode empilhar os comentários.
 
-# Para usar o shell do elixir use o comando `iex`.
+# Para usar o shell do Elixir use o comando `iex`.
 # Compile seus módulos com o comando `elixirc`.
 
 # Ambos devem estar em seu path se você instalou o Elixir corretamente.
@@ -51,7 +50,7 @@ elem({1, 2, 3}, 0) #=> 1
 head #=> 1
 tail #=> [2,3]
 
-# Em elixir, bem como em Erlang, o sinal `=` denota pattern match,
+# Em Elixir, bem como em Erlang, o sinal `=` denota pattern match,
 # e não uma atribuição.
 #
 # Isto significa que o que estiver à esquerda (pattern) é comparado com o que
@@ -85,7 +84,7 @@ linhas.
 <<?a, ?b, ?c>> #=> "abc"
 [?a, ?b, ?c]   #=> 'abc'
 
-# `?a` em elixir retorna o valor ASCII para a letra `a`
+# `?a` em Elixir retorna o valor ASCII para a letra `a`
 ?a #=> 97
 
 # Para concatenar listas use `++`, para binários use `<>`
@@ -98,7 +97,7 @@ linhas.
 # Ranges são representados como `início..fim` (ambos inclusivos)
 1..10 #=> 1..10
 menor..maior = 1..10 # Pattern matching pode ser usada em ranges também
-[lower, upper] #=> [1, 10]
+[menor, maior] #=> [1, 10]
 
 ## ---------------------------
 ## -- Operadores
@@ -110,7 +109,7 @@ menor..maior = 1..10 # Pattern matching pode ser usada em ranges também
 5 * 2  #=> 10
 10 / 2 #=> 5.0
 
-# Em elixir o operador `/` sempre retorna um float.
+# Em Elixir o operador `/` sempre retorna um float.
 
 # Para divisão de inteiros use `div`
 div(10, 2) #=> 5
@@ -167,7 +166,7 @@ else
   "Isso será"
 end
 
-# Lembra do patter matching? Muitas estruturas de fluxo de controle em elixir contam com ela.
+# Lembra do pattern matching? Muitas estruturas de fluxo de controle em Elixir contam com ela.
 
 # `case` nos permite comparar um valor com muitos patterns:
 case {:um, :dois} do
@@ -296,7 +295,7 @@ Geometry.area({:circle, 3})       #=> 28.25999999999999801048
 # Geometry.area({:circle, "not_a_number"})
 #=> ** (FunctionClauseError) no function clause matching in Geometry.area/1
 
-# Devido à imutabilidade, recursão é uma grande parte do elixir
+# Devido à imutabilidade, recursão é uma grande parte do Elixir
 defmodule Recursion do
   def sum_list([head | tail], acc) do
     sum_list(tail, acc + head)
@@ -309,7 +308,7 @@ end
 
 Recursion.sum_list([1,2,3], 0) #=> 6
 
-# Módulos do elixir suportam atributos, hpa atributos embutidos e você
+# Módulos do Elixir suportam atributos, hpa atributos embutidos e você
 # pode também adicionar os seus próprios.
 defmodule MyMod do
   @moduledoc """
@@ -361,7 +360,7 @@ end
 ## ---------------------------
 
 # Elixir conta com o modelo de ator para concorrência. Tudo o que precisamos para
-# escrever programas concorrentes em elixir são três primitivos: spawning processes,
+# escrever programas concorrentes em Elixir são três primitivos: spawning processes,
 # sending messages e receiving messages.
 
 # Para iniciar um novo processo usamos a função `spawn`, a qual leva uma função
diff --git a/pt-br/emacs-pt.html.markdown b/pt-br/emacs-pt.html.markdown
new file mode 100644
index 00000000..7a86a119
--- /dev/null
+++ b/pt-br/emacs-pt.html.markdown
@@ -0,0 +1,60 @@
+---
+category: tool
+tool: emacs
+filename: emacs.txt
+contributors:
+    - ["Joseph Riad", "https://github.com/Joseph-Riad"]
+translators:
+    - ["André de Santa Gabriel", "https://github.com/andredesanta"]
+lang: pt-br
+---
+
+O Emacs começou sua vida como (https://www.gnu.org/software/emacs/emacs-paper.html) e cresceu
+ao longo dos anos em um ecossistema completo. Muitas tarefas, geralmente
+relegado a um conjunto diversificado de ferramentas pode ser realizado de dentro
+Emacs em uma interface consistente e familiar. Exemplos incluem
+gerenciamento de diretório, visualização de documentos PDF, edição de arquivos via SSH, gerenciamento de
+repos git. Em suma, o Emacs é seu para fazer
+o que você quiser: o espectro de usuários varia daqueles que o usam para
+editar arquivos de texto para puristas extremos que o usam para substituir virtualmente seu
+sistema operacional.
+
+O Emacs é extensível através de um dialeto especializado do Lisp conhecido como Emacs
+Lisp (Elisp), que possui muitas macros voltadas para a edição de texto e
+gerenciamento de buffers de texto. Qualquer tecla (combinação) usada no Emacs está vinculada
+para uma função Emacs Lisp e pode ser remapeado para qualquer outra função,
+incluindo aqueles que você escreve
+você mesmo.
+
+# Conceitos básicos de Emacs
+
+Aqui, discuto alguns conceitos e terminologia básicos do Emacs que podem ser
+confusos para os recém-chegados (especialmente para as pessoas acostumadas à terminologia do Vim):
+
+  - O texto que o Emacs está editando é conhecido como **buffer**
+  
+  - Um buffer não corresponde necessariamente a um arquivo real no disco. Pode ser apenas texto na memória.
+    
+  - Quando um buffer corresponde a um arquivo no disco, dizemos que o buffer está **visitando** esse arquivo.
+  
+  - O Emacs normalmente possui muitos buffers abertos ao mesmo tempo.
+  
+  - A exibição do Emacs pode ser dividida em diferentes **windows**.
+  
+  - Uma janela do sistema operacional para o Emacs é chamada de **frame**. Assim, quando o manual do Emacs fala sobre a abertura de um novo frame, esse essencialmente significa abrir uma nova janela do SO contendo uma (outra) instância do Emacs.
+  
+  - Os conceitos convencionalmente conhecidos como recortar e colar são referido como **killing** e **yanking**, respectivamente no Emacs.
+  
+  - A posição atual do cursor é chamada de **point** no Emacs. Tecnicamente, **point** é definido como a posição imediatamente antes do caractere onde o cursor está atualmente.
+  
+  - Finalmente, cada buffer pode ter vários **modes** associados: o **major mode** e possivelmente vários **minor modes**.
+  
+  - O **major mode** define o principal comportamento do Emacs no buffer atualmente selecionado. Isso pode ser pensado como o tipo de arquivo. Por exemplo, se você estiver editando um arquivo Python, os principais modes é (por padrão) `python-mode`, que faz com que o Emacs destaque a sintaxe Python e idente automaticamente seus blocos de código conforme exigido sintaticamente pelo seu código Python.
+  
+  - **Minor modes** definem mudanças sutis no comportamento e várias alterações menores Os modos podem estar ativos ao mesmo tempo no mesmo buffer. Um exemplo menor modo é o modo flyspell, que destaca automaticamente os erros de ortografia no seu buffer.
+
+# Recursos adicionais
+
+  - [The GNU Emacs Manual](https://www.gnu.org/software/emacs/manual/emacs.html)
+  - [Emacs Stack Exchange](https://emacs.stackexchange.com/)
+  - [Emacs Wiki](https://www.emacswiki.org/emacs/EmacsWiki)
diff --git a/pt-br/erlang-pt.html.markdown b/pt-br/erlang-pt.html.markdown
index a81e5a1f..845837fb 100644
--- a/pt-br/erlang-pt.html.markdown
+++ b/pt-br/erlang-pt.html.markdown
@@ -242,7 +242,6 @@ catcher(N) ->
 % O outro é encapsular a chamada em uma expressão `catch`. Quando você captura
 % uma exceção, é convertida em uma tupla que descreve o erro.
 catcher(N) -> catch generate_exception(N).
-
 ```
 
 ## Referências
diff --git a/pt-br/factor-pt.html.markdown b/pt-br/factor-pt.html.markdown
index b4b5c7f5..88b10c8f 100644
--- a/pt-br/factor-pt.html.markdown
+++ b/pt-br/factor-pt.html.markdown
@@ -175,8 +175,6 @@ name get-global .       ! "Bob"
 0 [ 2 + ] nth                              ! 2
 1 [ 2 + ] nth                              ! +
 [ 2 + ] \ - suffix                         ! Quotation [ 2 + - ]
-
-
 ```
 
 ##Pronto para mais?
diff --git a/pt-br/fsharp-pt.html.markdown b/pt-br/fsharp-pt.html.markdown
index 55966cda..0fe360c3 100644
--- a/pt-br/fsharp-pt.html.markdown
+++ b/pt-br/fsharp-pt.html.markdown
@@ -19,7 +19,6 @@ A sintaxe é diferente das linguagens do estilo C (C, C#, Java, etc):
 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 (* . . . *)
 
@@ -629,7 +628,6 @@ module NetCompatibilityExamples =
             printfn "Click event with arg=%O" arg)
 
     myButton.TestEvent("Hello World!")
-
 ```
 
 ## Mais Informações
diff --git a/pt-br/git-pt.html.markdown b/pt-br/git-pt.html.markdown
index 2cc1c337..d9e5a9f4 100644
--- a/pt-br/git-pt.html.markdown
+++ b/pt-br/git-pt.html.markdown
@@ -480,6 +480,7 @@ Agora você irá conseguir realizar o pull!
 ```bash
 git pull
 ```
+
 `...changes apply...`
 
 Verifique se está tudo OK com o `git status`
@@ -583,6 +584,7 @@ Você pode fazer assim:
 ed8ddf2 HEAD@{4}: rebase -i (pick): pythonstatcomp spanish translation (#1748)
 2e6c386 HEAD@{5}: rebase -i (start): checkout 02fb96d
 ```
+
 2. Selecione para onde você quer resetar. No nosso exemplo, seria o commit
 `2e6c386`, ou `HEAD@{5}`
 3. 'git reset --hard HEAD@{5}' esse comando irá resetar o seu repositório para
diff --git a/pt-br/go-pt.html.markdown b/pt-br/go-pt.html.markdown
index f68d63eb..ce10e079 100644
--- a/pt-br/go-pt.html.markdown
+++ b/pt-br/go-pt.html.markdown
@@ -77,7 +77,7 @@ pode incluir quebras de linha.` // mesmo tipo string
     // literal não-ASCII. A linguagem Go utiliza de raiz a codificação UTF-8.
     g := 'Σ' // tipo rune, um alias para int32, que contém um código unicode
 
-    f := 3.14195 // float64, número de vírgula flutuante de 64bit (IEEE-754)
+    f := 3.14159 // float64, número de vírgula flutuante de 64bit (IEEE-754)
     c := 3 + 4i  // complex128, representado internamente com dois float64s
 
     // Declaração de variáveis, com inicialização.
@@ -295,17 +295,17 @@ func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 
 ## Leitura Recomendada
 
-A principal fonte de informação é o [web site oficial Go](http://golang.org/).
+A principal fonte de informação é o [web site oficial Go](https://go.dev/).
 Lá é possível seguir o tutorial, experimentar de forma iterativa, e ler muito.
 
 A própria especificação da linguagem é altamente recomendada. É fácil de ler e
 incrivelmente curta (em relação ao que é habitual hoje em dia).
 
 Na lista de leitura para os aprendizes de Go deve constar o [código fonte da 
-biblioteca padrão](http://golang.org/src/pkg/). Exaustivamente documentado, é
+biblioteca padrão](https://go.dev/src/). Exaustivamente documentado, é
 a melhor demonstração de código fácil de ler e de perceber, do estilo Go, e da
 sua escrita idiomática. Ou então clique no nome de uma função na [documentação]
-(http://golang.org/pkg/) e veja o código fonte aparecer!
+(https://go.dev/pkg/) e veja o código fonte aparecer!
 
 Outra ótima fonte para aprender Go é o [Go by example](https://gobyexample.com/).
 Apesar de ser em inglês, é possível recodificar os exemplos para aprender sobre
diff --git a/pt-br/groovy-pt.html.markdown b/pt-br/groovy-pt.html.markdown
index dff3f2e1..ebde76d8 100644
--- a/pt-br/groovy-pt.html.markdown
+++ b/pt-br/groovy-pt.html.markdown
@@ -13,7 +13,6 @@ lang: pt-br
 Groovy - Uma linguagem dinâmica para a plataforma Java. [Leia mais aqui.](http://www.groovy-lang.org/)
 
 ```groovy
-
 /*
   Prepare-se:
 
@@ -418,8 +417,6 @@ int soma(int x, int y) {
 }
 
 assert soma(2,5) == 7
-
-
 ```
 
 ## Referências
diff --git a/pt-br/hack-pt.html.markdown b/pt-br/hack-pt.html.markdown
index 7c938149..7f76a9b0 100644
--- a/pt-br/hack-pt.html.markdown
+++ b/pt-br/hack-pt.html.markdown
@@ -301,7 +301,6 @@ class Samuel
 
 $gato = new Samuel();
 $gato instanceof InterfaceGatinho === true; // True
-
 ```
 
 ## Mais informações
diff --git a/pt-br/haxe-pt.html.markdown b/pt-br/haxe-pt.html.markdown
index 13264dec..c2d88d13 100644
--- a/pt-br/haxe-pt.html.markdown
+++ b/pt-br/haxe-pt.html.markdown
@@ -777,8 +777,8 @@ class UsingExample {
       }
 
 }
-
 ```
+
 Isso foi apenas o começo do que Haxe pode fazer. Para uma documentação de todos
 os recursos de Haxe, veja o [manual](https://haxe.org/manual) e a
 [documentação de API](https://api.haxe.org/). Para um diretório de bibliotecas de terceiros
diff --git a/pt-br/html-pt.html.markdown b/pt-br/html-pt.html.markdown
index 22b7836e..26bb5b1c 100644
--- a/pt-br/html-pt.html.markdown
+++ b/pt-br/html-pt.html.markdown
@@ -111,7 +111,6 @@ Esse artigo tem seu foco principal na sintaxe do HTML e algumas dicas úteis.
 		<td>Segunda linha, segunda coluna</td>
 	</tr>
 </table>
-
 ```
 
 ## Uso
diff --git a/pt-br/httpie-pt.html.markdown b/pt-br/httpie-pt.html.markdown
new file mode 100644
index 00000000..f81919fe
--- /dev/null
+++ b/pt-br/httpie-pt.html.markdown
@@ -0,0 +1,122 @@
+---
+category: tool
+tool: httpie
+filename: learn-httpie-pt.sh
+contributors:
+  - ["Adaías Magdiel", "https://github.com/AdaiasMagdiel"]
+translators:
+  - ["Adaías Magdiel", "https://adaiasmagdiel.com/"]
+lang: pt-br
+---
+
+HTTPie é um poderoso cliente HTTP para linha de comando, projetado para uma
+integração suave com servidores HTTP. Oferece uma interface simples e intuitiva,
+tornando-se uma excelente ferramenta para desenvolvedores, testadores e administradores de sistemas.
+
+## Uso Básico
+
+HTTPie possui uma sintaxe simples: http [flags] [MÉTODO] URL [itens].
+
+```bash
+http GET https://api.example.com/posts
+```
+
+Você pode exibir a requisição sem executá-la, de fato, usando a flag `--offline`.
+
+```bash
+http --offline https://api.example.com/posts
+```
+
+### Encurtando URLs `localhost`
+
+HTTPie fornece suporte a atalhos para o localhost, similares aos do `curl`. Por exemplo, ":3000"
+expande para "http://localhost:3000". Se a porta for omitida, o padrão será a porta 80.
+
+```bash
+http :/users    # http://localhost/users
+http :5000/rss  # http://localhost:5000/rss
+```
+
+### Métodos Opcionais GET e POST
+
+Se você não especificar o método, o HTTPie usará o seguinte:
+
+- GET para requisições sem corpo
+- POST para requisições com corpo
+
+```bash
+http https://api.example.com/tags # GET - Seleciona as tags
+http https://api.example.com/tags title="Tutorial" slug="tutorial" # POST - Cria uma nova tag
+```
+
+## Parâmetros Querystring
+
+Se você adiciona querystrings manualmente no terminal, tente a seguinte sintaxe:
+`param==value`. Isso evita que o shell tente reconhecer o operador & como comando
+e automaticamente escape caracteres especiais nos parâmetros.
+Isso difere dos parâmetros na URL completa, que o HTTPie não modifica.
+
+```bash
+http https://api.example.com/search q==httpie per_page==20
+```
+
+## Enviando Dados
+
+Você pode enviar dados nos mais diversos formatos, como JSON, formulários ou arquivos.
+
+### Enviando JSON
+
+```bash
+http POST https://api.example.com/posts title="Olá" body="Mundo"
+```
+
+### Enviando Formulário
+
+```bash
+http -f POST https://api.example.com/submit name=John email=john@example.com
+```
+
+### Enviando Arquivos
+
+```bash
+http --form POST https://api.example.com/upload file@/caminho/do/arquivo.txt
+```
+
+## Headers e Autenticação
+
+HTTPie permite que você adicione headers e lide com autenticação de uma forma fácil.
+
+### Headers
+
+```bash
+http GET https://api.example.com/posts Authorization:"Bearer Token" User-Agent:"HTTPie"
+```
+
+### Autenticação Básica
+
+```bash
+http -a usuario:senha GET https://api.example.com/protected
+```
+
+### Autenticação Bearer
+
+```bash
+https -A bearer -a token https://api.example.com/admin
+```
+
+## Lidando com Respostas
+
+HTTPie fornece várias opções para lidar com respostas.
+
+```bash
+http GET https://api.example.com/data Accept:application/json  # Exibe o JSON de uma forma legível
+
+http GET https://api.example.com/image --output image.png      # Grava a resposta em um arquivo
+
+http --follow GET https://example.com  # Segue redirecionamentos
+```
+
+## Leitura Adicional
+
+- [Documentação Oficial](https://httpie.io/docs/cli).
+- [GitHub](https://github.com/httpie).
diff --git a/pt-br/java-pt.html.markdown b/pt-br/java-pt.html.markdown
index 1b9d7fc6..6069974b 100644
--- a/pt-br/java-pt.html.markdown
+++ b/pt-br/java-pt.html.markdown
@@ -621,7 +621,6 @@ public class EnumTeste {
 // Tipos Enum são muito mais poderosos do que nós mostramos acima.
 // O corpo de um enum pode incluir métodos e outros campos.
 // Você pode ver mais em https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html
-
 ```
 
 ## Leitura Recomendada
diff --git a/pt-br/jquery-pt.html.markdown b/pt-br/jquery-pt.html.markdown
index d49bea0f..f041352a 100644
--- a/pt-br/jquery-pt.html.markdown
+++ b/pt-br/jquery-pt.html.markdown
@@ -14,8 +14,6 @@ jQuery é uma biblioteca JavaScript que te ajuda a "fazer mais, escrevendo menos
 Pelo jQuery ser uma biblioteca JavaScript você deve [aprende-lo primeiro](https://learnxinyminutes.com/docs/pt-br/javascript-pt/)
 
 ```js
-
-
 ///////////////////////////////////
 // 1. Seletores
 
@@ -126,6 +124,4 @@ var heights = [];
 $('p').each(function() {
   heights.push($(this).height()); // Adiciona a altura das tags 'p' na array
 });
-
-
 ```
diff --git a/pt-br/kotlin-pt.html.markdown b/pt-br/kotlin-pt.html.markdown
index bbe8c0d1..bb9d2b2e 100644
--- a/pt-br/kotlin-pt.html.markdown
+++ b/pt-br/kotlin-pt.html.markdown
@@ -374,7 +374,6 @@ fun usaObjeto() {
     ExemploObjeto.ola()
     val algumaReferencia: Any = ExemploObjeto // usa-se o nome diretamente
 }
-
 ```
 
 ### Leitura Adicional
diff --git a/pt-br/less-pt.html.markdown b/pt-br/less-pt.html.markdown
index f6cf2d71..8af547c3 100644
--- a/pt-br/less-pt.html.markdown
+++ b/pt-br/less-pt.html.markdown
@@ -11,8 +11,6 @@ Less é um pré-processador de CSS, que adiciona recursos como variáveis, aninh
 Less (e outros pré-processadores, como o [Sass](http://sass-lang.com/)) ajudam os desenvolvedores a escreverem código que pode ser mantido e DRY (não se repita).
 
 ```css
-
-
 //Comentários de linha única são removidos quando Less é compilado para CSS.
 
 /*Comentários de várias linhas são preservados.*/
@@ -370,8 +368,6 @@ body {
 .gutter {
   width: 6.25%;
 }
-
-
 ```
 
 ## Pratique Less
diff --git a/pt-br/lua-pt.html.markdown b/pt-br/lua-pt.html.markdown
index 4aaf3a1e..07e7e70f 100644
--- a/pt-br/lua-pt.html.markdown
+++ b/pt-br/lua-pt.html.markdown
@@ -392,7 +392,6 @@ g = loadstring('print(343)')  -- Retorna uma função.
 g()  -- Imprime 343; nada foi impresso antes disso.
 
 --]]
-
 ```
 
 ## Referências
diff --git a/pt-br/make-pt.html.markdown b/pt-br/make-pt.html.markdown
index 40ac733a..b761273c 100644
--- a/pt-br/make-pt.html.markdown
+++ b/pt-br/make-pt.html.markdown
@@ -1,245 +1,244 @@
----

-category: tool

-tool: make

-contributors:

-    - ["Robert Steed", "https://github.com/robochat"]

-    - ["Stephan Fuhrmann", "https://github.com/sfuhrm"]

-translators:

-    - ["Rogério Gomes Rio", "https://github.com/rogerlista"]

-filename: Makefile-pt

-

-lang: pt-br

----

-

-Um Makefile define um gráfico de regras para criar um alvo (ou alvos). Sua finalidade é fazer o mínimo de trabalho necessário para atualizar um alvo para a versão mais recente da fonte. Famosamente escrito ao longo de um fim de semana por Stuart Feldman em 1976, ainda é amplamente usada (particularmente no Unix e no Linux) apesar de muitos concorrentes e críticas.

-

-Existem muitas variedades de make na existência, no entanto, este artigo pressupõe que estamos usando o GNU make, que é o padrão no Linux.

-

-```make

-

-# Comentários podem ser escritos assim.

-

-# O arquivo deve ser nomeado Makefile e então pode ser executado como `make <alvo>`.

-# Caso contrário, nós usamos `make -f "nome-do-arquivo" <alvo>`.

-

-# Aviso - use somente TABS para identar em Makefiles, nunca espaços!

-

-#-----------------------------------------------------------------------

-# Noções básicas

-#-----------------------------------------------------------------------

-

-# Regras são do formato

-# alvo: <pré-requisito>

-# onde os pré-requisitos são opcionais.

-

-# Uma regra - esta regra só será executada se o arquivo0.txt não existir.

-arquivo0.txt:

-	echo "foo" > arquivo0.txt

-	# Mesmo os comentários nestas seções da 'receita' são passados ​​para o shell.

-	# Experimentar `make arquivo0.txt` or simplyou simplesmente `make` - primeira regra é o padrão.

-

-# Esta regra só será executada se arquivo0.txt for mais recente que arquivo1.txt.

-arquivo1.txt: arquivo0.txt

-	cat arquivo0.txt > arquivo1.txt

-	# se as mesmas regras de citação do shell.

-	@cat arquivo0.txt >> arquivo1.txt

-	# @ pára o comando de ser ecoado para stdout.

-	-@echo 'hello'

-	# - significa que make continuará em caso de erro.

-	# Experimentar `make arquivo1.txt` na linha de comando.

-

-# Uma regra pode ter vários alvos e vários pré-requisitos

-arquivo2.txt arquivo3.txt: arquivo0.txt arquivo1.txt

-	touch arquivo2.txt

-	touch arquivo3.txt

-

-# Make vai reclamar sobre várias receitas para a mesma regra. Esvaziar

-# receitas não contam e podem ser usadas para adicionar novas dependências.

-

-#-----------------------------------------------------------------------

-# Alvos falsos

-#-----------------------------------------------------------------------

-

-# Um alvo falso. Qualquer alvo que não seja um arquivo.

-# Ele nunca será atualizado, portanto, o make sempre tentará executá-lo.

-all: maker process

-

-# Podemos declarar as coisas fora de ordem.

-maker:

-	touch ex0.txt ex1.txt

-

-# Pode evitar quebrar regras falsas quando um arquivo real tem o mesmo nome

-.PHONY: all maker process

-# Este é um alvo especial. Existem vários outros.

-

-# Uma regra com dependência de um alvo falso sempre será executada

-ex0.txt ex1.txt: maker

-

-# Alvos falsos comuns são: todos fazem instalação limpa ...

-

-#-----------------------------------------------------------------------

-# Variáveis ​​Automáticas e Curingas

-#-----------------------------------------------------------------------

-

-process: Arquivo*.txt	# Usando um curinga para corresponder nomes de arquivos

-	@echo $^	# $^ é uma variável que contém a lista de pré-requisitos

-	@echo $@	# imprime o nome do alvo

-	#(fpara várias regras alvo, $@ é o que causou a execução da regra)

-	@echo $<	# o primeiro pré-requisito listado

-	@echo $?	# somente as dependências que estão desatualizadas

-	@echo $+	# todas as dependências, incluindo duplicadas (ao contrário do normal)

-	#@echo $|	# todos os pré-requisitos 'somente pedidos'

-

-# Mesmo se dividirmos as definições de dependência de regra, $^ vai encontrá-los

-process: ex1.txt arquivo0.txt

-# ex1.txt será encontrado, mas arquivo0.txt será desduplicado.

-

-#-----------------------------------------------------------------------

-# Padrões

-#-----------------------------------------------------------------------

-

-# Pode ensinar make a converter certos arquivos em outros arquivos.

-

-%.png: %.svg

-	inkscape --export-png $^

-

-# As regras padrões só farão qualquer coisa se decidirem criar o alvo.

-

-# Os caminhos de diretório são normalmente ignorados quando as regras de

-# padrões são correspondentes. Mas make tentará usar a regra mais

-# apropriada disponível.

-small/%.png: %.svg

-	inkscape --export-png --export-dpi 30 $^

-

-# make utilizará a última versão para uma regra de padrão que encontrar.

-%.png: %.svg

-	@echo esta regra é escolhida

-

-# No entanto, o make usará a primeira regra padrão que pode se tornar o alvo

-%.png: %.ps

-	@echo esta regra não é escolhida se *.svg and *.ps estão ambos presentes

-

-# make já tem algumas regras padrões embutidas. Por exemplo, ele sabe

-# como transformar arquivos *.c em arquivos *.o.

-

-# Makefiles antigos podem usar regras de sufixo em vez de regras padrões

-.png.ps:

-	@echo essa regra é semelhante a uma regra de padrão.

-

-# make sobre a regra de sufixo

-.SUFFIXES: .png

-

-#-----------------------------------------------------------------------

-# Variáveis

-#-----------------------------------------------------------------------

-# aka. macros

-

-# As variáveis ​​são basicamente todos os tipos de string

-

-name = Ted

-name2="Sarah"

-

-echo:

-	@echo $(name)

-	@echo ${name2}

-	@echo $name    # Isso não funcionará, tratado como $ (n)ame.

-	@echo $(name3) # Variáveis ​​desconhecidas são tratadas como strings vazias.

-

-# Existem 4 lugares para definir variáveis.

-# Em ordem de prioridade, do maior para o menor:

-# 1: argumentos de linha de comando

-# 2: Makefile

-# 3: variáveis ​​de ambiente do shell - faça importações automaticamente.

-# 4: make tem algumas variáveis ​​predefinidas

-

-name4 ?= Jean

-# Somente defina a variável se a variável de ambiente ainda não estiver definida.

-

-override name5 = David

-# Pára os argumentos da linha de comando de alterar essa variável.

-

-name4 +=grey

-# Anexar valores à variável (inclui um espaço).

-

-# Valores variáveis ​​específicos de padrões (extensão GNU).

-echo: name2 = Sara # Verdadeiro dentro da regra de correspondência

-	# e também dentro de suas recursivas dependências

-	# (exceto que ele pode quebrar quando seu gráfico ficar muito complicado!)

-

-# Algumas variáveis ​​definidas automaticamente pelo make

-echo_inbuilt:

-	echo $(CC)

-	echo ${CXX}

-	echo $(FC)

-	echo ${CFLAGS}

-	echo $(CPPFLAGS)

-	echo ${CXXFLAGS}

-	echo $(LDFLAGS)

-	echo ${LDLIBS}

-

-#-----------------------------------------------------------------------

-# Variáveis 2

-#-----------------------------------------------------------------------

-

-# O primeiro tipo de variáveis ​​é avaliado a cada vez que elas são usadas.

-# TIsso pode ser caro, então existe um segundo tipo de variável que é

-# avaliado apenas uma vez. (Esta é uma extensão do GNU make)

-

-var := hello

-var2 ::=  $(var) hello

-#:= e ::= são equivalentes.

-

-# Essas variáveis ​​são avaliadas procedimentalmente (na ordem em que

-# aparecem), quebrando assim o resto da línguagem!

-

-# Isso não funciona

-var3 ::= $(var4) and good luck

-var4 ::= good night

-

-#-----------------------------------------------------------------------

-# Funções

-#-----------------------------------------------------------------------

-

-# make tem muitas funções disponíveis.

-

-sourcefiles = $(wildcard *.c */*.c)

-objectfiles = $(patsubst %.c,%.o,$(sourcefiles))

-

-# O formato é $(func arg0,arg1,arg2...)

-

-# Alguns exemplos

-ls:	* src/*

-	@echo $(filter %.txt, $^)

-	@echo $(notdir $^)

-	@echo $(join $(dir $^),$(notdir $^))

-

-#-----------------------------------------------------------------------

-# Diretivas

-#-----------------------------------------------------------------------

-

-# Inclua outros makefiles, úteis para código específico da plataforma

-include foo.mk

-

-sport = tennis

-# Compilação condicional

-report:

-ifeq ($(sport),tennis)

-	@echo 'game, set, match'

-else

-	@echo "They think it's all over; it is now"

-endif

-

-# Há também ifneq, ifdef, ifndef

-

-foo = true

-

-ifdef $(foo)

-bar = 'hello'

-endif

-```

-

-### More Resources

-

-+ [documentação gnu make](https://www.gnu.org/software/make/manual/)

-+ [tutorial de carpintaria de software](http://swcarpentry.github.io/make-novice/)

-+ aprenda C da maneira mais difícil [ex2](http://c.learncodethehardway.org/book/ex2.html) [ex28](http://c.learncodethehardway.org/book/ex28.html)

+---
+category: tool
+tool: make
+contributors:
+    - ["Robert Steed", "https://github.com/robochat"]
+    - ["Stephan Fuhrmann", "https://github.com/sfuhrm"]
+translators:
+    - ["Rogério Gomes Rio", "https://github.com/rogerlista"]
+filename: Makefile-pt
+
+lang: pt-br
+---
+
+Um Makefile define um gráfico de regras para criar um alvo (ou alvos). Sua finalidade é fazer o mínimo de trabalho necessário para atualizar um alvo para a versão mais recente da fonte. Famosamente escrito ao longo de um fim de semana por Stuart Feldman em 1976, ainda é amplamente usada (particularmente no Unix e no Linux) apesar de muitos concorrentes e críticas.
+
+Existem muitas variedades de make na existência, no entanto, este artigo pressupõe que estamos usando o GNU make, que é o padrão no Linux.
+
+```make
+# Comentários podem ser escritos assim.
+
+# O arquivo deve ser nomeado Makefile e então pode ser executado como `make <alvo>`.
+# Caso contrário, nós usamos `make -f "nome-do-arquivo" <alvo>`.
+
+# Aviso - use somente TABS para identar em Makefiles, nunca espaços!
+
+#-----------------------------------------------------------------------
+# Noções básicas
+#-----------------------------------------------------------------------
+
+# Regras são do formato
+# alvo: <pré-requisito>
+# onde os pré-requisitos são opcionais.
+
+# Uma regra - esta regra só será executada se o arquivo0.txt não existir.
+arquivo0.txt:
+	echo "foo" > arquivo0.txt
+	# Mesmo os comentários nestas seções da 'receita' são passados ​​para o shell.
+	# Experimentar `make arquivo0.txt` or simplyou simplesmente `make` - primeira regra é o padrão.
+
+# Esta regra só será executada se arquivo0.txt for mais recente que arquivo1.txt.
+arquivo1.txt: arquivo0.txt
+	cat arquivo0.txt > arquivo1.txt
+	# se as mesmas regras de citação do shell.
+	@cat arquivo0.txt >> arquivo1.txt
+	# @ pára o comando de ser ecoado para stdout.
+	-@echo 'hello'
+	# - significa que make continuará em caso de erro.
+	# Experimentar `make arquivo1.txt` na linha de comando.
+
+# Uma regra pode ter vários alvos e vários pré-requisitos
+arquivo2.txt arquivo3.txt: arquivo0.txt arquivo1.txt
+	touch arquivo2.txt
+	touch arquivo3.txt
+
+# Make vai reclamar sobre várias receitas para a mesma regra. Esvaziar
+# receitas não contam e podem ser usadas para adicionar novas dependências.
+
+#-----------------------------------------------------------------------
+# Alvos falsos
+#-----------------------------------------------------------------------
+
+# Um alvo falso. Qualquer alvo que não seja um arquivo.
+# Ele nunca será atualizado, portanto, o make sempre tentará executá-lo.
+all: maker process
+
+# Podemos declarar as coisas fora de ordem.
+maker:
+	touch ex0.txt ex1.txt
+
+# Pode evitar quebrar regras falsas quando um arquivo real tem o mesmo nome
+.PHONY: all maker process
+# Este é um alvo especial. Existem vários outros.
+
+# Uma regra com dependência de um alvo falso sempre será executada
+ex0.txt ex1.txt: maker
+
+# Alvos falsos comuns são: todos fazem instalação limpa ...
+
+#-----------------------------------------------------------------------
+# Variáveis ​​Automáticas e Curingas
+#-----------------------------------------------------------------------
+
+process: Arquivo*.txt	# Usando um curinga para corresponder nomes de arquivos
+	@echo $^	# $^ é uma variável que contém a lista de pré-requisitos
+	@echo $@	# imprime o nome do alvo
+	#(fpara várias regras alvo, $@ é o que causou a execução da regra)
+	@echo $<	# o primeiro pré-requisito listado
+	@echo $?	# somente as dependências que estão desatualizadas
+	@echo $+	# todas as dependências, incluindo duplicadas (ao contrário do normal)
+	#@echo $|	# todos os pré-requisitos 'somente pedidos'
+
+# Mesmo se dividirmos as definições de dependência de regra, $^ vai encontrá-los
+process: ex1.txt arquivo0.txt
+# ex1.txt será encontrado, mas arquivo0.txt será desduplicado.
+
+#-----------------------------------------------------------------------
+# Padrões
+#-----------------------------------------------------------------------
+
+# Pode ensinar make a converter certos arquivos em outros arquivos.
+
+%.png: %.svg
+	inkscape --export-png $^
+
+# As regras padrões só farão qualquer coisa se decidirem criar o alvo.
+
+# Os caminhos de diretório são normalmente ignorados quando as regras de
+# padrões são correspondentes. Mas make tentará usar a regra mais
+# apropriada disponível.
+small/%.png: %.svg
+	inkscape --export-png --export-dpi 30 $^
+
+# make utilizará a última versão para uma regra de padrão que encontrar.
+%.png: %.svg
+	@echo esta regra é escolhida
+
+# No entanto, o make usará a primeira regra padrão que pode se tornar o alvo
+%.png: %.ps
+	@echo esta regra não é escolhida se *.svg and *.ps estão ambos presentes
+
+# make já tem algumas regras padrões embutidas. Por exemplo, ele sabe
+# como transformar arquivos *.c em arquivos *.o.
+
+# Makefiles antigos podem usar regras de sufixo em vez de regras padrões
+.png.ps:
+	@echo essa regra é semelhante a uma regra de padrão.
+
+# make sobre a regra de sufixo
+.SUFFIXES: .png
+
+#-----------------------------------------------------------------------
+# Variáveis
+#-----------------------------------------------------------------------
+# aka. macros
+
+# As variáveis ​​são basicamente todos os tipos de string
+
+name = Ted
+name2="Sarah"
+
+echo:
+	@echo $(name)
+	@echo ${name2}
+	@echo $name    # Isso não funcionará, tratado como $ (n)ame.
+	@echo $(name3) # Variáveis ​​desconhecidas são tratadas como strings vazias.
+
+# Existem 4 lugares para definir variáveis.
+# Em ordem de prioridade, do maior para o menor:
+# 1: argumentos de linha de comando
+# 2: Makefile
+# 3: variáveis ​​de ambiente do shell - faça importações automaticamente.
+# 4: make tem algumas variáveis ​​predefinidas
+
+name4 ?= Jean
+# Somente defina a variável se a variável de ambiente ainda não estiver definida.
+
+override name5 = David
+# Pára os argumentos da linha de comando de alterar essa variável.
+
+name4 +=grey
+# Anexar valores à variável (inclui um espaço).
+
+# Valores variáveis ​​específicos de padrões (extensão GNU).
+echo: name2 = Sara # Verdadeiro dentro da regra de correspondência
+	# e também dentro de suas recursivas dependências
+	# (exceto que ele pode quebrar quando seu gráfico ficar muito complicado!)
+
+# Algumas variáveis ​​definidas automaticamente pelo make
+echo_inbuilt:
+	echo $(CC)
+	echo ${CXX}
+	echo $(FC)
+	echo ${CFLAGS}
+	echo $(CPPFLAGS)
+	echo ${CXXFLAGS}
+	echo $(LDFLAGS)
+	echo ${LDLIBS}
+
+#-----------------------------------------------------------------------
+# Variáveis 2
+#-----------------------------------------------------------------------
+
+# O primeiro tipo de variáveis ​​é avaliado a cada vez que elas são usadas.
+# TIsso pode ser caro, então existe um segundo tipo de variável que é
+# avaliado apenas uma vez. (Esta é uma extensão do GNU make)
+
+var := hello
+var2 ::=  $(var) hello
+#:= e ::= são equivalentes.
+
+# Essas variáveis ​​são avaliadas procedimentalmente (na ordem em que
+# aparecem), quebrando assim o resto da línguagem!
+
+# Isso não funciona
+var3 ::= $(var4) and good luck
+var4 ::= good night
+
+#-----------------------------------------------------------------------
+# Funções
+#-----------------------------------------------------------------------
+
+# make tem muitas funções disponíveis.
+
+sourcefiles = $(wildcard *.c */*.c)
+objectfiles = $(patsubst %.c,%.o,$(sourcefiles))
+
+# O formato é $(func arg0,arg1,arg2...)
+
+# Alguns exemplos
+ls:	* src/*
+	@echo $(filter %.txt, $^)
+	@echo $(notdir $^)
+	@echo $(join $(dir $^),$(notdir $^))
+
+#-----------------------------------------------------------------------
+# Diretivas
+#-----------------------------------------------------------------------
+
+# Inclua outros makefiles, úteis para código específico da plataforma
+include foo.mk
+
+sport = tennis
+# Compilação condicional
+report:
+ifeq ($(sport),tennis)
+	@echo 'game, set, match'
+else
+	@echo "They think it's all over; it is now"
+endif
+
+# Há também ifneq, ifdef, ifndef
+
+foo = true
+
+ifdef $(foo)
+bar = 'hello'
+endif
+```
+
+### More Resources
+
++ [documentação gnu make](https://www.gnu.org/software/make/manual/)
++ [tutorial de carpintaria de software](http://swcarpentry.github.io/make-novice/)
++ aprenda C da maneira mais difícil [ex2](http://c.learncodethehardway.org/book/ex2.html) [ex28](http://c.learncodethehardway.org/book/ex28.html)
diff --git a/pt-br/markdown-pt.html.markdown b/pt-br/markdown-pt.html.markdown
index 7960a59a..fca864bb 100644
--- a/pt-br/markdown-pt.html.markdown
+++ b/pt-br/markdown-pt.html.markdown
@@ -8,7 +8,7 @@ translators:
     - ["Monique Baptista", "https://github.com/bfmonique"]
     - ["Marcel Ribeiro-Dantas", "https://github.com/mribeirodantas"]
 
-lang: pt-br    
+lang: pt-br
 filename: learnmarkdown-pt.md
 ---
 
@@ -213,8 +213,8 @@ adicionais) para indentação no seu código.
 
 ```md
     my_array.each do |item|
-        puts item
-    end	
+      puts item
+    end
 ```
 
 Código embutido pode ser criado usando o caractere de crase `` ` ``.
@@ -225,13 +225,13 @@ John não sabia nem o que a função `go_to()` fazia!
 
 No GitHub Flavored Markdown, você pode usar uma sintaxe especial para código.
 
-<pre>
-<code class="highlight">&#x60;&#x60;&#x60;ruby
+````md
+```ruby
 def foobar
-    puts "Olá mundo!"
+  puts "Olá mundo!"
 end
-&#x60;&#x60;&#x60;</code></pre>
-
+```
+````
 
 O texto acima não requer indentação, além disso o GitHub vai usar o destaque
 de sintaxe da linguagem qeu você especificar após a tag <code>```</code>.
@@ -272,11 +272,13 @@ Caminhos relativos funcionam também.
 
 O Markdown também suporta links para referências no texto.
 
-<pre><code class="highlight">&#x5b;<span class="nv">Clique nesse link</span>][<span class="ss">link1</span>] para mais informações!
-&#x5b;<span class="nv">Também cheque esse link</span>][<span class="ss">foobar</span>] se você quiser.
+```md
+[Clique nesse link][link1] para mais informações!
+[Também cheque esse link][foobar] se você quiser.
 
-&#x5b;<span class="nv">link1</span>]: <span class="sx">http://test.com/</span> <span class="nn">"Legal!"</span>
-&#x5b;<span class="nv">link2r</span>]: <span class="sx">http://foobar.biz/</span> <span class="nn">"Certo!"</span></code></pre>
+[link1]: http://test.com/ "Legal!"
+[link2r]: http://foobar.biz/ "Certo!"
+```
 
 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
@@ -285,10 +287,11 @@ IDs de referência podem ser qualquer um, desde que eles sejam únicos.
 Existe também a "nomeação implícita", que permite que você use o texto do link
 como o id:
 
-<pre><code class="highlight">&#x5b;<span class="nv">Isso</span>][] é um link.
-
-&#x5b;<span class="nv">Isso</span>]: <span class="sx">http://thisisalink.com/</span></code></pre>
+```md
+[Isso][] é um link.
 
+[Isso]: http://thisisalink.com/
+```
 
 Mas geralmente não são usados.
 
@@ -322,9 +325,11 @@ exclamação na frente!
 
 E estilo de referência funciona como esperado
 
-<pre><code class="highlight">!&#x5b;<span class="nv">Esse é o alt-attribute.</span>][<span class="ss">myimage</span>]
+```md
+![Esse é o alt-attribute.][myimage]
 
-&#x5b;<span class="nv">Minha imagem</span>]: <span class="sx">relative/urls/cool/image.jpg</span> <span class="nn">"se precisar de um título, está aqui"</span></code></pre>
+[Minha imagem]: relative/urls/cool/image.jpg "se precisar de um título, está aqui"
+```
 
 ## Miscelânea 
 
diff --git a/pt-br/matlab-pt.html.markdown b/pt-br/matlab-pt.html.markdown
index 947e0699..cd300f39 100644
--- a/pt-br/matlab-pt.html.markdown
+++ b/pt-br/matlab-pt.html.markdown
@@ -529,7 +529,6 @@ ans = a.multiplicarLatPor(a,1/3)
 % dois objetos PosicoesGPS.
 b = ClassePosicoesGPS(15.0, 32.0)
 c = a + b
-
 ```
 
 ## Mais sobre MATLAB
diff --git a/pt-br/pascal-pt.html.markdown b/pt-br/pascal-pt.html.markdown
index 72302695..15a92908 100644
--- a/pt-br/pascal-pt.html.markdown
+++ b/pt-br/pascal-pt.html.markdown
@@ -249,6 +249,5 @@ BEGIN // programa principal
     // escrever valor de inutil (sempre 3, já que salvainteiro não a altera)
     WRITELN('inutil = ', inutil); 
 END.
-
 ```
 
diff --git a/pt-br/php-composer-pt.html.markdown b/pt-br/php-composer-pt.html.markdown
index 145f5cab..0ae83cf9 100644
--- a/pt-br/php-composer-pt.html.markdown
+++ b/pt-br/php-composer-pt.html.markdown
@@ -115,7 +115,6 @@ composer update phpunit/phpunit
 # remover o pacote antigo e suas dependências primeiro
 composer remove --dev phpunit/phpunit
 composer require --dev phpunit/phpunit:^5.0
-
 ```
 
 ## Autoloader
@@ -142,6 +141,7 @@ No `composer.json`, adicione um campo 'autoload':
   }
 }
 ```
+
 Isso irá dizer ao autoloader para buscar na pasta `src` tudo o que estiver no namespace `\Acme\`.
 
 Você também pode [usar a PSR-0, um mapa de classes ou apenas listar os arquivos para incluir](https://getcomposer.org/doc/04-schema.md#autoload),
diff --git a/pt-br/php-pt.html.markdown b/pt-br/php-pt.html.markdown
index 7db6a671..dd2ebcf1 100644
--- a/pt-br/php-pt.html.markdown
+++ b/pt-br/php-pt.html.markdown
@@ -686,7 +686,6 @@ use Meu\Espaconominal as OutroEspaconominal;
 $cls = new OutroEspaconominal\MinhaClasse();
 
 */
-
 ```
 
 ## Mais informações
diff --git a/pt-br/pug-pt.html.markdown b/pt-br/pug-pt.html.markdown
new file mode 100644
index 00000000..bbecfad1
--- /dev/null
+++ b/pt-br/pug-pt.html.markdown
@@ -0,0 +1,210 @@
+---
+language: Pug
+contributors:
+  - ["Michael Warner", "https://github.com/MichaelJGW"]
+filename: index-pt.pug
+translators:
+  - ["Adaías Magdiel", "https://adaiasmagdiel.com/"]
+lang: pt-br
+---
+
+## Começando com Pug
+
+Pug é uma pequena linguagem que compila para HTML. Possui uma sintaxe limpa 
+com algumas funcionalidades adicionais, como declarações if e loops. Também pode ser utilizada 
+como uma linguagem de templates no lado do servidor para tecnologias como o Node.js.
+
+### The Language
+
+```pug
+//- Comentário de uma linha
+
+//- Comentário de
+    várias linhas
+
+//- ---TAGS---
+//- Básico
+div
+//- <div></div>
+h1
+//- <h1></h1>
+minha-propriaTag
+//- <minha-propriaTag></minha-propriaTag>
+
+//- Tags irmãs
+div
+div
+//- <div></div>
+    <div></div>
+
+//- Tags aninhadas
+div
+  div
+//- <div>
+      <div></div>
+    </div>
+
+//- Textos
+h1 Olá, pessoas
+//- <h1>Olá, pessoas</h1>
+
+//- Texto de várias linhas
+div.
+  Oi,
+  tudo bem?
+//- <div>
+      Oi,
+      tudo bem?
+    </div>
+
+//- ---ATRIBUTOS---
+div(class="minha-class" id="meu-id" meu-proprio-atributo="data" enabled)
+//- <div class="minha-class" id="meu-id" meu-proprio-atributo="data" enabled></div>
+
+//- Abreviações
+span.minha-class
+//- <span class="minha-class"></span>
+.minha-class
+//- <div class="minha-class"></div>
+div#meu-id
+//- <div id="meu-id"></div>
+div#meu-id.minha-class
+//- <div class="minha-class" id="meu-id"></div>
+
+
+//- ---JAVASCRIPT---
+- const lang = "pug";
+
+//- Javascript em várias linhas
+-
+  const lang = "pug";
+  const awesome = true;
+
+//- Classes com Javascript
+- const myClass = ['class1', 'class2', 'class3']
+div(class=myClass)
+//- <div class="class1 class2 class3"></div>
+
+//- Estilos com Javascript
+- const myStyles = {'color':'white', 'background-color':'blue'}
+div(styles=myStyles)
+//- <div styles="{&quot;color&quot;:&quot;white&quot;,&quot;background-color&quot;:&quot;blue&quot;}"></div>
+
+//- Atributos com Javascript
+- const myAttributes = {"src": "photo.png", "alt": "My Photo"}
+img&attributes(myAttributes)
+//- <img src="photo.png" alt="My Photo">
+- let disabled = false
+input(type="text" disabled=disabled)
+//- <input type="text">
+- disabled = true
+input(type="text" disabled=disabled)
+//- <input type="text" disabled>
+
+//- Templates com Javascript
+- const name = "Bob";
+h1 Olá, #{name}
+h1= name
+//- <h1>Olá, Bob</h1>
+//- <h1>Bob</h1>
+
+//- ---LOOPS---
+
+//- 'each' e 'for' tem a mesma função, aqui nós usaremos apenas 'each'.
+
+each value, i in [1,2,3]
+  p=value
+//-
+  <p>1</p>
+  <p>2</p>
+  <p>3</p>
+
+each value, index in [1,2,3]
+  p=value + '-' + index
+//-
+  <p>1-0</p>
+  <p>2-1</p>
+  <p>3-2</p>
+
+each value in []
+  p=value
+//- 
+
+each value in []
+  p=value
+else
+  p Sem valores
+
+//- <p>Sem valores</p>
+
+//- ---CONDICIONAIS---
+
+- const number = 5
+if number < 5
+  p o número é menor do que 5
+else if number > 5
+  p o número é maior do que 5
+else
+  p o número é 5
+//- <p>o número é 5</p>
+
+- const orderStatus = "Aguardando";
+case orderStatus
+  when "Aguardando"
+    p.warn Seu pedido está em espera
+  when "Completado"
+    p.success Seu pedido foi completado.
+  when -1
+    p.error Ocorreu algum erro
+  default
+    p Nenhum registro de pedido encontrado
+//- <p class="warn">Seu pedido está em espera</p>
+
+//- --INCLUINDO CONTEÚDOS--
+//- Caminho do arquivo -> "includes/nav.pug"
+h1 Indústrias ACME
+nav
+  a(href="index.html") Início
+  a(href="about.html") Sobre Nós
+
+//- Caminho do arquivo -> "index.pug"
+html
+  body
+    include includes/nav.pug
+//-
+  <html>
+    <body>
+      <h1>Indústrias ACME</h1>
+      <nav><a href="index.html">Início</a><a href="about.html">Sobre Nós</a></nav>
+    </body>
+  </html>
+
+//- Importando Javascript e CSS
+script
+  include scripts/index.js
+style
+  include styles/theme.css
+
+//- ---MIXIN---
+mixin basic
+  div Olá
++basic
+//- <div>Olá</div>
+
+mixin comment(nome, comentario)
+  div
+    span.comment-name= nome
+    div.comment-text= comentario
++comment("Gil", "Tudo é divino, tudo é maravilhoso")
+//- 
+  <div>
+    <span class="comment-name">Gil</span>
+    <div class="comment-text">Tudo é divino, tudo é maravilhoso</div>
+  </div>
+```
+
+
+### Saiba Mais
+- [Site Oficial](https://pugjs.org/)
+- [Documentação](https://pugjs.org/api/getting-started.html)
+- [Repositório no GitHub](https://github.com/pugjs/pug)
diff --git a/pt-br/pyqt-pt.html.markdown b/pt-br/pyqt-pt.html.markdown
index 40fe82d5..4b78d52b 100644
--- a/pt-br/pyqt-pt.html.markdown
+++ b/pt-br/pyqt-pt.html.markdown
@@ -24,7 +24,7 @@ o pyqt!
 ```python
 import sys
 from PyQt4 import QtGui
-	
+
 def window():
 	# Cria um objeto para a aplicação
     app = QtGui.QApplication(sys.argv)
@@ -46,7 +46,6 @@ def window():
 
 if __name__ == '__main__':
     window()
-
 ```
 
 Para utilizar mais funcionalidades no **pyqt** veremos a construção de alguns
@@ -54,7 +53,7 @@ outros elementos.
 Aqui mostraremos como criar uma janela popup, muito útil para perguntar ao
 usuário qual decisão tomar ou exibir alguma informação.
 
-```Python 
+```python
 import sys
 from PyQt4.QtGui import *
 from PyQt4.QtCore import *
@@ -73,7 +72,7 @@ def window():
     w.setWindowTitle("PyQt Dialog")
     w.show()
     sys.exit(app.exec_())
-	
+
 # Essa função deve criar uma janela de diálogo com um botão,
 # aguarda ser clicado e encerra o programa
 def showdialog():
diff --git a/pt-br/python-pt.html.markdown b/pt-br/python-pt.html.markdown
index 3f9c54c1..d47395b1 100644
--- a/pt-br/python-pt.html.markdown
+++ b/pt-br/python-pt.html.markdown
@@ -25,7 +25,6 @@ Observação: Este artigo trata de Python 3 especificamente. Verifique
 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
diff --git a/pt-br/pythonlegacy-pt.html.markdown b/pt-br/pythonlegacy-pt.html.markdown
index 572bb787..4de413bd 100644
--- a/pt-br/pythonlegacy-pt.html.markdown
+++ b/pt-br/pythonlegacy-pt.html.markdown
@@ -487,8 +487,6 @@ math.sqrt(16) == m.sqrt(16) #=> True
 # estão definidos em um módulo qualquer.
 import math
 dir(math)
-
-
 ```
 
 ## Pronto para mais?
diff --git a/pt-br/pythonstatcomp-pt.html.markdown b/pt-br/pythonstatcomp-pt.html.markdown
index aa532eb4..bf641223 100644
--- a/pt-br/pythonstatcomp-pt.html.markdown
+++ b/pt-br/pythonstatcomp-pt.html.markdown
@@ -14,9 +14,6 @@ Este é um tutorial sobre como fazer algumas tarefas típicas de programação e
 Stata, SAS, SPSS ou MATLAB.
 
 ```python
-
-
-
 # 0. Preparando-se ====
 
 """  Para começar, instale o seguinte : jupyther, numpy, scipy, pandas, 
@@ -237,7 +234,6 @@ sns.lmplot("BirthY", "EstAge", data=hre)
     Para ver uma versão da análise dos sagrados imperadores romanos usando R, consulte
       - http://github.com/e99n09/R-notes/blob/master/holy_roman_emperors_dates.R
 """
-
 ```
 
 Se você quiser saber mais, obtenha o Python para análise de dados de Wes McKinney. É um excelente recurso e usei-o como referência ao escrever este tutorial.
diff --git a/pt-br/r-pt.html.markdown b/pt-br/r-pt.html.markdown
index 5c9304ec..ad3734e5 100644
--- a/pt-br/r-pt.html.markdown
+++ b/pt-br/r-pt.html.markdown
@@ -13,7 +13,6 @@ filename: learnr-pt.r
 R é uma linguagem de programação estatística. Ela tem muitas bibliotecas para carregar e limpar conjuntos de dados, executar análises estatísticas e produzir gráficos. Você também pode executar comandos do `R` dentro de um documento LaTeX.
 
 ```r
-
 # Comentários começam com o símbolo de Cerquilha, também conhecido como
 # jogo da velha
 
@@ -775,9 +774,6 @@ ll <- as.data.table(lista1)
 pp <- ggplot(ll, aes(x=tempo,preco))
 pp + geom_point()
 # ggplot2 tem uma excelente documentação (disponível em http://docs.ggplot2.org/current/)
-
-
-
 ```
 
 ## Como faço para obter R?
diff --git a/pt-br/sass-pt.html.markdown b/pt-br/sass-pt.html.markdown
index 28df3c59..07f59fe7 100644
--- a/pt-br/sass-pt.html.markdown
+++ b/pt-br/sass-pt.html.markdown
@@ -4,6 +4,7 @@ filename: learnsass-pt.scss
 contributors:
   - ["Laura Kyle", "https://github.com/LauraNK"]
   - ["Sean Corrales", "https://github.com/droidenator"]
+  - ["Thalles Augusto", "https://github.com/Theslladev"]
 translators:
   - ["Gabriel Gomes", "https://github.com/gabrielgomesferraz"]
   - ["Cássio Böck", "https://github.com/cassiobsilva"]
@@ -16,11 +17,9 @@ Sass (e outros pré-processadores, como [Less](http://lesscss.org/)) ajudam os d
 Sass tem duas opções de sintaxe diferentes para escolher. SCSS, que tem a mesma sintaxe de CSS, mas com os recursos adicionais de Sass. Ou Sass (a sintaxe original), que usa o recuo, em vez de chaves e ponto e vírgula.
 Este tutorial é escrito usando SCSS.
 
-Se você já está familiarizado com CSS3, você será capaz de pegar Sass de forma relativamente rápida. Ele não fornece quaisquer novas opções de estilo, mas sim as ferramentas para escrever sua CSS de forma mais eficiente e fazer a manutenção mais fácilmente.
+Se você já está familiarizado com CSS3, você será capaz de pegar Sass de forma relativamente rápida. Ele não fornece quaisquer novas opções de estilo, mas sim as ferramentas para escrever sua CSS de forma mais eficiente e fazer a manutenção mais facilmente.
 
 ```scss
-
-
 // Comentários de linha única são removidos quando Sass é compilado para CSS.
 
 /* Comentários multi-line são preservados. */
@@ -249,7 +248,7 @@ ul {
 /* '&' 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.
+Essas práticas também recomendam não mais de 3 níveis de profundidade quando nidificação.
 Por exemplo: */
 
 
@@ -379,7 +378,7 @@ body {
 
 /* Sass fornece os seguintes operadores: +, -, *, /, e %. estes podem
    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 usar valores que você já calcula manualmente. O exemplo abaixo é
    de um projeto simples de duas colunas. */
 
 $content-area: 960px;
@@ -423,8 +422,6 @@ body {
 .gutter {
   width: 6.25%;
 }
-
-
 ```
 
 
diff --git a/pt-br/scala-pt.html.markdown b/pt-br/scala-pt.html.markdown
index 3459f567..92400670 100644
--- a/pt-br/scala-pt.html.markdown
+++ b/pt-br/scala-pt.html.markdown
@@ -14,7 +14,6 @@ lang: pt-br
 Scala - a linguagem escalável
 
 ```scala
-
 /////////////////////////////////////////////////
 // 0. O básico
 /////////////////////////////////////////////////
diff --git a/pt-br/self-pt.html.markdown b/pt-br/self-pt.html.markdown
index eb821474..0fadf58d 100644
--- a/pt-br/self-pt.html.markdown
+++ b/pt-br/self-pt.html.markdown
@@ -117,6 +117,7 @@ Múltiplas expressões são separadas por ponto final. ^ retorna imediatamente.
 ```
 
 Blocos são realizados (completados) ao enviá-los a mensagem 'value' e herdando (imcumbir a) seus contextos:
+
 ```
 "retorna 0"
 [|x|
diff --git a/pt-br/set-theory-pt.html.markdown b/pt-br/set-theory-pt.html.markdown
new file mode 100644
index 00000000..3ec75510
--- /dev/null
+++ b/pt-br/set-theory-pt.html.markdown
@@ -0,0 +1,133 @@
+---
+category: Algorithms & Data Structures
+name: Set theory
+lang: pt-br
+contributors:
+    - ["Andrew Ryan Davis", "https://github.com/AndrewDavis1191"]
+translators:
+    - ["Bárbara Luz", "https://github.com/barbluz"]
+---
+
+Teoria de conjuntos é uma área da matemática que estuda conjuntos, suas operações e propriedades.
+- Um conjunto é uma coleção de itens disjuntos.
+
+## Símbolos básicos
+
+### Operações
+- a operação de união `∪`, significa "ou"
+- a operação de interseção `∩`, que significa "e"
+- a operação de exclusão `\`, significa "sem" ou "menos"
+- a operação de conjunto complementar `'`, que significa "o inverso de"
+- a operação de produto cartesiano `×`,que significa "o produto cartesiano de"
+
+### Outros símbolos
+- `:` ou `|`, símbolos que significam "tal que"
+- o símbolo de pertencimento `∈`, que significa "pertence a"
+- o símbolo `⊆`, que significa "subconjunto de" (neste caso, o subconjunto pode ser igual ao conjunto)
+- o símbolo `⊂`, que significa "subconjunto próprio" (neste caso, o subconjunto não pode ser igual ao conjunto)
+
+### Conjuntos canônicos
+- `∅`, o conjunto vazio, isto é, o conjunto que não possui itens
+- `ℕ`, o conjunto de todos os números naturais
+- `ℤ`, o conjunto de todos os números inteiros
+- `ℚ`, o conjunto de todos os números racionais
+- `ℝ`, o conjunto de todos os números reais
+
+Existem algumas ressalvas sobre os conjuntos canônicos:
+- Apesar de o conjunto vazio não conter itens, o conjunto vazio é subconjunto de si mesmo (e portanto de todos os outros conjuntos)
+- Matemáticos geralmente não concordam sobre o zero ser um número natural e os livros tipicamente explicitam se o autor considera ou não o zero como um número natural
+
+
+### Cardinalidade
+A cardinalidade (ou tamanho) de um conjunto é determinado pela quantidade de itens no conjunto. O operador de cardinalidade é `|...|`
+
+Por exemplo, se `S = {1, 2, 4}`, então `|S| = 3`.
+
+### O Conjunto Vazio
+- o conjunto vazio pode ser contruído em notação de conjuntos utilizando condições impossíveis, como por exemplo: `∅ = { x : x ≠ x }`, ou `∅ = { x : x ∈ N, x < 0 }`
+- o conjunto vazio é sempre único (ou seja, existe um e apenas um conjunto vazio)
+- o conjunto vazio é subconjunto de todos os conjuntos
+- a cardinalidade do conjunto vazio é `0`, ou seja, `|∅| = 0`.
+
+## Representando conjuntos
+
+### Definição Literal
+Um conjunto pode ser contruído literalmente fornecendo uma lista completa dos itens contigos no conjunto. Por exemplo `S = { a, b, c, d }`
+
+Listas longas podem ser encurtadas com reticências, desde que o contexto seja claro. Por exemplo, `E = { 2, 4, 6, 8, ... }` é claramente o conjunto de todos os números pares, contendo um número infinito de objetos, embora só tenhamos escrito explicitamente quatro deles.
+
+### Definição por compreensão
+Conjuntos também podem ser descritos de uma maneira mais descritiva, baseando-se em sujeito e predicado, de forma tal que `S = {sujeito : predicado}`. Por exemplo:
+
+```
+A = { x : x é uma vogal } = { a, e, i, o, u }         (lê-se x, tal que x é uma vogal)
+B = { x : x ∈ N, x < 10 } = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }
+C = { x : x = 2k, k ∈ N } = { 0, 2, 4, 6, 8, ... }
+```
+
+Ou pode-se também aplicar uma função ao sujeito, ex:
+
+```
+D = { 2x : x ∈ N } = { 0, 2, 4, 6, 8, ... }
+```
+
+## Relações
+
+### Pertencimento
+- Se um valor `a` está contido num conjunto `A`, então dizemos que `a` pertence a `A` e denotamos por `a ∈ A`
+- Se o valor `a` não está contido no conjunto `A`, então dizemos que `a` não pertence a `A` e denotamos por `a ∉ A`
+
+### Igualdade
+- Se dois conjuntos contém os mesmos itens, então dizemos que os conjuntos são iguals, ex. `A = B`
+- A ordenação não importa quando vamos avaliar a igualdade, ex: `{ 1, 2, 3, 4 } = { 2, 3, 1, 4 }`
+- Conjuntos são disjuntos, o que significa que os elementos não podem ser repetidos, ex: `{ 1, 2, 2, 3, 4, 3, 4, 2 } = { 1, 2, 3, 4 }`
+- Dois conjuntos `A` e `B` são iguais se, e somente se, `A ⊆ B` e `B ⊆ A`
+
+### Conjuntos especiais
+O Conjunto das Partes
+- Seja `A` um conjunto qualquer. O conjunto que contém todos os possíveis subconjuntos de `A` é chamado "conjunto das partes" e é denotado como `P(A)`. Se o conjunto `A` contém `n` elementos, então o conjunto das partes conterá `2^n` elementos.
+
+```
+P(A) = { x : x ⊆ A }
+```
+
+## Operações entre dois conjuntos
+
+### União
+Dados dois conjuntos `A` e `B`, a união entre esses dois conjuntos são os itens que aparecem em `A` ou em `B`, denotado por `A ∪ B`.
+
+```
+A ∪ B = { x : x ∈ A ∪ x ∈ B }
+```
+
+### Interseção
+Dados dois conjuntos `A` e `B`, a interseção entre esses dois conjuntos são os itens que aparecem em `A` e em `B`, denotado por `A ∩ B`.
+
+```
+A ∩ B = { x : x ∈ A, x ∈ B }
+```
+
+### Diferença
+Dados dois conjuntos `A` e `B`, o conjunto da diferença entre `A` e `B` são todos os itens de `A` que não pertencem a `B`.
+
+```
+A \ B = { x : x ∈ A, x ∉ B }
+```
+
+### Diferença simétrica
+Dados dois conjuntos `A` e `B`, a diferença simétrica são todos os itens entre `A` e `B` que não aparecem na interseção desses dois conjuntos.
+
+```
+A △ B = { x : ((x ∈ A) ∩ (x ∉ B)) ∪ ((x ∈ B) ∩ (x ∉ A)) }
+
+A △ B = (A \ B) ∪ (B \ A)
+```
+
+### Produto Cartesiano
+Dados dois conjuntos `A` e `B`, o produto cartesiano de `A` e `B` consiste no conjunto contendo todas as combinações dos itens de `A` e `B`.
+
+```
+A × B = { (x, y) | x ∈ A, y ∈ B }
+```
+
+
diff --git a/pt-br/stylus-pt.html.markdown b/pt-br/stylus-pt.html.markdown
index 40c3c02c..c5a949de 100755..100644
--- a/pt-br/stylus-pt.html.markdown
+++ b/pt-br/stylus-pt.html.markdown
@@ -16,7 +16,6 @@ Stylus não fornece novas opções de estilos, mas dá funcionalidades que permi
 
 
 ```scss
-
 /* Estilo de código
 ==============================*/
 
@@ -222,7 +221,6 @@ 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 largura pelo número da coluna*
-
 ```
 
 Agora que você conhece um pouco sobre esse poderoso pré-processador de CSS, você está pronto para criar folhas de estilos mais dinâmicas. Para aprofundar seus conhecimentos visite a documentação oficial do stylus em http://stylus-lang.com.
diff --git a/pt-br/swift-pt.html.markdown b/pt-br/swift-pt.html.markdown
index 96b96427..7f03c8a1 100644
--- a/pt-br/swift-pt.html.markdown
+++ b/pt-br/swift-pt.html.markdown
@@ -497,5 +497,4 @@ println(mySquare.sideLength) // 4
 // Troca o comprimento do lado usando um operador personalizado !!!, aumenta o lado por 3
 !!!mySquare
 println(mySquare.sideLength) // 12
-
 ```
diff --git a/pt-br/tmux-pt.html.markdown b/pt-br/tmux-pt.html.markdown
index e2130e0a..f3764b1f 100644
--- a/pt-br/tmux-pt.html.markdown
+++ b/pt-br/tmux-pt.html.markdown
@@ -14,7 +14,6 @@ ele permite criar vários terminais e gerenciar tudo na mesma interface.
 tmux pode também rodar em background e depois ser recuperado(exibido) novamente.
 
 ```
-
   tmux [command]     # Roda um [comando]
                      # 'tmux' sem comandos irá criar uma nova seção
 
@@ -48,7 +47,6 @@ tmux pode também rodar em background e depois ser recuperado(exibido) novamente
      -t "#"          # Encerrar seção com nome "#"
      -a              # Encerrar todas as seções
      -a -t "#"       # Encerrar todas as seções exceto a "#"
-
 ```
 
 ### Teclas de atalhos (comandos)
@@ -103,7 +101,6 @@ As seções tmux acopladas são controladas através de teclas de atalho. (prefi
 
   M-Up, M-Down       # Altera o tamanho do painel atual em cinco células.
   M-Left, M-Right
-
 ```
 
 
@@ -227,7 +224,6 @@ set -g status-left "#[fg=red] #H#[fg=green]:#[fg=white]#S#[fg=green] |#[default]
 # Requires https://github.com/thewtex/tmux-mem-cpu-load/
 set -g status-interval 4
 set -g status-right "#[fg=green] | #[fg=white]#(tmux-mem-cpu-load)#[fg=green] | #[fg=cyan]%H:%M #[default]"
-
 ```
 
 
diff --git a/pt-br/toml-pt.html.markdown b/pt-br/toml-pt.html.markdown
new file mode 100644
index 00000000..bdb1decf
--- /dev/null
+++ b/pt-br/toml-pt.html.markdown
@@ -0,0 +1,232 @@
+---
+language: toml
+filename: learntoml-pt.toml
+contributors:
+  - ["Alois de Gouvello", "https://github.com/aloisdg"]
+translators:
+  - ["Adaías Magdiel", "https://adaiasmagdiel.com/"]
+lang: pt-br
+---
+
+TOML significa Tom's Obvious, Minimal Language. É uma linguagem de serialização de dados projetada para ser um formato de arquivo de configuração mínimo que é fácil de ler devido à semântica óbvia.
+
+É uma alternativa ao YAML e JSON. Tem como objetivo ser mais amigável para humanos do que JSON e mais simples que YAML. TOML é projetado para mapear de forma inequívoca para uma tabela de hash e deve ser fácil de converter em estruturas de dados em uma ampla variedade de linguagens.
+
+Cuidado, a especificação do TOML ainda passa por muitas mudanças. Até que seja marcado como 1.0, você deve assumir que é instável e agir de acordo. Este documento segue o TOML v0.4.0.
+
+```toml
+# Comentários em TOML são feitos desta forma.
+
+###################
+# TIPOS ESCALARES #
+###################
+
+# Nosso objeto raiz (que continuará por todo o documento) será um mapa,
+# que é equivalente a um dicionário, hash ou objeto em outras linguagens.
+
+# A chave, o sinal de igual e o valor precisam estar na mesma linha
+# (embora alguns valores possam ser quebrados em várias linhas).
+chave = "valor"
+string = "Olá"
+number = 42
+float = 3.14
+boolean = true
+dateTime = 2002-07-16T20:32:00-03:00
+scientificNotation = 1e+12
+"chaves podem estar entre aspas" = true # Tanto " quanto ' são aceitáveis
+"chaves podem conter" = "letras, números, underscores e hífens"
+
+# Uma chave não pode ser vazia, mas uma chave vazia entre aspas é permitido
+"" = "blank" # VÁLIDO mas não é recomendado
+'' = 'blank' # VÁLIDO mas não é recomendado
+
+##########
+# String #
+##########
+
+# Todas as strings precisam ter apenas caracteres UTF-8 válidos.
+# Podemos escapar caracteres e alguns deles têm uma sequência de escape compacta.
+# Por exemplo: \t adiciona uma tabulação. Leia a spec para conhecer todos.
+basicString = "São cercadas por aspas. \"Sou digno de citação\". Nome\tJosé."
+
+multiLineString = """
+são cercadas por três aspas
+em cada lado e permitem novas linhas."""
+
+literalString = 'são cercadas por aspas simples. Escape de caracteres não é permitido.'
+
+multiLineString = '''
+são cercadas por três aspas simples em cada lado
+e permitem novas linhas. Escape de caracteres também não é permitido.
+A primeira quebra de linha é removida em strings brutas
+   Todo outro espaço em branco
+   é preservado. #! foi preservado?
+'''
+
+# Para dados binários é recomendado que você use Base64, outra codificação ASCII ou UTF8.
+# A manipulação dessa codificação será específico da aplicação.
+
+############
+# Inteiros #
+############
+
+## Inteiros podem começar com um +, um -, ou nada.
+## Zeros à frente não são permitidos.
+## Formatos em hexadecimal, octal e binário são permitidos.
+## Não são permitidos valores que não podem ser expressados como uma série de dígitos.
+int1 = +42
+int2 = 0
+int3 = -21
+int4 = 0xcafebabe
+int5 = 0o755
+int6 = 0b11011100
+integerRange = 64
+
+## Você pode usar underscores para melhorar a legibilidade.
+## Cada underscore precisa estar entre, pelo menos, um dígito.
+int7 = 5_349_221
+int8 = 1_2_3_4_5     # VÁLIDO, mas não é recomendado
+
+#########
+# Float #
+#########
+
+# Floats são inteiros seguidos por uma fração e/ou de um expoente.
+flt1 = 3.1415
+flt2 = -5e6
+flt3 = 6.626E-34
+
+#############
+# Booleanos #
+#############
+
+bool1 = true
+bool2 = false
+booleanosPrecisamEstarEmMinusculo = true
+
+############
+# Datetime #
+############
+
+date1 = 1979-05-27T07:32:00Z # Tempo UTC, seguindo especificação RFC 3339/ISO 8601
+date2 = 1979-05-26T15:32:00+08:00 # com um deslocamento segundo a RFC 3339/ISO 8601
+date3 = 1979-05-27T07:32:00 # sem deslocamento
+date4 = 1979-05-27 # sem as horas e sem deslocamento
+
+####################
+# TIPOS DE COLEÇÃO #
+####################
+
+#########
+# Array #
+#########
+
+array1 = [ 1, 2, 3 ]
+array2 = [ "Vírgulas", "são", "delimitadores" ]
+array3 = [ "Não misture", "tipos", "diferentes" ]
+array4 = [ [ 1.2, 2.4 ], ["todas as", 'strings', """são do mesmo""", '''tipo'''] ]
+array5 = [
+  "Espaços em branco", "são", "ignorados"
+]
+
+##########
+# Tabela #
+##########
+
+# Tabelas (ou tabelas de hash, ou dicionários) é uma coleção de pares chave/valor.
+# Eles aparecem entre colchetes em uma linha separada.
+# Tabelas vazias são permitidas e simplesmente não possuem chave/valor associado.
+[tabela]
+
+# Abaixo disso, e até a próxima tabela ou final do arquivo, estão as chaves/valores dessa tabela.
+# Os pares de chave/valor dentro das tabelas não têm garantia de estar em nenhuma ordem específica.
+[table-1]
+chave1 = "algum texto"
+chave2 = 123
+
+[table-2]
+chave1 = "outro texto"
+chave2 = 456
+
+# Pontos são proibidos em chaves simples porque são usados para indicar tabelas aninhadas.
+# As regras de nomenclatura para cada parte separada por ponto são as mesmas que para chaves.
+[dog."tater.man"]
+type = "pug"
+
+# Na terra do JSON, você teria a seguinte estrutura:
+# { "dog": { "tater.man": { "type": "pug" } } }
+
+# Espaços em branco em torno das partes separadas por pontos são ignorados, de qualquer forma,
+# é sempre recomendado não utilizar espaços em branco desnecessários.
+[a.b.c]            # isso é o recomendado
+[ d.e.f ]          # mesmo que [d.e.f]
+[ j . "ʞ" . 'l' ]  # mesmo que [j."ʞ".'l']
+
+# Você não precisa especificar todas as super-tabelas se não quiser. TOML sabe
+# como lidar com isso para você.
+# [x] você
+# [x.y] não precisa
+# [x.y.z] disso
+[x.y.z.w] # para isso funcionar
+
+# Mesmo que uma super-tabela não tenha sido definida diretamente e não tenha definido uma
+# chave específica, ainda é possível escrever nela.
+[a.b]
+c = 1
+
+[a]
+d = 2
+
+# Irá gerar o seguinte JSON:
+# { "a": {"b": {"c": 1}, "d": 2 } }
+
+# Você não pode definir uma chave ou tabela mais de uma vez. É inválido fazer isso.
+
+# NÃO FAÇA ISSO
+[a]
+b = 1
+
+[a]
+c = 2
+
+# NEM MESMO ISSO
+[a]
+b = 1
+
+[a.b]
+c = 2
+
+# O nome de todas as tabelas não pode ser vazio.
+[]     # INVÁLIDO
+[a.]   # INVÁLIDO
+[a..b] # INVÁLIDO
+[.b]   # INVÁLIDO
+[.]    # INVÁLIDO
+
+####################
+# Tabelas em linha #
+####################
+
+tabelasEmLinha = { sãoFechadasCom = "{ e }", precisamEstarEmUmaLinha = true }
+ponto = { x = 1, y = 2 }
+
+####################
+# Array de Tabelas #
+####################
+
+# Um array de tabelas pode ser expresso usando um nome de tabela entre colchetes duplos.
+# Cada tabela com o mesmo nome entre colchetes duplos será um item no array.
+# As tabelas são inseridas na ordem em que são encontradas.
+
+[[produtos]]
+nome = "array de tabelas"
+sku = 738594937
+tabelasVaziasSaoPermitidas = true
+
+[[produtos]]
+
+[[produtos]]
+nome = "Unhas"
+sku = 284758393
+color = "cinza"
+```
diff --git a/pt-br/typescript-pt.html.markdown b/pt-br/typescript-pt.html.markdown
index 7d28bf53..5888b641 100644
--- a/pt-br/typescript-pt.html.markdown
+++ b/pt-br/typescript-pt.html.markdown
@@ -161,7 +161,6 @@ var tuple = pairToTuple({ item1:"hello", item2:"world"});
 
 // Incluindo referências a um arquivo de definição:
 /// <reference path="jquery.d.ts" />
-
 ```
 
 ## Leitura adicional
diff --git a/pt-br/visualbasic-pt.html.markdown b/pt-br/visualbasic-pt.html.markdown
index 81292798..ff6dea7f 100644
--- a/pt-br/visualbasic-pt.html.markdown
+++ b/pt-br/visualbasic-pt.html.markdown
@@ -8,7 +8,7 @@ lang: pt-br
 filename: learnvisualbasic-pt.vb
 ---
 
-```
+```visualbasic
 Module Module1
 
 module Module1
@@ -273,7 +273,6 @@ module Module1
     End Sub
 
 End Module
-
 ```
 
 ##Referências
diff --git a/pt-br/xml-pt.html.markdown b/pt-br/xml-pt.html.markdown
index 6710b387..85df2b9e 100644
--- a/pt-br/xml-pt.html.markdown
+++ b/pt-br/xml-pt.html.markdown
@@ -63,8 +63,6 @@ Ao contrário de HTML, XML não especifica como exibir ou formatar os dados, ape
 	
 <!-- Abaixo, um elemento com dois atributos -->
 <arquivo type="gif" id="4293">computer.gif</arquivo>
-
-
 ```
 
 * Documento bem formatado x Validação
@@ -79,7 +77,6 @@ esse documento.
 Com esta ferramenta, você pode verificar os dados XML fora da lógica da aplicação.
 
 ```xml
-
 <!-- Abaixo, você pode ver uma versão simplificada do documento livraria,
 com a adição de definição DTD.-->
 
diff --git a/pt-br/yaml-pt.html.markdown b/pt-br/yaml-pt.html.markdown
index b2fb2a7d..a1c82e5e 100644
--- a/pt-br/yaml-pt.html.markdown
+++ b/pt-br/yaml-pt.html.markdown
@@ -179,6 +179,7 @@ conjunto2:
 
 ...  # fim do documento
 ```
+
 ### Mais Recursos
 
 + [Site Oficial do YAML](https://yaml.org/)