summaryrefslogtreecommitdiffhomepage
path: root/pt-br
diff options
context:
space:
mode:
Diffstat (limited to 'pt-br')
-rw-r--r--pt-br/c++-pt.html.markdown7
-rw-r--r--pt-br/cmake-pt.html.markdown178
-rw-r--r--pt-br/cypher-pt.html.markdown250
-rw-r--r--pt-br/dynamic-programming-pt.html.markdown10
-rw-r--r--pt-br/factor-pt.html.markdown184
-rw-r--r--pt-br/html-pt.html.markdown125
-rw-r--r--pt-br/less-pt.html.markdown390
-rw-r--r--pt-br/make-pt.html.markdown242
8 files changed, 1376 insertions, 10 deletions
diff --git a/pt-br/c++-pt.html.markdown b/pt-br/c++-pt.html.markdown
index 2c15e92c..42a29991 100644
--- a/pt-br/c++-pt.html.markdown
+++ b/pt-br/c++-pt.html.markdown
@@ -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/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/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/dynamic-programming-pt.html.markdown b/pt-br/dynamic-programming-pt.html.markdown
index 84b055d9..518660a3 100644
--- a/pt-br/dynamic-programming-pt.html.markdown
+++ b/pt-br/dynamic-programming-pt.html.markdown
@@ -63,13 +63,11 @@ grafo acíclico dirigido.
```
## 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
-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/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/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/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)