GoLang, desbravando uma linguagem de programação - Parte 2

Este artigo é a segunda parte de uma sequência de artigos sobre meu processo de aprendizado de uma nova linguagem de programação, nessa série tenho o objetivo de documentar esse processo na esperança de talvez poder ajudar alguém, não só aprender a própria linguagem Go, como qualquer outra linguagem de programação. A parte 1 dessa série pode ser lida aqui.

Antes de começarmos

Um ponto que venho percebendo durante meus estudos em Go, é que é muito fácil perceber o porque quase sempre se usa o termo Golang e não somente Go como inicialmente concebido. É inviável achar qualquer coisa em um buscador usando apenas Go, assim provavelmente irei me referir algumas vezes ao Go usando este termo e acabei por alterar os títulos dos artigos para facilitar a indexação nos mecanismos de busca.

Outro adendo importante que gostaria colocar é um utilitário web disponibilizado pela própria Google para testarmos a linguagem, sendo possível testar a Golang mesmo sem ter nada instalado localmente. Esse utilitário denominado The Go Playground pode ser encontrado em https://play.golang.org e realmente ajuda muito nos testes iniciais da linguagem.

Mas afinal quem usa Go?

Bom, além do próprio Google, outras grandes empresas estão investindo no Go, com a Sendgrid, Globo.com, Mercado Livre, Magazine Luiza, Walmart além de várias outras gigantes no mercado.

Um caso de uso bem interessante é o da sendgrid que pode ser lindo aqui onde seu Co-founder Tim Jenkins descreve os motivos da escolha da linguagem e o mais importante, os problemas encontrados nessa adoção e como eles superaram eles.

Outro caso de uso interessante é o do Globo.com que pode ser visto aqui, onde o analista Vinicius Pacheco descreve como saíram de 200 para 19 mil cadastros por segundo usando microservices e Go.

Quando usar o Go ?

Sinto muito, mas Golang não é a bala de prata que estava esperando 😞, pode parecer uma brincadeira, mas ainda hoje, mesmo com tantos artigos publicados sobre o assunto, não falta desenvolvedores em busca de uma linguagem/ecossistema que atenda todas as demandas possíveis da melhor forma. Para esses, eu tenho uma triste notícia, isso provavelmente nunca vai acontecer. Entender o que cada ecossistema de linguagem tem de melhor, e onde é interessante ou não usá-la é fundamental para que possamos prover sempre a melhor solução para cada problema.

Go tem objetivos muito claros, se precisa de um sistema multiplataforma, altamente escalável, com desempenho similar outras linguagens compiladas como C, que trabalhem com programação concorrente de forma nativa e de maneira altamente otimizada, então meu amigo, Go é pra você 😉. Se esses objetivos não se alinham com seu projeto, então esqueça, provavelmente Go não é a melhor opção.

Para se manter fiel a seus objetivos, Golang tende a ser simplista ao extremo, e não implementa, ou implementa de forma alternativa vários mecanismos hoje comum em quase todas as linguagens de alto nível. Para citar alguns desses pontos:

• Não tem classes;
• Não tem herança;
• Não é possível fazer overload de métodos;
• Não existe sistemas de Exceptions (try/catch); 😱
• Não tem conversões numéricas implícitas;
• Não possui Operadores Ternários; 😢

Isso mesmo, pode parecer estranho, eu mesmo ainda não me acostumei com isso, mas Go tem um suporte a orientação a objetos extremamente peculiar. Mas não desista ainda, por exemplo, para suprir a necessidade criada pela falta de classes, Go disponibiliza as Structs, que irão permitir trabalhar de forma similar a que estamos acostumados com as classes. Iremos ver isso com mais calma em um próximo artigo.

O tratamento de erros em Go vem se destacando em meus estudos como um grande ponto fraco do ecossistema, e é comum ver que a maioria dos desenvolvedores usam a capacidade de Golang de retornar vários valores em uma mesma função para fazer um tratamento que pra mim ainda parece um pouco primitivo. Abaixo um exemplo de tratamento de erro:

1
2
3
4
5

f, err := os.Open("filename.ext")

if err != nil {
    log.Fatal(err)
}

Para Go os erros não podem ser delegados, são considerados com parte fundamental do código. Um texto interessante que fala sobre isso, escrito por Elton Minetto pode ser lido aqui.

Gerenciamento de dependências

Nos dias de hoje dificilmente conseguiremos trabalhar em um sistema completamente sem dependências externas, até por que não faria sentido reinventar a roda a cada novo projeto.

Go vem inserido em um ecossistema muito rico de funcionalidades, traz já em sua base, funcionalidades como testes por exemplo, que na maioria das linguagens ficam a cargo de pacotes de terceiros. Porém isso não acontece com o sistema de gerência de dependências, o que é uma pena, considerando o grau de importância de um sistema realmente confiável para esse fim.

Não tendo uma ferramenta padrão para isso, acabou por ficar por conta da comunidade o desenvolvimento de uma ferramenta para esse fim, e assim fizeram, várias opções foram surgindo, cada uma com sua abordagem e incompatíveis entre-se, dessas aparentemente a mais relevante é a Glide, que parece ser entre todas a mais madura e concisa. Porém esse problema parece estar chegando ao fim, enquanto escrevo esse artigo existe uma iniciativa da própria comunidade em criar uma ferramenta de nome dep que ainda é um experimento oficial, mas tende a se tornar a ferramenta oficial para esse fim. Nessa série já vamos iniciar com ele, visto que já é considerado “safe for production use” apesar de estar em processo acelerado de desenvolvimento.

O processo de instalação do dep é extremamente simples, mas varia de acordo com seu ambiente. Para essa série, irei continuar usando o docker, mas a imagem padrão não mais vai nos atender, assim vamos fazer uma build customizada já com o dep disponível. Para isso, vamos criar um novo arquivo config/docker/go/Dockerfile, que conterá a receita para criar a imagem do docker.

1
2
3
4

# Arquivo config/docker/go/Dockerfile
FROM golang:1.9-stretch
ENV TZ America/Sao_Paulo
RUN go get -u github.com/golang/dep/cmd/dep

E posteriormente vamos precisar alterar nosso arquivo “docker-compose.yml” para que ele use essa imagem, ficando assim:

1
2
3
4
5
6
7
8

version: "2"

services:
  app:
    build: ./config/docker/go
    volumes:
      - ./:/go/src/learning-go-lang
    working_dir: /go/src/learning-go-lang

Para executar o build executamos o comando “docker-compose build” e tudo correndo bem podemos voltar a executar o comando “docker-compose run app go run main.go” e teremos novamente impresso nosso querido Hello World.

Próximos Capítulos

O passo seguinte será identificar se existem e quanto maduro são os frameworks disponíveis para a linguagem, por fim minha ideia é criar uma API simples usando os principais conceitos da linguagem e posteriormente a levar para produção para que seja possível perceber as dificuldades envolvidas no processo.

Obs.: Os códigos produzidos durante o projeto podem ser acompanhados usando o repositório hospedado no github -> https://github.com/meneguite/golang-learning

Bom por hoje é isso, em breve seguimos..

Click aqui para acessar a terceira e ultima parte do artigo!!