Merge branch 'master' into elixir-casing

16 files changed, 1038 insertions, 39 deletions

diff --git a/pt-br/asciidoc-pt.html.markdown b/pt-br/asciidoc-pt.html.markdown
index b12c0693..9fca5af0 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
diff --git a/pt-br/awk-pt.html.markdown b/pt-br/awk-pt.html.markdown
index 597b0e7a..02bffc41 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
diff --git a/pt-br/bc-pt.html.markdown b/pt-br/bc-pt.html.markdown
new file mode 100644
index 00000000..2a412806
--- /dev/null
+++ b/pt-br/bc-pt.html.markdown
@@ -0,0 +1,104 @@
+---
+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/c++-pt.html.markdown b/pt-br/c++-pt.html.markdown
index 7d8b75f1..ca289001 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>"
 }
 
diff --git a/pt-br/c-pt.html.markdown b/pt-br/c-pt.html.markdown
index c3f62bc6..22a86376 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).
diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown
index 475c0568..87e5b3a4 100644
--- a/pt-br/csharp-pt.html.markdown
+++ b/pt-br/csharp-pt.html.markdown
@@ -153,7 +153,7 @@ on a new line! ""Wow!"", the masses cried";
             intArray[1] = 1;
 
             // Listas
-            // Listas são usadas frequentemente tanto quanto matriz por serem mais flexiveis
+            // Listas são usadas frequentemente tanto quanto matriz por serem mais flexíveis
             // O formato de declarar uma lista é o seguinte:
             // List<tipodado> <var nome> = new List<tipodado>();
             List<int> intList = new List<int>();
diff --git a/pt-br/d-pt.html.markdown b/pt-br/d-pt.html.markdown
new file mode 100644
index 00000000..ae4bab22
--- /dev/null
+++ b/pt-br/d-pt.html.markdown
@@ -0,0 +1,262 @@
+---
+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/elixir-pt.html.markdown b/pt-br/elixir-pt.html.markdown
index 06ea8fbb..18441ff7 100644
--- a/pt-br/elixir-pt.html.markdown
+++ b/pt-br/elixir-pt.html.markdown
@@ -98,7 +98,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
@@ -167,7 +167,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
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/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/pug-pt.html.markdown b/pt-br/pug-pt.html.markdown
new file mode 100644
index 00000000..a74666fb
--- /dev/null
+++ b/pt-br/pug-pt.html.markdown
@@ -0,0 +1,211 @@
+---
+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/sass-pt.html.markdown b/pt-br/sass-pt.html.markdown
index 28df3c59..e5175857 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,7 +17,7 @@ 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
 
@@ -249,7 +250,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 +380,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;
diff --git a/pt-br/set-theory-pt.html.markdown b/pt-br/set-theory-pt.html.markdown
new file mode 100644
index 00000000..58fd7979
--- /dev/null
+++ b/pt-br/set-theory-pt.html.markdown
@@ -0,0 +1,129 @@
+---
+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/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/visualbasic-pt.html.markdown b/pt-br/visualbasic-pt.html.markdown
index 2a7205cd..81292798 100644
--- a/pt-br/visualbasic-pt.html.markdown
+++ b/pt-br/visualbasic-pt.html.markdown
@@ -28,12 +28,12 @@ module Module1
         Console.WriteLine ("2. Entrada Olá Mundo" )
         Console.WriteLine ("3. Cálculando números inteiros " )
         Console.WriteLine ("4. Calculando números decimais " )
-        Console.WriteLine ("5 . Calculadora de Trabalho " )
+        Console.WriteLine ("5. Calculadora de Trabalho " )
         Console.WriteLine ("6. Usando Do While Loops " )
         Console.WriteLine ("7. Usando Para While Loops " )
-        Console.WriteLine ("8 . Declarações condicionais " )
+        Console.WriteLine ("8. Declarações condicionais " )
         Console.WriteLine ("9. Selecione uma bebida" )
-        Console.WriteLine ("50 . About" )
+        Console.WriteLine ("50. About" )
         Console.WriteLine ("Por favor, escolha um número da lista acima " )
         Seleção Dim As String = Console.ReadLine
         Select A seleção dos casos
@@ -76,7 +76,7 @@ module Module1
     End Sub
 
     ' Um - Eu estou usando números para ajudar com a navegação acima quando eu voltar
-    ' depois de construí-lo .
+    ' depois de construí-lo.
 
     " Nós usamos subs privadas para separar diferentes seções do programa.
     Private Sub HelloWorldOutput ()
@@ -94,12 +94,12 @@ module Module1
         Console.Title = " Olá Mundo YourName | Saiba X em Y Minutes"
         ' Variáveis
         'Os dados inseridos por um usuário precisam ser armazenados.
-        ' As variáveis ​​também começar com um Dim e terminar com um Como VariableType .
+        ' As variáveis ​​também começar com um Dim e terminar com um Como VariableType.
 
         ' Neste tutorial, nós queremos saber qual é o seu nome, e faça o programa
         ' Responder ao que é dito.
         Nome de usuário Dim As String
-        " Nós usamos string como string é uma variável de texto baseado .
+        " Nós usamos string como string é uma variável de texto baseado.
         Console.WriteLine (" Olá, Qual é o seu nome? ") ' Peça ao usuário seu nome.
         username = Console.ReadLine () ' armazena o nome do usuário.
         Console.WriteLine (" Olá " + username) ' A saída é "Olá < seu nome >".
@@ -124,10 +124,10 @@ module Module1
     'Quatro
     Sub CalculatingDecimalNumbers particulares ()
         Console.Title = " Calculando com duplo | Saiba X em Y Minutes"
-        ' Claro que gostaria de ser capaz de somar decimais .
+        ' Claro que gostaria de ser capaz de somar decimais.
         " Por isso, poderia mudar o acima de Integer para Double.
 
-        " Digite um número inteiro , 1,2 , 2,4 , 50,1 , 104,9 ect
+        " Digite um número inteiro como 1, 2, 50, 104, etc
         Console.Write ("Primeiro número:")
         Dim a As Double = Console.ReadLine
         Console.Write ("Segundo número:") 'Enter segundo número inteiro.
@@ -141,9 +141,9 @@ module Module1
     ' Cinco
     Private Sub WorkingCalculator ()
         Console.Title = " A Calculadora de Trabalho | Saiba X em Y Minutes"
-        " No entanto, se você gostaria que a calculadora para subtrair, dividir , múltiplos e
+        " No entanto, se você gostaria que a calculadora para subtrair, dividir, múltiplos e
         ' somar.
-        ' Copie e cole o código acima novamente .
+        ' Copie e cole o código acima novamente.
         Console.Write ("Primeiro número:")
         Dim a As Double = Console.ReadLine
         Console.Write ("Segundo número:") 'Enter segundo número inteiro.
@@ -153,7 +153,7 @@ module Module1
         Dim e As Integer = a - b
         Dim f As Integer = a / b
 
-        " Ao adicionar as linhas abaixo , somos capazes de calcular a subtração ,
+        " Ao adicionar as linhas abaixo, somos capazes de calcular a subtração,
         ' multply bem como dividir os valores de a e b
         Console.Gravar ( a.ToString ( ) + " + " + b.ToString ( ) )
         'Queremos pad as respostas para a esquerda por três espaços.
@@ -172,8 +172,8 @@ module Module1
     Sub UsingDoWhileLoops particulares ()
         ' Assim como o sub privado anterior
         ' Desta vez, perguntar se o usuário deseja continuar ( Sim ou Não ? )
-        ' Estamos usando Do While Loop , como não temos certeza se o usuário quer usar o
-        'programa mais de uma vez .
+        ' Estamos usando Do While Loop, como não temos certeza se o usuário quer usar o
+        'programa mais de uma vez.
         Console.Title = " UsingDoWhileLoops | Saiba X em Y Minutes"
         Dim resposta As String ' Nós usamos a variável " String" como a resposta é um texto
         Do ' Começamos o programa com
@@ -195,12 +195,12 @@ module Module1
             Console.Write ( a.ToString () + "/" + b.ToString ())
             Console.WriteLine (" =" + e.ToString.PadLeft (3) )
             Console.ReadLine ()
-            ' Faça a pergunta , se o usuário deseja continuar? Infelizmente,
+            ' Faça a pergunta, se o usuário deseja continuar? Infelizmente,
             "é sensível a maiúsculas.
             Console.Write ( "Deseja continuar? (Sim / não )")
             " O programa pega a variável e imprime e começa de novo.
             answer = Console.ReadLine
-        " O comando para a variável para trabalhar seria , neste caso, " sim "
+        " O comando para a variável para trabalhar seria, neste caso, " sim "
         Loop While resposta = "yes"
 
     End Sub
@@ -233,7 +233,7 @@ module Module1
         outro
             Console.WriteLine (" Olá " + nome do usuário)
             Console.WriteLine (" Você check-out www.learnxinyminutes.com " )
-            Console.ReadLine () ' Fins e imprime a declaração acima .
+            Console.ReadLine () ' Fins e imprime a declaração acima.
         End If
     End Sub
 
@@ -242,15 +242,15 @@ module Module1
     Console.Title = "Se Declaração / Else | Saiba X em Y Minutes"
         'Às vezes é importante ter em conta mais de duas alternativas.
         'Às vezes, há um bom número de outros.
-        'Quando este for o caso , mais do que uma if seria necessária .
-        'Uma instrução if é ótimo para máquinas de venda automática . Quando o usuário digita um código.
-        ' A1 , A2, A3 , ect para selecionar um item.
+        'Quando este for o caso, mais do que uma if seria necessária.
+        'Uma instrução if é ótimo para máquinas de venda automática. Quando o usuário digita um código.
+        ' A1, A2, A3, etc para selecionar um item.
         'Todas as opções podem ser combinadas em uma única if.
 
         Seleção Dim Valor String = Console.ReadLine ' para a seleção
             Console.WriteLine (" A1. Para Soda " )
             Console.WriteLine (" A2. Para Fanta " )
-            Console.WriteLine (" A3 . Para Guaraná" )
+            Console.WriteLine (" A3. Para Guaraná" )
             Console.WriteLine (" A4. Para Coca Diet" )
             Console.ReadLine ()
             Se a seleção = "A1" Então
diff --git a/pt-br/yaml-pt.html.markdown b/pt-br/yaml-pt.html.markdown
index 732a36ad..b2fb2a7d 100644
--- a/pt-br/yaml-pt.html.markdown
+++ b/pt-br/yaml-pt.html.markdown
@@ -74,7 +74,8 @@ um_mapa_aninhado:
 # Mapas não tem que ter chaves com string.
 0.25: uma chave com valor flutuante
 
-# As chaves podem ser também objetos multi linhas, utilizando ? para indicar o começo de uma chave.
+# As chaves podem ser complexas, como sequência de várias linhas
+# Utilizando ? seguido por espaço para indicar o começo de uma chave complexa.
 ? |
   Esta é uma chave
   que tem várias linhas
@@ -91,13 +92,13 @@ um_mapa_aninhado:
 uma_sequencia:
   - Item 1
   - Item 2
-  - 0.5 # sequencias podem conter tipos diferentes.
+  - 0.5 # sequências podem conter tipos diferentes.
   - Item 4
   - chave: valor
     outra_chave: outro_valor
   -
-    - Esta é uma sequencia
-    - dentro de outra sequencia
+    - Esta é uma sequência
+    - dentro de outra sequência
   - - - Indicadores de sequência aninhadas
       - podem ser recolhidas
 
@@ -170,7 +171,7 @@ conjunto:
   ? item3
 ou: {item1, item2, item3}
 
-# Como Python, são apenas conjuntos de mapas com valors nulos; o acima é equivalente a:
+# Como Python, são apenas conjuntos de mapas com valores nulos; o acima é equivalente a:
 conjunto2:
   item1: null
   item2: null