Tag: performance

Como comparar valores em Go

Tiago TemporinDeixe um comentário

Comparar valores é uma das operações mais comuns em qualquer linguagem de programação, e em Go não é diferente. Porém, a simplicidade da linguagem esconde algumas nuances importantes sobre como certos tipos podem ou não ser comparados diretamente.

Neste post, exploraremos os operadores de comparação em Go, suas limitações e alternativas.

Operadores de Comparação

De modo geral, Go oferece dois operadores para comparação direta de valores:

  • ==: Verifica se os valores dos dois operandos são iguais.
  • !=: Verifica se os valores dos dois operandos são diferentes.

Esses operadores funcionam para os tipos chamados de “comparáveis”, como por exemplo o boolean, int, float, tipos complexos, string, channels, arrays, structs e ponteiros.

Para os tipos numéricos (int, float e tipos complexos) também podemos utilizar >, <, <= e >=.

Leia mais »

Por que evitar o package Reflect

Tiago Temporin1 comentário

O package reflect no Go é uma ferramenta poderosa que permite inspecionar e manipular tipos e valores em runtime. No entanto, como diria o tio Ben, “com grandes poderes vêm grandes responsabilidades”.

Embora possa parecer atraente em certos cenários, o uso excessivo ou inadequado do reflect pode introduzir problemas significativos no seu código, como dificuldades de manutenção, bugs difíceis de depurar e perda de performance.

Neste post, exploraremos o que é o package reflect, exemplos de sua utilização, onde ele é amplamente empregado e, mais importante, porque você deve evitá-lo quando possível.

O que é o package Reflect

O package reflect faz parte da biblioteca padrão do Go e oferece funcionalidades para inspecionar tipos e valores em runtime, ou seja, em tempo de execução.

Leia mais »

Dicas para escrever bons benchmarks

Tiago TemporinDeixe um comentário

Escrever benchmarks em Go é uma prática essencial para desenvolvedores que buscam otimizar a performance de suas aplicações.

Um benchmark bem elaborado pode revelar gargalos e oportunidades de otimização que, de outra forma, poderiam passar despercebidos.

No entanto, existem armadilhas comuns que podem distorcer os resultados dos benchmarks, levando a conclusões incorretas.

Neste post, exploraremos os principais cuidados que devem ser tomados ao escrever benchmarks em Go, com exemplos de código que ilustram boas e más práticas.

Importância de escrever Benchmarks

Benchmarking é uma técnica que permite medir a eficiência de determinadas partes do código, como funções ou métodos, em termos de tempo de execução.

Ao escrever benchmarks, você pode identificar quais partes do código precisam ser otimizadas e quais já estão suficientemente rápidas. No contexto de desenvolvimento de software, benchmarks são fundamentais para garantir que mudanças no código não degradem a performance.

Leia mais »

Diferenças entre structs e classes

Tiago Temporin1 comentário

No Go, uma struct é um tipo de dado fundamental que agrupa “variáveis” (atributos) sob um único nome, similar a como uma classe agrupa propriedades e métodos em linguagens orientadas a objetos como Java ou C#. No entanto, existem diferenças significativas tanto na sintaxe quanto nos conceitos e funcionalidades oferecidos por structs em Go quando comparada com classes em outras linguagens.

Estrutura e Sintaxe

Struct

Em Go, uma struct é definida usando a palavra-chave struct. A definição de uma struct envolve apenas a declaração de atributos.

type Pessoa struct {
	Nome  string
	Idade int
}
Leia mais »

Otimização automatizada com PGO

Tiago TemporinDeixe um comentário

A otimização de desempenho é uma preocupação constante no desenvolvimento de software, e a linguagem Go não é uma exceção. Uma técnica que tem ganhado bastante atenção nesse contexto é a Profile-Guided Optimization (PGO). Neste post, vamos explorar o que é PGO, sua história na linguagem Go, e como você pode utilizar essa técnica tanto em aplicações de linha de comando (CLI) quanto em APIs.

O que é PGO?

PGO é uma técnica de otimização que utiliza dados de execução de uma aplicação para guiar o processo de compilação. Ao contrário da otimização tradicional, onde o compilador faz suposições gerais, o PGO permite ao compilador otimizar o código com base em dados reais de uso, levando a um desempenho significativamente melhorado.

Leia mais »

Como escalar horizontalmente uma aplicação no Kubernetes

Tiago TemporinDeixe um comentário

Se você já se deparou com gargalos de performance ou custos exorbitantes na sua jornada com Kubernetes, prepare-se para conhecer seu novo melhor amigo: o Horizontal Pod Autoscaler (HPA). Neste post, vamos mergulhar no universo do HPA, desvendando seus segredos e te equipando com o conhecimento necessário para otimizar seus clusters.

O que é o HPA?

A função básica do HPA é monitorar sua aplicação em tempo real, e ajustar automaticamente o número de pods em ação para garantir a melhor experiência possível para seus usuários. Em outras palavras, esse recurso mágico do Kubernetes permite escalar horizontalmente seus workloads de forma inteligente e eficiente.

Leia mais »

Benchmark: ORM vs SQL puro

Tiago Temporin1 comentário

Finalmente tive tempo para sanar, com dados, uma das minhas e, imagino que de várias outras pessoas, maiores dúvidas quando se trata de Go e banco de dados. Qual a diferença, ao nível de consumo de recurso e performance, entre utilizar GORM vs escrever SQL na unha.

Para ficar mais fácil a leitura, separei o post em tópicos. Iniciarei explicando como fiz o setup, as funções comuns e realizei a execução dos benchmarks. Depois, separo o código do benchmark, assim como o resultado, em ações de CRUD.

Setup

Primeiramente, criei os packages entities, orm e std. Dentro do package entities, criei uma struct para ser utilizada em todos os benchmarks.

package entities

type Category struct {
    ID          int64  `gorm:"column:id;primaryKey"`
    Name        string `gorm:"column:name"`
    Description string `gorm:"column:description"`
}
Leia mais »

Benchmark: conexão sempre aberta vs uma conexão por chamada

Tiago Temporin1 comentário

Como eu nunca havia visto um benchmark para mostrar as diferenças entre, abrir uma conexão no início do programa e utilizá-la como dependência e, abrir uma nova conexão a cada chamada, resolvi fazê-la.

Embora a maioria das pessoas que converso saberem a resposta correta, não sei se, assim como eu, elas têm a ideia de quão grande é a diferença entre essas abordagens.

Mas antes de ver o resultado, mostrarei como construí o benchmark.

Conexão & Dados

Bem simples, para abrir a conexão sqlite3, criei uma função chamada Open.

package connections  

import (  
    "database/sql"  

    _ "github.com/mattn/go-sqlite3"  
)  

// Open a connection with a sqlite3 database
func Open() (*sql.DB, error) {  
    return sql.Open("sqlite3", "test.db")  
}
Leia mais »
green tree

Qual a diferença entre reflect.TypeOf e reflect.ValueOf

Tiago TemporinDeixe um comentário

Se você é novo no mundo Go, muito provavelmente ainda não tenha trabalhado diretamente com o package reflect. Na verdade, é completamente normal pessoas que já trabalhem com a linguagem a algum tempo e ainda não tenham utilizado tal package.

Isso por que esse package tem uma utilidade muito específica. Não que todos os packages não tenham, ou pelo menos deveriam ter. Mas no caso do reflect, sua especificidade é tão grande, que mesmo em sistemas que o utilizam, ele provavelmente fica em alguma parte obscura, complexa e pouco mantida.

Tendo dito tudo isso e, ao mesmo tempo falado muito pouco, nesse post explicarei tudo o que você precisa saber sobre o package reflect e suas funções TypeOf e ValueOf.

Reflect

Antes de entender o que as funções TypeOf e ValueOf tem a oferecer, falemos um pouco sobre a finalidade do package reflect.

Leia mais »
photo of gray faucet

Como resolver memory leaks em maps

Tiago TemporinDeixe um comentário

Uma das formas mais comuns de se fazer cache em aplicações Go é utilizando um map. Se você já fez isso, deve ter notado um aumento gradual no consumo de memória, e que normalmente após um restart da máquina ou pod volta ao “normal”.

Isso acontece devido a forma como o map funciona. Por isso, antes de ver o que podemos fazer para resolver esse tipo de problema, vamos entender melhor o map.

Para exemplificar o problema, vamos considerar uma variável do tipo map[int][128]byte, que será “carregada” com 1 milhão de elementos e que na sequência serão removidas.

package main

import (
	"fmt"
	"runtime"
)

func main() {
	n := 1_000_000
	m := make(map[int][128]byte)
	printAlloc()

	for i := 0; i < n; i++ {
		m[i] = [128]byte{}
	}
	printAlloc()

	for i := 0; i < n; i++ {
		delete(m, i)
	}

	runtime.GC()
	printAlloc()
	runtime.KeepAlive(m)
}

func printAlloc() {
	var m runtime.MemStats
	runtime.ReadMemStats(&m)
	fmt.Printf("%d KB\\n", m.Alloc/1024)
}
Leia mais »