DEV Community: Thiago Zilli Sarmento

Problemas com Variáveis Globais: Prós e contra

Thiago Zilli Sarmento — Fri, 08 Mar 2024 16:46:14 +0000

Manutenção: Elas podem levar a código que é difícil de manter e testar. Variáveis globais podem ser modificadas por qualquer parte do programa, tornando difícil rastrear e prever o estado do programa.

Concorrência: Em um ambiente de execução concorrente, como é comum em Go, o acesso não sincronizado a variáveis globais pode causar condições de corrida, onde múltiplas goroutines leem e escrevem na mesma variável simultaneamente, levando a resultados inesperados e bugs difíceis de depurar.

Dependência: Código que depende de variáveis globais pode ser mais difícil de isolar em testes unitários, o que reduz a qualidade dos testes e pode aumentar o risco de defeitos no software.

Benefícios e Boas Práticas:

Configuração Inicial: Em certos cenários, como configuração inicial de aplicativos ou definição de constantes, as variáveis globais podem ser úteis e aceitáveis.

**Padrões de Design: **Para evitar os problemas associados com variáveis globais, padrões de design como "Singleton" ou injeção de dependência podem ser utilizados. Esses padrões permitem um maior controle sobre o acesso e a modificação do estado global.

Sincronização: Se o uso de uma variável global é inevitável, garantir que o acesso seja sincronizado, como utilizando mutexes, pode mitigar problemas de concorrência.

Conclusão:

A utilização de variáveis globais deve ser evitada quando possível. Alternativas como o uso de estruturas e métodos para encapsular estado e injeção de dependência devem ser preferidas para criar um código mais limpo, testável e manutenível. Quando necessário, seu uso deve ser cuidadosamente controlado e sincronizado para evitar condições de corrida e outros bugs relacionados à concorrência.

Adotando Flexibilidade e Escalabilidade em Go com o Padrão Options

Thiago Zilli Sarmento — Wed, 21 Feb 2024 22:32:03 +0000

No mundo da engenharia de software, padrões de design são cruciais para criar códigos escaláveis e fáceis de manter. Dentre estes, o padrão Options tem ganhado popularidade em Go por sua flexibilidade e elegância, especialmente ao configurar objetos complexos. Neste artigo, exploraremos o padrão Options em Go, comparando-o com métodos convencionais e examinando suas vantagens através de exemplos.

Compreendendo o Padrão Options

O padrão Options em Go é uma abordagem de design usada para inicializar objetos com um conjunto potencialmente complexo de opções de configuração. Ele aborda o desafio de construtores ou funções que requerem muitos parâmetros, alguns dos quais podem ser opcionais.
Tradicionalmente, em linguagens como Go, você pode usar uma função construtora com uma longa lista de parâmetros ou vários construtores. No entanto, isso pode rapidamente se tornar complicado e propenso a erros, especialmente à medida que o número de parâmetros aumenta ou quando muitos deles são opcionais.

Exemplo de Implementação

Considere um struct Login em uma aplicação Go que requer várias dependências e configurações. Veja como o padrão Options pode ser implementado de forma elegante:
Definindo as Structs Options e Params

package login

type Options func(*LoginParams) error

type LoginParams struct {
    client client.ClientRepo
    auth   auth.AuthRepo
}

Criando o Struct Login com Options

type Login struct {
    params *LoginParams
}

func NewLogin(opts ...Options) (*Login, error) {
    params := &LoginParams{}

    for _, opt := range opts {
        if err := opt(params); err != nil {
            return nil, err
        }
    }

    return &Login{params: params}, nil
}

Fornecendo Opções Funcionais

func WithClient(repo client.ClientRepo) Options {
    return func(p *LoginParams) error {
        p.client = repo
        return nil
    }
}

func WithAuth(repo auth.AuthRepo) Options {
    return func(p *LoginParams) error {
        p.auth = repo
        return nil
    }
}

Benefícios do Padrão Options

Escalabilidade: Adicione novas opções facilmente sem alterar a assinatura do construtor.
Legibilidade: Os chamadores podem ver de relance quais opções estão sendo configuradas.
Flexibilidade: As opções podem ser omitidas ou adicionadas conforme necessário, reduzindo a necessidade de múltiplos construtores ou lógica de inicialização complexa.
Manutenibilidade: Centraliza a lógica de configuração, tornando o código mais fácil de manter e estender.

Comparação com Métodos Convencionais

Em contraste com métodos tradicionais, onde você pode sobrecarregar funções ou construtores, o padrão Options oferece uma abordagem mais escalável e fácil de manter. Funções sobrecarregadas podem se tornar complicadas e menos intuitivas, especialmente com muitos parâmetros opcionais.

Aplicação no Mundo Real

Em nosso exemplo, NewLogin pode ser inicializado com várias configurações sem a necessidade de vários construtores ou uma longa lista de parâmetros. Esta abordagem é especialmente benéfica em projetos maiores onde as configurações podem ser complexas e variadas.

loginInstance, err := NewLogin(WithClient(clientRepo), WithAuth(authRepo))

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

Este trecho demonstra como NewLogin pode ser configurado de forma flexível com diferentes opções. O código resultante é limpo, legível e fácil de modificar.

Conclusão

O padrão Options em Go oferece uma solução elegante para a inicialização de objetos com configurações complexas. Ao fornecer escalabilidade, legibilidade e flexibilidade, ele se destaca como uma escolha superior em comparação com métodos mais convencionais. Este padrão é particularmente valioso em aplicações de grande escala onde as configurações são diversas e sujeitas a mudanças.

Aprimorando o Tratamento de Erros em Go com o Pacote httpe (echo)

Thiago Zilli Sarmento — Wed, 21 Feb 2024 22:27:30 +0000

No mundo do desenvolvimento de software, especialmente em ambientes de microserviços, a gestão eficaz de erros é crucial. O tratamento estruturado de erros não só melhora a qualidade do código, mas também facilita a depuração e a manutenção. Hoje, quero compartilhar com vocês uma abordagem moderna utilizando o pacote httpe em Go.

O pacote httpe é uma ferramenta projetada para simplificar a forma como lidamos com erros em aplicações Go, especialmente aquelas que interagem com HTTP. Com ele, podemos criar objetos de erro HTTP com código de status específico, mensagem e detalhes internos opcionais. Isso permite um maior controle e uma melhor resposta aos consumidores da API.

Por que isso é importante? Em primeiro lugar, centraliza a lógica de erro, promovendo a reutilização e a consistência. Em segundo lugar, fornece uma camada de abstração, onde podemos incorporar lógicas, como logs detalhados ou métricas, sem poluir o código principal. Além disso, ao separar a lógica de erro do código de negócios, tornamos nosso código mais limpo e fácil de manter.

Um exemplo chave é a função ParseMessageToErrors do httpe, que transforma mensagens de erro em formatos estruturados. Isso é particularmente útil para APIs REST, onde os consumidores precisam de respostas claras e consistentes.

Em resumo, adotar um pacote como o httpe pode ser um passo significativo para melhorar a robustez e a clareza do tratamento de erros em suas aplicações Go. Com ele, você eleva o nível da sua aplicação e, por consequência, a satisfação dos usuários finais.

Código fonte
https://github.com/thiagozs/go-httpe

Desenvolvimento de Features: Navegando Entre Falhas e Sucesso

Thiago Zilli Sarmento — Wed, 21 Feb 2024 22:23:34 +0000

Desenvolvimento Ágil: A Arte de Corrigir em Movimento

No mundo dinâmico do desenvolvimento de software, adaptabilidade e eficiência são fundamentais. Quando estamos no meio do desenvolvimento de uma nova feature, enfrentar falhas e erros é uma realidade comum. A habilidade de identificar e corrigir esses problemas imediatamente pode ser a diferença entre sucesso e fracasso.

Fix Imediato: Prevenção é Melhor que Cura

Ao desenvolver uma nova funcionalidade, é natural que desafios e bugs surjam no caminho. Implementar correções ("fixes") assim que esses problemas são identificados não é apenas eficiente, mas também preventivo. Isso minimiza o risco de bugs se acumularem ou se tornarem mais complexos, economizando tempo e recursos no longo prazo.

Detectar, Agir, Avançar: Um Ciclo Contínuo de Melhoria

O processo de desenvolvimento deve ser iterativo e reflexivo. Detectar um erro, agir imediatamente para corrigi-lo e, em seguida, continuar o desenvolvimento, é um ciclo que promove a melhoria contínua. Isso mantém a qualidade do código elevada e assegura que a feature final seja robusta e confiável.

Flexibilidade e Resiliência: Adaptando-se às Mudanças

Ser flexível e resiliente diante de falhas e erros é uma qualidade valiosa em desenvolvimento de software. A capacidade de adaptar-se rapidamente e fazer correções eficientes é o que permite à equipe manter o ritmo e garantir que a entrega final atenda ou exceda as expectativas.

Conclusão: Fix Hoje, Sucesso Amanhã

Corrigir problemas durante o desenvolvimento de uma feature não é apenas uma prática recomendada, é um indicador de uma equipe ágil e de um projeto bem gerenciado. Encare cada fix como um passo em direção à excelência, mantendo a qualidade e a integridade do projeto sempre em foco. Lembre-se: um fix hoje pode significar a diferença entre o sucesso e a necessidade de revisões extensivas amanhã.

A Importância de Checar Erros em Go

Thiago Zilli Sarmento — Wed, 21 Feb 2024 22:20:10 +0000

Ao programar em Go, uma das práticas mais cruciais é a gestão eficiente dos erros. Go adota uma abordagem única para lidar com erros, que é tanto robusta quanto explícita. Em vez de exceções e try-catch que são comuns em muitas linguagens de programação, Go utiliza um sistema de tuplas, onde uma função pode retornar um erro como um de seus valores de retorno.
Por exemplo:

valor, err := algumaFuncao()

Aqui, algumaFuncao() retorna dois valores: um valor de interesse e um erro. É uma convenção em Go verificar esse erro imediatamente após a chamada da função. Ignorar essa etapa pode levar a bugs sutis e difíceis de diagnosticar, problemas de desempenho e, em última instância, falhas no sistema.

Por que é tão Importante?

Clareza e Legibilidade: O manejo explícito de erros torna o código mais legível. É fácil para os desenvolvedores, especialmente aqueles que são novos no código, entender onde e por que um erro pode ocorrer.
Robustez: Ao verificar e lidar com erros de forma proativa, você pode evitar muitos problemas em tempo de execução. O sistema não só se torna mais robusto, mas também mais seguro.
Diagnóstico Rápido: Quando um erro ocorre, é muito mais fácil diagnosticar e corrigir o problema se você souber exatamente onde e por que o erro aconteceu. Exemplo Prático Veja um exemplo prático para ilustrar a importância:

file, err := os.Open("arquivo.txt")
if err != nil {
   log.Fatalf("Erro ao abrir o arquivo: %v", err)
}

Neste exemplo, se um erro ocorrer ao tentar abrir o arquivo (por exemplo, se o arquivo não existir), o programa não só captura esse erro, mas também fornece um feedback útil sobre o que deu errado. Isso facilita a rápida identificação e resolução do problema.

Conclusão

A gestão de erros em Go é um componente essencial para escrever software confiável e eficiente. Ao adotar a prática de verificar erros de forma consistente, você não só torna seu código mais robusto e fácil de entender, mas também assegura que seu aplicativo possa ser mantido e ampliado com confiança ao longo do tempo.

Linkedin: A importancia de checar erros em go