# Error Handling

O tratamento de erros em Go é bem diferente do que em outras linguagem, não temos o tradicional try/except. Os erros em Go são simplesmente retornados como uma variável normal, daí que surge o famoso if err != nil {} do Golang. Nas primeiras vezes que vi essa estrutura foi meio estranho, mas depois fez bastante sentido. Essa estrutura vai completamente de encontro ao design da linguagem do Golang, manter a simplicidade e eficiencia da linguagem. Vamos criar uma função de divisão e retornar um erro quando o divisor é 0.

# Como o Runtime do Golang Gerencia Goroutines

O scheduler do Go é responsável por organizar e distribuir a execução das goroutines nas threads do sistema operacional. Como já falamos em outro post sobre as goroutines são muito mais leves que threads, então você pode ter milhares rodando ao mesmo tempo. Mas como o sistema operacional tem um número limitado de threads, o scheduler cuida de organizar quais goroutines rodam em quais threads e quando.

# make()

Aproveitando o Dia 32/100 busquei no roadmap.sh sobre os tópicos que já tinha estudado e verifiquei quais pontos ainda não tinha visto ou não sabia do que se tratava. A função make() entra nos assuntos que já vi nos materias que estou usando para estudar, mas pensando com mais profundidade não sei qual a utilidade dela nem quando fazer uso da mesma. Nesse posto pretendo sanar essas dúvidas.

# Caminhos para estudar Golang

Não cheguei nem em metade dos 100 dias e estou meio perdido em quais caminhos seguir para estudar. Procurei alguns materiais e encontrei vários caminhos bem interessantes.

# Go | Tech Guide - Alura

Go | Tech Guide - Alura Material muito legal desenvolvido pelo pessoal da Alura. Está dividido em 3 níveis de profundidade.

# Roadmap.sh

Roadmap.sh Caminho bem legal para seguir, passa por todo o básico da linguagem para depois ir para CLI, ORM, Frameworks Web, Logging, WebSockets, API, Testes e Ferramentas para microserviços.

# GORM

GORM é um ORM para Golang, segundo a documentação “The fantastic ORM library for Golang aims to be developer friendly.” Vamos seguir o quickstart da documentação e criar um exemplo mais nosso.

Instalação do gorm e sqlite

go get -u gorm.io/gorm
go get -u gorm.io/driver/sqlite

Vamos definir uma struct Livros que no futuro se transformará na nossa tabela do banco de dados.

type Livros struct {
  Autor  string
  Nome string
  NumeroDePaginas uint
}

Fazer a conexão com o banco de dados, veja que estamos utilizando o sqlite como banco. Caso seja utilizado outro banco, o import do driver deve ser diferente.

# Testes - Exemplo Prático

Vamos fazer um exemplo completo com o conhecimento que adquirimos até agora sobre testes na linguagem Go. Para esse exemplo vou criar um pacote chamado “stats” com algumas funções estatísticas simples. Usarei também testify que vimos no 29/100 Dias de Golang - Testes com Testify.

Vamos iniciar o projeto:

go mod init stats

E já adicionar as libs necessárias:

go get github.com/stretchr/testify/assert
go get github.com/stretchr/testify/require

Vamos criar um arquivo e adicionar duas funções, média e mediana. Veja que fiz algumas validações se o slice é vazio e criei um erro específico para isso.

# Testes com Testify

Toda a concepção do Go e as escolhas arquiteturais da linguagem são direcionadas para tornar a linguagem simples. Podemos ver isso claramente nos testes:

if total != expected {
	t.Errorf("Esperava %d recebi %d", expected, total)
}

Não temos um assert como em outras linguagens para verificar os valores. Para preencher esse “gap” no coração dos programadores temos a lib Testify. Vamos criar alguns testes com ela, mas antes vamos instalar a lib no nosso projeto:

# Testes em Go com Fuzzing

Já vimos que é muito importante termos testes de integração nos nossos códigos, vimos também sobre cobertura de código e comentamos que mesmo que um código esteja com 100% de cobertura não é garantia que ele esteja correto, lembre da frase do Dijkstra “Os testes mostram a presença, não a ausência de bugs”. É aqui que entra o fuzzing, uma técnica poderosa para encontrar falhas inesperadas no código. Desde a versão 1.18, o Go oferece suporte nativo ao fuzzing, tornando essa abordagem mais acessível para desenvolvedores.

# Benchmarking em Go: Medindo e Otimizando o desempenho

Como você deve ter visto até aqui, testes em go são muito simples e a biblioteca padrão nos oferece recursos bem poderosos. Outra ferramenta que a biblioteca testing oferece de forma nativa é o benchmarking. O benchmarking serve para diversas finalidades, todas relacionadas à avaliação e otimização do desempenho de sistemas, aplicações, algoritmos ou componentes de software. A questão mais legal que eu achei foi a comparação de implementações, testar qual implementação de uma função performa melhor que outra. Veja como é simples fazer esses testes:

# Testes em batch

Vamos adicionar mais alguns testes na função de soma, agora vamos testar com dois valores negativos, com somente um valor negativo e com zero.

func TestSomaTwoNegatives(t *testing.T) {
	total := Soma(-5, -10)

	expected := -15

	if total != expected {
		t.Errorf("Esperava %d recebi %d", expected, total)
	}
}

func TestSomaOneNegative(t *testing.T) {
	total := Soma(5, -10)

	expected := -5

	if total != expected {
		t.Errorf("Esperava %d recebi %d", expected, total)
	}
}

func TestSomaWithZero(t *testing.T) {
	total := Soma(5, 0)

	expected := 5

	if total != expected {
		t.Errorf("Esperava %d recebi %d", expected, total)
	}
}

O que você achou de todos esses testes? Não parece contraintuitivo gerar uma função para cada caso da função Soma? Só estamos trocando os parâmetros, parece desnecessário repetir toda a estrutura. Para resolver esse problema o Go possui o teste em batch. Veja como fazemos esse teste em batch.