Daniel Mazza

É isso mesmo! A linguagem Go foi incluída no GCC 4.6 (GNU Compiler Collection). Isso significa que subiu oficialmente ao hall das importantes linguagens mundiais, principalmente das open-source. Assim, virá na coleção padrão de compiladores do Linux e outros sistemas assim como já vinham C, C++, Objective-C, Java etc.

Eu esperava por isso já faz algum tempo, pois  creio ser bem merecido. Go é uma linguagem maravilhosa e tem tudo para – sem exagero – substituir com folga as grandes linguagens que temos no mercado! Eu sei que cada qual defende sua linguagem com unhas e dentes, mas se você considerar ponderadamente o que Go é, acho difícil que duvide do meu prognóstico.

Principais características:

• É compilada para código de máquina (não bytecode) e de tipagem estática (validada em tempo de compilação), portanto sua velocidade é comparável à de C e a tendência é se tornar cada vez mais rápida por otimização em futuras releases.
• É simples de aprender. A sintaxe é semelhante à de C de algum modo, mas muito mais afinizada com linguagens dinâmicas contemporâneas como Python.
• Suporta orientação a objeto. Mas com características peculiares muito interessantes… Objetos sem classes. São tipos/estruturas com seus métodos (funções vinculadas a eles), interfaces e packages [veja mais a seguir].
• É robusta e franca
  • Suporta processos concorrentes como recuso built-in.
  • Suas facilidades não iludem o programador sobre o que está ocorrendo nos bastidores.
  • É desenhada para aceitar caracteres UTF-8 por default inclusive em identificadores de variáveis e funções!
  • Tem recurso de inferência concisa de tipos para declaração simplificadas.
  • Tem “coletor de lixo” (garbage collector).
  • Explora o poder de processadores multicore.
  • Tem muuuitas bibliotecas padrão com tudo o que você geralmente sente que precisa e falta em outras linguagens.
  • O código é tão legível que já é quase sua própria documentação e é fácil tanto para programadores quanto para o compilador rastrear as dependências pelas regras de importação.
  • O compilador avisa sobre variáveis ou packages declaradas mas não utilizadas.
  • Possui biblioteca para números arbitrariamente grandes ou arbitrariamente precisos.
• É segura quanto ao tipo e quanto ao acesso à memória (tem ponteiros mas não ponteiros aritméticos e o tamanho de uma array é parte do tipo da array).
• É limpa. Graças ao bom Deus não me puseram shorthands como “templates” para declaração de múltiplos tipos o que arruinaria aquele monumento ao rigor que Go é. Mas alguns conceitos sobre manipulação de tipo ainda estão em discussão, porém cada vez menos se sente a necessidade de novos recursos para tal.
• É uma linguagem de sistema (pode ser usada para desenvolver sistemas operacionais), mas é ao mesmo tempo de uso geral.
• É modesta. [Isso eu demorei um pouco para valorizar, mas vendo a coisa na prática tenho que julgar que foi um acerto, dadas as circuntâncias]. Ou seja, não tenta vencer conceitualmente linguagens intelectuais como Scheme e tantas outras interessantes, mas simplesmente dá o que precisamos sem paradigmas desnecessariamente sofisticados que poderiam tornar o ato de programar muito burocrático. Em suma, tem sua rigorosa filosofia, mas evita “filosofices” puramente acadêmicas e anti-pragmáticas ou até mesmo boas idéias que não caberiam nesse momento histórico.
• É open source (você por ir lá na lista de email e influenciar a linguagem), bem como usar à vontade.
• É patrocinada e fomentada pelo Google, feita principalmente pelo time do Google que inclui grandes nomes da história da informática e novas mentes brilhantes. Esse fator é relevante porque muitas vezes uma linguagem é maravilhosa mas “não pega” amplamente como no caso de D. Com um fomentador de porte e qualidade, não há como “não pegar”.
• É madura. Aprendeu com os erros e acertos de grandes linguagens e veio numa época em que conceitos de linguagens de programação foram testados e regenerados à exaustão. Portanto, pôde contar com um desenho firme, elegante e seguro.

Isso é apenas uma amostra, portanto espero que não julgue a linguagem somente pelo meu post. A seguir, ponho alguns exemplos relevantes, mas dê uma olhada no site oficial. E você pode testar a linguagem online.

Exemplos

Programa mínimo

package main

func main() {
    //code
}

Hello world

package main

import "fmt"

func main() {
    fmt.Println("Olá Mundo!")
}

Inferência de tipo

package main

import "fmt"

func main() {

    var s1 string // tipo declarado
    s1 = "Olá "

    s2 := "Mundo" // tipo inferido

    fmt.Println(s1 + s2)
}

Caracteres UTF-8 por padrão, inclusive em identificadores

package main

import "fmt"

func main() {
    Saudação()
}

func Saudação() {
    fmt.Println("Olá Mundo!")
}

Processos concorrentes (exemplo trivial)

package main

import (
    "fmt"
    "time"
)

func main() {

    sec := int64(1000000000) // 1 segundo em nanosegundos

    // "go" aciona o processo e continua sem esperar
    go DigaNoTempo("Mundo!", 3 * sec)
    go DigaNoTempo(" ",      2 * sec)
    go DigaNoTempo("Olá",    1 * sec)

    time.Sleep(4 * sec) // aguardando os processos...
    fmt.Printf("\n")
}

func DigaNoTempo(s string, t int64) {
    time.Sleep(t)
    fmt.Printf(s)
}

// output: Olá Mundo!

Funções anônimas

package main

import (
    "fmt"
)

func main() {

    f := (func() func() {
        n := 0
        return func () {
            n = n + 1
            fmt.Printf("%d ", n)
        }
    })()
    // função anônima (executada) que retorna função anônima como em JavaScript

    f()
    f()
    f()
    fmt.Printf("\n")
}

// output: 1 2 3

Orientação a objeto (tipo numérico)

package main

import (
    "fmt"
)

func main() {

    n := new(Natural)
    *n = 4

    if n.ÉZero() {
        fmt.Printf("%v é zero\n", *n)
    } else {
        fmt.Printf("%v não é zero\n", *n)
    }

    if n.ÉPar() {
        fmt.Printf("%v é par\n", *n)
    } else {
        fmt.Printf("%v não é par\n", *n)
    }
}

type Natural uint // uint é o inteiro sem sinal de 16 bits

func (n *Natural) ÉZero() bool {
    if *n == 0 {
        return true
    }
    return false
}

func (n *Natural) ÉPar() bool {
    if n.ÉZero() || *n%2 == 0 {
        return true
    }
    return false
}

/* output:
4 não é zero
4 é par
*/