summaryrefslogtreecommitdiffhomepage
path: root/pt-br
diff options
context:
space:
mode:
Diffstat (limited to 'pt-br')
-rw-r--r--pt-br/amd.html.markdown218
-rw-r--r--pt-br/asciidoc-pt.html.markdown129
-rw-r--r--pt-br/asymptotic-notation-pt.html.markdown159
-rw-r--r--pt-br/asymptoticnotation-pt.html.markdown161
-rw-r--r--pt-br/bash-pt.html.markdown282
-rw-r--r--pt-br/bf.html.markdown (renamed from pt-br/brainfuck-pt.html.markdown)2
-rw-r--r--pt-br/binary-search-pt.html.markdown77
-rw-r--r--pt-br/c++-pt.html.markdown81
-rw-r--r--pt-br/c-pt.html.markdown2
-rw-r--r--pt-br/clojure-macros-pt.html.markdown2
-rw-r--r--pt-br/csharp.html.markdown896
-rw-r--r--pt-br/dynamic-programming-pt.html.markdown76
-rw-r--r--pt-br/elixir.html.markdown412
-rw-r--r--pt-br/elm-pt.html.markdown384
-rw-r--r--pt-br/git-pt.html.markdown46
-rw-r--r--pt-br/haskell-pt.html.markdown2
-rw-r--r--pt-br/hy-pt.html.markdown2
-rw-r--r--pt-br/java-pt.html.markdown70
-rw-r--r--pt-br/javascript-pt.html.markdown4
-rw-r--r--pt-br/jquery-pt.html.markdown131
-rw-r--r--pt-br/julia-pt.html.markdown748
-rw-r--r--pt-br/markdown-pt.html.markdown8
-rw-r--r--pt-br/paren-pt.html.markdown196
-rw-r--r--pt-br/php-composer-pt.html.markdown184
-rw-r--r--pt-br/php-pt.html.markdown66
-rw-r--r--pt-br/python3-pt.html.markdown746
-rw-r--r--pt-br/ruby-ecosystem-pt.html.markdown147
-rw-r--r--pt-br/ruby-pt.html.markdown68
-rw-r--r--pt-br/scala-pt.html.markdown668
-rw-r--r--pt-br/self-pt.html.markdown165
-rw-r--r--pt-br/swift-pt.html.markdown2
-rw-r--r--pt-br/tmux-pt.html.markdown82
-rw-r--r--pt-br/typescript-pt.html.markdown179
-rw-r--r--pt-br/vim-pt.html.markdown239
-rw-r--r--pt-br/yaml-pt.html.markdown142
35 files changed, 6614 insertions, 162 deletions
diff --git a/pt-br/amd.html.markdown b/pt-br/amd.html.markdown
new file mode 100644
index 00000000..38c1f70f
--- /dev/null
+++ b/pt-br/amd.html.markdown
@@ -0,0 +1,218 @@
+---
+category: tool
+tool: amd
+contributors:
+ - ["Frederik Ring", "https://github.com/m90"]
+translators:
+ - ["Felipe Tarijon", "http://nanoincub.com/"]
+lang: pt-br
+filename: learnamd-pt.js
+---
+
+## Começando com AMD
+
+A API de Definição de Módulos Assíncrona **Asynchronous Module Definition**
+especifica um mecanismo para definição de módulos em JavaScript para os quais o
+módulo e suas dependências podem ser carregados de forma assíncrona. Isso é
+particularmente bem adequado para o ambiente do browser onde o carregamento de
+módulos de forma síncrona fica sujeito a problemas de performance, usabilidade,
+debugging e problemas de acesso em requisições cross-domain.
+
+### Conceito básico
+```javascript
+// O básico da API de AMD consiste de nada mais que dois métodos: `define` e `require`
+// e isso é tudo sobre a definição de módulo e consumo:
+// `define(id?, dependências?, factory)` define um módulo
+// `require(dependências, callback)` importa uma série de dependências e
+// consome elas no callback passado como parâmetro.
+
+// Vamos começar usando o define para definir um novo módulo
+// que não tem dependências. Nós vamos fazer isso passando um nome
+// e uma função factory para definir:
+define('awesomeAMD', function(){
+ var isAMDAwesome = function(){
+ return true;
+ };
+ // O valor retornado da função de factory do módulo é
+ // o que os outros módulos ou chamadas de require irão
+ // receber quando requisitarem nosso módulo `awesomeAMD`.
+ // O valor exportado pode ser qualquer coisa, (construtor) funções,
+ // objetos, primitives, até mesmo undefined (apesar de que não irão ajudar muito).
+ return isAMDAwesome;
+});
+
+// Agora, vamos definir outro módulo que depende do nosso módulo `awesomeAMD`.
+// Perceba que existe um argumento adicional definindo nossas dependências do
+// módulo agora:
+define('loudmouth', ['awesomeAMD'], function(awesomeAMD){
+ // dependências serão passadas como argumentos da factory
+ // na ordem que elas forem especificadas
+ var tellEveryone = function(){
+ if (awesomeAMD()){
+ alert('Isso é tãaaao loko!');
+ } else {
+ alert('Bem estúpido, né não?');
+ }
+ };
+ return tellEveryone;
+});
+
+// Agora que nós sabemos como usar o define, vamos usar o `require` para
+// começar nosso programa. A assinatura do `require` é `(arrayDedependências, callback)`.
+require(['loudmouth'], function(loudmouth){
+ loudmouth();
+});
+
+// Para fazer esse tutorial executável, vamos implementar uma versão muito básica
+// (não-assíncrona) de AMD bem aqui nesse lugar:
+function define(nome, deps, factory){
+ // perceba como os módulos sem dependências são manipulados
+ define[nome] = require(factory ? deps : [], factory || deps);
+}
+
+function require(deps, callback){
+ var args = [];
+ // primeiro vamos recuperar todas as dependências necessárias
+ // pela chamada requerida
+ for (var i = 0; i < deps.length; i++){
+ args[i] = define[deps[i]];
+ }
+ // corresponder todas as dependências da função de callback
+ return callback.apply(null, args);
+}
+// você pode ver esse código em ação aqui: http://jsfiddle.net/qap949pd/
+```
+
+### Uso na vida real com require.js
+
+Em contraste com o exemplo introdutório, `require.js` (a biblioteca mais popular de AMD) na verdade implementa o **A** do **AMD**, permitindo que você carregue os módulos e suas
+dependências via XHR:
+
+```javascript
+/* file: app/main.js */
+require(['modules/algumaClasse'], function(AlgumaClasse){
+ // o callback é deferido até que a dependencia seja carregada
+ var coisa = new AlgumaClasse();
+});
+console.log('Então aqui estamos nós, esperando!'); // isso vai rodar primeiro
+```
+
+Por convenção, você geralmente guarda um módulo em um arquivo. `require.js` pode resolver nome de módulos baseado no caminho das pastas, então você não precisa nomear os seus módulos, mas sim simplesmente referenciar eles usando sua origem. No exemplo `algumaClasse` é adotado a pasta `modules`, relativa a configuração da sua `baseUrl`:
+
+* app/
+ * main.js
+ * modules/
+ * algumaClasse.js
+ * algunsHelpers.js
+ * ...
+ * daos/
+ * coisas.js
+ * ...
+
+Isso significa que nós podemos definir `algumaClasse` sem especificar o id de um módulo:
+
+```javascript
+/* arquivo: app/modules/algumaClasse.js */
+define(['daos/coisas', 'modules/algunsHelpers'], function(coisasDao, helpers){
+ // definição de módulo, claro, irá acontecer também de forma assíncrona
+ function AlgumaClasse(){
+ this.metodo = function(){/**/};
+ // ...
+ }
+ return AlgumaClasse;
+});
+```
+Para alterar o comportamento padrão de mapeamento de caminho de pastas utilize
+`requirejs.config(configObj)` em seu `main.js`:
+
+```javascript
+/* arquivo: main.js */
+requirejs.config({
+ baseUrl : 'app',
+ paths : {
+ // você pode também carregar módulos de outros locais
+ jquery : '//ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min',
+ coolLibFromBower : '../bower_components/cool-lib/coollib'
+ }
+});
+require(['jquery', 'coolLibFromBower', 'modules/algunsHelpers'], function($, coolLib, helpers){
+ // um arquivo `main` precisa chamar o require pelo menos uma vez,
+ // caso contrário, o código jamais rodará
+ 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:
+
+```html
+<!DOCTYPE html>
+<html>
+<head>
+ <title>Umas 100 tags de script? Nunca mais!</title>
+</head>
+<body>
+ <script src="require.js" data-main="app/main"></script>
+</body>
+</html>
+```
+
+### Otimizando um projeto inteiro utilizando r.js
+
+Muitas pessoas preferem usar AMD para sanar a organização do código durante o desenvolvimento, mas continuam querendo colocar um único arquivo de script em produção ao invés de realizarem centenas de requisições XHRs no carregamento da página.
+
+`require.js` vem com um script chamado `r.js` (que você vai provavelmente rodar em node.js, embora Rhino suporte também) que você pode analisar o gráfico de dependências de seu projeto, e fazer em um único arquivo contendo todos os seus módulos (corretamente nomeados), minificados e prontos para serem consumidos.
+
+Instale-o utilizando `npm`:
+```shell
+$ npm install requirejs -g
+```
+
+Agora você pode alimentá-lo com um arquivo de configuração:
+```shell
+$ r.js -o app.build.js
+```
+
+Para o nosso exemplo acima a configuração pode ser essa:
+```javascript
+/* file : app.build.js */
+({
+ name : 'main', // nome do ponto de acesso
+ out : 'main-built.js', // nome o arquivo para gravar a saída
+ baseUrl : 'app',
+ paths : {
+ // `empty:` fala para o r.js que isso ainda deve ser baixado da CDN, usando
+ // o local especificado no `main.js`
+ jquery : 'empty:',
+ coolLibFromBower : '../bower_components/cool-lib/coollib'
+ }
+})
+```
+
+Para usar o arquivo gerado, em produção, simplesmente troque o `data-main`:
+```html
+<script src="require.js" data-main="app/main-built"></script>
+```
+
+Uma incrível e detalhada visão geral [de build options](https://github.com/jrburke/r.js/blob/master/build/example.build.js) está disponível no repositório do GitHub.
+
+### Tópicos não abordados nesse tutorial
+* [Plugins de carregamento / transforms](http://requirejs.org/docs/plugins.html)
+* [CommonJS style carregamento e exportação](http://requirejs.org/docs/commonjs.html)
+* [Configuração avançada](http://requirejs.org/docs/api.html#config)
+* [Shim configuration (carregando módulos sem AMD)](http://requirejs.org/docs/api.html#config-shim)
+* [Carregando e otimizando CSS com require.js](http://requirejs.org/docs/optimization.html#onecss)
+* [Usando almond.js para builds](https://github.com/jrburke/almond)
+
+### Outras leituras:
+
+* [Especificação oficial](https://github.com/amdjs/amdjs-api/wiki/AMD)
+* [Por quê AMD?](http://requirejs.org/docs/whyamd.html)
+* [Universal Module Definition](https://github.com/umdjs/umd)
+
+### Implementações:
+
+* [require.js](http://requirejs.org)
+* [dojo toolkit](http://dojotoolkit.org/documentation/tutorials/1.9/modules/)
+* [cujo.js](http://cujojs.com/)
+* [curl.js](https://github.com/cujojs/curl)
+* [lsjs](https://github.com/zazl/lsjs)
+* [mmd](https://github.com/alexlawrence/mmd)
diff --git a/pt-br/asciidoc-pt.html.markdown b/pt-br/asciidoc-pt.html.markdown
new file mode 100644
index 00000000..75b3c268
--- /dev/null
+++ b/pt-br/asciidoc-pt.html.markdown
@@ -0,0 +1,129 @@
+---
+language: asciidoc
+contributors:
+ - ["Ryan Mavilia", "http://unoriginality.rocks/"]
+translators:
+ - ["David Lima", "https://github.com/davelima"]
+lang: pt-br
+filename: asciidoc-pt.md
+---
+
+AsciiDoc é uma linguagem de marcação similar ao Markdown e pode ser
+usada para qualquer coisa, de livros até blogs. Criada em 2002 por
+Stuart Rackham, a linguagem é simples mas facilita muito a customização.
+
+Cabeçalho do documento
+
+Cabeçalhos são opcionais e não podem conter linhas em branco.
+Devem estar separados do conteúdo com pelo menos uma linha em branco.
+
+Apenas Título
+
+```
+= Título do documento
+
+Primeira sentência do documento.
+```
+
+Título e Autor
+
+```
+= Título do Documento
+Nome Sobrenome <nome.sobrenome@learnxinyminutes.com>
+
+Início do documento.
+```
+
+Múltiplos Autores
+
+```
+= Título do Documento
+John Doe <john@go.com>; Jane Doe<jane@yo.com>; Black Beard <beardy@pirate.com>
+
+Início do documento com múltiplos autores.
+```
+
+Linhas de revisão (requer uma linha de autor)
+
+```
+= Documento V1
+Potato Man <chip@crunchy.com>
+v1.0, 2016-01-13
+
+Este artigo sobre batatas será divertido.
+```
+
+Parágrafos
+
+```
+Você não precisa fazer nada especial para criar um parágrafo.
+
+Adicione uma linha em branco entre os parágrafos para separá-los.
+
+Para criar uma linha em branco adicione um +
+e você terá uma quebra de linha!
+```
+
+Formatando texto
+
+```
+_underscore é itálico_
+*asterisco é negrito*
+*_você pode combinar efeitos_*
+`use crase para fonte monoespaçada`
+`*fonte monoespaçada em negrito*`
+```
+
+Título de seções
+
+```
+= Nível 0 (Use apenas no cabeçalho do documento)
+
+== Nível 1 <h2>
+
+=== Nível 2 <h3>
+
+==== Nível 3 <h4>
+
+===== Nível 4 <h5>
+
+====== Nível 5 <h6>
+
+======= Nível 6 <h7>
+
+```
+
+Listas
+
+Para criar uma lista com marcadores use asteriscos.
+
+```
+* foo
+* bar
+* baz
+```
+
+Para criar uma lista númerada use pontos.
+
+```
+. item 1
+. item 2
+. item 3
+```
+
+Você pode criar listas dentro de listas adicionando
+asteriscos ou pontos extras em até 5 níveis.
+
+```
+* foo 1
+** foo 2
+*** foo 3
+**** foo 4
+***** foo 5
+
+. foo 1
+.. foo 2
+... foo 3
+.... foo 4
+..... foo 5
+```
diff --git a/pt-br/asymptotic-notation-pt.html.markdown b/pt-br/asymptotic-notation-pt.html.markdown
new file mode 100644
index 00000000..2e299d09
--- /dev/null
+++ b/pt-br/asymptotic-notation-pt.html.markdown
@@ -0,0 +1,159 @@
+---
+category: Algorithms & Data Structures
+name: Asymptotic Notation
+contributors:
+ - ["Jake Prather", "http://github.com/JakeHP"]
+translators:
+ - ["João Farias", "https://github.com/JoaoGFarias"]
+lang: pt-br
+---
+
+# Notação Assintótica
+
+## O que é?
+
+Notação Assintótica é uma linguagem que nos permite analisar o tempo de execução
+ de um algoritmo através da indentificação de seu comportamento com o
+ crescimento da entrada oferecida. Isso também é conhecido como taxa de
+ crescimento do algoritmo. O algoritmo de repente torna-se lento quando o
+ tamanho da entrada cresce? O algoritmo mantém, em geral, seu tempo de execução
+ rápido mesmo com aumento da entrada? Notação Assintótica nos dá a habilidade de
+ responder estas questões.
+
+## Quais são as alternativas para responder a estas questões?
+
+Um modo seria contar o número de operações primitivas com diferentes tamanhos de
+ entrada. Apesar desta ser uma solução válida, o trabalho que ela requer, mesmo para algoritmos simples, não a justifica.
+
+ Outro modo é fisicamente medir a quantidade de tempo que um algoritmo requer
+ para terminar com diferentes tamanhos de entrada. Entretanto, a precisão e
+ relatividade (tempo obtido seria relativo apenas à máquina onde ocorreu a
+ execução) deste método está limitado a variáveis de ambiente, como hardware,
+ poder de processamento, etc.
+
+## Tipos de Notação Assintótica
+
+Na primeira seção desse documento, descrevemos como Notação Assintótica identifica o comportamento de um algoritmo
+ a medida que o tamanho da entrada cresce. Imaginemos um algoritmo como uma função
+ *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
+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
+maneiras. Você pode representar um algoritmo nas formas de Melhor Caso, Pior Caso
+ou Caso Médio.
+A maneira mais comum de analisar um algoritmo é pelo Pior Caso. Você tipicamente
+não avalia o melhor caso, porque essas condições não são atingidas com frequência.
+Um bom exemplo disto seria em algoritmos de ordenação; especificamente, na adição
+de elementos à árvores. O melhor caso na maioria de algoritmos pode ser de apenas
+uma operação. Entretanto, na maioria dos casos, o elemento a ser adicionado terá
+que percorrer a árvore de forma apropriada, o que pode causar a analise de um
+ramo inteiro.
+Este é o pior caso, e isto é o que você está se preparando.
+
+### Tipos de funções, limites e simplificação
+
+```
+Função Logarítmica - log n
+Função Linear - an + b
+Função Quadrática - an^2 + bn + c
+Função Polinomial - an^z + . . . + an^2 + a*n^1 + a*n^0, onde *z* é uma constante
+Função Exponencial - a^n, onde a é alguma constante
+```
+Estas são as funções básicas de crescimento usadas em várias notações. A lista
+ começa com a de crescimento mais lento (logarítima, a de execução mais rápida)
+e segue para a de crescimento mais rápido (exponencial, de execução mais lenta).
+Repare que enquando *n*, a entrada, cresce, cada uma dessas funções cresce mais
+rápido que quadrático, polinimial e exponencial, comparadas com logaritma e linear.
+
+Uma nota extremamente importante para notações é tentar usar os termos mais simples.
+Isto significa descartar constantes e termos de ordem mais baixa, pois quando o
+tamanho da entrada cresce para o infinito (limites matemáticos), os termos de ordem
+mais baixa e constantes tornam-se irrelevantes. Por exemplo, se você tiver uma
+constante muito grande, 2^9001, a simplificação não afeterá sua notação.
+
+Já que queremos as formas mais simples, mudemos nossa tabela um pouco...
+
+```
+Função Logarítmica - log n
+Função Linear - n
+Função Quadrática - n^2
+Função Polinomial - n^z, onde *z* é uma constante
+Função Exponencial - a^n, onde *a* é uma constante
+```
+
+### Big-O
+
+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
+quando constante real c (c > 0), *f(n)* <= *c g(n)* para todo tamanho de entrada
+n (n > 0).
+
+
+*Exemplo 1*
+
+```
+f(n) = 3log n + 100
+g(n) = log n
+```
+
+`f(n)` é O(g(n))?
+
+`3 log n + 100` é O(log n)?
+
+Vejamos a definição de Big-O:
+
+```
+3log n + 100 <= c * log n
+```
+
+Há alguma constante c que satisfaça a definição para todo n?
+
+```
+3log n + 100 <= 150 * log n, n > 2 (Indefinido em n = 1)
+```
+
+Sim! A definição de Big-I for atentida, portante `f(n)` é `O(g(n))`.
+
+*Exemplo 2*
+
+```
+f(n) = 3*n^2
+g(n) = n
+```
+
+`f(n)` é O(g(n))?
+
+`3 * n^2` é O(n)?
+Vejamos a definição de Big-O:
+
+```
+3 * n^2 <= c * n
+```
+
+Há alguma constante c que satisfaça a definição para todo n?
+
+Não, não há. `f(n)` não é O(g(n)).
+
+### Big-Omega
+Big-Omega, também escrita como Ω, é uma Notação Assintótica para o melhor caso.
+
+`f(n)`é Ω(g(n)), se para qualquer constante real c (c > 0), `f(n)` é >= `c g(n)` para todo tamanho de entrada n (n > 0).
+
+Sinta-se livre para adicionar mais exemplos. Big-O é a notação primária usada para medir complexidade de algoritmos.
+
+### Notas Finais
+É difícil manter esse tipo de tópico curto e você deveria ler os livros e artigos listados abaixo. Eles cobrem muito mais profundamente definições e exemplos. Mais x='Algoritms & Data Structures' virá; teremos um documento sobre analisar código em breve.
+
+## Livros
+
+* [Algorithms](http://www.amazon.com/Algorithms-4th-Robert-Sedgewick/dp/032157351X)
+* [Algorithm Design](http://www.amazon.com/Algorithm-Design-Foundations-Analysis-Internet/dp/0471383651)
+
+## Artigos Online
+
+* [MIT](http://web.mit.edu/16.070/www/lecture/big_o.pdf)
+* [KhanAcademy](https://www.khanacademy.org/computing/computer-science/algorithms/asymptotic-notation/a/asymptotic-notation)
diff --git a/pt-br/asymptoticnotation-pt.html.markdown b/pt-br/asymptoticnotation-pt.html.markdown
new file mode 100644
index 00000000..c5299a11
--- /dev/null
+++ b/pt-br/asymptoticnotation-pt.html.markdown
@@ -0,0 +1,161 @@
+---
+category: Algorithms & Data Structures
+name: Asymptotic Notation
+contributors:
+ - ["Jake Prather", "http://github.com/JakeHP"]
+translators:
+ - ["Carolina Knoll", "http://github.com/carolinaknoll"]
+lang: pt-br
+---
+
+# Aprenda X em Y minutos
+## Onde X=Notação Assintótica
+
+# Notações Assintóticas
+## O que são?
+
+Notações assintóticas são notações matemáticas que nos permitem analisar tempo de execução
+de um algoritmo, identificando o seu comportamento de acordo como o tamanho de entrada para
+o algoritmo aumenta. Também é conhecido como taxa de "crescimento" de um algoritmo. O algoritmo
+simplesmente se torna incrivelmente lento conforme o seu tamanho aumenta? Será que pode-se na
+maior parte manter o seu tempo de execução rápido mesmo quando o tamanho de entrada aumenta?
+A notação assintótica nos dá a capacidade de responder a essas perguntas.
+
+## Além desta, existem outras alternativas para responder a essas perguntas?
+
+Uma forma seria a de contar o número de operações primitivas em diferentes tamanhos de entrada.
+Embora esta seja uma solução válida, a quantidade de trabalho necessário, mesmo para algoritmos
+simples, não justifica a sua utilização.
+
+Outra maneira é a de medir fisicamente a quantidade de tempo que leva para se executar um algoritmo
+de diferentes tamanhos. No entanto, a precisão e a relatividade (já que tempos obtidos só teriam
+relação à máquina em que eles foram testados) deste método estão ligadas a variáveis ambientais,
+tais como especificações de hardware, poder de processamento, etc.
+
+## Tipos de Notação Assintótica
+
+Na primeira seção deste documento nós descrevemos como uma notação assintótica identifica o comportamento
+de um algoritmo como as alterações de tamanho de entrada (input). Imaginemos um algoritmo como uma função
+f, n como o tamanho da entrada, e f (n) sendo o tempo de execução. Assim, para um determinado algoritmo f,
+com tamanho de entrada n você obtenha algum tempo de execução resultante f (n). Isto resulta num gráfico,
+em que o eixo Y representa o tempo de execução, o eixo X é o tamanho da entrada, e os pontos marcados são
+os resultantes da quantidade de tempo para um dado tamanho de entrada.
+
+Pode-se rotular uma função ou algoritmo com uma notação assintótica de diversas maneiras diferentes.
+Dentre seus exemplos, está descrever um algoritmo pelo seu melhor caso, pior caso, ou caso equivalente.
+O mais comum é o de analisar um algoritmo pelo seu pior caso. Isso porque você normalmente não avaliaria
+pelo melhor caso, já que essas condições não são as que você está planejando. Um bom exemplo disto é o de
+algoritmos de ordenação; especificamente, a adição de elementos a uma estrutura de tipo árvore. O melhor
+caso para a maioria dos algoritmos pode ser tão simples como uma única operação. No entanto, na maioria
+dos casos, o elemento que você está adicionando terá de ser ordenado de forma adequada através da árvore,
+o que poderia significar a análise de um ramo inteiro. Este é o pior caso, e é por ele que precisamos seguir.
+
+### Tipos de funções, limites, e simplificação
+
+```
+Função Logaritmica - log n
+Função Linear - an + b
+Função Quadrática - an^2 + bn + c
+Função Polinomial - an^z + . . . + an^2 + a*n^1 + a*n^0, onde z é uma constante
+Função Exponencial - a^n, onde a é uma constante
+```
+
+Estas são algumas classificações básicas de crescimento de função usados em várias notações. A lista
+começa com a função crescimento mais lento (logarítmica, com tempo de execução mais rápido) e vai até
+a mais rápida (exponencial, com tempo de execução mais lento). Observe que 'n', ou nossa entrada,
+cresce em cada uma dessas funções, e o resultado claramente aumenta muito mais rapidamente em função
+quadrática, polinomial e exponencial, em comparação com a logarítmica e a linear.
+
+Uma observação de boa importância é que, para as notações a serem discutidas, deve-se fazer o melhor
+para utilizar termos mais simples. Isto significa desrespeitar constantes, e simplificar termos de
+ordem, porque, como o tamanho da entrada (ou n no nosso f (n) exemplo) aumenta infinitamente (limites
+matemáticos), os termos em ordens mais baixas e constantes são de pouca ou nenhuma importância. Dito
+isto, se você possui constantes com valor 2^9001, ou alguma outra quantidade ridícula, inimaginável,
+perceberá que a simplificação distorcerá a precisão de sua notação.
+
+Já que nós queremos a forma mais simples, vamos modificar nossas funções um pouco.
+
+```
+Logaritmica - log n
+Linear - n
+Quadrática - n^2
+Polinomial - n^z, onde z é uma constante
+Exponencial - a^n, onde a é uma constante
+```
+
+### O Grande-O
+
+Grande-O, geralmente escrita como O, é uma Notação Assintótica para o pior caso para uma dada função. Digamos
+que `f(n)` é o tempo de execução de seu algoritmo, e `g(n)` é uma complexidade de tempo arbitrário que você está
+tentando se relacionar com o seu algoritmo. `f(n)` será O(g(n)), se, por qualquer constante real c (c > 0),
+`f(n)` <= `c g(n)` para cada tamanho de entrada n (n > 0).
+
+*Exemplo 1*
+
+```
+f(n) = 3log n + 100
+g(n) = log n
+```
+
+É `f(n)` um O(g(n))?
+É 3 `log n + 100` igual a O(log n)?
+Vamos checar na definição de Grande-O.
+
+```
+3log n + 100 <= c * log n
+```
+
+Existe alguma constante c que satisfaça isso para todo n?
+
+```
+3log n + 100 <= 150 * log n, n > 2 (indefinido em n = 1)
+```
+
+Sim! A definição de Grande-O foi satisfeita. Sendo assim, `f(n)` é O(g(n)).
+
+*Exemplo 2*
+
+```
+f(n) = 3 * n^2
+g(n) = n
+```
+
+É `f(n)` um O(g(n))?
+É `3 * n^2` um O(n)?
+Vamos ver na definição de Grande-O.
+
+```
+3 * n^2 <= c * n
+```
+
+Existe alguma constante que satisfaça isso para todo n?
+Não, não existe. `f(n)` NÃO É O(g(n)).
+
+### Grande-Omega
+
+Grande-Omega, comumente escrito como Ω, é uma Notação Assintótica para o melhor caso, ou
+uma taxa de crescimento padrão para uma determinada função.
+
+`f(n)` é Ω(g(n)), se, por qualquer constante c real (c > 0), `f(n)` é >= `c g(n)` para cada
+tamanho de entrada n (n > 0).
+
+Sinta-se livre para pesquisar recursos adicionais e obter mais exemplos sobre este assunto!
+Grande-O é a notação primária utilizada para tempo de execução de algoritmos, de modo geral.
+
+### Notas de Finalização
+
+É complicado exibir este tipo de assunto de forma tão curta, então é definitivamente recomendado
+pesquisar além dos livros e recursos on-line listados. Eles serão capazes de analisar o assunto com
+uma profundidade muito maior, além de ter definições e exemplos. Mais sobre onde X="Algoritmos e
+Estruturas de Dados" está a caminho: Haverá conteúdo focado na análise de exemplos de códigos reais
+em breve.
+
+## Livros
+
+* [Algorithms] (http://www.amazon.com/Algorithms-4th-Robert-Sedgewick/dp/032157351X)
+* [Algorithm Design] (http://www.amazon.com/Algorithm-Design-Foundations-Analysis-Internet/dp/0471383651)
+
+## Recursos Online
+
+* [MIT] (http://web.mit.edu/16.070/www/lecture/big_o.pdf)
+* [KhanAcademy] (https://www.khanacademy.org/computing/computer-science/algorithms/asymptotic-notation/a/asymptotic-notation)
diff --git a/pt-br/bash-pt.html.markdown b/pt-br/bash-pt.html.markdown
new file mode 100644
index 00000000..ae18435a
--- /dev/null
+++ b/pt-br/bash-pt.html.markdown
@@ -0,0 +1,282 @@
+---
+category: tool
+tool: bash
+contributors:
+ - ["Max Yankov", "https://github.com/golergka"]
+ - ["Darren Lin", "https://github.com/CogBear"]
+ - ["Alexandre Medeiros", "http://alemedeiros.sdf.org"]
+ - ["Denis Arh", "https://github.com/darh"]
+ - ["akirahirose", "https://twitter.com/akirahirose"]
+ - ["Anton Strömkvist", "http://lutic.org/"]
+translators:
+ - ["Davidson Mizael", "https://github.com/davidsonmizael"]
+filename: LearnBash-pt_br.sh
+lang: pt-br
+---
+
+Tutorial de shell em português
+
+Bash é o nome do shell do Unix, que também é distribuido 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.
+
+[Leia mais sobre](http://www.gnu.org/software/bash/manual/bashref.html)
+
+```bash
+#!/bin/bash
+# A primeira linha do script é o shebang, que conta para o sistema como executar
+# o script: http://en.wikipedia.org/wiki/Shebang_(Unix)
+# Como você já deve ter percebido, comentários começam com #.
+# Shebang também é um comentário.
+
+# Exemplo simples de hello world:
+echo Hello World!
+
+# Cada comando começa com uma nova linha, ou após um ponto virgula:
+echo 'Essa é a primeira linha'; echo 'Essa é a segunda linha'
+
+# A declaração de variáveis é mais ou menos assim
+Variavel="Alguma string"
+
+# Mas não assim:
+Variavel = "Alguma string"
+# Bash interpretará Variavel como um comando e tentará executar e lhe retornar
+# um erro porque o comando não pode ser encontrado.
+
+# Ou assim:
+Variavel= 'Alguma string'
+# Bash interpretará 'Alguma string' como um comando e tentará executar e lhe retornar
+# um erro porque o comando não pode ser encontrado. (Nesse caso a a parte 'Variavel='
+# é vista com uma declaração de variável valida apenas para o escopo do comando 'Uma string').
+
+# Usando a variável:
+echo $Variavel
+echo "$Variavel"
+echo '$Variavel'
+# Quando você usa a variável em si — declarando valor, exportando, etc — você escreve
+# seu nome sem o $. Se você quer usar o valor da variável você deve usar o $.
+# Note que ' (aspas simples) não expandirão as variáveis!
+
+# Substituição de strings em variáveis
+echo ${Variavel/Alguma/Uma}
+# Isso substituirá a primeira ocorrência de "Alguma" por "Uma"
+
+# Substring de uma variável
+Tamanho=7
+echo ${Variavel:0:Tamanho}
+# Isso retornará apenas os 7 primeiros caractéres da variável
+
+# Valor padrão de uma variável
+echo ${Foo:-"ValorPadraoSeFooNaoExistirOuEstiverVazia"}
+# Isso funciona para nulo (Foo=) e (Foo=""); zero (Foo=0) retorna 0.
+# Note que isso apenas retornar o valor padrão e não mudar o valor da variável.
+
+# Variáveis internas
+# Tem algumas variáveis internas bem uteis, como
+echo "O ultimo retorno do programa: $?"
+echo "PID do script: $$"
+echo "Numero de argumentos passados para o script $#"
+echo "Todos os argumentos passados para o script $@"
+echo "Os argumentos do script em variáveis diferentes: $1, $2..."
+
+# Lendo o valor do input:
+echo "Qual o seu nome?"
+read Nome # Note que nós não precisamos declarar a variável
+echo Ola, $Nome
+
+# Nós temos a estrutura if normal:
+# use 'man test' para mais infomações para as condicionais
+if [ $Nome -ne $USER ]
+then
+ echo "Seu nome não é o seu username"
+else
+ echo "Seu nome é seu username"
+fi
+
+# Tem também execução condicional
+echo "Sempre executado" || echo "Somente executado se o primeiro falhar"
+echo "Sempre executado" && "Só executado se o primeiro NÃO falhar"
+
+# Para usar && e || com o if, você precisa multiplicar os pares de colchetes
+if [ $Nome == "Estevao"] && [ $Idade -eq 15]
+then
+ echo "Isso vai rodar se $Nome é igual Estevao E $Idade é 15."
+fi
+
+fi [ $Nome == "Daniela" ] || [ $Nome = "Jose" ]
+then
+ echo "Isso vai rodar se $Nome é Daniela ou Jose."
+fi
+
+# Expressões são denotadas com o seguinte formato
+echo $(( 10 + 5))
+
+# Diferentemente das outras linguagens de programação, bash é um shell, então ele
+# funciona no diretório atual. Você pode listar os arquivos e diretórios no diretório
+# atual com o comando ls:
+ls
+
+#Esse comando tem opções que controlam sua execução
+ls -l # Lista todo arquivo e diretorio em linhas separadas
+
+# Os resultados do comando anterior pode ser passado para outro comando como input.
+# O comando grep filtra o input com o padrão passado. É assim que listamos apenas
+# os arquivos .txt no diretório atual:
+ls -l | grep "\.txt"
+
+# Você pode redirecionar o comando de input e output (stdin, stdout e stderr).
+# Lê o stdin até ^EOF$ e sobrescreve hello.py com as linhas entre "EOF":
+cat > hello.py << EOF
+#!/usr/bin/env python
+from __future__ imprt print_function
+import sys
+print("#stdout", file=sys.stdout)
+print("stderr", file=sys.stderr)
+for line in sys.stdin:
+ print(line, file=sys.stdout)
+EOF
+
+# Rode hello.py com várias instruções stdin, stdout e stderr:
+python hello.py < "input.in"
+python hello.py > "ouput.out"
+python hello.py 2> "error.err"
+python hello.py > "output-and-error.log" 2>&1
+python hello.py > /dev/null 2>&1
+# O erro no output sobrescreverá o arquivo se existir,
+# se ao invés disso você quiser complementar, use ">>":
+python hello.py >> "output.out" 2>> "error.err"
+
+# Sobrescreve output.out, complemente para error.err e conta as linhas
+info bash 'Basic Shell Features' 'Redirections' > output.out 2>> error.err
+wc -l output.out error.err
+
+#Roda um comando e imprime o desencriptador (e.g. /dev/fd/123)
+# veja: man fd
+echo <(echo "#helloworld")
+
+# Sobrescreve ouput.out com "#helloworld":
+cat > output.out <(echo "#helloworld")
+echo "#helloworld" > output.out
+echo "#helloworld" | cat > output.out
+echo "#helloworld" | tee output.out > /dev/null
+
+# Limpa os arquivos temporários detalhando quais foram deletados (use '-i' para confirmar exclusão)
+rm -v output.out error.err output-and-error.log
+
+# Comando podem ser substituídos por outros comandos usando $( ):
+# O comando a seguir mostra o número de arquivos e diretórios no diretorio atual
+echo "Existem $(ls | wc -l) itens aqui."
+
+# O mesmo pode ser feito usando crase `` mas elas não podem ser aninhadas - dá se
+# preferência ao uso do $( )
+echo "Existem `ls | wc -l` itens aqui."
+
+# Bash usa o comando case que funciona de uma maneira similar ao switch de Java e C++:
+case "$Variavel" in
+ # Lista de parametros para condições que você quer encontrar
+ 0) echo "Isso é um Zero.";;
+ 1) echo "Isso é um Um.";;
+ *) echo "Isso não é null.";;
+esac
+
+# loops for iteragem para quantos argumentos passados:
+# O conteudo de $Variavel é exibido três vezes.
+for Variavel in {1..3}
+do
+ echo "$Variavel"
+done
+
+# Ou use o loop da "maneira tradicional":
+for ((a=1; a <= 3; a++))
+do
+ echo $a
+done
+
+# Eles também podem ser usados em arquivos...
+# Isso irá rodar o comando 'cat' em arquivo1 e arquivo2
+for Variavel in arquivo1 arquivo2
+do
+ cat "$Variavel"
+done
+
+# ...ou o output de um comando
+# Isso irá usar cat no output do ls.
+for Output in $(ls)
+do
+ cat "$Output"
+done
+
+# loop while:
+while [ true ]
+do
+ echo "corpo do loop aqui..."
+ break
+done
+
+# Você também pode usar funções
+# Definição:
+function foo() {
+ echo "Argumentos funcionam bem assim como os dos scripts: $@"
+ echo "E: $1 $2..."
+ echo "Isso é uma função"
+ return 0
+}
+
+# ou simplesmente
+bar () {
+ echo "Outro jeito de declarar funções!"
+ return 0
+}
+
+# Chamando sua função
+foo "Meu nome é" $Nome
+
+# Existe um monte de comandos úteis que você deveria aprender:
+# exibe as 10 ultimas linhas de arquivo.txt
+tail -n 10 arquivo.txt
+# exibe as primeiras 10 linhas de arquivo.txt
+head -n 10 arquivo.txt
+# ordena as linhas de arquivo.txt
+sort arquivo.txt
+# reporta ou omite as linhas repetidas, com -d você as reporta
+uniq -d arquivo.txt
+# exibe apenas a primeira coluna após o caráctere ','
+cut -d ',' -f 1 arquivo.txt
+# substitui todas as ocorrencias de 'okay' por 'legal' em arquivo.txt (é compativel com regex)
+sed -i 's/okay/legal/g' file.txt
+# exibe para o stdout todas as linhas do arquivo.txt que encaixam com o regex
+# O exemplo exibe linhas que começam com "foo" e terminam com "bar"
+grep "^foo.*bar$" arquivo.txt
+# passe a opção "-c" para ao invês de imprimir o numero da linha que bate com o regex
+grep -c "^foo.*bar$" arquivo.txt
+# se você quer literalmente procurar por uma string,
+# e não pelo regex, use fgrep (ou grep -F)
+fgrep "^foo.*bar$" arquivo.txt
+
+
+# Leia a documentação interna do shell Bash com o comando interno 'help':
+help
+help help
+help for
+help return
+help source
+help .
+
+# Leia a página principal da documentação com man
+apropos bash
+man 1 bash
+man bash
+
+# Leia a documentação de informação com info (? para ajuda)
+apropos info | grep '^info.*('
+man info
+info info
+info 5 info
+
+#Leia a documentação informativa do Bash:
+info bash
+info bash 'Bash Features'
+info bash 6
+info --apropos bash
+```
diff --git a/pt-br/brainfuck-pt.html.markdown b/pt-br/bf.html.markdown
index 9e4b458d..d6d7c6e9 100644
--- a/pt-br/brainfuck-pt.html.markdown
+++ b/pt-br/bf.html.markdown
@@ -1,5 +1,5 @@
---
-language: brainfuck
+language: bf
contributors:
- ["Prajit Ramachandran", "http://prajitr.github.io/"]
- ["Mathias Bynens", "http://mathiasbynens.be/"]
diff --git a/pt-br/binary-search-pt.html.markdown b/pt-br/binary-search-pt.html.markdown
new file mode 100644
index 00000000..d3060506
--- /dev/null
+++ b/pt-br/binary-search-pt.html.markdown
@@ -0,0 +1,77 @@
+---
+category: Algorithms & Data Structures
+name: Binary Search
+contributors:
+ - ["Abhishek Jaisingh", "http://github.com/abhishekjiitr"]
+translators:
+ - ["Claudson Martins", "https://github.com/claudsonm"]
+lang: pt-br
+---
+
+# Busca Binária
+
+## Por Que Busca Binária?
+
+Operações de busca são um dos principais problemas na Ciência da Computação.
+Atualmente existem mais de 1 trilhão de buscas por ano, e nós precisamos de
+algoritmos que possam realizá-las rapidamente. Busca binária é um dos algoritmos
+fundamentais em ciência da computação. A fim de explorá-la, iremos primeiro
+construir um conhecimento teórico, e então utilizá-lo para implementar o
+algoritmo apropriadamente.
+
+## Introdução
+
+Uma abordagem simples para implementar uma busca é realizar uma busca linear,
+mas algoritmos nessa abordagem levam muito tempo, o qual cresce linearmente de
+acordo com a quantidade ou número de dados. Por exemplo, iniciando do elemento
+mais a esquerda de arr[] e um a um comparar x com cada elemento de arr[], se x
+coincide com um elemento, retornar seu índice. Se x não coincide com nenhum dos
+elementos, retornar -1.
+
+```
+Busca Linear: O (n) Tempo Linear
+
+Busca Binária: O ( log(n) ) Tempo Logarítmico
+
+```
+```
+def busca(arr, x):
+
+ for i in range(len(arr)):
+
+ if arr[i] == x:
+ return i
+
+ return -1
+
+```
+## Algoritmo de Busca Binária
+
+O pré-requisito básico para que uma busca binária funcione é que os dados que se
+desejam buscar devem estar ordenados (em qualquer ordem).
+
+### Pseudocódigo
+
+```
+A ideia da busca binária é usar a informação de que o array está ordenado e
+reduzir a complexidade de tempo para O(Log n). Nós basicamente ignoramos metade
+dos elementos após uma comparação.
+
+1) Compare x com o elemento do meio.
+2) Se x coincide com o elemento do meio, retorne o índice do meio.
+3) Senão Se x é maior que o elemento do meio, então x só pode estar no lado
+direito do elemento do meio. Portanto nós pulamos para a metade direita.
+4) Senão (x é menor) pulamos para a metade esquerda.
+
+Essa é a ideia da implementação recursiva da busca binária.
+
+```
+
+### Considerações Finais
+
+Existem outras formas de busca binária que são muito úteis.
+
+## Recursos Online
+
+* [GeeksforGeeks](http://www.geeksforgeeks.org/the-ubiquitous-binary-search-set-1/)
+* [Topcoder Tutorial](https://www.topcoder.com/community/data-science/data-science-tutorials/binary-search/)
diff --git a/pt-br/c++-pt.html.markdown b/pt-br/c++-pt.html.markdown
index 61e267f5..fd392b9e 100644
--- a/pt-br/c++-pt.html.markdown
+++ b/pt-br/c++-pt.html.markdown
@@ -19,9 +19,9 @@ foi concebida para
- 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
-genéricos, exceções e classes. Esta combinação de velocidade e funcionalidade
+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
+genéricos, exceções e classes. Esta combinação de velocidade e funcionalidade
faz C++ uma das linguagens de programação mais utilizadas.
```c++
@@ -33,7 +33,7 @@ faz C++ uma das linguagens de programação mais utilizadas.
// declarações de variáveis, tipos primitivos, e funções. No entanto, C++ varia
// em algumas das seguintes maneiras:
-// A função main() em C++ deve retornar um int, embora void main() é aceita
+// A função main() em C++ deve retornar um int, embora void main() é aceita
// pela maioria dos compiladores (gcc, bumbum, etc.)
// Este valor serve como o status de saída do programa.
// Veja http://en.wikipedia.org/wiki/Exit_status para mais informações.
@@ -105,7 +105,7 @@ int main()
// Parâmetros padrão de função
/////////////////////////////
-// Você pode fornecer argumentos padrões para uma função se eles não são
+// Você pode fornecer argumentos padrões para uma função se eles não são
// fornecidos pelo chamador.
void doSomethingWithInts(int a = 1, int b = 4)
@@ -157,7 +157,7 @@ void foo()
int main()
{
- // Assuma que tudo é do namespace "Second" a menos que especificado de
+ // Assuma que tudo é do namespace "Second" a menos que especificado de
// outra forma.
using namespace Second;
@@ -222,7 +222,7 @@ cout << myString; // "Hello Dog"
// Além de indicadores como os de C, C++ têm _referências_. Esses são tipos de
// ponteiro que não pode ser reatribuída uma vez definidos e não pode ser nulo.
-// Eles também têm a mesma sintaxe que a própria variável: Não * é necessário
+// Eles também têm a mesma sintaxe que a própria variável: Não * é necessário
// para _dereferencing_ e & (endereço de) não é usado para atribuição.
using namespace std;
@@ -258,7 +258,7 @@ class Dog {
std::string name;
int weight;
-// Todos os membros a seguir este são públicos até que "private:" ou
+// Todos os membros a seguir este são públicos até que "private:" ou
// "protected:" é encontrado.
public:
@@ -274,13 +274,13 @@ 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 objecto 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
- // derivadas. As funções não são virtuais por padrão por razões de
+ // declarados como _virtual_, a fim de ser substituídas em classes
+ // derivadas. As funções não são virtuais por padrão por razões de
// performance.
-
+
virtual void print() const;
// As funções também podem ser definidas no interior do corpo da classe.
@@ -291,7 +291,7 @@ public:
// Estes são chamados quando um objeto é excluído ou fica fora do escopo.
// Isto permite paradigmas poderosos, como RAII
// (veja abaixo)
- // Destruidores devem ser virtual para permitir que as classes de ser
+ // Destruidores devem ser virtual para permitir que as classes de ser
// derivada desta.
virtual ~Dog();
@@ -323,7 +323,7 @@ void Dog::print() const
void Dog::~Dog()
{
- cout << "Goodbye " << name << "\n";
+ std::cout << "Goodbye " << name << "\n";
}
int main() {
@@ -343,8 +343,8 @@ class OwnedDog : public Dog {
// Substituir o comportamento da função de impressão de todas OwnedDogs.
// Ver http://en.wikipedia.org/wiki/Polymorphism_(computer_science)#Subtyping
- // Para uma introdução mais geral, se você não estiver familiarizado com o
- // polimorfismo subtipo. A palavra-chave override é opcional, mas torna-se
+ // Para uma introdução mais geral, se você não estiver familiarizado com o
+ // polimorfismo subtipo. A palavra-chave override é opcional, mas torna-se
// na verdade você está substituindo o método em uma classe base.
void print() const override;
@@ -371,8 +371,8 @@ void OwnedDog::print() const
// Inicialização e Sobrecarga de Operadores
//////////////////////////////////////////
-// Em C ++, você pode sobrecarregar o comportamento dos operadores, tais como
-// +, -, *, /, etc. Isto é feito através da definição de uma função que é
+// Em C ++, você pode sobrecarregar o comportamento dos operadores, tais como
+// +, -, *, /, etc. Isto é feito através da definição de uma função que é
// chamado sempre que o operador é usado.
#include <iostream>
@@ -438,7 +438,7 @@ int main () {
// mas qualquer tipo pode ser jogado como uma exceção
#include <exception>
-// Todas as exceções lançadas dentro do bloco try pode ser capturado por
+// Todas as exceções lançadas dentro do bloco try pode ser capturado por
// manipuladores de captura subseqüentes
try {
// Não aloca exceções no heap usando _new_.
@@ -460,7 +460,7 @@ catch (const std::exception& ex)
///////
// RAII significa alocação de recursos é de inicialização.
-// Muitas vezes, é considerado o paradigma mais poderoso em C++, e é o
+// Muitas vezes, é considerado o paradigma mais poderoso em C++, e é o
// conceito simples que um construtor para um objeto adquire recursos daquele
// objeto e o destruidor liberá-los.
@@ -479,18 +479,18 @@ void doSomethingWithAFile(const char* filename)
}
// Infelizmente, as coisas são levemente complicadas para tratamento de erros.
-// Suponha que fopen pode falhar, e que doSomethingWithTheFile e
-// doSomethingElseWithIt retornam códigos de erro se eles falharem. (As
-// exceções são a forma preferida de lidar com o fracasso, mas alguns
-// programadores, especialmente aqueles com um conhecimento em C, discordam
-// sobre a utilidade de exceções). Agora temos que verificar cada chamada para
+// Suponha que fopen pode falhar, e que doSomethingWithTheFile e
+// doSomethingElseWithIt retornam códigos de erro se eles falharem. (As
+// exceções são a forma preferida de lidar com o fracasso, mas alguns
+// programadores, especialmente aqueles com um conhecimento em C, discordam
+// sobre a utilidade de exceções). Agora temos que verificar cada chamada para
// o fracasso e fechar o identificador de arquivo se ocorreu um problema.
bool doSomethingWithAFile(const char* filename)
{
FILE* fh = fopen(filename, "r"); // Abra o arquivo em modo de leitura
if (fh == nullptr) // O ponteiro retornado é nulo em caso de falha.
- reuturn false; // Relate o fracasso para o chamador.
+ return false; // Relate o fracasso para o chamador.
// Suponha cada função retorne false, se falhar
if (!doSomethingWithTheFile(fh)) {
@@ -511,7 +511,7 @@ bool doSomethingWithAFile(const char* filename)
{
FILE* fh = fopen(filename, "r");
if (fh == nullptr)
- reuturn false;
+ return false;
if (!doSomethingWithTheFile(fh))
goto failure;
@@ -581,10 +581,35 @@ void doSomethingWithAFile(const std::string& filename)
// vetor (i.e. array de autodimensionamento), mapas hash, e assim por diante
// tudo é automaticamente destruído quando eles saem de escopo
// - Mutex usa lock_guard e unique_lock
+
+
+/////////////////////
+// Templates
+/////////////////////
+
+// Templates em C++ são utilizados para programação genérica, ou seja,
+// utilizar um tipo de dado genérico onde possa suportar qualquer entrada.
+// Por exemplo, invés de criar uma função que apenas some inteiros, você
+// poderá fazer uma função que soma double, float e inteiros em uma única
+// definição para reutilizar código.
+
+// Definimos um função que utiliza um "typename"
+template<class T>
+T soma(T a, T b) {
+ return A + B;
+}
+
+// E agora para executá-la
+int i=5, j=6, k;
+double f=2.0, g=0.5, h;
+k=sum<int>(i,j);
+h=sum<double>(f,g);
+
+// Deste modo, não precisamos fazer overload nas funções! (:
```
Leitura Adicional:
-Uma referência atualizada da linguagem pode ser encontrada em
+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>
diff --git a/pt-br/c-pt.html.markdown b/pt-br/c-pt.html.markdown
index 2c274f12..0af553c8 100644
--- a/pt-br/c-pt.html.markdown
+++ b/pt-br/c-pt.html.markdown
@@ -28,7 +28,7 @@ Funcionam no C89 também.
*/
// Constantes: #define <palavra-chave>
-#definie DAY_IN_YEAR 365
+#define DAY_IN_YEAR 365
//enumerações também são modos de definir constantes.
enum day {DOM = 1, SEG, TER, QUA, QUI, SEX, SAB};
diff --git a/pt-br/clojure-macros-pt.html.markdown b/pt-br/clojure-macros-pt.html.markdown
index dbc0c25c..d56840e0 100644
--- a/pt-br/clojure-macros-pt.html.markdown
+++ b/pt-br/clojure-macros-pt.html.markdown
@@ -142,6 +142,8 @@ Você vai querer estar familiarizado com Clojure. Certifique-se de entender tudo
(inline-2 (1 + (3 / 2) - (1 / 2) + 1))
; -> 3 (Na verdade, 3N, desde que o numero ficou convertido em uma fração racional com /
+```
+
### Leitura adicional
Escrevendo Macros de [Clojure para o Brave e True](http://www.braveclojure.com/)
diff --git a/pt-br/csharp.html.markdown b/pt-br/csharp.html.markdown
new file mode 100644
index 00000000..547f4817
--- /dev/null
+++ b/pt-br/csharp.html.markdown
@@ -0,0 +1,896 @@
+---
+language: c#
+filename: csharp-pt.cs
+contributors:
+ - ["Robson Alves", "http://robsonalves.net/"]
+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.
+
+[Read more here.](http://msdn.microsoft.com/pt-br/library/vstudio/z1zx9t92.aspx)
+
+```c#
+// Comentário de linha única começa com //
+/*
+Múltipas linhas é 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
+/// </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
+using System;
+using System.Collections.Generic;
+using System.Dynamic;
+using System.Linq;
+using System.Net;
+using System.Threading.Tasks;
+using System.IO;
+
+// Mas este aqui não é :
+using System.Data.Entity;
+// Para que consiga utiliza-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;
+namespace Learning.CSharp
+{
+ // Cada .cs deve conter uma classe com o mesmo nome do arquivo
+ // você está autorizado a contrariar isto, mas evite por sua sanidade.
+ public class AprenderCsharp
+ {
+ // Sintaxe Básica - Pule para as CARACTERÍSTICAS INTERESSANTES se você ja usou Java ou C++ antes.
+ public static void Syntax()
+ {
+ // Use Console.WriteLine para apresentar uma linha
+ Console.WriteLine("Hello World");
+ Console.WriteLine(
+ "Integer: " + 10 +
+ " Double: " + 3.14 +
+ " Boolean: " + true);
+
+ // Para apresentar sem incluir uma nova linha, use Console.Write
+ Console.Write("Hello ");
+ Console.Write("World");
+
+ ///////////////////////////////////////////////////
+ // Tpos e Variáveis
+ //
+ // Declare uma variável usando <tipo> <nome>
+ ///////////////////////////////////////////////////
+
+ // Sbyte - Signed 8-bit integer
+ // (-128 <= sbyte <= 127)
+ sbyte fooSbyte = 100;
+
+ // Byte - Unsigned 8-bit integer
+ // (0 <= byte <= 255)
+ byte fooByte = 100;
+
+ // Short - 16-bit integer
+ // Signed - (-32,768 <= short <= 32,767)
+ // Unsigned - (0 <= ushort <= 65,535)
+ short fooShort = 10000;
+ ushort fooUshort = 10000;
+
+ // Integer - 32-bit integer
+ int fooInt = 1; // (-2,147,483,648 <= int <= 2,147,483,647)
+ uint fooUint = 1; // (0 <= uint <= 4,294,967,295)
+
+ // Long - 64-bit integer
+ long fooLong = 100000L; // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
+ ulong fooUlong = 100000L; // (0 <= ulong <= 18,446,744,073,709,551,615)
+ // Numbers default to being int or uint depending on size.
+ // L is used to denote that this variable value is of type long or ulong
+
+ // Double - Double-precision 64-bit IEEE 754 Floating Point
+ double fooDouble = 123.4; // Precision: 15-16 digits
+
+ // Float - Single-precision 32-bit IEEE 754 Floating Point
+ float fooFloat = 234.5f; // Precision: 7 digits
+ // f is used to denote that this variable value is of type float
+
+ // Decimal - a 128-bits data type, with more precision than other floating-point types,
+ // suited for financial and monetary calculations
+ decimal fooDecimal = 150.3m;
+
+ // Boolean - true & false
+ bool fooBoolean = true; // or false
+
+ // Char - A single 16-bit Unicode character
+ char fooChar = 'A';
+
+ // Strings - ao contrário dos anteriores tipos base, que são todos os tipos de valor,
+            // Uma string é um tipo de referência. Ou seja, você pode configurá-lo como nulo
+ string fooString = "\"escape\" quotes and add \n (new lines) and \t (tabs)";
+ Console.WriteLine(fooString);
+
+ // Você pode acessar todos os caracteres de string com um indexador:
+ char charFromString = fooString[1]; // => 'e'
+ // Strings são imutáveis: você não pode fazer fooString[1] = 'X';
+
+ // Compare strings com sua atual cultura, ignorando maiúsculas e minúsculas
+ string.Compare(fooString, "x", StringComparison.CurrentCultureIgnoreCase);
+
+ // Formatando, baseado no sprintf
+ string fooFs = string.Format("Check Check, {0} {1}, {0} {1:0.0}", 1, 2);
+
+ // Datas e formatações
+ DateTime fooDate = DateTime.Now;
+ Console.WriteLine(fooDate.ToString("hh:mm, dd MMM yyyy"));
+
+ // Você pode juntar um string em mais de duas linhas com o símbolo @. Para escapar do " use ""
+ string bazString = @"Here's some stuff
+on a new line! ""Wow!"", the masses cried";
+
+ // Use const ou read-only para fazer uma variável imutável
+ // os valores da const são calculados durante o tempo de compilação
+ const int HoursWorkPerWeek = 9001;
+
+ ///////////////////////////////////////////////////
+ // Estrutura de Dados
+ ///////////////////////////////////////////////////
+
+ // Matrizes - zero indexado
+ // O tamanho do array pode ser decidido ainda na declaração
+ // O formato para declarar uma matriz é o seguinte:
+ // <tipodado>[] <var nome> = new <tipodado>[<array tamanho>];
+ int[] intArray = new int[10];
+
+ // Outra forma de declarar & inicializar uma matriz
+ int[] y = { 9000, 1000, 1337 };
+
+ // Indexando uma matriz - Acessando um elemento
+ Console.WriteLine("intArray @ 0: " + intArray[0]);
+ // Matriz são alteráveis
+ intArray[1] = 1;
+
+ // Listas
+ // Listas são usadas frequentemente tanto quanto matriz por serem mais flexiveis
+ // O formato de declarar uma lista é o seguinte:
+ // List<tipodado> <var nome> = new List<tipodado>();
+ List<int> intList = new List<int>();
+ List<string> stringList = new List<string>();
+ List<int> z = new List<int> { 9000, 1000, 1337 }; // inicializar
+ // O <> são para genéricos - Confira está interessante seção do material
+
+ // Lista não possuem valores padrão.
+ // Um valor deve ser adicionado antes e depois acessado pelo indexador
+ intList.Add(1);
+ Console.WriteLine("intList @ 0: " + intList[0]);
+
+ // Outras estruturas de dados para conferir:
+ // Pilha/Fila
+ // Dicionário (uma implementação de map de hash)
+ // HashSet
+ // Read-only Coleção
+ // Tuple (.Net 4+)
+
+ ///////////////////////////////////////
+ // Operadores
+ ///////////////////////////////////////
+ Console.WriteLine("\n->Operators");
+
+ int i1 = 1, i2 = 2; // Forma curta para declarar diversas variáveis
+
+ // Aritmética é clara
+ Console.WriteLine(i1 + i2 - i1 * 3 / 7); // => 3
+
+ // Modulo
+ Console.WriteLine("11%3 = " + (11 % 3)); // => 2
+
+ // Comparações de operadores
+ Console.WriteLine("3 == 2? " + (3 == 2)); // => falso
+ Console.WriteLine("3 != 2? " + (3 != 2)); // => verdadeiro
+ Console.WriteLine("3 > 2? " + (3 > 2)); // => verdadeiro
+ Console.WriteLine("3 < 2? " + (3 < 2)); // => falso
+ Console.WriteLine("2 <= 2? " + (2 <= 2)); // => verdadeiro
+ Console.WriteLine("2 >= 2? " + (2 >= 2)); // => verdadeiro
+
+ // Operadores bit a bit (bitwise)
+ /*
+ ~ Unário bitwise complemento
+ << Signed left shift
+ >> Signed right shift
+ & Bitwise AND
+ ^ Bitwise exclusivo OR
+ | Bitwise inclusivo OR
+ */
+
+ // Incrementações
+ int i = 0;
+ Console.WriteLine("\n->Inc/Dec-rementation");
+ Console.WriteLine(i++); //i = 1. Post-Incrementation
+ Console.WriteLine(++i); //i = 2. Pre-Incrementation
+ Console.WriteLine(i--); //i = 1. Post-Decrementation
+ Console.WriteLine(--i); //i = 0. Pre-Decrementation
+
+ ///////////////////////////////////////
+ // Estrutura de Controle
+ ///////////////////////////////////////
+ Console.WriteLine("\n->Control Structures");
+
+ // Declaração if é como a linguagem C
+ int j = 10;
+ if (j == 10)
+ {
+ Console.WriteLine("I get printed");
+ }
+ else if (j > 10)
+ {
+ Console.WriteLine("I don't");
+ }
+ else
+ {
+ Console.WriteLine("I also don't");
+ }
+
+ // Operador Ternário
+ // Um simples if/else pode ser escrito da seguinte forma
+ // <condição> ? <verdadeiro> : <falso>
+ int toCompare = 17;
+ string isTrue = toCompare == 17 ? "True" : "False";
+
+ // While loop
+ int fooWhile = 0;
+ while (fooWhile < 100)
+ {
+ //Iterated 100 times, fooWhile 0->99
+ fooWhile++;
+ }
+
+ // Do While Loop
+ int fooDoWhile = 0;
+ do
+ {
+ // Inicia a interação 100 vezes, fooDoWhile 0->99
+ if (false)
+ continue; // pule a intereção atual para apróxima
+
+ fooDoWhile++;
+
+ if (fooDoWhile == 50)
+ break; // Interrompe o laço inteiro
+
+ } while (fooDoWhile < 100);
+
+ //estrutura de loop for => for(<declaração para começar>; <condicional>; <passos>)
+ for (int fooFor = 0; fooFor < 10; fooFor++)
+ {
+ //Iterado 10 vezes, fooFor 0->9
+ }
+
+ // For Each Loop
+ // Estrutura do foreach => foreach(<Tipo Iterador> <Nome do Iterador> in <enumerable>)
+ // O laço foreach percorre sobre qualquer objeto que implementa IEnumerable ou IEnumerable<T>
+ // Toda a coleção de tipos (Array, List, Dictionary...) no .Net framework
+ // implementa uma ou mais destas interfaces.
+ // (O ToCharArray() pode ser removido, por que uma string também implementa IEnumerable)
+ foreach (char character in "Hello World".ToCharArray())
+ {
+ //Iterated over all the characters in the string
+ }
+
+ // Switch Case
+ // Um switch funciona com os tipos de dados byte, short, char, e int.
+ // Isto também funcional com tipos enumeradors (discutidos em Tipos Enum),
+ // A classe String, and a few special classes that wrap
+ // tipos primitívos: Character, Byte, Short, and Integer.
+ int month = 3;
+ string monthString;
+ switch (month)
+ {
+ case 1:
+ monthString = "January";
+ break;
+ case 2:
+ monthString = "February";
+ break;
+ case 3:
+ monthString = "March";
+ break;
+ // You can assign more than one case to an action
+ // But you can't add an action without a break before another case
+ // (if you want to do this, you would have to explicitly add a goto case x
+ case 6:
+ case 7:
+ case 8:
+ monthString = "Summer time!!";
+ break;
+ default:
+ monthString = "Some other month";
+ break;
+ }
+
+ ///////////////////////////////////////
+ // Converting Data Types And Typecasting
+ ///////////////////////////////////////
+
+ // Converting data
+
+ // Convert String To Integer
+ // this will throw a FormatException on failure
+ int.Parse("123");//returns an integer version of "123"
+
+ // try parse will default to type default on failure
+ // in this case: 0
+ int tryInt;
+ if (int.TryParse("123", out tryInt)) // Function is boolean
+ Console.WriteLine(tryInt); // 123
+
+ // Convert Integer To String
+ // Convert class has a number of methods to facilitate conversions
+ Convert.ToString(123);
+ // or
+ tryInt.ToString();
+
+ // Casting
+ // Cast decimal 15 to a int
+ // and then implicitly cast to long
+ long x = (int) 15M;
+ }
+
+ ///////////////////////////////////////
+ // CLASSES - see definitions at end of file
+ ///////////////////////////////////////
+ public static void Classes()
+ {
+ // See Declaration of objects at end of file
+
+ // Use new to instantiate a class
+ Bicycle trek = new Bicycle();
+
+ // Call object methods
+ trek.SpeedUp(3); // You should always use setter and getter methods
+ trek.Cadence = 100;
+
+ // ToString is a convention to display the value of this Object.
+ Console.WriteLine("trek info: " + trek.Info());
+
+ // Instantiate a new Penny Farthing
+ PennyFarthing funbike = new PennyFarthing(1, 10);
+ Console.WriteLine("funbike info: " + funbike.Info());
+
+ Console.Read();
+ } // End main method
+
+ // CONSOLE ENTRY A console application must have a main method as an entry point
+ public static void Main(string[] args)
+ {
+ OtherInterestingFeatures();
+ }
+
+ //
+ // INTERESTING FEATURES
+ //
+
+ // DEFAULT METHOD SIGNATURES
+
+ public // Visibility
+ static // Allows for direct call on class without object
+ int // Return Type,
+ MethodSignatures(
+ int maxCount, // First variable, expects an int
+ int count = 0, // will default the value to 0 if not passed in
+ int another = 3,
+ params string[] otherParams // captures all other parameters passed to method
+ )
+ {
+ return -1;
+ }
+
+ // Methods can have the same name, as long as the signature is unique
+ // A method that differs only in return type is not unique
+ public static void MethodSignatures(
+ ref int maxCount, // Pass by reference
+ out int count)
+ {
+ count = 15; // out param must be assigned before control leaves the method
+ }
+
+ // GENERICS
+ // The classes for TKey and TValue is specified by the user calling this function.
+ // This method emulates the SetDefault of Python
+ public static TValue SetDefault<TKey, TValue>(
+ IDictionary<TKey, TValue> dictionary,
+ TKey key,
+ TValue defaultItem)
+ {
+ TValue result;
+ if (!dictionary.TryGetValue(key, out result))
+ return dictionary[key] = defaultItem;
+ return result;
+ }
+
+ // You can narrow down the objects that are passed in
+ public static void IterateAndPrint<T>(T toPrint) where T: IEnumerable<int>
+ {
+ // We can iterate, since T is a IEnumerable
+ foreach (var item in toPrint)
+ // Item is an int
+ Console.WriteLine(item.ToString());
+ }
+
+ public static void OtherInterestingFeatures()
+ {
+ // OPTIONAL PARAMETERS
+ MethodSignatures(3, 1, 3, "Some", "Extra", "Strings");
+ MethodSignatures(3, another: 3); // explicity set a parameter, skipping optional ones
+
+ // BY REF AND OUT PARAMETERS
+ int maxCount = 0, count; // ref params must have value
+ MethodSignatures(ref maxCount, out count);
+
+ // EXTENSION METHODS
+ int i = 3;
+ i.Print(); // Defined below
+
+ // NULLABLE TYPES - great for database interaction / return values
+ // any value type (i.e. not a class) can be made nullable by suffixing a ?
+ // <type>? <var name> = <value>
+ int? nullable = null; // short hand for Nullable<int>
+ Console.WriteLine("Nullable variable: " + nullable);
+ bool hasValue = nullable.HasValue; // true if not null
+
+ // ?? is syntactic sugar for specifying default value (coalesce)
+ // in case variable is null
+ int notNullable = nullable ?? 0; // 0
+
+ // IMPLICITLY TYPED VARIABLES - you can let the compiler work out what the type is:
+ var magic = "magic is a string, at compile time, so you still get type safety";
+ // magic = 9; will not work as magic is a string, not an int
+
+ // GENERICS
+ //
+ var phonebook = new Dictionary<string, string>() {
+ {"Sarah", "212 555 5555"} // Add some entries to the phone book
+ };
+
+ // Calling SETDEFAULT defined as a generic above
+ Console.WriteLine(SetDefault<string,string>(phonebook, "Shaun", "No Phone")); // No Phone
+ // nb, you don't need to specify the TKey and TValue since they can be
+ // derived implicitly
+ Console.WriteLine(SetDefault(phonebook, "Sarah", "No Phone")); // 212 555 5555
+
+ // LAMBDA EXPRESSIONS - allow you to write code in line
+ Func<int, int> square = (x) => x * x; // Last T item is the return value
+ Console.WriteLine(square(3)); // 9
+
+ // ERROR HANDLING - coping with an uncertain world
+ try
+ {
+ var funBike = PennyFarthing.CreateWithGears(6);
+
+ // will no longer execute because CreateWithGears throws an exception
+ string some = "";
+ if (true) some = null;
+ some.ToLower(); // throws a NullReferenceException
+ }
+ catch (NotSupportedException)
+ {
+ Console.WriteLine("Not so much fun now!");
+ }
+ catch (Exception ex) // catch all other exceptions
+ {
+ throw new ApplicationException("It hit the fan", ex);
+ // throw; // A rethrow that preserves the callstack
+ }
+ // catch { } // catch-all without capturing the Exception
+ finally
+ {
+ // executes after try or catch
+ }
+
+ // DISPOSABLE RESOURCES MANAGEMENT - let you handle unmanaged resources easily.
+ // Most of objects that access unmanaged resources (file handle, device contexts, etc.)
+ // implement the IDisposable interface. The using statement takes care of
+ // cleaning those IDisposable objects for you.
+ using (StreamWriter writer = new StreamWriter("log.txt"))
+ {
+ writer.WriteLine("Nothing suspicious here");
+ // At the end of scope, resources will be released.
+ // Even if an exception is thrown.
+ }
+
+ // PARALLEL FRAMEWORK
+ // http://blogs.msdn.com/b/csharpfaq/archive/2010/06/01/parallel-programming-in-net-framework-4-getting-started.aspx
+ var websites = new string[] {
+ "http://www.google.com", "http://www.reddit.com",
+ "http://www.shaunmccarthy.com"
+ };
+ var responses = new Dictionary<string, string>();
+
+ // Will spin up separate threads for each request, and join on them
+ // before going to the next step!
+ Parallel.ForEach(websites,
+ new ParallelOptions() {MaxDegreeOfParallelism = 3}, // max of 3 threads
+ website =>
+ {
+ // Do something that takes a long time on the file
+ using (var r = WebRequest.Create(new Uri(website)).GetResponse())
+ {
+ responses[website] = r.ContentType;
+ }
+ });
+
+ // This won't happen till after all requests have been completed
+ foreach (var key in responses.Keys)
+ Console.WriteLine("{0}:{1}", key, responses[key]);
+
+ // DYNAMIC OBJECTS (great for working with other languages)
+ dynamic student = new ExpandoObject();
+ student.FirstName = "First Name"; // No need to define class first!
+
+ // You can even add methods (returns a string, and takes in a string)
+ student.Introduce = new Func<string, string>(
+ (introduceTo) => string.Format("Hey {0}, this is {1}", student.FirstName, introduceTo));
+ Console.WriteLine(student.Introduce("Beth"));
+
+ // IQUERYABLE<T> - almost all collections implement this, which gives you a lot of
+ // very useful Map / Filter / Reduce style methods
+ var bikes = new List<Bicycle>();
+ bikes.Sort(); // Sorts the array
+ bikes.Sort((b1, b2) => b1.Wheels.CompareTo(b2.Wheels)); // Sorts based on wheels
+ var result = bikes
+ .Where(b => b.Wheels > 3) // Filters - chainable (returns IQueryable of previous type)
+ .Where(b => b.IsBroken && b.HasTassles)
+ .Select(b => b.ToString()); // Map - we only this selects, so result is a IQueryable<string>
+
+ var sum = bikes.Sum(b => b.Wheels); // Reduce - sums all the wheels in the collection
+
+ // Create a list of IMPLICIT objects based on some parameters of the bike
+ var bikeSummaries = bikes.Select(b=>new { Name = b.Name, IsAwesome = !b.IsBroken && b.HasTassles });
+ // Hard to show here, but you get type ahead completion since the compiler can implicitly work
+ // out the types above!
+ foreach (var bikeSummary in bikeSummaries.Where(b => b.IsAwesome))
+ Console.WriteLine(bikeSummary.Name);
+
+ // ASPARALLEL
+ // And this is where things get wicked - combines linq and parallel operations
+ var threeWheelers = bikes.AsParallel().Where(b => b.Wheels == 3).Select(b => b.Name);
+ // this will happen in parallel! Threads will automagically be spun up and the
+ // results divvied amongst them! Amazing for large datasets when you have lots of
+ // cores
+
+ // LINQ - maps a store to IQueryable<T> objects, with delayed execution
+ // e.g. LinqToSql - maps to a database, LinqToXml maps to an xml document
+ var db = new BikeRepository();
+
+ // execution is delayed, which is great when querying a database
+ var filter = db.Bikes.Where(b => b.HasTassles); // no query run
+ if (42 > 6) // You can keep adding filters, even conditionally - great for "advanced search" functionality
+ filter = filter.Where(b => b.IsBroken); // no query run
+
+ var query = filter
+ .OrderBy(b => b.Wheels)
+ .ThenBy(b => b.Name)
+ .Select(b => b.Name); // still no query run
+
+ // Now the query runs, but opens a reader, so only populates are you iterate through
+ foreach (string bike in query)
+ Console.WriteLine(result);
+
+
+
+ }
+
+ } // End LearnCSharp class
+
+ // You can include other classes in a .cs file
+
+ public static class Extensions
+ {
+ // EXTENSION FUNCTIONS
+ public static void Print(this object obj)
+ {
+ Console.WriteLine(obj.ToString());
+ }
+ }
+
+ // Class Declaration Syntax:
+ // <public/private/protected/internal> class <class name>{
+ // //data fields, constructors, functions all inside.
+ // //functions are called as methods in Java.
+ // }
+
+ public class Bicycle
+ {
+ // Bicycle's Fields/Variables
+ public int Cadence // Public: Can be accessed from anywhere
+ {
+ get // get - define a method to retrieve the property
+ {
+ return _cadence;
+ }
+ set // set - define a method to set a proprety
+ {
+ _cadence = value; // Value is the value passed in to the setter
+ }
+ }
+ private int _cadence;
+
+ protected virtual int Gear // Protected: Accessible from the class and subclasses
+ {
+ get; // creates an auto property so you don't need a member field
+ set;
+ }
+
+ internal int Wheels // Internal: Accessible from within the assembly
+ {
+ get;
+ private set; // You can set modifiers on the get/set methods
+ }
+
+ int _speed; // Everything is private by default: Only accessible from within this class.
+ // can also use keyword private
+ public string Name { get; set; }
+
+ // Enum is a value type that consists of a set of named constants
+ // It is really just mapping a name to a value (an int, unless specified otherwise).
+ // The approved types for an enum are byte, sbyte, short, ushort, int, uint, long, or ulong.
+ // An enum can't contain the same value twice.
+ public enum BikeBrand
+ {
+ AIST,
+ BMC,
+ Electra = 42, //you can explicitly set a value to a name
+ Gitane // 43
+ }
+ // We defined this type inside a Bicycle class, so it is a nested type
+ // Code outside of this class should reference this type as Bicycle.Brand
+
+ public BikeBrand Brand; // After declaring an enum type, we can declare the field of this type
+
+ // Decorate an enum with the FlagsAttribute to indicate that multiple values can be switched on
+ [Flags] // Any class derived from Attribute can be used to decorate types, methods, parameters etc
+ public enum BikeAccessories
+ {
+ None = 0,
+ Bell = 1,
+ MudGuards = 2, // need to set the values manually!
+ Racks = 4,
+ Lights = 8,
+ FullPackage = Bell | MudGuards | Racks | Lights
+ }
+
+ // Usage: aBike.Accessories.HasFlag(Bicycle.BikeAccessories.Bell)
+ // Before .NET 4: (aBike.Accessories & Bicycle.BikeAccessories.Bell) == Bicycle.BikeAccessories.Bell
+ public BikeAccessories Accessories { get; set; }
+
+ // Static members belong to the type itself rather then specific object.
+ // You can access them without a reference to any object:
+ // Console.WriteLine("Bicycles created: " + Bicycle.bicyclesCreated);
+ public static int BicyclesCreated { get; set; }
+
+ // readonly values are set at run time
+ // they can only be assigned upon declaration or in a constructor
+ readonly bool _hasCardsInSpokes = false; // read-only private
+
+ // Constructors are a way of creating classes
+ // This is a default constructor
+ public Bicycle()
+ {
+ this.Gear = 1; // you can access members of the object with the keyword this
+ Cadence = 50; // but you don't always need it
+ _speed = 5;
+ Name = "Bontrager";
+ Brand = BikeBrand.AIST;
+ BicyclesCreated++;
+ }
+
+ // This is a specified constructor (it contains arguments)
+ public Bicycle(int startCadence, int startSpeed, int startGear,
+ string name, bool hasCardsInSpokes, BikeBrand brand)
+ : base() // calls base first
+ {
+ Gear = startGear;
+ Cadence = startCadence;
+ _speed = startSpeed;
+ Name = name;
+ _hasCardsInSpokes = hasCardsInSpokes;
+ Brand = brand;
+ }
+
+ // Constructors can be chained
+ public Bicycle(int startCadence, int startSpeed, BikeBrand brand) :
+ this(startCadence, startSpeed, 0, "big wheels", true, brand)
+ {
+ }
+
+ // Function Syntax:
+ // <public/private/protected> <return type> <function name>(<args>)
+
+ // classes can implement getters and setters for their fields
+ // or they can implement properties (this is the preferred way in C#)
+
+ // Method parameters can have default values.
+ // In this case, methods can be called with these parameters omitted
+ public void SpeedUp(int increment = 1)
+ {
+ _speed += increment;
+ }
+
+ public void SlowDown(int decrement = 1)
+ {
+ _speed -= decrement;
+ }
+
+ // properties get/set values
+ // when only data needs to be accessed, consider using properties.
+ // properties may have either get or set, or both
+ private bool _hasTassles; // private variable
+ public bool HasTassles // public accessor
+ {
+ get { return _hasTassles; }
+ set { _hasTassles = value; }
+ }
+
+ // You can also define an automatic property in one line
+ // this syntax will create a backing field automatically.
+ // You can set an access modifier on either the getter or the setter (or both)
+ // to restrict its access:
+ public bool IsBroken { get; private set; }
+
+ // Properties can be auto-implemented
+ public int FrameSize
+ {
+ get;
+ // you are able to specify access modifiers for either get or set
+ // this means only Bicycle class can call set on Framesize
+ private set;
+ }
+
+ // It's also possible to define custom Indexers on objects.
+ // All though this is not entirely useful in this example, you
+ // could do bicycle[0] which yields "chris" to get the first passenger or
+ // bicycle[1] = "lisa" to set the passenger. (of this apparent quattrocycle)
+ private string[] passengers = { "chris", "phil", "darren", "regina" };
+
+ public string this[int i]
+ {
+ get {
+ return passengers[i];
+ }
+
+ set {
+ return passengers[i] = value;
+ }
+ }
+
+ //Method to display the attribute values of this Object.
+ public virtual string Info()
+ {
+ return "Gear: " + Gear +
+ " Cadence: " + Cadence +
+ " Speed: " + _speed +
+ " Name: " + Name +
+ " Cards in Spokes: " + (_hasCardsInSpokes ? "yes" : "no") +
+ "\n------------------------------\n"
+ ;
+ }
+
+ // Methods can also be static. It can be useful for helper methods
+ public static bool DidWeCreateEnoughBycles()
+ {
+ // Within a static method, we only can reference static class members
+ return BicyclesCreated > 9000;
+ } // If your class only needs static members, consider marking the class itself as static.
+
+
+ } // end class Bicycle
+
+ // PennyFarthing is a subclass of Bicycle
+ class PennyFarthing : Bicycle
+ {
+ // (Penny Farthings are those bicycles with the big front wheel.
+ // They have no gears.)
+
+ // calling parent constructor
+ public PennyFarthing(int startCadence, int startSpeed) :
+ base(startCadence, startSpeed, 0, "PennyFarthing", true, BikeBrand.Electra)
+ {
+ }
+
+ protected override int Gear
+ {
+ get
+ {
+ return 0;
+ }
+ set
+ {
+ throw new InvalidOperationException("You can't change gears on a PennyFarthing");
+ }
+ }
+
+ public static PennyFarthing CreateWithGears(int gears)
+ {
+ var penny = new PennyFarthing(1, 1);
+ penny.Gear = gears; // Oops, can't do this!
+ return penny;
+ }
+
+ public override string Info()
+ {
+ string result = "PennyFarthing bicycle ";
+ result += base.ToString(); // Calling the base version of the method
+ return result;
+ }
+ }
+
+ // Interfaces only contain signatures of the members, without the implementation.
+ interface IJumpable
+ {
+ void Jump(int meters); // all interface members are implicitly public
+ }
+
+ interface IBreakable
+ {
+ 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
+ class MountainBike : Bicycle, IJumpable, IBreakable
+ {
+ int damage = 0;
+
+ public void Jump(int meters)
+ {
+ damage += meters;
+ }
+
+ public bool Broken
+ {
+ get
+ {
+ return damage > 100;
+ }
+ }
+ }
+
+ /// <summary>
+ /// Used to connect to DB for LinqToSql example.
+ /// EntityFramework Code First is awesome (similar to Ruby's ActiveRecord, but bidirectional)
+ /// http://msdn.microsoft.com/en-us/data/jj193542.aspx
+ /// </summary>
+ public class BikeRepository : DbContext
+ {
+ public BikeRepository()
+ : base()
+ {
+ }
+
+ public DbSet<Bicycle> Bikes { get; set; }
+ }
+} // End Namespace
+```
+
+## Topics Not Covered
+
+ * Attributes
+ * async/await, yield, pragma directives
+ * Web Development
+ * ASP.NET MVC & WebApi (new)
+ * ASP.NET Web Forms (old)
+ * WebMatrix (tool)
+ * Desktop Development
+ * Windows Presentation Foundation (WPF) (new)
+ * Winforms (old)
+
+## Further Reading
+
+ * [DotNetPerls](http://www.dotnetperls.com)
+ * [C# in Depth](http://manning.com/skeet2)
+ * [Programming C#](http://shop.oreilly.com/product/0636920024064.do)
+ * [LINQ](http://shop.oreilly.com/product/9780596519254.do)
+ * [MSDN Library](http://msdn.microsoft.com/en-us/library/618ayhy6.aspx)
+ * [ASP.NET MVC Tutorials](http://www.asp.net/mvc/tutorials)
+ * [ASP.NET Web Matrix Tutorials](http://www.asp.net/web-pages/tutorials)
+ * [ASP.NET Web Forms Tutorials](http://www.asp.net/web-forms/tutorials)
+ * [Windows Forms Programming in C#](http://www.amazon.com/Windows-Forms-Programming-Chris-Sells/dp/0321116208)
+ * [C# Coding Conventions](http://msdn.microsoft.com/en-us/library/vstudio/ff926074.aspx)
diff --git a/pt-br/dynamic-programming-pt.html.markdown b/pt-br/dynamic-programming-pt.html.markdown
new file mode 100644
index 00000000..8de9bee6
--- /dev/null
+++ b/pt-br/dynamic-programming-pt.html.markdown
@@ -0,0 +1,76 @@
+---
+category: Algorithms & Data Structures
+name: Dynamic Programming
+contributors:
+ - ["Akashdeep Goel", "http://github.com/akashdeepgoel"]
+translators:
+ - ["Claudson Martins", "https://github.com/claudsonm"]
+lang: pt-br
+---
+
+# Programação Dinâmica
+
+## Introdução
+
+Programação Dinâmica é uma técnica poderosa utilizada para resolver uma classe
+particular de problemas como veremos. A ideia é bastante simples, se você
+solucionou um problema com uma dada entrada, então salve o resultado para
+referência futura, e também para evitar resolver o mesmo problema novamente.
+
+Sempre se lembre!!
+"Aqueles que não conseguem lembrar o passado estão condenados a repeti-lo"
+
+## Maneiras de Solucionar tais Problemas
+
+1. Top-Down (De cima para baixo): Começe 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,
+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.
+
+## Exemplo de Programação Dinâmica
+
+O problema da subsequência crescente máxima consiste em encontrar a maior
+subsequência crescente de uma dada sequência. Dada uma sequência
+S= {a1 , a2 , a3, a4, ... , an-1, an} nós temos que encontrar o maior subconjunto
+de forma que para todo j e i, j < i no subconjunto aj < ai. Antes de mais nada
+nós temos que encontrar o valor das maiores subsequências (LSi) para cada índice
+i com o último elemento da sequência sendo ai. Então a maior LSi será a maior
+subsequência na sequência dada. Para começar LSi é atribuído a um pois ai é
+elemento da sequência (último elemento). Então para todo j tal que j < i e aj <
+ai, nós procuramos o maior LSj e o adicionamos a LSi. Portanto o algoritmo tem
+complexidade de tempo O(n2). O pseudocódigo para procurar o comprimento da
+subsequência crescente máxima: A complexidade desse algoritmo poderia ser
+reduzida utilizando uma estrutura de dados melhor que um array. Armazenando o
+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
+ for j=0 to i-1
+ if (a[i] > a[j] and LS[i]<LS[j])
+ LS[i] = LS[j]+1
+ for i=0 to n-1
+ 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
+
+Longest Common Subsequence - Tutorial and C Program source code : http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence
+```
+
+## Recursos Online (EN)
+
+* [codechef](https://www.codechef.com/wiki/tutorial-dynamic-programming)
diff --git a/pt-br/elixir.html.markdown b/pt-br/elixir.html.markdown
new file mode 100644
index 00000000..f8c56101
--- /dev/null
+++ b/pt-br/elixir.html.markdown
@@ -0,0 +1,412 @@
+---
+language: elixir
+contributors:
+ - ["Joao Marques", "http://github.com/mrshankly"]
+ - ["Dzianis Dashkevich", "https://github.com/dskecse"]
+translators:
+ - ["Rodrigo Muniz", "http://github.com/muniz95"]
+lang: pt-br
+filename: learnelixir-pt.ex
+---
+
+Elixir é uma linguagem funcional moderna construída no topo da Erlang VM.
+É totalmente compatível com Erlang, porém conta com uma sintaxe mais padronizada
+e muitos outros recursos.
+
+```elixir
+
+# Comentários de linha única começam com um símbolo de número.
+
+# Não há comentários de múltiplas linhas,
+# mas você pode empilhar os comentários.
+
+# Para usar o shell do elixir use o comando `iex`.
+# Compile seus módulos com o comando `elixirc`.
+
+# Ambos devem estar em seu path se você instalou o Elixir corretamente.
+
+## ---------------------------
+## -- Tipos Básicos
+## ---------------------------
+
+# Há números
+3 # integer
+0x1F # integer
+3.0 # float
+
+# Atoms, que são literais, uma constante com nome. Elas começam com `:`.
+:hello # atom
+
+# Tuplas que são guardadas contiguamente em memória.
+{1,2,3} # tupla
+
+# Podemos acessar um elemento de uma tupla om a função `elem`:
+elem({1, 2, 3}, 0) #=> 1
+
+# Listas que são implementadas como listas ligadas.
+[1,2,3] # lista
+
+# Podemos acessar a primeira posição (head) e o resto (tail) de uma lista como a seguir:
+[head | tail] = [1,2,3]
+head #=> 1
+tail #=> [2,3]
+
+# Em elixir, bem como em Erlang, o sinal `=` denota pattern match,
+# e não uma atribuição.
+#
+# Isto significa que o que estiver à esquerda (pattern) é comparado com o que
+# estiver à direita.
+#
+# É assim que o exemplo acima de acesso à head e tail de uma lista funciona.
+
+# Um pattern match retornará erro quando os lados não conferem, como neste exemplo
+# onde as tuplas tem diferentes tamanhos.
+# {a, b, c} = {1, 2} #=> ** (MatchError) no match of right hand side value: {1,2}
+
+# Também há binários
+<<1,2,3>> # binary
+
+# Strings e char lists
+"hello" # string
+'hello' # char list
+
+# Strings de múltiplas linhas
+"""
+Strings
+de múltiplas
+linhas.
+"""
+#=> "Strings\nde múltiplas\nlinhas"
+
+# Strings são sempre codificadas em UTF-8:
+"héllò" #=> "héllò"
+
+# Strings são de fato apenas binários, e char lists apenas listas.
+<<?a, ?b, ?c>> #=> "abc"
+[?a, ?b, ?c] #=> 'abc'
+
+# `?a` em elixir retorna o valor ASCII para a letra `a`
+?a #=> 97
+
+# Para concatenar listas use `++`, para binários use `<>`
+[1,2,3] ++ [4,5] #=> [1,2,3,4,5]
+'hello ' ++ 'world' #=> 'hello world'
+
+<<1,2,3>> <> <<4,5>> #=> <<1,2,3,4,5>>
+"hello " <> "world" #=> "hello world"
+
+# Ranges são representados como `início..fim` (ambos inclusivos)
+1..10 #=> 1..10
+menor..maior = 1..10 # Pattern matching pode ser usada em ranges também
+[lower, upper] #=> [1, 10]
+
+## ---------------------------
+## -- Operadores
+## ---------------------------
+
+# Matemática básica
+1 + 1 #=> 2
+10 - 5 #=> 5
+5 * 2 #=> 10
+10 / 2 #=> 5.0
+
+# Em elixir o operador `/` sempre retorna um float.
+
+# Para divisão de inteiros use `div`
+div(10, 2) #=> 5
+
+# Para obter o resto da divisão use `rem`
+rem(10, 3) #=> 1
+
+# Há também operadores booleanos: `or`, `and` e `not`.
+# Estes operadores esperam um booleano como primeiro argumento.
+true and true #=> true
+false or true #=> true
+# 1 and true #=> ** (ArgumentError) argument error
+
+# Elixir também fornece `||`, `&&` e `!` que aceitam argumentos de qualquer tipo.
+# Todos os valores exceto `false` e `nil` serão avaliados como true.
+1 || true #=> 1
+false && 1 #=> false
+nil && 20 #=> nil
+!true #=> false
+
+# Para comparações temos: `==`, `!=`, `===`, `!==`, `<=`, `>=`, `<` e `>`
+1 == 1 #=> true
+1 != 1 #=> false
+1 < 2 #=> true
+
+# `===` e `!==` são mais estritos ao comparar integers e floats:
+1 == 1.0 #=> true
+1 === 1.0 #=> false
+
+# Podemos comparar também dois tipos de dados diferentes:
+1 < :hello #=> true
+
+# A regra de ordenação no geral é definida abaixo:
+# number < atom < reference < functions < port < pid < tuple < list < bit string
+
+# Ao citar Joe Armstrong nisto: "A ordem de fato não é importante,
+# mas que uma ordem total esteja bem definida é importante."
+
+## ---------------------------
+## -- Fluxo de Controle
+## ---------------------------
+
+# expressão `if`
+if false do
+ "Isso nunca será visto"
+else
+ "Isso será"
+end
+
+# Também há `unless`
+unless true do
+ "Isso nunca será visto"
+else
+ "Isso será"
+end
+
+# Lembra do patter matching? Muitas estruturas de fluxo de controle em elixir contam com ela.
+
+# `case` nos permite comparar um valor com muitos patterns:
+case {:um, :dois} do
+ {:quatro, :cinco} ->
+ "Isso não corresponde"
+ {:um, x} ->
+ "Isso corresponde e vincula `x` a `:dois`"
+ _ ->
+ "Isso corresponde a qualquer valor"
+end
+
+# É comum vincular o valor a `_` se não precisamos dele.
+# Por exemplo, se apenas a head de uma lista nos interessa:
+[head | _] = [1,2,3]
+head #=> 1
+
+# Para melhor legibilidade podemos fazer o seguinte:
+[head | _tail] = [:a, :b, :c]
+head #=> :a
+
+# `cond` nos permite verificar várias condições ao mesmo tempo.
+# Use `cond` em vez de aninhar vários `if`'s.
+cond do
+ 1 + 1 == 3 ->
+ "Nunca serei visto"
+ 2 * 5 == 12 ->
+ "Nem eu"
+ 1 + 2 == 3 ->
+ "Mas eu serei"
+end
+
+# É comum definir a última condição igual a `true`, que sempre irá corresponder.
+cond do
+ 1 + 1 == 3 ->
+ "Nunca serei visto"
+ 2 * 5 == 12 ->
+ "Nem eu"
+ true ->
+ "Mas eu serei (isso é essencialmente um else)"
+end
+
+# `try/catch` é usado para capturar valores que são lançados, também suporta uma
+# cláusula `after` que é invocada havendo um valor capturado ou não.
+try do
+ throw(:hello)
+catch
+ message -> "Deu #{mensagem}."
+after
+ IO.puts("Sou o after.")
+end
+#=> Sou o after
+# "Deu :hello"
+
+## ---------------------------
+## -- Módulos e Funções
+## ---------------------------
+
+# Funções Anônimas (repare o ponto)
+square = fn(x) -> x * x end
+square.(5) #=> 25
+
+# Elas também aceitam várias cláusulas e guards.
+# Guards permitem ajustes finos de pattern matching,
+# sendo indicados pela palavra `when`:
+f = fn
+ x, y when x > 0 -> x + y
+ x, y -> x * y
+end
+
+f.(1, 3) #=> 4
+f.(-1, 3) #=> -3
+
+# Elixir também fornece várias funções embutidas.
+# Estas estão disponíveis no escopo atual.
+is_number(10) #=> true
+is_list("ola") #=> false
+elem({1,2,3}, 0) #=> 1
+
+# Você pode agrupar algumas funções em um módulo. Dentro de um módulo use `def`
+# para definir suas funções.
+defmodule Math do
+ def sum(a, b) do
+ a + b
+ end
+
+ def square(x) do
+ x * x
+ end
+end
+
+Math.sum(1, 2) #=> 3
+Math.square(3) #=> 9
+
+# Para compilar o módulo Math salve-o como `math.ex` e use `elixirc`
+# em seu terminal: elixirc math.ex
+
+# Dentro de um módulo podemos definir funções com `def` e funções privadas com `defp`.
+# Uma função definida com `def` pode ser invocada por outros módulos,
+# já uma função privada pode ser invocada apenas localmente.
+defmodule PrivateMath do
+ def sum(a, b) do
+ do_sum(a, b)
+ end
+
+ defp do_sum(a, b) do
+ a + b
+ end
+end
+
+PrivateMath.sum(1, 2) #=> 3
+# PrivateMath.do_sum(1, 2) #=> ** (UndefinedFunctionError)
+
+# Declarações de funções também suportam guards cláusulas múltiplas:
+defmodule Geometry do
+ def area({:rectangle, w, h}) do
+ w * h
+ end
+
+ def area({:circle, r}) when is_number(r) do
+ 3.14 * r * r
+ end
+end
+
+Geometry.area({:rectangle, 2, 3}) #=> 6
+Geometry.area({:circle, 3}) #=> 28.25999999999999801048
+# Geometry.area({:circle, "not_a_number"})
+#=> ** (FunctionClauseError) no function clause matching in Geometry.area/1
+
+# Devido à imutabilidade, recursão é uma grande parte do elixir
+defmodule Recursion do
+ def sum_list([head | tail], acc) do
+ sum_list(tail, acc + head)
+ end
+
+ def sum_list([], acc) do
+ acc
+ end
+end
+
+Recursion.sum_list([1,2,3], 0) #=> 6
+
+# Módulos do elixir suportam atributos, hpa atributos embutidos e você
+# pode também adicionar os seus próprios.
+defmodule MyMod do
+ @moduledoc """
+ Este é um atributo embutido em um módulo de exemplo.
+ """
+
+ @my_data 100 # Este é um atributo customizado.
+ IO.inspect(@my_data) #=> 100
+end
+
+## ---------------------------
+## -- Structs e Exceptions
+## ---------------------------
+
+# Structs são extensões no topo de mapas que trazem valores padrão,
+# garantias em tempo de compilação e polimorfismo para o Elixir.
+defmodule Pessoa do
+ defstruct nome: nil, idade: 0, peso: 0
+end
+
+joe_info = %Pessoa{ nome: "Joe", idade: 30, peso: 180 }
+#=> %Pessoa{idade: 30, peso: 180, nome: "Joe"}
+
+# Acessa o valor de nome
+joe_info.name #=> "Joe"
+
+# Atualiza o valor de idade
+older_joe_info = %{ joe_info | idade: 31 }
+#=> %Pessoa{idade: 31, peso: 180, nome: "Joe"}
+
+# O bloco `try` com a palavra `rescue` é usado para manipular exceções
+try do
+ raise "algum erro"
+rescue
+ RuntimeError -> "resgatado um erro em tempo de execução"
+ _error -> "isso resgatará qualquer erro"
+end
+
+# Toda exceção possui uma mensagem
+try do
+ raise "algum erro"
+rescue
+ x in [RuntimeError] ->
+ x.message
+end
+
+## ---------------------------
+## -- Concorrência
+## ---------------------------
+
+# Elixir conta com o modelo de ator para concorrência. Tudo o que precisamos para
+# escrever programas concorrentes em elixir são três primitivos: spawning processes,
+# sending messages e receiving messages.
+
+# Para iniciar um novo processo usamos a função `spawn`, a qual leva uma função
+# como argumento.
+f = fn -> 2 * 2 end #=> #Function<erl_eval.20.80484245>
+spawn(f) #=> #PID<0.40.0>
+
+# `spawn` retorna um pid (process identifier), você pode usar esse pid para enviar
+# mensagens ao processo. Para envio de mensagens usamos o operador `send`.
+# Para tudo isso ser útil precisamos estar aptos a receber mensagens. Isto é
+# realizado com o mecanismo `receive`:
+defmodule Geometry do
+ def area_loop do
+ receive do
+ {:rectangle, w, h} ->
+ IO.puts("Area = #{w * h}")
+ area_loop()
+ {:circle, r} ->
+ IO.puts("Area = #{3.14 * r * r}")
+ area_loop()
+ end
+ end
+end
+
+# Compile o módulo e crie um processo que avalie `area_loop` no shell
+pid = spawn(fn -> Geometry.area_loop() end) #=> #PID<0.40.0>
+
+# Envia uma mensagem ao `pid` correspondente a um pattern na declaração de recebimento
+send pid, {:rectangle, 2, 3}
+#=> Area = 6
+# {:rectangle,2,3}
+
+send pid, {:circle, 2}
+#=> Area = 12.56000000000000049738
+# {:circle,2}
+
+# O shell também é um processo, você pode usar `self` para obter o pid atual
+self() #=> #PID<0.27.0>
+```
+
+## Referências
+
+* [Getting started guide](http://elixir-lang.org/getting_started/1.html) da [página do elixir](http://elixir-lang.org)
+* [Elixir Documentation](http://elixir-lang.org/docs/master/)
+* ["Programming Elixir"](https://pragprog.com/book/elixir/programming-elixir) por Dave Thomas
+* [Elixir Cheat Sheet](http://media.pragprog.com/titles/elixir/ElixirCheat.pdf)
+* ["Learn You Some Erlang for Great Good!"](http://learnyousomeerlang.com/) por Fred Hebert
+* ["Programming Erlang: Software for a Concurrent World"](https://pragprog.com/book/jaerlang2/programming-erlang) por Joe Armstrong
diff --git a/pt-br/elm-pt.html.markdown b/pt-br/elm-pt.html.markdown
new file mode 100644
index 00000000..78a4f1b7
--- /dev/null
+++ b/pt-br/elm-pt.html.markdown
@@ -0,0 +1,384 @@
+---
+language: Elm
+contributors:
+ - ["Max Goldstein", "http://maxgoldste.in/"]
+translators:
+ - ["Marcel dos Santos", "https://twitter.com/marcelgsantos"]
+lang: pt-br
+filename: learnelm-pt.elm
+---
+
+Elm é uma linguagem de programação funcional reativa que compila para (client-side)
+JavaScript. Elm é estaticamente tipada, significando que o compilador captura a
+maioria dos erros imediatamente e fornece uma mensagem de erro limpa e compreensível.
+Elm é excelente para projetar interfaces de usuário e jogos para a web.
+
+
+```haskell
+-- Comentários de uma linha começam com dois traços.
+{- Comentários de múltiplas linhas podem ser delimitados em um bloco como este.
+{- Eles podem ser aninhados. -}
+-}
+
+{-- O Básico --}
+
+-- Operações Aritméticas
+1 + 1 -- 2
+8 - 1 -- 7
+10 * 2 -- 20
+
+-- Cada número literal sem um ponto decimal pode ser um Int ou um Float.
+33 / 2 -- 16.5 com divisão de ponto flutuante
+33 // 2 -- 16 com divisão inteira
+
+-- Exponenciação
+5 ^ 2 -- 25
+
+-- Booleanos
+not True -- False
+not False -- True
+1 == 1 -- True
+1 /= 1 -- False
+1 < 10 -- True
+
+-- Strings e caracteres
+"Esta é uma string porque ela utiliza aspas duplas."
+'a' -- caracteres entre aspas simples
+
+-- Strings podem ser anexadas.
+"Olá " ++ "mundo!" -- "Olá mundo!"
+
+{-- Listas, Tuplas e Registros --}
+
+-- Cada elemento em uma lista deve ter o mesmo tipo.
+["the", "quick", "brown", "fox"]
+[1, 2, 3, 4, 5]
+-- O segundo exemplo também pode ser escrito com dois pontos.
+[1..5]
+
+-- Junte listas da mesma forma que strings.
+[1..5] ++ [6..10] == [1..10] -- True
+
+-- Para adicionar um item utilize "cons".
+0 :: [1..5] -- [0, 1, 2, 3, 4, 5]
+
+-- A cabeça e a cauda de uma lista são retornadas como uma Maybe. Em vez de
+-- verificar cada valor para ver se ele é nulo, você lida com os valores
+-- faltantes explicitamente.
+List.head [1..5] -- Just 1
+List.tail [1..5] -- Just [2, 3, 4, 5]
+List.head [] -- Nothing
+-- List.functionName siginifica que a função faz parte do módulo List.
+
+-- Cada elemento em uma tupla pode ser de um tipo diferente, mas uma tupla
+-- tem um comprimento fixo.
+("elm", 42)
+
+-- 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
+
+-- Uma tupla vazia ou "unidade" às vezes é utilizada como um placeholder.
+-- É o único valor de seu tipo, também chamado de "Unit".
+()
+
+-- Registros são como tuplas mas os campos possuem nomes. A ordem dos campos
+-- não importa. Observe que os valores dos registros utilizam sinais de igual,
+-- e não dois-pontos.
+{ x = 3, y = 7 }
+
+-- Acesse um campo com um ponto e o nome do campo.
+{ x = 3, y = 7 }.x -- 3
+
+-- Ou com uma função acessora, que é um ponto e o nome do próprio campo.
+.y { x = 3, y = 7 } -- 7
+
+-- Atualiza os campos de um registro. (Ele já deve ter os campos.)
+{ person |
+ name = "George" }
+
+-- Atualiza vários campos de uma só vez utilizando os valores atuais.
+{ particle |
+ position = particle.position + particle.velocity,
+ velocity = particle.velocity + particle.acceleration }
+
+{-- Fluxo de Controle --}
+
+-- Declarações if sempre devem ter um else e os valores devem ser do mesmo tipo.
+if powerLevel > 9000 then
+ "WHOA!"
+else
+ "meh"
+
+-- Declarações if podem ser encadeadas.
+if n < 0 then
+ "n é negativo"
+else if n > 0 then
+ "n é positivo"
+else
+ "n é zero"
+
+-- Utilize declarações case para casar padrões entre diferentes possibilidades.
+case aList of
+ [] -> "casa com uma lista vazia"
+ [x]-> "casa com uma lista de exatamente um item, " ++ toString x
+ x::xs -> "casa com uma lista de pelo menos um item cuja cabeça é " ++ toString x
+-- O casamento do padrão acontece na ordem. Se colocarmos [x] por último, ele
+-- nunca iria casar porque x::xs também casa (xs seria a lista vazia). Os
+-- casamentos não "falham".
+-- O compilador irá alertá-lo sobre casos faltantes ou extras.
+
+-- Casa padrão com um Maybe.
+case List.head aList of
+ Just x -> "A cabeça é " ++ toString x
+ Nothing -> "A lista estava vazia."
+
+{-- Funções --}
+
+-- A sintaxe do Elm é muito mínima, baseando-se principalmente em espaços em
+-- branco em vez de parênteses e chaves. Não existe a palavra-chave "return".
+
+-- Define uma função com seu nome, argumentos, um sinal de igual e o corpo.
+multiply a b =
+ a * b
+
+-- Aplica (chama) uma função passando seus argumentos (vírgulas não necessárias).
+multiply 7 6 -- 42
+
+-- Aplica parcialmente uma função passando somente alguns de seus argumentos.
+-- Dando, em seguida, um novo nome a função.
+double =
+ multiply 2
+
+-- Constantes são semelhantes, exceto que não há argumentos.
+answer =
+ 42
+
+-- Passa funções como argumentos para outras funções.
+List.map double [1..4] -- [2, 4, 6, 8]
+
+-- Ou escreva uma função anônima.
+List.map (\a -> a * 2) [1..4] -- [2, 4, 6, 8]
+
+-- Você pode casar um padrão na definição de funções quando há somente um caso.
+-- Esta função recebe uma tupla em vez de dois argumentos.
+-- Esta é a maneira que você normalmente vai desempacotar/extrair valores de tuplas.
+area (width, height) =
+ width * height
+
+area (6, 7) -- 42
+
+-- Utilize chaves para casar o padrão de nomes de campos de um registro.
+-- Utilize let para definir valores intermediários.
+volume {width, height, depth} =
+ let
+ area = width * height
+ in
+ area * depth
+
+volume { width = 3, height = 2, depth = 7 } -- 42
+
+-- Funções podem ser recursivas.
+fib n =
+ if n < 2 then
+ 1
+ else
+ fib (n - 1) + fib (n - 2)
+
+List.map fib [0..8] -- [1, 1, 2, 3, 5, 8, 13, 21, 34]
+
+-- Outra função recursiva (utilize List.length em um código de verdade).
+listLength aList =
+ case aList of
+ [] -> 0
+ x::xs -> 1 + listLength xs
+
+-- Chamadas de funções acontecem antes de qualquer operador infixo.
+-- Os parênteses indicam a precendência.
+cos (degrees 30) ^ 2 + sin (degrees 30) ^ 2 -- 1
+-- Primeiro degrees é aplicada em 30, então o resultado é passado para as
+-- funções de trigonometria, que então é elevado ao quadrado e, por fim, a
+-- adição acontece.
+
+{-- Tipos e Anotações de Tipos --}
+
+-- O compilador irá inferir o tipo de cada valor em seu programa.
+-- Tipos iniciam com letra maiúscula. Leia x : T como "x é do tipo T".
+-- Alguns tipos comuns que você pode ver no REPL do Elm.
+5 : Int
+6.7 : Float
+"hello" : String
+True : Bool
+
+-- Funções têm tipos também. Leia -> como "vai para". Pense no tipo mais à
+-- direita como o tipo do valor de retorno e os outros como argumentos.
+not : Bool -> Bool
+round : Float -> Int
+
+-- Quando você define um valor, é uma boa prática escrever seu tipo acima dele.
+-- A anotação é uma forma de documentação, que é verifica pelo compilador.
+double : Int -> Int
+double x = x * 2
+
+-- Argumentos de uma função são passados entre parênteses.
+-- Tipos com letra minúscula são tipos variáveis: eles podem ser de qualquer
+-- tipo, desde que cada chamada seja consistente.
+List.map : (a -> b) -> List a -> List b
+-- "List.map é do tipo a-vai-para-b, vai para lista de a e vai para lista de b."
+
+-- Existem três tipos especiais com minúsculas: number, comparable e appendable.
+-- Numbers permite que você utilize aritmética em Ints e Floats.
+-- Comparable permite você ordenar números e strings, como a < b.
+-- Appendable permite que coisas possam ser combinadas com a ++ b.
+
+{-- Type Aliases e Union Types --}
+
+-- Quando você escreve um registro ou uma tupla, seu tipo já existe.
+-- (Observe que os tipos de um registro utilizam dois-pontos e os valores de um
+-- registro utilizam igual.)
+origin : { x : Float, y : Float, z : Float }
+origin =
+ { x = 0, y = 0, z = 0 }
+
+-- Você pode dar um bom nome para tipos existentes com um type alias.
+type alias Point3D =
+ { x : Float, y : Float, z : Float }
+
+-- Se você cria um alias para um registro, você pode usar o nome como uma
+-- função construtora.
+otherOrigin : Point3D
+otherOrigin =
+ Point3D 0 0 0
+
+-- Mas ele ainda é do mesmo tipo, então você pode compará-los.
+origin == otherOrigin -- True
+
+-- Por outro lado, a definição de um union type cria um tipo que não existia
+-- antes. Um union type é chamado assim porque ele pode ser uma de muitas
+-- possibilidades. Cada uma das possibilidades é representada como uma "tag".
+type Direction =
+ North | South | East | West
+
+-- As tags podem levar outros valores de tipos conhecidos. Isso pode trabalhar
+-- recursivamente.
+type IntTree =
+ Leaf | Node Int IntTree IntTree
+-- "Leaf" e "Node" são as tags. Tudo após uma tag é um tipo.
+
+-- As tags podem ser usadas como valores ou funções.
+root : IntTree
+root =
+ Node 7 Leaf Leaf
+
+-- Union types (e type aliases) podem utilizar tipos variáveis.
+type Tree a =
+ Leaf | Node a (Tree a) (Tree a)
+-- "O tipo árvore-de-a é uma folha ou um nó de a, árvore-de-a e árvore-de-a."
+
+-- Casa padrão com union tags. As tags maiúsculas serão casadas de maneira exa-
+-- ta. As variáveis minúsculas irão casar com qualquer coisa. Sublinhado também
+-- casa com qualquer coisa, mas siginifica que você não o está utilizando.
+leftmostElement : Tree a -> Maybe a
+leftmostElement tree =
+ case tree of
+ Leaf -> Nothing
+ Node x Leaf _ -> Just x
+ Node _ subtree _ -> leftmostElement subtree
+
+-- Isso é praticamente a própria linguagem. Agora vamos ver como organizar e
+-- executar seu código.
+
+{-- Módulos e Imports --}
+
+-- As bibliotecas internas são organizadas em módulos, assim como quaisquer
+-- bibliotecas de terceiros que você possa utilizar. Para grandes projetos,
+-- você pode definir seus próprios módulos.
+
+-- Coloque isso no topo do arquivo. Se for omitido, você está no Main.
+module Name where
+
+-- Por padrão, tudo é exportado. Você pode especificar as exportações de forma
+-- explícita.
+module Name (MyType, myValue) where
+
+-- Um padrão comum é exportar um union type mas não suas tags. Isto é conhecido
+-- como "tipo opaco" e é frequentemente utilizado em bibliotecas.
+
+-- Importe código de outros módulos para utilizá-lo no seu código.
+-- Coloque Dict no escopo para você poder chamar Dict.insert.
+import Dict
+
+-- Importe o módulo Dict e o tipo Dict para que suas anotações não tenham que
+-- dizer Dict.Dict. Você ainda pode utilizar Dict.insert.
+import Dict exposing (Dict)
+
+-- Renomeie um import.
+import Graphics.Collage as C
+
+{-- Portas --}
+
+-- Uma porta indica que você estará se comunicando com o mundo exterior.
+-- Portas são permitidas somente no módulo Main.
+
+-- Uma porta de entrada é apenas uma assinatura de tipo.
+port clientID : Int
+
+-- Uma porta de saída tem uma definição.
+port clientOrders : List String
+port clientOrders = ["Books", "Groceries", "Furniture"]
+
+-- Não vamos entrar em detalhes, mas você configura callbacks no JavaScript
+-- para enviar nas portas de entrada e receber nas portas de saída.
+
+{-- Ferramentas de Linha de Comando --}
+
+-- Compila um arquivo.
+$ elm make MyFile.elm
+
+-- A primeira vez que você fizer isso, o Elm instalará as bibliotecas internas
+-- e criará o elm-package.json, onde a informação sobre seu projeto é mantida.
+
+-- O reactor é um servidor que compila e roda seus arquivos.
+-- Clique na chave ao lado dos nomes de arquivo para entrar no depurador de
+-- viagem no tempo.
+$ elm reactor
+
+-- Teste expressões simples no Read-Eval-Print Loop.
+$ elm repl
+
+-- Pacotes são identificados pelo usuário e nome do repositório no GitHub.
+-- Instale um novo pacote e registre-o no elm-package.json.
+$ elm package install evancz/elm-html
+
+-- Veja o que mudou entre as versões de um pacote.
+$ elm package diff evancz/elm-html 3.0.0 4.0.2
+-- O gerenciador de pacotes do Elm obriga o versionamento semântico, logo
+-- mudanças de versões no minor nunca quebrará o seu build!
+```
+
+A linguagem Elm é supreendentemente pequena. Agora você pode olhar para quase
+qualquer código-fonte em Elm e ter uma ideia aproximada do que está acontecendo.
+No entanto, as possibilidades para código resistente a erros e de fácil
+refatoração são infinitas!
+
+Aqui estão algumas referências utéis.
+
+* O [site do Elm](http://elm-lang.org/). Ele inclui:
+ * Links para os [instaladores](http://elm-lang.org/install)
+ * [Documentação](http://elm-lang.org/docs), incluindo [a referência de sintaxe](http://elm-lang.org/docs/syntax)
+ * Muitos [exemplos](http://elm-lang.org/examples) úteis
+
+* Documentação para as [bibliotecas internas do Elm](http://package.elm-lang.org/packages/elm-lang/core/latest/). Tome nota de:
+ * [Basics](http://package.elm-lang.org/packages/elm-lang/core/latest/Basics), que é importada por padrão
+ * [Maybe](http://package.elm-lang.org/packages/elm-lang/core/latest/Maybe) e seu primo [Result](http://package.elm-lang.org/packages/elm-lang/core/latest/Result), comumente utilizados para valores faltantes e manipulação de erros
+ * Estruturas de dados como [List](http://package.elm-lang.org/packages/elm-lang/core/latest/List), [Array](http://package.elm-lang.org/packages/elm-lang/core/latest/Array), [Dict](http://package.elm-lang.org/packages/elm-lang/core/latest/Dict) e [Set](http://package.elm-lang.org/packages/elm-lang/core/latest/Set)
+ * [Codificação](http://package.elm-lang.org/packages/elm-lang/core/latest/Json-Encode) e [decodificação](http://package.elm-lang.org/packages/elm-lang/core/latest/Json-Decode) JSON
+
+* [A Arquitetura Elm](https://github.com/evancz/elm-architecture-tutorial#the-elm-architecture). Uma dissertação pelo criador do Elm com exemplos sobre como organizar código em componentes.
+
+* A [lista de e-mail do Elm](https://groups.google.com/forum/#!forum/elm-discuss). Todos são amigáveis e solícitos.
+
+* [Escopo em Elm](https://github.com/elm-guides/elm-for-js/blob/master/Scope.md#scope-in-elm) e [Como Ler uma Anotação de Tipo](https://github.com/elm-guides/elm-for-js/blob/master/How%20to%20Read%20a%20Type%20Annotation.md#how-to-read-a-type-annotation). Mais sobre guias da comunidade sobre o básico de Elm escrito por desenvolvedores JavaScript.
+
+Saia e escreva algum código Elm!
diff --git a/pt-br/git-pt.html.markdown b/pt-br/git-pt.html.markdown
index 981da503..e59ba901 100644
--- a/pt-br/git-pt.html.markdown
+++ b/pt-br/git-pt.html.markdown
@@ -2,11 +2,15 @@
category: tool
tool: git
lang: pt-br
-filename: LearnGit.txt
+filename: LearnGit-br.txt
contributors:
- ["Jake Prather", "http://github.com/JakeHP"]
+ - ["Leo Rudberg" , "http://github.com/LOZORD"]
+ - ["Betsy Lorton" , "http://github.com/schbetsy"]
+ - ["Bruno Volcov", "http://github.com/volcov"]
translators:
- ["Suzane Sant Ana", "http://github.com/suuuzi"]
+ - ["Bruno Volcov", "http://github.com/volcov"]
---
Git é um sistema distribuido de gestão para código fonte e controle de versões.
@@ -28,7 +32,7 @@ a um arquivo ou conjunto de arquivos ao longo do tempo.
de arquivos.
* Controle de versão distribuído foca em compartilhar alterações. Cada
alteração é associada a um *id* único.
-* Sistemas distribuídos não tem estrutura definida. É possivel ter um sistema
+* Sistemas distribuídos não têm estrutura definida. É possivel ter um sistema
centralizado ao estilo SVN usando git.
[Informação adicional (EN)](http://git-scm.com/book/en/Getting-Started-About-Version-Control)
@@ -52,7 +56,7 @@ referências. Pode ser descrito como uma estrutura de dados de código fonte
com a particularidade de cada elemento do código fonte permitir acesso ao
histórico das suas alterações, entre outras coisas.
-Um repositório git é constituido pelo diretório .git e a *working tree*
+Um repositório git é constituído pelo diretório .git e a *working tree*
### Diretório .git (componente do repositório)
@@ -84,6 +88,11 @@ Um *branch* é essencialmente uma referência que aponta para o último *commit*
efetuado. Na medida que são feitos novos commits, esta referência é atualizada
automaticamente e passa a apontar para o commit mais recente.
+### *Tag*
+
+Uma tag é uma marcação em um ponto específico da história. Geralmente as
+pessoas usam esta funcionalidade para marcar pontos de release (v2.0, e por aí vai)
+
### *HEAD* e *head* (componentes do diretório .git)
*HEAD* é a referência que aponta para o *branch* em uso. Um repositório só tem
@@ -131,10 +140,10 @@ Para visualizar rapidamente o detalhamento de cada comando ou apenas lembrar da
# Ver rapidamente os comandos disponiveis
$ git help
-# Ver todos os comandos disponiveis
+# Ver todos os comandos disponíveis
$ git help -a
-# Usar o *help* para um comando especifico
+# Usar o *help* para um comando específico
# git help <comando_aqui>
$ git help add
$ git help commit
@@ -149,7 +158,7 @@ do repositório) e o *commit* da *HEAD* atual.
```bash
# Apresenta o *branch*, arquivos não monitorados, alterações e outras
-# difereças
+# diferenças
$ git status
# Para aprender mais detalhes sobre git *status*
@@ -196,6 +205,29 @@ $ git branch -m myBranchName myNewBranchName
$ git branch myBranchName --edit-description
```
+### Tag
+
+Gerencia as *tags*
+
+```bash
+# Listar tags
+$ git tag
+# Criar uma tag anotada.
+# O parâmetro -m define uma mensagem, que é armazenada com a tag.
+# Se você não especificar uma mensagem para uma tag anotada,
+# o Git vai rodar seu editor de texto para você digitar alguma coisa.
+$ git tag -a v2.0 -m 'minha versão 2.0'
+# Mostrar informações sobre a tag
+# O comando mostra a informação da pessoa que criou a tag,
+# a data de quando o commit foi taggeado,
+# e a mensagem antes de mostrar a informação do commit.
+$ git show v2.0
+# Enviar uma tag para o repositório remoto
+$ git push origin v2.0
+# Enviar várias tags para o repositório remoto
+$ git push origin --tags
+```
+
### checkout
Atualiza todos os arquivos no diretório do projeto para que fiquem iguais
@@ -368,7 +400,7 @@ perigoso quando não há certeza do que se está fazendo.
```bash
# Restabelece a camada intermediária de registo para o último
-# commit (o directório fica sem alterações)
+# commit (o diretório fica sem alterações)
$ git reset
# Restabelece a camada intermediária de registo para o último commit, e
diff --git a/pt-br/haskell-pt.html.markdown b/pt-br/haskell-pt.html.markdown
index 788dc1d2..181aa471 100644
--- a/pt-br/haskell-pt.html.markdown
+++ b/pt-br/haskell-pt.html.markdown
@@ -93,7 +93,7 @@ not False -- Nega uma falácia
"AbBbbcAbbcbBbcbcb" !! 2 -- 'B'
----------------------------------------------------
--- Listas e Túplas
+-- 2. Listas e Túplas
----------------------------------------------------
-- A construção de uma lista precisa ser de elementos homogêneos
diff --git a/pt-br/hy-pt.html.markdown b/pt-br/hy-pt.html.markdown
index 4230579d..5fa4df75 100644
--- a/pt-br/hy-pt.html.markdown
+++ b/pt-br/hy-pt.html.markdown
@@ -171,6 +171,6 @@ Este tutorial é apenas uma introdução básica para hy/lisp/python.
Docs Hy: [http://hy.readthedocs.org](http://hy.readthedocs.org)
-Repo Hy no Github: [http://github.com/hylang/hy](http://github.com/hylang/hy)
+Repo Hy no GitHub: [http://github.com/hylang/hy](http://github.com/hylang/hy)
Acesso ao freenode irc com #hy, hashtag no twitter: #hylang
diff --git a/pt-br/java-pt.html.markdown b/pt-br/java-pt.html.markdown
index 3c9512aa..82989502 100644
--- a/pt-br/java-pt.html.markdown
+++ b/pt-br/java-pt.html.markdown
@@ -214,42 +214,42 @@ public class LearnJava {
//Iteração feita 10 vezes, fooFor 0->9
}
System.out.println("Valor do fooFor: " + fooFor);
-
- // O Loop For Each
+
+ // O Loop For Each
// Itera automaticamente por um array ou lista de objetos.
int[] fooList = {1,2,3,4,5,6,7,8,9};
//estrutura do loop for each => for(<objeto> : <array_de_objeto>)
//lê-se: para cada objeto no array
//nota: o tipo do objeto deve ser o mesmo do array.
-
+
for( int bar : fooList ){
//System.out.println(bar);
//Itera 9 vezes e imprime 1-9 em novas linhas
}
-
+
// Switch
// Um switch funciona com os tipos de dados: byte, short, char e int
// Ele também funciona com tipos enumerados (vistos em tipos Enum)
// como também a classe String e algumas outras classes especiais
// tipos primitivos: Character, Byte, Short e Integer
- int mes = 3;
- String mesString;
- switch (mes){
+ int mes = 3;
+ String mesString;
+ switch (mes){
case 1:
- mesString = "Janeiro";
+ mesString = "Janeiro";
break;
case 2:
- mesString = "Fevereiro";
+ mesString = "Fevereiro";
break;
case 3:
- mesString = "Março";
+ mesString = "Março";
break;
default:
- mesString = "Algum outro mês";
+ mesString = "Algum outro mês";
break;
}
System.out.println("Resultado do Switch: " + mesString);
-
+
// Condição de forma abreviada.
// Você pode usar o operador '?' para atribuições rápidas ou decisões lógicas.
// Lê-se "Se (declaração) é verdadeira, use <primeiro valor>
@@ -287,9 +287,9 @@ public class LearnJava {
// Classes e Métodos
///////////////////////////////////////
- System.out.println("\n->Classes e Métodos");
+ System.out.println("\n->Classes e Métodos");
- // (segue a definição da classe Bicicleta)
+ // (segue a definição da classe Bicicleta)
// Use o new para instanciar uma classe
Bicicleta caloi = new Bicicleta(); // Objeto caloi criado.
@@ -318,9 +318,9 @@ class Bicicleta {
// Atributos/Variáveis da classe Bicicleta.
public int ritmo; // Public: Pode ser acessada em qualquer lugar.
- private int velocidade; // Private: Apenas acessível a classe.
+ private int velocidade; // Private: Apenas acessível a classe.
protected int catraca; // Protected: Acessível a classe e suas subclasses.
- String nome; // default: Apenas acessível ao pacote.
+ String nome; // default: Apenas acessível ao pacote.
// Construtores são uma forma de criação de classes
// Este é o construtor padrão.
@@ -388,7 +388,7 @@ class Bicicleta {
// Velocipede é uma subclasse de bicicleta.
class Velocipede extends Bicicleta {
// (Velocípedes são bicicletas com rodas dianteiras grandes
- // Elas não possuem catraca.)
+ // Elas não possuem catraca.)
public Velocipede(int ritmoInicial, int velocidadeInicial){
// Chame o construtor do pai (construtor de Bicicleta) com o comando super.
@@ -407,7 +407,7 @@ class Velocipede extends Bicicleta {
// Interfaces
// Sintaxe de declaração de Interface
-// <nível de acesso> Interface <nome-da-interface> extends <super-interfaces> {
+// <nível de acesso> interface <nome-da-interface> extends <super-interfaces> {
// // Constantes
// // Declarações de método
//}
@@ -415,11 +415,15 @@ class Velocipede extends Bicicleta {
// Exemplo - Comida:
public interface Comestivel {
public void comer(); // Qualquer classe que implementa essa interface, deve
-                        // Implementar este método.
+                        // implementar este método.
}
public interface Digestivel {
public void digerir();
+ // Em Java 8, interfaces podem ter métodos default.
+ // public void digerir() {
+ // System.out.println("digerindo ...");
+ // }
}
@@ -438,7 +442,7 @@ public class Fruta implements Comestivel, Digestivel {
}
// Em Java, você pode estender somente uma classe, mas você pode implementar muitas
-// Interfaces. Por exemplo:
+// interfaces. Por exemplo:
public class ClasseExemplo extends ExemploClassePai implements InterfaceUm,
InterfaceDois {
@@ -461,8 +465,8 @@ public class ClasseExemplo extends ExemploClassePai implements InterfaceUm,
//}
// Marcar uma classe como abstrata significa que ela contém métodos abstratos que devem
-// ser definido em uma classe filha. Semelhante às interfaces, classes abstratas não podem
-// ser instanciadas, ao invés disso devem ser extendidas e os métodos abstratos
+// ser definidos em uma classe filha. Semelhante às interfaces, classes abstratas não podem
+// ser instanciadas, ao invés disso devem ser estendidas e os métodos abstratos
// definidos. Diferente de interfaces, classes abstratas podem conter uma mistura de
// métodos concretos e abstratos. Métodos em uma interface não podem ter um corpo,
// a menos que o método seja estático, e as variáveis sejam finais, por padrão, ao contrário de um
@@ -482,7 +486,7 @@ public abstract class Animal
// Não há necessidade de inicializar, no entanto, em uma interface
    // a variável é implicitamente final e, portanto, tem
-    // de ser inicializado.
+    // de ser inicializada.
protected int idade;
public void mostrarIdade()
@@ -501,7 +505,7 @@ class Cachorro extends Animal
{
// Nota: ainda precisamos substituir os métodos abstratos na
-    // classe abstrata
+    // classe abstrata.
@Override
public void fazerSom()
{
@@ -532,13 +536,13 @@ class Cachorro extends Animal
//}
// Classes finais são classes que não podem ser herdadas e são, portanto, um
-// filha final. De certa forma, as classes finais são o oposto de classes abstratas
-// Porque classes abstratas devem ser estendidas, mas as classes finais não pode ser
+// filho final. De certa forma, as classes finais são o oposto de classes abstratas,
+// porque classes abstratas devem ser estendidas, mas as classes finais não podem ser
// estendidas.
public final class TigreDenteDeSabre extends Animal
{
// Nota: Ainda precisamos substituir os métodos abstratos na
-     // classe abstrata.
+    // classe abstrata.
@Override
public void fazerSom();
{
@@ -552,7 +556,7 @@ public abstract class Mamifero()
// Sintaxe de Métodos Finais:
// <modificador-de-acesso> final <tipo-de-retorno> <nome-do-método>(<argumentos>)
- // Métodos finais, como, classes finais não podem ser substituídas por uma classe filha,
+ // Métodos finais, como classes finais, não podem ser substituídos por uma classe filha,
    // e são, portanto, a implementação final do método.
public final boolean EImpulsivo()
{
@@ -626,11 +630,11 @@ Os links fornecidos aqui abaixo são apenas para ter uma compreensão do tema, u
Outros tópicos para pesquisar:
-* [Tutorial Java para Sun Trail / Oracle](http://docs.oracle.com/javase/tutorial/index.html)
+* [Tutorial Java para Sun Trail / Oracle](http://docs.oracle.com/javase/tutorial/index.html)
* [Modificadores de acesso do Java](http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html)
-* [Coceitos de Programação Orientada à Objetos](http://docs.oracle.com/javase/tutorial/java/concepts/index.html):
+* [Coceitos de Programação Orientada à Objetos](http://docs.oracle.com/javase/tutorial/java/concepts/index.html):
* [Herança](http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html)
* [Polimorfismo](http://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html)
* [Abstração](http://docs.oracle.com/javase/tutorial/java/IandI/abstract.html)
@@ -646,3 +650,9 @@ Outros tópicos para pesquisar:
Livros:
* [Use a cabeça, Java] (http://www.headfirstlabs.com/books/hfjava/)
+
+Apostila:
+
+* [Java e Orientação a Objetos] (http://www.caelum.com.br/apostila-java-orientacao-objetos/)
+
+* [Java para Desenvolvimento Web] (https://www.caelum.com.br/apostila-java-web/)
diff --git a/pt-br/javascript-pt.html.markdown b/pt-br/javascript-pt.html.markdown
index 59c6890e..e337f4bc 100644
--- a/pt-br/javascript-pt.html.markdown
+++ b/pt-br/javascript-pt.html.markdown
@@ -197,7 +197,6 @@ myObj.myFourthKey; // = undefined
// A sintaxe para essa seção é quase idêntica a maioria das linguagens.
-// The `if` structure works as you'd expect.
// A estrutura `if` funciona como deveria ser.
var count = 1
if (count == 3){
@@ -219,9 +218,6 @@ do {
input = getInput();
} while (!isValid(input))
-// The `for` loop is the same as C and Java:
-// initialisation; continue condition; iteration.
-
// O loop `for` é o mesmo de C e Java:
// inicialização, condição para continuar; iteração
for (var i = 0; i < 5; i++){
diff --git a/pt-br/jquery-pt.html.markdown b/pt-br/jquery-pt.html.markdown
new file mode 100644
index 00000000..d49bea0f
--- /dev/null
+++ b/pt-br/jquery-pt.html.markdown
@@ -0,0 +1,131 @@
+---
+category: tool
+tool: jquery
+contributors:
+ - ["Sawyer Charles", "https://github.com/xssc"]
+translators:
+ - ["Nikolas Silva", "https://github.com/nikolassilva"]
+filename: jquery-pt.js
+lang: pt-br
+---
+
+jQuery é uma biblioteca JavaScript que te ajuda a "fazer mais, escrevendo menos". Ela faz com que muitas tarefas comuns em JavaScript sejam mais simples de escrever. jQuery é usado por grandes empresas e desenvolvedores do mundo todo. Ela torna o AJAX, manipulação de eventos, manipulação do DOM, entre outros, mais fácil e rápido.
+
+Pelo jQuery ser uma biblioteca JavaScript você deve [aprende-lo primeiro](https://learnxinyminutes.com/docs/pt-br/javascript-pt/)
+
+```js
+
+
+///////////////////////////////////
+// 1. Seletores
+
+// Seletores no jQuery são usados para selecionar um elemento
+var page = $(window); // Seleciona toda a viewport
+
+// Seletores também podem ser na forma do CSS
+var paragraph = $('p'); // Seleciona todos elementos de parágrafo
+var table1 = $('#table1'); // Seleciona o elemento com id 'table1'
+var squares = $('.square'); // Seleciona todos elementos com classe 'square'
+var square_p = $('p.square') // Seleciona todos elementos de parágrafo com a classe 'square'
+
+
+///////////////////////////////////
+// 2. Eventos e Efeitos
+// jQuery é muito bom em manipular o que acontece quando um evento é disparado
+// Um evento muito usado é o 'ready'
+// Você pode usar o método ready para esperar até que um elemento tenha terminado de carregar
+$(document).ready(function(){
+ // O código não será executado até que o documento carregue
+});
+// Você também pode usar funções declaradas
+function onAction() {
+ // Isso será executado quando um evento for disparado
+}
+$('#btn').click(onAction); // Chama 'onAction' quando o elemento receber um clique
+
+// Outros eventos comuns são:
+$('#btn').dblclick(onAction); // Clique duplo
+$('#btn').hover(onAction); // Mouse sobre elemento
+$('#btn').focus(onAction); // Elemento recebe foco
+$('#btn').blur(onAction); // Elemento perde foco
+$('#btn').submit(onAction); // Envio de formulário
+$('#btn').select(onAction); // Quando o elemento é selecionado
+$('#btn').keydown(onAction); // Quando uma tecla é segurada
+$('#btn').keyup(onAction); // Quando uma tecla é solta
+$('#btn').keypress(onAction); // Quando uma tecla é pressionada
+$('#btn').mousemove(onAction); // Quando o mouse é movido
+$('#btn').mouseenter(onAction); // Quando o mouse entra no elemento
+$('#btn').mouseleave(onAction); // Quando o mouse sai do elemento
+
+
+// Eles também podem disparar os eventos em vez de manipulá-los,
+// simplesmente deixando de passar os parâmetros
+$('#btn').dblclick(); // Dispara um clique duplo no elemento
+
+// Você pode manipular múltiplos eventos usando o seletor apenas uma vez
+$('#btn').on(
+ {dblclick: myFunction1} // Disparado num clique duplo
+ {blur: myFunction1} // Disparado quando perder o foco
+);
+
+// Você pode mover e esconder elementos com alguns métodos de efeito
+$('.table').hide(); // Esconde o elemento
+
+// Nota: chamar uma função nesse método ainda irá esconder o elemento
+$('.table').hide(function(){
+ // Elemento é escondido e a função é executada
+});
+
+// Você pode guardar seletores em variáveis
+var tables = $('.table');
+
+// Alguns métodos básicos de manipulação do DOM:
+tables.hide(); // Esconde elemento(s)
+tables.show(); // Exibe elemento(s)
+tables.toggle(); // Alterna entre esconder/exibir
+tables.fadeOut(); // Efeito fade out
+tables.fadeIn(); // Efeito fade in
+tables.fadeToggle(); // Alterna entre fade out/in
+tables.fadeTo(0.5); // Efeito fade com opacidade específica (entre 0 e 1)
+tables.slideUp(); // Efeito de deslize pra cima
+tables.slideDown(); // Efeito de deslize pra baixo
+tables.slideToggle(); // Alterna entre deslizar pra cima/baixo
+
+// Todos os métodos acima levam velocidade (em milissegundos) e uma função callback
+tables.hide(1000, myFunction); // Esconde o elemento em 1 segundo e chama a função
+
+// No fadeTo é obrigatório definir a opacidade como segundo parâmetro
+tables.fadeTo(2000, 0.1, myFunction); // 2 segundos de fade para 0.1 de opacidade e chama a função
+
+// Você pode fazer animações mais avançadas com o método animate
+tables.animate({'margin-top':"+=50", height: "100px"}, 500, myFunction);
+// O método animate leva um objeto com valores CSS,
+// um parâmetro de opções para melhorar a animação
+// e uma função callback, como de costume
+
+///////////////////////////////////
+// 3. Manipulação
+
+// São similares aos efeitos, mas podem fazer mais
+$('div').addClass('taming-slim-20'); // Adiciona a classe taming-slim-20 em todas as divs
+
+// Métodos comuns de manipulação
+$('p').append('Hello world'); // Adiciona ao final do elemento
+$('p').attr('class'); // Obtém o valor de um atributo
+$('p').attr('class', 'content'); // Define o valor de um atributo
+$('p').hasClass('taming-slim-20'); // Retorna true se tiver a classe
+$('p').height(); // Obtém/define a altura do elemento
+
+
+// Pra maioria dos métodos de manipulação, pegar o valor de um
+// elemento só afetará o primeiro deles
+$('p').height(); // Obtém a altura da primeira tag 'p'
+
+// Você pode usar o método each pra percorrer os elementos
+var heights = [];
+$('p').each(function() {
+ heights.push($(this).height()); // Adiciona a altura das tags 'p' na array
+});
+
+
+```
diff --git a/pt-br/julia-pt.html.markdown b/pt-br/julia-pt.html.markdown
new file mode 100644
index 00000000..48d97e58
--- /dev/null
+++ b/pt-br/julia-pt.html.markdown
@@ -0,0 +1,748 @@
+---
+language: Julia
+filename: learnjulia-pt.jl
+contributors:
+ - ["Leah Hanson", "http://leahhanson.us"]
+translators:
+ - ["Davidson Mizael", "https://github.com/davidsonmizael"]
+lang: pt-br
+---
+
+Julia é uma linguagem homoiconic funcional focada na computação tecnica. Ao mesmo tempo que ela tem todo o poder dos homoiconic macros, funções de primeira classe, e controle de baixo nivel, Julia é tão facil para aprender e usar quanto Python.
+
+Este tutorial é baseado no Julia 0.3.
+
+```ruby
+# Linhas únicas de comentários começam com o simbolo hash(jogo da velha).
+#= Comentários de multiplas linhas podem ser escritos
+ colocando '#=' antes do texto e '=#'
+ após o texto. Eles também podem ser agrupados
+=#
+
+####################################################
+## 1. Tipos primitivos e operadores
+####################################################
+
+# Tudo em Julia é uma expressão.
+
+# Há muitos tipos básicos de numeros.
+3 # => 3 (Int64)
+3.2 # => 3.2 (Float64)
+2 + 1im # => 2 + 1im (Complex{Int64})
+2//3 # => 2//3 (Rational{Int64})
+
+# Todos os operadores inseguros normais estão disponiveis.
+1 + 1 # => 2
+8 - 1 # => 7
+10 * 2 # => 20
+35 / 5 # => 7.0
+5 / 2 # => 2.5 # dividir um Int por um Int resulta em um float
+div(5, 2) # => 2 # para um restultado truncado, use div
+5 \ 35 # => 7.0
+2 ^ 2 # => 4 # elevado,não o opeardor binário xor
+12 % 10 # => 2
+
+# Impõe a priodidade nos parenteses
+(1 + 3) * 2 # => 8
+
+# Operadores binarios
+~2 # => -3 # not
+3 & 5 # => 1 # and
+2 | 4 # => 6 # or
+2 $ 4 # => 6 # xor
+2 >>> 1 # => 1 # deslocamento lógico de bits a direita
+2 >> 1 # => 1 # deslocamento aritmético de bits a direita
+2 << 1 # => 4 # deslocamento lógico/aritmético de bits a esquerda
+
+# Você pode usar a função bits para ver a representação binária de um numero.
+bits(12345)
+# => "0000000000000000000000000000000000000000000000000011000000111001"
+bits(12345.0)
+# => "0100000011001000000111001000000000000000000000000000000000000000"
+
+# Valores booleanos são primitivos.
+true
+false
+
+# Operadores booleanos
+!true # => false
+!false # => true
+1 == 1 # => true
+2 == 1 # => false
+1 != 1 # => false
+2 != 1 # => true
+1 < 10 # => true
+1 > 10 # => false
+2 <= 2 # => true
+2 >= 2 # => true
+# Comparações podem ser encadeadas
+1 < 2 < 3 # => true
+2 < 3 < 2 # => false
+
+# Strings são criadas com "
+"Isso é uma String."
+
+# Caracteres literais são escritos com '
+'a'
+
+# Uma string pode ser indexada como um vetor de caracteres
+"Isso é uma string"[1] # => 'I' # Julia começa a indexar a partir do 1
+# Porém isso não funcionará direito com strings em UTF8,
+# portanto é recomendado usar iterações sobre uma string (map, loops com for, etc).
+
+# $ pode ser usado para interpolação de string:
+"2 + 2 = $(2 + 2)" # => "2 + 2 = 4"
+# Você pode usar qualquer expressão Julia dentro dos parenteses.
+
+# Outro jeito de formatar strings é com um macro no printf.
+@printf "%d é menor que %f" 4.5 5.3 # 5 é menor que 5.300000
+
+# Escrever na tela é fácil
+println("Eu sou Julia. Prazer em conhece-lo!")
+
+####################################################
+## 2. Variáveis e coleções
+####################################################
+
+#Você não declara variáveis antes de atribui-lás.
+some_var = 5 # => 5
+some_var # => 5
+
+# Acessando a variável anterior não iniciada é um erro
+try
+ some_other_var # => ERROR: some_other_var não definida
+catch e
+ println(e)
+end
+
+# Nomes de variáveis começam com uma letra.
+# Depois disso, você pode usar letras, digitos, underscores e pontos de exclamação.
+SomeOtherVar123! = 6 # => 6
+
+# Você também pode usar caractéres unicode
+☃ = 8 # => 8
+# Estes são especialmente reservados para notações matemáticas.
+2 * π # => 6.283185307179586
+
+# Uma nota na convenção de nomes em Julia:
+#
+# * A separação de palavras pode ser feita por underscores ('_'), mas o uso
+# de underscore é desencorajado a menos que o nome da variável seja dificil
+# de ler.
+#
+# * Os nomes de tipos começam com letra maiúscula e a separação de letras é
+# feita a partir de CamelCase no lugar de underscores.
+#
+# * Nomes de funções e macros são em minúsculo, sem underscore.
+#
+# * Funções que modificam a própria entrada tem nomes que terminam em !. Estas
+# funções são chamadas as vezes de funções de mutação ou função in-place.
+
+# Vetores armazenam uma sequencia de valores indexados por integer de 1 a n:
+a = Int64[] # => 0-element Int64 Array
+
+# 1-Vetores dimensionais literais podem ter seus valores separados por virgula.
+b = [4, 5, 6] # => 3-element Int64 Array: [4, 5, 6]
+b[1] # => 4
+b[end] # => 6
+
+# 2-Vetores dimensionais usam espaço para separar valores e ponto e virgula para linhas.
+matrix = [1 2; 3 4] # => 2x2 Int64 Array: [1 2; 3 4]
+
+# Adiciona-se coisas ao final de uma lista com push! e append!
+push!(a,1) # => [1]
+push!(a,2) # => [1,2]
+push!(a,4) # => [1,2,4]
+push!(a,3) # => [1,2,4,3]
+append!(a,b) # => [1,2,4,3,4,5,6]
+
+# Remove-se do final com pop!
+pop!(b) # => 6 e 'b' agora é [4,5]
+
+# Vamos coloca-lo de novo
+push!(b,6) # 'b' agora é [4,5,6] de novo.
+
+a[1] # => 1 # lembre-se que Julia indexa a partir de 1, não 0.
+
+# end é um atalho para a ultima posição. Pode ser usada em qualquer
+# expressão indexada.
+a[end] # => 6
+
+# nós também temos shift e unshift
+shift!(a) # => 1 e 'a' agora é [2,4,3,4,5,6]
+unshift!(a,7) # => [7,2,4,3,4,5,6]
+
+# Funções que terminam com ponto de exclamação indicam que elas modificam
+# seus argumentos.
+arr = [5,4,6] # => 3-element Int64 Array: [5,4,6]
+sort(arr) # => [4,5,6]; 'arr' continua [5,4,6]
+sort!(arr) # => [4,5,6]; 'arr' agora é [4,5,6]
+
+# Olhar além dos limites é um BoundsError
+try
+ a[0] # => ERROR: BoundsError() in getindex at array.jl:270
+ a[end+1] # => ERROR: BoundsError() in getindex at array.jl:270
+catch e
+ println(e)
+end
+
+# Erros listam a linha e o nome do arquivo que ele está, mesmo se for uma
+# biblioteca padrão. Se você construiu Julia pelo source, você pode olhar na
+# pasta base dentro da pasta do Julia para encontrar esses arquivos.
+
+# Você pode inicializar vetores com limites
+a = [1:5;] # => 5-element Int64 Array: [1,2,3,4,5]
+
+# Você pode ver até um limite com a sintaxe separada
+a[1:3] # => [1, 2, 3]
+a[2:end] # => [2, 3, 4, 5]
+
+# Remova elementos de um array pelo index com splice!
+arr = [3,4,5]
+splice!(arr,2) # => 4 ; arr is now [3,5]
+
+# Concatene listas com append!
+b = [1,2,3]
+append!(a,b) # 'a' agora é [1, 2, 3, 4, 5, 1, 2, 3]
+
+# Cheque se um valor existe me uma lista com in
+in(1, a) # => true
+
+# Veja o tamanho com lenght
+length(a) # => 8
+
+# Tuples não podem ser mudados.
+tup = (1, 2, 3) # => (1,2,3) # um tuple (Int64,Int64,Int64).
+tup[1] # => 1
+try:
+ tup[1] = 3 # => ERROR: não há metodo setindex!((Int64,Int64,Int64),Int64,Int64)
+catch e
+ println(e)
+end
+
+# Muitas litas de funções também trabalham com tuples
+length(tup) # => 3
+tup[1:2] # => (1,2)
+in(2, tup) # => true
+
+#Você pode desempacotar tuples para variáveis.
+a, b, c = (1, 2, 3) # => (1,2,3) # 'a' agora é 1, 'b' agora é 2 e 'c' agora é 3
+
+# Tuplas são criados mesmo se você deixar fora dos parenteses
+d, e, f = 4, 5, 6 # => (4,5,6)
+
+# Uma tupla de um elemento é diferente do valor que ele contém
+(1,) == 1 # => false
+(1) == 1 # => true
+
+# Olhe como é facil pra trocar dois valores
+e, d = d, e # => (5,4) # 'd' agora é 5 e 'e' agora é 4
+
+# Dicionários armazenam mapeamentos
+empty_dict = Dict() # => Dict{Any,Any}()
+
+# Você pode criar um dicionário usando um literal
+filled_dict = ["one"=> 1, "two"=> 2, "three"=> 3]
+# => Dict{ASCIIString,Int64}
+
+# Veja os valores com []
+filled_dict["one"] # => 1
+
+# Pegue todas as chaves
+keys(filled_dict)
+# => KeyIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2])
+# Nota - as chaves dos dicionários não são ordenadas nem estão na ordem que você as inseriu.
+
+# Pegue todos os valores
+values(filled_dict)
+# => ValueIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2])
+# Nota - A mesma coisa que na nota acima sobre a ordenação das chaves.
+
+# Cheque pela existencia de chaves em um dicionário com in e haskey
+in(("one", 1), filled_dict) # => true
+in(("two", 3), filled_dict) # => false
+haskey(filled_dict, "one") # => true
+haskey(filled_dict, 1) # => false
+
+# Procurar por uma chave não existente irá gerar um erro
+try
+ filled_dict["four"] # => ERROR: key not found: four in getindex at dict.jl:489
+catch e
+ println(e)
+end
+
+# Use o método get para escapar desse erro passando um valor padrão
+# get(dictionary,key,default_value)
+get(filled_dict,"one",4) # => 1
+get(filled_dict,"four",4) # => 4
+
+# Use sets para representar coleções de valores unicos e não ordenados
+empty_set = Set() # => Set{Any}()
+# Inicialize um set com valores
+filled_set = Set(1,2,2,3,4) # => Set{Int64}(1,2,3,4)
+
+# Adicione mais valores para um set
+push!(filled_set,5) # => Set{Int64}(5,4,2,3,1)
+
+# Cheque se um valor está no set
+in(2, filled_set) # => true
+in(10, filled_set) # => false
+
+# Não há funções para interseção de set, união e diferença.
+other_set = Set(3, 4, 5, 6) # => Set{Int64}(6,4,5,3)
+intersect(filled_set, other_set) # => Set{Int64}(3,4,5)
+union(filled_set, other_set) # => Set{Int64}(1,2,3,4,5,6)
+setdiff(Set(1,2,3,4),Set(2,3,5)) # => Set{Int64}(1,4)
+
+####################################################
+## 3. Controle de fluxo
+####################################################
+
+# Vamos fazer uma variável
+some_var = 5
+
+# Aqui está um if. Identação nao é importante em Julia.
+if some_var > 10
+ println("some_var é totalmente maior que 10.")
+elseif some_var < 10 # Essa clausula elseif é opcional.
+ println("some_var é menor que 10.")
+else # A clausula else é opcional também.
+ println("some_var é literalmente 10.")
+end
+# => exibe "some_var é menor que 10"
+
+# Loops for repetem sobre variaveis iteráveis.
+# Tipos iterativos incluem Range, Array, set Dict e String.
+for animal=["dog", "cat", "mouse"]
+ println("$animal is a mammal")
+ # Você pode interpolar variáveis usando $ ou expressões em strings
+end
+# exibe:
+# dog is a mammal
+# cat is a mammal
+# mouse is a mammal
+
+# Você pode usar 'in' no lugar de '='.
+for animal in ["dog", "cat", "mouse"]
+ println("$animal is a mammal")
+end
+# exibe:
+# dog is a mammal
+# cat is a mammal
+# mouse is a mammal
+
+for a in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"]
+ println("$(a[1]) is a $(a[2])")
+end
+# exibe:
+# dog is a mammal
+# cat is a mammal
+# mouse is a mammal
+
+for (k,v) in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"]
+ println("$k is a $v")
+end
+# exibe:
+# dog is a mammal
+# cat is a mammal
+# mouse is a mammal
+
+# Loops while circulam enquanto a condição é true
+x = 0
+while x < 4
+ println(x)
+ x += 1 # Abreveação para x = x + 1
+end
+# exibe:
+# 0
+# 1
+# 2
+# 3
+
+# Trate exceções com um bloco try/catch
+try
+ error("help")
+catch e
+ println("caught it $e")
+end
+# => caught it ErrorException("help")
+
+
+####################################################
+## 4. Funções
+####################################################
+
+# A palavra chave 'function' cria novas funções
+#function name(arglist)
+# corpo...
+#end
+function add(x, y)
+ println("x is $x and y is $y")
+
+ # Funções retornam o valor da sua ultima declaração
+t x + y
+end
+
+add(5, 6) # => 11 after printing out "x is 5 and y is 6"
+
+# Você pode definir funções que tomam um numero incerto de
+# argumentos
+function varargs(args...)
+ return args
+ # use a palavra chave return para retornar um valor em qualquer parte da função
+end
+# => varargs (generic function with 1 method)
+
+varargs(1,2,3) # => (1,2,3)
+
+# O ... é chamado de splat.
+# Nós apenas o usamos na definição de uma função.
+# Também pode ser usado na chamada de uma função,
+# onde ela vai abrir um Array ou o conteúdo de um Tuple na lista de argumentos.
+Set([1,2,3]) # => Set{Array{Int64,1}}([1,2,3]) # produz um Set de Arrays
+Set([1,2,3]...) # => Set{Int64}(1,2,3) # isso é equivalente a Set(1,2,3)
+
+x = (1,2,3) # => (1,2,3)
+Set(x) # => Set{(Int64,Int64,Int64)}((1,2,3)) # um Set de Tuples
+Set(x...) # => Set{Int64}(2,3,1)
+
+# Você pode definir funções com argumentos posicionais opcionais.
+function defaults(a,b,x=5,y=6)
+ return "$a $b and $x $y"
+end
+
+defaults('h','g') # => "h g and 5 6"
+defaults('h','g','j') # => "h g and j 6"
+defaults('h','g','j','k') # => "h g and j k"
+try
+ defaults('h') # => ERROR: no method defaults(Char,)
+ defaults() # => ERROR: no methods defaults()
+catch e
+ println(e)
+end
+
+# Você pode definir funções que tomam argumentos como palavras chaves
+function keyword_args(;k1=4,name2="hello") # note the ;
+ return ["k1"=>k1,"name2"=>name2]
+end
+
+keyword_args(name2="ness") # => ["name2"=>"ness","k1"=>4]
+keyword_args(k1="mine") # => ["k1"=>"mine","name2"=>"hello"]
+keyword_args() # => ["name2"=>"hello","k1"=>4]
+
+# Você pode combinar todos os tipos de argumentos em uma só função
+function all_the_args(normal_arg, optional_positional_arg=2; keyword_arg="foo")
+ println("normal arg: $normal_arg")
+ println("optional arg: $optional_positional_arg")
+ println("keyword arg: $keyword_arg")
+end
+
+all_the_args(1, 3, keyword_arg=4)
+# exibe:
+# normal arg: 1
+# optional arg: 3
+# keyword arg: 4
+
+# Julia tem funções de primeira classe
+function create_adder(x)
+ adder = function (y)
+ return x + y
+ end
+ return adder
+end
+
+# Isso é "sintexe furiosa de lambda" pra criar funções anônimas.
+(x -> x > 2)(3) # => true
+
+#Esta função é identica a implementação da create_adder acima.
+function create_adder(x)
+ y -> x + y
+end
+
+# Você também pode nomear funções internas, se você quiser
+function create_adder(x)
+ function adder(y)
+ x + y
+ end
+ adder
+end
+
+add_10 = create_adder(10)
+add_10(3) # => 13
+
+
+# Há
+# There are built-in higher order functions
+map(add_10, [1,2,3]) # => [11, 12, 13]
+filter(x -> x > 5, [3, 4, 5, 6, 7]) # => [6, 7]
+
+# Nós podemos usar listas de compreensão para melhores mapeamentos
+[add_10(i) for i=[1, 2, 3]] # => [11, 12, 13]
+[add_10(i) for i in [1, 2, 3]] # => [11, 12, 13]
+
+####################################################
+## 5. Tipos
+####################################################
+
+#Julia tem um sistema de tipos.
+# Todo valor tem um tipo. Variaveis não tem tipos próprios.
+# Você pode usar a função 'typeof' para pegar o valor.
+typeof(5) # => Int64
+
+# Tipos são valores de primeira classe.
+typeof(Int64) # => DataType
+typeof(DataType) # => DataType
+# DataType é o tipo que representa tipos, incluindo ele mesmo.
+
+# Tipos são usados para documentação, optimização e envio
+# Eles não são estaticamente checados.
+
+# Usuários podem definir tipos
+# Eles são como records ou structs em outras linguagens.
+# Novos tipos são definidos usando a palavra chave 'type'
+
+# type Name
+# field::OptionalType
+# ...
+# end
+type Tiger
+ taillength::Float64
+ coatcolor # não incluindo uma notação type é o mesmo que '::Any'
+end
+
+# Os argumentos padrões de um construtor são as propriedades
+# do tipo na ordem que eles são listados na definição.
+tigger = Tiger(3.5,"orange") # => Tiger(3.5,"orange")
+
+# O tipo double como construtor de função para valores desse tipo
+# The type doubles as the constructor function for values of that type
+sherekhan = typeof(tigger)(5.6,"fire") # => Tiger(5.6,"fire")
+
+# Esses tipos no estilo struct são chamados tipos concretos
+# Eles podem ser instanciados, mas não podem ter subtipos.
+# O outro tipo de tipos são os tipos abstratos.
+
+# abstract Name
+abstract Cat # apenas um nome e um ponto na hierarquia de tipo
+
+# Tipos abstratos podem ser instanciados, mas não podem ter subtipos.
+# Por exemplo, Number é um tipo abstrato
+subtypes(Number) # => 6-element Array{Any,1}:
+ # Complex{Float16}
+ # Complex{Float32}
+ # Complex{Float64}
+ # Complex{T<:Real}
+ # ImaginaryUnit
+ # Real
+subtypes(Cat) # => 0-element Array{Any,1}
+
+# Todo tipo tem um super tipo; use a função 'super' para pegá-lo.
+typeof(5) # => Int64
+super(Int64) # => Signed
+super(Signed) # => Real
+super(Real) # => Number
+super(Number) # => Any
+super(super(Signed)) # => Number
+super(Any) # => Any
+# Todos esss tipos, exceto o Int64, são abstratos.
+
+# <: é o operador de subtipagem
+type Lion <: Cat # Lion é um subtipo de Cat
+ mane_color
+ roar::String
+end
+
+# Você pode definir mais construtores para seu tipo
+# É só definir uma função com o mesmo nome do tipo
+# e chamar um construtor existente para pegar o valor do tipo correto
+Lion(roar::String) = Lion("green",roar)
+# Isso é um construtor externo porque ele está fora da definição do tipo
+
+type Panther <: Cat # Panther também é um subtipo de Cat
+ eye_color
+ Panther() = new("green")
+# Panthers terão apenas esse construtor, e não construtor padrão.
+end
+# Usando construtores internos, como Panther faz, lhe da o controle
+# sobre como os valores dos tipos são criados.
+# Quando possivel, você deve usar construtores externos mais do que internos.
+
+####################################################
+## 6. Multiple-Dispatch
+####################################################
+
+
+# Em Julia todas as funções nomeadas são funções genericas
+# Isso significa que elas são construidas de muitos métodos pequenos
+# Cada construtor para Lion é um metodo da função genérica Lion.Lion.
+
+# Para um exemplo sem construtor, vamos fazer a função meow
+
+# Definição para Lion, Panther e Tiger
+function meow(animal::Lion)
+ animal.roar #propriedades do tipo de acesso usando a notação ponto '.'
+end
+
+function meow(animal::Panther)
+ "grrr"
+end
+
+function meow(animal::Tiger)
+ "rawwwr"
+end
+
+# Testando a função meow
+meow(tigger) # => "rawwr"
+meow(Lion("brown","ROAAR")) # => "ROAAR"
+meow(Panther()) # => "grrr"
+
+# Revendo o tipo local de hierarchy
+issubtype(Tiger,Cat) # => false
+issubtype(Lion,Cat) # => true
+issubtype(Panther,Cat) # => true
+
+# Definindo uma função que recebe Cats
+function pet_cat(cat::Cat)
+ println("The cat says $(meow(cat))")
+end
+
+pet_cat(Lion("42")) # => exibe "The cat says 42"
+try
+ pet_cat(tigger) # => ERROR: no method pet_cat(Tiger,)
+catch e
+ println(e)
+end
+
+# Em linguagens orientadas a objeto, envio unico é comúm
+# isso significa que o método é selecionado baseado no tipo do seu primeiro argumento
+# Em Julia todos os tipos de argumentos contribuem na seleção do melhor método
+
+
+# Vamos definir uma função com mais argumentos, então poderemos ver a diferença
+function fight(t::Tiger,c::Cat)
+ println("The $(t.coatcolor) tiger wins!")
+end
+# => fight (generic function with 1 method)
+
+fight(tigger,Panther()) # => exibe The orange tiger wins!
+fight(tigger,Lion("ROAR")) # => exibir The orange tiger wins!
+
+# Vamos mudar o comportamento quando o gato é especificamente um leão
+fight(t::Tiger,l::Lion) = println("The $(l.mane_color)-maned lion wins!")
+# => fight (generic function with 2 methods)
+
+fight(tigger,Panther()) # => exobe The orange tiger wins!
+fight(tigger,Lion("ROAR")) # => exobe The green-maned lion wins!
+
+# Nós não precisamos de um tigre para brigar
+fight(l::Lion,c::Cat) = println("The victorious cat says $(meow(c))")
+# => fight (generic function with 3 methods)
+
+fight(Lion("balooga!"),Panther()) # => exibe The victorious cat says grrr
+try
+ fight(Panther(),Lion("RAWR")) # => ERROR: no method fight(Panther,Lion)
+catch
+end
+
+# Aliás, vamos deixar o gato ir primeiro
+fight(c::Cat,l::Lion) = println("The cat beats the Lion")
+# => Warning: New definition
+# fight(Cat,Lion) at none:1
+# is ambiguous with
+# fight(Lion,Cat) at none:2.
+# Make sure
+# fight(Lion,Lion)
+# is defined first.
+#fight (generic function with 4 methods)
+
+# Este aviso é porque não está claro qual método fight será chamado em:
+fight(Lion("RAR"),Lion("brown","rarrr")) # => exibe The victorious cat says rarrr
+# O resultado pode ser diferente em outras versões de Julia
+
+fight(l::Lion,l2::Lion) = println("The lions come to a tie")
+fight(Lion("RAR"),Lion("brown","rarrr")) # => exibe The lions come to a tie
+
+
+# Embaixo dos panos
+# Você pode olhar o llvm e o código assembly gerado.
+
+square_area(l) = l * l # square_area (generic function with 1 method)
+
+square_area(5) #25
+
+# O que acontece quando alimentamos square_area com um inteiro?
+# What happens when we feed square_area an integer?
+code_native(square_area, (Int32,))
+ # .section __TEXT,__text,regular,pure_instructions
+ # Filename: none
+ # Source line: 1 # Prólogo
+ # push RBP
+ # mov RBP, RSP
+ # Source line: 1
+ # movsxd RAX, EDI # Busca l na memoria?
+ # imul RAX, RAX # Faz o quadrado de l e armazena o resultado em RAX
+ # pop RBP # Restaura o ponteiro de base antigo
+ # ret # O resultado continua em RAX
+
+code_native(square_area, (Float32,))
+ # .section __TEXT,__text,regular,pure_instructions
+ # Filename: none
+ # Source line: 1
+ # push RBP
+ # mov RBP, RSP
+ # Source line: 1
+ # vmulss XMM0, XMM0, XMM0 # Múltiplicação escalar unica de precisão (AVX)
+ # pop RBP
+ # ret
+
+code_native(square_area, (Float64,))
+ # .section __TEXT,__text,regular,pure_instructions
+ # Filename: none
+ # Source line: 1
+ # push RBP
+ # mov RBP, RSP
+ # Source line: 1
+ # vmulsd XMM0, XMM0, XMM0 # Duplicação ecalar de precisão multipla(AVX)
+ # pop RBP
+ # ret
+ #
+# Note que Julia usará instruções de ponto flutuante se quaser um dos
+# argumentos forem float
+# Vamos calcular a área de um circulo
+circle_area(r) = pi * r * r # circle_area (generic function with 1 method)
+circle_area(5) # 78.53981633974483
+
+code_native(circle_area, (Int32,))
+ # .section __TEXT,__text,regular,pure_instructions
+ # Filename: none
+ # Source line: 1
+ # push RBP
+ # mov RBP, RSP
+ # Source line: 1
+ # vcvtsi2sd XMM0, XMM0, EDI # Carrega inteiro (r) da memória
+ # movabs RAX, 4593140240 # Carrega pi
+ # vmulsd XMM1, XMM0, QWORD PTR [RAX] # pi * r
+ # vmulsd XMM0, XMM0, XMM1 # (pi * r) * r
+ # pop RBP
+ # ret
+ #
+
+code_native(circle_area, (Float64,))
+ # .section __TEXT,__text,regular,pure_instructions
+ # Filename: none
+ # Source line: 1
+ # push RBP
+ # mov RBP, RSP
+ # movabs RAX, 4593140496
+ # Source line: 1
+ # vmulsd XMM1, XMM0, QWORD PTR [RAX]
+ # vmulsd XMM0, XMM1, XMM0
+ # pop RBP
+ # ret
+ #
+```
+
+## Extras
+
+Você pode ver mais um monte de detalhes no [manual de Julia] (http://docs.julialang.org/en/latest/manual/)
+O melhor lugar pra pedir ajuda em Julia é a (muito amigável) [mailing list](https://groups.google.com/forum/#!forum/julia-users).
diff --git a/pt-br/markdown-pt.html.markdown b/pt-br/markdown-pt.html.markdown
index 4030ce3c..f22093f9 100644
--- a/pt-br/markdown-pt.html.markdown
+++ b/pt-br/markdown-pt.html.markdown
@@ -56,7 +56,7 @@ __E este também está._
*--Danouse! Este também__*
<!-- Em GitHub Flavored Markdown, que é usado para processar arquivos Markdown
-Github, nós também temos: -->
+GitHub, nós também temos: -->
~~Este texto é processado com tachado.~~
@@ -148,7 +148,7 @@ dentro do seu código -->
John não sabia nem o que o função 'goto()' fazia!
-<!-- Em Github Flavored Markdown, você pode usar uma sintaxe especial para o código -->
+<!-- Em GitHub Flavored Markdown, você pode usar uma sintaxe especial para o código -->
\`\`\`ruby <!-- exceto remover essas barras invertidas quando você faz isso, apenas ```
ruby! -->
@@ -157,7 +157,7 @@ def foobar
end
\`\`\` <!-- Aqui também, não barras invertidas, apenas ``` -->
-<-- O texto acima não requer recuo, mas o Github vai usar a sintaxe
+<-- O texto acima não requer recuo, mas o GitHub vai usar a sintaxe
destacando do idioma que você especificar após a ``` -->
<!-- Regra Horizontal (<hr />) -->
@@ -230,7 +230,7 @@ Quero digitar * Este texto entre asteriscos *, mas eu não quero que ele seja
em itálico, então eu faço o seguinte: \*Este texto entre asteriscos \*.
<!-- Tabelas -->
-<!-- Tabelas estão disponíveis apenas no Github Flavored Markdown e são ligeiramente
+<!-- Tabelas estão disponíveis apenas no GitHub Flavored Markdown e são ligeiramente
complicadas, mas se você realmente quer: -->
| Col1 | Col2 | Col3 |
diff --git a/pt-br/paren-pt.html.markdown b/pt-br/paren-pt.html.markdown
new file mode 100644
index 00000000..464a69d2
--- /dev/null
+++ b/pt-br/paren-pt.html.markdown
@@ -0,0 +1,196 @@
+---
+language: Paren
+filename: learnparen-pt.paren
+contributors:
+ - ["KIM Taegyoon", "https://github.com/kimtg"]
+translators:
+ - ["Claudson Martins", "https://github.com/claudsonm"]
+lang: pt-br
+---
+
+[Paren](https://bitbucket.org/ktg/paren) é um dialeto do Lisp. É projetado para ser uma linguagem embutida.
+
+Alguns exemplos foram retirados de <http://learnxinyminutes.com/docs/racket/>.
+
+```scheme
+;;; Comentários
+# Comentários
+
+;; Comentários de única linha começam com um ponto e vírgula ou cerquilha
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 1. Tipos de Dados Primitivos e Operadores
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;; Números
+123 ; inteiro
+3.14 ; double
+6.02e+23 ; double
+(int 3.14) ; => 3 : inteiro
+(double 123) ; => 123 : double
+
+;; O uso de funções é feito da seguinte maneira (f x y z ...)
+;; onde f é uma função e x, y, z, ... são os operandos
+;; Se você quiser criar uma lista literal de dados, use (quote) para impedir
+;; que sejam interpretados
+(quote (+ 1 2)) ; => (+ 1 2)
+;; Agora, algumas operações aritméticas
+(+ 1 1) ; => 2
+(- 8 1) ; => 7
+(* 10 2) ; => 20
+(^ 2 3) ; => 8
+(/ 5 2) ; => 2
+(% 5 2) ; => 1
+(/ 5.0 2) ; => 2.5
+
+;;; Booleanos
+true ; para verdadeiro
+false ; para falso
+(! true) ; => falso
+(&& true false (prn "não chega aqui")) ; => falso
+(|| false true (prn "não chega aqui")) ; => verdadeiro
+
+;;; Caracteres são inteiros.
+(char-at "A" 0) ; => 65
+(chr 65) ; => "A"
+
+;;; Strings são arrays de caracteres de tamanho fixo.
+"Olá, mundo!"
+"Sebastião \"Tim\" Maia" ; Contra-barra é um caractere de escape
+"Foo\tbar\r\n" ; Inclui os escapes da linguagem C: \t \r \n
+
+;; Strings podem ser concatenadas também!
+(strcat "Olá " "mundo!") ; => "Olá mundo!"
+
+;; Uma string pode ser tratada como uma lista de caracteres
+(char-at "Abacaxi" 0) ; => 65
+
+;; A impressão é muito fácil
+(pr "Isso é" "Paren. ") (prn "Prazer em conhecê-lo!")
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 2. Variáveis
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Você pode criar ou definir uma variável usando (set)
+;; o nome de uma variável pode conter qualquer caracter, exceto: ();#"
+(set alguma-variavel 5) ; => 5
+alguma-variavel ; => 5
+
+;; Acessar uma variável ainda não atribuída gera uma exceção
+; x ; => Unknown variable: x : nil
+
+;; Ligações locais: Utiliza cálculo lambda!
+;; 'a' e 'b' estão ligados a '1' e '2' apenas dentro de (fn ...)
+((fn (a b) (+ a b)) 1 2) ; => 3
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 3. Coleções
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;; Listas
+
+;; Listas são estruturas de dados semelhantes a vetores. (A classe de comportamento é O(1).)
+(cons 1 (cons 2 (cons 3 (list)))) ; => (1 2 3)
+;; 'list' é uma variação conveniente para construir listas
+(list 1 2 3) ; => (1 2 3)
+;; Um quote também pode ser usado para uma lista de valores literais
+(quote (+ 1 2)) ; => (+ 1 2)
+
+;; Você ainda pode utilizar 'cons' para adicionar um item ao início da lista
+(cons 0 (list 1 2 3)) ; => (0 1 2 3)
+
+;; Listas são um tipo muito básico, portanto existe *enorme* funcionalidade
+;; para elas, veja alguns exemplos:
+(map inc (list 1 2 3)) ; => (2 3 4)
+(filter (fn (x) (== 0 (% x 2))) (list 1 2 3 4)) ; => (2 4)
+(length (list 1 2 3 4)) ; => 4
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 3. Funções
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Use 'fn' para criar funções.
+;; Uma função sempre retorna o valor de sua última expressão
+(fn () "Olá Mundo") ; => (fn () Olá Mundo) : fn
+
+;; Use parênteses para chamar todas as funções, incluindo uma expressão lambda
+((fn () "Olá Mundo")) ; => "Olá Mundo"
+
+;; Atribuir uma função a uma variável
+(set ola-mundo (fn () "Olá Mundo"))
+(ola-mundo) ; => "Olá Mundo"
+
+;; Você pode encurtar isso utilizando a definição de função açúcar sintático:
+(defn ola-mundo2 () "Olá Mundo")
+
+;; Os () acima é a lista de argumentos para a função
+(set ola
+ (fn (nome)
+ (strcat "Olá " nome)))
+(ola "Steve") ; => "Olá Steve"
+
+;; ... ou equivalente, usando a definição açucarada:
+(defn ola2 (nome)
+ (strcat "Olá " name))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 4. Igualdade
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Para números utilize '=='
+(== 3 3.0) ; => verdadeiro
+(== 2 1) ; => falso
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 5. Controle de Fluxo
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;; Condicionais
+
+(if true ; Testa a expressão
+ "isso é verdade" ; Então expressão
+ "isso é falso") ; Senão expressão
+; => "isso é verdade"
+
+;;; Laços de Repetição
+
+;; O laço for é para número
+;; (for SÍMBOLO INÍCIO FIM SALTO EXPRESSÃO ..)
+(for i 0 10 2 (pr i "")) ; => Imprime 0 2 4 6 8 10
+(for i 0.0 10 2.5 (pr i "")) ; => Imprime 0 2.5 5 7.5 10
+
+;; Laço while
+((fn (i)
+ (while (< i 10)
+ (pr i)
+ (++ i))) 0) ; => Imprime 0123456789
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 6. Mutação
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Use 'set' para atribuir um novo valor a uma variável ou local
+(set n 5) ; => 5
+(set n (inc n)) ; => 6
+n ; => 6
+(set a (list 1 2)) ; => (1 2)
+(set (nth 0 a) 3) ; => 3
+a ; => (3 2)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 7. Macros
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Macros lhe permitem estender a sintaxe da linguagem.
+;; Os macros no Paren são fáceis.
+;; Na verdade, (defn) é um macro.
+(defmacro setfn (nome ...) (set nome (fn ...)))
+(defmacro defn (nome ...) (def nome (fn ...)))
+
+;; Vamos adicionar uma notação infixa
+(defmacro infix (a op ...) (op a ...))
+(infix 1 + 2 (infix 3 * 4)) ; => 15
+
+;; Macros não são higiênicos, você pode sobrescrever as variáveis já existentes!
+;; Eles são transformações de códigos.
+```
diff --git a/pt-br/php-composer-pt.html.markdown b/pt-br/php-composer-pt.html.markdown
new file mode 100644
index 00000000..145f5cab
--- /dev/null
+++ b/pt-br/php-composer-pt.html.markdown
@@ -0,0 +1,184 @@
+---
+category: tool
+tool: composer
+contributors:
+ - ["Brett Taylor", "https://github.com/glutnix"]
+translators:
+ - ["David Lima", "https://github.com/davelima"]
+lang: pt-br
+filename: LearnComposer-pt.sh
+---
+
+[Composer](https://getcomposer.org/) é uma ferramenta de gerenciamento de dependências para PHP. Ele permite que você defina as bibliotecas que seu projeto precisa, e então ele as gerencia (instala/atualiza) para você.
+
+# Instalando
+
+```sh
+# Instala o binário composer.phar no diretório atual
+curl -sS https://getcomposer.org/installer | php
+# Se você fizer desta forma, você precisará chamar o composer assim:
+php composer.phar about
+
+# Instala o binário em ~/bin/composer
+# Nota: certifique-se de que ~/bin está na variável de ambiente PATH do seu shell
+curl -sS https://getcomposer.org/installer | php -- --install-dir=~/bin --filename=composer
+```
+
+Usuários Windows devem seguir as Instruções de instalação para Windows:
+https://getcomposer.org/doc/00-intro.md#installation-windows (EN)
+
+## Confirmando a instalação
+
+```sh
+# Verifica a versão e lista as opções
+composer
+
+# Para obter ajuda com os comandos
+composer help require
+
+# Verifica se o Composer tem as permissões necessárias e se está atualizado
+composer diagnose
+composer diag # atalho
+
+# Atualiza o binário do Composer para a última versão
+composer self-update
+composer self # atalho
+```
+
+# Modo de uso
+
+O Composer armazena as dependências do seu projeto em `composer.json`.
+Você pode editar este arquivo, mas é recomendável deixar que o Composer faça isso.
+
+```sh
+# Cria um novo projeto na pasta atual
+composer init
+# Executa um questionário interativo, te pedindo detalhes sobre o projeto.
+# Você pode deixar o questionário em branco, desde que não haja outros projetos dependendo deste.
+
+# Se um arquivo composer.json já existir, baixa as dependências
+composer install
+
+# Para baixar apenas as dependências de produção, excluindo as de desenvolvimento
+composer install --no-dev
+
+# Adiciona uma dependência de produção ao projeto
+composer require guzzlehttp/guzzle
+# O Composer se encarrega de verificar qual é a última versão de
+# guzzlehttp/guzzle, baixar e adicionar a nova dependência no
+# campo 'require' do composer.json
+
+composer require guzzlehttp/guzzle:6.0.*
+# O composer baixa a última versão que combine com o padrão informado (6.0.2, por exemplo)
+# e adiciona essa dependência ao campo 'require' do arquivo composer.json
+
+composer require --dev phpunit/phpunit:~4.5.0
+# O composer irá baixar a dependencia como desenvolvimento,
+# usando a versão mais recente >= 4.5.0 e < 4.6.0
+
+composer require-dev phpunit/phpunit:^4.5.0
+# O composer irá baixar a dependencia como desenvolvimento,
+# usando a versão mais recente >= 4.5.0 e < 5.0
+
+# Para mais informações sobre os padrões de versões, veja a
+# Documentação sobre Versões do Composer: https://getcomposer.org/doc/articles/versions.md (EN)
+
+# Para ver quais pacotes estão disopníveis e quais estão instalados
+composer show
+
+# Para ver quais pacotes estão instalados
+composer show --installed
+
+# Para encontrar um pacote que tenha 'mailgun' no nome ou descrição
+composer search mailgun
+```
+
+[Packagist.org](https://packagist.org/) é o repositório principal para pacotes Composer. Pesquise aqui por pacotes existentes.
+
+## `composer.json` vs `composer.lock`
+
+O arquivo `composer.json` armazena as preferências de de versão de cada dependência, além de outras informações
+
+O arquivo `composer.lock` armazena exatamente qual versão foi baixada para cada dependência. Nunca altere este arquivo.
+
+Se você incluir o arquivo `composer.lock` no seu repositório git, todos os desenvolvedores irão instalar a mesma versão das dependências que você.
+Mesmo se uma nova versão for lançada, o Composer baixará apenas a versão salva no arquivo de lock.
+
+```sh
+# Atualizar todas as dependências para a versão mais recente (ainda dentro das preferências definidas)
+composer update
+
+# Para atualizar a versão de uma dependência específica:
+composer update phpunit/phpunit
+
+# Para migrar um pacote para uma nova preferência de versão, você pode precisar
+# remover o pacote antigo e suas dependências primeiro
+composer remove --dev phpunit/phpunit
+composer require --dev phpunit/phpunit:^5.0
+
+```
+
+## Autoloader
+
+O Composer cria uma classe autoloader que você pode usar na sua aplicação.
+Você pode instanciar as classes pelos seus namespaces.
+
+```php
+require __DIR__ . '/vendor/autoload.php';
+
+$mailgun = new Mailgun\Mailgun("key");
+```
+
+### Autoloader da PSR-4
+
+Você pode adicionar seus próprios namespaces ao autoloader.
+
+No `composer.json`, adicione um campo 'autoload':
+
+```json
+{
+ "autoload": {
+ "psr-4": {"Acme\\": "src/"}
+ }
+}
+```
+Isso irá dizer ao autoloader para buscar na pasta `src` tudo o que estiver no namespace `\Acme\`.
+
+Você também pode [usar a PSR-0, um mapa de classes ou apenas listar os arquivos para incluir](https://getcomposer.org/doc/04-schema.md#autoload),
+e pode usar o campo `autoload-dev` para namespaces de desenvolvimento.
+
+Ao adicionar ou alterar alguma chave de autoload, você precisará recriar o autoloader
+
+```sh
+composer dump-autoload
+composer dump # shorthand
+
+# Otimiza pacotes PSR-0 e PSR-4 para carregar com mapas de classes também.
+# É mais demorado, mas melhora a performance em produção.
+composer dump-autoload --optimize --no-dev
+```
+
+# O cache do Composer
+
+```sh
+# O Composer irá evitar baixar pacotes caso eles estejam no cache. Para limpar o cache:
+composer clear-cache
+```
+
+# Resolução de problemas
+
+```sh
+composer diagnose
+composer self-update
+composer clear-cache
+```
+
+## Tópicos (ainda) não falados neste tutorial
+
+* Criando e distribuindo seus próprios pacotes no Packagist.org ou qualquer lugar
+* Hooks Pré- e Pós-: rodar tarefas específicas em determinados eventos do Composer
+
+### Referências
+
+* [Composer - O gerenciador de dependências do PHP](https://getcomposer.org/) (EN)
+* [Packagist.org](https://packagist.org/) (EN)
diff --git a/pt-br/php-pt.html.markdown b/pt-br/php-pt.html.markdown
index 0e710742..8a1c956e 100644
--- a/pt-br/php-pt.html.markdown
+++ b/pt-br/php-pt.html.markdown
@@ -7,7 +7,7 @@ translators:
- ["Abdala Cerqueira", "http://abda.la"]
- ["Raquel Diniz", "http://twitter.com/raquelrdiniz"]
lang: pt-br
-filename: learnphp-pt.php
+filename: php-pt.html.markdown
---
Este documento descreve PHP 5+.
@@ -20,21 +20,23 @@ Este documento descreve PHP 5+.
// Duas barras iniciam o comentário de uma linha.
-# O hash (aka pound symbol) também inicia, mas // é mais comum
+# O hash (aka pound symbol) também inicia, mas // é mais comum.
/*
O texto envolto por barra-asterisco e asterisco-barra
- faz um comentário de múltiplas linhas
+ faz um comentário de múltiplas linhas.
*/
-// Utilize "echo" ou "print" para imprimir a saída
-print('Olá '); // Imprime "Olá " sem quebra de linha
+// Utilize "echo" ou "print" para imprimir a saída.
+print('Olá '); // Imprime "Olá " sem quebra de linha.
+print 'Olá '; // Não tem a necessidade de utilizar as chaves.
// () são opcionais para print e echo
-echo "Mundo\n"; // Imprime "Mundo" com quebra de linha
-// (Todas as declarações devem terminar com um ponto e vírgula)
+echo "Mundo\n"; // Imprime "Mundo" com quebra de linha.
+echo ("Mundo\n"); // Podemos tambem utilizar com chaves no echo.
+// (Todas as declarações devem terminar com um ponto e vírgula.)
-// Qualquer coisa fora da tag <?php é impresso automaticamente
+// Qualquer coisa fora da tag <?php é impresso automaticamente.
?>
Olá mundo novamente!
<?php
@@ -48,7 +50,7 @@ Olá mundo novamente!
// Um nome de variável válido se inicia com uma letra ou sublinhado,
// seguido por qualquer quantidade de letras, números ou sublinhados.
-// Valores booleanos não diferenciam maiúsculo de minúsculo (case-insensitive)
+// Valores booleanos não diferenciam maiúsculo de minúsculo (case-insensitive).
$boolean = true; // ou TRUE ou True
$boolean = false; // ou FALSE ou False
@@ -63,8 +65,8 @@ $float = 1.234;
$float = 1.2e3;
$float = 7E-10;
-// Excluir variável
-unset($int1)
+// Excluir variável.
+unset($int1);
// Aritmética
$soma = 1 + 1; // 2
@@ -79,17 +81,19 @@ echo $numero++; // Imprime 1 (incrementa após a avaliação)
echo ++$numero; // Imprime 3 (incrementa antes da avaliação)
$numero /= $float; // Divide e atribui o quociente de $numero
-// Strings podem ser colocadas entre aspas simples
+// Strings podem ser colocadas entre aspas simples.
$sgl_quotes = '$String'; // => '$String'
// Evite o uso de aspas duplas, exceto para incorporar outras variáveis
$dbl_quotes = "Esta é uma $sgl_quotes."; // => 'Esta é uma $String.'
-// Os caracteres especiais só são escapados entre aspas duplas
-$escapado = "Este contém um \t caractere tab.";
-$naoescapado = 'Este contém somente a barra e o t: \t';
+// Os caracteres especiais só são escapados entre aspas duplas.
+$escapado = "Este contém um \t caractere tab.";
+echo $escapado; //Imprime: Este contém um caractere tab.
+$naoescapado = 'Este contém somente a barra e o t: \t';
+echo $naoescapado; //Imprime: Este contém somente a barra e o t: \t
-// Coloque uma variável entre chaves se necessário
+// Coloque uma variável entre chaves se necessário.
$dinheiro = "Eu tenho $${numero} no banco.";
// Desde o PHP 5.3, nowdocs podem ser usados para múltiplas linhas sem análise
@@ -105,7 +109,7 @@ $sgl_quotes
FIM;
// Concatenação de string é feita com .
-echo 'Esta string ' . 'é concatenada';
+echo 'Esta string ' . 'é concatenada'; //Imprime: 'Esta string é concatenada'
/********************************
@@ -120,7 +124,7 @@ echo 'Esta string ' . 'é concatenada';
define("FOO", "alguma coisa");
// Acesso a uma constante é possível usando diretamente o nome escolhido
-echo 'Isto sairá '.FOO;
+echo 'Isto sairá '.FOO; //Imprime: Isto sairá alguma coisa
/********************************
@@ -135,16 +139,16 @@ $associativo = array('Um' => 1, 'Dois' => 2, 'Tres' => 3);
// PHP 5.4 introduziu uma nova sintaxe
$associativo = ['Um' => 1, 'Dois' => 2, 'Tres' => 3];
-echo $associativo['Um']; // imprime 1
+echo $associativo['Um']; // Imprime 1.
// Uma lista de literais atribui chaves inteiras implicitamente
$array = ['Um', 'Dois', 'Tres'];
-echo $array[0]; // => "Um"
+echo $array[0]; // Imprime => "Um"
// Adiciona um elemento no final do array
$array[] = 'Quatro';
-// Remove um elemento do array
+// Remove um elemento do array.
unset($array[3]);
/********************************
@@ -155,12 +159,12 @@ echo('Olá Mundo!');
// Imprime Olá Mundo! para stdout.
// Stdout é uma página web se executado em um navegador.
-print('Olá Mundo!'); // O mesmo que o echo
+print('Olá Mundo!'); // O mesmo que o echo.
// echo é atualmente um construtor de linguagem, então você pode
// remover os parênteses.
-echo 'Olá Mundo!';
-print 'Olá Mundo!'; // O print também é
+echo 'Olá Mundo!'; // Imprime: Olá Mundo!
+print 'Olá Mundo!'; // O print também é - Imprime: Olá Mundo!
$paragrafo = 'parágrafo';
@@ -181,11 +185,11 @@ $z = &$y;
// $z irá mudar o valor de $y também, e vice-versa.
// $x irá permanecer inalterado com o valor original de $y
-echo $x; // => 2
-echo $z; // => 2
+echo $x; // Imprime => 2
+echo $z; // Imprime => 2
$y = 0;
-echo $x; // => 2
-echo $z; // => 0
+echo $x; // Imprime => 2
+echo $z; // Imprime => 0
// Despeja tipos e valores de variável para o stdout
var_dump($z); // imprime int(0)
@@ -222,13 +226,13 @@ assert(1 !== '1');
// As variáveis podem ser convertidas entre tipos, dependendo da sua utilização.
$inteiro = 1;
-echo $inteiro + $inteiro; // => 2
+echo $inteiro + $inteiro; // Imprime => 2
$string = '1';
-echo $string + $string; // => 2 (strings são coagidas para inteiros)
+echo $string + $string; // Imprime => 2 (strings são coagidas para inteiros)
$string = 'one';
-echo $string + $string; // => 0
+echo $string + $string; // Imprime => 0
// Imprime 0 porque o operador + não pode fundir a string 'um' para um número
// Tipo de fundição pode ser utilizado para tratar uma variável
diff --git a/pt-br/python3-pt.html.markdown b/pt-br/python3-pt.html.markdown
new file mode 100644
index 00000000..9b6bd1b6
--- /dev/null
+++ b/pt-br/python3-pt.html.markdown
@@ -0,0 +1,746 @@
+---
+language: python3
+contributors:
+ - ["Louie Dinh", "http://pythonpracticeprojects.com"]
+ - ["Steven Basart", "http://github.com/xksteven"]
+ - ["Andre Polykanine", "https://github.com/Oire"]
+ - ["Zachary Ferguson", "http://github.com/zfergus2"]
+translators:
+ - ["Paulo Henrique Rodrigues Pinheiro", "http://www.sysincloud.it"]
+lang: pt-br
+filename: learnpython3-pt.py
+---
+
+Python foi criado por Guido Van Rossum nos anos 1990. Ele é atualmente uma
+das mais populares linguagens em existência. Eu fiquei morrendo de amor
+pelo Python por sua clareza sintática. É praticamente pseudocódigo executável.
+
+Suas opiniões são grandemente apreciadas. Você pode encontrar-me em
+[@louiedinh](http://twitter.com/louiedinh) ou louiedinh [em]
+[serviço de e-mail do google].
+
+Observação: Este artigo trata de Python 3 especificamente. Verifique
+[aqui](http://learnxinyminutes.com/docs/pt-br/python-pt/) se você pretende
+aprender o velho Python 2.7.
+
+```python
+
+# Comentários em uma única linha começam com uma cerquilha (também conhecido por sustenido).
+
+""" Strings de várias linhas podem ser escritas
+ usando três ", e são comumente usadas
+ como comentários.
+"""
+
+####################################################
+## 1. Tipos de dados primitivos e operadores
+####################################################
+
+# Você usa números normalmente
+3 # => 3
+
+# Matemática é como você espera que seja
+1 + 1 # => 2
+8 - 1 # => 7
+10 * 2 # => 20
+
+# Números inteiros por padrão, exceto na divisão, que retorna número
+# de ponto flutuante (float).
+35 / 5 # => 7.0
+
+# O resultado da divisão inteira arredonda para baixo tanto para números
+# positivos como para negativos.
+5 // 3 # => 1
+5.0 // 3.0 # => 1.0 # funciona em float também
+-5 // 3 # => -2
+-5.0 // 3.0 # => -2.0
+
+# Quando você usa um float, o resultado é float.
+3 * 2.0 # => 6.0
+
+# operador módulo
+7 % 3 # => 1
+
+# Exponenciação (x**y, x elevado à potência y)
+2**4 # => 16
+
+# Determine a precedência usando parêntesis
+(1 + 3) * 2 # => 8
+
+# Valores lógicos são primitivos (Atenção à primeira letra maiúscula)
+True
+False
+
+# negação lógica com not
+not True # => False
+not False # => True
+
+# Operadores lógicos
+# Observe que "and" e "or" são sensíveis a maiúsculas e minúsculas
+True and False # => False
+False or True # => True
+
+# Observe a utilização de operadores lógicos com números inteiros
+0 and 2 # => 0
+-5 or 0 # => -5
+0 == False # => True
+2 == True # => False
+1 == True # => True
+
+# Igualdade é ==
+1 == 1 # => True
+2 == 1 # => False
+
+# Diferença é !=
+1 != 1 # => False
+2 != 1 # => True
+
+# Mais comparações
+1 < 10 # => True
+1 > 10 # => False
+2 <= 2 # => True
+2 >= 2 # => True
+
+# Comparações podem ser agrupadas
+1 < 2 < 3 # => True
+2 < 3 < 2 # => False
+
+# (operador 'is' e operador '==') is verifica se duas referenciam um
+# mesmo objeto, mas == verifica se as variáveis apontam para o
+# mesmo valor.
+a = [1, 2, 3, 4] # Referência a uma nova lista, [1, 2, 3, 4]
+b = a # b referencia o que está referenciado por a
+b is a # => True, a e b referenciam o mesmo objeto
+b == a # => True, objetos a e b tem o mesmo conteúdo
+b = [1, 2, 3, 4] # Referência a uma nova lista, [1, 2, 3, 4]
+b is a # => False, a e b não referenciam o mesmo objeto
+b == a # => True, objetos a e b tem o mesmo conteúdo
+
+# Strings são criadas com " ou '
+"Isto é uma string."
+'Isto também é uma string.'
+
+# Strings também podem ser somadas! Mas tente não fazer isso.
+"Olá " + "mundo!" # => "Olá mundo!"
+# Strings podem ser somadas sem usar o '+'
+"Olá " "mundo!" # => "Olá mundo!"
+
+# Uma string pode ser manipulada como se fosse uma lista de caracteres
+"Isso é uma string"[0] # => 'I'
+
+# .format pode ser usado para formatar strings, dessa forma:
+"{} podem ser {}".format("Strings", "interpoladas") # => "Strings podem ser interpoladas"
+
+# Você pode repetir os argumentos para digitar menos.
+"Seja ágil {0}, seja rápido {0}, salte sobre o {1} {0}".format("Jack", "castiçal")
+# => "Seja ágil Jack, seja rápido Jack, salte sobre o castiçal Jack."
+
+# Você pode usar palavras-chave se quiser contar.
+"{nome} quer comer {comida}".format(nome="Beto", comida="lasanha") # => "Beto quer comer lasanha"
+
+# Se você precisa executar seu código Python3 com um interpretador Python 2.5 ou acima, você pode usar a velha forma para formatação de texto:
+"%s podem ser %s da forma %s" % ("Strings", "interpoladas", "antiga") # => "Strings podem ser interpoladas da forma antiga"
+
+
+# None é um objeto
+None # => None
+
+# Não use o operador de igualdade "==" para comparar objetos com None
+# Use "is" para isso. Ele checará pela identidade dos objetos.
+"etc" is None # => False
+None is None # => True
+
+# None, 0, e strings/listas/dicionários vazios todos retornam False.
+# Qualquer outra coisa retorna True
+bool(0) # => False
+bool("") # => False
+bool([]) # => False
+bool({}) # => False
+
+
+####################################################
+## 2. Variáveis e coleções
+####################################################
+
+# Python tem uma função print
+print("Eu sou o Python. Prazer em conhecer!") # => Eu sou o Python. Prazer em conhecer!
+
+# Por padrão a função print também imprime o caractere de nova linha ao final.
+# Use o argumento opcional end para mudar o caractere final.
+print("Olá, Mundo", end="!") # => Olá, Mundo!
+
+# Forma simples para capturar dados de entrada via console
+input_string_var = input("Digite alguma coisa: ") # Retorna o que foi digitado em uma string
+# Observação: Em versões antigas do Python, o método input() era chamado raw_input()
+
+# Não é necessário declarar variáveis antes de iniciá-las
+# È uma convenção usar letras_minúsculas_com_sublinhados
+alguma_variavel = 5
+alguma_variavel # => 5
+
+# Acessar uma variável que não tenha sido inicializada gera uma exceção.
+# Veja Controle de Fluxo para aprender mais sobre tratamento de exceções.
+alguma_variavel_nao_inicializada # Gera a exceção NameError
+
+# Listas armazenam sequencias
+li = []
+# Você pode iniciar com uma lista com alguns valores
+outra_li = [4, 5, 6]
+
+# Adicionar conteúdo ao fim da lista com append
+li.append(1) # li agora é [1]
+li.append(2) # li agora é [1, 2]
+li.append(4) # li agora é [1, 2, 4]
+li.append(3) # li agora é [1, 2, 4, 3]
+# Remover do final da lista com pop
+li.pop() # => 3 e agora li é [1, 2, 4]
+# Vamos colocá-lo lá novamente!
+li.append(3) # li agora é [1, 2, 4, 3] novamente.
+
+# Acessar uma lista da mesma forma que você faz com um array
+li[0] # => 1
+# Acessa o último elemento
+li[-1] # => 3
+
+# Acessando além dos limites gera um IndexError
+li[4] # Gera o IndexError
+
+# Você pode acessar vários elementos com a sintaxe de limites
+# (É um limite fechado, aberto pra você que gosta de matemática.)
+li[1:3] # => [2, 4]
+# Omitindo o final
+li[2:] # => [4, 3]
+# Omitindo o início
+li[:3] # => [1, 2, 4]
+# Selecione cada segunda entrada
+li[::2] # => [1, 4]
+# Tenha uma cópia em ordem invertida da lista
+li[::-1] # => [3, 4, 2, 1]
+# Use qualquer combinação dessas para indicar limites complexos
+# li[inicio:fim:passo]
+
+# Faça uma cópia profunda de um nível usando limites
+li2 = li[:] # => li2 = [1, 2, 4, 3] mas (li2 is li) resultará em False.
+
+# Apague elementos específicos da lista com "del"
+del li[2] # li agora é [1, 2, 3]
+
+# Você pode somar listas
+# Observação: valores em li e other_li não são modificados.
+li + other_li # => [1, 2, 3, 4, 5, 6]
+
+# Concatene listas com "extend()"
+li.extend(other_li) # Agora li é [1, 2, 3, 4, 5, 6]
+
+# Verifique se algo existe na lista com "in"
+1 in li # => True
+
+# Examine tamanho com "len()"
+len(li) # => 6
+
+
+# Tuplas são como l istas, mas imutáveis.
+tup = (1, 2, 3)
+tup[0] # => 1
+tup[0] = 3 # Gera um TypeError
+
+# Observe que uma tupla de tamanho um precisa ter uma vírgula depois do
+# último elemento mas tuplas de outros tamanhos, mesmo vazias, não precisa,.
+type((1)) # => <class 'int'>
+type((1,)) # => <class 'tuple'>
+type(()) # => <class 'tuple'>
+
+# Você pode realizar com tuplas a maior parte das operações que faz com listas
+len(tup) # => 3
+tup + (4, 5, 6) # => (1, 2, 3, 4, 5, 6)
+tup[:2] # => (1, 2)
+2 in tup # => True
+
+# Você pode desmembrar tuplas (ou listas) em variáveis.
+a, b, c = (1, 2, 3) # a é 1, b é 2 e c é 3
+# Por padrão, tuplas são criadas se você não coloca parêntesis.
+d, e, f = 4, 5, 6
+# Veja como é fácil permutar dois valores
+e, d = d, e # d é 5, e é 4
+
+# Dicionários armazenam mapeamentos
+empty_dict = {}
+# Aqui está um dicionário preenchido na definição da referência
+filled_dict = {"um": 1, "dois": 2, "três": 3}
+
+# Observe que chaves para dicionários devem ser tipos imutáveis. Isto é para
+# assegurar que a chave pode ser convertida para uma valor hash constante para
+# buscas rápidas.
+# Tipos imutáveis incluem inteiros, flotas, strings e tuplas.
+invalid_dict = {[1,2,3]: "123"} # => Gera um TypeError: unhashable type: 'list'
+valid_dict = {(1,2,3):[1,2,3]} # Já os valores, podem ser de qualquer tipo.
+
+# Acesse valores com []
+filled_dict["um"] # => 1
+
+# Acesse todas as chaves como um iterável com "keys()". É necessário encapsular
+# a chamada com um list() para transformá-las em uma lista. Falaremos sobre isso
+# mais adiante. Observe que a ordem de uma chave de dicionário não é garantida.
+# Por isso, os resultados aqui apresentados podem não ser exatamente como os
+# aqui apresentados.
+list(filled_dict.keys()) # => ["três", "dois", "um"]
+
+
+# Acesse todos os valores de um iterável com "values()". Novamente, é
+# necessário encapsular ele com list() para não termos um iterável, e sim os
+# valores. Observe que, como foi dito acima, a ordem dos elementos não é
+# garantida.
+list(filled_dict.values()) # => [3, 2, 1]
+
+
+# Verifique a existência de chaves em um dicionário com "in"
+"um" in filled_dict # => True
+1 in filled_dict # => False
+
+# Acessar uma chave inexistente gera um KeyError
+filled_dict["quatro"] # KeyError
+
+# Use o método "get()" para evitar um KeyError
+filled_dict.get("um") # => 1
+filled_dict.get("quatro") # => None
+# O método get permite um parâmetro padrão para quando não existir a chave
+filled_dict.get("um", 4) # => 1
+filled_dict.get("quatro", 4) # => 4
+
+# "setdefault()" insere em dicionário apenas se a dada chave não existir
+filled_dict.setdefault("cinco", 5) # filled_dict["cinco"] tem valor 5
+filled_dict.setdefault("cinco", 6) # filled_dict["cinco"] continua 5
+
+# Inserindo em um dicionário
+filled_dict.update({"quatro":4}) # => {"um": 1, "dois": 2, "três": 3, "quatro": 4}
+#filled_dict["quatro"] = 4 #outra forma de inserir em um dicionário
+
+# Remova chaves de um dicionário com del
+del filled_dict["um"] # Remove a chave "um" de filled_dict
+
+
+# Armazenamento em sets... bem, são conjuntos
+empty_set = set()
+# Inicializa um set com alguns valores. Sim, ele parece um dicionário. Desculpe.
+some_set = {1, 1, 2, 2, 3, 4} # some_set agora é {1, 2, 3, 4}
+
+# Da mesma forma que chaves em um dicionário, elementos de um set devem ser
+# imutáveis.
+invalid_set = {[1], 1} # => Gera um TypeError: unhashable type: 'list'
+valid_set = {(1,), 1}
+
+# Pode definir novas variáveis para um conjunto
+filled_set = some_set
+
+# Inclua mais um item no set
+filled_set.add(5) # filled_set agora é {1, 2, 3, 4, 5}
+
+# Faça interseção de conjuntos com &
+other_set = {3, 4, 5, 6}
+filled_set & other_set # => {3, 4, 5}
+
+# Faça união de conjuntos com |
+filled_set | other_set # => {1, 2, 3, 4, 5, 6}
+
+# Faça a diferença entre conjuntos com -
+{1, 2, 3, 4} - {2, 3, 5} # => {1, 4}
+
+# Verifique a existência em um conjunto com in
+2 in filled_set # => True
+10 in filled_set # => False
+
+
+
+####################################################
+## 3. Controle de fluxo e iteráveis
+####################################################
+
+# Iniciemos um variável
+some_var = 5
+
+# Aqui está uma expressão if. Indentação é significante em python!
+# imprime "somevar é menor que10"
+if some_var > 10:
+ print("some_var é absolutamente maior que 10.")
+elif some_var < 10: # Esta cláusula elif é opcional.
+ print("some_var é menor que 10.")
+else: # Isto também é opcional.
+ print("some_var é, de fato, 10.")
+
+
+"""
+Laços for iteram sobre listas
+imprime:
+ cachorro é um mamífero
+ gato é um mamífero
+ rato é um mamífero
+"""
+for animal in ["cachorro", "gato", "rato"]:
+ # Você pode usar format() para interpolar strings formatadas
+ print("{} é um mamífero".format(animal))
+
+"""
+"range(número)" retorna um iterável de números
+de zero até o número escolhido
+imprime:
+ 0
+ 1
+ 2
+ 3
+"""
+for i in range(4):
+ print(i)
+
+"""
+"range(menor, maior)" gera um iterável de números
+começando pelo menor até o maior
+imprime:
+ 4
+ 5
+ 6
+ 7
+"""
+for i in range(4, 8):
+ print(i)
+
+"""
+"range(menor, maior, passo)" retorna um iterável de números
+começando pelo menor número até o maior númeno, pulando de
+passo em passo. Se o passo não for indicado, o valor padrão é um.
+imprime:
+ 4
+ 6
+"""
+for i in range(4, 8, 2):
+ print(i)
+"""
+
+Laços while executam até que a condição não seja mais válida.
+imprime:
+ 0
+ 1
+ 2
+ 3
+"""
+x = 0
+while x < 4:
+ print(x)
+ x += 1 # Maneira mais curta para for x = x + 1
+
+# Lide com exceções com um bloco try/except
+try:
+ # Use "raise" para gerar um erro
+ raise IndexError("Isto é um erro de índice")
+except IndexError as e:
+ pass # Pass é um não-operador. Normalmente você usa algum código de recuperação aqui.
+except (TypeError, NameError):
+ pass # Varias exceções podem ser gerenciadas, se necessário.
+else: # Cláusula opcional para o bloco try/except. Deve estar após todos os blocos de exceção.
+ print("Tudo certo!") # Executa apenas se o código em try não gera exceção
+finally: # Sempre é executado
+ print("Nós podemos fazer o código de limpeza aqui.")
+
+# Ao invés de try/finally para limpeza você pode usar a cláusula with
+with open("myfile.txt") as f:
+ for line in f:
+ print(line)
+
+# Python provê uma abstração fundamental chamada Iterável.
+# Um iterável é um objeto que pode ser tratado como uma sequência.
+# O objeto retornou a função range, um iterável.
+
+filled_dict = {"um": 1, "dois": 2, "três": 3}
+our_iterable = filled_dict.keys()
+print(our_iterable) # => range(1,10). Esse é um objeto que implementa nossa interface iterável.
+
+# Nós podemos percorrê-la.
+for i in our_iterable:
+ print(i) # Imprime um, dois, três
+
+# Mas não podemos acessar os elementos pelo seu índice.
+our_iterable[1] # Gera um TypeError
+
+# Um iterável é um objeto que sabe como criar um iterador.
+our_iterator = iter(our_iterable)
+
+# Nosso iterador é um objeto que pode lembrar o estado enquanto nós o percorremos.
+# Nós acessamos o próximo objeto com "next()".
+next(our_iterator) # => "um"
+
+# Ele mantém o estado enquanto nós o percorremos.
+next(our_iterator) # => "dois"
+next(our_iterator) # => "três"
+
+# Após o iterador retornar todos os seus dados, ele gera a exceção StopIterator
+next(our_iterator) # Gera StopIteration
+
+# Você pode capturar todos os elementos de um iterador aplicando list() nele.
+list(filled_dict.keys()) # => Retorna ["um", "dois", "três"]
+
+
+####################################################
+## 4. Funções
+####################################################
+
+# Use "def" para criar novas funções.
+def add(x, y):
+ print("x é {} e y é {}".format(x, y))
+ return x + y # Retorne valores com a cláusula return
+
+# Chamando funções com parâmetros
+add(5, 6) # => imprime "x é 5 e y é 6" e retorna 11
+
+# Outro meio de chamar funções é com argumentos nomeados
+add(y=6, x=5) # Argumentos nomeados podem aparecer em qualquer ordem.
+
+# Você pode definir funções que pegam um número variável de argumentos
+# posicionais
+def varargs(*args):
+ return args
+
+varargs(1, 2, 3) # => (1, 2, 3)
+
+# Você pode definir funções que pegam um número variável de argumentos nomeados
+# também
+def keyword_args(**kwargs):
+ return kwargs
+
+# Vamos chamá-lo para ver o que acontece
+keyword_args(peh="grande", lago="ness") # => {"peh": "grande", "lago": "ness"}
+
+
+# Você pode fazer ambos simultaneamente, se você quiser
+def all_the_args(*args, **kwargs):
+ print(args)
+ print(kwargs)
+"""
+all_the_args(1, 2, a=3, b=4) imprime:
+ (1, 2)
+ {"a": 3, "b": 4}
+"""
+
+# Quando chamar funções, você pode fazer o oposto de args/kwargs!
+# Use * para expandir tuplas e use ** para expandir dicionários!
+args = (1, 2, 3, 4)
+kwargs = {"a": 3, "b": 4}
+all_the_args(*args) # equivalente a foo(1, 2, 3, 4)
+all_the_args(**kwargs) # equivalente a foo(a=3, b=4)
+all_the_args(*args, **kwargs) # equivalente a foo(1, 2, 3, 4, a=3, b=4)
+
+# Retornando múltiplos valores (com atribuição de tuplas)
+def swap(x, y):
+ return y, x # Retorna múltiplos valores como uma tupla sem os parêntesis.
+ # (Observação: os parêntesis foram excluídos mas podem estar
+ # presentes)
+
+x = 1
+y = 2
+x, y = swap(x, y) # => x = 2, y = 1
+# (x, y) = swap(x,y) # Novamente, os parêntesis foram excluídos mas podem estar presentes.
+
+# Escopo de função
+x = 5
+
+def setX(num):
+ # A variável local x não é a mesma variável global x
+ x = num # => 43
+ print (x) # => 43
+
+def setGlobalX(num):
+ global x
+ print (x) # => 5
+ x = num # variável global x agora é 6
+ print (x) # => 6
+
+setX(43)
+setGlobalX(6)
+
+
+# Python tem funções de primeira classe
+def create_adder(x):
+ def adder(y):
+ return x + y
+ return adder
+
+add_10 = create_adder(10)
+add_10(3) # => 13
+
+# Também existem as funções anônimas
+(lambda x: x > 2)(3) # => True
+(lambda x, y: x ** 2 + y ** 2)(2, 1) # => 5
+
+# TODO - Fix for iterables
+# Existem funções internas de alta ordem
+map(add_10, [1, 2, 3]) # => [11, 12, 13]
+map(max, [1, 2, 3], [4, 2, 1]) # => [4, 2, 3]
+
+filter(lambda x: x > 5, [3, 4, 5, 6, 7]) # => [6, 7]
+
+# Nós podemos usar compreensão de lista para interessantes mapas e filtros
+# Compreensão de lista armazena a saída como uma lista que pode ser uma lista
+# aninhada
+[add_10(i) for i in [1, 2, 3]] # => [11, 12, 13]
+[x for x in [3, 4, 5, 6, 7] if x > 5] # => [6, 7]
+
+####################################################
+## 5. Classes
+####################################################
+
+
+# Nós usamos o operador "class" para ter uma classe
+class Human:
+
+ # Um atributo de classe. Ele é compartilhado por todas as instâncias dessa
+ # classe.
+ species = "H. sapiens"
+
+ # Construtor básico, é chamado quando esta classe é instanciada.
+ # Note que dois sublinhados no início e no final de uma identificados
+ # significa objetos ou atributos que são usados pelo python mas vivem em
+ # um namespace controlado pelo usuário. Métodos (ou objetos ou atributos)
+ # como: __init__, __str__, __repr__, etc. são chamados métodos mágicos (ou
+ # algumas vezes chamados métodos dunder - "double underscore")
+ # Você não deve usar nomes assim por sua vontade.
+ def __init__(self, name):
+ @ Atribui o argumento ao atributo da instância
+ self.name = name
+
+ # Um método de instância. Todos os métodos tem "self" como primeiro
+ # argumento
+ def say(self, msg):
+ return "{name}: {message}".format(name=self.name, message=msg)
+
+ # Um método de classe é compartilhado por todas as instâncias
+ # Eles são chamados com a classe requisitante como primeiro argumento
+ @classmethod
+ def get_species(cls):
+ return cls.species
+
+ # Um método estático é chamado sem uma referência a classe ou instância
+ @staticmethod
+ def grunt():
+ return "*grunt*"
+
+
+# Instancie uma classe
+i = Human(name="Ian")
+print(i.say("oi")) # imprime "Ian: oi"
+
+j = Human("Joel")
+print(j.say("olá")) # imprime "Joel: olá"
+
+# Chama nosso método de classe
+i.get_species() # => "H. sapiens"
+
+# Altera um atributo compartilhado
+Human.species = "H. neanderthalensis"
+i.get_species() # => "H. neanderthalensis"
+j.get_species() # => "H. neanderthalensis"
+
+# Chama o método estático
+Human.grunt() # => "*grunt*"
+
+
+####################################################
+## 6. Módulos
+####################################################
+
+# Você pode importar módulos
+import math
+print(math.sqrt(16)) # => 4
+
+# Você pode importar apenas funções específicas de um módulo
+from math import ceil, floor
+print(ceil(3.7)) # => 4.0
+print(floor(3.7)) # => 3.0
+
+# Você pode importar todas as funções de um módulo para o namespace atual
+# Atenção: isso não é recomendado
+from math import *
+
+# Você pode encurtar o nome dos módulos
+import math as m
+math.sqrt(16) == m.sqrt(16) # => True
+
+# Módulos python são apenas arquivos python comuns. Você
+# pode escrever os seus, e importá-los. O nome do
+# módulo é o mesmo nome do arquivo.
+
+# Você pode procurar que atributos e funções definem um módulo.
+import math
+dir(math)
+
+
+####################################################
+## 7. Avançado
+####################################################
+
+# Geradores podem ajudar você a escrever código "preguiçoso"
+def double_numbers(iterable):
+ for i in iterable:
+ yield i + i
+
+# Um gerador cria valores conforme necessário.
+# Ao invés de gerar e retornar todos os valores de uma só vez ele cria um em
+# cada interação. Isto significa que valores maiores que 15 não serão
+# processados em double_numbers.
+# Nós usamos um sublinhado ao final do nome das variáveis quando queremos usar
+# um nome que normalmente colide com uma palavra reservada do python.
+range_ = range(1, 900000000)
+# Multiplica por 2 todos os números até encontrar um resultado >= 30
+for i in double_numbers(range_):
+ print(i)
+ if i >= 30:
+ break
+
+
+# Decoradores
+# Neste exemplo beg encapsula say
+# beg irá chamar say. Se say_please é verdade então ele irá mudar a mensagem
+# retornada
+from functools import wraps
+
+
+def beg(target_function):
+ @wraps(target_function)
+ def wrapper(*args, **kwargs):
+ msg, say_please = target_function(*args, **kwargs)
+ if say_please:
+ return "{} {}".format(msg, "Por favor! Eu sou pobre :(")
+ return msg
+
+ return wrapper
+
+
+@beg
+def say(say_please=False):
+ msg = "Você me paga uma cerveja?"
+ return msg, say_please
+
+
+print(say()) # Você me paga uma cerveja?
+print(say(say_please=True)) # Você me paga uma cerveja? Por favor! Eu sou pobre :(
+```
+
+## Pronto para mais?
+
+### Free Online
+
+* [Automate the Boring Stuff with Python](https://automatetheboringstuff.com)
+* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
+* [Dive Into Python](http://www.diveintopython.net/)
+* [Ideas for Python Projects](http://pythonpracticeprojects.com)
+* [The Official Docs](http://docs.python.org/3/)
+* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
+* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182)
+* [Python Course](http://www.python-course.eu/index.php)
+* [First Steps With Python](https://realpython.com/learn/python-first-steps/)
+* [A curated list of awesome Python frameworks, libraries and software](https://github.com/vinta/awesome-python)
+* [30 Python Language Features and Tricks You May Not Know About](http://sahandsaba.com/thirty-python-language-features-and-tricks-you-may-not-know.html)
+* [Official Style Guide for Python](https://www.python.org/dev/peps/pep-0008/)
+
+### Dead Tree
+
+* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20)
+* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20)
+* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20)
diff --git a/pt-br/ruby-ecosystem-pt.html.markdown b/pt-br/ruby-ecosystem-pt.html.markdown
new file mode 100644
index 00000000..da4f6f37
--- /dev/null
+++ b/pt-br/ruby-ecosystem-pt.html.markdown
@@ -0,0 +1,147 @@
+---
+category: tool
+tool: ruby ecosystem
+contributors:
+ - ["Jon Smock", "http://github.com/jonsmock"]
+ - ["Rafal Chmiel", "http://github.com/rafalchmiel"]
+translators:
+ - ["Claudson Martins", "http://github.com/claudsonm"]
+lang: pt-br
+
+---
+
+Pessoas utilizando Ruby geralmente têm uma forma de instalar diferentes versões
+do Ruby, gerenciar seus pacotes (ou gemas) e as dependências das gemas.
+
+## Gerenciadores Ruby
+
+Algumas plataformas possuem o Ruby pré-instalado ou disponível como um pacote.
+A maioria dos "rubistas" não os usam, e se usam, é apenas para inicializar outro
+instalador ou implementação do Ruby. Ao invés disso, rubistas tendêm a instalar
+um gerenciador para instalar e alternar entre diversas versões do Ruby e seus
+ambientes de projeto.
+
+Abaixo estão os gerenciadores Ruby mais populares:
+
+* [RVM](https://rvm.io/) - Instala e alterna entre os rubies. RVM também possui
+ o conceito de gemsets para isolar os ambientes dos projetos completamente.
+* [ruby-build](https://github.com/sstephenson/ruby-build) - Apenas instala os
+ rubies. Use este para um melhor controle sobre a instalação de seus rubies.
+* [rbenv](https://github.com/sstephenson/rbenv) - Apenas alterna entre os rubies.
+ Usado com o ruby-build. Use este para um controle mais preciso sobre a forma
+ como os rubies são carregados.
+* [chruby](https://github.com/postmodern/chruby) - Apenas alterna entre os rubies.
+ A concepção é bastante similar ao rbenv. Sem grandes opções sobre como os
+ rubies são instalados.
+
+## Versões do Ruby
+
+O Ruby foi criado por Yukihiro "Matz" Matsumoto, que continua a ser uma espécie
+de [BDFL](https://en.wikipedia.org/wiki/Benevolent_Dictator_for_Life), embora
+isso esteja mudando recentemente. Como resultado, a implementação de referência
+do Ruby é chamada de MRI (Matz' Reference Implementation), e quando você ver uma
+versão do Ruby, ela está se referindo a versão de lançamento do MRI.
+
+As três principais versões do Ruby em uso são:
+
+* 2.0.0 - Lançada em Fevereiro de 2013. Maioria das principais bibliotecas e
+ suporte a frameworks 2.0.0.
+* 1.9.3 - Lançada em Outubro de 2011. Está é a versão mais utilizada pelos rubistas
+ atualmente. Também [aposentada](https://www.ruby-lang.org/en/news/2015/02/23/support-for-ruby-1-9-3-has-ended/).
+* 1.8.7 - O Ruby 1.8.7 foi
+ [aposentado](http://www.ruby-lang.org/en/news/2013/06/30/we-retire-1-8-7/).
+
+A diferença entre a versão 1.8.7 para 1.9.x é muito maior do que a da 1.9.3 para
+a 2.0.0. Por exemplo, a série 1.9 introduziu encodes e uma VM bytecode. Ainda
+existem projetos na versão 1.8.7, mas eles estão tornando-se uma pequena minoria
+pois a maioria da comunidade migrou para a versão, pelo menos, 1.9.2 ou 1.9.3.
+
+## Implementações Ruby
+
+O ecossistema Ruby conta com várias diferentes implementações do Ruby, cada uma
+com pontos fortes e estados de compatibilidade. Para ser claro, as diferentes
+implementações são escritas em diferentes linguagens, mas *todas elas são Ruby*.
+Cada implementação possui hooks especiais e recursos extra, mas todas elas
+executam arquivos normais do Ruby tranquilamente. Por exemplo, JRuby é escrita
+em Java, mas você não precisa saber Java para utilizá-la.
+
+Muito maduras/compatíveis:
+
+* [MRI](https://github.com/ruby/ruby) - Escrita em C, esta é a implementação de
+ referência do Ruby. Por definição, é 100% compatível (consigo mesma). Todos os
+ outros rubies mantêm compatibilidade com a MRI (veja [RubySpec](#rubyspec) abaixo).
+* [JRuby](http://jruby.org/) - Escrita em Java e Ruby, esta implementação
+ robusta é um tanto rápida. Mais importante ainda, o ponto forte do JRuby é a
+ interoperabilidade com JVM/Java, aproveitando ferramentas JVM, projetos, e
+ linguagens existentes.
+* [Rubinius](http://rubini.us/) - Escrita principalmente no próprio Ruby, com
+ uma VM bytecode em C++. Também madura e rápida. Por causa de sua implementação
+ em Ruby, ela expõe muitos recursos da VM na rubyland.
+
+Medianamente maduras/compatíveis:
+
+* [Maglev](http://maglev.github.io/) - Construída em cima da Gemstone, uma
+ máquina virtual Smalltalk. O Smalltalk possui algumas ferramentas impressionantes,
+ e este projeto tenta trazer isso para o desenvolvimento Ruby.
+* [RubyMotion](http://www.rubymotion.com/) - Traz o Ruby para o desenvolvimento iOS.
+
+Pouco maduras/compatíveis:
+
+* [Topaz](http://topazruby.com/) - Escrita em RPython (usando o conjunto de
+ ferramentas PyPy), Topaz é bastante jovem e ainda não compatível. Parece ser
+ promissora como uma implementação Ruby de alta performance.
+* [IronRuby](http://ironruby.net/) - Escrita em C# visando a plataforma .NET,
+ o trabalho no IronRuby parece ter parado desde que a Microsoft retirou seu apoio.
+
+Implementações Ruby podem ter seus próprios números de lançamento, mas elas
+sempre focam em uma versão específica da MRI para compatibilidade. Diversas
+implementações têm a capacidade de entrar em diferentes modos (1.8 ou 1.9, por
+exemplo) para especificar qual versão da MRI focar.
+
+## RubySpec
+
+A maioria das implementações Ruby dependem fortemente da [RubySpec](http://rubyspec.org/).
+Ruby não tem uma especificação oficial, então a comunidade tem escrito
+especificações executáveis em Ruby para testar a compatibilidade de suas
+implementações com a MRI.
+
+## RubyGems
+
+[RubyGems](http://rubygems.org/) é um gerenciador de pacotes para Ruby mantido
+pela comunidade. RubyGems vem com o Ruby, portanto não é preciso baixar separadamente.
+
+Os pacotes do Ruby são chamados de "gemas", e elas podem ser hospedadas pela
+comunidade em RubyGems.org. Cada gema contém seu código-fonte e alguns metadados,
+incluindo coisas como versão, dependências, autor(es) e licença(s).
+
+## Bundler
+
+[Bundler](http://bundler.io/) é um gerenciador de dependências para as gemas.
+Ele usa a Gemfile de um projeto para encontrar dependências, e então busca as
+dependências dessas dependências de forma recursiva. Ele faz isso até que todas
+as dependências sejam resolvidas e baixadas, ou para se encontrar um conflito.
+
+O Bundler gerará um erro se encontrar um conflito entre dependências. Por exemplo,
+se a gema A requer versão 3 ou maior que a gema Z, mas a gema B requer a versão
+2, o Bundler irá notificá-lo que há um conflito. Isso se torna extremamente útil
+quando diversas gemas começam a referenciar outras gemas (que referem-se a outras
+gemas), o que pode formar uma grande cascata de dependências a serem resolvidas.
+
+# Testes
+
+Testes são uma grande parte da cultura do Ruby. O Ruby vem com o seu próprio
+framework de teste de unidade chamado minitest (ou TestUnit para Ruby versão 1.8.x).
+Existem diversas bibliotecas de teste com diferentes objetivos.
+
+* [TestUnit](http://ruby-doc.org/stdlib-1.8.7/libdoc/test/unit/rdoc/Test/Unit.html) -
+ Framework de testes "Unit-style" para o Ruby 1.8 (built-in)
+* [minitest](http://ruby-doc.org/stdlib-2.0.0/libdoc/minitest/rdoc/MiniTest.html) -
+ Framework de testes para o Ruby 1.9/2.0 (built-in)
+* [RSpec](http://rspec.info/) - Um framework de testes que foca na expressividade
+* [Cucumber](http://cukes.info/) - Um framework de testes BDD que analisa testes Gherkin formatados
+
+## Seja Legal
+
+A comunidade Ruby orgulha-se de ser uma comunidade aberta, diversa, e receptiva.
+O próprio Matz é extremamente amigável, e a generosidade dos rubistas em geral
+é incrível.
diff --git a/pt-br/ruby-pt.html.markdown b/pt-br/ruby-pt.html.markdown
index 668cd25f..1078f6c5 100644
--- a/pt-br/ruby-pt.html.markdown
+++ b/pt-br/ruby-pt.html.markdown
@@ -7,6 +7,7 @@ contributors:
- ["Jean Matheus Souto", "http://jeanmatheussouto.github.io"]
translators:
- ["Katyanna Moura", "https://twitter.com/amelie_kn"]
+ - ["Alan Peterson Carvalho Silva", "https://twitter.com/DemonKart"]
---
```ruby
@@ -101,7 +102,7 @@ caminho_para_a_raiz_do_projeto = '/bom/nome/'
caminho = '/nome/ruim/'
# Símbolos (são objetos)
-# Símbolos são imutáveis, são constantes reutilizáveis representadadas
+# Símbolos são imutáveis, são constantes reutilizáveis representados
# internamente por um valor inteiro. Eles são frequentemente usados no
# lugar de strings para transmitir com eficiência os valores específicos
# e significativos
@@ -260,7 +261,7 @@ somar 3, 4 #=> 7
somar(3,4), 5 #=> 12
# yield
-# Todos os métodos possuem implicitamente um paramêntro opcional que é um bloco
+# Todos os métodos possuem implicitamente um paramêtro opcional que é um bloco
# ele pode ser chamado com a palavra chave 'yield'
def ao_redor
@@ -285,7 +286,7 @@ class Humano
# Inicialização básica (contructor)
def initialize(nome, idade=0)
- # Atribui o argumento para a variável de instancia "nome" do objeto
+ # Atribui o argumento para a variável de instância "nome" do objeto
@nome = nome
# Se a idade não for passada, nós definimos um valor padrão na lista de argumentos
@idade = idade
@@ -301,7 +302,7 @@ class Humano
@nome
end
- # Um método de classe usa a palavra chave self para se defenciar dos métodos de instância.
+ # Um método de classe usa a palavra chave self para se diferenciar dos métodos de instância.
# Ele só pode ser chamado na classe, não na instancia
def self.diz(msg)
puts "#{msg}"
@@ -362,7 +363,7 @@ Trabalhador.foo # 0
Humano.foo = 2 # 2
Trabalhador.foo # 2
-# Uma variável de instância não é compartilhada por suas classes decendentes.
+# Uma variável de instância não é compartilhada por suas classes descendentes.
class Humano
@bar = 0
@@ -382,12 +383,65 @@ end
Humano.bar # 0
Doutor.bar # nil
+---
+
+module ModuloDeExemplo
+ def foo
+ 'foo'
+ end
+end
+
+# Incluir (include) módulos conecta seus métodos às instâncias da classe
+# Herdar (extend) módulos conecta seus métodos à classe em si
+
+class Pessoa
+ include ExemploDeModulo
+end
+
+class Livro
+ extend ExemploDeModulo
+end
+
+Pessoa.foo # => NoMethodError: undefined method `foo' for Pessoa:Class
+Pessoa.new.foo # => 'foo'
+Livro.foo # => 'foo'
+Livro.new.foo # => NoMethodError: undefined method `foo'
+
+# Callbacks são executados ao incluir e herdar um módulo
+
+module ExemploDeConceito
+ def self.included(base)
+ base.extend(MetodosDeClasse)
+ base.send(:include, MetodosDeInstancia)
+ end
+
+ module MetodosDeClasse
+ def bar
+ 'bar'
+ end
+ end
+
+ module MetodosDeInstancia
+ def qux
+ 'qux'
+ end
+ end
+end
+
+class Algo
+ include ExemploDeConceito
+end
+
+Algo.bar # => 'bar'
+Algo.qux # => NoMethodError: undefined method `qux'
+Algo.new.bar # => NoMethodError: undefined method `bar'
+Algo.new.qux # => 'qux'
```
-## Mais sobre Ruby
+## Recursos adicionais
-- [Documentação oficial](http://www.ruby-doc.org/core-2.1.1/)
- [Aprenda Ruby com desafios](http://www.learneroo.com/modules/61/nodes/338) - Uma coleção de desafios para testar a linguagem.
+- [Documentação oficial](http://www.ruby-doc.org/core-2.1.1/)
- [Ruby a partir de outras linguagens](https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/)
- [Programming Ruby](http://www.amazon.com/Programming-Ruby-1-9-2-0-Programmers/dp/1937785491/)- Um mais antigo [free edition](http://ruby-doc.com/docs/ProgrammingRuby/) e tambem uma versão online disponível.
- [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide) - Uma versão colaborativa de um *style-guide*
diff --git a/pt-br/scala-pt.html.markdown b/pt-br/scala-pt.html.markdown
new file mode 100644
index 00000000..3459f567
--- /dev/null
+++ b/pt-br/scala-pt.html.markdown
@@ -0,0 +1,668 @@
+---
+language: Scala
+filename: learnscala-pt.scala
+contributors:
+ - ["George Petrov", "http://github.com/petrovg"]
+ - ["Dominic Bou-Samra", "http://dbousamra.github.com"]
+ - ["Geoff Liu", "http://geoffliu.me"]
+ - ["Ha-Duong Nguyen", "http://reference-error.org"]
+translators:
+ - ["Francieli Viane", "https://github.com/FFrancieli"]
+lang: pt-br
+---
+
+Scala - a linguagem escalável
+
+```scala
+
+/////////////////////////////////////////////////
+// 0. O básico
+/////////////////////////////////////////////////
+/*
+ Configurando o Scala:
+
+ 1) Baixe o instalador do Scala - http://www.scala-lang.org/downloads
+ 2) Extraia (unzip ou tar) para sua localização favorita e coloque o subdiretório
+ bin na variável de ambiente `PATH`
+*/
+
+/*
+ Tente o REPL
+
+ Scala tem uma ferramenta chamada REPL (Read-Eval-Print Loop) que é análogo a
+ interpretadores de linha de comando de outras linguagens. Você pode digitar
+ qualquer expressão de Scala e o resultado será calculado e impresso.
+
+ O REPL é uma ferramenta muito conveniente para testar e verificar código. Use-o
+ enquanto você lê o tutorial para explorar os conceitos rapidamente por conta própria.
+*/
+
+//Inicialize um REPL de Scala executando o comando scala no terminal. Você deve ver o prompt:
+$ scala
+scala>
+
+//Por padrão, cada expressão que você executa é salva como um novo valor enumerado:
+scala> 2 + 2
+res0: Int = 4
+
+// Valores padrões podem ser reutilizados. Observe o tipo do valor exibido no resultado...
+scala> res0 + 2
+res1: Int = 6
+
+// Scala é uma linguagem fortemente tipada. Você pode usar o REPL para verfificar o tipo
+// sem avaliar uma expressão.
+
+scala> :type (true, 2.0)
+(Boolean, Double)
+
+// As sessões do REPL podem ser salvas
+scala> :save /sites/repl-test.scala
+
+//Arquivos podem ser carregados no REPL
+scala> :load /sites/repl-test.scala
+Loading /sites/repl-test.scala...
+res2: Int = 4
+res3: Int = 6
+
+// Você pode pesquisar em seu histórico recente
+scala> :h?
+1 2 + 2
+2 res0 + 2
+3 :save /sites/repl-test.scala
+4 :load /sites/repl-test.scala
+5 :h?
+
+// Agora que você já sabe brincar, vamos aprender um pouco de Scala...
+
+/////////////////////////////////////////////////
+// 1. Introdução
+/////////////////////////////////////////////////
+
+// Comentários de uma linha começam com duas barras
+
+/*
+ Comentários com múltiplas linhas, como você já pode ver, são assim.
+*/
+
+// Imprimir e forçar uma linha na próxima impressão
+println("Hello world!")
+println(10)
+// Hello world!
+// 10
+
+//Imprimir sem forçar uma nova linha na próxima impressão
+print("Hello world")
+print(10)
+// Hello world10
+
+//A declaração de valores pode ser feita usando tanto o var quanto o val.
+// Declarações feitas com `val` são imutáveis, enquanto que declarações feitas
+// com var são mutáveis. Imutabilidade é uma coisa boa.
+val x = 10 // x is now 10
+x = 20 // error: reassignment to val
+var y = 10
+ = 20 // y agora é 20
+
+/*
+ Scala é uma linguagem estaticamente tipada. Observe ainda que nas declarações
+ acima nós não especificamos um tipo. Isso se deve a um recurso da linguagem
+ chamado de inferência. Na maioria dos casos, o compilador do Scala consegue
+ adivinhar qual tipo é, de forma que você não precisa digitar sempre. Nós
+ podemos declarar o tipo da variável de maneira explícita asim:
+*/
+
+val z: Int = 10
+val a: Double = 1.0
+
+// Note que a conversão automática de Int para Double, o resultado é 10.0, não 10
+val b: Double = 10
+
+//Valores booleanos
+true
+false
+
+//Operações booleanas
+!true // false
+!false // true
+true == false // false
+10 > 5 // true
+
+// Matemática é como o de costume
+1 + 1 // 2
+2 - 1 // 1
+5 * 3 // 15
+6 / 2 // 3
+6 / 4 // 1
+6.0 / 4 // 1.5
+6 / 4.0 // 1.5
+
+// Calcular uma expressão no REPL te dá o tipo e o valor do resultado
+1 + 7
+
+/* A linha acima resulta em:
+ scala> 1 + 7
+ res29: Int = 8
+
+ Isso significa que o resultado ao culcular 1 + 7 é um objeto do tipo Int com
+ valor 8.
+
+ Note que "res29" é o nome de uma variável gerada sequencialmente para guardar
+ os resultados das expressões que você executa, logo seu nome pode ser
+ diferente.
+*/
+
+"Strings em Scala são delimitadas por aspas duplas"
+'a' // Um caractere em Scala
+// 'Strings com aspas simples não existem em Scala.' <= isso causa um erro.
+
+// Strings possuem os métodos comuns de Java definidos
+"hello world".length
+"hello world".substring(2, 6)
+"hello world".replace("C", "3")
+
+// Elas também possuem alguns métodos extras do Scala. Veja também:
+scala.collection.immutable.StringOps
+"hello world".take(5)
+"hello world".drop(5)
+
+//Interpolação de string: observe o prefixo "s"
+val n = 45
+s"We have $n apples" // => "We have 45 apples"
+
+// Também é possível ter expressões dentro de interpolação de strings
+val a = Array(11, 9, 6)
+s"My second daughter is ${a(0) - a(2)} years old." // => "My second daughter is 5 years old."
+s"We have double the amount of ${n / 2.0} in apples." // => "We have double the amount of 22.5 in apples."
+s"Power of 2: ${math.pow(2, 2)}" // => "Power of 2: 4"
+
+// Formatação de strings interpoladas com o prefixo "f"
+f"Power of 5: ${math.pow(5, 2)}%1.0f" // "Power of 5: 25"
+f"Square root of 122: ${math.sqrt(122)}%1.4f" // "Square root of 122: 11.0454"
+
+
+// Strings cruas, ignorando caracteres especiais
+raw"New line feed: \n. Carriage return: \r." // => "New line feed: \n. Carriage return: \r."
+
+//Alguns caracteres precisam ser "escapados", ex. uma aspa dupla dentro de uma string
+
+"They stood outside the \"Rose and Crown\"" // => "They stood outside the "Rose and Crown""
+
+// Aspas triplas permitem strings a abrangerem múltiplas linhas e conter Aspas
+val html = """<form id="daform">
+ <p>Press belo', Joe</p>
+ <input type="submit">
+ </form>"""
+
+
+/////////////////////////////////////////////////
+// 2. Funções
+/////////////////////////////////////////////////
+
+// Funções são definidas da seguinte maneira:
+//
+// def nomeDaFuncao(args ...): TipoDeRetorno = {body ...}
+//
+// Se você vem de linguagens mais tradicionais, note a omissão da palavra chave
+//return. Em Scala a última expressão no bloco da função é o valor de retorno
+def sumOfSquares(x: Int, y: Int): Int = {
+ val x2 = x * x
+ val y2 = y * y
+ x2 + y2
+}
+
+// As { } podem ser omitidas se o corpo da função possui apenas uma expressão:
+def sumOfSquaresShort(x: Int, y: Int): Int = x * x + y * y
+
+// A sintaxe para chamar funções é familiar:
+sumOfSquares(3, 4) // => 25
+
+// Você poode usar o nome dos parâmetros para especificá-los numa ordem diferente
+def subtract(x: Int, y: Int): Int = x - y
+
+subtract(10, 3) // => 7
+subtract(y=10, x=3) // => -7
+
+// Na maioria dos casos (sendo funções recursivas a a exceção mais notável) o
+// tipo de retorno da função pode ser omitido, e o mesmo tipo de inferência que
+// vimos nas variáveis funcionará com o valor de retorno da função:
+def sq(x: Int) = x * x // O compilador consegue adivinhar que o tipo de retorno é Int
+
+// Funções podem ter parâmetros padrão:
+def addWithDefault(x: Int, y: Int = 5) = x + y
+addWithDefault(1, 2) // => 3
+addWithDefault(1) // => 6
+
+// Funções anônimas são semelhantes a essa:
+(x: Int) => x * x
+
+// Diferente de defs, até mesmo a entrada de funções anônimas podem ser omitidas
+// se o contexto deixar isso claro. Observe o tipo "Int => Int", que significa
+// uma função que recebe umn Int e retorna um Int.
+val sq: Int => Int = x => x * x
+
+// Se cada argumento na sua função anônima é usado apenas uma vez, Scala te fornece
+// uma maneira ainda mais curta de definí-lo. Estas funções anônimas acabam por
+// ser muito comuns, como será mostrado na sessão de estrutura de dados.
+val addOne: Int => Int = _ + 1
+val weirdSum: (Int, Int) => Int = (_ * 2 + _ * 3)
+
+addOne(5) // => 6
+weirdSum(2, 4) // => 16
+
+// A palavra chave return existe em Scala, mas só retorna do def mais profundo que o cerca.
+//AVISO: O uso do return em Scala é propenso a erros e deve ser evitado.
+//Não há efeito em funções anônimas. Per exemplo:
+def foo(x: Int): Int = {
+ val anonFunc: Int => Int = { z =>
+ if (z > 5)
+ return z // Esta linha faz Z retornar o valor de foo!
+ else
+ z + 2 // Esta linha retorna o valor de anonFunc
+ }
+ anonFunc(x) // Esta linha retorna o valor de foo
+}
+
+/////////////////////////////////////////////////
+// 3. Controle de Fluxo
+/////////////////////////////////////////////////
+
+1 to 5
+val r = 1 to 5
+r.foreach(println)
+
+r foreach println
+///N.B.: Scala é bem flexível quando se fala de pontos e parêntesis - estude as regras
+//separadamente. Isso ajuda a escrever DSLs e APIs que são lidas como inglês.
+
+(5 to 1 by -1) foreach (println)
+
+// Um loop while
+var i = 0
+while (i < 10) { println("i " + i); i += 1 }
+
+while (i < 10) { println("i " + i); i += 1 } // Sim, de novo. O que aconteceu? Por quê?
+
+i // Exibe o valor de i. Note que o while é um loop no senso clássico -
+ // executa sequencialmente enquanto muda a variável do loop. While é muito
+ // rápido, mas usar os combinadores e compreenões acima é mais fácil
+ // para entender e paralizar
+
+// Um loop do-while
+i = 0
+do {
+ println("i ainda é menor que 10")
+ i += 1
+} while (i < 10)
+
+
+// Recursão é a forma mais idiomática de repetir uma ação em Scala (assim como na
+// maioria das linguagens de programação funcional)
+// Funções recursivas precisam de um tipo de retorno explícito, o compilador não
+// consegue inferir;
+// Aqui está o Unit
+def showNumbersInRange(a: Int, b: Int): Unit = {
+ print(a)
+ if (a < b)
+ showNumbersInRange(a + 1, b)
+}
+showNumbersInRange(1, 14)
+
+// Condicionais
+
+al x = 10
+
+if (x == 1) println("yeah")
+if (x == 10) println("yeah")
+if (x == 11) println("yeah")
+if (x == 11) println("yeah") else println("nay")
+
+println(if (x == 10) "yeah" else "nope")
+val text = if (x == 10) "yeah" else "nope"
+
+/////////////////////////////////////////////////
+// 4. Estrutura de Dados
+/////////////////////////////////////////////////
+
+val a = Array(1, 2, 3, 5, 8, 13)
+a(0) // Int = 1
+a(3) // Int = 5
+a(21) // Lança uma exceção
+
+val safeM = m.withDefaultValue("no lo se")
+safeM("bottle") // java.lang.String = no lo se
+
+val s = Set(1, 3, 7)
+s(0) // Boolean = false
+s(1) // Boolean = true
+
+/* Veja a documantação do map aqui -
+ * http://www.scala-lang.org/api/current/index.html#scala.collection.immutable.Map
+ * e garanta que você leia
+ */
+
+ // Tuplas
+
+ (1, 2)
+
+ (4, 3, 2)
+
+ (1, 2, "three")
+
+ (a, 2, "three")
+
+ //Por que ter isso?
+ val divideInts = (x: Int, y: Int) => (x / y, x % y)
+
+//A função divideInts te dá o resultado e o resultado
+divideInts(10, 3) // (Int, Int) = (3,1)
+
+//Para acessar os elementos de uma tupla, use _._n onde n é o índex do elemento
+
+val d = divideInts(10, 3) // (Int, Int) = (3,1)
+
+d._1 // Int = 3
+d._2 // Int = 1
+
+// Alternativamente, você pode atribuir múltiplas variáveis para uma tupla, o
+// que é mais conveniente e legível em muitos casos
+val (div, mod) = divideInts(10, 3)
+
+div // Int = 3
+mod // Int = 1
+
+/////////////////////////////////////////////////
+// 5. Object Oriented Programming
+/////////////////////////////////////////////////
+
+/*
+ Tudo o que vimos até agora neste tutorial foram expressões simples (valores, funções, etc).
+ Essas expressões são boas para digitar no interpretador da linha de comando para
+ testes rápidos, mas elas não podem existir por si só em um arquivo Scala. Por exemplo,
+ você não pode ter simplesmente "val x = 5" em um arquivo Scala. Ao invés disso, os únicos
+ construtores de alto nível permitidos em Scala são:
+
+ - objects
+ - classes
+ - case classes
+ - traits
+
+ E agora vamos explicar o que é cada um deles.
+*/
+
+//classes são similares a classes em outras linguagens. Os argumentos do construtor
+// são declarados logo depois do nome da classe e a inicialização é feita no corpo da classe.
+
+class Dog(br: String) {
+ // codigo do construtor aqui
+ var breed: String = br
+
+ // Define um método chamado bark que retorna uma String
+ def bark = "Woof, woof!"
+
+ // Assume-se que os métodos e valores são públicos. As palavras chave "protected"
+ // e "private" também estão disponíveis.
+ private def sleep(hours: Int) =
+ println(s"I'm sleeping for $hours hours")
+
+ // Métodos abstratos são simplesmente métodos sem corpo. Se a gente remover o
+ // comentário da próxima linha a classe Dog teria que ser declarada como abstrata
+
+ // abstract class Dog(...) { ... }
+ // def chaseAfter(what: String): String
+}
+
+// A palavra chave "object" cria um tipo e uma instância singlenton desse tipo.
+// É comum para classes em Scala ter um "companion object" (objeto companheiro),
+// onde, por exemlo, o comportamento é capturado pelas classes em si, mas o comportamento
+// relacionado a toda instância da classe vai em objects. A diferença é semelhante
+// a métodos versus métodos estáticos em outras linguagens. Note que objects e
+// classes podem ter o mesmo nome.
+
+object Dog {
+ def allKnownBreeds = List("pitbull", "shepherd", "retriever")
+ def createDog(breed: String) = new Dog(breed)
+}
+
+// Case classes são classes que possuem uma funcionalidade extra incorporada.
+// Uma dúvida comum para iniciantes em Scala é quando usar classes e quando usar
+// case classes. A linha é bem tênue, mas em geral classes tendem a focar em encapsulamento,
+// polimorfismo e comportamento. Os valores nestas classes tendem a ser privados e
+// apenas métodos ficam expostos. O propósito primário de uma case class é guardar
+// dados imutáveis. Às vezes as case classes possuem alguns poucos métodos, os quais
+// raramente possuem efeitos colaterais (side effects).
+case class Person(name: String, phoneNumber: String)
+
+// Cria uma nova instância. Observe que case classes não precisam de usar "new" ao serem instanciadas
+val george = Person("George", "1234")
+val kate = Person("Kate", "4567")
+
+// Com case classes você ganha algumas regalias, como getters:
+// With case classes, you get a few perks for free, like getters:
+george.phoneNumber // => "1234"
+
+// Verificação de igualdade por campo (sem a necessidade de sobrescrever o método equals)
+Person("George", "1234") == Person("Kate", "1236") // => false
+
+// Uma maneira fácil de copiar
+// otherGeorge == Person("george", "9876")
+val otherGeorge = george.copy(phoneNumber = "9876")
+
+// E muitas outras. Case classes também possuem pattern matching de graça. Veja no próximo tópico.
+
+// Traits a caminho.
+
+
+/////////////////////////////////////////////////
+// 6. Pattern Matching
+/////////////////////////////////////////////////
+
+// Pattern matching é um recurso muito poderoso e muito usado em Scala. Aqui
+// mostramos como o seu pattern se adequa a uma case class.
+// NB: Diferente de outras linguagens, Scala não precisa de quebras. Entrar em
+// todas as condições do pattern matching simples não acontece.
+
+def matchPerson(person: Person): String = person match {
+ // Enrão você especifica os padrões
+ case Person("George", number) => "We found George! His number is " + number
+ case Person("Kate", number) => "We found Kate! Her number is " + number
+ case Person(name, number) => "We matched someone : " + name + ", phone : " + number
+}
+
+val email = "(.*)@(.*)".r // Define uma regex para o próximo exemplo.
+
+// Pattern matching pode parecer com o comando switch nas liguagens da família C,
+// mas é muito mais poderoso. Em Scala você pode encontrar mais correpondências:
+
+def matchEverything(obj: Any): String = obj match {
+ // Você pode encontrar valores correspondentes:
+ case "Hello world" => "Got the string Hello world"
+
+ // Você pode fazer correspondência por tipo:
+ case x: Double => "Got a Double: " + x
+
+ // Você pode especificar condições:
+ case x: Int if x > 10000 => "Got a pretty big number!"
+
+ // Você pode encontrar correspondência com case classes, como fizemos antes:
+ case Person(name, number) => s"Got contact info for $name!"
+
+ // Você pode encontrar correspondências por regex:
+ case email(name, domain) => s"Got email address $name@$domain"
+
+ // Você pode encontrar correspondencias por tuplas:
+ case (a: Int, b: Double, c: String) => s"Got a tuple: $a, $b, $c"
+
+ // Você pode encontrar corresponências por estruturas de dados:
+ case List(1, b, c) => s"Got a list with three elements and starts with 1: 1, $b, $c"
+
+ // Você pode aninhar padrões:
+ case List(List((1, 2, "YAY"))) => "Got a list of list of tuple"
+
+ // Retornar qualquer valor (padrão - default) caso nenhuma das possibilidades é correspondente.
+ case _ => "Got unknown object"
+
+ // Na verdade, você pode fazer correspondência de padrão de qualquer objeto que
+ // tenha o método "unnaply". Este recurso é tão poderoso que o Scala te deixa
+ // criar funções inteiras como patterns:
+
+ val patternFunc: Person => String = {
+ case Person("George", number) => s"George's number: $number"
+ case Person(name, number) => s"Random person's number: $number"
+ }
+}
+
+/////////////////////////////////////////////////
+// 7. Programação Funcional
+/////////////////////////////////////////////////
+
+// Scala permite que métodos e funções recebam ou retornem outras funções ou métodos.
+
+val add10: Int => Int = _ + 10 // A function taking an Int and returning an Int
+List(1, 2, 3) map add10 // List(11, 12, 13) - add10 is applied to each element
+
+// Funções anônimas podem ser usadas ao invés de funções com nomes:
+List(1, 2, 3) map (x => x + 10)
+
+// E o símbolo underline ("_") pode ser usado quando há apenas um argumento para a função anônima.
+List(1, 2, 3) map (_ + 10)
+
+// Se tanto o bloco animo quanto a função que você estiver usando receberem apenas
+// um argumento, você pode inclusive omitir o símbolo _
+List(1, 2, 3) map (_ + 10)
+
+// Combinadores
+
+s.map(sq)
+
+val sSquared = s. map(sq)
+
+sSquared.filter(_ < 10)
+
+sSquared.reduce (_+_)
+
+// A função filter recebe um predicado (uma função do tipo A -> Boolean) e seleciona
+// todos os elementos que satisfazem o predicado.
+List(1, 2, 3) filter (_ > 2) // List(3)
+case class Person(name: String, age: Int)
+List(
+ Person(name = "Dom", age = 23),
+ Person(name = "Bob", age = 30)
+).filter(_.age > 25) // List(Person("Bob", 30))
+
+// Scala tem o método foreach definido em algumas collections em específico, o qual
+// recebe um tipo e retorna Unit (um método void)
+val aListOfNumbers = List(1, 2, 3, 4, 10, 20, 100)
+aListOfNumbers foreach (x => println(x))
+aListOfNumbers foreach println
+
+/* NB Ests não são laços for. A semântica dos laços for é 'repetir' enquanto um
+ for-comprehension define um relacionamento entre dois conjuntos de dados */
+
+
+/////////////////////////////////////////////////
+// 8. Implicits
+/////////////////////////////////////////////////
+
+/* ALERTA ALERTA:
+ Implicits são um conjunto de recursos poderosos de Scala e consequentemente é
+ fácil abusar deles. Iniciantes em Scala deveriam resistir a tentação de usá-los
+ até que eles entendam não apenas como eles funcionam mas também as melhores práticas
+ deles. Incluimos uma sessão neste tutorial sobre isso porque implicits são tão
+ corriqueiros em bibliotecas do Scala que é impossível fazer qualqeuer coisa expressiva
+ sem utilizar uma biblioteca que usa implicits. Isto é para você entender e trabalhar
+ com implicits. Não declare seus próprios implicits por conta própria.
+*/
+
+// qualquer valor (val, function, objects, etc) pode ser declarado para ser implícito
+// usando a, você adivinhou, palavra chave "implicit". Usaremos a classe Dog definida
+// na sessão 5 para os próximos exemplos.
+implicit val myImplicitInt = 100
+implicit def myImplicitFunction(breed: String) = new Dog("Golden " + breed)
+
+// A palavra chave implicit não muda o comportamento do valor por si só, então
+// os valores acima podem ser usados como de costume.
+myImplicitInt + 2 // => 102
+myImplicitFunction("Pitbull").breed // => "Golden Pitbull"
+
+A diferença é que agora esses valores são elegíveis para serem usados quando outra
+// parte do código "precisa" de um valor implícito. Uma situação é uma função
+// com argumentos implícitos:
+def sendGreetings(toWhom: String)(implicit howMany: Int) =
+ s"Hello $toWhom, $howMany blessings to you and yours!"
+
+// Se fornecermos um valor para "howMany" a função se comporta como sempre
+sendGreetings("John")(1000) // => "Hello John, 1000 blessings to you and yours!"
+
+// Mas se omitirmos o parâmetro implícito um valor implícito de mesmo tipo é usado,
+// neste caso, "myImplicitInt":
+sendGreetings("Jane") // => "Hello Jane, 100 blessings to you and yours!"
+
+// Parâmetros implícitos de funções nos permitem simular type classes em outras
+//linguagens funcionais. As linhas abaixo são a mesma coisa:
+// def foo[T](implicit c: C[T]) = ...
+// def foo[T : C] = ...
+
+// Outro caso no qual o compilador procura por um implicit é quando você tem obj.method(...)
+// mas "obj" não possui "method" como um método. Neste caso, se houver uma conversão
+// de implicit do tipo A => B, onde A é o tipo do "obj" e B tem um método chamado
+// "method", a conversão é aplicada. Então, tendo myImplicitFunction acima em escopo, podemos dizer:
+"Retriever".breed // => "Golden Retriever"
+"Sheperd".bark // => "Woof, woof!"
+
+// Aqui, a String é convertida para Dog usando nossa função acima, então o método
+// apropriado é chamado. Isso é um recurso extremamente poderoso, mas de novo, não
+// é para ser usado de maneira leviana. Na verdade, quando você define a função
+// implícita, o seu compilador deve exibir um aviso de que você não deveria fazer isso,
+// a menos que você realmente saiba o que você está fazendo.
+
+/////////////////////////////////////////////////
+// 9. Misc
+/////////////////////////////////////////////////
+
+// Importando coisas
+import scala.collection.immutable.List
+
+// Importando todos os sub pacotes
+import scala.collection.immutable._
+
+// Importando várias classes em um único comando
+import scala.collection.immutable.{List, Map}
+
+// Renomeando um import usando '=>'
+import scala.collection.immutable.{List => ImmutableList}
+
+// Importa todas as classes, com exceção de algumas. O import abaixo importa todas as classes excluindo Map e Set:
+import scala.collection.immutable.{Map => _, Set => _, _}
+
+// Classes Java também podem ser importadas. A syntaxe de Scala pode ser usada:
+import java.swing.{JFrame, JWindow}
+
+// O ponto de entrada do seu programa é definido em um arquivo Scala usando um object com um único método main:
+object Application {
+ def main(args: Array[String]): Unit = {
+ // o código fica aqui
+ }
+}
+
+// Arquivos podem ter múltiplas classes e objects. Compile com scalac
+
+// Entrada e saída
+
+// Para ler um arquivo linha a linha
+import scala.io.Source
+for(line <- Source.fromFile("myfile.txt").getLines())
+ println(line)
+
+// Para escrever um arquivo use o PrintWriter do Javaval writer = new PrintWriter("myfile.txt")
+writer.write("Writing line for line" + util.Properties.lineSeparator)
+writer.write("Another line here" + util.Properties.lineSeparator)
+writer.close()
+
+## Recursos adicionais
+
+* [Scala for the impatient](http://horstmann.com/scala/)
+* [Twitter Scala school](http://twitter.github.io/scala_school/)
+* [Documentação de Scala](http://docs.scala-lang.org/)
+* [Tente Scala no seu navegador](http://scalatutorials.com/tour/)
+* Junte [Scala user group](https://groups.google.com/forum/#!forum/scala-user)
+```
diff --git a/pt-br/self-pt.html.markdown b/pt-br/self-pt.html.markdown
new file mode 100644
index 00000000..2fb2953b
--- /dev/null
+++ b/pt-br/self-pt.html.markdown
@@ -0,0 +1,165 @@
+---
+language: self
+contributors:
+ - ["Russell Allen", "http://github.com/russellallen"]
+translators:
+ - ["Ricardo de Almeida Gonzaga", "http://github.com/ricardotk"]
+lang: pt-br
+filename: learnself-br.self
+---
+
+Self é um protótipo rápido baseado em linguagem orientada a objeto a qual roda em sua própria JIT vm. A maior parte do desenvolvimento é feito através de interações com objetos ativos, através de um ambiente visual de desenvolvimento chamado *morphic* com navegador e depurador integrados.
+
+Tudo em Self é um objeto. Toda computação é feita através do envio de mensagens para objetos. Objetos em Self podem ser compreendidos como conjuntos de slots de chave-valor.
+
+# Construindo objetos
+
+O analisador interno de Self pode construir objetos, incluindo objetos método.
+
+```
+"Isto é um comentario"
+
+"A string:"
+'Isto é uma string com caracteres \'escapados\'.\n'
+
+"Um inteiro de 30 bits"
+23
+
+"Um float de 30 bits"
+3.2
+
+"-20"
+-14r16
+
+"Um objeto o qual entende apenas uma menssagem, 'x' que retorna 20"
+(|
+ x = 20.
+|)
+
+"Um objeto o qual tambem entende 'x', que atribui o slot x"
+(|
+ x <- 20.
+|)
+
+"Um objeto o qual entende o método 'doubleX' que
+dobra o valor de x e então retorna o objeto"
+(|
+ x <- 20.
+ doubleX = (x: x * 2. self)
+|)
+
+"Um objeto o qual entende todas as mensagens
+que 'traits point' entende". O analisador
+procura 'traits point' enviando as mensagens
+'traits' e 'point' para um objeto conhecido
+chamado de 'lobby'. Ele procura pelo objeto
+'true' também enviando a mensagem 'true'
+para o 'lobby'.""
+(| parent* = traits point.
+ x = 7.
+ y <- 5.
+ isNice = true.
+|)
+```
+
+# Enviando mensagens para objetos
+
+Mensagens podem ser unárias, binárias ou palavras-chave. Precedência é nesta ordem. Diferentemente de Smalltalk, a precedência de mensagens binárias precisam ser especificadas, e todas as palavras-chave após a primeira devem começar com letra maiúscula. Mensagens são separadas de seu destinatário através de espaço em branco.
+
+```
+"mensagem unária, envia 'printLine' para o objeto '23'
+o qual escreve a string '23' para stdout e retorna o objeto recebido (ie 23)"
+23 printLine
+
+"envia a mensagem '+' com '7' para '23', em seguida a mensagem '*' com '8' para o resultado"
+(23 + 7) * 8
+
+"envia 'power:' para '2' com '8' retorna 256"
+2 power: 8
+
+"envia 'keyOf:IfAbsent:' para 'hello' com argumentos 'e' e '-1'.
+Retorna 1, o índice de 'e' em 'hello'."
+'hello' keyOf: 'e' IfAbsent: -1
+```
+
+# Blocos
+
+Self define controle de fluxo assim como Smalltalk e Ruby por meio de blocos. Blocos são computações atrasadas da forma:
+
+```
+[|:x. localVar| x doSomething with: localVar]
+```
+
+Exemplos do uso de um bloco:
+
+```
+"retorna 'HELLO'"
+'hello' copyMutable mapBy: [|:c| c capitalize]
+
+"retorna 'Nah'"
+'hello' size > 5 ifTrue: ['Yay'] False: ['Nah']
+
+"retorna 'HaLLO'"
+'hello' copyMutable mapBy: [|:c|
+ c = 'e' ifTrue: [c capitalize]
+ False: ['a']]
+```
+
+Múltiplas expressões são separadas por ponto final. ^ retorna imediatamente.
+
+```
+"retorna An 'E'! How icky!"
+'hello' copyMutable mapBy: [|:c. tmp <- ''|
+ tmp: c capitalize.
+ tmp = 'E' ifTrue: [^ 'An \'E\'! How icky!'].
+ c capitalize
+ ]
+```
+
+Blocos são realizados (completados) ao enviá-los a mensagem 'value' e herdando (imcumbir a) seus contextos:
+```
+"retorna 0"
+[|x|
+ x: 15.
+ "Repetidamente envia 'value' para o primeiro bloco enquanto o resultado do
+ envio de 'value' para o segundo bloco é o objeto 'true'"
+ [x > 0] whileTrue: [x: x - 1].
+ x
+] value
+```
+
+# Métodos
+
+Métodos são como blocos, porém eles não estão dentro de um contexto, ao invés disto são armazenados como valores de slots. Diferentemente de Smalltalk, métodos por padrão retornam o seu valor final e não 'self'.
+
+```
+"Aqui está um objeto com um slot atribuível 'x' e um método 'reduceXTo: y'.
+Enviar a mensagem 'reduceXTo: 10' para este objeto colocará
+o objeto '10' no slot 'x' e retornará o objeto original"
+(|
+ x <- 50.
+ reduceXTo: y = (
+ [x > y] whileTrue: [x: x - 1].
+ self)
+|)
+.
+```
+
+# Protótipos
+
+Não existem classes em Self. A maneira de obter um objeto é encontrar um protótipo e copia-lo.
+
+```
+| d |
+d: dictionary copy.
+d at: 'hello' Put: 23 + 8.
+d at: 'goodbye' Put: 'No!.
+"Imprime No!"
+( d at: 'goodbye' IfAbsent: 'Yes! ) printLine.
+"Imprime 31"
+( d at: 'hello' IfAbsent: -1 ) printLine.
+```
+
+# Informações adicionais
+
+O [Manual do Self](http://handbook.selflanguage.org) tem muito mais informações, e nada melhor do que por a mão na massa com Self através de sua [homepage](http://www.selflanguage.org).
diff --git a/pt-br/swift-pt.html.markdown b/pt-br/swift-pt.html.markdown
index e840b8cf..4ad67a06 100644
--- a/pt-br/swift-pt.html.markdown
+++ b/pt-br/swift-pt.html.markdown
@@ -353,7 +353,7 @@ internal class Rect: Shape {
func shrink() {
if sideLength > 0 {
- --sideLength
+ sideLength -= 1
}
}
diff --git a/pt-br/tmux-pt.html.markdown b/pt-br/tmux-pt.html.markdown
index 9d5bf292..ce3be407 100644
--- a/pt-br/tmux-pt.html.markdown
+++ b/pt-br/tmux-pt.html.markdown
@@ -9,11 +9,9 @@ lang: pt-br
filename: LearnTmux-pt.txt
---
-O [tmux](http://tmux.sourceforge.net)
-é um multiplexador de terminal, ele permite que terminais sejam criados,
-acessados e controlados a partir de uma unica instância. tmux pode ser separado
-de uma tela e continuar rodando no plano de fundo e depois ser reacoplado à
-instância (ou tela original).
+O [tmux](http://tmux.sourceforge.net) é um multiplexador de terminal,
+ele permite criar vários terminais e gerenciar tudo na mesma interface.
+tmux pode também rodar em background e depois ser recuperado(exibido) novamente.
```
@@ -25,9 +23,9 @@ instância (ou tela original).
-n "Janela" # Cria uma janela com o nome "Janela"
-c "/dir" # Inícia em uma pasta específica
- attach # Reacopla a última seção disponível
- -t "#" # Reacopla a seção com nome "#"
- -d # Separa (Desacopla) a sessaão de outras instâncias.
+ attach # Acopla a última seção disponível
+ -t "#" # Acopla a seção com nome "#"
+ -d # Separa (Desacopla) a seção de outras instâncias.
ls # Lista todas as seções
-a # Lista todas as seções abertas
@@ -39,56 +37,54 @@ instância (ou tela original).
lsp # Lista os painéis
-a # Lista todos os painéis
-s # Lista todos os painéis em uma seção
- -t "#" # Lista os painéis baseado no nome "#"
+ -t "#" # Lista os painéis chamados "#"
- kill-window # Encerrar a janela corrente
- -t "#" # Encerrar a janela baseado no nome "#"
+ kill-window # Encerrar a janela atual
+ -t "#" # Encerrar a janela chamada "#"
-a # Encerrar todas as janelas
- -a -t "#" # Encerrar todas as janelas exceto a com nome "#"
+ -a -t "#" # Encerrar todas as janelas exceto a "#"
- kill-session # Encerrar seção corrente
+ kill-session # Encerrar seção atual
-t "#" # Encerrar seção com nome "#"
-a # Encerrar todas as seções
- -a -t "#" # Encerrar todas as seções exceto a com nome "#"
+ -a -t "#" # Encerrar todas as seções exceto a "#"
```
-
### Teclas de atalhos (comandos)
-A maneira de controllar uma seção tmux acoplada é através de uma
-combinação de teclas de prefixo.
+As seções tmux acopladas são controladas através de teclas de atalho. (prefix key)
```
----------------------------------------------------------------------
- (C-b) = Ctrl + b # Combinação de prefixos para usar comandos(atalhos).
+ (C-b) = Ctrl + b # Abre a opção de receber comandos(atalhos).
(M-1) = Meta + 1 -or- Alt + 1
----------------------------------------------------------------------
? # Lista todos os comandos.
- : # Acessa o lugar (prompt command) para receber comandos do tmux
- r # Força a redefiniçao do cliente acoplado.
+ : # Acessa o prompt command do tmux
+ r # Força a reinicialização do cliente acoplado.
c # Cria uma nova janela.
- ! # Retira o painel corrente da janela.
- % # Divide o painel corrente em dois para a esquerda e direita.
- " # Divide o painel corrente em dois para cima e para baixo.
+ ! # Retira o painel atual da janela.
+ % # Divide o painel atual em dois. Esquerda e direita.
+ " # Divide o painel atual em dois. Para cima e para baixo.
- n # Move para a próxima janela.
- p # Move para a janela anterior.
- { # Troca o painel corrente pelo anterior.
+ n # Muda para a próxima janela.
+ p # Muda para a janela anterior.
+ { # Troca o painel atual pelo anterior.
} # Troca o painel corrent pelo posterior.
s # Seleciona uma nova seção para o cliente acoplado iterativamente.
- w # Seleciona a janela corrente iterativamente.
+ w # Seleciona a janela atual iterativamente.
0 to 9 # Seleciona a janela de 0 à 9.
d # Separa o cliente atual.
D # Seleciona um cliente a ser separado.
- & # Encerra a janela corrente.
- x # Encerra o painel corrente.
+ & # Encerra a janela atual.
+ x # Encerra o painel atual.
Up, Down # Move para o painel acima, abaixo, a esquerda ou a direita.
Left, Right
@@ -100,10 +96,10 @@ combinação de teclas de prefixo.
# 4) Principal verticamente.
# 5) Mosaico
- C-Up, C-Down # Altera o tamanho do painel corrente baseado em uma célula.
+ C-Up, C-Down # Altera o tamanho do painel atual em uma célula.
C-Left, C-Right
- M-Up, M-Down # Altera o tamanho do painel corrente baseado em cinco células.
+ M-Up, M-Down # Altera o tamanho do painel atual em cinco células.
M-Left, M-Right
```
@@ -116,17 +112,13 @@ Existe um arquivo chamado tmux.conf, ele pode ser usado para definir opções no
```
-# Exemplo de tmux.conf
-# 2014.10
+# Exemplo tmux.conf
+# 2015.12
### General
###########################################################################
-# Habilita UTF-8
-setw -g utf8 on
-set-option -g status-utf8 on
-
# Limite da história de comandos
set -g history-limit 2048
@@ -134,14 +126,14 @@ set -g history-limit 2048
set -g base-index 1
# Mouse
-set-option -g mouse-select-pane on
+set-option -g -q mouse on
# Recarregar o arquivo de configuração sem a necessidade de reiniciar o programa
unbind r
bind r source-file ~/.tmux.conf
-### Teclas de atalho
+### Keybinds / Comandos
###########################################################################
# Desvincular C-b como prefixo padrão.
@@ -150,7 +142,7 @@ unbind C-b
# Define um novo prefixo padrão.
set-option -g prefix `
-# Definir prefixos que podem ser usados para voltar para a janela anterior.
+# Voltar janela anterior quando comando for usado duas vezes.
bind C-a last-window
bind ` last-window
@@ -158,11 +150,11 @@ bind ` last-window
bind F11 set-option -g prefix C-a
bind F12 set-option -g prefix `
-# Preferencia de teclas de atalho
+# Preferencia de comandos
setw -g mode-keys vi
set-option -g status-keys vi
-# Mover enter paineis com teclas de orientaçao do vim
+# Alternar enter painéis com teclas de orientaçao do vim
bind h select-pane -L
bind j select-pane -D
bind k select-pane -U
@@ -174,7 +166,7 @@ bind f next-window
bind E swap-window -t -1
bind F swap-window -t +1
-# Iterar entre os painéis
+# Dividir painéis
bind = split-window -h
bind - split-window -v
unbind '"'
@@ -184,7 +176,7 @@ unbind %
bind a send-prefix
-### Theme
+### Theme // Estilo
###########################################################################
# Paleta de cores para a barra de status
@@ -209,8 +201,6 @@ setw -g window-status-bg black
setw -g window-status-current-fg green
setw -g window-status-bell-attr default
setw -g window-status-bell-fg red
-setw -g window-status-content-attr default
-setw -g window-status-content-fg yellow
setw -g window-status-activity-attr default
setw -g window-status-activity-fg yellow
diff --git a/pt-br/typescript-pt.html.markdown b/pt-br/typescript-pt.html.markdown
new file mode 100644
index 00000000..f072b257
--- /dev/null
+++ b/pt-br/typescript-pt.html.markdown
@@ -0,0 +1,179 @@
+---
+language: TypeScript
+filename: learntypescript-pt.ts
+contributors:
+ - ["Philippe Vlérick", "https://github.com/pvlerick"]
+translators:
+ - ["Gabriel Gomes", "https://github.com/gabrielgomesferraz"]
+lang: pt-br
+---
+
+TypeScript is a language that aims at easing development of large scale applications written in JavaScript.
+TypeScript adds common concepts such as classes, modules, interfaces, generics and (optional) static typing to JavaScript.
+It is a superset of JavaScript: all JavaScript code is valid TypeScript code so it can be added seamlessly to any project. The TypeScript compiler emits JavaScript.
+
+This article will focus only on TypeScript extra syntax, as opposed to [JavaScript] (../javascript/).
+
+
+Typescript é uma linguagem que visa facilitar o desenvolvimento de aplicações em grande escala escritos em JavaScript.
+Typescript acrescenta conceitos comuns como classes, módulos, interfaces, genéricos e (opcional) tipagem estática para JavaScript.
+É um super conjunto de JavaScript: todo o código JavaScript é o código do texto dactilografado válido para que possa ser adicionados diretamente a qualquer projeto. O compilador emite typescript JavaScript.
+
+Este artigo irá se concentrar apenas em texto datilografado sintaxe extra, ao contrário de [JavaScript](javascript-pt.html.markdown).
+
+Para testar compilador do texto datilografado, de cabeça para o [Parque](http://www.typescriptlang.org/Playground), onde você vai ser capaz de escrever código, ter auto conclusão e ver diretamente o JavaScript emitida.
+
+```js
+// Existem 3 tipos básicos no TypeScript
+var isDone: boolean = false;
+var lines: number = 42;
+var name: string = "Anders";
+
+// Quando é impossível saber, há o "Qualquer" tipo
+var notSure: any = 4;
+notSure = "maybe a string instead";
+notSure = false; // Ok, definitivamente um boolean
+
+// Para coleções, não são matrizes e matrizes genéricas digitado
+var list: number[] = [1, 2, 3];
+// Como alternativa, usando o tipo de matriz genérica
+var list: Array<number> = [1, 2, 3];
+
+// Para enumerações:
+enum Color {Red, Green, Blue};
+var c: Color = Color.Green;
+
+// Por último, "vazio" é utilizado no caso especial de uma função que não retorna nada
+function bigHorribleAlert(): void {
+ alert("I'm a little annoying box!");
+}
+
+// Funções são cidadãos de primeira classe, apoiar a sintaxe lambda "seta gordura" e
+// Tipo de uso inferência
+
+// A seguir são equivalentes, a mesma assinatura será inferido pelo
+// Compilador, e mesmo JavaScript será emitido
+var f1 = function(i: number): number { return i * i; }
+// Tipo de retorno inferida
+var f2 = function(i: number) { return i * i; }
+var f3 = (i: number): number => { return i * i; }
+// Tipo de retorno inferida
+var f4 = (i: number) => { return i * i; }
+// Tipo de retorno inferido, one-liner significa nenhuma palavra-chave retorno necessário
+var f5 = (i: number) => i * i;
+
+// Interfaces são estruturais, qualquer coisa que tenha as propriedades é compatível com
+// A interface
+interface Person {
+ name: string;
+ // Propriedades opcionais, marcado com um "?"
+ age?: number;
+ // E de funções curso
+ move(): void;
+}
+
+// Objeto que implementa a "Pessoa" Interface
+// Pode ser tratado como uma pessoa desde que tem o nome e mover propriedades
+var p: Person = { name: "Bobby", move: () => {} };
+// Os objetos que têm a propriedade opcional:
+var validPerson: Person = { name: "Bobby", age: 42, move: () => {} };
+// Não é uma pessoa porque a idade não é um número
+var invalidPerson: Person = { name: "Bobby", age: true };
+
+// Interfaces também pode descrever um tipo de função
+interface SearchFunc {
+ (source: string, subString: string): boolean;
+}
+// Somente tipos dos parâmetros são importantes, os nomes não são importantes.
+var mySearch: SearchFunc;
+mySearch = function(src: string, sub: string) {
+ return src.search(sub) != -1;
+}
+
+// Classes - membros são públicos por padrão
+class Point {
+ // Propriedades
+ x: number;
+
+ // Construtor - the public/private keywords in this context will generate
+ // o código clichê para a propriedade e a inicialização no
+ // construtor.
+ // Neste exemplo, "y" será definida como "X" é, mas com menos código
+ // Os valores padrão também são suportados.
+
+ constructor(x: number, public y: number = 0) {
+ this.x = x;
+ }
+
+ // Funções
+ dist() { return Math.sqrt(this.x * this.x + this.y * this.y); }
+
+ // Membros Estáticos
+ static origin = new Point(0, 0);
+}
+
+var p1 = new Point(10 ,20);
+var p2 = new Point(25); //y será 0
+
+// Herança
+class Point3D extends Point {
+ constructor(x: number, y: number, public z: number = 0) {
+ super(x, y); // Chamada explícita para o construtor da super classe é obrigatória
+ }
+
+ // Sobrescrever
+ dist() {
+ var d = super.dist();
+ return Math.sqrt(d * d + this.z * this.z);
+ }
+}
+
+// Módulos, "." pode ser utilizado como separador de sub módulos
+module Geometry {
+ export class Square {
+ constructor(public sideLength: number = 0) {
+ }
+ area() {
+ return Math.pow(this.sideLength, 2);
+ }
+ }
+}
+
+var s1 = new Geometry.Square(5);
+
+// Alias no local para fazer referência a um módulo
+import G = Geometry;
+
+var s2 = new G.Square(10);
+
+// Genericos
+// Classes
+class Tuple<T1, T2> {
+ constructor(public item1: T1, public item2: T2) {
+ }
+}
+
+// Interfaces
+interface Pair<T> {
+ item1: T;
+ item2: T;
+}
+
+// e funções
+var pairToTuple = function<T>(p: Pair<T>) {
+ return new Tuple(p.item1, p.item2);
+};
+
+var tuple = pairToTuple({ item1:"hello", item2:"world"});
+
+// Incluindo referências a um arquivo de definição:
+/// <reference path="jquery.d.ts" />
+
+```
+
+## Leitura adicional
+ * [TypeScript site oficial](http://www.typescriptlang.org/)
+ * [TypeScript especificações de idioma (pdf)](http://go.microsoft.com/fwlink/?LinkId=267238)
+ * [Anders Hejlsberg - Apresentando texto datilografado no Canal 9](http://channel9.msdn.com/posts/Anders-Hejlsberg-Introducing-TypeScript)
+ * [Código fonte no GitHub](https://github.com/Microsoft/TypeScript)
+ * [Definitivamente datilografado - repositório de definições de tipo](http://definitelytyped.org/)
diff --git a/pt-br/vim-pt.html.markdown b/pt-br/vim-pt.html.markdown
new file mode 100644
index 00000000..51eddb48
--- /dev/null
+++ b/pt-br/vim-pt.html.markdown
@@ -0,0 +1,239 @@
+---
+category: tool
+tool: vim
+contributors:
+ - ["RadhikaG", "https://github.com/RadhikaG"]
+translators:
+ - ["David Lima", "https://github.com/davelima"]
+lang: pt-br
+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
+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
+
+```
+ vim <nome-do-arquivo> # Abre <nome-do-arquivo> no vim
+ :q # Fecha o vim
+ :w # Salva o arquivo atual
+ :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)
+
+ u # Desfazer
+ CTRL+R # Refazer
+
+ h # Move o cursor para a esquerda
+ j # Move o cursor para baixo
+ k # Move o cursor para cima
+ l # Move o cursor para a direita
+
+ # Movendo o cursor dentro da linha
+
+ 0 # Move para o início da linha
+ $ # Move para o final da linha
+ ^ # Move para o primeiro caractere da linha (ignora caracteres em branco)
+
+ # Pesquisa no texto
+
+ /palavra # Destaca todas as ocorrências de 'palavra' após o cursor
+ ?palavra # Destaca todas as ocorrências de 'palavra' antes do cursor
+ n # Move o cursor para a próxima ocorrência após a pesquisa
+ N # Move o cursor para a ocorrência anterior após a pesquisa
+
+ :%s/foo/bar/g # Substitui 'foo' por 'bar' no arquivo inteiro
+ :s/foo/bar/g # Substitui 'foo' por 'bar' na linha atual
+
+ # Pulando para caracteres específicos
+
+ f<caracter> # Posiciona o cursor no próximo <caracter>
+ t<character> # Posiciona o cursor antes do próximo <caracter>
+
+ # Por exemplo,
+ f< # Posiciona o cursor no <
+ t< # Posiciona o cursor logo antes do <
+
+ # Movendo por palavras
+
+ w # Move o cursor uma palavra a diante
+ b # Move o cursor uma palavra atrás
+ e # Move o cursor ao fim da palavra atual
+
+ # Outros caracteres para mover o cursor no arquivo
+
+ gg # Move para o topo do arquivo
+ G # Move para o final do arquivo
+ :NUM # Move para a linha NUM (NUM é qualquer número)
+ H # Move para o topo da tela visível
+ M # Move para o meio da tela visível
+ L # Move para o final da tela visível
+```
+
+## Modos:
+
+O Vim é baseado no conceito de **modos**.
+
+Modo Comando - usado para navegar e escrever comandos - o Vim já inicia nesse modo
+Modo Inserção - usado para fazer alterações no arquivo
+Modo Visual - usado para destacar textos e executar comandos neles
+Modo Ex - usado para ir a linha com ':' no final da tela para executar comandos
+
+```
+ i # Coloca o Vim no Modo Inserção, logo antes do cursor
+ a # Coloca o Vim no Modo Inserção, logo após o cursor
+ v # Coloca o Vim no Modo Visual
+ : # Coloca o Vim no Modo Ex
+ <esc> # Sai de qualquer modo que você estiver, e coloca o Vim no Modo Comando
+
+ # Copiando e colando texto
+
+ y # Coloca a seleção atual na área de transferência
+ yy # Coloca a linha atual na área de transferência
+ d # Deleta a seleção tual
+ dd # Deleta a linha atual
+ p # Cola o texto copiado após a posição do cursor
+ P # Cola o texto copiado antes da posição do cursor
+ x # Deleta o caractere que está na posição do cursor
+```
+
+## A 'Gramática' do Vim
+
+Podemos pensar no Vim como uma série de comendos
+em um formato 'Verbo-Modificador-Nome', onde:
+
+Verbo - sua ação
+Modificador - como você executará sua ação
+Nome - o objeto onde você vai executar sua acão
+
+Alguns exemplos importantes de 'Verbos', 'Modificadores' e 'Nomes':
+
+```
+ # 'Verbos'
+
+ d # Apagar (Delete)
+ c # Alterar (Change)
+ y # Copiar (Yank)
+ v # Seleção Visual
+
+ # 'Modificadores'
+
+ i # Dentro (Inside)
+ a # Em torno de (Around)
+ NUM # Número (NUM qualquer número)
+ f # Pesquisa algo e posiciona o cursor acima do resultado
+ t # Pesquisa algo e posiciona o cursor logo antes do resultado
+ / # Encontra algo a frente do cursor
+ ? # Encontra algo antes do cursor
+
+ # 'Nomes'
+
+ w # Palavra (word)
+ s # Sentência
+ p # Parágrafo
+ b # Bloco
+
+ # Exemplos de comandos
+
+ d2w # Apaga 2 palavras
+ cis # Altera dentro de uma sentência
+ yip # Coloca o parágrafo atual da área de transferência)
+ ct< # Altera para '<'
+ # Altera todo o texto a partir da posição do cursor até o próximo '<'
+ d$ # Apaga tudo da posição do cursor até o final da linha
+```
+
+## Alguns atalhos e dicas
+
+ <!--TODO: Adicionar mais!-->
+```
+ > # Adiciona um bloco de indentação
+ < # Remove um bloco de indentação
+ :earlier 15m # Reverte o documento para como ele estava há 15 minutos atrás
+ :later 15m # Reverte o comando acima
+ ddp # Troca linhas consecutivas de posição, dd e depois p
+ . # Repete a última ação
+```
+
+## Macros
+
+Macros, basicamente, são ações graváveis.
+Quando você começa a gravar uma macro, ele salva **toda** ação e comando
+que você usar, até que você pare de gravar. Ao executar uma macro, ele aplica
+exatamente a mesma sequencia de ações e comandos na seleção atual.
+
+```
+ qa # Inicia a gravação de uma macro chamado 'a'
+ q # Para a gravação
+ @a # Executa a macro
+```
+
+### Configurando o ~/.vimrc
+
+O arquivo .vimrc pode ser usado para configurar o Vim no seu início.
+
+Exemplo de arquivo ~/.vimrc
+
+```
+" Exemplo de ~/.vimrc
+" 2015.10
+
+" Obrigatório para rodar apenas no Vim (Vi Improved)
+set nocompatible
+
+" Determina o tipo de arquivo pelo nome para habilitar indentação automática, etc
+filetype indent plugin on
+
+" Habilita sintaxe colorida
+syntax on
+
+" Ativa um 'auto-completar' melhor para a linha de comando
+set wildmenu
+
+" Faz as buscas não diferenciarem maiúsculas-minúsculas (case insensitive)
+" Exceto quando você usar letras maiúsculas
+set ignorecase
+set smartcase
+
+" Quando criar uma nova linha e a indentação por tipo de arquivo estiver
+" desabilitada, mantem a mesma indentação da linha atual
+set autoindent
+
+" Mostra o número das linhas à esquerda
+set number
+
+" Opções de indentação, aqui você pode mudar como preferir
+
+" Número de espaços visíveis por TAB
+set tabstop=4
+
+" Número de espaços por TAB ao editar um arquivo
+set softtabstop=4
+
+" Número de espaços usados nas funções de indentação (>> e <<)
+set shiftwidth=4
+
+" Converte TABs em espaços
+set expandtab
+
+" Habilita indentação/alinhamento inteligente
+set smarttab
+```
+
+### Referências
+
+[Vim | Home](http://www.vim.org/index.php) (EN)
+
+`$ vimtutor pt`
+
+[Vim: um tutorial/cartilha](https://danielmiessler.com/study/vim/) (EN)
+
+[O que são as partes sombrias do Vim que sua mãe nunca te explicou? (tópico no Stack Overflow)](http://stackoverflow.com/questions/726894/what-are-the-dark-corners-of-vim-your-mom-never-told-you-about) (EN)
+
+[Arch Linux Wiki](https://wiki.archlinux.org/index.php/Vim) (EN)
diff --git a/pt-br/yaml-pt.html.markdown b/pt-br/yaml-pt.html.markdown
new file mode 100644
index 00000000..341ae675
--- /dev/null
+++ b/pt-br/yaml-pt.html.markdown
@@ -0,0 +1,142 @@
+---
+language: yaml
+contributors:
+ - ["Adam Brenecki", "https://github.com/adambrenecki"]
+translators:
+ - ["Rodrigo Russo", "https://github.com/rodrigozrusso"]
+filename: learnyaml-pt.yaml
+lang: pt-br
+---
+
+YAML é uma linguagem de serialização de dados projetado para ser diretamente gravável e
+legível por seres humanos.
+
+É um estrito subconjunto de JSON, com a adição de sintaticamente
+novas linhas e recuo significativos, como Python. Ao contrário de Python, no entanto,
+YAML não permite caracteres de tabulação literais em tudo.
+
+```yaml
+# Commentários em YAML são como este.
+
+###################
+# TIPOS ESCALARES #
+###################
+
+# Nosso objeto raiz (que continua por todo o documento) será um mapa,
+# o que equivale a um dicionário, hash ou objeto em outras linguagens.
+chave: valor
+outra_chave: Outro valor vai aqui.
+u_valor_numerico: 100
+notacao_cientifica: 1e+12
+boleano: true
+valor_nulo: null
+chave com espaco: valor
+# Observe que strings não precisam de aspas. Porém, elas podem ter.
+porem: "Uma string, entre aspas."
+"Chaves podem estar entre aspas tambem.": "É útil se você quiser colocar um ':' na sua chave."
+
+# Seqüências de várias linhas podem ser escritos como um 'bloco literal' (utilizando |),
+# ou em um 'bloco compacto' (utilizando '>').
+bloco_literal: |
+ Todo esse bloco de texto será o valor da chave 'bloco_literal',
+ preservando a quebra de com linhas.
+
+ O literal continua até de-dented, e a primeira identação é
+ removida.
+
+ Quaisquer linhas que são 'mais identadas' mantém o resto de suas identações -
+ estas linhas serão identadas com 4 espaços.
+estilo_compacto: >
+ Todo esse bloco de texto será o valor de 'estilo_compacto', mas esta
+ vez, todas as novas linhas serão substituídas com espaço simples.
+
+ Linhas em branco, como acima, são convertidas em um carater de nova linha.
+
+ Linhas 'mais-indentadas' mantém suas novas linhas também -
+ este texto irá aparecer em duas linhas.
+
+####################
+# TIPOS DE COLEÇÃO #
+####################
+
+# Texto aninhado é conseguido através de identação.
+um_mapa_aninhado:
+ chave: valor
+ outra_chave: Outro valor
+ outro_mapa_aninhado:
+ ola: ola
+
+# Mapas não tem que ter chaves com string.
+0.25: uma chave com valor flutuante
+
+# As chaves podem ser também objetos multi linhas, utilizando ? para indicar o começo de uma chave.
+? |
+ Esta é uma chave
+ que tem várias linhas
+: e este é o seu valor
+
+# também permite tipos de coleção de chaves, mas muitas linguagens de programação
+# vão reclamar.
+
+# Sequências (equivalente a listas ou arrays) semelhante à isso:
+uma_sequencia:
+ - Item 1
+ - Item 2
+ - 0.5 # sequencias podem conter tipos diferentes.
+ - Item 4
+ - chave: valor
+ outra_chave: outro_valor
+ -
+ - Esta é uma sequencia
+ - dentro de outra sequencia
+
+# Como YAML é um super conjunto de JSON, você também pode escrever mapas JSON de estilo e
+# sequencias:
+mapa_json: {"chave": "valor"}
+json_seq: [3, 2, 1, "decolar"]
+
+##########################
+# RECURSOS EXTRA DO YAML #
+##########################
+
+# YAML também tem um recurso útil chamado "âncoras", que permitem que você facilmente duplique
+# conteúdo em seu documento. Ambas estas chaves terão o mesmo valor:
+conteudo_ancora: & nome_ancora Essa string irá aparecer como o valor de duas chaves.
+outra_ancora: * nome_ancora
+
+# YAML também tem tags, que você pode usar para declarar explicitamente os tipos.
+string_explicita: !! str 0,5
+# Alguns analisadores implementam tags específicas de linguagem, como este para Python de
+# Tipo de número complexo.
+numero_complexo_em_python: !! python / complex 1 + 2j
+
+####################
+# YAML TIPOS EXTRA #
+####################
+
+# Strings e números não são os únicos que escalares YAML pode entender.
+# Data e 'data e hora' literais no formato ISO também são analisados.
+datetime: 2001-12-15T02: 59: 43.1Z
+datetime_com_espacos 2001/12/14: 21: 59: 43.10 -5
+Data: 2002/12/14
+
+# A tag !!binary indica que a string é na verdade um base64-encoded (condificado)
+# representação de um blob binário.
+gif_file: !!binary |
+ R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5
+ OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+
+ +f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC
+ AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs=
+
+# YAML também tem um tipo de conjunto, o que se parece com isso:
+set:
+ ? item1
+ ? item2
+ ? item3
+
+# Como Python, são apenas conjuntos de mapas com valors nulos; o acima é equivalente a:
+set2:
+ item1: nulo
+ item2: nulo
+ item3: nulo
+```