6 files changed, 445 insertions, 10 deletions
diff --git a/pt-br/go-pt.html.markdown b/pt-br/go-pt.html.markdown
index 32c8fbdd..c7339831 100644
--- a/pt-br/go-pt.html.markdown
+++ b/pt-br/go-pt.html.markdown
@@ -75,7 +75,7 @@ func learnTypes() {
 pode incluir quebras de linha.` // mesmo tipo string
 
     // literal não-ASCII. A linguagem Go utiliza de raiz a codificação UTF-8.
-    g := 'Σ' // tipo rune, um alias para uint32, que contém um código unicode
+    g := 'Σ' // tipo rune, um alias para int32, que contém um código unicode
 
     f := 3.14195 // float64, número de vírgula flutuante de 64bit (IEEE-754)
     c := 3 + 4i  // complex128, representado internamente com dois float64s
diff --git a/pt-br/groovy-pt.html.markdown b/pt-br/groovy-pt.html.markdown
new file mode 100644
index 00000000..885d5b27
--- /dev/null
+++ b/pt-br/groovy-pt.html.markdown
@@ -0,0 +1,435 @@
+---
+language: Groovy
+category: language
+filename: learngroovy.groovy
+contributors:
+    - ["Roberto Pérez Alcolea", "http://github.com/rpalcolea"]
+translators:
+    - ["João Farias", "https://github.com/JoaoGFarias"]
+lang: pt-br
+---
+
+Groovy - Uma linguagem dinâmica para a plataforma Java. [Leia mais aqui.](http://groovy.codehaus.org)
+
+```groovy
+
+/*
+  Prepara-se:
+
+  1) Instale a máquina virtual de Groovy - http://gvmtool.net/
+  2) Intalse o Groovy: gvm install groovy
+  3) Inicie o console groovy digitando: groovyConsole
+
+*/
+
+// Comentário de uma linha inicia-se com duas barras
+/*
+Comentário de múltiplas linhas são assim.
+*/
+
+// Olá Mundo!
+println "Olá mundo!"
+
+/*
+  Variáveis:
+
+  Você pode atribuir valores a variáveis para uso posterior
+*/
+
+def x = 1
+println x
+
+x = new java.util.Date()
+println x
+
+x = -3.1499392
+println x
+
+x = false
+println x
+
+x = "Groovy!"
+println x
+
+/*
+  Coleções e mapeamentos
+*/
+
+//Criando uma lista vazia
+def tecnologias = []
+
+/*** Adicionando elementos à lista ***/
+
+// Assim como Java
+tecnologias.add("Grails")
+
+// Shift para esquerda adiciona e retorna a lista
+tecnologias << "Groovy"
+
+// Adição de múltiplos elementos
+tecnologias.addAll(["Gradle","Griffon"])
+
+/*** Removendo elementos da lista ***/
+
+// Assim como Java
+tecnologias.remove("Griffon")
+
+// Subtração também funciona
+tecnologias = technologies - 'Grails'
+
+/*** Iterando sobre listas ***/
+
+// Itera sobre os elementos da lista
+tecnologias.each { println "Tecnologias: $it"}
+tecnologias.eachWithIndex { it, i -> println "$i: $it"}
+
+/*** Checando os elementos da lista ***/
+
+//Avalia se a lista contém o elemento 'Groovy'
+contem = tecnologias.contains( 'Groovy' )
+
+// Ou
+contem = 'Groovy' in tecnologias
+
+// Checagem por múltiplos elementos
+tecnologias.containsAll(['Groovy','Grails'])
+
+/*** Ordenando listas ***/
+
+// Ordena a lista (altera a lista in-place)
+tecnologias.sort()
+
+// Para ordenar a lista sem alterar a original
+tecnologiasOrdenadas = tecnologias.sort( false )
+
+/*** Manipulando listas ***/
+
+//Substitue todos os elementos da lista
+Collections.replaceAll(tecnologias, 'Gradle', 'gradle')
+
+//Desorganiza a lista
+Collections.shuffle(tecnologias, new Random())
+
+//Limpa a lista
+technologies.clear()
+
+//Criando um mapeamento vazio
+def devMap = [:]
+
+//Adicionando valores
+devMap = ['nome':'Roberto', 'framework':'Grails', 'linguagem':'Groovy']
+devMap.put('ultimoNome','Perez')
+
+//Iterando sobre os elementos do mapeamento
+devMap.each { println "$it.key: $it.value" }
+devMap.eachWithIndex { it, i -> println "$i: $it"}
+
+//Avalia se um mapeamento contém uma chave
+assert devMap.containsKey('nome')
+
+//Avalia se um mapeamento contém um valor
+assert devMap.containsValue('Roberto')
+
+//Pega as chaves de um mapeamento
+println devMap.keySet()
+
+//Pega os valores de um mapeamento
+println devMap.values()
+
+/*
+  Groovy Beans
+
+  GroovyBeans são JavaBeans com uma sintaxe muito mais simples.
+
+  Quando Groovy é compilado para bytecode, as seguintes regras são usadas:
+
+    * Se o nome é declarado com um modificador de acesso(public, private or
+      protected) então um atributo é gerado.
+
+    * Um nome declarado sem modificador de acesso gera um campo privado com
+      getter e setter públicos (ou seja, uma propriedade).
+
+    * Se uma propriedade é declarada como final, um campo private final é criado
+      e o setter não é gerado.
+
+    * Você pode declarar uma propriedade e também declarar seus próprios getters
+      e setters.
+
+    * Você pode declarar uma propriedade e um campo com o mesmo nome, a propriedade
+      usará este campo.
+
+    * Se você quer uma propriedade private ou protected, você deve prover seus
+      próprios getters e setter, que devem ser declarados como private ou protected.
+
+    * Se você acessar uma propriedade dentro da classe e esta propriedade é definida
+      em tempo de compilação com 'this', implícito ou explícito (por exemplo,
+      this.foo, ou simplesmente foo), Groovy acessará este campo diretamente, sem
+      passar pelo getter ou setter.
+
+    * Se você acessar uma propriedade que não existe usando foo, explicitamente ou
+      implicitamente, então Groovy irá acessar esta propriedade através da meta
+      classe, o que pode falhar em tempo de execução.
+
+*/
+
+class Foo {
+    // propriedade de leitura, apenas
+    final String nome = "Roberto"
+
+    // propriedade de leitura, apenas, com getter e setter públicos
+    String linguagem
+    protected void setLinguagem(String linguagem) { this.linguagem = linguagem }
+
+    // propriedade tipada dinamicamente
+    def ultimoNome
+}
+
+/*
+  Condicionais e loops
+*/
+
+//Groovy suporta a sintaxe if-else
+def x = 3
+
+if(x==1) {
+    println "Um"
+} else if(x==2) {
+    println "Dois"
+} else {
+    println "X é maior que Dois"
+}
+
+//Groovy também suporta o operador ternário
+def y = 10
+def x = (y > 1) ? "functionou" : "falhou"
+assert x == "functionou"
+
+//Loop 'for'
+//Itera sobre um intervalo (range)
+def x = 0
+for (i in 0 .. 30) {
+    x += i
+}
+
+//Itera sobre uma lista
+x = 0
+for( i in [5,3,2,1] ) {
+    x += i
+}
+
+//Itera sobre um array
+array = (0..20).toArray()
+x = 0
+for (i in array) {
+    x += i
+}
+
+//Itera sobre um mapa
+def map = ['name':'Roberto', 'framework':'Grails', 'language':'Groovy']
+x = 0
+for ( e in map ) {
+    x += e.value
+}
+
+/*
+  Operadores
+
+  Sobrecarregamento de Operadores para uma lsita dos operadores comuns que
+  Grooby suporta:
+  http://groovy.codehaus.org/Operator+Overloading
+
+  Operadores Groovy úteis
+*/
+//Operador de espalhamento: invoca uma ação sobre todos os itens de um
+//objeto agregador.
+def tecnologias = ['Groovy','Grails','Gradle']
+tecnologias*.toUpperCase() // = to tecnologias.collect { it?.toUpperCase() }
+
+//Operador de navegação segura: usado para evitar NullPointerException.
+def usuario = User.get(1)
+def nomeUsuario = usuario?.nomeUsuario
+
+
+/*
+  Closures
+  Um closure, em Grooby, é como um "bloco de código" ou um ponteiro para método.
+  É um pedação de código que é definido e executado em um momento posterior.
+
+  Mais informação em: http://groovy.codehaus.org/Closures+-+Formal+Definition
+*/
+//Exemplo:
+def clos = { println "Hello World!" }
+
+println "Executando o closure:"
+clos()
+
+//Passando parêmetros para um closure
+def soma = { a, b -> println a+b }
+soma(2,4)
+
+//Closdures por referir-se a variáveis que não estão listadas em sua
+//lista de parêmetros.
+def x = 5
+def multiplicarPor = { num -> num * x }
+println multiplicarPor(10)
+
+// Se você tiver um closure que tem apenas um argumento, você pode omitir
+// o parâmetro na definição do closure
+def clos = { print it }
+clos( "oi" )
+
+/*
+  Groovy pode memorizar resultados de closures [1][2][3]
+*/
+def cl = {a, b ->
+    sleep(3000) //  simula processamento
+    a + b
+}
+
+mem = cl.memoize()
+
+def chamaClosure(a, b) {
+    def inicio = System.currentTimeMillis()
+    mem(a, b)
+    println "Os inputs(a = $a, b = $b) - tomam ${System.currentTimeMillis() - inicio} msecs."
+}
+
+chamaClosure(1, 2)
+chamaClosure(1, 2)
+chamaClosure(2, 3)
+chamaClosure(2, 3)
+chamaClosure(3, 4)
+chamaClosure(3, 4)
+chamaClosure(1, 2)
+chamaClosure(2, 3)
+chamaClosure(3, 4)
+
+/*
+  Expando
+
+  A classe Expando é um bean dinâmico que permite adicionar propriedade e 
+  closures como métodos a uma instância desta classe
+
+  http://mrhaki.blogspot.mx/2009/10/groovy-goodness-expando-as-dynamic-bean.html
+*/
+  def usuario = new Expando(nome:"Roberto")
+  assert 'Roberto' == nome.name
+
+  nome.lastName = 'Pérez'
+  assert 'Pérez' == nome.lastName
+
+  nome.showInfo = { out ->
+      out << "Name: $name"
+      out << ", Last name: $lastName"
+  }
+
+  def sw = new StringWriter()
+  println nome.showInfo(sw)
+
+
+/*
+  Metaprogramação (MOP)
+*/
+
+//Usando a ExpandoMetaClasse para adicionar comportamento
+String.metaClass.testAdd = {
+    println "adicionamos isto"
+}
+
+String x = "teste"
+x?.testAdd()
+
+//Interceptando chamadas a métodos
+class Test implements GroovyInterceptable {
+    def soma(Integer x, Integer y) { x + y }
+
+    def invocaMetodo(String name, args) {
+        System.out.println "Invoca método $name com argumentos: $args"
+    }
+}
+
+def teste = new Test()
+teste?.soma(2,3)
+teste?.multiplica(2,3)
+
+//Groovy suporta propertyMissing para lidar com tentativas de resolução de
+//propriedades.
+class Foo {
+   def propertyMissing(String nome) { nome }
+}
+def f = new Foo()
+
+assertEquals "boo", f.boo
+
+/*
+  TypeChecked e CompileStatic
+  Groovy, por natureza, é e sempre será uma linguagem dinâmica, mas ela também
+  suporta typecheked e compilestatic
+
+  Mais informações: http://www.infoq.com/articles/new-groovy-20
+*/
+//TypeChecked
+import groovy.transform.TypeChecked
+
+void testeMethod() {}
+
+@TypeChecked
+void test() {
+    testeMethod()
+
+    def nome = "Roberto"
+
+    println noomee
+
+}
+
+//Outro exemplo:
+import groovy.transform.TypeChecked
+
+@TypeChecked
+Integer test() {
+    Integer num = "1"
+
+    Integer[] numeros = [1,2,3,4]
+
+    Date dia = numeros[1]
+
+    return "Teste"
+
+}
+
+//Exemplo de CompileStatic :
+import groovy.transform.CompileStatic
+
+@CompileStatic
+int soma(int x, int y) {
+    x + y
+}
+
+assert soma(2,5) == 7
+
+
+```
+
+## Referências
+
+[Groovy documentation](http://groovy.codehaus.org/Documentation)
+
+[Groovy web console](http://groovyconsole.appspot.com/)
+
+Junte-se a um [grupo de usuários Groovy](http://groovy.codehaus.org/User+Groups)
+
+## Livro
+
+* [Groovy Goodness] (https://leanpub.com/groovy-goodness-notebook)
+
+* [Groovy in Action] (http://manning.com/koenig2/)
+
+* [Programming Groovy 2: Dynamic Productivity for the Java Developer] (http://shop.oreilly.com/product/9781937785307.do)
+
+[1] http://roshandawrani.wordpress.com/2010/10/18/groovy-new-feature-closures-can-now-memorize-their-results/
+[2] http://www.solutionsiq.com/resources/agileiq-blog/bid/72880/Programming-with-Groovy-Trampoline-and-Memoize
+[3] http://mrhaki.blogspot.mx/2011/05/groovy-goodness-cache-closure-results.html
+
+
+
diff --git a/pt-br/haskell-pt.html.markdown b/pt-br/haskell-pt.html.markdown
index 55f90bd6..788dc1d2 100644
--- a/pt-br/haskell-pt.html.markdown
+++ b/pt-br/haskell-pt.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: haskell
+language: Haskell
 contributors:
     - ["Adit Bhargava", "http://adit.io"]
 translators:
diff --git a/pt-br/markdown-pt.html.markdown b/pt-br/markdown-pt.html.markdown
index cac4a13e..4030ce3c 100644
--- a/pt-br/markdown-pt.html.markdown
+++ b/pt-br/markdown-pt.html.markdown
@@ -14,7 +14,7 @@ escrever sintaxe que converte facilmente em HTML (hoje, suporta outros formatos
 Dê-me feedback tanto quanto você quiser! / Sinta-se livre para a garfar (fork) e 
 puxar o projeto (pull request)
 
-```
+```markdown
 <!-- Markdown é um superconjunto do HTML, de modo que qualquer arvquivo HTML é 
 um arquivo Markdown válido, isso significa que nós podemos usar elementos HTML 
 em Markdown, como o elemento de comentário, e eles não serão afetados pelo analisador
diff --git a/pt-br/php-pt.html.markdown b/pt-br/php-pt.html.markdown
index 344df43a..0e710742 100644
--- a/pt-br/php-pt.html.markdown
+++ b/pt-br/php-pt.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: php
+language: PHP
 contributors:
     - ["Malcolm Fell", "http://emarref.net/"]
     - ["Trismegiste", "https://github.com/Trismegiste"]
diff --git a/pt-br/ruby-pt.html.markdown b/pt-br/ruby-pt.html.markdown
index 4a8a1b5c..89a051d4 100644
--- a/pt-br/ruby-pt.html.markdown
+++ b/pt-br/ruby-pt.html.markdown
@@ -33,7 +33,7 @@ Você não deve usar também
 10 * 2 #=> 20
 35 / 5 #=> 7
 
-# Aritimética é apenas açúcar sintático
+# Aritmética é apenas açúcar sintático
 # para chamar um método de um objeto
 1.+(3) #=> 4
 10.* 5 #=> 50
@@ -129,7 +129,7 @@ array = [1, "Oi", false] #=> => [1, "Oi", false]
 array[0] #=> 1
 array[12] #=> nil
 
-# Como aritimética, o acesso via [var]
+# Como aritmética, o acesso via [var]
 # é apenas açúcar sintático
 # para chamar o método [] de um objeto
 array.[] 0 #=> 1
@@ -171,7 +171,7 @@ end
 
 # Desde o Ruby 1.9, temos uma sintaxe especial quando usamos símbolos como chaves (keys)
 
-novo_hash = { defcon: 3, acao: true}
+novo_hash = {defcon: 3, acao: true}
 
 novo_hash.keys #=> [:defcon, :acao]
 
@@ -183,9 +183,9 @@ novo_hash.keys #=> [:defcon, :acao]
 if true
   "Se verdadeiro"
 elsif false
- "else if, opicional"
+ "else if, opcional"
 else
- "else, também é opicional"
+ "else, também é opcional"
 end
 
 for contador in 1..5
@@ -259,7 +259,7 @@ end
 # Argumentos de métodos são separados por uma vírgula
 somar 3, 4 #=> 7
 
-somar somar(3,4), 5 #=> 12
+somar(3,4), 5 #=> 12
 
 # yield
 # Todos os métodos possuem implicitamente um paramêntro opcional que é um bloco