From d1b75f63352338bcbb1af6731c9a47b977a6be24 Mon Sep 17 00:00:00 2001
From: Raphael Nascimento <raphaelbn10@gmail.com>
Date: Thu, 8 Oct 2015 23:39:00 -0300
Subject: translation clojure-macros to pt br

---
 pt-br/clojure-macros-pt.html.markdown | 154 ++++++++++++++++++++++++++++++++++
 1 file changed, 154 insertions(+)
 create mode 100644 pt-br/clojure-macros-pt.html.markdown

(limited to 'pt-br')

diff --git a/pt-br/clojure-macros-pt.html.markdown b/pt-br/clojure-macros-pt.html.markdown
new file mode 100644
index 00000000..dbc0c25c
--- /dev/null
+++ b/pt-br/clojure-macros-pt.html.markdown
@@ -0,0 +1,154 @@
+---
+language: clojure
+filename: learnclojure-pt.clj
+contributors:
+    - ["Adam Bard", "http://adambard.com/"]
+translators:
+    - ["Raphael Bezerra do Nascimento"]
+lang: pt-br
+---
+
+Como todas as Lisps, a inerente [homoiconicity](https://en.wikipedia.org/wiki/Homoiconic)
+do Clojure lhe dá acesso a toda a extensão da linguagem 
+para escrever rotinas de geração de código chamados "macros". Macros fornecem uma poderosa forma de adequar a linguagem 
+às suas necessidades.
+
+Pórem Tenha cuidado. É considerado má pratica escrever uma macro quando uma função vai fazer. Use uma macro apenas 
+quando você precisar do controle sobre quando ou se os argumentos para um formulário será avaliado.
+
+Você vai querer estar familiarizado com Clojure. Certifique-se de entender tudo em 
+[Clojure em Y Minutos](/docs/clojure/).
+
+```clojure
+;; Defina uma macro utilizando defmacro. Sua macro deve ter como saida uma lista que possa
+;; ser avaliada como codigo Clojure.
+;;
+;; Essa macro é a mesma coisa que se você escrever (reverse "Hello World")
+(defmacro my-first-macro []
+  (list reverse "Hello World"))
+
+;; Inspecione o resultado de uma macro utilizando macroexpand or macroexpand-1.
+;;
+;; Note que a chamada deve utilizar aspas simples.
+(macroexpand '(my-first-macro))
+;; -> (#<core$reverse clojure.core$reverse@xxxxxxxx> "Hello World")
+
+;; Você pode avaliar o resultad de macroexpand diretamente:
+(eval (macroexpand '(my-first-macro)))
+; -> (\d \l \o \r \W \space \o \l \l \e \H)
+
+;; mas você deve usar esse mais suscinto, sintax como de função:
+(my-first-macro)  ; -> (\d \l \o \r \W \space \o \l \l \e \H)
+
+;; Você pode tornar as coisas mais faceis pra você, utilizando a sintaxe de citação mais suscinta
+;; para criar listas nas suas macros:
+(defmacro my-first-quoted-macro []
+  '(reverse "Hello World"))
+
+(macroexpand '(my-first-quoted-macro))
+;; -> (reverse "Hello World")
+;; Note que reverse não é mais uma função objeto, mas um simbolo.
+
+;; Macros podem ter argumentos.
+(defmacro inc2 [arg]
+  (list + 2 arg))
+
+(inc2 2) ; -> 4
+
+;; Mas se você tentar fazer isso com uma lista entre aspas simples, você vai receber um erro, por que o 
+;; argumento irá entra aspas simples também. Para contornar isso, Clojure prover uma maneira de utilizar aspas simples 
+;; em macros: `. Dentro `, você pode usar ~ para chegar ao escopo externo.
+(defmacro inc2-quoted [arg]
+  `(+ 2 ~arg))
+
+(inc2-quoted 2)
+
+;; Você pode usar os argumentos de destruturação habituais. Expandir lista de variaveis usando ~@
+(defmacro unless [arg & body]
+  `(if (not ~arg)
+     (do ~@body))) ; Lembrar o do!
+
+(macroexpand '(unless true (reverse "Hello World")))
+;; ->
+;; (if (clojure.core/not true) (do (reverse "Hello World")))
+
+;; (unless) avalia e retorna seu corpo, se o primeiro argumento é falso.
+;; caso contrario, retorna nil
+
+(unless true "Hello") ; -> nil
+(unless false "Hello") ; -> "Hello"
+
+;; Usado sem cuidados, macros podem fazer muito mal por sobreporem suas variaveis
+(defmacro define-x []
+  '(do
+     (def x 2)
+     (list x)))
+
+(def x 4)
+(define-x) ; -> (2)
+(list x) ; -> (2)
+
+;;s Para evitar isso, use gensym para receber um identificador unico
+(gensym 'x) ; -> x1281 (ou outra coisa)
+
+(defmacro define-x-safely []
+  (let [sym (gensym 'x)]
+    `(do
+       (def ~sym 2)
+       (list ~sym))))
+
+(def x 4)
+(define-x-safely) ; -> (2)
+(list x) ; -> (4)
+
+;; Você pode usar # dentro de ` para produzir uma gensym para cada simbolo automaticamente
+(defmacro define-x-hygenically []
+  `(do
+     (def x# 2)
+     (list x#)))
+
+(def x 4)
+(define-x-hygenically) ; -> (2)
+(list x) ; -> (4)
+
+;; É típico o uso de funções de auxilio com macros. Vamos criar um pouco
+;; Vamos criar um pouco para nos ajudar a suportar uma sintaxe aritmética inline (estupida)
+(declare inline-2-helper)
+(defn clean-arg [arg]
+  (if (seq? arg)
+    (inline-2-helper arg)
+    arg))
+
+(defn apply-arg
+  "Given args [x (+ y)], return (+ x y)"
+  [val [op arg]]
+  (list op val (clean-arg arg)))
+
+(defn inline-2-helper
+  [[arg1 & ops-and-args]]
+  (let [ops (partition 2 ops-and-args)]
+    (reduce apply-arg (clean-arg arg1) ops)))
+
+;; Podemos testar isso imediatamente, sem criar uma macro
+(inline-2-helper '(a + (b - 2) - (c * 5))) ; -> (- (+ a (- b 2)) (* c 5))
+
+; Entretanto, temos que tornar isso uma macro caso quisermos que isso seja rodado em tempo de compilação
+(defmacro inline-2 [form]
+  (inline-2-helper form)))
+
+(macroexpand '(inline-2 (1 + (3 / 2) - (1 / 2) + 1)))
+; -> (+ (- (+ 1 (/ 3 2)) (/ 1 2)) 1)
+
+(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
+
+Escrevendo Macros de [Clojure para o Brave e True](http://www.braveclojure.com/)
+[http://www.braveclojure.com/writing-macros/](http://www.braveclojure.com/writing-macros/)
+
+Documentos oficiais 
+[http://clojure.org/macros](http://clojure.org/macros)
+
+Quando utilizar macros? 
+[http://dunsmor.com/lisp/onlisp/onlisp_12.html](http://dunsmor.com/lisp/onlisp/onlisp_12.html)
-- 
cgit v1.2.3


From ed716a3a9534a1c58a3b6d085825a5144bcb9bba Mon Sep 17 00:00:00 2001
From: Elton Viana <eltonvs@outlook.com>
Date: Mon, 12 Oct 2015 11:10:27 -0300
Subject: Some translation fixes

---
 pt-br/c-pt.html.markdown | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/c-pt.html.markdown b/pt-br/c-pt.html.markdown
index 451df4f3..f775f8b0 100644
--- a/pt-br/c-pt.html.markdown
+++ b/pt-br/c-pt.html.markdown
@@ -6,6 +6,7 @@ contributors:
     - ["Árpád Goretity", "http://twitter.com/H2CO3_iOS"]
 translators:
     - ["João Farias", "https://github.com/JoaoGFarias"]
+    - ["Elton Viana", "https://github.com/eltonvs"]
 lang: pt-br
 filename: c-pt.el
 ---
@@ -139,13 +140,13 @@ int main() {
     int var_length_array[size]; // declara o VLA
     printf("sizeof array = %zu\n", sizeof var_length_array);
 
-	//Uma possível saída para esse programa seria:
-    // > Entre o tamanho do array:: 10
+    // Uma possível saída para esse programa seria:
+    // > Entre o tamanho do array: 10
     // > sizeof array = 40
 
 	// String são apenas arrays de caracteres terminados por um 
-	// byte NUL (0x00), representado em string pelo caracter especial '\0'.
-	// (Não precisamos incluir o byte NUL em literais de string; o compilador
+	// byte nulo (0x00), representado em string pelo caracter especial '\0'.
+	// (Não precisamos incluir o byte nulo em literais de string; o compilador
 	// o insere ao final do array para nós.)
     char uma_string[20] = "Isto é uma string"; 
 	// Observe que 'é' não está na tabela ASCII
@@ -153,8 +154,8 @@ int main() {
 	// Porém, comentários podem conter acentos 
     printf("%s\n", uma_string); // %s formata a string
 
-    printf("%d\n", uma_string[16]); // => 0
-    // i.e., byte #17 é 0 (assim como 18, 19, e 20)
+    printf("%d\n", uma_string[17]); // => 0
+    // i.e., byte #18 é 0 (assim como o 19°, 20°, 21°...)
 
 	// Se temos caracteres entre aspas simples, temos um caracter literal.
 	// Seu tipo é `int`, *não* `char` (por razões históricas).
-- 
cgit v1.2.3


From 253d0d9281c519ed6bceabccef7033e1fad58e01 Mon Sep 17 00:00:00 2001
From: Elton Viana <eltonvs@outlook.com>
Date: Mon, 12 Oct 2015 11:17:18 -0300
Subject: Added some extra information

---
 pt-br/c-pt.html.markdown | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/c-pt.html.markdown b/pt-br/c-pt.html.markdown
index f775f8b0..43688724 100644
--- a/pt-br/c-pt.html.markdown
+++ b/pt-br/c-pt.html.markdown
@@ -221,11 +221,11 @@ int main() {
     0 || 1; // => 1 (Ou lógico)
     0 || 0; // => 0
 
-    //Expressão condicional ( ? : )
+    //Expressão condicional ternária ( ? : )
     int a = 5;
     int b = 10;
     int z;
-    z = (a > b) ? a : b; // => 10 "se a > b retorne a, senão retorne b." 
+    z = (a > b) ? a : b; // => 10 "se a > b retorne a, senão retorne b."
 
     //Operadores de incremento e decremento:
     char *s = "iLoveC";
@@ -291,6 +291,8 @@ int main() {
     for (i = 0; i <= 5; i++) {
         ; // Use ponto e vírgula para agir como um corpo (declaração nula)
     }
+    // Ou
+    for (i = 0; i <= 5; i++);
 
 	// Criando branchs com escolhas múltiplas: switch()
     switch (alguma_expressao_integral) {
-- 
cgit v1.2.3


From 9958252cc3990c930fe11441f456387fe0512ec8 Mon Sep 17 00:00:00 2001
From: Elton Viana <eltonvs@outlook.com>
Date: Mon, 12 Oct 2015 11:36:45 -0300
Subject: Added "Python para Zumbis" link

---
 pt-br/python-pt.html.markdown | 1 +
 1 file changed, 1 insertion(+)

(limited to 'pt-br')

diff --git a/pt-br/python-pt.html.markdown b/pt-br/python-pt.html.markdown
index 5afd46d0..ac07e1ae 100644
--- a/pt-br/python-pt.html.markdown
+++ b/pt-br/python-pt.html.markdown
@@ -500,6 +500,7 @@ dir(math)
 * [The Official Docs](http://docs.python.org/2.6/)
 * [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
 * [Python Module of the Week](http://pymotw.com/2/)
+* [Python para Zumbis](http://pycursos.com/python-para-zumbis/)
 
 ### Livros impressos
 
-- 
cgit v1.2.3


From a62d99a393b583ffe480c057aa1578d0b137d775 Mon Sep 17 00:00:00 2001
From: Elton Viana <eltonvs@outlook.com>
Date: Mon, 12 Oct 2015 11:38:01 -0300
Subject: Unset

---
 pt-br/python-pt.html.markdown | 1 -
 1 file changed, 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/python-pt.html.markdown b/pt-br/python-pt.html.markdown
index ac07e1ae..5afd46d0 100644
--- a/pt-br/python-pt.html.markdown
+++ b/pt-br/python-pt.html.markdown
@@ -500,7 +500,6 @@ dir(math)
 * [The Official Docs](http://docs.python.org/2.6/)
 * [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
 * [Python Module of the Week](http://pymotw.com/2/)
-* [Python para Zumbis](http://pycursos.com/python-para-zumbis/)
 
 ### Livros impressos
 
-- 
cgit v1.2.3


From 791b06d94a1513f359cd82f0e9d91eb06aace758 Mon Sep 17 00:00:00 2001
From: Gabriel Gomes <gabrielgomes639@gmail.com>
Date: Fri, 16 Oct 2015 15:08:32 -0300
Subject: Added css.pt.html.markdown

---
 pt-br/css.pt.html.markdown | 257 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 257 insertions(+)
 create mode 100644 pt-br/css.pt.html.markdown

(limited to 'pt-br')

diff --git a/pt-br/css.pt.html.markdown b/pt-br/css.pt.html.markdown
new file mode 100644
index 00000000..8ffd8d62
--- /dev/null
+++ b/pt-br/css.pt.html.markdown
@@ -0,0 +1,257 @@
+---
+language: css
+filename: learncss.css
+contributors:
+    - ["Mohammad Valipour", "https://github.com/mvalipour"]
+    - ["Marco Scannadinari", "https://github.com/marcoms"]
+    - ["Geoffrey Liu", "https://github.com/g-liu"]
+    - ["Connor Shea", "https://github.com/connorshea"]
+    - ["Deepanshu Utkarsh", "https://github.com/duci9y"]
+translators:
+    - ["Gabriel Gomes", "https://github.com/gabrielgomesferraz"]
+lang: pt-br
+---
+
+Nos primeiros dias da web não havia elementos visuais, apenas texto puro. Mas com maior desenvolvimento de navegadores da web, páginas web totalmente visuais também se tornou comum.
+
+CSS ajuda a manter a separação entre o conteúdo (HTML) e o look-and-feel de uma página web.
+
+CSS permite atingir diferentes elementos em uma página HTML e atribuir diferentes propriedades visuais para eles.
+
+Este guia foi escrito para CSS2, embora CSS3 está rapidamente se tornando popular.
+
+**NOTA:** Porque CSS produz resultados visuais, a fim de aprender, você precisa tentar de tudo em um playground CSS como [dabblet](http://dabblet.com/).
+O foco principal deste artigo é sobre 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 * /
+
+/* ####################
+   ## SELETORES
+   #################### */
+
+/* O seletor é usado para direcionar um elemento em uma página.
+   seletor { propriedade: valor; / * Mais propriedades ... * / }
+
+/*
+Abaixo um elemento de exemplo:
+
+<div class='class1 class2' id='anID' attr='value' otherAttr='pt-br foo bar' />
+*/
+
+/* Você pode direciona-lo usando uma das suas classes CSS */
+.class1 { }
+
+/* ou ambas as classes! */
+.class1.class2 { }
+
+/* ou o seu nome */
+div { }
+
+/* ou o seu id */
+#anID { }
+
+/* ou utilizando o fator de que tem um atributo!*/
+[attr] { font-size:smaller; }
+
+/* ou que o atributo tem um valor específico */
+[attr='value'] { font-size:smaller; }
+
+/* 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 contém um valor em uma lista separada por espaços */
+[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; }
+
+
+/* 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 selecionar um elemento que é filho de outro elemento */
+div.some-parent> .class-name {}
+
+/* Ou um descendente de um outro elemento. As crianças são os descendentes diretos de
+   seu elemento pai, apenas um nível abaixo da árvore. Pode ser qualquer descendentes
+   nivelar por baixo da árvore. */
+div.some-parent class-name {}
+
+/* Atenção: o mesmo seletor sem espaço tem um outro significado.
+   Você consegue adivinhar o que? */
+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 {}
+
+/* Ou qualquer irmão que o precede */
+.i am-qualquer-elemento antes ~ .Este elemento {}
+
+/* Existem alguns selectores chamado pseudo classes que podem ser usados para selecionar um
+   elemento quando ele está em um determinado estado */
+
+/* Por exemplo, quando o cursor passa sobre um elemento */
+seletor:hover {}
+
+/* Ou um link foi visitado */
+seletor:visited {}
+
+/* Ou não tenha sido visitado */
+seletor:link {}
+
+/* Ou um elemento em foco */
+seletor:focus {}
+
+/* Qualquer elemento que é o primeiro filho de seu pai */
+seletor:first-child {}
+
+/* Qualquer elemento que é o último filho de seu pai */
+seletor:last-child {}
+
+/* Assim como pseudo classes, pseudo elementos permitem que você estilo certas partes de um documento */
+
+/* Corresponde a um primeiro filho virtual do elemento selecionado */
+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
+   elemento */
+* {} /* */ Todos os elementos
+.parent * {} /* */ todos os descendentes
+.parent> * {} /* */ todas as crianças
+
+/* ####################
+   ## PROPRIEDADES
+   #################### */
+
+seletor {
+
+    /* Unidades de comprimento pode ser absoluta ou relativa. */
+
+    /* Unidades relativas */
+    width: 50%; /* Percentagem de largura 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 */
+    cor: RGB (10%, 20%, 50%); /* Como porcentagens rgb */
+    cor: rgba (255, 0, 0, 0,3); /* Como valores RGBA (CSS 3) NOTA: 0 <a <1 */
+    color: transparent; /* Equivale a definir o alfa a 0 */
+    cor: HSL (0, 100%, 50%); /* Como porcentagens HSL (CSS 3) */
+    cor: 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;
+}
+```
+
+## Uso
+
+Guardar uma folha de estilo CSS com a extensão `.css`.
+
+```xml
+<!-- Você precisa incluir o arquivo css no da sua página <head>. Isto é o
+     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. -->
+<style>
+   a { color: purple; }
+</style>
+
+<!-- Ou diretamente definir propriedades CSS 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 os outros. Geralmente, uma regra em um seletor mais específico têm precedência sobre um menos específico, e uma regra que ocorre mais tarde na folha de estilo substitui uma anterior.
+
+Este processo é chamado de cascata, portanto, as Fichas de nome de estilo em cascata.
+
+Dado o seguinte CSS:
+
+```css
+/* UMA */
+p.class1[attr="value"]
+
+/* B */
+p.class1 {}
+
+/* C */
+p.class2 {}
+
+/* D */
+p { }
+
+/* E */
+p { property: value !important; }
+```
+
+e a seguinte marcação:
+
+```xml
+<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.
+
+* `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.
+
+## Compatibilidade
+
+A maior parte dos recursos do CSS 2 (e muitos em CSS 3) estão disponíveis em todos os navegadores e dispositivos. Mas é sempre boa prática para verificar antes de usar um novo recurso.
+
+## Recursos
+
+* 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/)
+
+## Leitura adicional
+
+* [Entendendo Estilo Precedência em CSS: Especificidade, Herança, eo 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 [menos](http://lesscss.org/) para CSS pré-processamento
+* [CSS-Tricks](https://css-tricks.com)
-- 
cgit v1.2.3


From 123f8ce1e00354cc966ed0a8e84a99f0a8a0995f Mon Sep 17 00:00:00 2001
From: Gabriel Gomes <gabrielgomes639@gmail.com>
Date: Fri, 16 Oct 2015 15:16:40 -0300
Subject: Added css.pt.html.markdown

---
 pt-br/css.pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/css.pt.html.markdown b/pt-br/css.pt.html.markdown
index 8ffd8d62..fdf65b80 100644
--- a/pt-br/css.pt.html.markdown
+++ b/pt-br/css.pt.html.markdown
@@ -1,6 +1,6 @@
 ---
 language: css
-filename: learncss.css
+filename: learncss.css-pt
 contributors:
     - ["Mohammad Valipour", "https://github.com/mvalipour"]
     - ["Marco Scannadinari", "https://github.com/marcoms"]
-- 
cgit v1.2.3


From 99daab78adb52d8878a2ed51aa49a6dd278dbea1 Mon Sep 17 00:00:00 2001
From: Gabriel Gomes <gabrielgomes639@gmail.com>
Date: Fri, 16 Oct 2015 15:25:05 -0300
Subject: Added css-pt.html.markdown

---
 pt-br/css-pt.html.markdown | 257 +++++++++++++++++++++++++++++++++++++++++++++
 pt-br/css.pt.html.markdown | 257 ---------------------------------------------
 2 files changed, 257 insertions(+), 257 deletions(-)
 create mode 100644 pt-br/css-pt.html.markdown
 delete mode 100644 pt-br/css.pt.html.markdown

(limited to 'pt-br')

diff --git a/pt-br/css-pt.html.markdown b/pt-br/css-pt.html.markdown
new file mode 100644
index 00000000..fdf65b80
--- /dev/null
+++ b/pt-br/css-pt.html.markdown
@@ -0,0 +1,257 @@
+---
+language: css
+filename: learncss.css-pt
+contributors:
+    - ["Mohammad Valipour", "https://github.com/mvalipour"]
+    - ["Marco Scannadinari", "https://github.com/marcoms"]
+    - ["Geoffrey Liu", "https://github.com/g-liu"]
+    - ["Connor Shea", "https://github.com/connorshea"]
+    - ["Deepanshu Utkarsh", "https://github.com/duci9y"]
+translators:
+    - ["Gabriel Gomes", "https://github.com/gabrielgomesferraz"]
+lang: pt-br
+---
+
+Nos primeiros dias da web não havia elementos visuais, apenas texto puro. Mas com maior desenvolvimento de navegadores da web, páginas web totalmente visuais também se tornou comum.
+
+CSS ajuda a manter a separação entre o conteúdo (HTML) e o look-and-feel de uma página web.
+
+CSS permite atingir diferentes elementos em uma página HTML e atribuir diferentes propriedades visuais para eles.
+
+Este guia foi escrito para CSS2, embora CSS3 está rapidamente se tornando popular.
+
+**NOTA:** Porque CSS produz resultados visuais, a fim de aprender, você precisa tentar de tudo em um playground CSS como [dabblet](http://dabblet.com/).
+O foco principal deste artigo é sobre 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 * /
+
+/* ####################
+   ## SELETORES
+   #################### */
+
+/* O seletor é usado para direcionar um elemento em uma página.
+   seletor { propriedade: valor; / * Mais propriedades ... * / }
+
+/*
+Abaixo um elemento de exemplo:
+
+<div class='class1 class2' id='anID' attr='value' otherAttr='pt-br foo bar' />
+*/
+
+/* Você pode direciona-lo usando uma das suas classes CSS */
+.class1 { }
+
+/* ou ambas as classes! */
+.class1.class2 { }
+
+/* ou o seu nome */
+div { }
+
+/* ou o seu id */
+#anID { }
+
+/* ou utilizando o fator de que tem um atributo!*/
+[attr] { font-size:smaller; }
+
+/* ou que o atributo tem um valor específico */
+[attr='value'] { font-size:smaller; }
+
+/* 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 contém um valor em uma lista separada por espaços */
+[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; }
+
+
+/* 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 selecionar um elemento que é filho de outro elemento */
+div.some-parent> .class-name {}
+
+/* Ou um descendente de um outro elemento. As crianças são os descendentes diretos de
+   seu elemento pai, apenas um nível abaixo da árvore. Pode ser qualquer descendentes
+   nivelar por baixo da árvore. */
+div.some-parent class-name {}
+
+/* Atenção: o mesmo seletor sem espaço tem um outro significado.
+   Você consegue adivinhar o que? */
+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 {}
+
+/* Ou qualquer irmão que o precede */
+.i am-qualquer-elemento antes ~ .Este elemento {}
+
+/* Existem alguns selectores chamado pseudo classes que podem ser usados para selecionar um
+   elemento quando ele está em um determinado estado */
+
+/* Por exemplo, quando o cursor passa sobre um elemento */
+seletor:hover {}
+
+/* Ou um link foi visitado */
+seletor:visited {}
+
+/* Ou não tenha sido visitado */
+seletor:link {}
+
+/* Ou um elemento em foco */
+seletor:focus {}
+
+/* Qualquer elemento que é o primeiro filho de seu pai */
+seletor:first-child {}
+
+/* Qualquer elemento que é o último filho de seu pai */
+seletor:last-child {}
+
+/* Assim como pseudo classes, pseudo elementos permitem que você estilo certas partes de um documento */
+
+/* Corresponde a um primeiro filho virtual do elemento selecionado */
+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
+   elemento */
+* {} /* */ Todos os elementos
+.parent * {} /* */ todos os descendentes
+.parent> * {} /* */ todas as crianças
+
+/* ####################
+   ## PROPRIEDADES
+   #################### */
+
+seletor {
+
+    /* Unidades de comprimento pode ser absoluta ou relativa. */
+
+    /* Unidades relativas */
+    width: 50%; /* Percentagem de largura 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 */
+    cor: RGB (10%, 20%, 50%); /* Como porcentagens rgb */
+    cor: rgba (255, 0, 0, 0,3); /* Como valores RGBA (CSS 3) NOTA: 0 <a <1 */
+    color: transparent; /* Equivale a definir o alfa a 0 */
+    cor: HSL (0, 100%, 50%); /* Como porcentagens HSL (CSS 3) */
+    cor: 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;
+}
+```
+
+## Uso
+
+Guardar uma folha de estilo CSS com a extensão `.css`.
+
+```xml
+<!-- Você precisa incluir o arquivo css no da sua página <head>. Isto é o
+     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. -->
+<style>
+   a { color: purple; }
+</style>
+
+<!-- Ou diretamente definir propriedades CSS 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 os outros. Geralmente, uma regra em um seletor mais específico têm precedência sobre um menos específico, e uma regra que ocorre mais tarde na folha de estilo substitui uma anterior.
+
+Este processo é chamado de cascata, portanto, as Fichas de nome de estilo em cascata.
+
+Dado o seguinte CSS:
+
+```css
+/* UMA */
+p.class1[attr="value"]
+
+/* B */
+p.class1 {}
+
+/* C */
+p.class2 {}
+
+/* D */
+p { }
+
+/* E */
+p { property: value !important; }
+```
+
+e a seguinte marcação:
+
+```xml
+<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.
+
+* `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.
+
+## Compatibilidade
+
+A maior parte dos recursos do CSS 2 (e muitos em CSS 3) estão disponíveis em todos os navegadores e dispositivos. Mas é sempre boa prática para verificar antes de usar um novo recurso.
+
+## Recursos
+
+* 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/)
+
+## Leitura adicional
+
+* [Entendendo Estilo Precedência em CSS: Especificidade, Herança, eo 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 [menos](http://lesscss.org/) para CSS pré-processamento
+* [CSS-Tricks](https://css-tricks.com)
diff --git a/pt-br/css.pt.html.markdown b/pt-br/css.pt.html.markdown
deleted file mode 100644
index fdf65b80..00000000
--- a/pt-br/css.pt.html.markdown
+++ /dev/null
@@ -1,257 +0,0 @@
----
-language: css
-filename: learncss.css-pt
-contributors:
-    - ["Mohammad Valipour", "https://github.com/mvalipour"]
-    - ["Marco Scannadinari", "https://github.com/marcoms"]
-    - ["Geoffrey Liu", "https://github.com/g-liu"]
-    - ["Connor Shea", "https://github.com/connorshea"]
-    - ["Deepanshu Utkarsh", "https://github.com/duci9y"]
-translators:
-    - ["Gabriel Gomes", "https://github.com/gabrielgomesferraz"]
-lang: pt-br
----
-
-Nos primeiros dias da web não havia elementos visuais, apenas texto puro. Mas com maior desenvolvimento de navegadores da web, páginas web totalmente visuais também se tornou comum.
-
-CSS ajuda a manter a separação entre o conteúdo (HTML) e o look-and-feel de uma página web.
-
-CSS permite atingir diferentes elementos em uma página HTML e atribuir diferentes propriedades visuais para eles.
-
-Este guia foi escrito para CSS2, embora CSS3 está rapidamente se tornando popular.
-
-**NOTA:** Porque CSS produz resultados visuais, a fim de aprender, você precisa tentar de tudo em um playground CSS como [dabblet](http://dabblet.com/).
-O foco principal deste artigo é sobre 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 * /
-
-/* ####################
-   ## SELETORES
-   #################### */
-
-/* O seletor é usado para direcionar um elemento em uma página.
-   seletor { propriedade: valor; / * Mais propriedades ... * / }
-
-/*
-Abaixo um elemento de exemplo:
-
-<div class='class1 class2' id='anID' attr='value' otherAttr='pt-br foo bar' />
-*/
-
-/* Você pode direciona-lo usando uma das suas classes CSS */
-.class1 { }
-
-/* ou ambas as classes! */
-.class1.class2 { }
-
-/* ou o seu nome */
-div { }
-
-/* ou o seu id */
-#anID { }
-
-/* ou utilizando o fator de que tem um atributo!*/
-[attr] { font-size:smaller; }
-
-/* ou que o atributo tem um valor específico */
-[attr='value'] { font-size:smaller; }
-
-/* 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 contém um valor em uma lista separada por espaços */
-[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; }
-
-
-/* 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 selecionar um elemento que é filho de outro elemento */
-div.some-parent> .class-name {}
-
-/* Ou um descendente de um outro elemento. As crianças são os descendentes diretos de
-   seu elemento pai, apenas um nível abaixo da árvore. Pode ser qualquer descendentes
-   nivelar por baixo da árvore. */
-div.some-parent class-name {}
-
-/* Atenção: o mesmo seletor sem espaço tem um outro significado.
-   Você consegue adivinhar o que? */
-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 {}
-
-/* Ou qualquer irmão que o precede */
-.i am-qualquer-elemento antes ~ .Este elemento {}
-
-/* Existem alguns selectores chamado pseudo classes que podem ser usados para selecionar um
-   elemento quando ele está em um determinado estado */
-
-/* Por exemplo, quando o cursor passa sobre um elemento */
-seletor:hover {}
-
-/* Ou um link foi visitado */
-seletor:visited {}
-
-/* Ou não tenha sido visitado */
-seletor:link {}
-
-/* Ou um elemento em foco */
-seletor:focus {}
-
-/* Qualquer elemento que é o primeiro filho de seu pai */
-seletor:first-child {}
-
-/* Qualquer elemento que é o último filho de seu pai */
-seletor:last-child {}
-
-/* Assim como pseudo classes, pseudo elementos permitem que você estilo certas partes de um documento */
-
-/* Corresponde a um primeiro filho virtual do elemento selecionado */
-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
-   elemento */
-* {} /* */ Todos os elementos
-.parent * {} /* */ todos os descendentes
-.parent> * {} /* */ todas as crianças
-
-/* ####################
-   ## PROPRIEDADES
-   #################### */
-
-seletor {
-
-    /* Unidades de comprimento pode ser absoluta ou relativa. */
-
-    /* Unidades relativas */
-    width: 50%; /* Percentagem de largura 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 */
-    cor: RGB (10%, 20%, 50%); /* Como porcentagens rgb */
-    cor: rgba (255, 0, 0, 0,3); /* Como valores RGBA (CSS 3) NOTA: 0 <a <1 */
-    color: transparent; /* Equivale a definir o alfa a 0 */
-    cor: HSL (0, 100%, 50%); /* Como porcentagens HSL (CSS 3) */
-    cor: 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;
-}
-```
-
-## Uso
-
-Guardar uma folha de estilo CSS com a extensão `.css`.
-
-```xml
-<!-- Você precisa incluir o arquivo css no da sua página <head>. Isto é o
-     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. -->
-<style>
-   a { color: purple; }
-</style>
-
-<!-- Ou diretamente definir propriedades CSS 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 os outros. Geralmente, uma regra em um seletor mais específico têm precedência sobre um menos específico, e uma regra que ocorre mais tarde na folha de estilo substitui uma anterior.
-
-Este processo é chamado de cascata, portanto, as Fichas de nome de estilo em cascata.
-
-Dado o seguinte CSS:
-
-```css
-/* UMA */
-p.class1[attr="value"]
-
-/* B */
-p.class1 {}
-
-/* C */
-p.class2 {}
-
-/* D */
-p { }
-
-/* E */
-p { property: value !important; }
-```
-
-e a seguinte marcação:
-
-```xml
-<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.
-
-* `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.
-
-## Compatibilidade
-
-A maior parte dos recursos do CSS 2 (e muitos em CSS 3) estão disponíveis em todos os navegadores e dispositivos. Mas é sempre boa prática para verificar antes de usar um novo recurso.
-
-## Recursos
-
-* 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/)
-
-## Leitura adicional
-
-* [Entendendo Estilo Precedência em CSS: Especificidade, Herança, eo 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 [menos](http://lesscss.org/) para CSS pré-processamento
-* [CSS-Tricks](https://css-tricks.com)
-- 
cgit v1.2.3


From 6305ec5aecf256a69d490b0e7571c51edc0b3116 Mon Sep 17 00:00:00 2001
From: Gabriel Gomes <gabrielgomes639@gmail.com>
Date: Fri, 16 Oct 2015 15:36:05 -0300
Subject: Change filename for learncss-pt.css

---
 pt-br/css-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/css-pt.html.markdown b/pt-br/css-pt.html.markdown
index fdf65b80..ed6f6c4c 100644
--- a/pt-br/css-pt.html.markdown
+++ b/pt-br/css-pt.html.markdown
@@ -1,6 +1,6 @@
 ---
 language: css
-filename: learncss.css-pt
+filename: learncss-pt.css
 contributors:
     - ["Mohammad Valipour", "https://github.com/mvalipour"]
     - ["Marco Scannadinari", "https://github.com/marcoms"]
-- 
cgit v1.2.3


From 1593873e29a01454aa3b0cfdf7e156e9a9530615 Mon Sep 17 00:00:00 2001
From: Gabriel Gomes <gabrielgomes639@gmail.com>
Date: Fri, 16 Oct 2015 17:33:57 -0300
Subject: Added sass-pt-html.markdown

---
 pt-br/sass-pt.html.markdown | 477 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 477 insertions(+)
 create mode 100644 pt-br/sass-pt.html.markdown

(limited to 'pt-br')

diff --git a/pt-br/sass-pt.html.markdown b/pt-br/sass-pt.html.markdown
new file mode 100644
index 00000000..105896b2
--- /dev/null
+++ b/pt-br/sass-pt.html.markdown
@@ -0,0 +1,477 @@
+---
+language: sass
+filename: learnsass-pt.scss
+contributors:
+  - ["Laura Kyle", "https://github.com/LauraNK"]
+  - ["Sean Corrales", "https://github.com/droidenator"]
+translators:
+  - ["Gabriel Gomes", "https://github.com/gabrielgomesferraz"]
+lang: pt-br
+---
+
+Sass é uma linguagem de extensão CSS que adiciona recursos, como variáveis, aninhamento, mixins e muito mais.
+Sass (e outros pré-processadores, como [Less](http://lesscss.org/)) ajudam os desenvolvedores a escrever código de fácil manutenção e DRY (Do not Repeat Yourself).
+
+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.
+
+```scss
+
+
+// Comentários de linha única são removidos quando Sass é compilado para CSS.
+
+/* Comentários multi-line são preservados. */
+
+
+
+/*Variáveis
+==============================*/
+
+
+
+/* É possível armazenar um valor CSS (tais como a cor) de uma variável.
+Use o símbolo "$" para criar uma variável. */
+
+$primary-color: #A3A4FF;
+$secondary-color: #51527F;
+$body-font: 'Roboto', sans-serif;
+
+/* Você pode usar as variáveis em toda a sua folha de estilo.
+Agora, se você quer mudar a cor, você só tem que fazer a mudança uma vez. */
+
+body {
+	background-color: $primary-color;
+	color: $secondary-color;
+	font-family: $body-font;
+}
+
+/* Quando compilar ficaria assim: */
+body {
+	background-color: #A3A4FF;
+	color: #51527F;
+	font-family: 'Roboto', sans-serif;
+}
+
+
+/ * Este é muito mais fácil de manter do que ter de mudar a cor
+cada vez que aparece em toda a sua folha de estilo. * /
+
+
+
+
+/*Mixins
+==============================*/
+
+
+
+/* Se você achar que você está escrevendo o mesmo código para mais de um
+elemento, você pode querer armazenar esse código em um mixin.
+
+Use a diretiva '@mixin', além de um nome para o seu mixin. */
+
+@mixin center {
+	display: block;
+	margin-left: auto;
+	margin-right: auto;
+	left: 0;
+	right: 0;
+}
+
+/* Você pode usar o mixin com '@include' e o nome mixin. */
+
+div {
+	@include center;
+	background-color: $primary-color;
+}
+
+/* Apoś compilar ficaria assim: */
+div {
+	display: block;
+	margin-left: auto;
+	margin-right: auto;
+	left: 0;
+	right: 0;
+	background-color: #A3A4FF;
+}
+
+
+/* Você pode usar mixins para criar uma propriedade estenográfica. */
+
+@mixin size($width, $height) {
+	width: $width;
+	height: $height;
+}
+
+/* O que você pode invocar passando argumentos de largura e altura. */
+
+.rectangle {
+	@include size(100px, 60px);
+}
+
+.square {
+	@include size(40px, 40px);
+}
+
+/* Isso compilado ficará assim: */
+.rectangle {
+  width: 100px;
+  height: 60px;
+}
+
+.square {
+  width: 40px;
+  height: 40px;
+}
+
+
+
+/*Funções
+==============================*/
+
+
+
+/* Sass fornece funções que podem ser utilizados para realizar uma variedade de
+    tarefas. Considere o seguinte */
+
+/* Funções pode ser chamado usando seu nome e passando o
+    argumentos necessários */
+body {
+  width: round(10.25px);
+}
+
+.footer {
+  background-color: fade_out(#000000, 0.25)
+}
+
+/* Compiles to: */
+
+body {
+  width: 10px;
+}
+
+.footer {
+  background-color: rgba(0, 0, 0, 0.75);
+}
+
+/* You may also define your own functions. Functions are very similar to
+   mixins. When trying to choose between a function or a mixin, remember
+   that mixins are best for generating CSS while functions are better for
+   logic that might be used throughout your Sass code. The examples in
+   the Math Operators' section are ideal candidates for becoming a reusable
+   function. */
+
+/* This function will take a target size and the parent size and calculate
+   and return the percentage */
+
+/* Você também pode definir suas próprias funções. As funções são muito semelhantes aos
+   mixins. Ao tentar escolher entre uma função ou um mixin, lembre-
+   que mixins são os melhores para gerar CSS enquanto as funções são melhores para
+   lógica que pode ser usado em todo o seu código Sass. Os exemplos
+   seção Operadores Math 'são candidatos ideais para se tornar um reutilizável
+   função. */
+
+/* Esta função terá um tamanho de destino eo tamanho do pai e calcular
+   e voltar a percentagem */
+
+@function calculate-percentage($target-size, $parent-size) {
+  @return $target-size / $parent-size * 100%;
+}
+
+$main-content: calculate-percentage(600px, 960px);
+
+.main-content {
+  width: $main-content;
+}
+
+.sidebar {
+  width: calculate-percentage(300px, 960px);
+}
+
+/* Compila para: */
+
+.main-content {
+  width: 62.5%;
+}
+
+.sidebar {
+  width: 31.25%;
+}
+
+
+
+/* Extend (Herança)
+============================== */
+
+
+
+/*Extend é uma maneira de compartilhar as propriedades de um seletor com outro. */
+
+.display {
+	@include size(5em, 5em);
+	border: 5px solid $secondary-color;
+}
+
+.display-success {
+	@extend .display;
+	border-color: #22df56;
+}
+
+/* Compiles to: */
+.display, .display-success {
+  width: 5em;
+  height: 5em;
+  border: 5px solid #51527F;
+}
+
+.display-success {
+  border-color: #22df56;
+}
+
+/* Ampliando uma declaração CSS é preferível a criação de um mixin
+   por causa da maneira agrupa as classes que todos compartilham
+   o mesmo estilo base. Se isso for feito com um mixin, a largura,
+   altura, e a borda seria duplicado para cada instrução que
+   o chamado mixin. Enquanto isso não irá afetar o seu fluxo de trabalho, será
+   adicionar inchaço desnecessário para os arquivos criados pelo compilador Sass. */
+
+
+
+/*Assentamento
+==============================*/
+
+
+
+/ * Sass permite seletores ninhos dentro seletores * /
+
+ul {
+	list-style-type: none;
+	margin-top: 2em;
+
+	li {
+		background-color: #FF0000;
+	}
+}
+
+/* '&' será substituído pelo selector pai. */
+/* 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.
+Por exemplo: */
+
+
+ul {
+	list-style-type: none;
+	margin-top: 2em;
+
+	li {
+		background-color: red;
+
+		&:hover {
+		  background-color: blue;
+		}
+
+		a {
+		  color: white;
+		}
+	}
+}
+
+/* Compila para: */
+
+ul {
+  list-style-type: none;
+  margin-top: 2em;
+}
+
+ul li {
+  background-color: red;
+}
+
+ul li:hover {
+  background-color: blue;
+}
+
+ul li a {
+  color: white;
+}
+
+
+
+/*Parciais e Importações
+==============================*/
+
+
+/* Sass permite criar arquivos parciais. Isso pode ajudar a manter seu Sass
+   código modularizado. Arquivos parciais deve começar com um '_', por exemplo, _reset.css.
+   Parciais não são geradas em CSS. */
+
+
+
+/* Considere o seguinte CSS que nós vamos colocar em um arquivo chamado _reset.css */
+
+html,
+body,
+ul,
+ol {
+  margin: 0;
+  padding: 0;
+}
+
+/* Sass offers @import which can be used to import partials into a file.
+   This differs from the traditional CSS @import statement which makes
+   another HTTP request to fetch the imported file. Sass takes the
+   imported file and combines it with the compiled code. */
+
+/* Sass oferece @import que pode ser usado para importar parciais em um arquivo.
+   Isso difere da declaração CSS @import tradicional, que faz
+   outra solicitação HTTP para buscar o arquivo importado. Sass converte os
+   importadas arquivo e combina com o código compilado. */
+
+@import 'reset';
+
+body {
+  font-size: 16px;
+  font-family: Helvetica, Arial, Sans-serif;
+}
+
+/* Compiles to: */
+
+html, body, ul, ol {
+  margin: 0;
+  padding: 0;
+}
+
+body {
+  font-size: 16px;
+  font-family: Helvetica, Arial, Sans-serif;
+}
+
+
+
+/*Placeholder Selectors
+==============================*/  
+
+
+
+/* Placeholders are useful when creating a CSS statement to extend. If you
+   wanted to create a CSS statement that was exclusively used with @extend,
+   you can do so using a placeholder. Placeholders begin with a '%' instead
+   of '.' or '#'. Placeholders will not appear in the compiled CSS. */
+
+/* Os espaços reservados são úteis na criação de uma declaração CSS para ampliar. Se você
+   queria criar uma instrução CSS que foi usado exclusivamente com @extend,
+   Você pode fazer isso usando um espaço reservado. Espaços reservados começar com um '%' em vez
+   de '.' ou '#'. Espaços reservados não aparece no CSS compilado. * /
+
+%content-window {
+  font-size: 14px;
+  padding: 10px;
+  color: #000;
+  border-radius: 4px;
+}
+
+.message-window {
+  @extend %content-window;
+  background-color: #0000ff;
+}
+
+/* Compilado para: */
+
+.message-window {
+  font-size: 14px;
+  padding: 10px;
+  color: #000;
+  border-radius: 4px;
+}
+
+.message-window {
+  background-color: #0000ff;
+}
+
+
+
+/*Operações Math
+============================== * /
+
+
+/* Sass provides the following operators: +, -, *, /, and %. These can
+   be useful for calculating values directly in your Sass files instead
+   of using values that you've already calculated by hand. Below is an example
+   of a setting up a simple two column design. */
+
+/* Sass fornece os seguintes operadores: +, -, *, /, e %. estes podem
+   ser úteis para calcular os valores diretamente no seu Sass arquivos em vez
+   de usar valores que você já calculados pela mão. Abaixo está um exemplo
+   de uma criação de um projeto simples de duas colunas. * /
+
+$content-area: 960px;
+$main-content: 600px;
+$sidebar-content: 300px;
+
+$main-size: $main-content / $content-area * 100%;
+$sidebar-size: $sidebar-content / $content-area * 100%;
+$gutter: 100% - ($main-size + $sidebar-size);
+
+body {
+  width: 100%;
+}
+
+.main-content {
+  width: $main-size;
+}
+
+.sidebar {
+  width: $sidebar-size;
+}
+
+.gutter {
+  width: $gutter;
+}
+
+/* Compiles to: */
+
+body {
+  width: 100%;
+}
+
+.main-content {
+  width: 62.5%;
+}
+
+.sidebar {
+  width: 31.25%;
+}
+
+.gutter {
+  width: 6.25%;
+}
+
+
+```
+
+
+
+## SASS ou Sass?
+Alguma vez você já se perguntou se Sass é um acrônimo ou não? Você provavelmente não tem, mas vou dizer-lhe de qualquer maneira. O nome do idioma é uma palavra, "Sass", e não uma sigla.
+Porque as pessoas estavam constantemente a escrevê-lo como "SASS", o criador da linguagem de brincadeira chamou de "StyleSheets Sintaticamente Incríveis".
+
+
+## Prática Sass
+Se você quiser jogar com Sass em seu navegador, vá para [SassMeister](http://sassmeister.com/).
+Você pode usar uma sintaxe, basta ir para as configurações e selecionar Sass ou SCSS.
+
+
+## Compatibilidade
+
+Sass pode ser usado em qualquer projeto, desde que você tenha um programa para compilá-lo
+em CSS. Você vai querer verificar se o CSS que você está usando é compatível
+com os seus navegadores de destino.
+
+[QuirksMode CSS](http://www.quirksmode.org/css/) e [CanIUse](http://caniuse.com) são ótimos recursos para verificação de compatibilidade.
+
+
+## Leitura
+* [Official Documentation](http://sass-lang.com/documentation/file.SASS_REFERENCE.html)
+* [The Sass Way](http://thesassway.com/) fornece tutoriais (iniciante avançados) e artigos.
-- 
cgit v1.2.3


From c9348e5a82b639093f8f3eee955ffdf6fb99b5d8 Mon Sep 17 00:00:00 2001
From: Luis Custodio <luis.custodio@gmail.com>
Date: Sat, 17 Oct 2015 13:10:00 +0200
Subject: [pt-br tmux] Adds a portuguese translation to tmux.

---
 pt-br/tmux-pt.html.markdown | 254 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 254 insertions(+)
 create mode 100644 pt-br/tmux-pt.html.markdown

(limited to 'pt-br')

diff --git a/pt-br/tmux-pt.html.markdown b/pt-br/tmux-pt.html.markdown
new file mode 100644
index 00000000..89f0e0f3
--- /dev/null
+++ b/pt-br/tmux-pt.html.markdown
@@ -0,0 +1,254 @@
+---
+category: tool
+tool: tmux
+contributors:
+    - ["mdln", "https://github.com/mdln"]
+translators:
+    - ["Luis Custodio", "http://luiscustodio.com"]
+lang: pt-br
+filename: LearnTmux-pt.txt
+---
+
+O [tmux](http://tmux.sourceforge.net)
+é um multiplexador de terminal, ele permite que terminais sejam criados,
+acessados e controlados a partir de uma unica instância. tmux pode ser separado
+de uma tela e continuar rodando no plano de fundo e depois ser reacoplado à
+instância (ou tela original).
+
+```
+
+  tmux [command]     # Roda um [comando]
+                     # 'tmux' sem comandos irá criar uma nova seção
+
+    new              # Cria uma nova seção
+     -s "Nome"       # Cria uma nova seção com nome "Nome"
+     -n "Janela"     # Cria uma janela com o nome "Janela"
+     -c "/dir"       # Inícia em uma pasta específica
+
+    attach           # Reacopla a última seção disponível
+     -t "#"          # Reacopla a seção com nome "#"
+     -d              # Separa (Desacopla) a sessaão de outras instâncias.
+
+    ls               # Lista todas as seções
+     -a              # Lista todas as seções abertas
+
+    lsw              # Lista as janelas
+     -a              # Lista todas as janelas
+     -s              # Lista todas janleas em uma seção
+
+    lsp              # Lista os painéis
+     -a              # Lista todos os painéis
+     -s              # Lista todos os painéis em uma seção
+     -t "#"          # Lista os painéis baseado no nome "#"
+
+    kill-window      # Encerrar a janela corrente
+     -t "#"          # Encerrar a janela baseado no nome "#"
+     -a              # Encerrar todas as janelas
+     -a -t "#"       # Encerrar todas as janelas exceto a com nome "#"
+
+    kill-session     # Encerrar seção corrente
+     -t "#"          # Encerrar seção com nome "#"
+     -a              # Encerrar todas as seções
+     -a -t "#"       # Encerrar todas as seções exceto a com nome "#"
+
+```
+
+
+### Teclas de commando (atalhos)
+
+A maneira de controllar uma seção tmux acoplada é através de uma
+combinação de teclas de prefixo.
+
+```
+----------------------------------------------------------------------
+  (C-b) = Ctrl + b    # Combinação de prefixos para usar comandos(atalhos).
+
+  (M-1) = Meta + 1 -or- Alt + 1
+----------------------------------------------------------------------
+
+  ?                  # Lista todos os comandos.
+  :                  # Acessa o lugar (prompt command) para receber comandos do tmux
+  r                  # Força a redefiniçao do cliente acoplado.
+  c                  # Cria uma nova janela.
+
+  !                  # Retira o painel corrente da janela.
+  %                  # Divide o painel corrente em dois para a esquerda e direita.
+  "                  # Divide o painel corrente em dois para cima e para baixo.
+
+  n                  # Move para a próxima janela.
+  p                  # Move para a janela anterior.
+  {                  # Troca o painel corrente pelo anterior.
+  }                  # Troca o painel corrent pelo posterior.
+
+  s                  # Seleciona uma nova seção para o cliente acoplado iterativamente.
+  w                  # Seleciona a janela corrente iterativamente.
+  0 to 9             # Seleciona a janela de 0 à 9.
+
+  d                  # Separa o cliente atual.
+  D                  # Seleciona um cliente a ser separado.
+
+  &                  # Encerra a janela corrente.
+  x                  # Encerra o painel corrente.
+
+  Up, Down           # Move para o painel acima, abaixo, a esquerda ou a direita respectivamente.
+  Left, Right
+
+  M-1 to M-5         # Organiza os paines:
+                       # 1) Horizontalmente de maneira igual
+                       # 2) Verticalmente de maineira igual.
+                       # 3) Principal horizontalmente
+                       # 4) Principal verticamente.
+                       # 5) Mosaico
+
+  C-Up, C-Down       # Altera o tamanho do painel corrente baseado em uma célula.
+  C-Left, C-Right
+
+  M-Up, M-Down       # Altera o tamanho do painel corrente baseado em cinco células.
+  M-Left, M-Right
+
+```
+
+
+### Configurando ~/.tmux.conf
+
+Existe um arquivo chamado tmux.conf, ele pode ser usado para definir opções no
+ momento de inicialização, da mesma maneira que .vimrc, init.el, .bash_profile são usados.
+
+
+```
+# Exemplo de tmux.conf
+# 2014.10
+
+
+### General
+###########################################################################
+
+# Habilita UTF-8
+setw -g utf8 on
+set-option -g status-utf8 on
+
+# Limite da história de comandos
+set -g history-limit 2048
+
+# Indíce de inicialização
+set -g base-index 1
+
+# Mouse
+set-option -g mouse-select-pane on
+
+# Recarregar o arquivo de configuração sem a necessidade de reiniciar o programa.
+unbind r
+bind r source-file ~/.tmux.conf
+
+
+### Teclas de atalho
+###########################################################################
+
+# Desvincular C-b como prefixo padrão.
+unbind C-b
+
+# Define um novo prefixo padrão.
+set-option -g prefix `
+
+# Definir prefixos que podem ser usados para voltar para a janela anterior.
+bind C-a last-window
+bind ` last-window
+
+# Fazer com que F11 e F12 alterem o comportamento de C-a e `
+bind F11 set-option -g prefix C-a
+bind F12 set-option -g prefix `
+
+# Preferencia de teclas de atalho
+setw -g mode-keys vi
+set-option -g status-keys vi
+
+# Mover enter paineis com teclas de orientaçao do vim
+bind h select-pane -L
+bind j select-pane -D
+bind k select-pane -U
+bind l select-pane -R
+
+# Iterar entre as Janelas
+bind e previous-window
+bind f next-window
+bind E swap-window -t -1
+bind F swap-window -t +1
+
+# Iterar entre os painéis
+bind = split-window -h
+bind - split-window -v
+unbind '"'
+unbind %
+
+# Habilitar a sub-seção a enviar comandos.
+bind a send-prefix
+
+
+### Theme
+###########################################################################
+
+# Paleta de cores para a barra de status
+set-option -g status-justify left
+set-option -g status-bg black
+set-option -g status-fg white
+set-option -g status-left-length 40
+set-option -g status-right-length 80
+
+# Paleta de cores para bordas do painel
+set-option -g pane-active-border-fg green
+set-option -g pane-active-border-bg black
+set-option -g pane-border-fg white
+set-option -g pane-border-bg black
+
+# Palta de cores para mensagem
+set-option -g message-fg black
+set-option -g message-bg green
+
+# Paleta de cores para janela de status
+setw -g window-status-bg black
+setw -g window-status-current-fg green
+setw -g window-status-bell-attr default
+setw -g window-status-bell-fg red
+setw -g window-status-content-attr default
+setw -g window-status-content-fg yellow
+setw -g window-status-activity-attr default
+setw -g window-status-activity-fg yellow
+
+
+### UI
+###########################################################################
+
+# Notificações
+setw -g monitor-activity on
+set -g visual-activity on
+set-option -g bell-action any
+set-option -g visual-bell off
+
+# Definir automaticamente o título de janelas
+set-option -g set-titles on
+set-option -g set-titles-string '#H:#S.#I.#P #W #T' # window number,program name,active (or not)
+
+# Ajustes na barra de status
+set -g status-left "#[fg=red] #H#[fg=green]:#[fg=white]#S#[fg=green] |#[default]"
+
+# Mostrar indicativos de performance na barra de status
+# 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]"
+
+```
+
+
+### References
+
+[Tmux | Início](http://tmux.sourceforge.net)
+
+[Manual Tmux (em inglês)](http://www.openbsd.org/cgi-bin/man.cgi/OpenBSD-current/man1/tmux.1?query=tmux)
+
+[Gentoo Wiki](http://wiki.gentoo.org/wiki/Tmux)
+
+[Archlinux Wiki](https://wiki.archlinux.org/index.php/Tmux)
+
+[Mostrar CPU/MEM % in statusbar](https://stackoverflow.com/questions/11558907/is-there-a-better-way-to-display-cpu-usage-in-tmux)
+
+Possui uma sugestão? Uma correção, talvez? Abra um issue no Repositório GitHub, ou então faça um pull request.
-- 
cgit v1.2.3


From 340ded50e08c86017616737a0aaaab4d4727f6c9 Mon Sep 17 00:00:00 2001
From: Luis Custodio <luis.custodio@gmail.com>
Date: Sat, 17 Oct 2015 13:13:02 +0200
Subject: [pt-br tmux] keeping in mind the 80 columns

---
 pt-br/tmux-pt.html.markdown | 46 ++++++++++++++++++++++-----------------------
 1 file changed, 23 insertions(+), 23 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/tmux-pt.html.markdown b/pt-br/tmux-pt.html.markdown
index 89f0e0f3..c184b55f 100644
--- a/pt-br/tmux-pt.html.markdown
+++ b/pt-br/tmux-pt.html.markdown
@@ -66,44 +66,44 @@ combinação de teclas de prefixo.
   (M-1) = Meta + 1 -or- Alt + 1
 ----------------------------------------------------------------------
 
-  ?                  # Lista todos os comandos.
-  :                  # Acessa o lugar (prompt command) para receber comandos do tmux
-  r                  # Força a redefiniçao do cliente acoplado.
-  c                  # Cria uma nova janela.
+  ?           # Lista todos os comandos.
+  :           # Acessa o lugar (prompt command) para receber comandos do tmux
+  r           # Força a redefiniçao do cliente acoplado.
+  c           # Cria uma nova janela.
 
-  !                  # Retira o painel corrente da janela.
-  %                  # Divide o painel corrente em dois para a esquerda e direita.
-  "                  # Divide o painel corrente em dois para cima e para baixo.
+  !           # Retira o painel corrente da janela.
+  %           # Divide o painel corrente em dois para a esquerda e direita.
+  "           # Divide o painel corrente em dois para cima e para baixo.
 
-  n                  # Move para a próxima janela.
-  p                  # Move para a janela anterior.
-  {                  # Troca o painel corrente pelo anterior.
-  }                  # Troca o painel corrent pelo posterior.
+  n           # Move para a próxima janela.
+  p           # Move para a janela anterior.
+  {           # Troca o painel corrente pelo anterior.
+  }           # Troca o painel corrent pelo posterior.
 
-  s                  # Seleciona uma nova seção para o cliente acoplado iterativamente.
-  w                  # Seleciona a janela corrente iterativamente.
-  0 to 9             # Seleciona a janela de 0 à 9.
+  s           # Seleciona uma nova seção para o cliente acoplado iterativamente.
+  w           # Seleciona a janela corrente iterativamente.
+  0 to 9      # Seleciona a janela de 0 à 9.
 
-  d                  # Separa o cliente atual.
-  D                  # Seleciona um cliente a ser separado.
+  d           # Separa o cliente atual.
+  D           # Seleciona um cliente a ser separado.
 
-  &                  # Encerra a janela corrente.
-  x                  # Encerra o painel corrente.
+  &           # Encerra a janela corrente.
+  x           # Encerra o painel corrente.
 
-  Up, Down           # Move para o painel acima, abaixo, a esquerda ou a direita respectivamente.
+  Up, Down    # Move para o painel acima, abaixo, a esquerda ou a direita.
   Left, Right
 
-  M-1 to M-5         # Organiza os paines:
+  M-1 to M-5  # Organiza os paines:
                        # 1) Horizontalmente de maneira igual
                        # 2) Verticalmente de maineira igual.
                        # 3) Principal horizontalmente
                        # 4) Principal verticamente.
                        # 5) Mosaico
 
-  C-Up, C-Down       # Altera o tamanho do painel corrente baseado em uma célula.
+  C-Up, C-Down    # Altera o tamanho do painel corrente baseado em uma célula.
   C-Left, C-Right
 
-  M-Up, M-Down       # Altera o tamanho do painel corrente baseado em cinco células.
+  M-Up, M-Down    # Altera o tamanho do painel corrente baseado em cinco células.
   M-Left, M-Right
 
 ```
@@ -136,7 +136,7 @@ set -g base-index 1
 # Mouse
 set-option -g mouse-select-pane on
 
-# Recarregar o arquivo de configuração sem a necessidade de reiniciar o programa.
+# Recarregar o arquivo de configuração sem a necessidade de reiniciar o programa
 unbind r
 bind r source-file ~/.tmux.conf
 
-- 
cgit v1.2.3


From 942ce10709fb3cfee4932a38abd97eb600097188 Mon Sep 17 00:00:00 2001
From: Luis Custodio <luis.custodio@gmail.com>
Date: Sat, 17 Oct 2015 13:14:48 +0200
Subject: [pt-br tmux] small fix on the translation

---
 pt-br/tmux-pt.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/tmux-pt.html.markdown b/pt-br/tmux-pt.html.markdown
index c184b55f..9d5bf292 100644
--- a/pt-br/tmux-pt.html.markdown
+++ b/pt-br/tmux-pt.html.markdown
@@ -54,7 +54,7 @@ instância (ou tela original).
 ```
 
 
-### Teclas de commando (atalhos)
+### Teclas de atalhos (comandos)
 
 A maneira de controllar uma seção tmux acoplada é através de uma
 combinação de teclas de prefixo.
@@ -239,7 +239,7 @@ set -g status-right "#[fg=green] | #[fg=white]#(tmux-mem-cpu-load)#[fg=green] |
 ```
 
 
-### References
+### Referências
 
 [Tmux | Início](http://tmux.sourceforge.net)
 
-- 
cgit v1.2.3


From 3253734d4c03f93aa9b6a59d62733f0a3b683392 Mon Sep 17 00:00:00 2001
From: Lucas Moreira <eskerlucas1@gmail.com>
Date: Sat, 17 Oct 2015 19:53:33 -0300
Subject: =?UTF-8?q?Corre=C3=A7=C3=A3o=20de=20palavra.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 pt-br/json-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/json-pt.html.markdown b/pt-br/json-pt.html.markdown
index fc63b126..e4f10a61 100644
--- a/pt-br/json-pt.html.markdown
+++ b/pt-br/json-pt.html.markdown
@@ -35,7 +35,7 @@ tudo o que é vai ser 100% JSON válido. Felizmente, isso meio que fala por si.
     "array": [0, 1, 2, 3, "Arrays podem ter qualquer coisa em si.", 5],
 
     "outro objeto": {
-      "ccomentário": "Estas coisas podem ser aninhadas, muito úteis."
+      "comentário": "Estas coisas podem ser aninhadas, muito úteis."
     }
   },
 
-- 
cgit v1.2.3


From b0ae4db5589ce91ca52f9aece0cf065524c027fe Mon Sep 17 00:00:00 2001
From: Claudson Martins <claudson@outlook.com>
Date: Sun, 18 Oct 2015 08:23:59 -0300
Subject: =?UTF-8?q?Iniciando=20tradu=C3=A7=C3=A3o=20do=20MatLab=20para=20P?=
 =?UTF-8?q?T-BR?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 pt-br/matlab.html.markdown | 531 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 531 insertions(+)
 create mode 100644 pt-br/matlab.html.markdown

(limited to 'pt-br')

diff --git a/pt-br/matlab.html.markdown b/pt-br/matlab.html.markdown
new file mode 100644
index 00000000..7c0760d1
--- /dev/null
+++ b/pt-br/matlab.html.markdown
@@ -0,0 +1,531 @@
+---
+language: Matlab
+contributors:
+    - ["mendozao", "http://github.com/mendozao"]
+    - ["jamesscottbrown", "http://jamesscottbrown.com"]
+    - ["Colton Kohnke", "http://github.com/voltnor"]
+translators:
+    - ["Claudson Martins", "https://github.com/claudsonm"]
+lang: pt-br
+
+---
+
+MATLAB significa MATrix LABoratory. É uma poderosa linguagem de computação numérica geralmente utilizada em engenharia e matemática.
+
+Se você tem algum feedback, por favor fique a vontade para me contactar via
+[@the_ozzinator](https://twitter.com/the_ozzinator), ou
+[osvaldo.t.mendoza@gmail.com](mailto:osvaldo.t.mendoza@gmail.com).
+
+```matlab
+% Comentários iniciam com um sinal de porcentagem
+
+%{
+Comentários de múltiplas linhas
+parecem
+com
+algo assim
+%}
+
+% comandos podem ocupar várinhas linhas, usando '...':
+ a = 1 + 2 + ...
+ + 4
+
+% comandos podem ser passados para o sistema operacional
+!ping google.com
+
+who % Exibe todas as variáveis na memória
+whos % Exibe todas as variáveis na memória, com seus tipos
+clear % Apaga todas as suas variáveis da memória
+clear('A') % Apaga uma variável em particular
+openvar('A') % Abre a variável no editor de variável
+
+clc % Apaga o conteúdo escrito na sua janela de comando
+diary % Alterna o conteúdo escrito na janela de comando para um arquivo de texto
+ctrl-c % Aborta a computação atual
+
+edit('minhafuncao.m') % Abre a função/script no editor
+type('minhafuncao.m') % Imprime o código-fonte da função/script na janela de comando
+
+profile on 	% Ativa o perfil de código
+profile off 	% Desativa o perfil de código
+profile viewer 	% Visualiza os resultados na janela de Profiler
+
+help comando 	% Exibe a documentação do comando na janela de comando
+doc comando 	% Exibe a documentação do comando na janela de ajuda
+lookfor comando % Procura por comando na primeira linha comentada de todas as funções
+lookfor comando -all % Procura por comando em todas as funções
+
+
+% Formatação de saída
+format short 	% 4 casas decimais em um número flutuante
+format long 	% 15 casas decimais
+format bank 	% 2 dígitos após o ponto decimal - para cálculos financeiros
+fprintf('texto') % Imprime na tela "texto"
+disp('texto') 	% Imprime na tela "texto"
+
+% Variáveis & Expressões
+minhaVariavel = 4  % O painel Workspace mostra a variável recém-criada
+minhaVariavel = 4; % Ponto e vírgula suprime a saída para a janela de comando
+4 + 6  		% Resposta = 10
+8 * minhaVariavel 	% Resposta = 32
+2 ^ 3 		% Resposta = 8
+a = 2; b = 3;
+c = exp(a)*sin(pi/2) % c = 7.3891
+
+% A chamada de funções pode ser feita por uma das duas maneiras:
+% Sintaxe de função padrão:
+load('arquivo.mat', 'y') % Argumentos entre parênteses, separados por vírgula
+% Sintaxe de comando:
+load arquivo.mat y 	% Sem parênteses, e espaços ao invés de vírgulas
+% Observe a falta de aspas no formulário de comando: entradas são sempre
+% passadas como texto literal - não pode passar valores de variáveis.
+% Além disso, não pode receber saída:
+[V,D] = eig(A);  % this has no equivalent in command form
+[~,D] = eig(A);  % if you only want D and not V
+
+
+
+% Logicals
+1 > 5 % ans = 0
+10 >= 10 % ans = 1
+3 ~= 4 % Not equal to -> ans = 1
+3 == 3 % equal to -> ans = 1
+3 > 1 && 4 > 1 % AND -> ans = 1
+3 > 1 || 4 > 1 % OR -> ans = 1
+~1 % NOT -> ans = 0
+
+% Logicals can be applied to matrices:
+A > 5
+% for each element, if condition is true, that element is 1 in returned matrix
+A( A > 5 )
+% returns a vector containing the elements in A for which condition is true
+
+% Strings
+a = 'MyString'
+length(a) % ans = 8
+a(2) % ans = y
+[a,a] % ans = MyStringMyString
+
+
+% Cells
+a = {'one', 'two', 'three'}
+a(1) % ans = 'one' - returns a cell
+char(a(1)) % ans = one - returns a string
+
+% Structures
+A.b = {'one','two'};
+A.c = [1 2];
+A.d.e = false;
+
+% Vectors
+x = [4 32 53 7 1]
+x(2) % ans = 32, indices in Matlab start 1, not 0
+x(2:3) % ans = 32 53
+x(2:end) % ans = 32 53 7 1
+
+x = [4; 32; 53; 7; 1] % Column vector
+
+x = [1:10] % x = 1 2 3 4 5 6 7 8 9 10
+
+% Matrices
+A = [1 2 3; 4 5 6; 7 8 9]
+% Rows are separated by a semicolon; elements are separated with space or comma
+% A =
+
+%     1     2     3
+%     4     5     6
+%     7     8     9
+
+A(2,3) % ans = 6, A(row, column)
+A(6) % ans = 8
+% (implicitly concatenates columns into vector, then indexes into that)
+
+
+A(2,3) = 42 % Update row 2 col 3 with 42
+% A =
+
+%     1     2     3
+%     4     5     42
+%     7     8     9
+
+A(2:3,2:3) % Creates a new matrix from the old one
+%ans =
+
+%     5     42
+%     8     9
+
+A(:,1) % All rows in column 1
+%ans =
+
+%     1
+%     4
+%     7
+
+A(1,:) % All columns in row 1
+%ans =
+
+%     1     2     3
+
+[A ; A] % Concatenation of matrices (vertically)
+%ans =
+
+%     1     2     3
+%     4     5    42
+%     7     8     9
+%     1     2     3
+%     4     5    42
+%     7     8     9
+
+% this is the same as
+vertcat(A,A);
+
+
+[A , A] % Concatenation of matrices (horizontally)
+
+%ans =
+
+%     1     2     3     1     2     3
+%     4     5    42     4     5    42
+%     7     8     9     7     8     9
+
+% this is the same as
+horzcat(A,A);
+
+
+A(:, [3 1 2]) % Rearrange the columns of original matrix
+%ans =
+
+%     3     1     2
+%    42     4     5
+%     9     7     8
+
+size(A) % ans = 3 3
+
+A(1, :) =[] % Delete the first row of the matrix
+A(:, 1) =[] % Delete the first column of the matrix
+
+transpose(A) % Transpose the matrix, which is the same as:
+A one
+ctranspose(A) % Hermitian transpose the matrix
+% (the transpose, followed by taking complex conjugate of each element)
+
+
+
+
+% Element by Element Arithmetic vs. Matrix Arithmetic
+% On their own, the arithmetic operators act on whole matrices. When preceded
+% by a period, they act on each element instead. For example:
+A * B % Matrix multiplication
+A .* B % Multiple each element in A by its corresponding element in B
+
+% There are several pairs of functions, where one acts on each element, and
+% the other (whose name ends in m) acts on the whole matrix.
+exp(A) % exponentiate each element
+expm(A) % calculate the matrix exponential
+sqrt(A) % take the square root of each element
+sqrtm(A) %  find the matrix whose square is A
+
+
+% Plotting
+x = 0:.10:2*pi; % Creates a vector that starts at 0 and ends at 2*pi with increments of .1
+y = sin(x);
+plot(x,y)
+xlabel('x axis')
+ylabel('y axis')
+title('Plot of y = sin(x)')
+axis([0 2*pi -1 1]) % x range from 0 to 2*pi, y range from -1 to 1
+
+plot(x,y1,'-',x,y2,'--',x,y3,':') % For multiple functions on one plot
+legend('Line 1 label', 'Line 2 label') % Label curves with a legend
+
+% Alternative method to plot multiple functions in one plot.
+% while 'hold' is on, commands add to existing graph rather than replacing it
+plot(x, y)
+hold on
+plot(x, z)
+hold off
+
+loglog(x, y) % A log-log plot
+semilogx(x, y) % A plot with logarithmic x-axis
+semilogy(x, y) % A plot with logarithmic y-axis
+
+fplot (@(x) x^2, [2,5]) % plot the function x^2 from x=2 to x=5
+
+grid on % Show grid; turn off with 'grid off'
+axis square % Makes the current axes region square
+axis equal % Set aspect ratio so data units are the same in every direction
+
+scatter(x, y); % Scatter-plot
+hist(x); % Histogram
+
+z = sin(x);
+plot3(x,y,z); % 3D line plot
+
+pcolor(A) % Heat-map of matrix: plot as grid of rectangles, coloured by value
+contour(A) % Contour plot of matrix
+mesh(A) % Plot as a mesh surface
+
+h = figure	% Create new figure object, with handle f
+figure(h) % Makes the figure corresponding to handle h the current figure
+close(h) % close figure with handle h
+close all % close all open figure windows
+close % close current figure window
+
+shg % bring an existing graphics window forward, or create new one if needed
+clf clear % clear current figure window, and reset most figure properties
+
+% Properties can be set and changed through a figure handle.
+% You can save a handle to a figure when you create it.
+% The function gcf returns a handle to the current figure
+h = plot(x, y); % you can save a handle to a figure when you create it
+set(h, 'Color', 'r')
+% 'y' yellow; 'm' magenta, 'c' cyan, 'r' red, 'g' green, 'b' blue, 'w' white, 'k' black
+set(h, 'LineStyle', '--')
+ % '--' is solid line, '---' dashed, ':' dotted, '-.' dash-dot, 'none' is no line
+get(h, 'LineStyle')
+
+
+% The function gca returns a handle to the axes for the current figure
+set(gca, 'XDir', 'reverse'); % reverse the direction of the x-axis
+
+% To create a figure that contains several axes in tiled positions, use subplot
+subplot(2,3,1); % select the first position in a 2-by-3 grid of subplots
+plot(x1); title('First Plot') % plot something in this position
+subplot(2,3,2); % select second position in the grid
+plot(x2); title('Second Plot') % plot something there
+
+
+% To use functions or scripts, they must be on your path or current directory
+path % display current path
+addpath /path/to/dir % add to path
+rmpath /path/to/dir % remove from path
+cd /path/to/move/into % change directory
+
+
+% Variables can be saved to .mat files
+save('myFileName.mat') % Save the variables in your Workspace
+load('myFileName.mat') % Load saved variables into Workspace
+
+% M-file Scripts
+% A script file is an external file that contains a sequence of statements.
+% They let you avoid repeatedly typing the same code in the Command Window
+% Have .m extensions
+
+% M-file Functions
+% Like scripts, and have the same .m extension
+% But can accept input arguments and return an output
+% Also, they have their own workspace (ie. different variable scope).
+% Function name should match file name (so save this example as double_input.m).
+% 'help double_input.m' returns the comments under line beginning function
+function output = double_input(x)
+	%double_input(x) returns twice the value of x
+	output = 2*x;
+end
+double_input(6) % ans = 12
+
+
+% You can also have subfunctions and nested functions.
+% Subfunctions are in the same file as the primary function, and can only be
+% called by functions in the file. Nested functions are defined within another
+% functions, and have access to both its workspace and their own workspace.
+
+% If you want to create a function without creating a new file you can use an
+% anonymous function. Useful when quickly defining a function to pass to
+% another function (eg. plot with fplot, evaluate an indefinite integral
+% with quad, find roots with fzero, or find minimum with fminsearch).
+% Example that returns the square of it's input, assigned to to the handle sqr:
+sqr = @(x) x.^2;
+sqr(10) % ans = 100
+doc function_handle % find out more
+
+% User input
+a = input('Enter the value: ')
+
+% Stops execution of file and gives control to the keyboard: user can examine
+% or change variables. Type 'return' to continue execution, or 'dbquit' to exit
+keyboard
+
+% Reading in data (also xlsread/importdata/imread for excel/CSV/image files)
+fopen(filename)
+
+% Output
+disp(a) % Print out the value of variable a
+disp('Hello World') % Print out a string
+fprintf % Print to Command Window with more control
+
+% Conditional statements (the parentheses are optional, but good style)
+if (a > 15)
+	disp('Greater than 15')
+elseif (a == 23)
+	disp('a is 23')
+else
+	disp('neither condition met')
+end
+
+% Looping
+% NB. looping over elements of a vector/matrix is slow!
+% Where possible, use functions that act on whole vector/matrix at once
+for k = 1:5
+	disp(k)
+end
+
+k = 0;
+while (k < 5)
+	k = k + 1;
+end
+
+% Timing code execution: 'toc' prints the time since 'tic' was called
+tic
+A = rand(1000);
+A*A*A*A*A*A*A;
+toc
+
+% Connecting to a MySQL Database
+dbname = 'database_name';
+username = 'root';
+password = 'root';
+driver = 'com.mysql.jdbc.Driver';
+dburl = ['jdbc:mysql://localhost:8889/' dbname];
+javaclasspath('mysql-connector-java-5.1.xx-bin.jar'); %xx depends on version, download available at http://dev.mysql.com/downloads/connector/j/
+conn = database(dbname, username, password, driver, dburl);
+sql = ['SELECT * from table_name where id = 22'] % Example sql statement
+a = fetch(conn, sql) %a will contain your data
+
+
+% Common math functions
+sin(x)
+cos(x)
+tan(x)
+asin(x)
+acos(x)
+atan(x)
+exp(x)
+sqrt(x)
+log(x)
+log10(x)
+abs(x)
+min(x)
+max(x)
+ceil(x)
+floor(x)
+round(x)
+rem(x)
+rand % Uniformly distributed pseudorandom numbers
+randi % Uniformly distributed pseudorandom integers
+randn % Normally distributed pseudorandom numbers
+
+% Common constants
+pi
+NaN
+inf
+
+% Solving matrix equations (if no solution, returns a least squares solution)
+% The \ and / operators are equivalent to the functions mldivide and mrdivide
+x=A\b % Solves Ax=b. Faster and more numerically accurate than using inv(A)*b.
+x=b/A % Solves xA=b
+
+inv(A) % calculate the inverse matrix
+pinv(A) % calculate the pseudo-inverse
+
+% Common matrix functions
+zeros(m,n) % m x n matrix of 0's
+ones(m,n) % m x n matrix of 1's
+diag(A) % Extracts the diagonal elements of a matrix A
+diag(x) % Construct a matrix with diagonal elements listed in x, and zeroes elsewhere
+eye(m,n) % Identity matrix
+linspace(x1, x2, n) % Return n equally spaced points, with min x1 and max x2
+inv(A) % Inverse of matrix A
+det(A) % Determinant of A
+eig(A) % Eigenvalues and eigenvectors of A
+trace(A) % Trace of matrix - equivalent to sum(diag(A))
+isempty(A) % Tests if array is empty
+all(A) % Tests if all elements are nonzero or true
+any(A) % Tests if any elements are nonzero or true
+isequal(A, B) % Tests equality of two arrays
+numel(A) % Number of elements in matrix
+triu(x) % Returns the upper triangular part of x
+tril(x) % Returns the lower triangular part of x
+cross(A,B) %  Returns the cross product of the vectors A and B
+dot(A,B) % Returns scalar product of two vectors (must have the same length)
+transpose(A) % Returns the transpose of A
+fliplr(A) % Flip matrix left to right
+flipud(A) % Flip matrix up to down
+
+% Matrix Factorisations
+[L, U, P] = lu(A) % LU decomposition: PA = LU,L is lower triangular, U is upper triangular, P is permutation matrix
+[P, D] = eig(A) % eigen-decomposition: AP = PD, P's columns are eigenvectors and D's diagonals are eigenvalues
+[U,S,V] = svd(X) % SVD: XV = US, U and V are unitary matrices, S has non-negative diagonal elements in decreasing order
+
+% Common vector functions
+max     % largest component
+min     % smallest component
+length  % length of a vector
+sort    % sort in ascending order
+sum     % sum of elements
+prod    % product of elements
+mode	% modal value
+median  % median value
+mean    % mean value
+std     % standard deviation
+perms(x) % list all permutations of elements of x
+
+
+% Classes
+% Matlab can support object-oriented programming. 
+% Classes must be put in a file of the class name with a .m extension. 
+% To begin, we create a simple class to store GPS waypoints.
+% Begin WaypointClass.m
+classdef WaypointClass % The class name.
+  properties % The properties of the class behave like Structures
+    latitude 
+    longitude 
+  end
+  methods 
+    % This method that has the same name of the class is the constructor. 
+    function obj = WaypointClass(lat, lon)
+      obj.latitude = lat;
+      obj.longitude = lon;
+    end
+
+    % Other functions that use the Waypoint object
+    function r = multiplyLatBy(obj, n)
+      r = n*[obj.latitude];
+    end
+
+    % If we want to add two Waypoint objects together without calling
+    % a special function we can overload Matlab's arithmetic like so:
+    function r = plus(o1,o2)
+      r = WaypointClass([o1.latitude] +[o2.latitude], ...
+                        [o1.longitude]+[o2.longitude]);
+    end
+  end
+end
+% End WaypointClass.m
+
+% We can create an object of the class using the constructor
+a = WaypointClass(45.0, 45.0)
+
+% Class properties behave exactly like Matlab Structures.
+a.latitude = 70.0
+a.longitude = 25.0
+
+% Methods can be called in the same way as functions
+ans = multiplyLatBy(a,3)
+
+% The method can also be called using dot notation. In this case, the object 
+% does not need to be passed to the method.
+ans = a.multiplyLatBy(a,1/3)
+
+% Matlab functions can be overloaded to handle objects. 
+% In the method above, we have overloaded how Matlab handles 
+% the addition of two Waypoint objects.
+b = WaypointClass(15.0, 32.0)
+c = a + b
+
+```
+
+## More on Matlab
+
+* The official website [http://http://www.mathworks.com/products/matlab/](http://www.mathworks.com/products/matlab/)
+* The official MATLAB Answers forum: [http://www.mathworks.com/matlabcentral/answers/](http://www.mathworks.com/matlabcentral/answers/)
+
-- 
cgit v1.2.3


From 603d72e9eaca53aeb3610eceecb9af7d0aa84e0d Mon Sep 17 00:00:00 2001
From: Claudson Martins <claudson@outlook.com>
Date: Sun, 18 Oct 2015 13:41:14 -0300
Subject: Matlab portuguese translation

The markdown is completely translated
---
 pt-br/matlab.html.markdown | 506 +++++++++++++++++++++++----------------------
 1 file changed, 255 insertions(+), 251 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/matlab.html.markdown b/pt-br/matlab.html.markdown
index 7c0760d1..4e822a60 100644
--- a/pt-br/matlab.html.markdown
+++ b/pt-br/matlab.html.markdown
@@ -26,11 +26,11 @@ com
 algo assim
 %}
 
-% comandos podem ocupar várinhas linhas, usando '...':
+% Comandos podem ocupar várinhas linhas, usando '...':
  a = 1 + 2 + ...
  + 4
 
-% comandos podem ser passados para o sistema operacional
+% Comandos podem ser passados para o sistema operacional
 !ping google.com
 
 who % Exibe todas as variáveis na memória
@@ -46,7 +46,7 @@ ctrl-c % Aborta a computação atual
 edit('minhafuncao.m') % Abre a função/script no editor
 type('minhafuncao.m') % Imprime o código-fonte da função/script na janela de comando
 
-profile on 	% Ativa o perfil de código
+profile on    % Ativa o perfil de código
 profile off 	% Desativa o perfil de código
 profile viewer 	% Visualiza os resultados na janela de Profiler
 
@@ -77,97 +77,98 @@ c = exp(a)*sin(pi/2) % c = 7.3891
 load('arquivo.mat', 'y') % Argumentos entre parênteses, separados por vírgula
 % Sintaxe de comando:
 load arquivo.mat y 	% Sem parênteses, e espaços ao invés de vírgulas
-% Observe a falta de aspas no formulário de comando: entradas são sempre
-% passadas como texto literal - não pode passar valores de variáveis.
+% Observe a falta de aspas na forma de comando: entradas são sempre passadas
+% como texto literal - não pode passar valores de variáveis.
 % Além disso, não pode receber saída:
-[V,D] = eig(A);  % this has no equivalent in command form
-[~,D] = eig(A);  % if you only want D and not V
+[V,D] = eig(A);  % Isto não tem um equivalente na forma de comando
+[~,D] = eig(A);  % Se você só deseja D e não V
 
 
 
-% Logicals
-1 > 5 % ans = 0
-10 >= 10 % ans = 1
-3 ~= 4 % Not equal to -> ans = 1
-3 == 3 % equal to -> ans = 1
-3 > 1 && 4 > 1 % AND -> ans = 1
-3 > 1 || 4 > 1 % OR -> ans = 1
-~1 % NOT -> ans = 0
+% Operadores Lógicos e Relacionais
+1 > 5 % Resposta = 0
+10 >= 10 % Resposta = 1
+3 ~= 4 % Diferente de -> Resposta = 1
+3 == 3 % Igual a -> Resposta = 1
+3 > 1 && 4 > 1 % E -> Resposta = 1
+3 > 1 || 4 > 1 % OU -> Resposta = 1
+~1 % NOT -> Resposta = 0
 
-% Logicals can be applied to matrices:
+% Operadores Lógicos e Relacionais podem ser aplicados a matrizes
 A > 5
-% for each element, if condition is true, that element is 1 in returned matrix
+% Para cada elemento, caso seja verdade, esse elemento será 1 na matriz retornada
 A( A > 5 )
-% returns a vector containing the elements in A for which condition is true
+% Retorna um vetor com os elementos de A para os quais a condição é verdadeira
 
-% Strings
-a = 'MyString'
-length(a) % ans = 8
-a(2) % ans = y
-[a,a] % ans = MyStringMyString
+% Cadeias de caracteres (Strings)
+a = 'MinhaString'
+length(a) % Resposta = 11
+a(2) % Resposta = i
+[a,a] % Resposta = MinhaStringMinhaString
 
 
-% Cells
-a = {'one', 'two', 'three'}
-a(1) % ans = 'one' - returns a cell
-char(a(1)) % ans = one - returns a string
+% Vetores de células
+a = {'um', 'dois', 'três'}
+a(1) % Resposta = 'um' - retorna uma célula
+char(a(1)) % Resposta = um - retorna uma string
 
-% Structures
-A.b = {'one','two'};
+% Estruturas
+A.b = {'um','dois'};
 A.c = [1 2];
 A.d.e = false;
 
-% Vectors
+% Vetores
 x = [4 32 53 7 1]
-x(2) % ans = 32, indices in Matlab start 1, not 0
-x(2:3) % ans = 32 53
-x(2:end) % ans = 32 53 7 1
+x(2) % Resposta = 32, índices no Matlab começam por 1, não 0
+x(2:3) % Resposta = 32 53
+x(2:end) % Resposta = 32 53 7 1
 
-x = [4; 32; 53; 7; 1] % Column vector
+x = [4; 32; 53; 7; 1] % Vetor coluna
 
 x = [1:10] % x = 1 2 3 4 5 6 7 8 9 10
 
-% Matrices
+% Matrizes
 A = [1 2 3; 4 5 6; 7 8 9]
-% Rows are separated by a semicolon; elements are separated with space or comma
+% Linhas são separadas por um ponto e vírgula;
+% Elementos são separados com espaço ou vírgula
 % A =
 
 %     1     2     3
 %     4     5     6
 %     7     8     9
 
-A(2,3) % ans = 6, A(row, column)
-A(6) % ans = 8
-% (implicitly concatenates columns into vector, then indexes into that)
+A(2,3) % Resposta = 6, A(linha, coluna)
+A(6) % Resposta = 8
+% (implicitamente encadeia as colunas do vetor, e então as indexa)
 
 
-A(2,3) = 42 % Update row 2 col 3 with 42
+A(2,3) = 42 % Atualiza a linha 2 coluna 3 com o valor 42
 % A =
 
 %     1     2     3
 %     4     5     42
 %     7     8     9
 
-A(2:3,2:3) % Creates a new matrix from the old one
-%ans =
+A(2:3,2:3) % Cria uma nova matriz a partir da antiga
+%Resposta =
 
 %     5     42
 %     8     9
 
-A(:,1) % All rows in column 1
-%ans =
+A(:,1) % Todas as linhas na coluna 1
+%Resposta =
 
 %     1
 %     4
 %     7
 
-A(1,:) % All columns in row 1
-%ans =
+A(1,:) % Todas as colunas na linha 1
+%Resposta =
 
 %     1     2     3
 
-[A ; A] % Concatenation of matrices (vertically)
-%ans =
+[A ; A] % Concatenação de matrizes (verticalmente)
+%Resposta =
 
 %     1     2     3
 %     4     5    42
@@ -176,195 +177,197 @@ A(1,:) % All columns in row 1
 %     4     5    42
 %     7     8     9
 
-% this is the same as
+% Isto é o mesmo de
 vertcat(A,A);
 
 
-[A , A] % Concatenation of matrices (horizontally)
+[A , A] % Concatenação de matrizes (horizontalmente)
 
-%ans =
+%Resposta =
 
 %     1     2     3     1     2     3
 %     4     5    42     4     5    42
 %     7     8     9     7     8     9
 
-% this is the same as
+% Isto é o mesmo de
 horzcat(A,A);
 
 
-A(:, [3 1 2]) % Rearrange the columns of original matrix
-%ans =
+A(:, [3 1 2]) % Reorganiza as colunas da matriz original
+%Resposta =
 
 %     3     1     2
 %    42     4     5
 %     9     7     8
 
-size(A) % ans = 3 3
+size(A) % Resposta = 3 3
 
-A(1, :) =[] % Delete the first row of the matrix
-A(:, 1) =[] % Delete the first column of the matrix
+A(1, :) =[] % Remove a primeira linha da matriz
+A(:, 1) =[] % Remove a primeira coluna da matriz
 
-transpose(A) % Transpose the matrix, which is the same as:
+transpose(A) % Transposta a matriz, que é o mesmo de:
 A one
-ctranspose(A) % Hermitian transpose the matrix
-% (the transpose, followed by taking complex conjugate of each element)
+ctranspose(A) % Transposta a matriz
+% (a transposta, seguida pelo conjugado complexo de cada elemento)
 
 
 
 
-% Element by Element Arithmetic vs. Matrix Arithmetic
-% On their own, the arithmetic operators act on whole matrices. When preceded
-% by a period, they act on each element instead. For example:
-A * B % Matrix multiplication
-A .* B % Multiple each element in A by its corresponding element in B
+% Aritmética Elemento por Elemento vs. Aritmética com Matriz
+% Naturalmente, os operadores aritméticos agem em matrizes inteiras. Quando
+% precedidos por um ponto, eles atuam em cada elemento. Por exemplo:
+A * B % Multiplicação de matrizes
+A .* B % Multiplica cada elemento em A por seu correspondente em B
 
-% There are several pairs of functions, where one acts on each element, and
-% the other (whose name ends in m) acts on the whole matrix.
-exp(A) % exponentiate each element
-expm(A) % calculate the matrix exponential
-sqrt(A) % take the square root of each element
-sqrtm(A) %  find the matrix whose square is A
+% Existem vários pares de funções nas quais uma atua sob cada elemento, e a
+% outra (cujo nome termina com m) age na matriz por completo.
+exp(A) % Exponencia cada elemento
+expm(A) % Calcula o exponencial da matriz
+sqrt(A) % Tira a raiz quadrada de cada elemento
+sqrtm(A) %  Procura a matriz cujo quadrado é A
 
 
-% Plotting
-x = 0:.10:2*pi; % Creates a vector that starts at 0 and ends at 2*pi with increments of .1
+% Gráficos
+x = 0:.10:2*pi; % Vetor que começa em 0 e termina em 2*pi com incrementos de 0,1
 y = sin(x);
 plot(x,y)
-xlabel('x axis')
-ylabel('y axis')
-title('Plot of y = sin(x)')
-axis([0 2*pi -1 1]) % x range from 0 to 2*pi, y range from -1 to 1
+xlabel('eixo x')
+ylabel('eixo y')
+title('Gráfico de y = sin(x)')
+axis([0 2*pi -1 1]) % x vai de 0 a 2*pi, y vai de -1 a 1
 
-plot(x,y1,'-',x,y2,'--',x,y3,':') % For multiple functions on one plot
-legend('Line 1 label', 'Line 2 label') % Label curves with a legend
+plot(x,y1,'-',x,y2,'--',x,y3,':') % Para várias funções em um só gráfico
+legend('Descrição linha 1', 'Descrição linha 2') % Curvas com uma legenda
 
-% Alternative method to plot multiple functions in one plot.
-% while 'hold' is on, commands add to existing graph rather than replacing it
+% Método alternativo para traçar várias funções em um só gráfico:
+% Enquanto 'hold' estiver ativo, os comandos serão adicionados ao gráfico
+% existente ao invés de o substituirem.
 plot(x, y)
 hold on
 plot(x, z)
 hold off
 
-loglog(x, y) % A log-log plot
-semilogx(x, y) % A plot with logarithmic x-axis
-semilogy(x, y) % A plot with logarithmic y-axis
+loglog(x, y) % Plotar em escala loglog
+semilogx(x, y) % Um gráfico com eixo x logarítmico
+semilogy(x, y) % Um gráfico com eixo y logarítmico
 
-fplot (@(x) x^2, [2,5]) % plot the function x^2 from x=2 to x=5
+fplot (@(x) x^2, [2,5]) % Plotar a função x^2 para x=2 até x=5
 
-grid on % Show grid; turn off with 'grid off'
-axis square % Makes the current axes region square
-axis equal % Set aspect ratio so data units are the same in every direction
+grid on % Exibe as linhas de grade; Oculta com 'grid off'
+axis square % Torna quadrada a região dos eixos atuais
+axis equal % Taxa de proporção onde as unidades serão as mesmas em todas direções
 
-scatter(x, y); % Scatter-plot
-hist(x); % Histogram
+scatter(x, y); % Gráfico de dispersão ou bolha
+hist(x); % Histograma
 
 z = sin(x);
-plot3(x,y,z); % 3D line plot
+plot3(x,y,z); % Plotar em espaço em 3D
 
-pcolor(A) % Heat-map of matrix: plot as grid of rectangles, coloured by value
-contour(A) % Contour plot of matrix
-mesh(A) % Plot as a mesh surface
+pcolor(A) % Mapa de calor da matriz: traça uma grade de retângulos, coloridos pelo valor
+contour(A) % Plotar de contorno da matriz
+mesh(A) % Plotar malha 3D
 
-h = figure	% Create new figure object, with handle f
-figure(h) % Makes the figure corresponding to handle h the current figure
-close(h) % close figure with handle h
-close all % close all open figure windows
-close % close current figure window
+h = figure	% Cria uma nova figura objeto, com identificador h
+figure(h) % Cria uma nova janela de figura com h
+close(h) % Fecha a figura h
+close all % Fecha todas as janelas de figuras abertas
+close % Fecha a janela de figura atual
 
-shg % bring an existing graphics window forward, or create new one if needed
-clf clear % clear current figure window, and reset most figure properties
+shg % Traz uma janela gráfica existente para frente, ou cria uma nova se necessário
+clf clear % Limpa a janela de figura atual e redefine a maioria das propriedades da figura
 
-% Properties can be set and changed through a figure handle.
-% You can save a handle to a figure when you create it.
-% The function gcf returns a handle to the current figure
-h = plot(x, y); % you can save a handle to a figure when you create it
+% Propriedades podem ser definidas e alteradas através de um identificador.
+% Você pode salvar um identificador para uma figura ao criá-la.
+% A função gcf retorna o identificador da figura atual
+h = plot(x, y); % Você pode salvar um identificador para a figura ao criá-la
 set(h, 'Color', 'r')
-% 'y' yellow; 'm' magenta, 'c' cyan, 'r' red, 'g' green, 'b' blue, 'w' white, 'k' black
+% 'y' amarelo; 'm' magenta, 'c' ciano, 'r' vermelho, 'g' verde, 'b' azul, 'w' branco, 'k' preto
 set(h, 'LineStyle', '--')
- % '--' is solid line, '---' dashed, ':' dotted, '-.' dash-dot, 'none' is no line
+ % '--' linha sólida, '---' tracejada, ':' pontilhada, '-.' traço-ponto, 'none' sem linha
 get(h, 'LineStyle')
 
 
-% The function gca returns a handle to the axes for the current figure
-set(gca, 'XDir', 'reverse'); % reverse the direction of the x-axis
+% A função gca retorna o identificador para os eixos da figura atual
+set(gca, 'XDir', 'reverse'); % Inverte a direção do eixo x
 
-% To create a figure that contains several axes in tiled positions, use subplot
-subplot(2,3,1); % select the first position in a 2-by-3 grid of subplots
-plot(x1); title('First Plot') % plot something in this position
-subplot(2,3,2); % select second position in the grid
-plot(x2); title('Second Plot') % plot something there
+% Para criar uma figura que contém vários gráficos use subplot, o qual divide
+% a janela de gráficos em m linhas e n colunas.
+subplot(2,3,1); % Seleciona a primeira posição em uma grade de 2-por-3
+plot(x1); title('Primeiro Plot') % Plota algo nesta posição
+subplot(2,3,2); % Seleciona a segunda posição na grade
+plot(x2); title('Segundo Plot') % Plota algo ali
 
 
-% To use functions or scripts, they must be on your path or current directory
-path % display current path
-addpath /path/to/dir % add to path
-rmpath /path/to/dir % remove from path
-cd /path/to/move/into % change directory
+% Para usar funções ou scripts, eles devem estar no caminho ou na pasta atual
+path % Exibe o caminho atual
+addpath /caminho/para/pasta % Adiciona o diretório ao caminho
+rmpath /caminho/para/pasta % Remove o diretório do caminho
+cd /caminho/para/mudar % Muda o diretório
 
 
-% Variables can be saved to .mat files
-save('myFileName.mat') % Save the variables in your Workspace
-load('myFileName.mat') % Load saved variables into Workspace
+% Variáveis podem ser salvas em arquivos *.mat
+save('meuArquivo.mat') % Salva as variáveis do seu Workspace
+load('meuArquivo.mat') % Carrega as variáveis em seu Workspace
 
-% M-file Scripts
-% A script file is an external file that contains a sequence of statements.
-% They let you avoid repeatedly typing the same code in the Command Window
-% Have .m extensions
+% Arquivos M (M-files)
+% Um arquivo de script é um arquivo externo contendo uma sequência de instruções.
+% Eles evitam que você digite os mesmos códigos repetidamente na janela de comandos.
+% Possuem a extensão *.m
 
-% M-file Functions
-% Like scripts, and have the same .m extension
-% But can accept input arguments and return an output
-% Also, they have their own workspace (ie. different variable scope).
-% Function name should match file name (so save this example as double_input.m).
-% 'help double_input.m' returns the comments under line beginning function
-function output = double_input(x)
-	%double_input(x) returns twice the value of x
+% Arquivos M de Funções (M-file Functions)
+% Assim como scripts e têm a mesma extensão *.m
+% Mas podem aceitar argumentos de entrada e retornar uma saída.
+% Além disso, possuem seu próprio workspace (ex. diferente escopo de variáveis).
+% O nome da função deve coincidir com o nome do arquivo (salve o exemplo como dobra_entrada.m)
+% 'help dobra_entrada.m' retorna os comentários abaixo da linha de início da função
+function output = dobra_entrada(x)
+	%dobra_entrada(x) retorna duas vezes o valor de x
 	output = 2*x;
 end
-double_input(6) % ans = 12
+dobra_entrada(6) % Resposta = 12
 
 
-% You can also have subfunctions and nested functions.
-% Subfunctions are in the same file as the primary function, and can only be
-% called by functions in the file. Nested functions are defined within another
-% functions, and have access to both its workspace and their own workspace.
+% Você também pode ter subfunções e funções aninhadas.
+% Subfunções estão no mesmo arquivo da função primária, e só podem ser chamados
+% por funções dentro do arquivo. Funções aninhadas são definidas dentro de
+% outras funções, e têm acesso a ambos workspaces.
 
-% If you want to create a function without creating a new file you can use an
-% anonymous function. Useful when quickly defining a function to pass to
-% another function (eg. plot with fplot, evaluate an indefinite integral
-% with quad, find roots with fzero, or find minimum with fminsearch).
-% Example that returns the square of it's input, assigned to to the handle sqr:
+% Se você quer criar uma função sem criar um novo arquivo, você pode usar uma
+% função anônima. Úteis para definir rapidamente uma função para passar a outra
+% função (ex. plotar com fplot, avaliar uma integral indefinida com quad,
+% procurar raízes com fzero, ou procurar mínimo com fminsearch).
+% Exemplo que retorna o quadrado de sua entrada, atribuído ao identificador sqr:
 sqr = @(x) x.^2;
-sqr(10) % ans = 100
-doc function_handle % find out more
+sqr(10) % Resposta = 100
+doc function_handle % Saiba mais
 
-% User input
-a = input('Enter the value: ')
+% Entrada do usuário
+a = input('Digite o valor: ')
 
-% Stops execution of file and gives control to the keyboard: user can examine
-% or change variables. Type 'return' to continue execution, or 'dbquit' to exit
+% Para a execução do arquivo e passa o controle para o teclado: o usuário pode
+% examinar ou alterar variáveis. Digite 'return' para continuar a execução, ou 'dbquit' para sair
 keyboard
 
-% Reading in data (also xlsread/importdata/imread for excel/CSV/image files)
-fopen(filename)
+% Leitura de dados (ou xlsread/importdata/imread para arquivos excel/CSV/imagem)
+fopen(nomedoarquivo)
 
-% Output
-disp(a) % Print out the value of variable a
-disp('Hello World') % Print out a string
-fprintf % Print to Command Window with more control
+% Saída
+disp(a) % Imprime o valor da variável a
+disp('Olá Mundo') % Imprime a string
+fprintf % Imprime na janela de comandos com mais controle
 
-% Conditional statements (the parentheses are optional, but good style)
+% Estruturas Condicionais (os parênteses são opicionais, porém uma boa prática)
 if (a > 15)
-	disp('Greater than 15')
+	disp('Maior que 15')
 elseif (a == 23)
-	disp('a is 23')
+	disp('a é 23')
 else
-	disp('neither condition met')
+	disp('Nenhuma condição reconheceu')
 end
 
-% Looping
-% NB. looping over elements of a vector/matrix is slow!
-% Where possible, use functions that act on whole vector/matrix at once
+% Estruturas de Repetição
+% Nota: fazer o loop sobre elementos de um vetor/matriz é lento!
+% Sempre que possível, use funções que atuem em todo o vetor/matriz de uma só vez.
 for k = 1:5
 	disp(k)
 end
@@ -374,25 +377,26 @@ while (k < 5)
 	k = k + 1;
 end
 
-% Timing code execution: 'toc' prints the time since 'tic' was called
+% Tempo de Execução de Código (Timing Code Execution): 'toc' imprime o tempo
+% passado desde que 'tic' foi chamado.
 tic
 A = rand(1000);
 A*A*A*A*A*A*A;
 toc
 
-% Connecting to a MySQL Database
-dbname = 'database_name';
+% Conectando a uma base de dados MySQL
+dbname = 'nome_base_de_dados';
 username = 'root';
 password = 'root';
 driver = 'com.mysql.jdbc.Driver';
 dburl = ['jdbc:mysql://localhost:8889/' dbname];
-javaclasspath('mysql-connector-java-5.1.xx-bin.jar'); %xx depends on version, download available at http://dev.mysql.com/downloads/connector/j/
+javaclasspath('mysql-connector-java-5.1.xx-bin.jar'); %xx depende da versão, download disponível em http://dev.mysql.com/downloads/connector/j/
 conn = database(dbname, username, password, driver, dburl);
-sql = ['SELECT * from table_name where id = 22'] % Example sql statement
+sql = ['SELECT * FROM nome_tabela WHERE id = 22'] % Exemplo de uma consulta SQL
 a = fetch(conn, sql) %a will contain your data
 
 
-% Common math functions
+% Funções Matemáticas Comuns
 sin(x)
 cos(x)
 tan(x)
@@ -410,122 +414,122 @@ ceil(x)
 floor(x)
 round(x)
 rem(x)
-rand % Uniformly distributed pseudorandom numbers
-randi % Uniformly distributed pseudorandom integers
-randn % Normally distributed pseudorandom numbers
+rand % Números pseudo-aleatórios uniformemente distribuídos
+randi % Inteiros pseudo-aleatórios uniformemente distribuídos
+randn % Números pseudo-aleatórios normalmente distribuídos
 
-% Common constants
+% Constantes Comuns
 pi
 NaN
 inf
 
-% Solving matrix equations (if no solution, returns a least squares solution)
-% The \ and / operators are equivalent to the functions mldivide and mrdivide
-x=A\b % Solves Ax=b. Faster and more numerically accurate than using inv(A)*b.
-x=b/A % Solves xA=b
-
-inv(A) % calculate the inverse matrix
-pinv(A) % calculate the pseudo-inverse
-
-% Common matrix functions
-zeros(m,n) % m x n matrix of 0's
-ones(m,n) % m x n matrix of 1's
-diag(A) % Extracts the diagonal elements of a matrix A
-diag(x) % Construct a matrix with diagonal elements listed in x, and zeroes elsewhere
-eye(m,n) % Identity matrix
-linspace(x1, x2, n) % Return n equally spaced points, with min x1 and max x2
-inv(A) % Inverse of matrix A
-det(A) % Determinant of A
-eig(A) % Eigenvalues and eigenvectors of A
-trace(A) % Trace of matrix - equivalent to sum(diag(A))
-isempty(A) % Tests if array is empty
-all(A) % Tests if all elements are nonzero or true
-any(A) % Tests if any elements are nonzero or true
-isequal(A, B) % Tests equality of two arrays
-numel(A) % Number of elements in matrix
-triu(x) % Returns the upper triangular part of x
-tril(x) % Returns the lower triangular part of x
-cross(A,B) %  Returns the cross product of the vectors A and B
-dot(A,B) % Returns scalar product of two vectors (must have the same length)
-transpose(A) % Returns the transpose of A
-fliplr(A) % Flip matrix left to right
-flipud(A) % Flip matrix up to down
-
-% Matrix Factorisations
-[L, U, P] = lu(A) % LU decomposition: PA = LU,L is lower triangular, U is upper triangular, P is permutation matrix
-[P, D] = eig(A) % eigen-decomposition: AP = PD, P's columns are eigenvectors and D's diagonals are eigenvalues
-[U,S,V] = svd(X) % SVD: XV = US, U and V are unitary matrices, S has non-negative diagonal elements in decreasing order
-
-% Common vector functions
-max     % largest component
-min     % smallest component
-length  % length of a vector
-sort    % sort in ascending order
-sum     % sum of elements
-prod    % product of elements
-mode	% modal value
-median  % median value
-mean    % mean value
-std     % standard deviation
-perms(x) % list all permutations of elements of x
+% Resolvendo equações matriciais (se não houver solução, retorna uma solução de mínimos quadrados)
+% Os operadores \ e / são equivalentes às funções mldivide e mrdivide
+x=A\b % Resolve Ax=b. Mais rápido e numericamente mais preciso do que inv(A)*b.
+x=b/A % Resolve xA=b
+
+inv(A) % Calcula a matriz inversa
+pinv(A) % Calcula a pseudo-inversa
+
+% Funções Matriciais Comuns
+zeros(m,n) % Matriz de zeros m x n
+ones(m,n) % Matriz de 1's m x n
+diag(A) % Extrai os elementos diagonais da matriz A
+diag(x) % Constrói uma matriz com os elementos diagonais listados em x, e zero nas outras posições
+eye(m,n) % Matriz identidade
+linspace(x1, x2, n) % Retorna n pontos igualmente espaçados, com min x1 e max x2
+inv(A) % Inverso da matriz A
+det(A) % Determinante da matriz A
+eig(A) % Valores e vetores próprios de A
+trace(A) % Traço da matriz - equivalente a sum(diag(A))
+isempty(A) % Testa se a matriz está vazia
+all(A) % Testa se todos os elementos são diferentes de zero ou verdadeiro
+any(A) % Testa se algum elemento é diferente de zero ou verdadeiro
+isequal(A, B) % Testa a igualdade de duas matrizes
+numel(A) % Número de elementos na matriz
+triu(x) % Retorna a parte triangular superior de x
+tril(x) % Retorna a parte triangular inferior de x
+cross(A,B) %  Retorna o produto cruzado das matrizes A e B
+dot(A,B) % Retorna o produto escalar de duas matrizes (devem possuir mesmo tamanho)
+transpose(A) % Retorna a matriz transposta de A
+fliplr(A) % Inverte a matriz da esquerda para a direita
+flipud(A) % Inverte a matriz de cima para baixo
+
+% Fatorações de Matrizes
+[L, U, P] = lu(A) % Decomposição LU: PA = LU,L é triangular inferior, U é triangular superior, P é a matriz de permutação
+[P, D] = eig(A) % Decomposição em Autovalores: AP = PD, colunas de P são autovetores e as diagonais de D são autovalores
+[U,S,V] = svd(X) % SVD: XV = US, U e V são matrizes unitárias, S possui elementos não negativos na diagonal em ordem decrescente
+
+% Funções Vetoriais Comuns
+max     % Maior componente
+min     % Menor componente
+length  % Tamanho do vetor
+sort    % Ordena em orcer ascendente
+sum     % Soma de elementos
+prod    % Produto de elementos
+mode	% Valor modal
+median  % Valor mediano
+mean    % Valor médio
+std     % Desvio padrão
+perms(x) % Lista todas as permutações de elementos de x
 
 
 % Classes
-% Matlab can support object-oriented programming. 
-% Classes must be put in a file of the class name with a .m extension. 
-% To begin, we create a simple class to store GPS waypoints.
-% Begin WaypointClass.m
-classdef WaypointClass % The class name.
-  properties % The properties of the class behave like Structures
+% Matlab pode suportar programação orientada a objetos.
+% Classes devem ser colocadas em um arquivo de mesmo nome com a extensão *.m
+% Para começar, criamos uma simples classe que armazena posições de GPS
+% Início ClassePosicoesGPS.m
+classdef ClassePosicoesGPS % O nome da classe.
+  properties % As propriedades da classe comportam-se como estruturas
     latitude 
     longitude 
   end
   methods 
-    % This method that has the same name of the class is the constructor. 
-    function obj = WaypointClass(lat, lon)
+    % Este método que tem o mesmo nome da classe é o construtor.
+    function obj = ClassePosicoesGPS(lat, lon)
       obj.latitude = lat;
       obj.longitude = lon;
     end
 
-    % Other functions that use the Waypoint object
-    function r = multiplyLatBy(obj, n)
+    % Outras funções que usam os objetos de PosicoesGPS
+    function r = multiplicarLatPor(obj, n)
       r = n*[obj.latitude];
     end
 
-    % If we want to add two Waypoint objects together without calling
-    % a special function we can overload Matlab's arithmetic like so:
+    % Se quisermos somar dois objetos de PosicoesGPS juntos sem chamar
+    % uma função especial nós podemos sobrepor a aritmética do Matlab, desta maneira:
     function r = plus(o1,o2)
-      r = WaypointClass([o1.latitude] +[o2.latitude], ...
+      r = ClassePosicoesGPS([o1.latitude] +[o2.latitude], ...
                         [o1.longitude]+[o2.longitude]);
     end
   end
 end
-% End WaypointClass.m
+% End ClassePosicoesGPS.m
 
-% We can create an object of the class using the constructor
-a = WaypointClass(45.0, 45.0)
+% Podemos criar um objeto da classe usando o construtor
+a = ClassePosicoesGPS(45.0, 45.0)
 
-% Class properties behave exactly like Matlab Structures.
+% Propriedades da classe se comportam exatamente como estruturas Matlab
 a.latitude = 70.0
 a.longitude = 25.0
 
-% Methods can be called in the same way as functions
-ans = multiplyLatBy(a,3)
+% Métodos podem ser chamados da mesma forma que funções
+ans = multiplicarLatPor(a,3)
 
-% The method can also be called using dot notation. In this case, the object 
-% does not need to be passed to the method.
-ans = a.multiplyLatBy(a,1/3)
+% O método também pode ser chamado usando a notação de ponto. Neste caso,
+% o objeto não precisa ser passado para o método.
+ans = a.multiplicarLatPor(a,1/3)
 
-% Matlab functions can be overloaded to handle objects. 
-% In the method above, we have overloaded how Matlab handles 
-% the addition of two Waypoint objects.
-b = WaypointClass(15.0, 32.0)
+% Funções do Matlab podem ser sobrepostas para lidar com objetos.
+% No método abaixo, nós sobrepomos a forma como o Matlab lida com a soma de
+% dois objetos PosicoesGPS.
+b = ClassePosicoesGPS(15.0, 32.0)
 c = a + b
 
 ```
 
-## More on Matlab
+## Mais sobre Matlab
 
-* The official website [http://http://www.mathworks.com/products/matlab/](http://www.mathworks.com/products/matlab/)
-* The official MATLAB Answers forum: [http://www.mathworks.com/matlabcentral/answers/](http://www.mathworks.com/matlabcentral/answers/)
+* O site oficial [http://http://www.mathworks.com/products/matlab/](http://www.mathworks.com/products/matlab/)
+* O fórum oficial de respostas: [http://www.mathworks.com/matlabcentral/answers/](http://www.mathworks.com/matlabcentral/answers/)
 
-- 
cgit v1.2.3


From a98f1d041b5d492490d8b14c71b5a33fb4bad00e Mon Sep 17 00:00:00 2001
From: Claudson Martins <claudson@outlook.com>
Date: Sun, 18 Oct 2015 13:46:27 -0300
Subject: Fixing some linebreaks

Some lines were broken to be better presented
---
 pt-br/matlab.html.markdown | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/matlab.html.markdown b/pt-br/matlab.html.markdown
index 4e822a60..ea320d07 100644
--- a/pt-br/matlab.html.markdown
+++ b/pt-br/matlab.html.markdown
@@ -390,7 +390,8 @@ username = 'root';
 password = 'root';
 driver = 'com.mysql.jdbc.Driver';
 dburl = ['jdbc:mysql://localhost:8889/' dbname];
-javaclasspath('mysql-connector-java-5.1.xx-bin.jar'); %xx depende da versão, download disponível em http://dev.mysql.com/downloads/connector/j/
+%Abaixo, o xx depende da versão, download disponível em http://dev.mysql.com/downloads/connector/j/
+javaclasspath('mysql-connector-java-5.1.xx-bin.jar');
 conn = database(dbname, username, password, driver, dburl);
 sql = ['SELECT * FROM nome_tabela WHERE id = 22'] % Exemplo de uma consulta SQL
 a = fetch(conn, sql) %a will contain your data
@@ -456,9 +457,12 @@ fliplr(A) % Inverte a matriz da esquerda para a direita
 flipud(A) % Inverte a matriz de cima para baixo
 
 % Fatorações de Matrizes
-[L, U, P] = lu(A) % Decomposição LU: PA = LU,L é triangular inferior, U é triangular superior, P é a matriz de permutação
-[P, D] = eig(A) % Decomposição em Autovalores: AP = PD, colunas de P são autovetores e as diagonais de D são autovalores
-[U,S,V] = svd(X) % SVD: XV = US, U e V são matrizes unitárias, S possui elementos não negativos na diagonal em ordem decrescente
+% Decomposição LU: PA = LU,L é triangular inferior, U é triangular superior, P é a matriz de permutação
+[L, U, P] = lu(A)
+% Decomposição em Autovalores: AP = PD, colunas de P são autovetores e as diagonais de D são autovalores
+[P, D] = eig(A)
+% SVD: XV = US, U e V são matrizes unitárias, S possui elementos não negativos na diagonal em ordem decrescente
+[U,S,V] = svd(X)
 
 % Funções Vetoriais Comuns
 max     % Maior componente
-- 
cgit v1.2.3


From 9ee5d3739fac053c2c156e071162638392149e1d Mon Sep 17 00:00:00 2001
From: Claudson Martins <claudson@outlook.com>
Date: Sun, 18 Oct 2015 14:12:16 -0300
Subject: Rename matlab.html.markdown to matlab-pt.html.markdown

---
 pt-br/matlab-pt.html.markdown | 539 ++++++++++++++++++++++++++++++++++++++++++
 pt-br/matlab.html.markdown    | 539 ------------------------------------------
 2 files changed, 539 insertions(+), 539 deletions(-)
 create mode 100644 pt-br/matlab-pt.html.markdown
 delete mode 100644 pt-br/matlab.html.markdown

(limited to 'pt-br')

diff --git a/pt-br/matlab-pt.html.markdown b/pt-br/matlab-pt.html.markdown
new file mode 100644
index 00000000..ea320d07
--- /dev/null
+++ b/pt-br/matlab-pt.html.markdown
@@ -0,0 +1,539 @@
+---
+language: Matlab
+contributors:
+    - ["mendozao", "http://github.com/mendozao"]
+    - ["jamesscottbrown", "http://jamesscottbrown.com"]
+    - ["Colton Kohnke", "http://github.com/voltnor"]
+translators:
+    - ["Claudson Martins", "https://github.com/claudsonm"]
+lang: pt-br
+
+---
+
+MATLAB significa MATrix LABoratory. É uma poderosa linguagem de computação numérica geralmente utilizada em engenharia e matemática.
+
+Se você tem algum feedback, por favor fique a vontade para me contactar via
+[@the_ozzinator](https://twitter.com/the_ozzinator), ou
+[osvaldo.t.mendoza@gmail.com](mailto:osvaldo.t.mendoza@gmail.com).
+
+```matlab
+% Comentários iniciam com um sinal de porcentagem
+
+%{
+Comentários de múltiplas linhas
+parecem
+com
+algo assim
+%}
+
+% Comandos podem ocupar várinhas linhas, usando '...':
+ a = 1 + 2 + ...
+ + 4
+
+% Comandos podem ser passados para o sistema operacional
+!ping google.com
+
+who % Exibe todas as variáveis na memória
+whos % Exibe todas as variáveis na memória, com seus tipos
+clear % Apaga todas as suas variáveis da memória
+clear('A') % Apaga uma variável em particular
+openvar('A') % Abre a variável no editor de variável
+
+clc % Apaga o conteúdo escrito na sua janela de comando
+diary % Alterna o conteúdo escrito na janela de comando para um arquivo de texto
+ctrl-c % Aborta a computação atual
+
+edit('minhafuncao.m') % Abre a função/script no editor
+type('minhafuncao.m') % Imprime o código-fonte da função/script na janela de comando
+
+profile on    % Ativa o perfil de código
+profile off 	% Desativa o perfil de código
+profile viewer 	% Visualiza os resultados na janela de Profiler
+
+help comando 	% Exibe a documentação do comando na janela de comando
+doc comando 	% Exibe a documentação do comando na janela de ajuda
+lookfor comando % Procura por comando na primeira linha comentada de todas as funções
+lookfor comando -all % Procura por comando em todas as funções
+
+
+% Formatação de saída
+format short 	% 4 casas decimais em um número flutuante
+format long 	% 15 casas decimais
+format bank 	% 2 dígitos após o ponto decimal - para cálculos financeiros
+fprintf('texto') % Imprime na tela "texto"
+disp('texto') 	% Imprime na tela "texto"
+
+% Variáveis & Expressões
+minhaVariavel = 4  % O painel Workspace mostra a variável recém-criada
+minhaVariavel = 4; % Ponto e vírgula suprime a saída para a janela de comando
+4 + 6  		% Resposta = 10
+8 * minhaVariavel 	% Resposta = 32
+2 ^ 3 		% Resposta = 8
+a = 2; b = 3;
+c = exp(a)*sin(pi/2) % c = 7.3891
+
+% A chamada de funções pode ser feita por uma das duas maneiras:
+% Sintaxe de função padrão:
+load('arquivo.mat', 'y') % Argumentos entre parênteses, separados por vírgula
+% Sintaxe de comando:
+load arquivo.mat y 	% Sem parênteses, e espaços ao invés de vírgulas
+% Observe a falta de aspas na forma de comando: entradas são sempre passadas
+% como texto literal - não pode passar valores de variáveis.
+% Além disso, não pode receber saída:
+[V,D] = eig(A);  % Isto não tem um equivalente na forma de comando
+[~,D] = eig(A);  % Se você só deseja D e não V
+
+
+
+% Operadores Lógicos e Relacionais
+1 > 5 % Resposta = 0
+10 >= 10 % Resposta = 1
+3 ~= 4 % Diferente de -> Resposta = 1
+3 == 3 % Igual a -> Resposta = 1
+3 > 1 && 4 > 1 % E -> Resposta = 1
+3 > 1 || 4 > 1 % OU -> Resposta = 1
+~1 % NOT -> Resposta = 0
+
+% Operadores Lógicos e Relacionais podem ser aplicados a matrizes
+A > 5
+% Para cada elemento, caso seja verdade, esse elemento será 1 na matriz retornada
+A( A > 5 )
+% Retorna um vetor com os elementos de A para os quais a condição é verdadeira
+
+% Cadeias de caracteres (Strings)
+a = 'MinhaString'
+length(a) % Resposta = 11
+a(2) % Resposta = i
+[a,a] % Resposta = MinhaStringMinhaString
+
+
+% Vetores de células
+a = {'um', 'dois', 'três'}
+a(1) % Resposta = 'um' - retorna uma célula
+char(a(1)) % Resposta = um - retorna uma string
+
+% Estruturas
+A.b = {'um','dois'};
+A.c = [1 2];
+A.d.e = false;
+
+% Vetores
+x = [4 32 53 7 1]
+x(2) % Resposta = 32, índices no Matlab começam por 1, não 0
+x(2:3) % Resposta = 32 53
+x(2:end) % Resposta = 32 53 7 1
+
+x = [4; 32; 53; 7; 1] % Vetor coluna
+
+x = [1:10] % x = 1 2 3 4 5 6 7 8 9 10
+
+% Matrizes
+A = [1 2 3; 4 5 6; 7 8 9]
+% Linhas são separadas por um ponto e vírgula;
+% Elementos são separados com espaço ou vírgula
+% A =
+
+%     1     2     3
+%     4     5     6
+%     7     8     9
+
+A(2,3) % Resposta = 6, A(linha, coluna)
+A(6) % Resposta = 8
+% (implicitamente encadeia as colunas do vetor, e então as indexa)
+
+
+A(2,3) = 42 % Atualiza a linha 2 coluna 3 com o valor 42
+% A =
+
+%     1     2     3
+%     4     5     42
+%     7     8     9
+
+A(2:3,2:3) % Cria uma nova matriz a partir da antiga
+%Resposta =
+
+%     5     42
+%     8     9
+
+A(:,1) % Todas as linhas na coluna 1
+%Resposta =
+
+%     1
+%     4
+%     7
+
+A(1,:) % Todas as colunas na linha 1
+%Resposta =
+
+%     1     2     3
+
+[A ; A] % Concatenação de matrizes (verticalmente)
+%Resposta =
+
+%     1     2     3
+%     4     5    42
+%     7     8     9
+%     1     2     3
+%     4     5    42
+%     7     8     9
+
+% Isto é o mesmo de
+vertcat(A,A);
+
+
+[A , A] % Concatenação de matrizes (horizontalmente)
+
+%Resposta =
+
+%     1     2     3     1     2     3
+%     4     5    42     4     5    42
+%     7     8     9     7     8     9
+
+% Isto é o mesmo de
+horzcat(A,A);
+
+
+A(:, [3 1 2]) % Reorganiza as colunas da matriz original
+%Resposta =
+
+%     3     1     2
+%    42     4     5
+%     9     7     8
+
+size(A) % Resposta = 3 3
+
+A(1, :) =[] % Remove a primeira linha da matriz
+A(:, 1) =[] % Remove a primeira coluna da matriz
+
+transpose(A) % Transposta a matriz, que é o mesmo de:
+A one
+ctranspose(A) % Transposta a matriz
+% (a transposta, seguida pelo conjugado complexo de cada elemento)
+
+
+
+
+% Aritmética Elemento por Elemento vs. Aritmética com Matriz
+% Naturalmente, os operadores aritméticos agem em matrizes inteiras. Quando
+% precedidos por um ponto, eles atuam em cada elemento. Por exemplo:
+A * B % Multiplicação de matrizes
+A .* B % Multiplica cada elemento em A por seu correspondente em B
+
+% Existem vários pares de funções nas quais uma atua sob cada elemento, e a
+% outra (cujo nome termina com m) age na matriz por completo.
+exp(A) % Exponencia cada elemento
+expm(A) % Calcula o exponencial da matriz
+sqrt(A) % Tira a raiz quadrada de cada elemento
+sqrtm(A) %  Procura a matriz cujo quadrado é A
+
+
+% Gráficos
+x = 0:.10:2*pi; % Vetor que começa em 0 e termina em 2*pi com incrementos de 0,1
+y = sin(x);
+plot(x,y)
+xlabel('eixo x')
+ylabel('eixo y')
+title('Gráfico de y = sin(x)')
+axis([0 2*pi -1 1]) % x vai de 0 a 2*pi, y vai de -1 a 1
+
+plot(x,y1,'-',x,y2,'--',x,y3,':') % Para várias funções em um só gráfico
+legend('Descrição linha 1', 'Descrição linha 2') % Curvas com uma legenda
+
+% Método alternativo para traçar várias funções em um só gráfico:
+% Enquanto 'hold' estiver ativo, os comandos serão adicionados ao gráfico
+% existente ao invés de o substituirem.
+plot(x, y)
+hold on
+plot(x, z)
+hold off
+
+loglog(x, y) % Plotar em escala loglog
+semilogx(x, y) % Um gráfico com eixo x logarítmico
+semilogy(x, y) % Um gráfico com eixo y logarítmico
+
+fplot (@(x) x^2, [2,5]) % Plotar a função x^2 para x=2 até x=5
+
+grid on % Exibe as linhas de grade; Oculta com 'grid off'
+axis square % Torna quadrada a região dos eixos atuais
+axis equal % Taxa de proporção onde as unidades serão as mesmas em todas direções
+
+scatter(x, y); % Gráfico de dispersão ou bolha
+hist(x); % Histograma
+
+z = sin(x);
+plot3(x,y,z); % Plotar em espaço em 3D
+
+pcolor(A) % Mapa de calor da matriz: traça uma grade de retângulos, coloridos pelo valor
+contour(A) % Plotar de contorno da matriz
+mesh(A) % Plotar malha 3D
+
+h = figure	% Cria uma nova figura objeto, com identificador h
+figure(h) % Cria uma nova janela de figura com h
+close(h) % Fecha a figura h
+close all % Fecha todas as janelas de figuras abertas
+close % Fecha a janela de figura atual
+
+shg % Traz uma janela gráfica existente para frente, ou cria uma nova se necessário
+clf clear % Limpa a janela de figura atual e redefine a maioria das propriedades da figura
+
+% Propriedades podem ser definidas e alteradas através de um identificador.
+% Você pode salvar um identificador para uma figura ao criá-la.
+% A função gcf retorna o identificador da figura atual
+h = plot(x, y); % Você pode salvar um identificador para a figura ao criá-la
+set(h, 'Color', 'r')
+% 'y' amarelo; 'm' magenta, 'c' ciano, 'r' vermelho, 'g' verde, 'b' azul, 'w' branco, 'k' preto
+set(h, 'LineStyle', '--')
+ % '--' linha sólida, '---' tracejada, ':' pontilhada, '-.' traço-ponto, 'none' sem linha
+get(h, 'LineStyle')
+
+
+% A função gca retorna o identificador para os eixos da figura atual
+set(gca, 'XDir', 'reverse'); % Inverte a direção do eixo x
+
+% Para criar uma figura que contém vários gráficos use subplot, o qual divide
+% a janela de gráficos em m linhas e n colunas.
+subplot(2,3,1); % Seleciona a primeira posição em uma grade de 2-por-3
+plot(x1); title('Primeiro Plot') % Plota algo nesta posição
+subplot(2,3,2); % Seleciona a segunda posição na grade
+plot(x2); title('Segundo Plot') % Plota algo ali
+
+
+% Para usar funções ou scripts, eles devem estar no caminho ou na pasta atual
+path % Exibe o caminho atual
+addpath /caminho/para/pasta % Adiciona o diretório ao caminho
+rmpath /caminho/para/pasta % Remove o diretório do caminho
+cd /caminho/para/mudar % Muda o diretório
+
+
+% Variáveis podem ser salvas em arquivos *.mat
+save('meuArquivo.mat') % Salva as variáveis do seu Workspace
+load('meuArquivo.mat') % Carrega as variáveis em seu Workspace
+
+% Arquivos M (M-files)
+% Um arquivo de script é um arquivo externo contendo uma sequência de instruções.
+% Eles evitam que você digite os mesmos códigos repetidamente na janela de comandos.
+% Possuem a extensão *.m
+
+% Arquivos M de Funções (M-file Functions)
+% Assim como scripts e têm a mesma extensão *.m
+% Mas podem aceitar argumentos de entrada e retornar uma saída.
+% Além disso, possuem seu próprio workspace (ex. diferente escopo de variáveis).
+% O nome da função deve coincidir com o nome do arquivo (salve o exemplo como dobra_entrada.m)
+% 'help dobra_entrada.m' retorna os comentários abaixo da linha de início da função
+function output = dobra_entrada(x)
+	%dobra_entrada(x) retorna duas vezes o valor de x
+	output = 2*x;
+end
+dobra_entrada(6) % Resposta = 12
+
+
+% Você também pode ter subfunções e funções aninhadas.
+% Subfunções estão no mesmo arquivo da função primária, e só podem ser chamados
+% por funções dentro do arquivo. Funções aninhadas são definidas dentro de
+% outras funções, e têm acesso a ambos workspaces.
+
+% Se você quer criar uma função sem criar um novo arquivo, você pode usar uma
+% função anônima. Úteis para definir rapidamente uma função para passar a outra
+% função (ex. plotar com fplot, avaliar uma integral indefinida com quad,
+% procurar raízes com fzero, ou procurar mínimo com fminsearch).
+% Exemplo que retorna o quadrado de sua entrada, atribuído ao identificador sqr:
+sqr = @(x) x.^2;
+sqr(10) % Resposta = 100
+doc function_handle % Saiba mais
+
+% Entrada do usuário
+a = input('Digite o valor: ')
+
+% Para a execução do arquivo e passa o controle para o teclado: o usuário pode
+% examinar ou alterar variáveis. Digite 'return' para continuar a execução, ou 'dbquit' para sair
+keyboard
+
+% Leitura de dados (ou xlsread/importdata/imread para arquivos excel/CSV/imagem)
+fopen(nomedoarquivo)
+
+% Saída
+disp(a) % Imprime o valor da variável a
+disp('Olá Mundo') % Imprime a string
+fprintf % Imprime na janela de comandos com mais controle
+
+% Estruturas Condicionais (os parênteses são opicionais, porém uma boa prática)
+if (a > 15)
+	disp('Maior que 15')
+elseif (a == 23)
+	disp('a é 23')
+else
+	disp('Nenhuma condição reconheceu')
+end
+
+% Estruturas de Repetição
+% Nota: fazer o loop sobre elementos de um vetor/matriz é lento!
+% Sempre que possível, use funções que atuem em todo o vetor/matriz de uma só vez.
+for k = 1:5
+	disp(k)
+end
+
+k = 0;
+while (k < 5)
+	k = k + 1;
+end
+
+% Tempo de Execução de Código (Timing Code Execution): 'toc' imprime o tempo
+% passado desde que 'tic' foi chamado.
+tic
+A = rand(1000);
+A*A*A*A*A*A*A;
+toc
+
+% Conectando a uma base de dados MySQL
+dbname = 'nome_base_de_dados';
+username = 'root';
+password = 'root';
+driver = 'com.mysql.jdbc.Driver';
+dburl = ['jdbc:mysql://localhost:8889/' dbname];
+%Abaixo, o xx depende da versão, download disponível em http://dev.mysql.com/downloads/connector/j/
+javaclasspath('mysql-connector-java-5.1.xx-bin.jar');
+conn = database(dbname, username, password, driver, dburl);
+sql = ['SELECT * FROM nome_tabela WHERE id = 22'] % Exemplo de uma consulta SQL
+a = fetch(conn, sql) %a will contain your data
+
+
+% Funções Matemáticas Comuns
+sin(x)
+cos(x)
+tan(x)
+asin(x)
+acos(x)
+atan(x)
+exp(x)
+sqrt(x)
+log(x)
+log10(x)
+abs(x)
+min(x)
+max(x)
+ceil(x)
+floor(x)
+round(x)
+rem(x)
+rand % Números pseudo-aleatórios uniformemente distribuídos
+randi % Inteiros pseudo-aleatórios uniformemente distribuídos
+randn % Números pseudo-aleatórios normalmente distribuídos
+
+% Constantes Comuns
+pi
+NaN
+inf
+
+% Resolvendo equações matriciais (se não houver solução, retorna uma solução de mínimos quadrados)
+% Os operadores \ e / são equivalentes às funções mldivide e mrdivide
+x=A\b % Resolve Ax=b. Mais rápido e numericamente mais preciso do que inv(A)*b.
+x=b/A % Resolve xA=b
+
+inv(A) % Calcula a matriz inversa
+pinv(A) % Calcula a pseudo-inversa
+
+% Funções Matriciais Comuns
+zeros(m,n) % Matriz de zeros m x n
+ones(m,n) % Matriz de 1's m x n
+diag(A) % Extrai os elementos diagonais da matriz A
+diag(x) % Constrói uma matriz com os elementos diagonais listados em x, e zero nas outras posições
+eye(m,n) % Matriz identidade
+linspace(x1, x2, n) % Retorna n pontos igualmente espaçados, com min x1 e max x2
+inv(A) % Inverso da matriz A
+det(A) % Determinante da matriz A
+eig(A) % Valores e vetores próprios de A
+trace(A) % Traço da matriz - equivalente a sum(diag(A))
+isempty(A) % Testa se a matriz está vazia
+all(A) % Testa se todos os elementos são diferentes de zero ou verdadeiro
+any(A) % Testa se algum elemento é diferente de zero ou verdadeiro
+isequal(A, B) % Testa a igualdade de duas matrizes
+numel(A) % Número de elementos na matriz
+triu(x) % Retorna a parte triangular superior de x
+tril(x) % Retorna a parte triangular inferior de x
+cross(A,B) %  Retorna o produto cruzado das matrizes A e B
+dot(A,B) % Retorna o produto escalar de duas matrizes (devem possuir mesmo tamanho)
+transpose(A) % Retorna a matriz transposta de A
+fliplr(A) % Inverte a matriz da esquerda para a direita
+flipud(A) % Inverte a matriz de cima para baixo
+
+% Fatorações de Matrizes
+% Decomposição LU: PA = LU,L é triangular inferior, U é triangular superior, P é a matriz de permutação
+[L, U, P] = lu(A)
+% Decomposição em Autovalores: AP = PD, colunas de P são autovetores e as diagonais de D são autovalores
+[P, D] = eig(A)
+% SVD: XV = US, U e V são matrizes unitárias, S possui elementos não negativos na diagonal em ordem decrescente
+[U,S,V] = svd(X)
+
+% Funções Vetoriais Comuns
+max     % Maior componente
+min     % Menor componente
+length  % Tamanho do vetor
+sort    % Ordena em orcer ascendente
+sum     % Soma de elementos
+prod    % Produto de elementos
+mode	% Valor modal
+median  % Valor mediano
+mean    % Valor médio
+std     % Desvio padrão
+perms(x) % Lista todas as permutações de elementos de x
+
+
+% Classes
+% Matlab pode suportar programação orientada a objetos.
+% Classes devem ser colocadas em um arquivo de mesmo nome com a extensão *.m
+% Para começar, criamos uma simples classe que armazena posições de GPS
+% Início ClassePosicoesGPS.m
+classdef ClassePosicoesGPS % O nome da classe.
+  properties % As propriedades da classe comportam-se como estruturas
+    latitude 
+    longitude 
+  end
+  methods 
+    % Este método que tem o mesmo nome da classe é o construtor.
+    function obj = ClassePosicoesGPS(lat, lon)
+      obj.latitude = lat;
+      obj.longitude = lon;
+    end
+
+    % Outras funções que usam os objetos de PosicoesGPS
+    function r = multiplicarLatPor(obj, n)
+      r = n*[obj.latitude];
+    end
+
+    % Se quisermos somar dois objetos de PosicoesGPS juntos sem chamar
+    % uma função especial nós podemos sobrepor a aritmética do Matlab, desta maneira:
+    function r = plus(o1,o2)
+      r = ClassePosicoesGPS([o1.latitude] +[o2.latitude], ...
+                        [o1.longitude]+[o2.longitude]);
+    end
+  end
+end
+% End ClassePosicoesGPS.m
+
+% Podemos criar um objeto da classe usando o construtor
+a = ClassePosicoesGPS(45.0, 45.0)
+
+% Propriedades da classe se comportam exatamente como estruturas Matlab
+a.latitude = 70.0
+a.longitude = 25.0
+
+% Métodos podem ser chamados da mesma forma que funções
+ans = multiplicarLatPor(a,3)
+
+% O método também pode ser chamado usando a notação de ponto. Neste caso,
+% o objeto não precisa ser passado para o método.
+ans = a.multiplicarLatPor(a,1/3)
+
+% Funções do Matlab podem ser sobrepostas para lidar com objetos.
+% No método abaixo, nós sobrepomos a forma como o Matlab lida com a soma de
+% dois objetos PosicoesGPS.
+b = ClassePosicoesGPS(15.0, 32.0)
+c = a + b
+
+```
+
+## Mais sobre Matlab
+
+* O site oficial [http://http://www.mathworks.com/products/matlab/](http://www.mathworks.com/products/matlab/)
+* O fórum oficial de respostas: [http://www.mathworks.com/matlabcentral/answers/](http://www.mathworks.com/matlabcentral/answers/)
+
diff --git a/pt-br/matlab.html.markdown b/pt-br/matlab.html.markdown
deleted file mode 100644
index ea320d07..00000000
--- a/pt-br/matlab.html.markdown
+++ /dev/null
@@ -1,539 +0,0 @@
----
-language: Matlab
-contributors:
-    - ["mendozao", "http://github.com/mendozao"]
-    - ["jamesscottbrown", "http://jamesscottbrown.com"]
-    - ["Colton Kohnke", "http://github.com/voltnor"]
-translators:
-    - ["Claudson Martins", "https://github.com/claudsonm"]
-lang: pt-br
-
----
-
-MATLAB significa MATrix LABoratory. É uma poderosa linguagem de computação numérica geralmente utilizada em engenharia e matemática.
-
-Se você tem algum feedback, por favor fique a vontade para me contactar via
-[@the_ozzinator](https://twitter.com/the_ozzinator), ou
-[osvaldo.t.mendoza@gmail.com](mailto:osvaldo.t.mendoza@gmail.com).
-
-```matlab
-% Comentários iniciam com um sinal de porcentagem
-
-%{
-Comentários de múltiplas linhas
-parecem
-com
-algo assim
-%}
-
-% Comandos podem ocupar várinhas linhas, usando '...':
- a = 1 + 2 + ...
- + 4
-
-% Comandos podem ser passados para o sistema operacional
-!ping google.com
-
-who % Exibe todas as variáveis na memória
-whos % Exibe todas as variáveis na memória, com seus tipos
-clear % Apaga todas as suas variáveis da memória
-clear('A') % Apaga uma variável em particular
-openvar('A') % Abre a variável no editor de variável
-
-clc % Apaga o conteúdo escrito na sua janela de comando
-diary % Alterna o conteúdo escrito na janela de comando para um arquivo de texto
-ctrl-c % Aborta a computação atual
-
-edit('minhafuncao.m') % Abre a função/script no editor
-type('minhafuncao.m') % Imprime o código-fonte da função/script na janela de comando
-
-profile on    % Ativa o perfil de código
-profile off 	% Desativa o perfil de código
-profile viewer 	% Visualiza os resultados na janela de Profiler
-
-help comando 	% Exibe a documentação do comando na janela de comando
-doc comando 	% Exibe a documentação do comando na janela de ajuda
-lookfor comando % Procura por comando na primeira linha comentada de todas as funções
-lookfor comando -all % Procura por comando em todas as funções
-
-
-% Formatação de saída
-format short 	% 4 casas decimais em um número flutuante
-format long 	% 15 casas decimais
-format bank 	% 2 dígitos após o ponto decimal - para cálculos financeiros
-fprintf('texto') % Imprime na tela "texto"
-disp('texto') 	% Imprime na tela "texto"
-
-% Variáveis & Expressões
-minhaVariavel = 4  % O painel Workspace mostra a variável recém-criada
-minhaVariavel = 4; % Ponto e vírgula suprime a saída para a janela de comando
-4 + 6  		% Resposta = 10
-8 * minhaVariavel 	% Resposta = 32
-2 ^ 3 		% Resposta = 8
-a = 2; b = 3;
-c = exp(a)*sin(pi/2) % c = 7.3891
-
-% A chamada de funções pode ser feita por uma das duas maneiras:
-% Sintaxe de função padrão:
-load('arquivo.mat', 'y') % Argumentos entre parênteses, separados por vírgula
-% Sintaxe de comando:
-load arquivo.mat y 	% Sem parênteses, e espaços ao invés de vírgulas
-% Observe a falta de aspas na forma de comando: entradas são sempre passadas
-% como texto literal - não pode passar valores de variáveis.
-% Além disso, não pode receber saída:
-[V,D] = eig(A);  % Isto não tem um equivalente na forma de comando
-[~,D] = eig(A);  % Se você só deseja D e não V
-
-
-
-% Operadores Lógicos e Relacionais
-1 > 5 % Resposta = 0
-10 >= 10 % Resposta = 1
-3 ~= 4 % Diferente de -> Resposta = 1
-3 == 3 % Igual a -> Resposta = 1
-3 > 1 && 4 > 1 % E -> Resposta = 1
-3 > 1 || 4 > 1 % OU -> Resposta = 1
-~1 % NOT -> Resposta = 0
-
-% Operadores Lógicos e Relacionais podem ser aplicados a matrizes
-A > 5
-% Para cada elemento, caso seja verdade, esse elemento será 1 na matriz retornada
-A( A > 5 )
-% Retorna um vetor com os elementos de A para os quais a condição é verdadeira
-
-% Cadeias de caracteres (Strings)
-a = 'MinhaString'
-length(a) % Resposta = 11
-a(2) % Resposta = i
-[a,a] % Resposta = MinhaStringMinhaString
-
-
-% Vetores de células
-a = {'um', 'dois', 'três'}
-a(1) % Resposta = 'um' - retorna uma célula
-char(a(1)) % Resposta = um - retorna uma string
-
-% Estruturas
-A.b = {'um','dois'};
-A.c = [1 2];
-A.d.e = false;
-
-% Vetores
-x = [4 32 53 7 1]
-x(2) % Resposta = 32, índices no Matlab começam por 1, não 0
-x(2:3) % Resposta = 32 53
-x(2:end) % Resposta = 32 53 7 1
-
-x = [4; 32; 53; 7; 1] % Vetor coluna
-
-x = [1:10] % x = 1 2 3 4 5 6 7 8 9 10
-
-% Matrizes
-A = [1 2 3; 4 5 6; 7 8 9]
-% Linhas são separadas por um ponto e vírgula;
-% Elementos são separados com espaço ou vírgula
-% A =
-
-%     1     2     3
-%     4     5     6
-%     7     8     9
-
-A(2,3) % Resposta = 6, A(linha, coluna)
-A(6) % Resposta = 8
-% (implicitamente encadeia as colunas do vetor, e então as indexa)
-
-
-A(2,3) = 42 % Atualiza a linha 2 coluna 3 com o valor 42
-% A =
-
-%     1     2     3
-%     4     5     42
-%     7     8     9
-
-A(2:3,2:3) % Cria uma nova matriz a partir da antiga
-%Resposta =
-
-%     5     42
-%     8     9
-
-A(:,1) % Todas as linhas na coluna 1
-%Resposta =
-
-%     1
-%     4
-%     7
-
-A(1,:) % Todas as colunas na linha 1
-%Resposta =
-
-%     1     2     3
-
-[A ; A] % Concatenação de matrizes (verticalmente)
-%Resposta =
-
-%     1     2     3
-%     4     5    42
-%     7     8     9
-%     1     2     3
-%     4     5    42
-%     7     8     9
-
-% Isto é o mesmo de
-vertcat(A,A);
-
-
-[A , A] % Concatenação de matrizes (horizontalmente)
-
-%Resposta =
-
-%     1     2     3     1     2     3
-%     4     5    42     4     5    42
-%     7     8     9     7     8     9
-
-% Isto é o mesmo de
-horzcat(A,A);
-
-
-A(:, [3 1 2]) % Reorganiza as colunas da matriz original
-%Resposta =
-
-%     3     1     2
-%    42     4     5
-%     9     7     8
-
-size(A) % Resposta = 3 3
-
-A(1, :) =[] % Remove a primeira linha da matriz
-A(:, 1) =[] % Remove a primeira coluna da matriz
-
-transpose(A) % Transposta a matriz, que é o mesmo de:
-A one
-ctranspose(A) % Transposta a matriz
-% (a transposta, seguida pelo conjugado complexo de cada elemento)
-
-
-
-
-% Aritmética Elemento por Elemento vs. Aritmética com Matriz
-% Naturalmente, os operadores aritméticos agem em matrizes inteiras. Quando
-% precedidos por um ponto, eles atuam em cada elemento. Por exemplo:
-A * B % Multiplicação de matrizes
-A .* B % Multiplica cada elemento em A por seu correspondente em B
-
-% Existem vários pares de funções nas quais uma atua sob cada elemento, e a
-% outra (cujo nome termina com m) age na matriz por completo.
-exp(A) % Exponencia cada elemento
-expm(A) % Calcula o exponencial da matriz
-sqrt(A) % Tira a raiz quadrada de cada elemento
-sqrtm(A) %  Procura a matriz cujo quadrado é A
-
-
-% Gráficos
-x = 0:.10:2*pi; % Vetor que começa em 0 e termina em 2*pi com incrementos de 0,1
-y = sin(x);
-plot(x,y)
-xlabel('eixo x')
-ylabel('eixo y')
-title('Gráfico de y = sin(x)')
-axis([0 2*pi -1 1]) % x vai de 0 a 2*pi, y vai de -1 a 1
-
-plot(x,y1,'-',x,y2,'--',x,y3,':') % Para várias funções em um só gráfico
-legend('Descrição linha 1', 'Descrição linha 2') % Curvas com uma legenda
-
-% Método alternativo para traçar várias funções em um só gráfico:
-% Enquanto 'hold' estiver ativo, os comandos serão adicionados ao gráfico
-% existente ao invés de o substituirem.
-plot(x, y)
-hold on
-plot(x, z)
-hold off
-
-loglog(x, y) % Plotar em escala loglog
-semilogx(x, y) % Um gráfico com eixo x logarítmico
-semilogy(x, y) % Um gráfico com eixo y logarítmico
-
-fplot (@(x) x^2, [2,5]) % Plotar a função x^2 para x=2 até x=5
-
-grid on % Exibe as linhas de grade; Oculta com 'grid off'
-axis square % Torna quadrada a região dos eixos atuais
-axis equal % Taxa de proporção onde as unidades serão as mesmas em todas direções
-
-scatter(x, y); % Gráfico de dispersão ou bolha
-hist(x); % Histograma
-
-z = sin(x);
-plot3(x,y,z); % Plotar em espaço em 3D
-
-pcolor(A) % Mapa de calor da matriz: traça uma grade de retângulos, coloridos pelo valor
-contour(A) % Plotar de contorno da matriz
-mesh(A) % Plotar malha 3D
-
-h = figure	% Cria uma nova figura objeto, com identificador h
-figure(h) % Cria uma nova janela de figura com h
-close(h) % Fecha a figura h
-close all % Fecha todas as janelas de figuras abertas
-close % Fecha a janela de figura atual
-
-shg % Traz uma janela gráfica existente para frente, ou cria uma nova se necessário
-clf clear % Limpa a janela de figura atual e redefine a maioria das propriedades da figura
-
-% Propriedades podem ser definidas e alteradas através de um identificador.
-% Você pode salvar um identificador para uma figura ao criá-la.
-% A função gcf retorna o identificador da figura atual
-h = plot(x, y); % Você pode salvar um identificador para a figura ao criá-la
-set(h, 'Color', 'r')
-% 'y' amarelo; 'm' magenta, 'c' ciano, 'r' vermelho, 'g' verde, 'b' azul, 'w' branco, 'k' preto
-set(h, 'LineStyle', '--')
- % '--' linha sólida, '---' tracejada, ':' pontilhada, '-.' traço-ponto, 'none' sem linha
-get(h, 'LineStyle')
-
-
-% A função gca retorna o identificador para os eixos da figura atual
-set(gca, 'XDir', 'reverse'); % Inverte a direção do eixo x
-
-% Para criar uma figura que contém vários gráficos use subplot, o qual divide
-% a janela de gráficos em m linhas e n colunas.
-subplot(2,3,1); % Seleciona a primeira posição em uma grade de 2-por-3
-plot(x1); title('Primeiro Plot') % Plota algo nesta posição
-subplot(2,3,2); % Seleciona a segunda posição na grade
-plot(x2); title('Segundo Plot') % Plota algo ali
-
-
-% Para usar funções ou scripts, eles devem estar no caminho ou na pasta atual
-path % Exibe o caminho atual
-addpath /caminho/para/pasta % Adiciona o diretório ao caminho
-rmpath /caminho/para/pasta % Remove o diretório do caminho
-cd /caminho/para/mudar % Muda o diretório
-
-
-% Variáveis podem ser salvas em arquivos *.mat
-save('meuArquivo.mat') % Salva as variáveis do seu Workspace
-load('meuArquivo.mat') % Carrega as variáveis em seu Workspace
-
-% Arquivos M (M-files)
-% Um arquivo de script é um arquivo externo contendo uma sequência de instruções.
-% Eles evitam que você digite os mesmos códigos repetidamente na janela de comandos.
-% Possuem a extensão *.m
-
-% Arquivos M de Funções (M-file Functions)
-% Assim como scripts e têm a mesma extensão *.m
-% Mas podem aceitar argumentos de entrada e retornar uma saída.
-% Além disso, possuem seu próprio workspace (ex. diferente escopo de variáveis).
-% O nome da função deve coincidir com o nome do arquivo (salve o exemplo como dobra_entrada.m)
-% 'help dobra_entrada.m' retorna os comentários abaixo da linha de início da função
-function output = dobra_entrada(x)
-	%dobra_entrada(x) retorna duas vezes o valor de x
-	output = 2*x;
-end
-dobra_entrada(6) % Resposta = 12
-
-
-% Você também pode ter subfunções e funções aninhadas.
-% Subfunções estão no mesmo arquivo da função primária, e só podem ser chamados
-% por funções dentro do arquivo. Funções aninhadas são definidas dentro de
-% outras funções, e têm acesso a ambos workspaces.
-
-% Se você quer criar uma função sem criar um novo arquivo, você pode usar uma
-% função anônima. Úteis para definir rapidamente uma função para passar a outra
-% função (ex. plotar com fplot, avaliar uma integral indefinida com quad,
-% procurar raízes com fzero, ou procurar mínimo com fminsearch).
-% Exemplo que retorna o quadrado de sua entrada, atribuído ao identificador sqr:
-sqr = @(x) x.^2;
-sqr(10) % Resposta = 100
-doc function_handle % Saiba mais
-
-% Entrada do usuário
-a = input('Digite o valor: ')
-
-% Para a execução do arquivo e passa o controle para o teclado: o usuário pode
-% examinar ou alterar variáveis. Digite 'return' para continuar a execução, ou 'dbquit' para sair
-keyboard
-
-% Leitura de dados (ou xlsread/importdata/imread para arquivos excel/CSV/imagem)
-fopen(nomedoarquivo)
-
-% Saída
-disp(a) % Imprime o valor da variável a
-disp('Olá Mundo') % Imprime a string
-fprintf % Imprime na janela de comandos com mais controle
-
-% Estruturas Condicionais (os parênteses são opicionais, porém uma boa prática)
-if (a > 15)
-	disp('Maior que 15')
-elseif (a == 23)
-	disp('a é 23')
-else
-	disp('Nenhuma condição reconheceu')
-end
-
-% Estruturas de Repetição
-% Nota: fazer o loop sobre elementos de um vetor/matriz é lento!
-% Sempre que possível, use funções que atuem em todo o vetor/matriz de uma só vez.
-for k = 1:5
-	disp(k)
-end
-
-k = 0;
-while (k < 5)
-	k = k + 1;
-end
-
-% Tempo de Execução de Código (Timing Code Execution): 'toc' imprime o tempo
-% passado desde que 'tic' foi chamado.
-tic
-A = rand(1000);
-A*A*A*A*A*A*A;
-toc
-
-% Conectando a uma base de dados MySQL
-dbname = 'nome_base_de_dados';
-username = 'root';
-password = 'root';
-driver = 'com.mysql.jdbc.Driver';
-dburl = ['jdbc:mysql://localhost:8889/' dbname];
-%Abaixo, o xx depende da versão, download disponível em http://dev.mysql.com/downloads/connector/j/
-javaclasspath('mysql-connector-java-5.1.xx-bin.jar');
-conn = database(dbname, username, password, driver, dburl);
-sql = ['SELECT * FROM nome_tabela WHERE id = 22'] % Exemplo de uma consulta SQL
-a = fetch(conn, sql) %a will contain your data
-
-
-% Funções Matemáticas Comuns
-sin(x)
-cos(x)
-tan(x)
-asin(x)
-acos(x)
-atan(x)
-exp(x)
-sqrt(x)
-log(x)
-log10(x)
-abs(x)
-min(x)
-max(x)
-ceil(x)
-floor(x)
-round(x)
-rem(x)
-rand % Números pseudo-aleatórios uniformemente distribuídos
-randi % Inteiros pseudo-aleatórios uniformemente distribuídos
-randn % Números pseudo-aleatórios normalmente distribuídos
-
-% Constantes Comuns
-pi
-NaN
-inf
-
-% Resolvendo equações matriciais (se não houver solução, retorna uma solução de mínimos quadrados)
-% Os operadores \ e / são equivalentes às funções mldivide e mrdivide
-x=A\b % Resolve Ax=b. Mais rápido e numericamente mais preciso do que inv(A)*b.
-x=b/A % Resolve xA=b
-
-inv(A) % Calcula a matriz inversa
-pinv(A) % Calcula a pseudo-inversa
-
-% Funções Matriciais Comuns
-zeros(m,n) % Matriz de zeros m x n
-ones(m,n) % Matriz de 1's m x n
-diag(A) % Extrai os elementos diagonais da matriz A
-diag(x) % Constrói uma matriz com os elementos diagonais listados em x, e zero nas outras posições
-eye(m,n) % Matriz identidade
-linspace(x1, x2, n) % Retorna n pontos igualmente espaçados, com min x1 e max x2
-inv(A) % Inverso da matriz A
-det(A) % Determinante da matriz A
-eig(A) % Valores e vetores próprios de A
-trace(A) % Traço da matriz - equivalente a sum(diag(A))
-isempty(A) % Testa se a matriz está vazia
-all(A) % Testa se todos os elementos são diferentes de zero ou verdadeiro
-any(A) % Testa se algum elemento é diferente de zero ou verdadeiro
-isequal(A, B) % Testa a igualdade de duas matrizes
-numel(A) % Número de elementos na matriz
-triu(x) % Retorna a parte triangular superior de x
-tril(x) % Retorna a parte triangular inferior de x
-cross(A,B) %  Retorna o produto cruzado das matrizes A e B
-dot(A,B) % Retorna o produto escalar de duas matrizes (devem possuir mesmo tamanho)
-transpose(A) % Retorna a matriz transposta de A
-fliplr(A) % Inverte a matriz da esquerda para a direita
-flipud(A) % Inverte a matriz de cima para baixo
-
-% Fatorações de Matrizes
-% Decomposição LU: PA = LU,L é triangular inferior, U é triangular superior, P é a matriz de permutação
-[L, U, P] = lu(A)
-% Decomposição em Autovalores: AP = PD, colunas de P são autovetores e as diagonais de D são autovalores
-[P, D] = eig(A)
-% SVD: XV = US, U e V são matrizes unitárias, S possui elementos não negativos na diagonal em ordem decrescente
-[U,S,V] = svd(X)
-
-% Funções Vetoriais Comuns
-max     % Maior componente
-min     % Menor componente
-length  % Tamanho do vetor
-sort    % Ordena em orcer ascendente
-sum     % Soma de elementos
-prod    % Produto de elementos
-mode	% Valor modal
-median  % Valor mediano
-mean    % Valor médio
-std     % Desvio padrão
-perms(x) % Lista todas as permutações de elementos de x
-
-
-% Classes
-% Matlab pode suportar programação orientada a objetos.
-% Classes devem ser colocadas em um arquivo de mesmo nome com a extensão *.m
-% Para começar, criamos uma simples classe que armazena posições de GPS
-% Início ClassePosicoesGPS.m
-classdef ClassePosicoesGPS % O nome da classe.
-  properties % As propriedades da classe comportam-se como estruturas
-    latitude 
-    longitude 
-  end
-  methods 
-    % Este método que tem o mesmo nome da classe é o construtor.
-    function obj = ClassePosicoesGPS(lat, lon)
-      obj.latitude = lat;
-      obj.longitude = lon;
-    end
-
-    % Outras funções que usam os objetos de PosicoesGPS
-    function r = multiplicarLatPor(obj, n)
-      r = n*[obj.latitude];
-    end
-
-    % Se quisermos somar dois objetos de PosicoesGPS juntos sem chamar
-    % uma função especial nós podemos sobrepor a aritmética do Matlab, desta maneira:
-    function r = plus(o1,o2)
-      r = ClassePosicoesGPS([o1.latitude] +[o2.latitude], ...
-                        [o1.longitude]+[o2.longitude]);
-    end
-  end
-end
-% End ClassePosicoesGPS.m
-
-% Podemos criar um objeto da classe usando o construtor
-a = ClassePosicoesGPS(45.0, 45.0)
-
-% Propriedades da classe se comportam exatamente como estruturas Matlab
-a.latitude = 70.0
-a.longitude = 25.0
-
-% Métodos podem ser chamados da mesma forma que funções
-ans = multiplicarLatPor(a,3)
-
-% O método também pode ser chamado usando a notação de ponto. Neste caso,
-% o objeto não precisa ser passado para o método.
-ans = a.multiplicarLatPor(a,1/3)
-
-% Funções do Matlab podem ser sobrepostas para lidar com objetos.
-% No método abaixo, nós sobrepomos a forma como o Matlab lida com a soma de
-% dois objetos PosicoesGPS.
-b = ClassePosicoesGPS(15.0, 32.0)
-c = a + b
-
-```
-
-## Mais sobre Matlab
-
-* O site oficial [http://http://www.mathworks.com/products/matlab/](http://www.mathworks.com/products/matlab/)
-* O fórum oficial de respostas: [http://www.mathworks.com/matlabcentral/answers/](http://www.mathworks.com/matlabcentral/answers/)
-
-- 
cgit v1.2.3


From 05f7cd1a2420d5659ef89d1c5ab185600c6c153a Mon Sep 17 00:00:00 2001
From: Claudson Martins <claudson@outlook.com>
Date: Sun, 18 Oct 2015 16:37:24 -0300
Subject: Adding filename markdown

---
 pt-br/matlab-pt.html.markdown | 1 +
 1 file changed, 1 insertion(+)

(limited to 'pt-br')

diff --git a/pt-br/matlab-pt.html.markdown b/pt-br/matlab-pt.html.markdown
index ea320d07..eb660d4c 100644
--- a/pt-br/matlab-pt.html.markdown
+++ b/pt-br/matlab-pt.html.markdown
@@ -7,6 +7,7 @@ contributors:
 translators:
     - ["Claudson Martins", "https://github.com/claudsonm"]
 lang: pt-br
+filename: learnmatlab-pt.mat
 
 ---
 
-- 
cgit v1.2.3


From 401093269d1a5b0db14c54f2e355ff3461b43325 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?C=C3=A1ssio=20B=C3=B6ck?= <cassio.bock@gmail.com>
Date: Tue, 20 Oct 2015 23:53:25 -0200
Subject: Pogoscript to pt-br

Partial translation to pt-br
---
 pt-br/pogo.html.markdown | 202 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 202 insertions(+)
 create mode 100644 pt-br/pogo.html.markdown

(limited to 'pt-br')

diff --git a/pt-br/pogo.html.markdown b/pt-br/pogo.html.markdown
new file mode 100644
index 00000000..80972c98
--- /dev/null
+++ b/pt-br/pogo.html.markdown
@@ -0,0 +1,202 @@
+---
+language: pogoscript
+contributors:
+    - ["Tim Macfarlane", "http://github.com/refractalize"]
+    - ["Cássio Böck", "https://github.com/cassiobsilva"]
+filename: learnPogo.pogo
+---
+
+Pogoscript é uma linguagem de programação que possui tipos primitivos concorrents
+e que compila para linguagem Javascript padrão.
+
+``` javascript
+// definindo uma variável
+water temperature = 24
+
+// reatribuindo o valor de uma variável após a sua definição
+water temperature := 26
+
+// funções permitem que seus parâmetros sejam colocados em qualquer lugar
+temperature at (a) altitude = 32 - a / 100
+
+// funções longas são apenas indentadas
+temperature at (a) altitude :=
+    if (a < 0)
+        water temperature
+    else
+        32 - a / 100
+
+// chamada de uma função
+current temperature = temperature at 3200 altitude
+
+// essa função cria um novo objeto com métodos
+position (x, y) = {
+    x = x
+    y = y
+
+    distance from position (p) =
+        dx = self.x - p.x
+        dy = self.y - p.y
+        Math.sqrt (dx * dx + dy * dy)
+}
+
+// `self` é similiar ao `this` no Javascript, com exceção de que `self` não
+// é redefinido em cada nova função
+
+// chamada de métodos
+position (7, 2).distance from position (position (5, 1))
+
+// assim como no Javascript, objetos também são hashes
+position.'x' == position.x == position.('x')
+
+// arrays
+positions = [
+    position (1, 1)
+    position (1, 2)
+    position (1, 3)
+]
+
+// indexando um array
+positions.0.y
+
+n = 2
+positions.(n).y
+
+// strings
+poem = 'Tail turned to red sunset on a juniper crown a lone magpie cawks.
+        Mad at Oryoki in the shrine-room -- Thistles blossomed late afternoon.
+        Put on my shirt and took it off in the sun walking the path to lunch.
+        A dandelion seed floats above the marsh grass with the mosquitos.
+        At 4 A.M. the two middleaged men sleeping together holding hands.
+        In the half-light of dawn a few birds warble under the Pleiades.
+        Sky reddens behind fir trees, larks twitter, sparrows cheep cheep cheep
+        cheep cheep.'
+
+// texto de Allen Ginsburg
+
+// interpolação
+outlook = 'amazing!'
+console.log "the weather tomorrow is going to be #(outlook)"
+
+// expressões regulares
+r/(\d+)m/i
+r/(\d+) degrees/mg
+
+// operadores
+true @and true
+false @or true
+@not false
+2 < 4
+2 >= 2
+2 > 1
+
+// todos do Javascript também são suportados
+
+// definindo seu próprio operador
+(p1) plus (p2) =
+    position (p1.x + p2.x, p1.y + p2.y)
+
+// `plus` pode ser usado com um operador
+position (1, 1) @plus position (0, 2)
+// ou como uma função
+(position (1, 1)) plus (position (0, 2))
+
+// retorno explícito
+(x) times (y) = return (x * y)
+
+// new
+now = @new Date ()
+
+// funções podem receber argumentos opcionais
+spark (position, color: 'black', velocity: {x = 0, y = 0}) = {
+    color = color
+    position = position
+    velocity = velocity
+}
+
+red = spark (position 1 1, color: 'red')
+fast black = spark (position 1 1, velocity: {x = 10, y = 0})
+
+// functions can unsplat arguments too
+log (messages, ...) =
+    console.log (messages, ...)
+
+// blocks are functions passed to other functions.
+// This block takes two parameters, `spark` and `c`,
+// the body of the block is the indented code after the
+// function call
+
+render each @(spark) into canvas context @(c)
+    ctx.begin path ()
+    ctx.stroke style = spark.color
+    ctx.arc (
+        spark.position.x + canvas.width / 2
+        spark.position.y
+        3
+        0
+        Math.PI * 2
+    )
+    ctx.stroke ()
+
+// asynchronous calls
+
+// JavaScript both in the browser and on the server (with Node.js)
+// makes heavy use of asynchronous IO with callbacks. Async IO is
+// amazing for performance and making concurrency simple but it
+// quickly gets complicated.
+// Pogoscript has a few things to make async IO much much easier
+
+// Node.js includes the `fs` module for accessing the file system.
+// Let's list the contents of a directory
+
+fs = require 'fs'
+directory listing = fs.readdir! '.'
+
+// `fs.readdir()` is an asynchronous function, so we can call it
+// using the `!` operator. The `!` operator allows you to call
+// async functions with the same syntax and largely the same
+// semantics as normal synchronous functions. Pogoscript rewrites
+// it so that all subsequent code is placed in the callback function
+// to `fs.readdir()`.
+
+// to catch asynchronous errors while calling asynchronous functions
+
+try
+    another directory listing = fs.readdir! 'a-missing-dir'
+catch (ex)
+    console.log (ex)
+
+// in fact, if you don't use `try catch`, it will raise the error up the
+// stack to the outer-most `try catch` or to the event loop, as you'd expect
+// with non-async exceptions
+
+// all the other control structures work with asynchronous calls too
+// here's `if else`
+config =
+    if (fs.stat! 'config.json'.is file ())
+        JSON.parse (fs.read file! 'config.json' 'utf-8')
+    else
+        {
+            color: 'red'
+        }
+
+// to run two asynchronous calls concurrently, use the `?` operator.
+// The `?` operator returns a *future* which can be executed to
+// wait for and obtain the result, again using the `!` operator
+
+// we don't wait for either of these calls to finish
+a = fs.stat? 'a.txt'
+b = fs.stat? 'b.txt'
+
+// now we wait for the calls to finish and print the results
+console.log "size of a.txt is #(a!.size)"
+console.log "size of b.txt is #(b!.size)"
+
+// futures in Pogoscript are analogous to Promises
+```
+
+That's it.
+
+Download [Node.js](http://nodejs.org/) and `npm install pogo`.
+
+There is plenty of documentation on [http://pogoscript.org/](http://pogoscript.org/), including a [cheat sheet](http://pogoscript.org/cheatsheet.html), a [guide](http://pogoscript.org/guide/), and how [Pogoscript translates to Javascript](http://featurist.github.io/pogo-examples/). Get in touch on the [google group](http://groups.google.com/group/pogoscript) if you have questions!
-- 
cgit v1.2.3


From f0daae643482918fce3c75b012087dc19f883d25 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?C=C3=A1ssio=20B=C3=B6ck?= <cassio.bock@gmail.com>
Date: Wed, 21 Oct 2015 23:30:42 -0200
Subject: translation to pt-br

translation to pt-br completed
---
 pt-br/pogo.html.markdown | 76 ++++++++++++++++++++++++------------------------
 1 file changed, 38 insertions(+), 38 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/pogo.html.markdown b/pt-br/pogo.html.markdown
index 80972c98..5dc81ec0 100644
--- a/pt-br/pogo.html.markdown
+++ b/pt-br/pogo.html.markdown
@@ -3,7 +3,8 @@ language: pogoscript
 contributors:
     - ["Tim Macfarlane", "http://github.com/refractalize"]
     - ["Cássio Böck", "https://github.com/cassiobsilva"]
-filename: learnPogo.pogo
+filename: learnPogo-pt-br.pogo
+lang: pt-br
 ---
 
 Pogoscript é uma linguagem de programação que possui tipos primitivos concorrents
@@ -26,7 +27,7 @@ temperature at (a) altitude :=
     else
         32 - a / 100
 
-// chamada de uma função
+// declarando uma função
 current temperature = temperature at 3200 altitude
 
 // essa função cria um novo objeto com métodos
@@ -43,7 +44,7 @@ position (x, y) = {
 // `self` é similiar ao `this` no Javascript, com exceção de que `self` não
 // é redefinido em cada nova função
 
-// chamada de métodos
+// declaração de métodos
 position (7, 2).distance from position (position (5, 1))
 
 // assim como no Javascript, objetos também são hashes
@@ -117,14 +118,13 @@ spark (position, color: 'black', velocity: {x = 0, y = 0}) = {
 red = spark (position 1 1, color: 'red')
 fast black = spark (position 1 1, velocity: {x = 10, y = 0})
 
-// functions can unsplat arguments too
+// funções também podem ser utilizadas para realizar o "unsplat" de argumentos
 log (messages, ...) =
     console.log (messages, ...)
 
-// blocks are functions passed to other functions.
-// This block takes two parameters, `spark` and `c`,
-// the body of the block is the indented code after the
-// function call
+// blocos são funções passadas para outras funções.
+// Este bloco recebe dois parâmetros, `spark` e `c`,
+// o corpo do bloco é o código indentado após a declaração da função
 
 render each @(spark) into canvas context @(c)
     ctx.begin path ()
@@ -138,40 +138,40 @@ render each @(spark) into canvas context @(c)
     )
     ctx.stroke ()
 
-// asynchronous calls
+// chamadas assíncronas
 
-// JavaScript both in the browser and on the server (with Node.js)
-// makes heavy use of asynchronous IO with callbacks. Async IO is
-// amazing for performance and making concurrency simple but it
-// quickly gets complicated.
-// Pogoscript has a few things to make async IO much much easier
+// O Javascript, tanto no navegador quanto no servidor (através do Node.js)
+// realiza um uso massivo de funções assíncronas de E/S (entrada/saída) com
+// chamadas de retorno. E/S assíncrona é maravilhosa para a performance e
+// torna a concorrência simples, porém pode rapidamente se tornar algo complicado.
+// O Pogoscript possui algumas coisas que tornam o uso de E/S assíncrono mosquitos
+// mais fácil
 
-// Node.js includes the `fs` module for accessing the file system.
-// Let's list the contents of a directory
+// O Node.js inclui o móduolo `fs` para acessar o sistema de arquivos.
+// Vamos listar o conteúdo de um diretório
 
 fs = require 'fs'
 directory listing = fs.readdir! '.'
 
-// `fs.readdir()` is an asynchronous function, so we can call it
-// using the `!` operator. The `!` operator allows you to call
-// async functions with the same syntax and largely the same
-// semantics as normal synchronous functions. Pogoscript rewrites
-// it so that all subsequent code is placed in the callback function
-// to `fs.readdir()`.
+// `fs.readdir()` é uma função assíncrona, então nos a chamamos usando o
+// operador `!`. O operador `!` permite que você chame funções assíncronas
+// com a mesma sintaxe e praticamente a mesma semântica do que as demais
+// funções síncronas. O Pogoscript reescreve a função para que todo código
+// inserido após o operador seja inserido em uma função de callback para o
+// `fs.readdir()`.
 
-// to catch asynchronous errors while calling asynchronous functions
+// para se obter erros ao utilizar funções assíncronas
 
 try
     another directory listing = fs.readdir! 'a-missing-dir'
 catch (ex)
     console.log (ex)
 
-// in fact, if you don't use `try catch`, it will raise the error up the
-// stack to the outer-most `try catch` or to the event loop, as you'd expect
-// with non-async exceptions
+// na verdade, se você não usar o `try catch`, o erro será passado para o
+// `try catch` mais externo do evento, assim como é feito nas exceções síncronas
 
-// all the other control structures work with asynchronous calls too
-// here's `if else`
+// todo o controle de estrutura funciona com chamadas assíncronas também
+// aqui um exemplo de `if else`
 config =
     if (fs.stat! 'config.json'.is file ())
         JSON.parse (fs.read file! 'config.json' 'utf-8')
@@ -180,23 +180,23 @@ config =
             color: 'red'
         }
 
-// to run two asynchronous calls concurrently, use the `?` operator.
-// The `?` operator returns a *future* which can be executed to
-// wait for and obtain the result, again using the `!` operator
+// para executar duas chamadas assíncronas de forma concorrente, use o
+// operador `?`.
+// O operador `?` retorna um *future* que pode ser executado aguardando
+// o resultado, novamente utilizando o operador `o`
 
-// we don't wait for either of these calls to finish
+// nós não esperamos nenhuma dessas chamadas serem concluídas
 a = fs.stat? 'a.txt'
 b = fs.stat? 'b.txt'
 
-// now we wait for the calls to finish and print the results
+// agora nos aguardamos o término das chamadas e escrevemos os resultados
 console.log "size of a.txt is #(a!.size)"
 console.log "size of b.txt is #(b!.size)"
 
-// futures in Pogoscript are analogous to Promises
+// no Pogoscript, futures são semelhantes a Promises
 ```
+E encerramos por aqui.
 
-That's it.
+Baixe o [Node.js](http://nodejs.org/) e execute `npm install pogo`.
 
-Download [Node.js](http://nodejs.org/) and `npm install pogo`.
-
-There is plenty of documentation on [http://pogoscript.org/](http://pogoscript.org/), including a [cheat sheet](http://pogoscript.org/cheatsheet.html), a [guide](http://pogoscript.org/guide/), and how [Pogoscript translates to Javascript](http://featurist.github.io/pogo-examples/). Get in touch on the [google group](http://groups.google.com/group/pogoscript) if you have questions!
+Há bastante documentação em [http://pogoscript.org/](http://pogoscript.org/), incluindo um material para [consulta rápida](http://pogoscript.org/cheatsheet.html), um [guia](http://pogoscript.org/guide/), e como o [Pogoscript é traduzido para o Javascript](http://featurist.github.io/pogo-examples/). Entre em contato através do [grupo do Google](http://groups.google.com/group/pogoscript) se você possui dúvidas!
-- 
cgit v1.2.3


From 4c9f38665d291e4abe2c7d57e633f5aed9eb72ae Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?C=C3=A1ssio=20B=C3=B6ck?= <cassio.bock@gmail.com>
Date: Thu, 22 Oct 2015 00:35:27 -0200
Subject: grammar fixes

Portuguese changes to a better text understanding
---
 pt-br/pogo.html.markdown | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/pogo.html.markdown b/pt-br/pogo.html.markdown
index 5dc81ec0..124b32f7 100644
--- a/pt-br/pogo.html.markdown
+++ b/pt-br/pogo.html.markdown
@@ -41,7 +41,7 @@ position (x, y) = {
         Math.sqrt (dx * dx + dy * dy)
 }
 
-// `self` é similiar ao `this` no Javascript, com exceção de que `self` não
+// `self` é similiar ao `this` do Javascript, com exceção de que `self` não
 // é redefinido em cada nova função
 
 // declaração de métodos
@@ -91,7 +91,7 @@ false @or true
 2 >= 2
 2 > 1
 
-// todos do Javascript também são suportados
+// os operadores padrão do Javascript também são suportados
 
 // definindo seu próprio operador
 (p1) plus (p2) =
@@ -142,9 +142,10 @@ render each @(spark) into canvas context @(c)
 
 // O Javascript, tanto no navegador quanto no servidor (através do Node.js)
 // realiza um uso massivo de funções assíncronas de E/S (entrada/saída) com
-// chamadas de retorno. E/S assíncrona é maravilhosa para a performance e
-// torna a concorrência simples, porém pode rapidamente se tornar algo complicado.
-// O Pogoscript possui algumas coisas que tornam o uso de E/S assíncrono mosquitos
+// chamadas de retorno (callbacks). A E/S assíncrona é ótima para a performance e
+// torna a utilização da concorrência simples, porém pode rapidamente se tornar
+// algo complicado.
+// O Pogoscript possui algumas coisas que tornam o uso de E/S assíncrono muito
 // mais fácil
 
 // O Node.js inclui o móduolo `fs` para acessar o sistema de arquivos.
@@ -155,12 +156,11 @@ directory listing = fs.readdir! '.'
 
 // `fs.readdir()` é uma função assíncrona, então nos a chamamos usando o
 // operador `!`. O operador `!` permite que você chame funções assíncronas
-// com a mesma sintaxe e praticamente a mesma semântica do que as demais
-// funções síncronas. O Pogoscript reescreve a função para que todo código
-// inserido após o operador seja inserido em uma função de callback para o
-// `fs.readdir()`.
+// com a mesma sintaxe e a mesma semântica do que as demais funções síncronas.
+// O Pogoscript reescreve a função para que todo código inserido após o
+//  operador seja inserido em uma função de callback para o `fs.readdir()`.
 
-// para se obter erros ao utilizar funções assíncronas
+// obtendo erros ao utilizar funções assíncronas
 
 try
     another directory listing = fs.readdir! 'a-missing-dir'
@@ -168,9 +168,9 @@ catch (ex)
     console.log (ex)
 
 // na verdade, se você não usar o `try catch`, o erro será passado para o
-// `try catch` mais externo do evento, assim como é feito nas exceções síncronas
+// `try catch` mais externo do evento, assim como é feito em exceções síncronas
 
-// todo o controle de estrutura funciona com chamadas assíncronas também
+// todo o controle de estrutura também funciona com chamadas assíncronas
 // aqui um exemplo de `if else`
 config =
     if (fs.stat! 'config.json'.is file ())
@@ -182,8 +182,8 @@ config =
 
 // para executar duas chamadas assíncronas de forma concorrente, use o
 // operador `?`.
-// O operador `?` retorna um *future* que pode ser executado aguardando
-// o resultado, novamente utilizando o operador `o`
+// O operador `?` retorna um *future*, que pode ser executado para
+// aguardar o resultado, novamente utilizando o operador `!`
 
 // nós não esperamos nenhuma dessas chamadas serem concluídas
 a = fs.stat? 'a.txt'
-- 
cgit v1.2.3


From 9fcfa2c91feb2af119e67c9d1897340e87f03daa Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?C=C3=A1ssio=20B=C3=B6ck?= <cassio.bock@gmail.com>
Date: Thu, 22 Oct 2015 00:37:46 -0200
Subject: File name changed

---
 pt-br/pogo-pt.html.markdown | 202 ++++++++++++++++++++++++++++++++++++++++++++
 pt-br/pogo.html.markdown    | 202 --------------------------------------------
 2 files changed, 202 insertions(+), 202 deletions(-)
 create mode 100644 pt-br/pogo-pt.html.markdown
 delete mode 100644 pt-br/pogo.html.markdown

(limited to 'pt-br')

diff --git a/pt-br/pogo-pt.html.markdown b/pt-br/pogo-pt.html.markdown
new file mode 100644
index 00000000..124b32f7
--- /dev/null
+++ b/pt-br/pogo-pt.html.markdown
@@ -0,0 +1,202 @@
+---
+language: pogoscript
+contributors:
+    - ["Tim Macfarlane", "http://github.com/refractalize"]
+    - ["Cássio Böck", "https://github.com/cassiobsilva"]
+filename: learnPogo-pt-br.pogo
+lang: pt-br
+---
+
+Pogoscript é uma linguagem de programação que possui tipos primitivos concorrents
+e que compila para linguagem Javascript padrão.
+
+``` javascript
+// definindo uma variável
+water temperature = 24
+
+// reatribuindo o valor de uma variável após a sua definição
+water temperature := 26
+
+// funções permitem que seus parâmetros sejam colocados em qualquer lugar
+temperature at (a) altitude = 32 - a / 100
+
+// funções longas são apenas indentadas
+temperature at (a) altitude :=
+    if (a < 0)
+        water temperature
+    else
+        32 - a / 100
+
+// declarando uma função
+current temperature = temperature at 3200 altitude
+
+// essa função cria um novo objeto com métodos
+position (x, y) = {
+    x = x
+    y = y
+
+    distance from position (p) =
+        dx = self.x - p.x
+        dy = self.y - p.y
+        Math.sqrt (dx * dx + dy * dy)
+}
+
+// `self` é similiar ao `this` do Javascript, com exceção de que `self` não
+// é redefinido em cada nova função
+
+// declaração de métodos
+position (7, 2).distance from position (position (5, 1))
+
+// assim como no Javascript, objetos também são hashes
+position.'x' == position.x == position.('x')
+
+// arrays
+positions = [
+    position (1, 1)
+    position (1, 2)
+    position (1, 3)
+]
+
+// indexando um array
+positions.0.y
+
+n = 2
+positions.(n).y
+
+// strings
+poem = 'Tail turned to red sunset on a juniper crown a lone magpie cawks.
+        Mad at Oryoki in the shrine-room -- Thistles blossomed late afternoon.
+        Put on my shirt and took it off in the sun walking the path to lunch.
+        A dandelion seed floats above the marsh grass with the mosquitos.
+        At 4 A.M. the two middleaged men sleeping together holding hands.
+        In the half-light of dawn a few birds warble under the Pleiades.
+        Sky reddens behind fir trees, larks twitter, sparrows cheep cheep cheep
+        cheep cheep.'
+
+// texto de Allen Ginsburg
+
+// interpolação
+outlook = 'amazing!'
+console.log "the weather tomorrow is going to be #(outlook)"
+
+// expressões regulares
+r/(\d+)m/i
+r/(\d+) degrees/mg
+
+// operadores
+true @and true
+false @or true
+@not false
+2 < 4
+2 >= 2
+2 > 1
+
+// os operadores padrão do Javascript também são suportados
+
+// definindo seu próprio operador
+(p1) plus (p2) =
+    position (p1.x + p2.x, p1.y + p2.y)
+
+// `plus` pode ser usado com um operador
+position (1, 1) @plus position (0, 2)
+// ou como uma função
+(position (1, 1)) plus (position (0, 2))
+
+// retorno explícito
+(x) times (y) = return (x * y)
+
+// new
+now = @new Date ()
+
+// funções podem receber argumentos opcionais
+spark (position, color: 'black', velocity: {x = 0, y = 0}) = {
+    color = color
+    position = position
+    velocity = velocity
+}
+
+red = spark (position 1 1, color: 'red')
+fast black = spark (position 1 1, velocity: {x = 10, y = 0})
+
+// funções também podem ser utilizadas para realizar o "unsplat" de argumentos
+log (messages, ...) =
+    console.log (messages, ...)
+
+// blocos são funções passadas para outras funções.
+// Este bloco recebe dois parâmetros, `spark` e `c`,
+// o corpo do bloco é o código indentado após a declaração da função
+
+render each @(spark) into canvas context @(c)
+    ctx.begin path ()
+    ctx.stroke style = spark.color
+    ctx.arc (
+        spark.position.x + canvas.width / 2
+        spark.position.y
+        3
+        0
+        Math.PI * 2
+    )
+    ctx.stroke ()
+
+// chamadas assíncronas
+
+// O Javascript, tanto no navegador quanto no servidor (através do Node.js)
+// realiza um uso massivo de funções assíncronas de E/S (entrada/saída) com
+// chamadas de retorno (callbacks). A E/S assíncrona é ótima para a performance e
+// torna a utilização da concorrência simples, porém pode rapidamente se tornar
+// algo complicado.
+// O Pogoscript possui algumas coisas que tornam o uso de E/S assíncrono muito
+// mais fácil
+
+// O Node.js inclui o móduolo `fs` para acessar o sistema de arquivos.
+// Vamos listar o conteúdo de um diretório
+
+fs = require 'fs'
+directory listing = fs.readdir! '.'
+
+// `fs.readdir()` é uma função assíncrona, então nos a chamamos usando o
+// operador `!`. O operador `!` permite que você chame funções assíncronas
+// com a mesma sintaxe e a mesma semântica do que as demais funções síncronas.
+// O Pogoscript reescreve a função para que todo código inserido após o
+//  operador seja inserido em uma função de callback para o `fs.readdir()`.
+
+// obtendo erros ao utilizar funções assíncronas
+
+try
+    another directory listing = fs.readdir! 'a-missing-dir'
+catch (ex)
+    console.log (ex)
+
+// na verdade, se você não usar o `try catch`, o erro será passado para o
+// `try catch` mais externo do evento, assim como é feito em exceções síncronas
+
+// todo o controle de estrutura também funciona com chamadas assíncronas
+// aqui um exemplo de `if else`
+config =
+    if (fs.stat! 'config.json'.is file ())
+        JSON.parse (fs.read file! 'config.json' 'utf-8')
+    else
+        {
+            color: 'red'
+        }
+
+// para executar duas chamadas assíncronas de forma concorrente, use o
+// operador `?`.
+// O operador `?` retorna um *future*, que pode ser executado para
+// aguardar o resultado, novamente utilizando o operador `!`
+
+// nós não esperamos nenhuma dessas chamadas serem concluídas
+a = fs.stat? 'a.txt'
+b = fs.stat? 'b.txt'
+
+// agora nos aguardamos o término das chamadas e escrevemos os resultados
+console.log "size of a.txt is #(a!.size)"
+console.log "size of b.txt is #(b!.size)"
+
+// no Pogoscript, futures são semelhantes a Promises
+```
+E encerramos por aqui.
+
+Baixe o [Node.js](http://nodejs.org/) e execute `npm install pogo`.
+
+Há bastante documentação em [http://pogoscript.org/](http://pogoscript.org/), incluindo um material para [consulta rápida](http://pogoscript.org/cheatsheet.html), um [guia](http://pogoscript.org/guide/), e como o [Pogoscript é traduzido para o Javascript](http://featurist.github.io/pogo-examples/). Entre em contato através do [grupo do Google](http://groups.google.com/group/pogoscript) se você possui dúvidas!
diff --git a/pt-br/pogo.html.markdown b/pt-br/pogo.html.markdown
deleted file mode 100644
index 124b32f7..00000000
--- a/pt-br/pogo.html.markdown
+++ /dev/null
@@ -1,202 +0,0 @@
----
-language: pogoscript
-contributors:
-    - ["Tim Macfarlane", "http://github.com/refractalize"]
-    - ["Cássio Böck", "https://github.com/cassiobsilva"]
-filename: learnPogo-pt-br.pogo
-lang: pt-br
----
-
-Pogoscript é uma linguagem de programação que possui tipos primitivos concorrents
-e que compila para linguagem Javascript padrão.
-
-``` javascript
-// definindo uma variável
-water temperature = 24
-
-// reatribuindo o valor de uma variável após a sua definição
-water temperature := 26
-
-// funções permitem que seus parâmetros sejam colocados em qualquer lugar
-temperature at (a) altitude = 32 - a / 100
-
-// funções longas são apenas indentadas
-temperature at (a) altitude :=
-    if (a < 0)
-        water temperature
-    else
-        32 - a / 100
-
-// declarando uma função
-current temperature = temperature at 3200 altitude
-
-// essa função cria um novo objeto com métodos
-position (x, y) = {
-    x = x
-    y = y
-
-    distance from position (p) =
-        dx = self.x - p.x
-        dy = self.y - p.y
-        Math.sqrt (dx * dx + dy * dy)
-}
-
-// `self` é similiar ao `this` do Javascript, com exceção de que `self` não
-// é redefinido em cada nova função
-
-// declaração de métodos
-position (7, 2).distance from position (position (5, 1))
-
-// assim como no Javascript, objetos também são hashes
-position.'x' == position.x == position.('x')
-
-// arrays
-positions = [
-    position (1, 1)
-    position (1, 2)
-    position (1, 3)
-]
-
-// indexando um array
-positions.0.y
-
-n = 2
-positions.(n).y
-
-// strings
-poem = 'Tail turned to red sunset on a juniper crown a lone magpie cawks.
-        Mad at Oryoki in the shrine-room -- Thistles blossomed late afternoon.
-        Put on my shirt and took it off in the sun walking the path to lunch.
-        A dandelion seed floats above the marsh grass with the mosquitos.
-        At 4 A.M. the two middleaged men sleeping together holding hands.
-        In the half-light of dawn a few birds warble under the Pleiades.
-        Sky reddens behind fir trees, larks twitter, sparrows cheep cheep cheep
-        cheep cheep.'
-
-// texto de Allen Ginsburg
-
-// interpolação
-outlook = 'amazing!'
-console.log "the weather tomorrow is going to be #(outlook)"
-
-// expressões regulares
-r/(\d+)m/i
-r/(\d+) degrees/mg
-
-// operadores
-true @and true
-false @or true
-@not false
-2 < 4
-2 >= 2
-2 > 1
-
-// os operadores padrão do Javascript também são suportados
-
-// definindo seu próprio operador
-(p1) plus (p2) =
-    position (p1.x + p2.x, p1.y + p2.y)
-
-// `plus` pode ser usado com um operador
-position (1, 1) @plus position (0, 2)
-// ou como uma função
-(position (1, 1)) plus (position (0, 2))
-
-// retorno explícito
-(x) times (y) = return (x * y)
-
-// new
-now = @new Date ()
-
-// funções podem receber argumentos opcionais
-spark (position, color: 'black', velocity: {x = 0, y = 0}) = {
-    color = color
-    position = position
-    velocity = velocity
-}
-
-red = spark (position 1 1, color: 'red')
-fast black = spark (position 1 1, velocity: {x = 10, y = 0})
-
-// funções também podem ser utilizadas para realizar o "unsplat" de argumentos
-log (messages, ...) =
-    console.log (messages, ...)
-
-// blocos são funções passadas para outras funções.
-// Este bloco recebe dois parâmetros, `spark` e `c`,
-// o corpo do bloco é o código indentado após a declaração da função
-
-render each @(spark) into canvas context @(c)
-    ctx.begin path ()
-    ctx.stroke style = spark.color
-    ctx.arc (
-        spark.position.x + canvas.width / 2
-        spark.position.y
-        3
-        0
-        Math.PI * 2
-    )
-    ctx.stroke ()
-
-// chamadas assíncronas
-
-// O Javascript, tanto no navegador quanto no servidor (através do Node.js)
-// realiza um uso massivo de funções assíncronas de E/S (entrada/saída) com
-// chamadas de retorno (callbacks). A E/S assíncrona é ótima para a performance e
-// torna a utilização da concorrência simples, porém pode rapidamente se tornar
-// algo complicado.
-// O Pogoscript possui algumas coisas que tornam o uso de E/S assíncrono muito
-// mais fácil
-
-// O Node.js inclui o móduolo `fs` para acessar o sistema de arquivos.
-// Vamos listar o conteúdo de um diretório
-
-fs = require 'fs'
-directory listing = fs.readdir! '.'
-
-// `fs.readdir()` é uma função assíncrona, então nos a chamamos usando o
-// operador `!`. O operador `!` permite que você chame funções assíncronas
-// com a mesma sintaxe e a mesma semântica do que as demais funções síncronas.
-// O Pogoscript reescreve a função para que todo código inserido após o
-//  operador seja inserido em uma função de callback para o `fs.readdir()`.
-
-// obtendo erros ao utilizar funções assíncronas
-
-try
-    another directory listing = fs.readdir! 'a-missing-dir'
-catch (ex)
-    console.log (ex)
-
-// na verdade, se você não usar o `try catch`, o erro será passado para o
-// `try catch` mais externo do evento, assim como é feito em exceções síncronas
-
-// todo o controle de estrutura também funciona com chamadas assíncronas
-// aqui um exemplo de `if else`
-config =
-    if (fs.stat! 'config.json'.is file ())
-        JSON.parse (fs.read file! 'config.json' 'utf-8')
-    else
-        {
-            color: 'red'
-        }
-
-// para executar duas chamadas assíncronas de forma concorrente, use o
-// operador `?`.
-// O operador `?` retorna um *future*, que pode ser executado para
-// aguardar o resultado, novamente utilizando o operador `!`
-
-// nós não esperamos nenhuma dessas chamadas serem concluídas
-a = fs.stat? 'a.txt'
-b = fs.stat? 'b.txt'
-
-// agora nos aguardamos o término das chamadas e escrevemos os resultados
-console.log "size of a.txt is #(a!.size)"
-console.log "size of b.txt is #(b!.size)"
-
-// no Pogoscript, futures são semelhantes a Promises
-```
-E encerramos por aqui.
-
-Baixe o [Node.js](http://nodejs.org/) e execute `npm install pogo`.
-
-Há bastante documentação em [http://pogoscript.org/](http://pogoscript.org/), incluindo um material para [consulta rápida](http://pogoscript.org/cheatsheet.html), um [guia](http://pogoscript.org/guide/), e como o [Pogoscript é traduzido para o Javascript](http://featurist.github.io/pogo-examples/). Entre em contato através do [grupo do Google](http://groups.google.com/group/pogoscript) se você possui dúvidas!
-- 
cgit v1.2.3


From d9d8de0d229443534272e2a1976fb7f0e69631b6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?C=C3=A1ssio=20B=C3=B6ck?= <cassio.bock@gmail.com>
Date: Sun, 25 Oct 2015 15:44:35 -0200
Subject: Translator section added

Changed my name from contributor section to the translator section
---
 pt-br/pogo-pt.html.markdown | 1 +
 1 file changed, 1 insertion(+)

(limited to 'pt-br')

diff --git a/pt-br/pogo-pt.html.markdown b/pt-br/pogo-pt.html.markdown
index 124b32f7..80dcfcd5 100644
--- a/pt-br/pogo-pt.html.markdown
+++ b/pt-br/pogo-pt.html.markdown
@@ -2,6 +2,7 @@
 language: pogoscript
 contributors:
     - ["Tim Macfarlane", "http://github.com/refractalize"]
+translators:
     - ["Cássio Böck", "https://github.com/cassiobsilva"]
 filename: learnPogo-pt-br.pogo
 lang: pt-br
-- 
cgit v1.2.3


From d35663f1752c0815ee48fb6b66f0b6c6d7deaab9 Mon Sep 17 00:00:00 2001
From: Victor <victor@victor-RV411.(none)>
Date: Thu, 29 Oct 2015 22:09:43 -0200
Subject: fixing selector(color) name that was improperly translated

---
 pt-br/css-pt.html.markdown | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/css-pt.html.markdown b/pt-br/css-pt.html.markdown
index ed6f6c4c..b1fbd961 100644
--- a/pt-br/css-pt.html.markdown
+++ b/pt-br/css-pt.html.markdown
@@ -159,11 +159,11 @@ seletor {
     color: # FF66EE; /* Formato hexadecimal longo */
     color: tomato; /* Uma cor nomeada */
     color: rgb (255, 255, 255); /* Como valores rgb */
-    cor: RGB (10%, 20%, 50%); /* Como porcentagens rgb */
-    cor: rgba (255, 0, 0, 0,3); /* Como valores RGBA (CSS 3) NOTA: 0 <a <1 */
+    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 */
-    cor: HSL (0, 100%, 50%); /* Como porcentagens HSL (CSS 3) */
-    cor: HSLA (0, 100%, 50%, 0,3); /* Como porcentagens HSLA com alfa */
+    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 */
-- 
cgit v1.2.3


From c013b2c95732022c0a4a56152489e6d45e44695d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?C=C3=A1ssio=20B=C3=B6ck?= <cassio.bock@gmail.com>
Date: Thu, 29 Oct 2015 23:17:09 -0200
Subject: English content removed

The pt-br file had english content after translation. That content is
now removed.
---
 pt-br/pogo-pt.html.markdown | 203 --------------------------------------------
 pt-br/sass-pt.html.markdown |  27 +-----
 2 files changed, 1 insertion(+), 229 deletions(-)
 delete mode 100644 pt-br/pogo-pt.html.markdown

(limited to 'pt-br')

diff --git a/pt-br/pogo-pt.html.markdown b/pt-br/pogo-pt.html.markdown
deleted file mode 100644
index 80dcfcd5..00000000
--- a/pt-br/pogo-pt.html.markdown
+++ /dev/null
@@ -1,203 +0,0 @@
----
-language: pogoscript
-contributors:
-    - ["Tim Macfarlane", "http://github.com/refractalize"]
-translators:
-    - ["Cássio Böck", "https://github.com/cassiobsilva"]
-filename: learnPogo-pt-br.pogo
-lang: pt-br
----
-
-Pogoscript é uma linguagem de programação que possui tipos primitivos concorrents
-e que compila para linguagem Javascript padrão.
-
-``` javascript
-// definindo uma variável
-water temperature = 24
-
-// reatribuindo o valor de uma variável após a sua definição
-water temperature := 26
-
-// funções permitem que seus parâmetros sejam colocados em qualquer lugar
-temperature at (a) altitude = 32 - a / 100
-
-// funções longas são apenas indentadas
-temperature at (a) altitude :=
-    if (a < 0)
-        water temperature
-    else
-        32 - a / 100
-
-// declarando uma função
-current temperature = temperature at 3200 altitude
-
-// essa função cria um novo objeto com métodos
-position (x, y) = {
-    x = x
-    y = y
-
-    distance from position (p) =
-        dx = self.x - p.x
-        dy = self.y - p.y
-        Math.sqrt (dx * dx + dy * dy)
-}
-
-// `self` é similiar ao `this` do Javascript, com exceção de que `self` não
-// é redefinido em cada nova função
-
-// declaração de métodos
-position (7, 2).distance from position (position (5, 1))
-
-// assim como no Javascript, objetos também são hashes
-position.'x' == position.x == position.('x')
-
-// arrays
-positions = [
-    position (1, 1)
-    position (1, 2)
-    position (1, 3)
-]
-
-// indexando um array
-positions.0.y
-
-n = 2
-positions.(n).y
-
-// strings
-poem = 'Tail turned to red sunset on a juniper crown a lone magpie cawks.
-        Mad at Oryoki in the shrine-room -- Thistles blossomed late afternoon.
-        Put on my shirt and took it off in the sun walking the path to lunch.
-        A dandelion seed floats above the marsh grass with the mosquitos.
-        At 4 A.M. the two middleaged men sleeping together holding hands.
-        In the half-light of dawn a few birds warble under the Pleiades.
-        Sky reddens behind fir trees, larks twitter, sparrows cheep cheep cheep
-        cheep cheep.'
-
-// texto de Allen Ginsburg
-
-// interpolação
-outlook = 'amazing!'
-console.log "the weather tomorrow is going to be #(outlook)"
-
-// expressões regulares
-r/(\d+)m/i
-r/(\d+) degrees/mg
-
-// operadores
-true @and true
-false @or true
-@not false
-2 < 4
-2 >= 2
-2 > 1
-
-// os operadores padrão do Javascript também são suportados
-
-// definindo seu próprio operador
-(p1) plus (p2) =
-    position (p1.x + p2.x, p1.y + p2.y)
-
-// `plus` pode ser usado com um operador
-position (1, 1) @plus position (0, 2)
-// ou como uma função
-(position (1, 1)) plus (position (0, 2))
-
-// retorno explícito
-(x) times (y) = return (x * y)
-
-// new
-now = @new Date ()
-
-// funções podem receber argumentos opcionais
-spark (position, color: 'black', velocity: {x = 0, y = 0}) = {
-    color = color
-    position = position
-    velocity = velocity
-}
-
-red = spark (position 1 1, color: 'red')
-fast black = spark (position 1 1, velocity: {x = 10, y = 0})
-
-// funções também podem ser utilizadas para realizar o "unsplat" de argumentos
-log (messages, ...) =
-    console.log (messages, ...)
-
-// blocos são funções passadas para outras funções.
-// Este bloco recebe dois parâmetros, `spark` e `c`,
-// o corpo do bloco é o código indentado após a declaração da função
-
-render each @(spark) into canvas context @(c)
-    ctx.begin path ()
-    ctx.stroke style = spark.color
-    ctx.arc (
-        spark.position.x + canvas.width / 2
-        spark.position.y
-        3
-        0
-        Math.PI * 2
-    )
-    ctx.stroke ()
-
-// chamadas assíncronas
-
-// O Javascript, tanto no navegador quanto no servidor (através do Node.js)
-// realiza um uso massivo de funções assíncronas de E/S (entrada/saída) com
-// chamadas de retorno (callbacks). A E/S assíncrona é ótima para a performance e
-// torna a utilização da concorrência simples, porém pode rapidamente se tornar
-// algo complicado.
-// O Pogoscript possui algumas coisas que tornam o uso de E/S assíncrono muito
-// mais fácil
-
-// O Node.js inclui o móduolo `fs` para acessar o sistema de arquivos.
-// Vamos listar o conteúdo de um diretório
-
-fs = require 'fs'
-directory listing = fs.readdir! '.'
-
-// `fs.readdir()` é uma função assíncrona, então nos a chamamos usando o
-// operador `!`. O operador `!` permite que você chame funções assíncronas
-// com a mesma sintaxe e a mesma semântica do que as demais funções síncronas.
-// O Pogoscript reescreve a função para que todo código inserido após o
-//  operador seja inserido em uma função de callback para o `fs.readdir()`.
-
-// obtendo erros ao utilizar funções assíncronas
-
-try
-    another directory listing = fs.readdir! 'a-missing-dir'
-catch (ex)
-    console.log (ex)
-
-// na verdade, se você não usar o `try catch`, o erro será passado para o
-// `try catch` mais externo do evento, assim como é feito em exceções síncronas
-
-// todo o controle de estrutura também funciona com chamadas assíncronas
-// aqui um exemplo de `if else`
-config =
-    if (fs.stat! 'config.json'.is file ())
-        JSON.parse (fs.read file! 'config.json' 'utf-8')
-    else
-        {
-            color: 'red'
-        }
-
-// para executar duas chamadas assíncronas de forma concorrente, use o
-// operador `?`.
-// O operador `?` retorna um *future*, que pode ser executado para
-// aguardar o resultado, novamente utilizando o operador `!`
-
-// nós não esperamos nenhuma dessas chamadas serem concluídas
-a = fs.stat? 'a.txt'
-b = fs.stat? 'b.txt'
-
-// agora nos aguardamos o término das chamadas e escrevemos os resultados
-console.log "size of a.txt is #(a!.size)"
-console.log "size of b.txt is #(b!.size)"
-
-// no Pogoscript, futures são semelhantes a Promises
-```
-E encerramos por aqui.
-
-Baixe o [Node.js](http://nodejs.org/) e execute `npm install pogo`.
-
-Há bastante documentação em [http://pogoscript.org/](http://pogoscript.org/), incluindo um material para [consulta rápida](http://pogoscript.org/cheatsheet.html), um [guia](http://pogoscript.org/guide/), e como o [Pogoscript é traduzido para o Javascript](http://featurist.github.io/pogo-examples/). Entre em contato através do [grupo do Google](http://groups.google.com/group/pogoscript) se você possui dúvidas!
diff --git a/pt-br/sass-pt.html.markdown b/pt-br/sass-pt.html.markdown
index 105896b2..3d91f1ca 100644
--- a/pt-br/sass-pt.html.markdown
+++ b/pt-br/sass-pt.html.markdown
@@ -6,6 +6,7 @@ contributors:
   - ["Sean Corrales", "https://github.com/droidenator"]
 translators:
   - ["Gabriel Gomes", "https://github.com/gabrielgomesferraz"]
+  - ["Cássio Böck", "https://github.com/cassiobsilva"]
 lang: pt-br
 ---
 
@@ -155,16 +156,6 @@ body {
   background-color: rgba(0, 0, 0, 0.75);
 }
 
-/* You may also define your own functions. Functions are very similar to
-   mixins. When trying to choose between a function or a mixin, remember
-   that mixins are best for generating CSS while functions are better for
-   logic that might be used throughout your Sass code. The examples in
-   the Math Operators' section are ideal candidates for becoming a reusable
-   function. */
-
-/* This function will take a target size and the parent size and calculate
-   and return the percentage */
-
 /* Você também pode definir suas próprias funções. As funções são muito semelhantes aos
    mixins. Ao tentar escolher entre uma função ou um mixin, lembre-
    que mixins são os melhores para gerar CSS enquanto as funções são melhores para
@@ -319,11 +310,6 @@ ol {
   padding: 0;
 }
 
-/* Sass offers @import which can be used to import partials into a file.
-   This differs from the traditional CSS @import statement which makes
-   another HTTP request to fetch the imported file. Sass takes the
-   imported file and combines it with the compiled code. */
-
 /* Sass oferece @import que pode ser usado para importar parciais em um arquivo.
    Isso difere da declaração CSS @import tradicional, que faz
    outra solicitação HTTP para buscar o arquivo importado. Sass converte os
@@ -354,12 +340,6 @@ body {
 ==============================*/  
 
 
-
-/* Placeholders are useful when creating a CSS statement to extend. If you
-   wanted to create a CSS statement that was exclusively used with @extend,
-   you can do so using a placeholder. Placeholders begin with a '%' instead
-   of '.' or '#'. Placeholders will not appear in the compiled CSS. */
-
 /* Os espaços reservados são úteis na criação de uma declaração CSS para ampliar. Se você
    queria criar uma instrução CSS que foi usado exclusivamente com @extend,
    Você pode fazer isso usando um espaço reservado. Espaços reservados começar com um '%' em vez
@@ -396,11 +376,6 @@ body {
 ============================== * /
 
 
-/* Sass provides the following operators: +, -, *, /, and %. These can
-   be useful for calculating values directly in your Sass files instead
-   of using values that you've already calculated by hand. Below is an example
-   of a setting up a simple two column design. */
-
 /* Sass fornece os seguintes operadores: +, -, *, /, e %. estes podem
    ser úteis para calcular os valores diretamente no seu Sass arquivos em vez
    de usar valores que você já calculados pela mão. Abaixo está um exemplo
-- 
cgit v1.2.3


From 762af2de245ab665af0e4b1397acc960d25932f0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?C=C3=A1ssio=20B=C3=B6ck?= <cassio.bock@gmail.com>
Date: Thu, 29 Oct 2015 23:29:46 -0200
Subject: Fixing typos

Fixing pt-br typos
---
 pt-br/c-pt.html.markdown    |  71 ++++++++--------
 pt-br/pogo-pt.html.markdown | 203 --------------------------------------------
 2 files changed, 36 insertions(+), 238 deletions(-)
 delete mode 100644 pt-br/pogo-pt.html.markdown

(limited to 'pt-br')

diff --git a/pt-br/c-pt.html.markdown b/pt-br/c-pt.html.markdown
index 43688724..2c274f12 100644
--- a/pt-br/c-pt.html.markdown
+++ b/pt-br/c-pt.html.markdown
@@ -7,29 +7,30 @@ contributors:
 translators:
     - ["João Farias", "https://github.com/JoaoGFarias"]
     - ["Elton Viana", "https://github.com/eltonvs"]
+    - ["Cássio Böck", "https://github.com/cassiobsilva"]
 lang: pt-br
 filename: c-pt.el
 ---
 
 Ah, C. Ainda é **a** linguagem de computação de alta performance.
 
-C é a liguangem de mais baixo nível que a maioria dos programadores
-irão usar, e isso dá a ela uma grande velocidade bruta. Apenas fique
-antento que este manual de gerenciamento de memória e C vai levanter-te
-tão longe quanto você precisa. 
+C é a linguagem de mais baixo nível que a maioria dos programadores
+utilizarão, e isso dá a ela uma grande velocidade bruta. Apenas fique
+atento se este manual de gerenciamento de memória e C vai te levar
+tão longe quanto precisa.
 
 ```c
 // Comentários de uma linha iniciam-se com // - apenas disponível a partir do C99
 
 /*
-Comentários de multiplas linhas se parecem com este. 
+Comentários de múltiplas linhas se parecem com este.
 Funcionam no C89 também.
 */
 
 // Constantes: #define <palavra-chave>
 #definie DAY_IN_YEAR 365
 
-//enumarações também são modos de definir constantes.
+//enumerações também são modos de definir constantes.
 enum day {DOM = 1, SEG, TER, QUA, QUI, SEX, SAB};
 // SEG recebe 2 automaticamente, TER recebe 3, etc.
 
@@ -54,13 +55,13 @@ int soma_dois_ints(int x1, int x2); // protótipo de função
 // O ponto de entrada do teu programa é uma função
 // chamada main, com tipo de retorno inteiro
 int main() {
-	// Usa-se printf para escrever na tela, 
+	// Usa-se printf para escrever na tela,
 	// para "saída formatada"
 	// %d é um inteiro, \n é uma nova linha
     printf("%d\n", 0); // => Imprime 0
 	// Todos as declarações devem acabar com
 	// ponto e vírgula
-	
+
     ///////////////////////////////////////
     // Tipos
     ///////////////////////////////////////
@@ -78,7 +79,7 @@ int main() {
     // longs tem entre 4 e 8 bytes; longs long tem garantia
     // de ter pelo menos 64 bits
     long x_long = 0;
-    long long x_long_long = 0; 
+    long long x_long_long = 0;
 
     // floats são normalmente números de ponto flutuante
 	// com 32 bits
@@ -93,7 +94,7 @@ int main() {
     unsigned int ux_int;
     unsigned long long ux_long_long;
 
-	// caracteres dentro de aspas simples são inteiros 
+	// caracteres dentro de aspas simples são inteiros
 	// no conjunto de caracteres da máquina.
     '0' // => 48 na tabela ASCII.
     'A' // => 65 na tabela ASCII.
@@ -104,7 +105,7 @@ int main() {
 
 	// Se o argumento do operador `sizeof` é uma expressão, então seus argumentos
 	// não são avaliados (exceto em VLAs (veja abaixo)).
-	// O valor devolve, neste caso, é uma constante de tempo de compilação. 
+	// O valor devolve, neste caso, é uma constante de tempo de compilação.
     int a = 1;
 	// size_t é um inteiro sem sinal com pelo menos 2 bytes que representa
 	// o tamanho de um objeto.
@@ -120,7 +121,7 @@ int main() {
 	// Você pode inicializar um array com 0 desta forma:
     char meu_array[20] = {0};
 
-	// Indexar um array é semelhante a outras linguages
+	// Indexar um array é semelhante a outras linguagens
 	// Melhor dizendo, outras linguagens são semelhantes a C
     meu_array[0]; // => 0
 
@@ -129,7 +130,7 @@ int main() {
     printf("%d\n", meu_array[1]); // => 2
 
 	// No C99 (e como uma features opcional em C11), arrays de tamanho variável
-	// VLA (do inglês), podem ser declarados também. O tamanho destes arrays 
+	// VLA (do inglês), podem ser declarados também. O tamanho destes arrays
 	// não precisam ser uma constante de tempo de compilação:
     printf("Entre o tamanho do array: "); // Pergunta ao usuário pelo tamanho
     char buf[0x100];
@@ -144,14 +145,14 @@ int main() {
     // > Entre o tamanho do array: 10
     // > sizeof array = 40
 
-	// String são apenas arrays de caracteres terminados por um 
+	// String são apenas arrays de caracteres terminados por um
 	// byte nulo (0x00), representado em string pelo caracter especial '\0'.
 	// (Não precisamos incluir o byte nulo em literais de string; o compilador
 	// o insere ao final do array para nós.)
-    char uma_string[20] = "Isto é uma string"; 
+    char uma_string[20] = "Isto é uma string";
 	// Observe que 'é' não está na tabela ASCII
 	// A string vai ser salva, mas a saída vai ser estranha
-	// Porém, comentários podem conter acentos 
+	// Porém, comentários podem conter acentos
     printf("%s\n", uma_string); // %s formata a string
 
     printf("%d\n", uma_string[17]); // => 0
@@ -175,7 +176,7 @@ int main() {
     ///////////////////////////////////////
 
     // Atalho para multiplas declarações:
-    int i1 = 1, i2 = 2; 
+    int i1 = 1, i2 = 2;
     float f1 = 1.0, f2 = 2.0;
 
     int a, b, c;
@@ -206,7 +207,7 @@ int main() {
     2 <= 2; // => 1
     2 >= 2; // => 1
 
-	// C não é Python - comparações não se encadeam.
+	// C não é Python - comparações não se encadeiam.
     int a = 1;
     // Errado:
     int entre_0_e_2 = 0 < a < 2;
@@ -231,7 +232,7 @@ int main() {
     char *s = "iLoveC";
     int j = 0;
     s[j++]; // => "i". Retorna o j-ésimo item de s E DEPOIS incrementa o valor de j.
-    j = 0; 
+    j = 0;
     s[++j]; // => "L". Incrementa o valor de j. E DEPOIS retorna o j-ésimo item de s.
     // o mesmo com j-- e --j
 
@@ -308,7 +309,7 @@ int main() {
         exit(-1);
         break;
     }
-    
+
 
     ///////////////////////////////////////
     // Cast de tipos
@@ -327,8 +328,8 @@ int main() {
 	// Tipos irão ter overflow sem aviso
     printf("%d\n", (unsigned char) 257); // => 1 (Max char = 255 se char tem 8 bits)
 
-	// Para determinar o valor máximo de um `char`, de um `signed char` e de 
-	// um `unisigned char`, respectivamente, use as macros CHAR_MAX, SCHAR_MAX 
+	// Para determinar o valor máximo de um `char`, de um `signed char` e de
+	// um `unisigned char`, respectivamente, use as macros CHAR_MAX, SCHAR_MAX
 	// e UCHAR_MAX de <limits.h>
 
 	// Tipos inteiros podem sofrer cast para pontos-flutuantes e vice-versa.
@@ -341,7 +342,7 @@ int main() {
     ///////////////////////////////////////
 
 	// Um ponteiro é uma variável declarada para armazenar um endereço de memória.
-	// Seu declaração irá também dizer o tipo de dados para o qual ela aponta. Você
+	// Sua declaração irá também dizer o tipo de dados para o qual ela aponta. Você
 	// Pode usar o endereço de memória de suas variáveis, então, brincar com eles.
 
     int x = 0;
@@ -363,13 +364,13 @@ int main() {
     printf("%d\n", *px); // => Imprime 0, o valor de x
 
 	// Você também pode mudar o valor que o ponteiro está apontando.
-	// Teremo que cercar a de-referência entre parenteses, pois
+	// Temos que cercar a de-referência entre parênteses, pois
 	// ++ tem uma precedência maior que *.
     (*px)++; // Incrementa o valor que px está apontando por 1
     printf("%d\n", *px); // => Imprime 1
     printf("%d\n", x); // => Imprime 1
 
-	// Arrays são um boa maneira de alocar um bloco contínuo de memória
+	// Arrays são uma boa maneira de alocar um bloco contínuo de memória
     int x_array[20]; // Declara um array de tamanho 20 (não pode-se mudar o tamanho
     int xx;
     for (xx = 0; xx < 20; xx++) {
@@ -379,7 +380,7 @@ int main() {
 	// Declara um ponteiro do tipo int e inicialize ele para apontar para x_array
     int* x_ptr = x_array;
 	// x_ptr agora aponta para o primeiro elemento do array (o inteiro 20).
-	// Isto funciona porque arrays são apenas ponteiros para seu primeiros elementos.
+	// Isto funciona porque arrays são apenas ponteiros para seus primeiros elementos.
 	// Por exemplo, quando um array é passado para uma função ou é atribuído a um
 	// ponteiro, ele transforma-se (convertido implicitamente) em um ponteiro.
 	// Exceções: quando o array é o argumento de um operador `&` (endereço-de):
@@ -395,7 +396,7 @@ int main() {
     printf("%zu, %zu\n", sizeof arr, sizeof ptr); // provavelmente imprime "40, 4" ou "40, 8"
 
 	// Ponteiros podem ser incrementados ou decrementados baseado no seu tipo
-	// (isto é chamado aritimética de ponteiros
+	// (isto é chamado aritmética de ponteiros
     printf("%d\n", *(x_ptr + 1)); // => Imprime 19
     printf("%d\n", x_array[1]); // => Imprime 19
 
@@ -413,9 +414,9 @@ int main() {
 	// "resultados imprevisíveis" - o programa é dito ter um "comportamento indefinido"
     printf("%d\n", *(my_ptr + 21)); // => Imprime quem-sabe-o-que? Talvez até quebre o programa.
 
-	// Quando termina-se de usar um bloco de memória alocado, você pode liberá-lo,
+	// Quando se termina de usar um bloco de memória alocado, você pode liberá-lo,
 	// ou ninguém mais será capaz de usá-lo até o fim da execução
-	// (Isto cham-se "memory leak"):
+	// (Isto chama-se "memory leak"):
     free(my_ptr);
 
 	// Strings são arrays de char, mas elas geralmente são representadas
@@ -537,7 +538,7 @@ int area(retan r)
     return r.largura * r.altura;
 }
 
-// Se você tiver structus grande, você pode passá-las "por ponteiro" 
+// Se você tiver structus grande, você pode passá-las "por ponteiro"
 // para evitar cópia de toda a struct:
 int area(const retan *r)
 {
@@ -554,8 +555,8 @@ conhecidos. Ponteiros para funções são como qualquer outro ponteiro
 diretamente e passá-las para por toda parte.
 Entretanto, a sintaxe de definição por ser um pouco confusa.
 
-Exemplo: use str_reverso através de um ponteiro 
-*/	
+Exemplo: use str_reverso através de um ponteiro
+*/
 void str_reverso_através_ponteiro(char *str_entrada) {
     // Define uma variável de ponteiro para função, nomeada f.
     void (*f)(char *); //Assinatura deve ser exatamente igual à função alvo.
@@ -575,7 +576,7 @@ typedef void (*minha_função_type)(char *);
 
 // Declarando o ponteiro:
 // ...
-// minha_função_type f; 
+// minha_função_type f;
 
 //Caracteres especiais:
 '\a' // Alerta (sino)
@@ -586,7 +587,7 @@ typedef void (*minha_função_type)(char *);
 '\r' // Retorno de carroça
 '\b' // Backspace
 '\0' // Caracter nulo. Geralmente colocado ao final de string em C.
-     //   oi\n\0. \0 é usado por convenção para marcar o fim da string. 
+     //   oi\n\0. \0 é usado por convenção para marcar o fim da string.
 '\\' // Barra invertida
 '\?' // Interrogação
 '\'' // Aspas simples
@@ -606,7 +607,7 @@ typedef void (*minha_função_type)(char *);
 "%p"    // ponteiro
 "%x"    // hexadecimal
 "%o"    // octal
-"%%"    // imprime % 
+"%%"    // imprime %
 
 ///////////////////////////////////////
 // Ordem de avaliação
diff --git a/pt-br/pogo-pt.html.markdown b/pt-br/pogo-pt.html.markdown
deleted file mode 100644
index 80dcfcd5..00000000
--- a/pt-br/pogo-pt.html.markdown
+++ /dev/null
@@ -1,203 +0,0 @@
----
-language: pogoscript
-contributors:
-    - ["Tim Macfarlane", "http://github.com/refractalize"]
-translators:
-    - ["Cássio Böck", "https://github.com/cassiobsilva"]
-filename: learnPogo-pt-br.pogo
-lang: pt-br
----
-
-Pogoscript é uma linguagem de programação que possui tipos primitivos concorrents
-e que compila para linguagem Javascript padrão.
-
-``` javascript
-// definindo uma variável
-water temperature = 24
-
-// reatribuindo o valor de uma variável após a sua definição
-water temperature := 26
-
-// funções permitem que seus parâmetros sejam colocados em qualquer lugar
-temperature at (a) altitude = 32 - a / 100
-
-// funções longas são apenas indentadas
-temperature at (a) altitude :=
-    if (a < 0)
-        water temperature
-    else
-        32 - a / 100
-
-// declarando uma função
-current temperature = temperature at 3200 altitude
-
-// essa função cria um novo objeto com métodos
-position (x, y) = {
-    x = x
-    y = y
-
-    distance from position (p) =
-        dx = self.x - p.x
-        dy = self.y - p.y
-        Math.sqrt (dx * dx + dy * dy)
-}
-
-// `self` é similiar ao `this` do Javascript, com exceção de que `self` não
-// é redefinido em cada nova função
-
-// declaração de métodos
-position (7, 2).distance from position (position (5, 1))
-
-// assim como no Javascript, objetos também são hashes
-position.'x' == position.x == position.('x')
-
-// arrays
-positions = [
-    position (1, 1)
-    position (1, 2)
-    position (1, 3)
-]
-
-// indexando um array
-positions.0.y
-
-n = 2
-positions.(n).y
-
-// strings
-poem = 'Tail turned to red sunset on a juniper crown a lone magpie cawks.
-        Mad at Oryoki in the shrine-room -- Thistles blossomed late afternoon.
-        Put on my shirt and took it off in the sun walking the path to lunch.
-        A dandelion seed floats above the marsh grass with the mosquitos.
-        At 4 A.M. the two middleaged men sleeping together holding hands.
-        In the half-light of dawn a few birds warble under the Pleiades.
-        Sky reddens behind fir trees, larks twitter, sparrows cheep cheep cheep
-        cheep cheep.'
-
-// texto de Allen Ginsburg
-
-// interpolação
-outlook = 'amazing!'
-console.log "the weather tomorrow is going to be #(outlook)"
-
-// expressões regulares
-r/(\d+)m/i
-r/(\d+) degrees/mg
-
-// operadores
-true @and true
-false @or true
-@not false
-2 < 4
-2 >= 2
-2 > 1
-
-// os operadores padrão do Javascript também são suportados
-
-// definindo seu próprio operador
-(p1) plus (p2) =
-    position (p1.x + p2.x, p1.y + p2.y)
-
-// `plus` pode ser usado com um operador
-position (1, 1) @plus position (0, 2)
-// ou como uma função
-(position (1, 1)) plus (position (0, 2))
-
-// retorno explícito
-(x) times (y) = return (x * y)
-
-// new
-now = @new Date ()
-
-// funções podem receber argumentos opcionais
-spark (position, color: 'black', velocity: {x = 0, y = 0}) = {
-    color = color
-    position = position
-    velocity = velocity
-}
-
-red = spark (position 1 1, color: 'red')
-fast black = spark (position 1 1, velocity: {x = 10, y = 0})
-
-// funções também podem ser utilizadas para realizar o "unsplat" de argumentos
-log (messages, ...) =
-    console.log (messages, ...)
-
-// blocos são funções passadas para outras funções.
-// Este bloco recebe dois parâmetros, `spark` e `c`,
-// o corpo do bloco é o código indentado após a declaração da função
-
-render each @(spark) into canvas context @(c)
-    ctx.begin path ()
-    ctx.stroke style = spark.color
-    ctx.arc (
-        spark.position.x + canvas.width / 2
-        spark.position.y
-        3
-        0
-        Math.PI * 2
-    )
-    ctx.stroke ()
-
-// chamadas assíncronas
-
-// O Javascript, tanto no navegador quanto no servidor (através do Node.js)
-// realiza um uso massivo de funções assíncronas de E/S (entrada/saída) com
-// chamadas de retorno (callbacks). A E/S assíncrona é ótima para a performance e
-// torna a utilização da concorrência simples, porém pode rapidamente se tornar
-// algo complicado.
-// O Pogoscript possui algumas coisas que tornam o uso de E/S assíncrono muito
-// mais fácil
-
-// O Node.js inclui o móduolo `fs` para acessar o sistema de arquivos.
-// Vamos listar o conteúdo de um diretório
-
-fs = require 'fs'
-directory listing = fs.readdir! '.'
-
-// `fs.readdir()` é uma função assíncrona, então nos a chamamos usando o
-// operador `!`. O operador `!` permite que você chame funções assíncronas
-// com a mesma sintaxe e a mesma semântica do que as demais funções síncronas.
-// O Pogoscript reescreve a função para que todo código inserido após o
-//  operador seja inserido em uma função de callback para o `fs.readdir()`.
-
-// obtendo erros ao utilizar funções assíncronas
-
-try
-    another directory listing = fs.readdir! 'a-missing-dir'
-catch (ex)
-    console.log (ex)
-
-// na verdade, se você não usar o `try catch`, o erro será passado para o
-// `try catch` mais externo do evento, assim como é feito em exceções síncronas
-
-// todo o controle de estrutura também funciona com chamadas assíncronas
-// aqui um exemplo de `if else`
-config =
-    if (fs.stat! 'config.json'.is file ())
-        JSON.parse (fs.read file! 'config.json' 'utf-8')
-    else
-        {
-            color: 'red'
-        }
-
-// para executar duas chamadas assíncronas de forma concorrente, use o
-// operador `?`.
-// O operador `?` retorna um *future*, que pode ser executado para
-// aguardar o resultado, novamente utilizando o operador `!`
-
-// nós não esperamos nenhuma dessas chamadas serem concluídas
-a = fs.stat? 'a.txt'
-b = fs.stat? 'b.txt'
-
-// agora nos aguardamos o término das chamadas e escrevemos os resultados
-console.log "size of a.txt is #(a!.size)"
-console.log "size of b.txt is #(b!.size)"
-
-// no Pogoscript, futures são semelhantes a Promises
-```
-E encerramos por aqui.
-
-Baixe o [Node.js](http://nodejs.org/) e execute `npm install pogo`.
-
-Há bastante documentação em [http://pogoscript.org/](http://pogoscript.org/), incluindo um material para [consulta rápida](http://pogoscript.org/cheatsheet.html), um [guia](http://pogoscript.org/guide/), e como o [Pogoscript é traduzido para o Javascript](http://featurist.github.io/pogo-examples/). Entre em contato através do [grupo do Google](http://groups.google.com/group/pogoscript) se você possui dúvidas!
-- 
cgit v1.2.3


From 76bf016f82133ecdb53e02975014d10a34fefce9 Mon Sep 17 00:00:00 2001
From: Victor Caldas <victorcaldas@gmail.com>
Date: Fri, 30 Oct 2015 00:12:29 -0200
Subject: translating java to pt-br

---
 pt-br/java-pt.html.markdown | 213 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 213 insertions(+)

(limited to 'pt-br')

diff --git a/pt-br/java-pt.html.markdown b/pt-br/java-pt.html.markdown
index a884f273..3c9512aa 100644
--- a/pt-br/java-pt.html.markdown
+++ b/pt-br/java-pt.html.markdown
@@ -405,6 +405,219 @@ class Velocipede extends Bicicleta {
 
 }
 
+// Interfaces
+// Sintaxe de declaração de Interface
+// <nível de acesso> Interface <nome-da-interface> extends <super-interfaces> {
+// // Constantes
+// // Declarações de método
+//}
+
+// Exemplo - Comida:
+public interface Comestivel {
+    public void comer(); // Qualquer classe que implementa essa interface, deve
+                        // Implementar este método.
+}
+
+public interface Digestivel {
+    public void digerir();
+}
+
+
+// Agora podemos criar uma classe que implementa ambas as interfaces.
+public class Fruta implements Comestivel, Digestivel {
+
+    @Override
+    public void comer() {
+        // ...
+    }
+
+    @Override
+    public void digerir() {
+        // ...
+    }
+}
+
+// Em Java, você pode estender somente uma classe, mas você pode implementar muitas
+// Interfaces. Por exemplo:
+public class ClasseExemplo extends ExemploClassePai implements InterfaceUm,
+    InterfaceDois {
+
+    @Override
+    public void InterfaceUmMetodo() {
+    }
+
+    @Override
+    public void InterfaceDoisMetodo() {
+    }
+
+}
+
+// Classes abstratas
+
+// Sintaxe de declaração de classe abstrata
+// <Nível de acesso> abstract <nome-da-classe-abstrata> extends <estende super-abstratas-classes> {
+// // Constantes e variáveis
+// // Declarações de método
+//}
+
+// Marcar uma classe como abstrata significa que ela contém métodos abstratos que devem
+// ser definido em uma classe filha. Semelhante às interfaces, classes abstratas não podem
+// ser instanciadas, ao invés disso devem ser extendidas e os métodos abstratos
+// definidos. Diferente de interfaces, classes abstratas podem conter uma mistura de
+// métodos concretos e abstratos. Métodos em uma interface não podem ter um corpo,
+// a menos que o método seja estático, e as variáveis sejam finais, por padrão, ao contrário de um
+// classe abstrata. Classes abstratas também PODEM ter o método "main".
+
+public abstract class Animal
+{
+    public abstract void fazerSom();
+
+    // Método pode ter um corpo
+    public void comer()
+    {
+        System.out.println("Eu sou um animal e estou comendo.");  
+        //Nota: Nós podemos acessar variáveis privadas aqui.
+        idade = 30;
+    }
+
+    // Não há necessidade de inicializar, no entanto, em uma interface
+    // a variável é implicitamente final e, portanto, tem
+    // de ser inicializado.
+    protected int idade;
+
+    public void mostrarIdade()
+    {
+        System.out.println(idade);  
+    }
+
+    //Classes abstratas podem ter o método main.
+    public static void main(String[] args)
+    {
+        System.out.println("Eu sou abstrata");
+    }
+}
+
+class Cachorro extends Animal
+{
+
+    // Nota: ainda precisamos substituir os métodos abstratos na
+    // classe abstrata
+    @Override
+    public void fazerSom()
+    {
+        System.out.println("Bark");
+        // idade = 30;    ==> ERRO!  idade é privada de Animal
+    }
+
+    // NOTA: Você receberá um erro se usou a
+    // anotação Override aqui, uma vez que java não permite
+    // sobrescrita de métodos estáticos.
+    // O que está acontecendo aqui é chamado de "esconder o método".
+    // Vejá também este impressionante SO post: http://stackoverflow.com/questions/16313649/
+    public static void main(String[] args)
+    {
+        Cachorro pluto = new Cachorro();
+        pluto.fazerSom();
+        pluto.comer();
+        pluto.mostrarIdade();
+    }
+}
+
+// Classes Finais
+
+// Sintaxe de declaração de classe final
+// <nível de acesso> final <nome-da-classe-final> {
+// // Constantes e variáveis
+// // Declarações de método
+//}
+
+// Classes finais são classes que não podem ser herdadas e são, portanto, um
+// filha final. De certa forma, as classes finais são o oposto de classes abstratas
+// Porque classes abstratas devem ser estendidas, mas as classes finais não pode ser
+// estendidas.
+public final class TigreDenteDeSabre extends Animal
+{
+    // Nota: Ainda precisamos substituir os métodos abstratos na
+     // classe abstrata.
+    @Override
+    public void fazerSom();
+    {
+        System.out.println("Roar");
+    }
+}
+
+// Métodos Finais
+public abstract class Mamifero()
+{
+    // Sintaxe de Métodos Finais:
+    // <modificador-de-acesso> final <tipo-de-retorno> <nome-do-método>(<argumentos>)
+
+    // Métodos finais, como, classes finais não podem ser substituídas por uma classe filha,
+    // e são, portanto, a implementação final do método.
+    public final boolean EImpulsivo()
+    {
+        return true;
+    }
+}
+
+
+// Tipo Enum
+//
+// Um tipo enum é um tipo de dado especial que permite a uma variável ser um conjunto de constantes predefinidas. A 
+// variável deve ser igual a um dos valores que foram previamente definidos para ela.
+// Por serem constantes, os nomes dos campos de um tipo de enumeração estão em letras maiúsculas.
+// Na linguagem de programação Java, você define um tipo de enumeração usando a palavra-chave enum. Por exemplo, você poderia
+// especificar um tipo de enum dias-da-semana como:
+
+public enum Dia {
+    DOMINGO, SEGUNDA, TERÇA, QUARTA,
+    QUINTA, SEXTA, SABADO 
+}
+
+// Nós podemos usar nosso enum Dia assim:
+
+public class EnumTeste {
+
+    // Variável Enum
+    Dia dia;
+
+    public EnumTeste(Dia dia) {
+        this.dia = dia;
+    }
+
+    public void digaComoE() {
+        switch (dia) {
+            case SEGUNDA:
+                System.out.println("Segundas são ruins.");
+                break;
+
+            case SEXTA:
+                System.out.println("Sextas são melhores.");
+                break;
+
+            case SABADO: 
+            case DOMINGO:
+                System.out.println("Finais de semana são os melhores.");
+                break;
+
+            default:
+                System.out.println("Dias no meio da semana são mais ou menos.");
+                break;
+        }
+    }
+
+    public static void main(String[] args) {
+        EnumTeste primeiroDia = new EnumTeste(Dia.SEGUNDA);
+        primeiroDia.digaComoE(); // => Segundas-feiras são ruins.
+        EnumTeste terceiroDia = new EnumTeste(Dia.QUARTA);
+        terceiroDia.digaComoE(); // => Dias no meio da semana são mais ou menos.
+    }
+}
+
+// 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
-- 
cgit v1.2.3


From 77a16fc34b056843b0fda4c29547b8f575c72823 Mon Sep 17 00:00:00 2001
From: Francisco Marques <kiko96kiko@gmail.com>
Date: Fri, 30 Oct 2015 23:41:21 +0000
Subject: Fixed sentences that didn't make sense (at all)

---
 pt-br/json-pt.html.markdown | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/json-pt.html.markdown b/pt-br/json-pt.html.markdown
index e4f10a61..d4eed0c1 100644
--- a/pt-br/json-pt.html.markdown
+++ b/pt-br/json-pt.html.markdown
@@ -3,6 +3,7 @@ language: json
 contributors:
   - ["Anna Harren", "https://github.com/iirelu"]
   - ["Marco Scannadinari", "https://github.com/marcoms"]
+  - ["Francisco Marques", "https://github.com/ToFran"]
 translators:
   - ["Miguel Araújo", "https://github.com/miguelarauj1o"]
 lang: pt-br
@@ -12,10 +13,8 @@ filename: learnjson-pt.json
 Como JSON é um formato de intercâmbio de dados, este será, muito provavelmente, o
 "Learn X in Y minutes" mais simples existente.
 
-JSON na sua forma mais pura não tem comentários em reais, mas a maioria dos analisadores 
-aceitarão comentários no estilo C (//, /\* \*/). Para os fins do presente, no entanto, 
-tudo o que é vai ser 100% JSON válido. Felizmente, isso meio que fala por si.
-
+JSON na sua forma mais pura não tem comentários, mas a maioria dos analisadores 
+aceitarão comentários no estilo C (//, /\* \*/). No entanto estes devem ser evitados para otimizar a compatibilidade.
 
 ```json
 {
-- 
cgit v1.2.3


From 5de94e16901270de8d584b022d8e9557bba8adc1 Mon Sep 17 00:00:00 2001
From: Francisco Marques <kiko96kiko@gmail.com>
Date: Fri, 30 Oct 2015 23:45:00 +0000
Subject: Added more info.

As I'm already editing this, added more detail (translated from the en version).
---
 pt-br/json-pt.html.markdown | 8 ++++++++
 1 file changed, 8 insertions(+)

(limited to 'pt-br')

diff --git a/pt-br/json-pt.html.markdown b/pt-br/json-pt.html.markdown
index d4eed0c1..f57cd383 100644
--- a/pt-br/json-pt.html.markdown
+++ b/pt-br/json-pt.html.markdown
@@ -16,6 +16,14 @@ Como JSON é um formato de intercâmbio de dados, este será, muito provavelment
 JSON na sua forma mais pura não tem comentários, mas a maioria dos analisadores 
 aceitarão comentários no estilo C (//, /\* \*/). No entanto estes devem ser evitados para otimizar a compatibilidade.
 
+Um valor JSON pode ser um numero, uma string, um array, um objeto, um booleano (true, false) ou null.
+
+Os browsers suportados são: Firefox 3.5+, Internet Explorer 8.0+, Chrome 1.0+, Opera 10.0+, e Safari 4.0+.
+
+A extensão dos ficheiros JSON é “.json” e o tipo de mídia de Internet (MIME) é “application/json”.
+
+Mais informação em: http://www.json.org/
+
 ```json
 {
   "chave": "valor",
-- 
cgit v1.2.3


From 3b9de3c441d583242a7229ce534a446945b8085a Mon Sep 17 00:00:00 2001
From: Francisco Marques <kiko96kiko@gmail.com>
Date: Fri, 30 Oct 2015 23:47:10 +0000
Subject: Removed dot from the last line.

There was a misplaced dot (".") in the last line of the example.
---
 pt-br/json-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/json-pt.html.markdown b/pt-br/json-pt.html.markdown
index f57cd383..fd822c03 100644
--- a/pt-br/json-pt.html.markdown
+++ b/pt-br/json-pt.html.markdown
@@ -64,6 +64,6 @@ Mais informação em: http://www.json.org/
   , "outro comentário": "que bom"
   },
 
-  "que foi curto": "E, você está feito. Você já sabe tudo que JSON tem para oferecer.".
+  "que foi curto": "E, você está feito. Você já sabe tudo que JSON tem para oferecer."
 }
 ```
-- 
cgit v1.2.3


From 04694a00e54272799e50ef8570ddef70a1fd5779 Mon Sep 17 00:00:00 2001
From: Victor Caldas <victorcaldas@gmail.com>
Date: Sat, 31 Oct 2015 16:31:22 -0200
Subject: fixing javascript translate

---
 pt-br/javascript-pt.html.markdown | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/javascript-pt.html.markdown b/pt-br/javascript-pt.html.markdown
index 406042fa..6424214e 100644
--- a/pt-br/javascript-pt.html.markdown
+++ b/pt-br/javascript-pt.html.markdown
@@ -436,7 +436,6 @@ var myPrototype = {
 myObj.__proto__ = myPrototype;
 myObj.meaningOfLife; // = 42
 
-// This works for functions, too.
 // Isto funciona para funções, também.
 myObj.myFunc(); // = "olá mundo!"
 
@@ -506,7 +505,7 @@ String.prototype.firstCharacter = function(){
 
 // Havíamos mencionado que `Object.create` não estava ainda disponível em 
 // todos as implementações, mas nós podemos usá-lo com esse polyfill:
-if (Object.create === undefined){ // don't overwrite it if it exists
+if (Object.create === undefined){ // Não o sobrescreve se já existir
     Object.create = function(proto){
         // faz um construtor temporário com o prototype certo
         var Constructor = function(){};
-- 
cgit v1.2.3