summaryrefslogtreecommitdiffhomepage
path: root/pt-br
diff options
context:
space:
mode:
Diffstat (limited to 'pt-br')
-rw-r--r--pt-br/amd-pt.html.markdown2
-rw-r--r--pt-br/asciidoc-pt.html.markdown2
-rw-r--r--pt-br/asymptotic-notation-pt.html.markdown4
-rw-r--r--pt-br/awk-pt.html.markdown376
-rw-r--r--pt-br/bash-pt.html.markdown2
-rw-r--r--pt-br/bf-pt.html.markdown4
-rw-r--r--pt-br/c++-pt.html.markdown25
-rw-r--r--pt-br/c-pt.html.markdown13
-rw-r--r--pt-br/cmake-pt.html.markdown178
-rw-r--r--pt-br/common-lisp-pt.html.markdown2
-rw-r--r--pt-br/csharp-pt.html.markdown38
-rw-r--r--pt-br/css-pt.html.markdown43
-rw-r--r--pt-br/cypher-pt.html.markdown250
-rw-r--r--pt-br/dart-pt.html.markdown509
-rw-r--r--pt-br/dynamic-programming-pt.html.markdown20
-rw-r--r--pt-br/elm-pt.html.markdown4
-rw-r--r--pt-br/factor-pt.html.markdown184
-rw-r--r--pt-br/go-pt.html.markdown6
-rw-r--r--pt-br/html-pt.html.markdown125
-rw-r--r--pt-br/java-pt.html.markdown2
-rw-r--r--pt-br/javascript-pt.html.markdown2
-rw-r--r--pt-br/json-pt.html.markdown2
-rw-r--r--pt-br/latex-pt.html.markdown291
-rw-r--r--pt-br/less-pt.html.markdown390
-rw-r--r--pt-br/make-pt.html.markdown242
-rw-r--r--pt-br/markdown-pt.html.markdown2
-rw-r--r--pt-br/matlab-pt.html.markdown3
-rw-r--r--pt-br/perl-pt.html.markdown6
-rw-r--r--pt-br/pyqt-pt.html.markdown2
-rw-r--r--pt-br/rust-pt.html.markdown6
-rw-r--r--pt-br/solidity-pt.html.markdown2
-rw-r--r--pt-br/vim-pt.html.markdown6
-rw-r--r--pt-br/visualbasic-pt.html.markdown14
-rw-r--r--pt-br/whip-pt.html.markdown247
34 files changed, 2918 insertions, 86 deletions
diff --git a/pt-br/amd-pt.html.markdown b/pt-br/amd-pt.html.markdown
index 38c1f70f..40c7cd09 100644
--- a/pt-br/amd-pt.html.markdown
+++ b/pt-br/amd-pt.html.markdown
@@ -141,7 +141,7 @@ require(['jquery', 'coolLibFromBower', 'modules/algunsHelpers'], function($, coo
coolLib.facaAlgoDoidoCom(helpers.transform($('#foo')));
});
```
-Apps baseados em `require.js` geralmente terão u´m único ponto de acesso (`main.js`) que é passado à tag script do `require.js` como um data-attribute. Ele vai ser automaticamente carregado e executado com o carregamento da página:
+Apps baseados em `require.js` geralmente terão um único ponto de acesso (`main.js`) que é passado à tag script do `require.js` como um data-attribute. Ele vai ser automaticamente carregado e executado com o carregamento da página:
```html
<!DOCTYPE html>
diff --git a/pt-br/asciidoc-pt.html.markdown b/pt-br/asciidoc-pt.html.markdown
index 1dee31db..b12c0693 100644
--- a/pt-br/asciidoc-pt.html.markdown
+++ b/pt-br/asciidoc-pt.html.markdown
@@ -99,7 +99,7 @@ Para criar uma lista com marcadores use asteriscos.
* baz
```
-Para criar uma lista númerada use pontos.
+Para criar uma lista numerada use pontos.
```
. item 1
diff --git a/pt-br/asymptotic-notation-pt.html.markdown b/pt-br/asymptotic-notation-pt.html.markdown
index 2e299d09..2f179f96 100644
--- a/pt-br/asymptotic-notation-pt.html.markdown
+++ b/pt-br/asymptotic-notation-pt.html.markdown
@@ -38,7 +38,7 @@ Na primeira seção desse documento, descrevemos como Notação Assintótica ide
*f*, *n* como o tamanho da entrada e *f(n)* sendo o tempo de execução. Então,
para dado algoritmo *f*, com entrada de tamanho *n*, você terá tempo de execução
*f(n)*. Isto resulta em um gráfico onde a coordernada Y é o tempo de execução
-, a coordernada X representa o tamanho da entrada e os pontos representao o tempo
+, a coordernada X representa o tamanho da entrada e os pontos representam o tempo
de execução para dado tamanho de entrada.
Você pode representar a função, ou o algoritmo, com Notação Assintótica de várias
@@ -88,7 +88,7 @@ Função Exponencial - a^n, onde *a* é uma constante
Big-O, também escrita como O, é uma Notação Assintótica para o pior caso. Digamos
*f(n)* seja o tempo de exeução de um algoritmo e *g(n)) um tempo de complexidade
-arbritário que você quer relacionar com seu algoritmo. *f(n)* é O(g(n)), se, para
+arbitrário que você quer relacionar com seu algoritmo. *f(n)* é O(g(n)), se, para
quando constante real c (c > 0), *f(n)* <= *c g(n)* para todo tamanho de entrada
n (n > 0).
diff --git a/pt-br/awk-pt.html.markdown b/pt-br/awk-pt.html.markdown
new file mode 100644
index 00000000..761f5294
--- /dev/null
+++ b/pt-br/awk-pt.html.markdown
@@ -0,0 +1,376 @@
+---
+language: awk
+filename: learnawk-pt.awk
+contributors:
+ - ["Marshall Mason", "http://github.com/marshallmason"]
+translators:
+ - ["Paulo Henrique Rodrigues Pinheiro", "https://github.com/paulohrpinheiro"]
+lang: pt-br
+
+---
+
+AWK é uma ferramenta padrão em todos os sistemas UNIX compatíveis com POSIX. É
+como um Perl despojado, perfeito para tarefas de processamento de texto e
+outras tarefas de script. Possui uma sintaxe C-like, mas sem ponto e vírgula,
+gerenciamento manual de memória, ou tipagem estática. Destaca-se no
+processamento de texto. Você pode chamá-lo a partir de um shell-script, ou você
+pode usá-lo como uma linguagem de script autônomo.
+
+Por que usar AWK ao invés de Perl? Principalmente porque AWK faz parte do UNIX.
+Você pode sempre contar com ele, enquanto o futuro do Perl é indefinido. AWK é
+também mais fácil de ler que Perl. Para scripts simples de processamento de
+texto, particularmente aqueles que leem arquivos linha por linha e fatiam texto
+por delimitadores, AWK é provavelmente a ferramenta certa para a tarefa.
+
+```awk
+#!/usr/bin/awk -f
+
+# Comentários são assim
+
+# Programas AWK consistem de uma coleção de padrões e ações. O mais
+# importante padrão é chamado BEGIN. Ações estão dentro de blocos
+# entre chaves.
+
+BEGIN {
+
+ # O bloco BEGIN será executado no começo do programa. É onde você coloca
+ # todo código que prepara a execução, antes que você processe qualquer
+ # arquivo de texto. Se você não tem arquivos de texto, então pense no
+ # BEGIN como o ponto principal de entrada.
+
+ # Variáveis são globais. Simplesmente atribua valores ou as use, sem
+ # necessidade de declarar.
+
+ # Operadores são como em C e similares
+ a = count + 1
+ b = count - 1
+ c = count * 1
+ d = count / 1 # divisão inteira
+ e = count % 1 # módulo
+ f = count ^ 1 # exponenciação
+
+ a += 1
+ b -= 1
+ c *= 1
+ d /= 1
+ e %= 1
+ f ^= 1
+
+ # Incrementando e decrementando por um
+ a++
+ b--
+
+ # Como um operador pré-fixado, retorna o valor incrementado
+ ++a
+ --b
+
+ # Perceba, não há pontuação, como ponto-e-vírgula, ao final das declarações
+
+ # Declarações de controle
+ if (count == 0)
+ print "Começando com count em 0"
+ else
+ print "Como é que é?"
+
+ # Ou você pode usar o operador ternário
+ print (count == 0) ? "Começando com count em 0" : "Como é que é?"
+
+ # Blocos multilinhas devem usar chaves
+ while (a < 10) {
+ print "Concatenação de texto é feita" " com uma série" " de"
+ " textos separados por espaço"
+ print a
+
+ a++
+ }
+
+ for (i = 0; i < 10; i++)
+ print "Uma boa opção para um loop de uma linha"
+
+ # Quanto a comparações, eis os padrões:
+ a < b # Menor que
+ a <= b # Menor ou igual a
+ a != b # Não igual
+ a == b # Igual
+ a > b # Maior que
+ a >= b # Maior ou igual a
+
+ # Bem como operadores lógicos
+ a && b # E
+ a || b # OU (inclusivo)
+
+ # Em adição, há o utilíssimo operador para expressões regulares
+ if ("foo" ~ "^fo+$")
+ print "Fooey!"
+ if ("boo" !~ "^fo+$")
+ print "Boo!"
+
+ # Matrizes
+ arr[0] = "foo"
+ arr[1] = "bar"
+ # Infelizmente, não há outra forma para inicializar uma matriz. Apenas
+ # coloque cada valor em uma linha, como mostrado acima.
+
+ # Você também pode ter matrizes associativas
+ assoc["foo"] = "bar"
+ assoc["bar"] = "baz"
+
+ # E matrizes multidimensionais, com algumas limitações que não mencionarei
+ multidim[0,0] = "foo"
+ multidim[0,1] = "bar"
+ multidim[1,0] = "baz"
+ multidim[1,1] = "boo"
+
+ # Você pode testar a pertinência de um elemento em uma matriz
+ if ("foo" in assoc)
+ print "Fooey!"
+
+ # Você pode também usar o operador 'in' para percorrer as chaves de uma
+ # matriz associativa
+ for (key in assoc)
+ print assoc[key]
+
+ # Os argumentos da linha de comando estão em uma matriz especial ARGV
+ for (argnum in ARGV)
+ print ARGV[argnum]
+
+ # Você pode remover elementos de uma matriz
+ # Isso é muito útil para prevenir que o AWK assuma que os argumentos são
+ # arquivo para ele processar
+ delete ARGV[1]
+
+ # A quantidade de argumentos passados está na variável ARGC
+ print ARGC
+
+ # O AWK tem várias funções nativas. Elas estão separadas em três categorias.
+ # Demonstrarei cada uma delas logo mais abaixo.
+
+ return_value = arithmetic_functions(a, b, c)
+ string_functions()
+ io_functions()
+}
+
+# Eis como você deve definir uma função
+function arithmetic_functions(a, b, c, d) {
+
+ # Provavelmente a parte mais irritante do AWK é ele não possuir variáveis
+ # locais. Tudo é global. Para pequenos scripts, isso não é problema, e
+ # pode até mesmo ser considerado útil, mas para grandes scripts, isso pode
+ # ser um problema.
+
+ # Mas há como contornar isso (um hack). Os argumentos de função são locais
+ # para a função e o AWK permite que você defina mais argumentos de função
+ # do que ele precise. Então, coloque a variável local na declaração de
+ # função, como eu fiz acima. Como uma convenção, adicione alguns espaços
+ # extras para distinguir entre parâmetros de função reais e variáveis
+ # locais. Neste exemplo, a, b e c são parâmetros reais, enquanto d é
+ # meramente uma variável local.
+
+ # Agora, serão demonstradas as funções aritméticas
+
+ # Muitas implementações AWK possuem algumas funções trigonométricas padrão
+ localvar = sin(a)
+ localvar = cos(a)
+ localvar = atan2(b, a) # arco-tangente de b / a
+
+ # E conteúdo logarítmico
+ localvar = exp(a)
+ localvar = log(a)
+
+ # Raiz quadrada
+ localvar = sqrt(a)
+
+ # Descartando a parte não inteira de um número em ponto flutuante.
+ localvar = int(5.34) # localvar => 5
+
+ # Números aleatórios
+ srand() # Forneça uma semente como argumento. Por padrão, ele usa a hora atual
+ localvar = rand() # Número aleatório entre 0 e 1.
+
+ # Aqui mostramos como retornar um valor
+ return localvar
+}
+
+function string_functions( localvar, arr) {
+
+ # Sendo o AWK uma linguagem para processamento de texto, ele possui
+ # várias funções para manipulação de texto, muitas das quais
+ # fortemente dependentes de expressões regulares.
+
+ # Procurar e substituir, primeira instância (sub), ou todas (gsub)
+ # Ambas retornam o número de instâncias substituídas
+ localvar = "fooooobar"
+ sub("fo+", "Meet me at the ", localvar) # localvar => "Meet me at the bar"
+ gsub("e+", ".", localvar) # localvar => "m..t m. at th. bar"
+
+ # Localiza um texto que casa com uma expressão regular
+ # index() faz a mesma coisa, mas não permite uma expressão regular
+ match(localvar, "t") # => 4, pois 't' é o quarto carácter
+
+ # Separa por delimitador
+ split("foo-bar-baz", arr, "-") # a => ["foo", "bar", "baz"]
+
+ # Outras coisas úteis
+ sprintf("%s %d %d %d", "Testing", 1, 2, 3) # => "Testing 1 2 3"
+ substr("foobar", 2, 3) # => "oob"
+ substr("foobar", 4) # => "bar"
+ length("foo") # => 3
+ tolower("FOO") # => "foo"
+ toupper("foo") # => "FOO"
+}
+
+function io_functions( localvar) {
+
+ # Você já viu como imprimir
+ print "Hello world"
+
+ # Também há o printf
+ printf("%s %d %d %d\n", "Testing", 1, 2, 3)
+
+ # O AWK não disponibiliza manipuladores de arquivo. Ele irá automaticamente
+ # manipular um arquivo quando você fizer algo que precise disso. O texto
+ # que você usou para isso pode ser usado como um manipulador de arquivo,
+ # para propósitos de E/S. Isso faz ele parecer com um shell script:
+
+ print "foobar" >"/tmp/foobar.txt"
+
+ # Agora a string "/tmp/foobar.txt" é um manipulador de arquivos. Você pode
+ # fechá-lo:
+ close("/tmp/foobar.txt")
+
+ # Aqui está como você pode executar alguma coisa no shell
+ system("echo foobar") # => prints foobar
+
+ # Lê uma linha da entrada padrão e armazena em localvar
+ getline localvar
+
+ # Lê uma linha de um pipe
+ "echo foobar" | getline localvar # localvar => "foobar"
+ close("echo foobar")
+
+ # Lê uma linha de um arquivo e armazena em localvar
+ getline localvar <"/tmp/foobar.txt"
+ close("/tmp/foobar.txt")
+}
+
+# Como dito no início, os programas AWK consistem de uma coleção de padrões
+# e ações. Você já viu o padrão BEGIN, o mais importante. Outros padrões são
+# usados apenas se você estiver processando linhas de arquivos ou a entrada
+# padrão.
+
+# Quando você passa argumentos para o AWK, eles são tratados como nomes de
+# arquivos para processar. Todos serão processados, em ordem. Pense nisso como
+# um implícito para loop, iterando sobre as linhas nesses arquivos. Esses
+# padrões e ações são como instruções de mudança dentro do loop.
+
+/^fo+bar$/ {
+
+ # Esta ação será executada para cada linha que corresponda à expressão
+ # regular, / ^ fo + bar $ /, e será ignorada para qualquer linha que não
+ # corresponda. Vamos apenas imprimir a linha:
+
+ print
+
+ # Opa, sem argumento! Isso ocorre pois print tem um argumento padrão: $0.
+ # $0 é o nome da linha atual que está sendo processada. Essa variável é
+ # criada automaticamente para você.
+
+ # Você provavelmente pode adivinhar que existem outras variáveis $. Toda
+ # linha é implicitamente dividida antes de cada ação ser chamada, como
+ # o shell faz. E, como o shell, cada campo pode ser acessado com um sinal
+ # de cifrão
+
+ # Isso irá imprimir o segundo e quarto campos da linha
+ print $2, $4
+
+ # O AWK automaticamente define muitas outras variáveis para ajudar você
+ # a inspecionar processar cada linha. A mais importante delas é NF.
+
+ # Imprime o número de campos da linha atual
+ print NF
+
+ # Imprime o último campo da linha atual
+ print $NF
+}
+
+# Todo padrão é na verdade um teste verdadeiro/falso. A expressão regular no
+# último padrão também é um teste verdadeiro/falso, mas parte dele estava
+# escondido. Se você não informar um texto para testar, AWK assumirá $0,
+# a linha que está atualmente sendo processada. Assim, a versão completa
+# é a seguinte:
+
+$0 ~ /^fo+bar$/ {
+ print "Equivalente ao último padrão"
+}
+
+a > 0 {
+ # Isso será executado uma vez para cada linha, quando a for positivo
+}
+
+# Você entendeu. Processar arquivos de texto, ler uma linha de cada vez, e
+# fazer algo com ela, particularmente dividir com base em um delimitador, é
+# tão comum no UNIX que AWK é uma linguagem de script que faz tudo por você,
+# sem você precisa perguntar. Tudo o que você precisa fazer é escrever os
+# padrões e ações com base no que você espera da entrada, e o que você quer
+# fazer com isso.
+
+# Aqui está um exemplo rápido de um script simples, o tipo de coisa que o AWK
+# é perfeito para fazer. Ele irá ler um nome da entrada padrão e depois
+imprimirá a média de idade de todos com esse primeiro nome. Digamos que você
+forneça como argumento o nome de um arquivo com esses dados:
+
+# Bob Jones 32
+# Jane Doe 22
+# Steve Stevens 83
+# Bob Smith 29
+# Bob Barker 72
+#
+# Eis o script:
+
+BEGIN {
+
+ # Primeiro, pergunte o nome do usuário
+ print "Para qual nome você quer calcular a média de idade?"
+
+ # Pega uma linha da entrada padrão, não dos arquivos indicados na
+ # linha de comando
+ getline name <"/dev/stdin"
+}
+
+# Agora, processa cada linha em que o primeiro nome é o nome informado
+$1 == name {
+
+ # Dentro desse bloco, nós temos acesso a algumas variáveis uteis, que
+ # foram pré-carregadas para nós:
+ # $0 é a linha corrente completa
+ # $3 é o terceiro campo, que é o que nos interessa aqui
+ # NF é a quantidade de campos, que deve ser 3
+ # NR é o número de registros (linhas) lidas até agora
+ # FILENAME é o nome do arquivo sendo processado
+ # FS é o delimitador em uso, que é " " aqui
+ # ...etc. Há muito mais, documentadas no manual.
+
+ # Mantenha um registro do total e da quantidade de linhas encontradas
+ sum += $3
+ nlines++
+}
+
+# Outro padrão especial é chamado END. Ele será executado após o processamento
+# de todos os arquivos de texto. Ao contrário de BEGIN, ele só será executado
+# se você tiver dado a ele dados para processar. Ele será executado depois de
+# todos os arquivos terem sido lidos e processados de acordo com as regras e
+# ações que você forneceu. O objetivo disso em geral é produzir algum tipo de
+# relatório final, ou fazer algo com o agregado dos dados acumulados ao longo
+# do script.
+
+END {
+ if (nlines)
+ print "A média da idade para " name " é " sum / nlines
+}
+
+```
+Leituras adicionais (em inglês):
+
+* [Awk tutorial](http://www.grymoire.com/Unix/Awk.html)
+* [Awk man page](https://linux.die.net/man/1/awk)
+* [The GNU Awk User's Guide](https://www.gnu.org/software/gawk/manual/gawk.html) GNU AWK é encontrado na maioria dos sistemas GNU/Linux.
diff --git a/pt-br/bash-pt.html.markdown b/pt-br/bash-pt.html.markdown
index ae18435a..3a48d994 100644
--- a/pt-br/bash-pt.html.markdown
+++ b/pt-br/bash-pt.html.markdown
@@ -16,7 +16,7 @@ lang: pt-br
Tutorial de shell em português
-Bash é o nome do shell do Unix, que também é distribuido como shell do sistema
+Bash é o nome do shell do Unix, que também é distribuído como shell do sistema
operacional GNU e como shell padrão para Linux e Mac OS X. Praticamente todos
os exemplos abaixo podem fazer parte de um shell script e pode ser executados
diretamente no shell.
diff --git a/pt-br/bf-pt.html.markdown b/pt-br/bf-pt.html.markdown
index 52a5269e..53baa9a2 100644
--- a/pt-br/bf-pt.html.markdown
+++ b/pt-br/bf-pt.html.markdown
@@ -13,7 +13,9 @@ lang: pt-br
Brainfuck (em letras minúsculas, exceto no início de frases) é uma linguagem de
programação Turing-completa extremamente simples com apenas 8 comandos.
-```
+Você pode experimentar brainfuck pelo seu browser com [brainfuck-visualizer](http://fatiherikli.github.io/brainfuck-visualizer/).
+
+```bf
Qualquer caractere exceto "><+-.,[]" (sem contar as aspas) é ignorado.
Brainfuck é representado por um vetor com 30 000 células inicializadas em zero
diff --git a/pt-br/c++-pt.html.markdown b/pt-br/c++-pt.html.markdown
index c1cfbbb1..42a29991 100644
--- a/pt-br/c++-pt.html.markdown
+++ b/pt-br/c++-pt.html.markdown
@@ -18,9 +18,9 @@ foi concebida para
- suportar programação orientada a objetos
- suportar programação genérica
-Embora sua sintaxe pode ser mais difícil ou complexa do que as linguagens mais
-recentes, C++ é amplamente utilizado porque compila para instruções nativas que
-podem ser executadas diretamente pelo processador e oferece um controlo rígido sobre hardware (como C), enquanto oferece recursos de alto nível, como os
+Embora sua sintaxe possa ser mais difícil ou complexa do que as linguagens mais
+recentes, C++ é amplamente utilizada porque compila para instruções nativas que
+podem ser executadas diretamente pelo processador e oferece um controle rígido sobre o hardware (como C), enquanto oferece recursos de alto nível, como os
genéricos, exceções e classes. Esta combinação de velocidade e funcionalidade
faz C++ uma das linguagens de programação mais utilizadas.
@@ -40,10 +40,10 @@ faz C++ uma das linguagens de programação mais utilizadas.
int main(int argc, char** argv)
{
- // Argumentos de linha de comando são passados em pelo argc e argv da mesma
+ // Argumentos de linha de comando são passados para argc e argv da mesma
// forma que eles estão em C.
// argc indica o número de argumentos,
- // e argv é um array de strings, feito C (char*) representado os argumentos
+ // e argv é um array de strings, feito C (char*) representando os argumentos
// O primeiro argumento é o nome pelo qual o programa foi chamado.
// argc e argv pode ser omitido se você não se importa com argumentos,
// dando a assinatura da função de int main()
@@ -274,7 +274,7 @@ public:
void setWeight(int dogsWeight);
- // Funções que não modificam o estado do objecto devem ser marcadas como
+ // Funções que não modificam o estado do objeto devem ser marcadas como
// const. Isso permite que você chamá-los se for dada uma referência const
// para o objeto. Além disso, observe as funções devem ser explicitamente
// declarados como _virtual_, a fim de ser substituídas em classes
@@ -564,15 +564,15 @@ void doSomethingWithAFile(const std::string& filename)
// Isto tem _grandes_ vantagens:
// 1. Não importa o que aconteça,
-// o recurso (neste caso, o identificador de ficheiro) irá ser limpo.
+// o recurso (neste caso, o identificador de ficheiro) será limpo.
// Depois de escrever o destruidor corretamente,
// É _impossível_ esquecer de fechar e vazar o recurso
// 2. Nota-se que o código é muito mais limpo.
// As alças destructor fecham o arquivo por trás das cenas
// sem que você precise se preocupar com isso.
// 3. O código é seguro de exceção.
-// Uma exceção pode ser jogado em qualquer lugar na função e a limpeza
-// irá ainda ocorrer.
+// Uma exceção pode ser lançada em qualquer lugar na função e a limpeza
+// ainda irá ocorrer.
// Todos códigos C++ usam RAII extensivamente para todos os recursos.
// Outros exemplos incluem
@@ -609,7 +609,6 @@ h=sum<double>(f,g);
```
Leitura Adicional:
-Uma referência atualizada da linguagem pode ser encontrada em
-<http://cppreference.com/w/cpp>
-
-Uma fonte adicional pode ser encontrada em <http://cplusplus.com>
+* Uma referência atualizada da linguagem pode ser encontrada em [CPP Reference](http://cppreference.com/w/cpp).
+* Uma fonte adicional pode ser encontrada em [CPlusPlus](http://cplusplus.com).
+* Um tutorial cobrindo o básico da linguagem e configurando o ambiente de codificação está disponível em [TheChernoProject - C ++](https://www.youtube.com/playlist?list=PLlrATfBNZ98dudnM48yfGUldqGD0S4FFb).
diff --git a/pt-br/c-pt.html.markdown b/pt-br/c-pt.html.markdown
index 6e7aa8c2..e1c27958 100644
--- a/pt-br/c-pt.html.markdown
+++ b/pt-br/c-pt.html.markdown
@@ -182,7 +182,7 @@ int main() {
int a, b, c;
a = b = c = 0;
- // Aritimética é óbvia
+ // Aritmética é óbvia
i1 + i2; // => 3
i2 - i1; // => 1
i2 * i1; // => 2
@@ -191,7 +191,7 @@ int main() {
f1 / f2; // => 0.5, mais ou menos epsilon
// Números e cálculos de ponto flutuante não são exatos
- // Modulo também existe
+ // Módulo também existe
11 % 3; // => 2
// Operadores de comparação provavelmente são familiares,
@@ -538,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 structs grandes, você pode passá-las "por ponteiro"
// para evitar cópia de toda a struct:
int area(const retan *r)
{
@@ -638,16 +638,17 @@ typedef void (*minha_função_type)(char *);
## Leitura adicional
É recomendado ter uma cópia de [K&R, aka "The C Programming Language"](https://en.wikipedia.org/wiki/The_C_Programming_Language).
-Este é *o* livro sobre C, escrito pelos criadores da linguage. Mas cuidado - ele é antigo e contém alguns erros (bem,
-ideias que não são consideradas boas hoje) ou práticas mudadas.
+Este é *o* livro sobre C, escrito pelos criadores da linguagem. Mas cuidado - ele é antigo e contém alguns erros (bem,
+ideias que não são mais consideradas boas) ou práticas ultrapassadas.
Outra boa referência é [Learn C the hard way](http://c.learncodethehardway.org/book/).
Se você tem uma pergunta, leia [compl.lang.c Frequently Asked Questions](http://c-faq.com).
É importante usar espaços e indentação adequadamente e ser consistente com seu estilo de código em geral.
-Código legível é melhor que código 'esperto' e rápido. Para adotar um estilo de código bom e são, veja
+Código legível é melhor que código 'esperto' e rápido. Para adotar um estilo de código bom e sensato, veja
[Linux kernel coding style](https://www.kernel.org/doc/Documentation/CodingStyle).
Além disso, Google é teu amigo.
+
[1] http://stackoverflow.com/questions/119123/why-isnt-sizeof-for-a-struct-equal-to-the-sum-of-sizeof-of-each-member
diff --git a/pt-br/cmake-pt.html.markdown b/pt-br/cmake-pt.html.markdown
new file mode 100644
index 00000000..bc3e7050
--- /dev/null
+++ b/pt-br/cmake-pt.html.markdown
@@ -0,0 +1,178 @@
+---
+language: cmake
+contributors:
+ - ["Bruno Alano", "https://github.com/brunoalano"]
+filename: CMake
+translators:
+ - ["Lucas Pugliesi", "https://github.com/fplucas"]
+lang: pt-br
+---
+
+CMake é um programa de compilação open-source e multiplataforma. Essa ferramenta
+permitirá testar, compilar e criar pacotes a partir do seu código fonte.
+
+O problema que o CMake tenta resolver são os problemas de configurar os Makefiles
+e Autoconfigure (diferente dos interpretadores make que tem comandos diferentes)
+e sua facilidade de uso envolvendo bibliotecas terceiras.
+
+CMake é um sistema open-source extensível que gerencia o processo de build em um
+sistema operacional e um método independente de compilador. Diferente de sistemas
+multiplataformas, CMake é designado a usar em conjunto ao ambiente de compilação
+nativo. Seus simples arquivos de configuração localizados em seus diretórios
+(chamados arquivos CMakeLists.txt) que são usados para gerar padrões de arquivos
+de compilação (ex: makefiles no Unix e projetos em Windows MSVC) que são usados
+de maneira simples.
+
+```cmake
+# No CMake, isso é um comentário
+
+# Para rodar nosso código, iremos utilizar esses comandos:
+# - mkdir build && cd build
+# - cmake ..
+# - make
+#
+# Com esses comandos, iremos seguir as melhores práticas para compilar em um
+# subdiretório e na segunda linha pediremos ao CMake para gerar um novo Makefile
+# independente de sistema operacional. E finalmente, rodar o comando make.
+
+#------------------------------------------------------------------------------
+# Básico
+#------------------------------------------------------------------------------
+#
+# O arquivo CMake deve ser chamado de "CMakeLists.txt".
+
+# Configura a versão mínima requerida do CMake para gerar o Makefile
+cmake_minimum_required (VERSION 2.8)
+
+# Exibe FATAL_ERROR se a versão for menor que 2.8
+cmake_minimum_required (VERSION 2.8 FATAL_ERROR)
+
+# Configuramos o nome do nosso projeto. Mas antes disso, iremos alterar alguns
+# diretórios em nome da convenção gerada pelo CMake. Podemos enviar a LANG do
+# código como segundo parâmetro
+project (learncmake C)
+
+# Configure o diretório do código do projeto (somente convenção)
+set( LEARN_CMAKE_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR} )
+set( LEARN_CMAKE_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR} )
+
+# Isso é muito útil para configurar a versão do nosso código no sistema de compilação
+# usando um estilo `semver`
+set (LEARN_CMAKE_VERSION_MAJOR 1)
+set (LEARN_CMAKE_VERSION_MINOR 0)
+set (LEARN_CMAKE_VERSION_PATCH 0)
+
+# Envie as variáveis (número da versão) para o cabeçalho de código-fonte
+configure_file (
+ "${PROJECT_SOURCE_DIR}/TutorialConfig.h.in"
+ "${PROJECT_BINARY_DIR}/TutorialConfig.h"
+)
+
+# Inclua Diretórios
+# No GCC, isso irá invocar o comando "-I"
+include_directories( include )
+
+# Onde as bibliotecas adicionais estão instaladas? Nota: permite incluir o path
+# aqui, na sequência as checagens irão resolver o resto
+set( CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/CMake/modules/" )
+
+# Condições
+if ( CONDICAO )
+ # reposta!
+
+ # Informação incidental
+ message(STATUS "Minha mensagem")
+
+ # Aviso CMake, continua processando
+ message(WARNING "Minha mensagem")
+
+ # Aviso (dev) CMake, continua processando
+ message(AUTHOR_WARNING "Minha mensagem")
+
+ # Erro CMake, continua processando, mas pula a geração
+ message(SEND_ERROR "Minha mensagem")
+
+ # Erro CMake, para o processamento e a geração
+ message(FATAL_ERROR "Minha mensagem")
+endif()
+
+if( CONDICAO )
+
+elseif( CONDICAO )
+
+else( CONDICAO )
+
+endif( CONDICAO )
+
+# Loops
+foreach(loop_var arg1 arg2 ...)
+ COMANDO1(ARGS ...)
+ COMANDO2(ARGS ...)
+ ...
+endforeach(loop_var)
+
+foreach(loop_var RANGE total)
+foreach(loop_var RANGE start stop [step])
+
+foreach(loop_var IN [LISTS [list1 [...]]]
+ [ITEMS [item1 [...]]])
+
+while(condicao)
+ COMANDO1(ARGS ...)
+ COMANDO2(ARGS ...)
+ ...
+endwhile(condicao)
+
+
+# Operações Lógicas
+if(FALSE AND (FALSE OR TRUE))
+ message("Não exiba!")
+endif()
+
+# Configure um cache normal, ou uma variável de ambiente com o dado valor.
+# Se a opção PARENT_SCOPE for informada em uma variável que será setada no escopo
+# acima do escopo corrente.
+# `set(<variavel> <valor>... [PARENT_SCOPE])`
+
+# Como refencia variáveis dentro de aspas ou não, argumentos com strings vazias
+# não serão setados
+${nome_da_variavel}
+
+# Listas
+# Configure a lista de arquivos código-fonte
+set( LEARN_CMAKE_SOURCES
+ src/main.c
+ src/imagem.c
+ src/pather.c
+)
+
+# Chama o compilador
+#
+# ${PROJECT_NAME} referencia ao Learn_CMake
+add_executable( ${PROJECT_NAME} ${LEARN_CMAKE_SOURCES} )
+
+# Linka as bibliotecas
+target_link_libraries( ${PROJECT_NAME} ${LIBS} m )
+
+# Onde as bibliotecas adicionais serão instaladas? Nota: nos permite incluir o path
+# aqui, em seguida os testes irão resolver o restante
+set( CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/CMake/modules/" )
+
+# Condição do compilador (gcc ; g++)
+if ( "${CMAKE_C_COMPILER_ID}" STREQUAL "GNU" )
+ message( STATUS "Setting the flags for ${CMAKE_C_COMPILER_ID} compiler" )
+ add_definitions( --std=c99 )
+endif()
+
+# Checa o Sistema Operacional
+if( UNIX )
+ set( LEARN_CMAKE_DEFINITIONS
+ "${LEARN_CMAKE_DEFINITIONS} -Wall -Wextra -Werror -Wno-deprecated-declarations -Wno-unused-parameter -Wno-comment" )
+endif()
+```
+
+### Mais Recursos
+
++ [cmake tutorial](https://cmake.org/cmake-tutorial/)
++ [cmake documentation](https://cmake.org/documentation/)
++ [mastering cmake](http://amzn.com/1930934319/)
diff --git a/pt-br/common-lisp-pt.html.markdown b/pt-br/common-lisp-pt.html.markdown
index 03a7c15c..c22cfd8e 100644
--- a/pt-br/common-lisp-pt.html.markdown
+++ b/pt-br/common-lisp-pt.html.markdown
@@ -19,7 +19,7 @@ Outro livro recente e popular é o
[Land of Lisp](http://landoflisp.com/).
-```common_lisp
+```lisp
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 0. Sintaxe
diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown
index 547f4817..be14a1c8 100644
--- a/pt-br/csharp-pt.html.markdown
+++ b/pt-br/csharp-pt.html.markdown
@@ -6,23 +6,23 @@ contributors:
lang: pt-br
---
-C# é uma linguagem elegante e altamente tipado orientada a objetos que permite aos desenvolvedores criarem uma variedade de aplicações seguras e robustas que são executadas no .NET Framework.
+C# é uma linguagem elegante, altamente tipada e orientada a objetos que permite aos desenvolvedores criar uma variedade de aplicações seguras e robustas que são executadas no .NET Framework.
-[Read more here.](http://msdn.microsoft.com/pt-br/library/vstudio/z1zx9t92.aspx)
+[Leia mais aqui.](http://msdn.microsoft.com/pt-br/library/vstudio/z1zx9t92.aspx)
```c#
-// Comentário de linha única começa com //
+// Comentários de linha única começam com //
/*
-Múltipas linhas é desta forma
+Comentários de múltiplas linhas são desta forma
*/
/// <summary>
-/// Esta é uma documentação comentário XML que pode ser usado para gerar externo
-/// documentação ou fornecer ajuda de contexto dentro de um IDE
+/// Este é um comentário de documentação XML que pode ser usado para gerar documentação
+/// externa ou para fornecer ajuda de contexto dentro de uma IDE
/// </summary>
//public void MethodOrClassOrOtherWithParsableHelp() {}
-// Especificar qual namespace seu código irá usar
-// Os namespaces a seguir são padrões do .NET Framework Class Library
+// Especifica os namespaces que o código irá usar
+// Os namespaces a seguir são padrões da biblioteca de classes do .NET Framework
using System;
using System.Collections.Generic;
using System.Dynamic;
@@ -33,11 +33,11 @@ using System.IO;
// Mas este aqui não é :
using System.Data.Entity;
-// Para que consiga utiliza-lo, você precisa adicionar novas referências
+// Para que consiga utilizá-lo, você precisa adicionar novas referências
// Isso pode ser feito com o gerenciador de pacotes NuGet : `Install-Package EntityFramework`
-// Namespaces são escopos definidos para organizar o códgo em "pacotes" or "módulos"
-// Usando este código a partir de outra arquivo de origem: using Learning.CSharp;
+// Namespaces são escopos definidos para organizar o código em "pacotes" ou "módulos"
+// Usando este código a partir de outro arquivo de origem: using Learning.CSharp;
namespace Learning.CSharp
{
// Cada .cs deve conter uma classe com o mesmo nome do arquivo
@@ -762,7 +762,7 @@ on a new line! ""Wow!"", the masses cried";
}
}
- //Method to display the attribute values of this Object.
+ //Método para exibir os valores dos atributos deste objeto.
public virtual string Info()
{
return "Gear: " + Gear +
@@ -784,13 +784,13 @@ on a new line! ""Wow!"", the masses cried";
} // end class Bicycle
- // PennyFarthing is a subclass of Bicycle
+ // PennyFarthing é uma subclasse de Bicycle
class PennyFarthing : Bicycle
{
- // (Penny Farthings are those bicycles with the big front wheel.
- // They have no gears.)
+ // (Penny Farthings são aquelas bicicletas com uma grande roda frontal.
+ // Elas não tem correias.)
- // calling parent constructor
+ // chamando construtor pai
public PennyFarthing(int startCadence, int startSpeed) :
base(startCadence, startSpeed, 0, "PennyFarthing", true, BikeBrand.Electra)
{
@@ -823,10 +823,10 @@ on a new line! ""Wow!"", the masses cried";
}
}
- // Interfaces only contain signatures of the members, without the implementation.
+ // Interfaces contêm apenas as assinaturas dos membros, sem a implementação.
interface IJumpable
{
- void Jump(int meters); // all interface members are implicitly public
+ void Jump(int meters); // todos os membros da interface são implicitamente públicos
}
interface IBreakable
@@ -834,7 +834,7 @@ on a new line! ""Wow!"", the masses cried";
bool Broken { get; } // interfaces can contain properties as well as methods & events
}
- // Class can inherit only one other class, but can implement any amount of interfaces
+ // Classes podem herdar apenas de uma outra classe, mas podem implementar qualquer quantidade de interfaces.
class MountainBike : Bicycle, IJumpable, IBreakable
{
int damage = 0;
diff --git a/pt-br/css-pt.html.markdown b/pt-br/css-pt.html.markdown
index b1fbd961..c73669d0 100644
--- a/pt-br/css-pt.html.markdown
+++ b/pt-br/css-pt.html.markdown
@@ -9,6 +9,8 @@ contributors:
- ["Deepanshu Utkarsh", "https://github.com/duci9y"]
translators:
- ["Gabriel Gomes", "https://github.com/gabrielgomesferraz"]
+ - ["Gabriele Luz", "https://github.com/gabrieleluz"]
+
lang: pt-br
---
@@ -25,7 +27,7 @@ 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 * /
+ Não há "comentários de uma linha"; este é o único estilo de comentário * /
/* ####################
## SELETORES
@@ -236,6 +238,45 @@ A precedência de estilo é a seguinte. Lembre-se, a precedência é para cada
* `B` é o próximo.
* `D` é a última.
+## Media Queries
+Media queries são recursos do CSS3 que permitem especificar quando determinadas regras de CSS devem ser aplicadas; é possível aplicar regras diferentes quando a página é impressa, quando a tela possui determinadas dimensões ou densidade de pixels e quando é lida por um leitor de tela. Media queries não adicionam especificidade ao seletor.
+
+```css
+/* Uma regra que será aplicada a todos os dispositivos */
+h1 {
+ font-size: 2em;
+ color: white;
+ background-color: black;
+}
+
+/* Altera a cor do h1 para utilizar menos tinta durante a impressão */
+@media print {
+ h1 {
+ color: black;
+ background-color: white;
+ }
+}
+
+/* Altera o tamanho da fonte quando exibida numa tela com pelo menos 480px de largura */
+@media screen and (min-width: 480px) {
+ h1 {
+ font-size: 3em;
+ font-weight: normal;
+ }
+}
+```
+Media queries podem incluir os seguintes atributos: `width`, `height`, `device-width`, `device-height`, `orientation`, `aspect-ratio`, `device-aspect-ratio`, `color`, `color-index`, `monochrome`, `resolution`, `scan`, `grid`. A maioria desses atributos pode ser prefixada com `min-` ou `max-`.
+
+O atributo `resolution` não é suportado em dispositivos mais antigos. Em vez disso, use `device-pixel-ratio`.
+
+Muitos smartphones e tablets tentarão renderizar a página como se estivesse num desktop a menos que você utilize a meta-tag `viewport`.
+
+```html
+<head>
+ <meta name="viewport" content="width=device-width; initial-scale=1.0">
+</head>
+```
+
## 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.
diff --git a/pt-br/cypher-pt.html.markdown b/pt-br/cypher-pt.html.markdown
new file mode 100644
index 00000000..7cfd8dcd
--- /dev/null
+++ b/pt-br/cypher-pt.html.markdown
@@ -0,0 +1,250 @@
+---
+language: cypher
+filename: LearnCypher.cql
+contributors:
+ - ["Théo Gauchoux", "https://github.com/TheoGauchoux"]
+
+lang: pt-br
+---
+
+O Cypher é a linguagem de consulta do Neo4j para manipular gráficos facilmente. Ela reutiliza a sintaxe do SQL e a mistura com o tipo de ascii-art para representar gráficos. Este tutorial pressupõe que você já conheça conceitos de gráficos como nós e relacionamentos.
+
+[Leia mais aqui.](https://neo4j.com/developer/cypher-query-language/)
+
+
+Nós
+---
+
+**Representa um registro em um gráfico.**
+
+`()`
+É um *nó* vazio, para indicar que existe um *nó*, mas não é relevante para a consulta.
+
+`(n)`
+É um *nó* referido pela variável **n**, reutilizável na consulta. Começa com minúsculas e usa o camelCase.
+
+`(p:Person)`
+Você pode adicionar um *label* ao seu nó, aqui **Person**. É como um tipo / uma classe / uma categoria. Começa com maiúsculas e usa o camelCase.
+
+`(p:Person:Manager)`
+Um nó pode ter muitos *labels*.
+
+`(p:Person {name : 'Théo Gauchoux', age : 22})`
+Um nó pode ter algumas *propriedades*, aqui **name** e **age**. Começa com minúsculas e usa o camelCase.
+
+Os tipos permitidos nas propriedades:
+
+ - Numeric
+ - Boolean
+ - String
+ - Lista de tipos primitivos anteriores
+
+*Aviso: não há propriedade datetime no Cypher! Você pode usar String com um padrão específico ou um Numeric a partir de uma data específica.*
+
+`p.name`
+Você pode acessar uma propriedade com o estilo de ponto.
+
+
+Relacionamentos (ou Arestas)
+---
+
+**Conecta dois nós**
+
+`[:KNOWS]`
+É um *relacionamento* com o *label* **KNOWS**. É um *label* como um rótulo do nó. Começa com maiúsculas e usa UPPER_SNAKE_CASE.
+
+`[k:KNOWS]`
+O mesmo *relacionamento*, referido pela variável **k**, reutilizável na consulta, mas não é necessário.
+
+`[k:KNOWS {since:2017}]`
+O mesmo *relacionamento*, com *propriedades* (como *nó*), aqui **since**.
+
+`[k:KNOWS*..4]`
+É uma informação estrutural para usar em um *path* (visto posteriormente). Aqui, **\*..4** diz, “Corresponda o padrão, com a relação **k** que é repetida de 1 a 4 vezes.
+
+
+Paths
+---
+
+**A maneira de misturar nós e relacionamentos.**
+
+`(a:Person)-[:KNOWS]-(b:Person)`
+Um path descrevendo que **a** e **b** se conhecem.
+
+`(a:Person)-[:MANAGES]->(b:Person)`
+Um path pode ser direcionado. Este path descreve que **a** é o gerente de **b**.
+
+`(a:Person)-[:KNOWS]-(b:Person)-[:KNOWS]-(c:Person)`
+Você pode encadear vários relacionamentos. Este path descreve o amigo de um amigo.
+
+`(a:Person)-[:MANAGES]->(b:Person)-[:MANAGES]->(c:Person)`
+Uma encadeamento também pode ser direcionada. Este path descreve que **a** é o chefe de **b** e o grande chefe de **c**.
+
+Padrões frequentemente usados ​​(do Neo4j doc) :
+
+```
+// Amigo de um amigo
+(user)-[:KNOWS]-(friend)-[:KNOWS]-(foaf)
+
+// Path mais curto
+path = shortestPath( (user)-[:KNOWS*..5]-(other) )
+
+// Filtragem colaborativa
+(user)-[:PURCHASED]->(product)<-[:PURCHASED]-()-[:PURCHASED]->(otherProduct)
+
+// Navegação de árvore
+(root)<-[:PARENT*]-(leaf:Category)-[:ITEM]->(data:Product)
+
+```
+
+
+Crie consultas
+---
+
+Create a new node
+```
+CREATE (a:Person {name:"Théo Gauchoux"})
+RETURN a
+```
+*`RETURN` permite ter um resultado após a consulta. Pode ser múltiplo, como `RETURN a, b`.*
+
+Crie um novo relacionamento (com 2 novos nós)
+```
+CREATE (a:Person)-[k:KNOWS]-(b:Person)
+RETURN a,k,b
+```
+
+Consultas que casam
+---
+
+Casam todos os nós
+```
+MATCH (n)
+RETURN n
+```
+
+Casam nós por label
+```
+MATCH (a:Person)
+RETURN a
+```
+
+Casam nós por label e propriedade
+```
+MATCH (a:Person {name:"Théo Gauchoux"})
+RETURN a
+```
+
+Casam nós de acordo com os relacionamentos (não direcionados)
+```
+MATCH (a)-[:KNOWS]-(b)
+RETURN a,b
+```
+
+Casam nós de acordo com os relacionamentos (direcionados)
+```
+MATCH (a)-[:MANAGES]->(b)
+RETURN a,b
+```
+
+Casam nós com um cláusula `WHERE`
+```
+MATCH (p:Person {name:"Théo Gauchoux"})-[s:LIVES_IN]->(city:City)
+WHERE s.since = 2015
+RETURN p,state
+```
+
+Você pode usa a cláusula `MATCH WHERE` com a cláusula `CREATE`
+```
+MATCH (a), (b)
+WHERE a.name = "Jacquie" AND b.name = "Michel"
+CREATE (a)-[:KNOWS]-(b)
+```
+
+
+Atualizar consultas
+---
+
+Atualizar uma propriedade específica de um nó
+```
+MATCH (p:Person)
+WHERE p.name = "Théo Gauchoux"
+SET p.age = 23
+```
+
+Substituir todas as propriedades de um nó
+```
+MATCH (p:Person)
+WHERE p.name = "Théo Gauchoux"
+SET p = {name: "Michel", age: 23}
+```
+
+Adicionar nova propriedade a um nó
+```
+MATCH (p:Person)
+WHERE p.name = "Théo Gauchoux"
+SET p + = {studies: "IT Engineering"}
+```
+
+Adicione um label a um nó
+```
+MATCH (p:Person)
+WHERE p.name = "Théo Gauchoux"
+SET p:Internship
+```
+
+
+Excluir consultas
+---
+
+Excluir um nó específico (os relacionamentos vinculados devem ser excluídos antes)
+```
+MATCH (p:Person)-[relationship]-()
+WHERE p.name = "Théo Gauchoux"
+DELETE relationship, p
+```
+
+Remover uma propriedade em um nó específico
+```
+MATCH (p:Person)
+WHERE p.name = "Théo Gauchoux"
+REMOVE p.age
+```
+*Prestar atenção à palavra chave `REMOVE`, não é `DELETE` !*
+
+Remover um label de um nó específico
+```
+MATCH (p:Person)
+WHERE p.name = "Théo Gauchoux"
+DELETE p:Person
+```
+
+Excluir o banco de dados inteiro
+```
+MATCH (n)
+OPTIONAL MATCH (n)-[r]-()
+DELETE n, r
+```
+*Sério, é o `rm -rf /` do Cypher !*
+
+
+Outras cláusulas úteis
+---
+
+`PROFILE`
+Antes de uma consulta, mostre o plano de execução dela.
+
+`COUNT(e)`
+Contar entidades (nós ou relacionamentos) que casam com **e**.
+
+`LIMIT x`
+Limite o resultado aos primeiros x resultados.
+
+
+Dicas Especiais
+---
+
+- Há apenas comentários de uma linha no Cypher, com barras duplas : // Comentários
+- Você pode executar um script Cypher armazenado em um arquivo **.cql** diretamente no Neo4j (é uma importação). No entanto, você não pode ter várias instruções neste arquivo (separadas por **;**).
+- Use o shell Neo4j para escrever Cypher, é realmente incrível.
+- O Cypher será a linguagem de consulta padrão para todos os bancos de dados de gráficos (conhecidos como **OpenCypher**).
diff --git a/pt-br/dart-pt.html.markdown b/pt-br/dart-pt.html.markdown
new file mode 100644
index 00000000..e9d72850
--- /dev/null
+++ b/pt-br/dart-pt.html.markdown
@@ -0,0 +1,509 @@
+---
+language: dart
+filename: learndart-pt.dart
+contributors:
+ - ["Joao Pedrosa", "https://github.com/jpedrosa/"]
+translators:
+ - ["Junior Damacena", "https://github.com/jdamacena/"]
+lang: pt-br
+---
+
+Dart é uma novata no reino das linguagens de programação.
+Ela empresta muito de outras linguagens mais conhecidas, e tem a meta de não se diferenciar muito de seu irmão, JavaScript. Assim como JavaScript, Dart foi pensada para oferecer grande integração com o Browser.
+
+A característica mais controversa da Dart é a sua Tipagem Opcional, ou seja, não é obrigatório declarar tipos.
+
+```dart
+import "dart:collection";
+import "dart:math" as DM;
+
+// Bem vindo ao Aprenda Dart em 15 minutos. http://www.dartlang.org/
+// Este é um tutorial executável. Você pode rodar esse tutorial com Dart ou no
+// site Try Dart!, é só copiar e colar este código lá. http://try.dartlang.org/
+
+// Declarações de funções e métodos são iguais. Declarações de funções
+// podem ser aninhadas. A declaração é feita das seguintes formas
+// nome() {} ou nome() => expressaoDeUmaLinhaSo;
+// A declaração feita com a seta tem um return implícito para o resultado da
+// expressão.
+example1() {
+ example1nested1() {
+ example1nested2() => print("Example1 nested 1 nested 2");
+ example1nested2();
+ }
+ example1nested1();
+}
+
+// Funções anônimas são criadas sem um nome.
+example2() {
+ example2nested1(fn) {
+ fn();
+ }
+ example2nested1(() => print("Example2 nested 1"));
+}
+
+// Quando uma função é declarada como parâmetro, a declaração pode incluir o número
+// de parâmetros que a função recebe, isso é feito especificando o nome de cada um dos
+// parâmetros que serão recebidos pela função.
+example3() {
+ example3nested1(fn(informSomething)) {
+ fn("Example3 nested 1");
+ }
+ example3planB(fn) { // Ou não declare o número de parâmetros.
+ fn("Example3 plan B");
+ }
+ example3nested1((s) => print(s));
+ example3planB((s) => print(s));
+}
+
+// Funções têm acesso à variáveis fora de seu escopo
+var example4Something = "Example4 nested 1";
+example4() {
+ example4nested1(fn(informSomething)) {
+ fn(example4Something);
+ }
+ example4nested1((s) => print(s));
+}
+
+// Declaração de classe com um método chamado sayIt, que também tem acesso
+// à variável externa, como se fosse uma função como se viu antes.
+var example5method = "Example5 sayIt";
+class Example5Class {
+ sayIt() {
+ print(example5method);
+ }
+}
+example5() {
+ // Criar uma instância anônima de Example5Class e chamar o método sayIt
+ // nela.
+ new Example5Class().sayIt();
+}
+
+// A declaração de uma classe é feita da seguinte maneira: class name { [classBody] }.
+// onde classBody pode incluir métodos e variáveis de instância, assim como
+// métodos e variáveis de classe.
+class Example6Class {
+ var example6InstanceVariable = "Example6 instance variable";
+ sayIt() {
+ print(example6InstanceVariable);
+ }
+}
+example6() {
+ new Example6Class().sayIt();
+}
+
+// Métodos e variáveis de classe são declarados como "static".
+class Example7Class {
+ static var example7ClassVariable = "Example7 class variable";
+ static sayItFromClass() {
+ print(example7ClassVariable);
+ }
+ sayItFromInstance() {
+ print(example7ClassVariable);
+ }
+}
+example7() {
+ Example7Class.sayItFromClass();
+ new Example7Class().sayItFromInstance();
+}
+
+// Literais são ótimos, mas há uma limitação para o que eles podem ser
+// quando estão fora do corpo de uma função/método. Literais fora do escopo da classe
+// ou fora da classe têm que ser constantes. Strings e números são constantes
+// por padrão. Mas arrays e mapas não. Eles podem ser declarados como constantes
+// usando o comando "const".
+var example8A = const ["Example8 const array"],
+ example8M = const {"someKey": "Example8 const map"};
+example8() {
+ print(example8A[0]);
+ print(example8M["someKey"]);
+}
+
+// Loops em Dart são criados com for () {} ou while () {},
+// um pouco mais moderno temos for (.. in ..) {}, ou funções de callbacks com muitas
+// funcionalidades, começando com o forEach.
+var example9A = const ["a", "b"];
+example9() {
+ for (var i = 0; i < example9A.length; i++) {
+ print("Example9 for loop '${example9A[i]}'");
+ }
+ var i = 0;
+ while (i < example9A.length) {
+ print("Example9 while loop '${example9A[i]}'");
+ i++;
+ }
+ for (var e in example9A) {
+ print("Example9 for-in loop '${e}'");
+ }
+ example9A.forEach((e) => print("Example9 forEach loop '${e}'"));
+}
+
+// Para percorrer os caracteres de uma string ou extrair uma substring.
+var example10S = "ab";
+example10() {
+ for (var i = 0; i < example10S.length; i++) {
+ print("Example10 String character loop '${example10S[i]}'");
+ }
+ for (var i = 0; i < example10S.length; i++) {
+ print("Example10 substring loop '${example10S.substring(i, i + 1)}'");
+ }
+}
+
+// Int e double são os dois formatos de número suportados.
+example11() {
+ var i = 1 + 320, d = 3.2 + 0.01;
+ print("Example11 int ${i}");
+ print("Example11 double ${d}");
+}
+
+// DateTime traz operações com data/hora.
+example12() {
+ var now = new DateTime.now();
+ print("Example12 now '${now}'");
+ now = now.add(new Duration(days: 1));
+ print("Example12 tomorrow '${now}'");
+}
+
+// Expressões regulares são suportadas.
+example13() {
+ var s1 = "some string", s2 = "some", re = new RegExp("^s.+?g\$");
+ match(s) {
+ if (re.hasMatch(s)) {
+ print("Example13 regexp matches '${s}'");
+ } else {
+ print("Example13 regexp doesn't match '${s}'");
+ }
+ }
+ match(s1);
+ match(s2);
+}
+
+// Expressões booleanas precisam retornar ou true ou false, já que
+// Dart não faz a conversão implicitamente.
+example14() {
+ var v = true;
+ if (v) {
+ print("Example14 value is true");
+ }
+ v = null;
+ try {
+ if (v) {
+ // Nunca seria executada
+ } else {
+ // Nunca seria executada
+ }
+ } catch (e) {
+ print("Example14 null value causes an exception: '${e}'");
+ }
+}
+
+// try/catch/finally e throw são usados para tratamento de exceções.
+// throw aceita qualquer objeto como parâmetro;
+example15() {
+ try {
+ try {
+ throw "Some unexpected error.";
+ } catch (e) {
+ print("Example15 an exception: '${e}'");
+ throw e; // Re-throw
+ }
+ } catch (e) {
+ print("Example15 catch exception being re-thrown: '${e}'");
+ } finally {
+ print("Example15 Still run finally");
+ }
+}
+
+// Para mais eficiência ao criar strings longas dinamicamente, use o
+// StringBuffer. Ou você pode também concatenar um array de strings.
+example16() {
+ var sb = new StringBuffer(), a = ["a", "b", "c", "d"], e;
+ for (e in a) { sb.write(e); }
+ print("Example16 dynamic string created with "
+ "StringBuffer '${sb.toString()}'");
+ print("Example16 join string array '${a.join()}'");
+}
+
+// Strings podem ser concatenadas apenas colocando strings literais uma perto
+// da outra, sem necessidade de nenhum outro operador.
+example17() {
+ print("Example17 "
+ "concatenar "
+ "strings "
+ "é simples assim");
+}
+
+// Strings podem ser delimitadas por apóstrofos ou aspas e não há
+// diferença entre os dois. Essa flexibilidade pode ser boa para
+// evitar a necessidade de escapar conteúdos que contenham o delimitador da string.
+// Por exemplo, aspas dos atributos HTMLse a string conter HTML.
+example18() {
+ print('Example18 <a href="etc">'
+ "Don't can't I'm Etc"
+ '</a>');
+}
+
+// Strings com três apóstrofos ou aspas podem
+// ter muitas linhas e incluem os delimitadores de linha (ou seja, os enter).
+example19() {
+ print('''Example19 <a href="etc">
+Example19 Don't can't I'm Etc
+Example19 </a>''');
+}
+
+// Strings têm a função de interpolação que é chamada com o caractere $.
+// Com $ { [expression] }, o retorno da expressão é interpolado.
+// $ seguido pelo nome de uma variável interpola o conteúdo dessa variável.
+// $ pode ser escapedo assim \$.
+example20() {
+ var s1 = "'\${s}'", s2 = "'\$s'";
+ print("Example20 \$ interpolation ${s1} or $s2 works.");
+}
+
+// A tipagem opcional permite que APIs usem anotações e também ajuda os
+// IDEs na hora das refatorações, auto-complete e checagem de
+// erros. Note que até agora não declaramos nenhum tipo e o programa está
+// funcionando normalmente. De fato, os tipos são ignorados em tempo de execução.
+// Os tipos podem até mesmo estarem errados e o programa ainda vai dar o
+// benefício da dúvida e rodar, visto que os tipos não importam.
+// Existe um parâmetro que checa erros de tipagem que é o
+// checked mode, dizem que é útil enquanto se está desenvolvendo,
+// mas também é mais lento devido às checagens extras e por isso
+// é evitado em ambiente de produção.
+class Example21 {
+ List<String> _names;
+ Example21() {
+ _names = ["a", "b"];
+ }
+ List<String> get names => _names;
+ set names(List<String> list) {
+ _names = list;
+ }
+ int get length => _names.length;
+ void add(String name) {
+ _names.add(name);
+ }
+}
+void example21() {
+ Example21 o = new Example21();
+ o.add("c");
+ print("Example21 names '${o.names}' and length '${o.length}'");
+ o.names = ["d", "e"];
+ print("Example21 names '${o.names}' and length '${o.length}'");
+}
+
+// Herança em classes é feito assim: class name extends AnotherClassName {}.
+class Example22A {
+ var _name = "Some Name!";
+ get name => _name;
+}
+class Example22B extends Example22A {}
+example22() {
+ var o = new Example22B();
+ print("Example22 class inheritance '${o.name}'");
+}
+
+// Mistura de classes também é possível, e é feito assim:
+// class name extends SomeClass with AnotherClassName {}
+// É necessário extender uma classe para poder misturar com outra.
+// No momento, classes misturadas não podem ter construtor.
+// Mistura de classes é mais usado para compartilhar métodos com classes distantes, então
+// a herança comum não fica no caminho do reuso de código.
+// As misturas aparecem após o comando "with" na declaração da classe.
+class Example23A {}
+class Example23Utils {
+ addTwo(n1, n2) {
+ return n1 + n2;
+ }
+}
+class Example23B extends Example23A with Example23Utils {
+ addThree(n1, n2, n3) {
+ return addTwo(n1, n2) + n3;
+ }
+}
+example23() {
+ var o = new Example23B(), r1 = o.addThree(1, 2, 3),
+ r2 = o.addTwo(1, 2);
+ print("Example23 addThree(1, 2, 3) results in '${r1}'");
+ print("Example23 addTwo(1, 2) results in '${r2}'");
+}
+
+// O método construtor da classe usa o mesmo nome da classe e
+// é feito assim SomeClass() : super() {}, onde a parte ": super()"
+// é opcional e é usada para passar parâmetros estáticos para o
+// construtor da classe pai.
+class Example24A {
+ var _value;
+ Example24A({value: "someValue"}) {
+ _value = value;
+ }
+ get value => _value;
+}
+class Example24B extends Example24A {
+ Example24B({value: "someOtherValue"}) : super(value: value);
+}
+example24() {
+ var o1 = new Example24B(),
+ o2 = new Example24B(value: "evenMore");
+ print("Example24 calling super during constructor '${o1.value}'");
+ print("Example24 calling super during constructor '${o2.value}'");
+}
+
+// Há um atalho para passar parâmetros para o construtor no caso de classes mais simples.
+// Simplesmente use o prefixo this.nomeDoParametro e isso irá passar o parâmetro para uma
+// instância de variável de mesmo nome.
+class Example25 {
+ var value, anotherValue;
+ Example25({this.value, this.anotherValue});
+}
+example25() {
+ var o = new Example25(value: "a", anotherValue: "b");
+ print("Example25 shortcut for constructor '${o.value}' and "
+ "'${o.anotherValue}'");
+}
+
+// Parâmetros com nome estão disponíveis quando declarados entre {}.
+// Quando os parâmetros têm nomes, eles podem ser passados em qualquer ordem.
+// Parâmetros declarados entre [] são opcionais.
+example26() {
+ var _name, _surname, _email;
+ setConfig1({name, surname}) {
+ _name = name;
+ _surname = surname;
+ }
+ setConfig2(name, [surname, email]) {
+ _name = name;
+ _surname = surname;
+ _email = email;
+ }
+ setConfig1(surname: "Doe", name: "John");
+ print("Example26 name '${_name}', surname '${_surname}', "
+ "email '${_email}'");
+ setConfig2("Mary", "Jane");
+ print("Example26 name '${_name}', surname '${_surname}', "
+ "email '${_email}'");
+}
+
+// Variáveis declaradas com um final só podem receber valor uma vez.
+// No caso de classes, variáveis final podem ter valor atribuido através
+// de um parâmetro no construtor
+class Example27 {
+ final color1, color2;
+ // Um pouco de flexibilidade ao criar variáveis final com a sintaxe
+ // que é a seguinte:
+ Example27({this.color1, color2}) : color2 = color2;
+}
+example27() {
+ final color = "orange", o = new Example27(color1: "lilac", color2: "white");
+ print("Example27 color is '${color}'");
+ print("Example27 color is '${o.color1}' and '${o.color2}'");
+}
+
+// para importar uma biblioteca, use import "libraryPath" ou se for uma biblioteca da linguagem,
+// import "dart:libraryName". Também tem o gerenciador de pacotes "pub"que tem
+// sua própria convenção de import "package:packageName".
+// Veja o import "dart:collection"; no início do arquivo. Imports devem vir no início
+// do arquivo. IterableBase vem de dart:collection.
+class Example28 extends IterableBase {
+ var names;
+ Example28() {
+ names = ["a", "b"];
+ }
+ get iterator => names.iterator;
+}
+example28() {
+ var o = new Example28();
+ o.forEach((name) => print("Example28 '${name}'"));
+}
+
+// Para controle de fluxo nós temos:
+// * switch com comandos break obrigatórios
+// * if-else if-else e se-ternário ..?..:..
+// * closures e funções anônimas
+// * comandos break, continue e return
+example29() {
+ var v = true ? 30 : 60;
+ switch (v) {
+ case 30:
+ print("Example29 switch statement");
+ break;
+ }
+ if (v < 30) {
+ } else if (v > 30) {
+ } else {
+ print("Example29 if-else statement");
+ }
+ callItForMe(fn()) {
+ return fn();
+ }
+ rand() {
+ v = new DM.Random().nextInt(50);
+ return v;
+ }
+ while (true) {
+ print("Example29 callItForMe(rand) '${callItForMe(rand)}'");
+ if (v != 30) {
+ break;
+ } else {
+ continue;
+ }
+ // Nunca chega aqui.
+ }
+}
+
+// Você pode converter string para int, double para int, ou só pegar a parte inteira da divisão
+// usando o comando ~/. Vamos jogar um jogo de adivinhação.
+example30() {
+ var gn, tooHigh = false,
+ n, n2 = (2.0).toInt(), top = int.parse("123") ~/ n2, bottom = 0;
+ top = top ~/ 6;
+ gn = new DM.Random().nextInt(top + 1); // +1 porque o máximo do nextInt conta o número passado - 1
+ print("Example30 Diga um número entre 0 e ${top}");
+ guessNumber(i) {
+ if (n == gn) {
+ print("Example30 Você acertou! O número é ${gn}");
+ } else {
+ tooHigh = n > gn;
+ print("Example30 O número ${n} é muito "
+ "${tooHigh ? 'alto' : 'baixo'}. Tente de novo");
+ }
+ return n == gn;
+ }
+ n = (top - bottom) ~/ 2;
+ while (!guessNumber(n)) {
+ if (tooHigh) {
+ top = n - 1;
+ } else {
+ bottom = n + 1;
+ }
+ n = bottom + ((top - bottom) ~/ 2);
+ }
+}
+
+// Programas em Dart só têm um ponto de entrada, que é a função main.
+// Nada será executado antes da funcão main de um programa.
+// Isso ajuda a carregar o programa mais rapidamente, até mesmo quando o
+// carregamento é "Lazy".
+// O programa deve começar com:
+main() {
+ print("Aprenda Dart em 15 minutos!");
+ [example1, example2, example3, example4, example5, example6, example7,
+ example8, example9, example10, example11, example12, example13, example14,
+ example15, example16, example17, example18, example19, example20,
+ example21, example22, example23, example24, example25, example26,
+ example27, example28, example29, example30
+ ].forEach((ef) => ef());
+}
+
+```
+
+## Continue lendo
+
+Dart tem um site bastante fácil de entender. Ele tem os docs da API, tutoriais, artigos e muito mais, incluindo uma
+opção muito útil de testar o Dart online.
+* [https://www.dartlang.org](https://www.dartlang.org)
+* [https://try.dartlang.org](https://try.dartlang.org)
+
+
+
+
diff --git a/pt-br/dynamic-programming-pt.html.markdown b/pt-br/dynamic-programming-pt.html.markdown
index 8de9bee6..518660a3 100644
--- a/pt-br/dynamic-programming-pt.html.markdown
+++ b/pt-br/dynamic-programming-pt.html.markdown
@@ -22,16 +22,16 @@ Sempre se lembre!!
## Maneiras de Solucionar tais Problemas
-1. Top-Down (De cima para baixo): Começe solucionando o problema quebrando-o em
+1. Top-Down (De cima para baixo): Comece solucionando o problema quebrando-o em
partes. Se você perceber que o problema já foi resolvido, então simplemente
pegue a resposta salva. Se ainda não foi resolvido, solucione-o e salve a
resposta. Isso é geralmente fácil de pensar e muito intuitivo. É geralmente
referenciado como Memorização.
2. Bottom-Up (De baixo para cima): Analise o problema e veja a ordem em que os
-subproblemas são resolvidos e começe a solucionar dos problemas mais triviais,
+subproblemas são resolvidos e comece a solucionar dos problemas mais triviais,
até o problema dado. Neste processo, é garantido que os subproblemas são
-resolvidos antes de resoler o problema. Isto é referenciado como Programação Dinâmica.
+resolvidos antes de resolver o problema. Isto é referenciado como Programação Dinâmica.
## Exemplo de Programação Dinâmica
@@ -51,7 +51,7 @@ array antecedente e uma variável como maiorSequenciasAteAgora e seu índice
ajudariam a poupar muito tempo.
Um conceito similar poderia ser aplicado ao procurar o maior caminho em um
grafo acíclico dirigido.
----------------------------------------------------------------------------
+
```
for i=0 to n-1
LS[i]=1
@@ -62,14 +62,12 @@ grafo acíclico dirigido.
if (largest < LS[i])
```
-### Alguns Problemas Famosos de Programação Dinâmica
-```
-Floyd Warshall Algorithm - Tutorial and C Program source code:http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code
-
-Integer Knapsack Problem - Tutorial and C Program source code: http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem
+## Alguns Problemas Famosos de Programação Dinâmica
-Longest Common Subsequence - Tutorial and C Program source code : http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence
-```
+- Floyd Warshall Algorithm - Tutorial and C Program source code: [http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code]()
+- Integer Knapsack Problem - Tutorial and C Program source code: [http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem]()
+- Longest Common Subsequence - Tutorial and C Program source code : [http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence]()
+
## Recursos Online (EN)
diff --git a/pt-br/elm-pt.html.markdown b/pt-br/elm-pt.html.markdown
index 78a4f1b7..d2469a93 100644
--- a/pt-br/elm-pt.html.markdown
+++ b/pt-br/elm-pt.html.markdown
@@ -76,8 +76,8 @@ List.head [] -- Nothing
-- Acesse os elementos de um par com as funções first e second.
-- (Este é um atalho; nós iremos para o "caminho real" em breve.)
-fst ("elm", 42) -- "elm"
-snd ("elm", 42) -- 42
+Tuple.first ("elm", 42) -- "elm"
+Tuple.second ("elm", 42) -- 42
-- Uma tupla vazia ou "unidade" às vezes é utilizada como um placeholder.
-- É o único valor de seu tipo, também chamado de "Unit".
diff --git a/pt-br/factor-pt.html.markdown b/pt-br/factor-pt.html.markdown
new file mode 100644
index 00000000..e3c8f4a9
--- /dev/null
+++ b/pt-br/factor-pt.html.markdown
@@ -0,0 +1,184 @@
+---
+language: factor
+contributors:
+ - ["hyphz", "http://github.com/hyphz/"]
+filename: learnfactor.factor
+
+lang: pt-br
+---
+
+Factor é uma linguagem moderna baseada em pilha, baseado em Forth, criada por Slava Pestov.
+
+Código neste arquivo pode ser digitado em Fator, mas não importado diretamente porque o cabeçalho de vocabulário e importação faria o início completamente confuso.
+
+```factor
+! Este é um comentário
+
+! Como Forth, toda a programação é feita manipulando a pilha.
+! A indicação de um valor literal o coloca na pilha.
+5 2 3 56 76 23 65 ! Nenhuma saída, mas a pilha é impressa no modo interativo
+
+! Esses números são adicionados à pilha, da esquerda para a direita.
+! .s imprime a pilha de forma não destrutiva.
+.s ! 5 2 3 56 76 23 65
+
+! A aritmética funciona manipulando dados na pilha.
+5 4 + ! Sem saída
+
+! `.` mostra o resultado superior da pilha e o imprime.
+. ! 9
+
+! Mais exemplos de aritmética:
+6 7 * . ! 42
+1360 23 - . ! 1337
+12 12 / . ! 1
+13 2 mod . ! 1
+
+99 neg . ! -99
+-99 abs . ! 99
+52 23 max . ! 52
+52 23 min . ! 23
+
+! Várias palavras são fornecidas para manipular a pilha, coletivamente conhecidas como palavras embaralhadas.
+
+3 dup - ! duplica o primeiro item (1st agora igual a 2nd): 3 - 3
+2 5 swap / ! troca o primeiro com o segundo elemento: 5 / 2
+4 0 drop 2 / ! remove o primeiro item (não imprima na tela): 4 / 2
+1 2 3 nip .s ! remove o segundo item (semelhante a drop): 1 3
+1 2 clear .s ! acaba com toda a pilha
+1 2 3 4 over .s ! duplica o segundo item para o topo: 1 2 3 4 3
+1 2 3 4 2 pick .s ! duplica o terceiro item para o topo: 1 2 3 4 2 3
+
+! Criando Palavras
+! O `:` conjuntos de palavras do Factor no modo de compilação até que ela veja a palavra `;`.
+: square ( n -- n ) dup * ; ! Sem saída
+5 square . ! 25
+
+! Podemos ver o que as palavra fazem também.
+! \ suprime a avaliação de uma palavra e coloca seu identificador na pilha.
+\ square see ! : square ( n -- n ) dup * ;
+
+! Após o nome da palavra para criar, a declaração entre parênteses dá o efeito da pilha.
+! Podemos usar os nomes que quisermos dentro da declaração:
+: weirdsquare ( camel -- llama ) dup * ;
+
+! Contanto que sua contagem corresponda ao efeito da pilha da palavra:
+: doubledup ( a -- b ) dup dup ; ! Error: Stack effect declaration is wrong
+: doubledup ( a -- a a a ) dup dup ; ! Ok
+: weirddoubledup ( i -- am a fish ) dup dup ; ! Além disso Ok
+
+! Onde Factor difere do Forth é no uso de citações.
+! Uma citação é um bloco de código que é colocado na pilha como um valor.
+! [ inicia o modo de citação; ] termina.
+[ 2 + ] ! A citação que adiciona 2 é deixada na pilha
+4 swap call . ! 6
+
+! E assim, palavras de ordem mais alta. TONS de palavras de ordem superior.
+2 3 [ 2 + ] dip .s ! Retira valor do topo da pilha, execute citação, empurre de volta: 4 3
+3 4 [ + ] keep .s ! Copie o valor do topo da pilha, execute a citação, envie a cópia: 7 4
+1 [ 2 + ] [ 3 + ] bi .s ! Executar cada citação no valor do topo, empurrar os dois resultados: 3 4
+4 3 1 [ + ] [ + ] bi .s ! As citações em um bi podem extrair valores mais profundos da pilha: 4 5 ( 1+3 1+4 )
+1 2 [ 2 + ] bi@ .s ! Executar a citação no primeiro e segundo valores
+2 [ + ] curry ! Injeta o valor fornecido no início da citação: [ 2 + ] é deixado na pilha
+
+! Condicionais
+! Qualquer valor é verdadeiro, exceto o valor interno f.
+! m valor interno não existe, mas seu uso não é essencial.
+! Condicionais são palavras de maior ordem, como com os combinadores acima.
+
+5 [ "Five is true" . ] when ! Cinco é verdadeiro
+0 [ "Zero is true" . ] when ! Zero é verdadeiro
+f [ "F is true" . ] when ! Sem saída
+f [ "F is false" . ] unless ! F é falso
+2 [ "Two is true" . ] [ "Two is false" . ] if ! Two é verdadeiro
+
+! Por padrão, as condicionais consomem o valor em teste, mas variantes com asterisco
+! deixe sozinho se é verdadeiro:
+
+5 [ . ] when* ! 5
+f [ . ] when* ! Nenhuma saída, pilha vazia, f é consumida porque é falsa
+
+
+! Laços
+! Você adivinhou .. estas são palavras de ordem mais elevada também.
+
+5 [ . ] each-integer ! 0 1 2 3 4
+4 3 2 1 0 5 [ + . ] each-integer ! 0 2 4 6 8
+5 [ "Hello" . ] times ! Hello Hello Hello Hello Hello
+
+! Here's a list:
+{ 2 4 6 8 } ! Goes on the stack as one item
+
+! Aqui está uma lista:
+{ 2 4 6 8 } [ 1 + . ] each ! Exibe 3 5 7 9
+{ 2 4 6 8 } [ 1 + ] map ! Sai { 3 5 7 9 } na pilha
+
+! Reduzir laços ou criar listas:
+{ 1 2 3 4 5 } [ 2 mod 0 = ] filter ! Mantém apenas membros da lista para os quais a citação é verdadeira: { 2 4 }
+{ 2 4 6 8 } 0 [ + ] reduce . ! Como "fold" em linguagens funcionais: exibe 20 (0+2+4+6+8)
+{ 2 4 6 8 } 0 [ + ] accumulate . . ! Como reduzir, mas mantém os valores intermediários em uma lista: exibe { 0 2 6 12 } então 20
+1 5 [ 2 * dup ] replicate . ! Repete a citação 5 vezes e coleta os resultados em uma lista: { 2 4 8 16 32 }
+1 [ dup 100 < ] [ 2 * dup ] produce ! Repete a segunda citação até que a primeira retorne como falsa e colete os resultados: { 2 4 8 16 32 64 128 }
+
+! Se tudo mais falhar, uma finalidade geral, enquanto repete:
+1 [ dup 10 < ] [ "Hello" . 1 + ] while ! Exibe "Hello" 10 vezes
+ ! Sim, é difícil de ler
+ ! Isso é o que todos esses loops variantes são para
+
+! Variáveis
+! Normalmente, espera-se que os programas Factor mantenham todos os dados na pilha.
+! Usar variáveis ​​nomeadas torna a refatoração mais difícil (e é chamada de Factor por um motivo)
+! Variáveis ​​globais, se você precisar:
+
+SYMBOL: name ! Cria o nome como uma palavra identificadora
+"Bob" name set-global ! Sem saída
+name get-global . ! "Bob"
+
+! Variáveis ​​locais nomeadas são consideradas uma extensão, mas estão disponíveis
+! Em uma citação ..
+[| m n ! A citação captura os dois principais valores da pilha em m e n
+ | m n + ] ! Leia-os
+
+! Ou em uma palavra..
+:: lword ( -- ) ! Note os dois pontos duplos para invocar a extensão da variável lexica
+ 2 :> c ! Declara a variável imutável c para manter 2
+ c . ; ! Imprima isso
+
+! Em uma palavra declarada dessa maneira, o lado de entrada da declaração de pilha
+! torna-se significativo e fornece os valores das variáveis ​​em que os valores da pilha são capturados
+:: double ( a -- result ) a 2 * ;
+
+! Variáveis ​​são declaradas mutáveis ​​ao terminar seu nome com um ponto de exclamação
+:: mword2 ( a! -- x y ) ! Capture o topo da pilha na variável mutável a
+ a ! Empurrar a
+ a 2 * a! ! Multiplique por 2 e armazene o resultado em a
+ a ; ! Empurre novo valor de a
+5 mword2 ! Pilha: 5 10
+
+! Listas e Sequências
+! Vimos acima como empurrar uma lista para a pilha
+
+0 { 1 2 3 4 } nth ! Acessar um membro específico de uma lista: 1
+10 { 1 2 3 4 } nth ! Error: índice de sequência fora dos limites
+1 { 1 2 3 4 } ?nth ! O mesmo que nth se o índice estiver dentro dos limites: 2
+10 { 1 2 3 4 } ?nth ! Nenhum erro se estiver fora dos limites: f
+
+{ "at" "the" "beginning" } "Append" prefix ! { "Append" "at" "the" "beginning" }
+{ "Append" "at" "the" } "end" suffix ! { "Append" "at" "the" "end" }
+"in" 1 { "Insert" "the" "middle" } insert-nth ! { "Insert" "in" "the" "middle" }
+"Concat" "enate" append ! "Concatenate" - strings are sequences too
+"Concatenate" "Reverse " prepend ! "Reverse Concatenate"
+{ "Concatenate " "seq " "of " "seqs" } concat ! "Concatenate seq of seqs"
+{ "Connect" "subseqs" "with" "separators" } " " join ! "Connect subseqs with separators"
+
+! E se você quiser obter meta, as citações são seqüências e podem ser desmontadas..
+0 [ 2 + ] nth ! 2
+1 [ 2 + ] nth ! +
+[ 2 + ] \ - suffix ! Quotation [ 2 + - ]
+
+
+```
+
+##Pronto para mais?
+
+* [Documentação do Factor](http://docs.factorcode.org/content/article-help.home.html)
diff --git a/pt-br/go-pt.html.markdown b/pt-br/go-pt.html.markdown
index c7339831..31473ee1 100644
--- a/pt-br/go-pt.html.markdown
+++ b/pt-br/go-pt.html.markdown
@@ -16,7 +16,7 @@ A linguagem Go foi criada a partir da necessidade de ver trabalho feito. Não
forma de resolver os problemas do mundo real.
Tem conceitos familiares de linguagens imperativas com tipagem estática. É
-rápida a compilar e rápida a executar, acrescentando mecanismos de concorrência
+rápida para compilar e rápida para executar, acrescentando mecanismos de concorrência
fáceis de entender para tirar partido dos CPUs multi-core de hoje em dia, e tem
recursos para ajudar com a programação em larga escala.
@@ -39,10 +39,10 @@ import (
)
// Definição de uma função. Main é especial. É o ponto de entrada para o
-// programa executável. Goste-se ou não, a linguagem Go usa chavetas.
+// programa executável. Goste-se ou não, a linguagem Go usa chaves.
func main() {
// A função Println envia uma linha para stdout.
- // É necessário qualifica-la com o nome do pacote, fmt.
+ // É necessário qualificá-la com o nome do pacote, fmt.
fmt.Println("Olá Mundo!")
// Chama outra função dentro deste pacote.
diff --git a/pt-br/html-pt.html.markdown b/pt-br/html-pt.html.markdown
new file mode 100644
index 00000000..5a4bc3bc
--- /dev/null
+++ b/pt-br/html-pt.html.markdown
@@ -0,0 +1,125 @@
+---
+language: html
+filename: learnhtml.txt
+contributors:
+ - ["Christophe THOMAS", "https://github.com/WinChris"]
+translators:
+ - ["Robert Steed", "https://github.com/robochat"]
+lang: pt-br
+---
+
+HTML é um acrônimo de HyperText Markup Language(Linguagem de Marcação de HiperTexto).
+É uma linguagem que nos permite escrever páginas para a "world wide web".
+É uma linguagem de marcação, nos permite escrever páginas na web usando código
+para indicar como o texto e os dados serão ser exibidos.
+De fato, arquivos HTML são simples arquivos de texto.
+O que seria marcação? É um método de organização dos dados da página envolvidos
+por abertura e fechamento de tags.
+Essa marcação serve para dar significado ao texto que envolve.
+Assim como outras linguagens, o HTML tem diversas versões. Aqui falaremos sobre o HTML5.
+
+**NOTA :** Você pode testar diferentes tags e elementos conforme progride os
+tutoriais em sites como [codepen](http://codepen.io/pen/) podendo ver seus efeitos,
+entendendo como funcionam e se familiarizando com a linguagem.
+Esse artigo tem seu foco principal na sintaxe do HTML e algumas dicas úteis.
+
+
+```html
+<!-- Comentários são envolvidos conforme essa linha! -->
+
+<!-- #################### As Tags #################### -->
+
+<!-- Aqui está um exemplo de arquivo HTML que iremos analisar. -->
+
+<!doctype html>
+ <html>
+ <head>
+ <title>Meu Site</title>
+ </head>
+ <body>
+ <h1>Olá, mundo!</h1>
+ <a href = "http://codepen.io/anon/pen/xwjLbZ">Venha ver como isso aparece</a>
+ <p>Esse é um parágrafo.</p>
+ <p>Esse é um outro parágrafo.</p>
+ <ul>
+ <li>Esse é um item de uma lista não enumerada (bullet list)</li>
+ <li>Esse é um outro item</li>
+ <li>E esse é o último item da lista</li>
+ </ul>
+ </body>
+ </html>
+
+<!-- Um arquivo HTML sempre inicia indicando ao navegador que é uma página HTML. -->
+<!doctype html>
+
+<!-- Após isso, inicia abrindo a tag <html>. -->
+<html>
+
+<!-- Essa tag deverá ser fechada ao final do arquivo com </html>. -->
+</html>
+
+<!-- Não deverá haver nada após o fechamento desta tag. -->
+
+<!-- Entre a abertura e o fechamento das tags <html></html>, nós encontramos: -->
+
+<!-- Um cabeçalho definido por <head> (deverá ser fechado com </head>). -->
+<!-- O cabeçalho contém uma descrição e algumas informações adicionais que não serão exibidas; chamam-se metadados. -->
+
+<head>
+ <title>Meu Site</title><!-- Essa tag <title> indica ao navegador o título a ser exibido na barra de títulos e no nome da aba. -->
+</head>
+
+<!-- Após a seção <head>, nós encontramos a tag - <body> -->
+<!-- Até esse ponto, nada descrito irá aparecer na janela do browser. -->
+<!-- Nós deveremos preencher o body(corpo) com o conteúdo a ser exibido. -->
+
+<body>
+ <h1>Olá, mundo!</h1> <!-- A tag h1 cria um título. -->
+ <!-- Há também subtítulos do <h1>, o mais importante, aos mais precisos (h6). -->
+ <a href = "http://codepen.io/anon/pen/xwjLbZ">Venha ver o que isso exibe</a> <!-- Um hiperlink ao endereço preenchido no atributo href="" -->
+ <p>Esse é um parágrafo.</p> <!-- A tag <p> permite incluir um texto na página. -->
+ <p>Esse é um outro parágrafo.</p>
+ <ul> <!-- A tag <ul> cria uma lista de marcação. -->
+ <!-- Para criar uma lista ordenada, devemos usar <ol>, exibindo 1. para o primeiro elemento, 2. para o segundo, etc. -->
+ <li>Esse é um item de uma lista não-enumerada.</li>
+ <li>Esse é um outro item</li>
+ <li>E esse é o último item da lista</li>
+ </ul>
+</body>
+
+<!-- E é isso, criar um arquivo HTML pode ser bem simples. -->
+
+<!-- Também é possível adicionar alguns outros tipos de tags HTML. -->
+
+<!-- Para inserir uma imagem. -->
+<img src="http://i.imgur.com/XWG0O.gif"/> <!-- O caminho da imagem deve ser indicado usando o atributo src="" -->
+<!-- O caminho da imagem pode ser uma URL ou até mesmo o caminho do arquivo no seu computador. -->
+
+<!-- Também é possível criar uma tabela. -->
+
+<table> <!-- Iniciamos a tabela com a tag <table>. -->
+ <tr> <!-- <tr> nos permite criar uma linha. -->
+ <th>Primeiro cabeçalho</th> <!-- <th> nos permite criar o título de uma coluna. -->
+ <th>Segundo cabeçalho</th>
+ </tr>
+ <tr>
+ <td>Primeira linha, primeira coluna</td> <!-- <td> nos permite criar uma célula da tabela. -->
+ <td>Primeira linha, segunda coluna</td>
+ </tr>
+ <tr>
+ <td>Segunda linha, primeira coluna</td>
+ <td>Segunda linha, segunda coluna</td>
+ </tr>
+</table>
+
+```
+
+## Uso
+
+HTML é escrito em arquivos com a extensão `.html` ou `.htm`. Seu mime type é `text/html`.
+
+## Para aprender mais
+
+* [wikipedia](https://en.wikipedia.org/wiki/HTML)
+* [HTML tutorial](https://developer.mozilla.org/en-US/docs/Web/HTML)
+* [W3School](http://www.w3schools.com/html/html_intro.asp)
diff --git a/pt-br/java-pt.html.markdown b/pt-br/java-pt.html.markdown
index 82989502..1b9d7fc6 100644
--- a/pt-br/java-pt.html.markdown
+++ b/pt-br/java-pt.html.markdown
@@ -42,7 +42,7 @@ public class LearnJava {
" Double: " + 3.14 +
" Boolean: " + true);
- // Para imprimir sem inserir uma nova lina, use o System.out.print
+ // Para imprimir sem inserir uma nova linha, use o System.out.print
System.out.print("Olá ");
System.out.print("Mundo");
diff --git a/pt-br/javascript-pt.html.markdown b/pt-br/javascript-pt.html.markdown
index 7b6729ef..ed4a6ff3 100644
--- a/pt-br/javascript-pt.html.markdown
+++ b/pt-br/javascript-pt.html.markdown
@@ -25,7 +25,7 @@ Feedback são muito apreciados! Você me encontrar em
```js
// Comentários são como em C. Comentários de uma linha começam com duas barras,
-/* e comentários de múltplas linhas começam com barra-asterisco
+/* e comentários de múltiplas linhas começam com barra-asterisco
e fecham com asterisco-barra */
// comandos podem ser terminados com ;
diff --git a/pt-br/json-pt.html.markdown b/pt-br/json-pt.html.markdown
index fd822c03..62d9ccad 100644
--- a/pt-br/json-pt.html.markdown
+++ b/pt-br/json-pt.html.markdown
@@ -16,7 +16,7 @@ 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.
+Um valor JSON pode ser um número, 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+.
diff --git a/pt-br/latex-pt.html.markdown b/pt-br/latex-pt.html.markdown
new file mode 100644
index 00000000..103af28e
--- /dev/null
+++ b/pt-br/latex-pt.html.markdown
@@ -0,0 +1,291 @@
+---
+language: latex
+contributors:
+ - ["Chaitanya Krishna Ande", "http://icymist.github.io"]
+ - ["Colton Kohnke", "http://github.com/voltnor"]
+ - ["Sricharan Chiruvolu", "http://sricharan.xyz"]
+ - ["Ramanan Balakrishnan", "https://github.com/ramananbalakrishnan"]
+ - ["Svetlana Golubeva", "https://attillax.github.io/"]
+translators:
+ - ["Paulo Henrique Rodrigues Pinheiro", "https://github.com/paulohrpinheiro"]
+lang: pt-br
+filename: learn-latex-pt.tex
+---
+
+```tex
+% Todas as linhas de comentários começam com %
+% Não existem comentários multilinhas
+
+$ LaTeX não é um programa processador de textos "Visual" como
+% MS Word ou OpenOffice Writer
+
+$ Todo comando LaTeX começa com uma barra invertida (\)
+
+% Documentos LaTeX começam com a definição do tipo que será % compilado
+% Os tipos de documento podem ser livro, relatório, apresentação, etc.
+% As opções para um documento aparecem entre [] chaves. Nesse caso
+% está especificado que queremos o tamanho da fonte em 12pt.
+\documentclass[12pt]{article}
+
+% Em seguida definimos os pacotes que o documento usa.
+% Se você quiser incluir gráficos, texto colorido, ou código fonte de outra
+% linguagem em outro arquivo em seu documento, você precisa ampliar as
+% capacidades do LaTeX. Isso é feito adicionando-se pacotes.
+% Serão incluídos os pacotes float e caption para imagens e hyperref
+% para links.
+\usepackage{caption}
+\usepackage{float}
+\usepackage{hyperref}
+
+% Para poder usar caracteres acentuados, use o seguinte pacote:
+\usepackage[utf8]{inputenc}
+
+% Podemos definir algumas outras propriedades do documento também!
+\author{Chaitanya Krishna Ande, Colton Kohnke, Sricharan Chiruvolu \& \\
+Svetlana Golubeva}
+\date{\today}
+\title{Aprenda \LaTeX \hspace{1pt} em Y Minutos!}
+
+% Agora estamos prontos para começar o documento
+% Tudo antes dessa linha é chamado "preâmbulo".
+\begin{document}
+% Se informarmos os campos author (autores), date (data), "title" (título),
+% LaTeX poderá cria uma página inicial para nós.
+\maketitle
+% Se tivermos seções, poderemos criar uma tabela de conteúdo. Para isso,
+% o documento deve ser compilado duas vezes, para que tudo apareça na ordem
+% correta.
+% É uma boa prática separar a tabela de conteúdo do corpo do documento. Para
+% isso usa-se o comando \newpage
+\newpage
+\tableofcontents
+
+\newpage
+
+% Muitos artigos de pesquisa possuem um resumo, e pode-se isar comandos
+% predefinidos para isso.
+% Isso deve aparecer em sua ordem lógica, portanto, após o topo,
+% mas antes das seções principais do corpo.
+% Esse comando está disponível para os documentos do tipo artigo (article)
+% e relatório (report).
+\begin{abstract}
+ Documentação do \LaTeX \hspace{1pt} escrita em \LaTeX! Nada original!
+\end{abstract}
+
+% Comandos para seções são intuitivos.
+% Todos os títulos de seção são adicionados automaticamente à tabela de conteúdo.
+\section{Introdução}
+Olá, meu nome é Colton e juntos estamos explorando o mundo do \LaTeX!
+
+\section{Outra seção}
+Esse é o texto para outra seção. Penso que precisamos de uma subseção.
+
+\subsection{Isso é uma subseção} % Subseções também são intuitivas.
+Penso que precisamos de mais uma
+
+\subsubsection{Pythagoras}
+Muito melhor agora.
+\label{subsec:pythagoras}
+
+% Ao usar o asterisco nós impedimos a numeração automática.
+% Isso funciona para outros comandos \LaTeX também.
+\section*{Essa é uma seção não numerada}
+Afinal nem todas as seções precisam ser numeradas!
+
+\section{Algumas notas sobre texto}
+%\section{Espaçamento % É necessário mais informação sobre intervalos de espaço.
+\LaTeX \hspace{1pt} geralmente é muito bom sobre colocar texto onde ele deve
+ser posto. Se
+uma linha \\ deve \\ ser \\ quebrada \\ adicione \textbackslash\textbackslash
+\hspace{1pt} ao código de seu documento. \\
+
+\section{Listas}
+Listas são uma das coisas mais fáceis de criar no \LaTeX! Preciso fazer compras
+amanhã, então façamos uma lista de compras.
+\begin{enumerate} % Isso cria o bloco "enumerate".
+ % \item faz com que o enumerate incremente
+ \item Salada.
+ \item 27 melancias.
+ \item Uma lebre.
+ % pode-se também sobrescrever o número do item usando []
+ \item[quantas?] Pistolas de água médias.
+
+ Não é um item da lista, mas faz parte do bloco enumerate.
+
+ \end{enumerate} % Todos os blocos devem ter um final (end{}).
+
+\section{Matemática}
+
+Um dos usos iniciais para \LaTeX \hspace{1pt} foi a produção de artigos
+acadêmicos e técnicos. Usualmente nos campos da matemática e ciência. Assim, é
+necessários que consigamos incluir alguns símbolos especiais em nosso texto! \\
+
+A matemática tem muitos símbolos, além dos quais se pode encontrar no teclado;
+símbolos para relações e conjuntos, setas, operadores, e letras gregas, apenas
+para mencionar alguns.\\
+
+Conjuntos e relações são essenciais em muitos textos de pesquisa em matemática.
+Aqui está como você pode indicar como todo x que pertence
+a X, $\forall$ x $\in$ X. \\
+% Perceba que é necessário adicionar os sinais $ antes e depois dos símbolos.
+% Isso é porque quando escrevendo, estamos em modo texto.
+% Mas os símbolos de matemática só existem no modo matemática.
+% Podemos entrar no modo matemática a partir do modo texto com os símbolos $.
+% O oposto também pode ocorrer. Variáveis podem ser renderizadas no modo
+% matemática.
+% Também podemos entrar no modo matemática com \[\]
+
+\[a^2 + b^2 = c^2 \]
+
+Minha letra grega favorita é $\xi$. Eu também gosto da $\beta$, $\gamma$ e $\sigma$.
+Eu ainda não encontrei uma letra grega que o \LaTeX \hspace{1pt} não tenha!\\
+
+Operadores são parte essencial de um documento sobre matemática:
+funções trigonométricas ($\sin$, $\cos$, $\tan$),
+logaritmo e exponencial ($\log$, $\exp$),
+limites ($\lim$), etc.
+possuem comandos pré-definidos em LaTex.
+Vamos escrever uma equação para ver como se faz:
+$\cos(2\theta) = \cos^{2}(\theta) - \sin^{2}(\theta)$ \\
+
+Frações (numerador/denominador) podem ser escritas dessa forma:
+
+% 10 / 7
+$$ ^{10}/_{7} $$
+
+% Frações relativamente complexas podem ser escritas como
+% \frac{numerator}{denominator}
+$$ \frac{n!}{k!(n - k)!} $$ \\
+
+Também podemos escrever equações em um ``bloco de equação''.
+
+% Apresenta matemática com o 'bloco' equação
+\begin{equation} % entra no modo matemática
+ c^2 = a^2 + b^2.
+ \label{eq:pythagoras} % para referência
+ \end{equation} % toda declaração \begin precisa de uma declaração end
+
+Podemos então referenciar nossa nova equação!
+A equação~\ref{eq:pythagoras} é também conhecida como Teorema de Pitágoras que é
+também assunto da Seção~\ref{subsec:pythagoras}. Muitas coisas podem ser
+rotuladas: figuras, equações, seções, etc.
+
+Somatórios e Integrais são escritas com os comandos sum e int:
+
+% Alguns compiladores LaTeX irão reclamar se existirem linhas em branco
+% em um bloco de equação.
+\begin{equation}
+ \sum_{i=0}^{5} f_{i}
+\end{equation}
+\begin{equation}
+ \int_{0}^{\infty} \mathrm{e}^{-x} \mathrm{d}x
+\end{equation}
+
+\section{Figuras}
+
+Insiramos uma Figura. O local para colocar a figura pode ser difícil
+de determinar. Eu tenho sempre que verificar as opções toda vez.
+
+\begin{figure}[H] % H aqui é uma opção para o local da figura.
+ \centering % centra a figura na página
+ % Inclui uma figura com escala de 0.8 do tamanho da página.
+ %\includegraphics[width=0.8\linewidth]{right-triangle.png}
+ % Comentado para propósitos de compilação. Por favor, use sua imaginação.
+ \caption{Triângulo retângulo com lados $a$, $b$, $c$}
+ \label{fig:right-triangle}
+\end{figure}
+
+\subsection{Tabelas}
+Também podemos incluir tabelas da mesma forma que figuras.
+
+\begin{table}[H]
+ \caption{Título para a Tabela.}
+ % os argumentos {} abaixo descrevem como cada linha da tabela é desenhada.
+ % Aqui também, Preciso ver isso. Toda. E. Cada. Vez.
+ \begin{tabular}{c|cc}
+ Número & Sobrenome & Primeiro Nome \\ % Colunas são separadas por &
+ \hline % uma linha horizontal
+ 1 & Biggus & Dickus \\
+ 2 & Monty & Python
+ \end{tabular}
+\end{table}
+
+\section{Fazendo o \LaTeX \hspace{1pt} não compilar algo (o código fonte)}
+Digamos que precisamos incluir algum código dentro do nosso
+documento \LaTeX \hspace{1pt}, para isso precisamos com o \LaTeX \hspace{1pt}
+não tente interpretar esse texto e que apenas inclua ele no documento. Fazemos
+isso com o bloco verbatim.
+
+% Existem outros pacotes (por exemplo, minty, lstlisting, etc.)
+% mas verbatim é o básico
+\begin{verbatim}
+ print("Hello World!")
+ a%b; % olha só! Podemos usar os sinais % no bloco verbatim.
+ random = 4; #decided by fair random dice roll
+\end{verbatim}
+
+\section{Compilando}
+
+Imagino que agora você esteja pensando como compilar esse fantástico documento
+e visualizar a gloriosa glória que é um pdf gerado por \LaTeX \hspace{1pt} pdf.
+(sim, esse documento é compilável). \\
+
+Finalizando o documento usando \LaTeX \hspace{1pt} consiste nos seguintes passos:
+ \begin{enumerate}
+ \item Escrever o documento em texto puro (o ``código fonte'').
+ \item Compilar o código fonte para gerar um pdf.
+ Os passos para compilar se parecem (em Linux) com: \\
+ \begin{verbatim}
+ > pdflatex learn-latex.tex
+ \end{verbatim}
+ \end{enumerate}
+
+Existem editores de \LaTeX \hspace{1pt} que combinam os passos 1 e 2 no mesmo
+sistema de software. Assim, você pode ver o passo 1, mas não o passo 2 por
+completo. Passo 2 estará acontecendo escondido\footnote{Por exemplo, quando usar
+referências (como Equação~\ref{eq:pythagoras}), pode ser necessário executar o
+passo 2 várias vezes, para gerar arquivos *.aux intermediários.}.
+% É assim que você adiciona notas de rodapé em seus documentos!
+
+Você escreve toda a informação de formatação em texto puro, no passo 1. O
+momento da compilação no passo 2 é responsável por produzir o documento no
+formato que você definiu no passo 1.
+
+\section{Links}
+Nós podemos inserir links em nosso documento. Para isso nós necessitamos incluir
+o pacote hyperref no preâmbulo com o comando:
+\begin{verbatim}
+ \usepackage{hyperref}
+\end{verbatim}
+
+Existem dois tipos principais de links: URL visíveis \\
+\url{https://learnxinyminutes.com/docs/latex/}, ou
+\href{https://learnxinyminutes.com/docs/latex/}{um texto alternativo}
+% Você não pode adicionar espaços extras ou símbolos especiais no texto
+% alternativo, pois isso causará problemas na compilação.
+
+Esse pacote também produz uma lista de thumbnails no documento pdf gerado e
+ativa os links na tabela de conteúdo.
+
+\section{End}
+
+Por enquanto é isso!
+
+% Frequentemente você precisa de uma seção de referências em seu documento.
+% A forma mais fácil de configurá-la é usando uma seção de bibliografia
+\begin{thebibliography}{1}
+ % como em outras listas, o comando \bibitem pode ser usado para itens da lista
+ % cada entrada pode ser citada diretamente no corpo do texto
+ \bibitem{latexwiki} The amazing \LaTeX \hspace{1pt} wikibook: {\em
+https://en.wikibooks.org/wiki/LaTeX}
+ \bibitem{latextutorial} An actual tutorial: {\em http://www.latex-tutorial.com}
+\end{thebibliography}
+
+% end the document
+\end{document}
+```
+
+## Mais sobre LaTeX
+
+* The amazing LaTeX wikibook: [https://en.wikibooks.org/wiki/LaTeX](https://en.wikibooks.org/wiki/LaTeX)
+* An actual tutorial: [http://www.latex-tutorial.com/](http://www.latex-tutorial.com/)
diff --git a/pt-br/less-pt.html.markdown b/pt-br/less-pt.html.markdown
new file mode 100644
index 00000000..679a2ed2
--- /dev/null
+++ b/pt-br/less-pt.html.markdown
@@ -0,0 +1,390 @@
+---
+language: less
+filename: learnless.less
+contributors:
+ - ["Saravanan Ganesh", "http://srrvnn.me"]
+
+lang: pt-br
+---
+
+Less é um pré-processador de CSS, que adiciona recursos como variáveis, aninhamento, mixins e muito mais.
+Less (e outros pré-processadores, como o [Sass](http://sass-lang.com/)) ajudam os desenvolvedores a escreverem código que pode ser mantido e DRY (não se repita).
+
+```css
+
+
+//Comentários de linha única são removidos quando Less é compilado para CSS.
+
+/*Comentários de várias linhas são preservados.*/
+
+
+
+/* Variáveis
+==============================*/
+
+
+/* Você pode armazenar um valor de CSS (como uma cor) em 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ê quiser alterar uma cor, só precisa fazer a alteração uma vez. */
+
+body {
+ background-color: @primary-color;
+ color: @secondary-color;
+ font-family: @body-font;
+}
+
+/* Isso compilará para: */
+
+body {
+ background-color: #a3a4ff;
+ color: #51527F;
+ font-family: 'Roboto', sans-serif;
+}
+
+
+/* Isso é muito mais sustentável do que ter que mudar a cor
+ cada vez que aparece em toda a sua folha de estilo. */
+
+
+
+/* Mixins
+==============================*/
+
+
+/* Se você achar que está escrevendo o mesmo código para mais de um
+ elemento, você pode querer reutilizá-lo facilmente. */
+
+.center {
+ display: block;
+ margin-left: auto;
+ margin-right: auto;
+ left: 0;
+ right: 0;
+}
+
+/* Você pode usar o mixin simplesmente adicionando o seletor como um estilo. */
+
+div {
+ .center;
+ background-color: @primary-color;
+}
+
+/* Que compilaria para: */
+
+.center {
+ display: block;
+ margin-left: auto;
+ margin-right: auto;
+ left: 0;
+ right: 0;
+}
+div {
+ display: block;
+ margin-left: auto;
+ margin-right: auto;
+ left: 0;
+ right: 0;
+ background-color: #a3a4ff;
+}
+
+/* Você pode omitir o código mixin de ser compilado adicionando parênteses
+ depois do seletor. */
+
+.center() {
+ display: block;
+ margin-left: auto;
+ margin-right: auto;
+ left: 0;
+ right: 0;
+}
+
+div {
+ .center;
+ background-color: @primary-color;
+}
+
+/* Que compilaria para: */
+div {
+ display: block;
+ margin-left: auto;
+ margin-right: auto;
+ left: 0;
+ right: 0;
+ background-color: #a3a4ff;
+}
+
+
+
+/* Aninhamento
+==============================*/
+
+
+/* Less permite aninhar seletores nos seletores. */
+
+ul {
+ list-style-type: none;
+ margin-top: 2em;
+
+ li {
+ background-color: #f00;
+ }
+}
+
+/* '&' será substituído pelo seletor pai. */
+/* Você também pode aninhar pseudo-classes. */
+/* Tenha em mente que o aninhamento excessivo tornará seu código menos sustentável.
+ As melhores práticas recomendam não ultrapassar 3 níveis de profundidade ao aninhar.
+ 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;
+}
+
+
+
+/* Functions
+==============================*/
+
+
+/* Less fornece funções que podem ser usadas para realizar uma variedade de
+ tarefas. Considere o seguinte: */
+
+/* Funções podem ser invocadas usando seu nome e passando os
+ argumentos requeridos. */
+
+body {
+ width: round(10.25px);
+}
+
+.header {
+ background-color: lighten(#000, 0.5);
+}
+
+.footer {
+ background-color: fadeout(#000, 0.25)
+}
+
+/* Compila para: */
+
+body {
+ width: 10px;
+}
+
+.header {
+ background-color: #010101;
+}
+
+.footer {
+ background-color: rgba(0, 0, 0, 0.75);
+}
+
+/* Você também pode definir suas próprias funções. Funções são muito semelhantes às
+ mixins. Ao tentar escolher entre uma função ou a um mixin, lembre-se
+ que mixins são melhores para gerar CSS, enquanto as funções são melhores para
+ lógica que pode ser usada em todo o seu código Less. Os exemplos na
+ seção 'Operadores Matemáticos' são candidatos ideais para se tornarem funções reutilizáveis. */
+
+/* Esta função calcula a média de dois números: */
+
+.average(@x, @y) {
+ @average-result: ((@x + @y) / 2);
+}
+
+div {
+ .average(16px, 50px); // "chama" o mixin
+ padding: @average-result; // use seu valor de "retorno"
+}
+
+/* Compila para: */
+
+div {
+ padding: 33px;
+}
+
+
+
+/* Estender (herança)
+==============================*/
+
+
+/* Estender é uma maneira de compartilhar as propriedades de um seletor com outro. */
+
+.display {
+ height: 50px;
+}
+
+.display-success {
+ &:extend(.display);
+ border-color: #22df56;
+}
+
+/* Compila para: */
+
+.display,
+.display-success {
+ height: 50px;
+}
+.display-success {
+ border-color: #22df56;
+}
+
+/* Estender uma instrução CSS é preferível para criar um mixin
+ por causa da maneira como agrupa as classes que compartilham
+ o mesmo estilo base. Se isso foi feito com um mixin, as propriedades
+ seriam duplicadas para cada declaração que
+ chamou o mixin. Embora isso não afete o seu fluxo de trabalho,
+ adicione o inchaço desnecessário aos arquivos criados pelo compilador Less. */
+
+
+
+/* Parciais e Importações
+==============================*/
+
+
+/* Less permite criar arquivos parciais. Isso pode ajudar a manter o seu
+ código Less modularizado. Arquivos parciais convencionalmente começam com um '_',
+ por exemplo. _reset.less. e são importados para um arquivo less principal que recebe
+ o css compilado. */
+
+/* Considere o seguinte CSS que vamos colocar em um arquivo chamado _reset.less */
+
+html,
+body,
+ul,
+ol {
+ margin: 0;
+ padding: 0;
+}
+
+/* Less disponibiliza @import que podem ser usadas para importar parciais em um arquivo.
+ Isso difere da declaração tradicional CSS @import que faz
+ outra solicitação HTTP para buscar o arquivo importado. Less leva o
+ arquivo importado e combina com o código compilado. */
+
+@import 'reset';
+
+body {
+ font-size: 16px;
+ font-family: Helvetica, Arial, Sans-serif;
+}
+
+/* Compila para: */
+
+html, body, ul, ol {
+ margin: 0;
+ padding: 0;
+}
+
+body {
+ font-size: 16px;
+ font-family: Helvetica, Arial, Sans-serif;
+}
+
+
+
+/* Operações Matemáticas
+==============================*/
+
+
+/* Less fornece os seguintes operadores: +, -, *, / e %. Estes podem
+ ser úteis para calcular valores diretamente nos seus arquivos Less
+ para usar valores que você já calculou manualmente. Abaixo está um exemplo
+ de como configurar um design 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;
+}
+
+/* Compila para: */
+
+body {
+ width: 100%;
+}
+
+.main-content {
+ width: 62.5%;
+}
+
+.sidebar {
+ width: 31.25%;
+}
+
+.gutter {
+ width: 6.25%;
+}
+
+
+```
+
+## Pratique Less
+
+Se você quiser praticar com Less no seu navegador, confira: * [Codepen](http://codepen.io/) * [LESS2CSS](http://lesscss.org/less-preview/)
+
+## Compatibilidade
+
+Less pode ser usado em qualquer projeto, desde que você tenha um programa para compilá-lo em CSS. Você deseja verificar
+se o CSS que você está usando é compatível com seus navegadores de destino.
+
+[QuirksMode CSS](http://www.quirksmode.org/css/) e [CanIUse](http://caniuse.com) são ótimos recursos para verificar a compatibilidade.
+
+## Leitura adicional
+* [Documentação Oficial](http://lesscss.org/features/)
+* [Less CSS - Guia do iniciante](http://www.hongkiat.com/blog/less-basic/)
diff --git a/pt-br/make-pt.html.markdown b/pt-br/make-pt.html.markdown
new file mode 100644
index 00000000..8e7603cc
--- /dev/null
+++ b/pt-br/make-pt.html.markdown
@@ -0,0 +1,242 @@
+---
+language: make
+contributors:
+ - ["Robert Steed", "https://github.com/robochat"]
+ - ["Stephan Fuhrmann", "https://github.com/sfuhrm"]
+filename: Makefile
+
+lang: pt-br
+---
+
+Um Makefile define um gráfico de regras para criar um alvo (ou alvos). Sua finalidade é fazer o mínimo de trabalho necessário para atualizar um alvo para a versão mais recente da fonte. Famosamente escrito ao longo de um fim de semana por Stuart Feldman em 1976, ainda é amplamente usada (particularmente no Unix e no Linux) apesar de muitos concorrentes e críticas.
+
+Existem muitas variedades de make na existência, no entanto, este artigo pressupõe que estamos usando o GNU make, que é o padrão no Linux.
+
+```make
+
+# Comentários podem ser escritos assim.
+
+# O arquivo deve ser nomeado Makefile e então pode ser executado como `make <alvo>`.
+# Caso contrário, nós usamos `make -f "nome-do-arquivo" <alvo>`.
+
+# Aviso - use somente TABS para identar em Makefiles, nunca espaços!
+
+#-----------------------------------------------------------------------
+# Noções básicas
+#-----------------------------------------------------------------------
+
+# Regras são do formato
+# alvo: <pré-requisito>
+# onde os pré-requisitos são opcionais.
+
+# Uma regra - esta regra só será executada se o arquivo0.txt não existir.
+arquivo0.txt:
+ echo "foo" > arquivo0.txt
+ # Mesmo os comentários nestas seções da 'receita' são passados ​​para o shell.
+ # Experimentar `make arquivo0.txt` or simplyou simplesmente `make` - primeira regra é o padrão.
+
+# Esta regra só será executada se arquivo0.txt for mais recente que arquivo1.txt.
+arquivo1.txt: arquivo0.txt
+ cat arquivo0.txt > arquivo1.txt
+ # se as mesmas regras de citação do shell.
+ @cat arquivo0.txt >> arquivo1.txt
+ # @ pára o comando de ser ecoado para stdout.
+ -@echo 'hello'
+ # - significa que make continuará em caso de erro.
+ # Experimentar `make arquivo1.txt` na linha de comando.
+
+# Uma regra pode ter vários alvos e vários pré-requisitos
+arquivo2.txt arquivo3.txt: arquivo0.txt arquivo1.txt
+ touch arquivo2.txt
+ touch arquivo3.txt
+
+# Make vai reclamar sobre várias receitas para a mesma regra. Esvaziar
+# receitas não contam e podem ser usadas para adicionar novas dependências.
+
+#-----------------------------------------------------------------------
+# Alvos falsos
+#-----------------------------------------------------------------------
+
+# Um alvo falso. Qualquer alvo que não seja um arquivo.
+# Ele nunca será atualizado, portanto, o make sempre tentará executá-lo.
+all: maker process
+
+# Podemos declarar as coisas fora de ordem.
+maker:
+ touch ex0.txt ex1.txt
+
+# Pode evitar quebrar regras falsas quando um arquivo real tem o mesmo nome
+.PHONY: all maker process
+# Este é um alvo especial. Existem vários outros.
+
+# Uma regra com dependência de um alvo falso sempre será executada
+ex0.txt ex1.txt: maker
+
+# Alvos falsos comuns são: todos fazem instalação limpa ...
+
+#-----------------------------------------------------------------------
+# Variáveis ​​Automáticas e Curingas
+#-----------------------------------------------------------------------
+
+process: Arquivo*.txt # Usando um curinga para corresponder nomes de arquivos
+ @echo $^ # $^ é uma variável que contém a lista de pré-requisitos
+ @echo $@ # imprime o nome do alvo
+ #(fpara várias regras alvo, $@ é o que causou a execução da regra)
+ @echo $< # o primeiro pré-requisito listado
+ @echo $? # somente as dependências que estão desatualizadas
+ @echo $+ # todas as dependências, incluindo duplicadas (ao contrário do normal)
+ #@echo $| # todos os pré-requisitos 'somente pedidos'
+
+# Mesmo se dividirmos as definições de dependência de regra, $^ vai encontrá-los
+process: ex1.txt arquivo0.txt
+# ex1.txt será encontrado, mas arquivo0.txt será desduplicado.
+
+#-----------------------------------------------------------------------
+# Padrões
+#-----------------------------------------------------------------------
+
+# Pode ensinar make a converter certos arquivos em outros arquivos.
+
+%.png: %.svg
+ inkscape --export-png $^
+
+# As regras padrões só farão qualquer coisa se decidirem criar o alvo.
+
+# Os caminhos de diretório são normalmente ignorados quando as regras de
+# padrões são correspondentes. Mas make tentará usar a regra mais
+# apropriada disponível.
+small/%.png: %.svg
+ inkscape --export-png --export-dpi 30 $^
+
+# make utilizará a última versão para uma regra de padrão que encontrar.
+%.png: %.svg
+ @echo esta regra é escolhida
+
+# No entanto, o make usará a primeira regra padrão que pode se tornar o alvo
+%.png: %.ps
+ @echo esta regra não é escolhida se *.svg and *.ps estão ambos presentes
+
+# make já tem algumas regras padrões embutidas. Por exemplo, ele sabe
+# como transformar arquivos *.c em arquivos *.o.
+
+# Makefiles antigos podem usar regras de sufixo em vez de regras padrões
+.png.ps:
+ @echo essa regra é semelhante a uma regra de padrão.
+
+# make sobre a regra de sufixo
+.SUFFIXES: .png
+
+#-----------------------------------------------------------------------
+# Variáveis
+#-----------------------------------------------------------------------
+# aka. macros
+
+# As variáveis ​​são basicamente todos os tipos de string
+
+name = Ted
+name2="Sarah"
+
+echo:
+ @echo $(name)
+ @echo ${name2}
+ @echo $name # Isso não funcionará, tratado como $ (n)ame.
+ @echo $(name3) # Variáveis ​​desconhecidas são tratadas como strings vazias.
+
+# Existem 4 lugares para definir variáveis.
+# Em ordem de prioridade, do maior para o menor:
+# 1: argumentos de linha de comando
+# 2: Makefile
+# 3: variáveis ​​de ambiente do shell - faça importações automaticamente.
+# 4: make tem algumas variáveis ​​predefinidas
+
+name4 ?= Jean
+# Somente defina a variável se a variável de ambiente ainda não estiver definida.
+
+override name5 = David
+# Pára os argumentos da linha de comando de alterar essa variável.
+
+name4 +=grey
+# Anexar valores à variável (inclui um espaço).
+
+# Valores variáveis ​​específicos de padrões (extensão GNU).
+echo: name2 = Sara # Verdadeiro dentro da regra de correspondência
+ # e também dentro de suas recursivas dependências
+ # (exceto que ele pode quebrar quando seu gráfico ficar muito complicado!)
+
+# Algumas variáveis ​​definidas automaticamente pelo make
+echo_inbuilt:
+ echo $(CC)
+ echo ${CXX}
+ echo $(FC)
+ echo ${CFLAGS}
+ echo $(CPPFLAGS)
+ echo ${CXXFLAGS}
+ echo $(LDFLAGS)
+ echo ${LDLIBS}
+
+#-----------------------------------------------------------------------
+# Variáveis 2
+#-----------------------------------------------------------------------
+
+# O primeiro tipo de variáveis ​​é avaliado a cada vez que elas são usadas.
+# TIsso pode ser caro, então existe um segundo tipo de variável que é
+# avaliado apenas uma vez. (Esta é uma extensão do GNU make)
+
+var := hello
+var2 ::= $(var) hello
+#:= e ::= são equivalentes.
+
+# Essas variáveis ​​são avaliadas procedimentalmente (na ordem em que
+# aparecem), quebrando assim o resto da línguagem!
+
+# Isso não funciona
+var3 ::= $(var4) and good luck
+var4 ::= good night
+
+#-----------------------------------------------------------------------
+# Funções
+#-----------------------------------------------------------------------
+
+# make tem muitas funções disponíveis.
+
+sourcefiles = $(wildcard *.c */*.c)
+objectfiles = $(patsubst %.c,%.o,$(sourcefiles))
+
+# O formato é $(func arg0,arg1,arg2...)
+
+# Alguns exemplos
+ls: * src/*
+ @echo $(filter %.txt, $^)
+ @echo $(notdir $^)
+ @echo $(join $(dir $^),$(notdir $^))
+
+#-----------------------------------------------------------------------
+# Diretivas
+#-----------------------------------------------------------------------
+
+# Inclua outros makefiles, úteis para código específico da plataforma
+include foo.mk
+
+sport = tennis
+# Compilação condicional
+report:
+ifeq ($(sport),tennis)
+ @echo 'game, set, match'
+else
+ @echo "They think it's all over; it is now"
+endif
+
+# Há também ifneq, ifdef, ifndef
+
+foo = true
+
+ifdef $(foo)
+bar = 'hello'
+endif
+```
+
+### More Resources
+
++ [documentação gnu make](https://www.gnu.org/software/make/manual/)
++ [tutorial de carpintaria de software](http://swcarpentry.github.io/make-novice/)
++ aprenda C da maneira mais difícil [ex2](http://c.learncodethehardway.org/book/ex2.html) [ex28](http://c.learncodethehardway.org/book/ex28.html)
diff --git a/pt-br/markdown-pt.html.markdown b/pt-br/markdown-pt.html.markdown
index f22093f9..c2aa515d 100644
--- a/pt-br/markdown-pt.html.markdown
+++ b/pt-br/markdown-pt.html.markdown
@@ -14,7 +14,7 @@ escrever sintaxe que converte facilmente em HTML (hoje, suporta outros formatos
Dê-me feedback tanto quanto você quiser! / Sinta-se livre para a garfar (fork) e
puxar o projeto (pull request)
-```markdown
+```md
<!-- Markdown é um superconjunto do HTML, de modo que qualquer arvquivo HTML é
um arquivo Markdown válido, isso significa que nós podemos usar elementos HTML
em Markdown, como o elemento de comentário, e eles não serão afetados pelo analisador
diff --git a/pt-br/matlab-pt.html.markdown b/pt-br/matlab-pt.html.markdown
index eb660d4c..5ed6b7ba 100644
--- a/pt-br/matlab-pt.html.markdown
+++ b/pt-br/matlab-pt.html.markdown
@@ -206,8 +206,7 @@ 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
+transpose(A) % Transposta a matriz, que é o mesmo de: A.'
ctranspose(A) % Transposta a matriz
% (a transposta, seguida pelo conjugado complexo de cada elemento)
diff --git a/pt-br/perl-pt.html.markdown b/pt-br/perl-pt.html.markdown
index cc07a2ec..217861f9 100644
--- a/pt-br/perl-pt.html.markdown
+++ b/pt-br/perl-pt.html.markdown
@@ -21,7 +21,7 @@ Perl 5 roda em mais de 100 plataformas, de portáteis a mainframes e é adequada
# Variáveis iniciam com um sigilo, que é um símbolo que mostra o tipo.
# Um nome de variável válido começa com uma letra ou sublinhado,
-# seguido por qualquer número de letras, números ou sublinhados.
+# seguido por qualquer quantidade de letras, números ou sublinhados.
### Perl has three main variable types: $scalar, @array, e %hash.
@@ -52,10 +52,10 @@ my %fruta_cor = (
banana => "amarelo",
);
-# Scalars, arrays and hashes são documentados mais profundamentes em perldata.
+# Scalars, arrays and hashes são documentados mais profundamente em perldata.
# (perldoc perldata).
-# Mais tipos de dados complexos podem ser construídas utilizando referências,
+# Mais tipos de dados complexos podem ser construídos utilizando referências,
# o que permite que você crie listas e hashes dentro de listas e hashes.
#### Condicionais e construtores de iteração
diff --git a/pt-br/pyqt-pt.html.markdown b/pt-br/pyqt-pt.html.markdown
index 10d55784..40fe82d5 100644
--- a/pt-br/pyqt-pt.html.markdown
+++ b/pt-br/pyqt-pt.html.markdown
@@ -10,7 +10,7 @@ lang: pt-br
---
**Qt** é amplamente conhecido como um framework para desenvolvimento de
-software multi-plataforma que pode rodar em vários outras plataformas de
+software multi-plataforma que pode rodar em várias outras plataformas de
softwares e hardwares com pouca ou nenhuma alteração no código, enquanto mantém
o poder e a velocidade de uma aplicação nativa. Embora o **Qt** tenha sido
originalmente escrito em *C++*.
diff --git a/pt-br/rust-pt.html.markdown b/pt-br/rust-pt.html.markdown
index 8134d3c5..b2bab214 100644
--- a/pt-br/rust-pt.html.markdown
+++ b/pt-br/rust-pt.html.markdown
@@ -11,7 +11,7 @@ Rust é uma linguagem de programação desenvolvida pelo Mozilla Research. Rust
combina controle de baixo nível sobre o desempenho com facilidades de alto
nível e garantias de segurança.
-Ele atinge esse objetico sem necessitar de um coletor de lixo ou um processo
+Ele atinge esse objetivo sem necessitar de um coletor de lixo ou um processo
*runtime*, permitindo que se use bibliotecas Rust em substituição a bibliotecas
em C.
@@ -27,7 +27,7 @@ noite. Rust adotou um modelo de versões *train-based* com novas versões
regularmente liberadas a cada seis semanas. A versão 1.1 beta de Rust foi
disponibilizada ao mesmo tempo que a versão 1.0.
-Apesar de Rust ser uma linguagem mais e baixo nível, Rust tem alguns conceitos
+Apesar de Rust ser uma linguagem mais de baixo nível, Rust tem alguns conceitos
funcionais geralmente encontradas em linguagens de alto nível. Isso faz Rust
não apenas rápido, mas também fácil e eficiente para programar.
@@ -68,7 +68,7 @@ fn main() {
// Em geral, o compilador Rust consegue inferir qual o tipo de uma
// variável, então você não tem que escrever uma anotação explícita de tipo.
// Ao longo desse tutorial, os tipos serão explicitamente anotados em
- // muitos lugares, mas apenas com propóstico demonstrativo. A inferência de
+ // muitos lugares, mas apenas com propósito demonstrativo. A inferência de
// tipos pode gerenciar isso na maioria das vezes.
let implicit_x = 1;
let implicit_f = 1.3;
diff --git a/pt-br/solidity-pt.html.markdown b/pt-br/solidity-pt.html.markdown
index 37d15bf2..d4555fa7 100644
--- a/pt-br/solidity-pt.html.markdown
+++ b/pt-br/solidity-pt.html.markdown
@@ -1,6 +1,6 @@
---
language: Solidity
-filename: learnSolidity.sol
+filename: learnSolidity-br.sol
contributors:
- ["Nemil Dalal", "https://www.nemil.com"]
- ["Joseph Chow", ""]
diff --git a/pt-br/vim-pt.html.markdown b/pt-br/vim-pt.html.markdown
index 51eddb48..d7617bbe 100644
--- a/pt-br/vim-pt.html.markdown
+++ b/pt-br/vim-pt.html.markdown
@@ -13,7 +13,7 @@ filename: LearnVim-pt.txt
[Vim](http://www.vim.org)
(Vi IMproved - Vi Melhorado) é um clone do editor vi para Unix. Ele é um
editor de texto projetado para ter velocidade e produtividade, e está presente
-na maioria dos systemas UNIX. O editor tem um grande número de atalhos de teclado
+na maioria dos sistemas UNIX. O editor tem um grande número de atalhos de teclado
para agilizar a navegação para pontos específicos no arquivo, além de edição rápida.
## Navegação do Vim: o básico
@@ -25,7 +25,7 @@ para agilizar a navegação para pontos específicos no arquivo, além de ediçÃ
:wq # Salva o arquivo e fecha o vim
:q! # Fecha o vim e descarta as alterações no arquivo
# ! *força* :q a executar, fechando o vim sem salvar antes
- :x # Salvar o arquivo e fechao vim (atalho para :wq)
+ :x # Salva o arquivo e fecha o vim (atalho para :wq)
u # Desfazer
CTRL+R # Refazer
@@ -62,7 +62,7 @@ para agilizar a navegação para pontos específicos no arquivo, além de ediçÃ
# Movendo por palavras
- w # Move o cursor uma palavra a diante
+ w # Move o cursor uma palavra adiante
b # Move o cursor uma palavra atrás
e # Move o cursor ao fim da palavra atual
diff --git a/pt-br/visualbasic-pt.html.markdown b/pt-br/visualbasic-pt.html.markdown
index 76cca567..2a7205cd 100644
--- a/pt-br/visualbasic-pt.html.markdown
+++ b/pt-br/visualbasic-pt.html.markdown
@@ -8,16 +8,16 @@ lang: pt-br
filename: learnvisualbasic-pt.vb
---
-```vb
+```
Module Module1
module Module1
Sub Main ()
' Uma visão geral de console de aplicativos do Visual Basic antes de
- ' mergulharmos mais profundamente na linguagem
+ ' mergulharmos mais profundamente na linguagem.
' Aspas simples começam comentários.
- ' Para Navegar este tutorial dentro do compilador do Visual Basic,
+ ' Para navegar neste tutorial dentro do compilador do Visual Basic,
' eu criei um sistema de navegação.
' Este sistema de navegação vai ser explicado conforme avançarmos no
' tutorial, e você vai entender o que isso significa.
@@ -93,16 +93,16 @@ module Module1
Private Sub HelloWorldInput ()
Console.Title = " Olá Mundo YourName | Saiba X em Y Minutes"
' Variáveis
- 'Os dados inseridos por um usuário precisa ser armazenada .
+ 'Os dados inseridos por um usuário precisam ser armazenados.
' As variáveis ​​também começar com um Dim e terminar com um Como VariableType .
- ' Neste tutorial, nós queremos saber o que o seu nome, e faça o programa
+ ' Neste tutorial, nós queremos saber qual é o seu nome, e faça o programa
' Responder ao que é dito.
Nome de usuário Dim As String
" Nós usamos string como string é uma variável de texto baseado .
Console.WriteLine (" Olá, Qual é o seu nome? ") ' Peça ao usuário seu nome.
- username = Console.ReadLine () ' armazena o nome usuários.
- Console.WriteLine (" Olá " + nome do usuário) " A saída é Olá ' Seu nome '
+ username = Console.ReadLine () ' armazena o nome do usuário.
+ Console.WriteLine (" Olá " + username) ' A saída é "Olá < seu nome >".
Console.ReadLine () ' Outsputs acima.
' O código acima irá lhe fazer uma pergunta seguiu imprimindo sua resposta.
" Outras variáveis ​​incluem Integer e usamos inteiro para números inteiros.
diff --git a/pt-br/whip-pt.html.markdown b/pt-br/whip-pt.html.markdown
new file mode 100644
index 00000000..989bae05
--- /dev/null
+++ b/pt-br/whip-pt.html.markdown
@@ -0,0 +1,247 @@
+---
+language: whip
+contributors:
+ - ["Tenor Biel", "http://github.com/L8D"]
+ - ["Saurabh Sandav", "http://github.com/SaurabhSandav"]
+author: Tenor Biel
+author_url: http://github.com/L8D
+translators:
+ - ["Paulo Henrique Rodrigues Pinheiro", "https://github.com/paulohrpinheiro"]
+lang: pt-br
+filename: whip-pt.lisp
+---
+
+Whip é um dialeto de Lisp feito para construir scripts e trabalhar com
+conceitos mais simples.
+Ele também copia muitas funções e sintaxe de Haskell (uma linguagem não correlata)
+
+Esse documento foi escrito pelo próprio autor da linguagem. Então é isso.
+
+```scheme
+; Comentário são como em Lisp. Pontos-e-vírgulas...
+
+; A maioria das declarações de primeiro nível estão dentro de "listas"
+; que nada mais são que coisas entre parêntesis separadas por espaços em branco
+nao_é_uma_lista
+(uma lista)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; 1. Números, texto e operadores
+
+; Whip tem um tipo numérico (que é um double de 64 bits IEE 754, do JavaScript)
+3 ; => 3
+1.5 ; => 1.5
+
+; Funções são chamadas se elas são o primeiro elemento em uma lista
+(funcao_chamada argumentos)
+
+; A maioria das operações são feitas com funções
+; Todas as funções aritméticas básicas são bem diretas
+(+ 1 1) ; => 2
+(- 2 1) ; => 1
+(* 1 2) ; => 2
+(/ 2 1) ; => 2
+; até mesmo o módulo
+(% 9 4) ; => 1
+; Divisão não inteira ao estilo JavaScript.
+(/ 5 2) ; => 2.5
+
+; Aninhamento de listas funciona como esperado.
+(* 2 (+ 1 3)) ; => 8
+
+; Há um tipo boleano.
+true
+false
+
+; Textos são criados com ".
+"Hello, world"
+
+; Caracteres são criados com '.
+'a'
+
+; Para negação usa-se a função 'not'.
+(not true) ; => false
+(not false) ; => true
+
+; Mas a maioria das funções não-haskell tem atalhos
+; o não atalho é um '!'.
+(! (! true)) ; => true
+
+; Igualdade é `equal` ou `=`.
+(= 1 1) ; => true
+(equal 2 1) ; => false
+
+; Por exemplo, inigualdade pode ser verificada combinando as funções
+;`not` e `equal`.
+(! (= 2 1)) ; => true
+
+; Mais comparações
+(< 1 10) ; => true
+(> 1 10) ; => false
+; e suas contra partes para texto.
+(lesser 1 10) ; => true
+(greater 1 10) ; => false
+
+; Texto pode ser concatenado com +.
+(+ "Hello " "world!") ; => "Hello world!"
+
+; Você pode usar as características comparativas do JavaScript.
+(< 'a' 'b') ; => true
+; ... e coerção de tipos
+(= '5' 5)
+
+; As funções `at` ou `@` acessarão caracteres de um texto, começando em 0.
+(at 0 'a') ; => 'a'
+(@ 3 "foobar") ; => 'b'
+
+; Também existem as variáveis `null` e `undefined`.
+null ; usada para indicar a ausência de algum valor
+undefined ; usada para indicar que um valor não foi informado
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; 2. Variáveis, matrizes e dicionários
+
+; Variáveis são declaradas com as funções `def` ou `let`.
+; Variáveis que não tiveram valor atribuído serão `undefined`.
+(def some_var 5)
+; `def` deixará a variável no contexto global.
+; `let` deixará a variável no contexto local, e tem uma sintaxe estranha.
+(let ((a_var 5)) (+ a_var 5)) ; => 10
+(+ a_var 5) ; = undefined + 5 => undefined
+
+; Matrizes são listas de valores de qualquer tipo.
+; Elas basicamente são listas sem funções no início
+(1 2 3) ; => [1, 2, 3] (sintaxe JavaScript)
+
+; Dicionários em Whip são o equivalente a 'object' em JavaScript ou
+; 'dict' em python ou 'hash' em Ruby: eles s]ão uma coleção desordenada
+de pares chave-valor.
+{"key1" "value1" "key2" 2 3 3}
+
+; Chaves podem ser apenas identificadores, números ou texto.
+(def my_dict {my_key "my_value" "my other key" 4})
+; Mas em Whip, dicionários são parceados como: valor, espaço, valor;
+; com mais espaço entre cada. Então isso significa que
+{"key" "value"
+"another key"
+1234
+}
+é avaliado da mesma forma que
+{"key" "value" "another key" 1234}
+
+; Dicionários podem ser acessados usando a função `at`
+; (como em texto e listas)
+(@ "my other key" my_dict) ; => 4
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; 3. Lógica e controle de fluxo
+
+; A função `if` é muito simples, ainda que muito diferente do que em muitas
+linguagens imperativas.
+(if true "returned if first arg is true" "returned if first arg is false")
+; => "returned if first arg is true"
+
+; E por conta do legado operador ternário
+; `?` é o atalho não utilizado para `if`.
+(? false true false) ; => false
+
+; `both` é uma declaração lógica `and`, e `either` é o `or` lógico.
+(both true true) ; => true
+(both true false) ; => false
+(either true false) ; => true
+(either false false) ; => false
+; E seus atalhos são
+; & => both
+; ^ => either
+(& true true) ; => true
+(^ false true) ; => true
+
+;;;;;;;;;
+; Lambdas
+
+; Lambdas em Whip são declaradas com as funções `lambda` ou `->`.
+; E funções são na verdade lambdas com nomes.
+(def my_function (-> (x y) (+ (+ x y) 10)))
+; | | | |
+; | | | valor retornado (com escopo contento argumentos)
+; | | argumentos
+; | declaração de funções lambda
+; |
+; nome do lambda a ser declarado
+
+(my_function 10 10) ; = (+ (+ 10 10) 10) => 30
+
+; Obviamente, todos os lambdas por definição são anônimos e
+; tecnicamente sempre usados anonimamente. Redundância.
+((lambda (x) x) 10) ; => 10
+
+;;;;;;;;;;;;;;;;
+; Comprehensions
+
+; `range` or `..` geram uma lista dos números para
+; cada número entre seus dois argumentos.
+(range 1 5) ; => (1 2 3 4 5)
+(.. 0 2) ; => (0 1 2)
+
+; `map` aplica seu primeiro argumento (que deve ser um lambda/função)
+; a cada item dos argumentos seguintes (que precisa ser uma lista)
+(map (-> (x) (+ x 1)) (1 2 3)) ; => (2 3 4)
+
+; Reduce
+(reduce + (.. 1 5))
+; equivalente a
+((+ (+ (+ 1 2) 3) 4) 5)
+
+; Nota: map e reduce não possuem atalhos
+
+; `slice` ou `\` é similar ao .slice() do JavaScript
+; mas veja que ele pega uma lista como primeiro argumento, não o último.
+(slice (.. 1 5) 2) ; => (3 4 5)
+(\ (.. 0 100) -5) ; => (96 97 98 99 100)
+
+; `append` ou `<<` são auto explicativos
+(append 4 (1 2 3)) ; => (1 2 3 4)
+(<< "bar" ("foo")) ; => ("foo" "bar")
+
+; Length é auto explicativo.
+(length (1 2 3)) ; => 3
+(_ "foobar") ; => 6
+
+;;;;;;;;;;;;;;;
+; Delicadezas Haskell
+
+; Primeiro item de uma lista
+(head (1 2 3)) ; => 1
+; Pega do segundo ao último elemento de uma lista
+(tail (1 2 3)) ; => (2 3)
+; Último item de uma lista
+(last (1 2 3)) ; => 3
+; Contrário de `tail`
+(init (1 2 3)) ; => (1 2)
+; Pega do primeiro até o elemento especificado da lista
+(take 1 (1 2 3 4)) ; (1 2)
+; Contrário de `take`
+(drop 1 (1 2 3 4)) ; (3 4)
+; Menos valor em uma lista
+(min (1 2 3 4)) ; 1
+; Maior valor em uma lista
+(max (1 2 3 4)) ; 4
+; Verifica se o valor está em uma lista ou objeto
+(elem 1 (1 2 3)) ; true
+(elem "foo" {"foo" "bar"}) ; true
+(elem "bar" {"foo" "bar"}) ; false
+; Inverte a ordem de uma lista
+(reverse (1 2 3 4)) ; => (4 3 2 1)
+; Verifica se o valor é par ou ímpar
+(even 1) ; => false
+(odd 1) ; => true
+; Separa um texto cortando por espaço em branco
+(words "foobar nachos cheese") ; => ("foobar" "nachos" "cheese")
+; Junta lista de textos
+(unwords ("foo" "bar")) ; => "foobar"
+; Sucessor e predecessor
+(pred 21) ; => 20
+(succ 20) ; => 21
+```
+
+Para mais informação, verifique o [repositório](http://github.com/L8D/whip)