DEV Community: Leonardo Gregianin

go is good (this is about golang)

Leonardo Gregianin — Mon, 31 Mar 2025 12:15:00 +0000

A few days ago, I came across the repository "go-is-not-good", which contains several articles with negative views about Golang. After analyzing and reading all the points, I wrote this article highlighting the positive points of the language.

Go, often called Golang, is a modern programming language that stands out for its simplicity, efficiency, and scalability. Designed by Google, Go was created to address common challenges in software development, making it an excellent choice for developers who need a powerful yet easy-to-use language. Here's why Go is a fantastic programming language:

1. Simplicity and Readability

One of the most significant advantages of Go is its simplicity. Unlike many other languages that come with complex syntax and unnecessary features, Go focuses on keeping things straightforward. This simplicity makes Go easy to learn, read, and maintain, which is especially beneficial for teams and large-scale projects.

2. Fast Compilation and Execution

Go is a compiled language, meaning it translates code directly into machine code, resulting in fast execution. The Go compiler is incredibly efficient, enabling rapid compilation times that significantly boost development speed. This makes Go an excellent choice for performance-critical applications.

3. Built-in Concurrency Support

Concurrency is a first-class citizen in Go. With goroutines and channels, Go makes it easier than ever to write concurrent programs. Goroutines are lightweight threads managed by the Go runtime, allowing developers to efficiently handle multiple tasks at once without the complexity of traditional threading models.

4. Strong Standard Library

Go comes with a powerful standard library that covers a wide range of functionalities, including networking, file handling, and cryptography. The standard library is well-designed, reducing the need for third-party dependencies and ensuring consistency across projects.

5. Garbage Collection for Memory Management

Go's garbage collector ensures that developers don't have to manually manage memory, reducing the risk of memory leaks and improving application stability. The garbage collection mechanism is optimized for performance, making Go an excellent choice for applications that require efficient memory management.

6. Static Typing with Simplicity

Go is statically typed, which helps catch errors early in the development process. However, it avoids the verbosity of other statically typed languages, striking a balance between type safety and ease of use.

7. Excellent Tooling and Ecosystem

Go provides built-in tools for formatting, testing, and performance analysis. Features like go fmt, go test, and go vet streamline the development workflow, ensuring high code quality with minimal effort. The Go ecosystem also includes robust package management with go mod and a thriving community that continuously contributes to its growth.

8. Cross-Platform Compilation

Go's ability to compile applications for different platforms (Windows, Linux, macOS) with a simple command makes it an attractive choice for developers building cross-platform applications. This feature eliminates the need for complex build processes and ensures seamless deployment across various environments.

9. Cloud and Microservices-Friendly

Go is widely used in cloud computing and microservices architectures due to its efficiency and scalability. Many modern cloud-native platforms, including Kubernetes and Docker, are written in Go, showcasing its suitability for building scalable and high-performance services.

10. Backed by Google and a Strong Community

Go is backed by Google, ensuring ongoing support and continuous improvement. Additionally, the Go community is active and supportive, providing a wealth of resources, open-source projects, and forums where developers can collaborate and learn from one another.

Conclusion

Go is a powerful and pragmatic programming language that excels in simplicity, performance, and scalability. Whether you're building high-performance web services, cloud-native applications, or system-level utilities, Go provides the right balance of efficiency and ease of use. Its growing adoption in the tech industry is a testament to its strengths, making it a top choice for modern software development.

If you want to know more details about go features, see the repository and click on the star: https://github.com/leogregianin/go-is-good

Kubernetes: o que é, quando e como aplicá-lo

Leonardo Gregianin — Wed, 03 Jan 2024 18:08:00 +0000

O que é Kubernetes?

Kubernetes é uma plataforma de orquestração de contêineres de código aberto. Ele automatiza o deploy, a escalabilidade e o gerenciamento de aplicativos em contêineres.

Qual a sua origem?

O Kubernetes iniciou como um sistema interno de orquestração de contêineres no Google, chamado Borg, que gerenciava a implantação de milhares de aplicativos no Google. Em 2014, o Google abriu o código-fonte de uma versão do Borg e o denominou como Kubernetes, que em grego (κυβερνήτης) significa "timoneiro" ou "piloto" e agora é mantido pela Cloud Native Computing Foundation.

Porque alguns o chamam de K8S?

Esta é uma maneira um tanto nerd de abreviar palavras longas. O número 8 em K8S refere-se às oito letras entre a primeira letra K e a última letra S na palavra Kubernetes. Outros exemplos são I18N para internacionalização e L10N para localização.

Quais as principais peças de um cluster K8S?

Um cluster Kubernetes é um conjunto de máquinas chamadas "nós" que são usadas para executar aplicativos em contêineres. Existem duas peças principais em um cluster Kubernetes, vejamos:

O primeiro é o plano de controle ou control plane que é responsável por gerenciar o estado do cluster. Em ambientes de produção, o control plane geralmente é executado em vários nós que abrangem diversas zonas do data center. Em ambientes on-premisse você mesmo deve ter o controle sobre ele, em ambientes cloud providers como AWS, Google Cloud ou Azure, a própria cloud gerencia o control plane.
O segundo é um conjunto de nós de trabalho ou worker. Esses nós executam as cargas de trabalho de aplicativos em contêineres. Os aplicativos em contêineres são executados em um "pod". Os pods são as menores unidades de um cluster Kubernetes. Um pod hospeda um ou mais contêineres e fornece armazenamento compartilhado e rede para esses contêineres. Os pods são criados e gerenciados pelo control plane do Kubernetes. Eles são os blocos de construção básicos dos aplicativos Kubernetes.

Control Plane

Plano de Controle consiste em vários componentes principais. Eles são o Servidor API (API Server), o etcd, o agendador (Scheduler) e o gerenciador de controle (Controller Manager). O API Server é a principal interface de comunicação entre Control Plane e o restante do Cluster.

O Control Plane expõe uma API RESTful que permite aos clientes interagir com o Control Plane e enviar solicitações para gerenciar o cluster.

etcd é um armazenamento de chave-valor distribuído, ou seja, é o estado persistente do cluster. É utilizado pela API Server e outros componentes do Control Plane para armazenar e recuperar informações sobre o cluster.

O Scheduler é responsável por agendar pods nos nós dos workers do cluster. Ele usa informações sobre os recursos exigidos pelos pods e os recursos disponíveis nos nós do worker para tomar decisões.

O Controller Manager é responsável por executar controladores que gerenciam o estado do cluster, por exemplo, o controlador de réplicas, que garante que o número desejado de réplicas de um pod esteja em execução, e um controlador de deploy, que gerencia as atualizações contínuas e reversões de deploys.

Worker

Os principais componentes do Kubernetes executados nos worker nodes incluem kubelet, container runtime e o kubeproxy.

O kubelet é um daemon executado em cada worker node e é responsável pela comunicação com o Control Plane recebendo instruções de quais pods serão executados no nó e garante que o estado desejado dos pods seja mantido.

O Container runtime executa os contêineres nos worker nodes e é responsável por extrair as imagens dos contêineres de um registro, iniciar, parar e gerenciar os recursos dos contêineres.

O kubeproxy é um proxy de rede executado em cada wroker node e é responsável por rotear o tráfego para os pods corretos, realiza balanceamento de carga para os pods e garante que o tráfego seja distribuído uniformemente entre os pods.

Vantagens

Kubernetes é escalonável e altamente disponível, fornece recursos como autocorreção, reversões automáticas e dimensionamento horizontal. Isso torna mais fácil aumentar ou diminuir nosso aplicativo conforme necessário, permitindo-nos responder rapidamente às mudanças na demanda.

Kubernetes é portátil, nos ajuda a implantar e gerir aplicações de forma consistente e confiável, independentemente da infraestrutura. Ele é executado on-premise, em cloud ou em ambiente híbrido. Fornece uma maneira uniforme de empacotar, implantar e gerenciar aplicativos.

Desvantagens

A desvantagem número um é a complexidade. O Kubernetes é complexo de configurar e operar. O custo inicial é alto para formar uma equipe com conhecimento em orquestração de contêineres. Requer um alto nível de conhecimento e recursos para configurar e gerenciar um ambiente de produção do Kubernetes.

A segunda desvantagem é o custo. O Kubernetes requer um certo nível mínimo de recursos para funcionar, a fim de oferecer suporte a todos os recursos mencionados acima. Provavelmente é um exagero para aplicações menores.

Opção razoável

Uma opção popular que atinge um equilíbrio razoável é transferir o gerenciamento do control plane para um serviço gerenciado do Kubernetes em um cloud provider como Amazon EKS, GKE no Google Cloud e AKS no Azure. Esses serviços permitem que as organizações executem aplicativos Kubernetes sem se preocupar com a infraestrutura.

Eles cuidam de tarefas que exigem conhecimento profundo, como instalar e configurar o control plane, dimensionar o cluster e fornecer manutenção e suporte contínuos. Esta é uma opção razoável para uma organização de médio porte testar o Kubernetes.

Exemplo em código

Como exemplo, fizemos uma aplicação real chamada URL shorter, ou, Encurtador de URL que recebe uma URL e retorna um hash da URL original tornando uma URL curta, que ao ser acessada redireciona para a URL original e grava a quantidade de acessos a URL curta e a URL original.

Por exemplo, a URL de um dos meus artigos no Medium é essa: https://dev.to/leogregianin/python-e-facil-go-e-simples-simples-e-diferente-de-facil-5b9o e poderia ficar somente https://encurtador_de_url.com/abc123.

O objetivo é mostrar como é possível criar uma aplicação utilizando as melhores práticas de desenvolvimento e deploy, utilizando as tecnologias Django para backend e frontend, Django Rest Framework para API, Postgres como banco de dados e Docker e Kubernetes para containerização e orquestração do deploy.

URL shorter é uma aplicação pequena e é utilizada para fins didáticos de como construir uma aplicação e escalar ela utilizando Kubernetes.

Um único pod:

Escalando para 12 réplicas:

App rodando:

O código da aplicação e os arquivos de configuração do Docker e Kubernetes estão em: https://github.com/leogregianin/kubernetes-workshop

Python é fácil. Go é simples. Simples é diferente de fácil

Leonardo Gregianin — Tue, 12 Dec 2023 15:08:00 +0000

Tradução livre do artigo “Python is Easy. Go is Simple. Simple != Easy” escrito por Preslav Rachev no seu blog. O artigo original pode ser lido em: https://preslav.me/2023/11/27/python-is-easy-golang-is-simple-simple-is-not-easy/

Existe um equívoco comum de que simples e fácil se referem à mesma coisa. Afinal, se algo é fácil de usar, seu funcionamento interno deve ser simples de entender, certo? Ou vice-versa? Na verdade, é exatamente o oposto. Embora os dois conceitos apontem para o mesmo resultado, fazer algo parecer fácil requer uma enorme complexidade.

Tomemos como exemplo o Python, uma linguagem conhecida por sua baixa barreira de entrada e, portanto, uma escolha favorita para linguagem de programação de entrada. Escolas, universidades, centros de pesquisa e um grande número de empresas em todo o mundo escolheram Python precisamente por causa de sua acessibilidade a qualquer pessoa, independentemente do seu nível de educação ou formação acadêmica (ou total falta dela). Raramente é necessária muita teoria de tipos ou compreensão de como e onde as coisas são armazenadas na memória, em quais threads algum trecho de código está sendo executado, etc. Além disso, Python é a porta de entrada para algumas das mais profundas bibliotecas científicas e de nível de sistema. Ser capaz de controlar essa quantidade de poder com uma única linha de código fala muito a favor de que ela se torne uma das linguagens de programação mais populares do planeta.

E aí vem o problema: a facilidade de expressar coisas em código Python tem um custo. Por baixo dos panos, o interpretador Python é enorme e muitas operações devem ocorrer para que até mesmo uma única linha de código seja executada. Quando você ouve alguém se referindo ao Python como uma linguagem “lenta”, grande parte da “lentidão” percebida vem do número de decisões que o interpretador toma em tempo de execução. Mas esse nem é o maior problema, na minha opinião. A complexidade do ecossistema de tempo de execução do Python, juntamente com algumas decisões liberais de design em torno do gerenciamento de pacotes, cria um ambiente muito frágil, e as atualizações geralmente levam a incompatibilidades e travamentos de tempo de execução. Não é incomum deixar um aplicativo Python para voltar a ele depois de alguns meses, apenas para perceber que o ambiente mudou o suficiente para que não seja mais possível nem mesmo iniciar o aplicativo.

Claro, isso é uma simplificação grosseira, e até as crianças de hoje em dia sabem que existem contêineres para resolver problemas como esse. Na verdade, graças ao Docker e similares, é possível “congelar” as dependências de uma base de código Python no tempo para que ela possa praticamente rodar para sempre. No entanto, isso tem o custo de transferir a responsabilidade e a complexidade para a infraestrutura do sistema operacional. Não é o fim do mundo, mas também não é algo que deva ser subestimado e ignorado.

Da facilidade à simplicidade

Se resolvêssemos os problemas com Python, acabaríamos com algo como Rust — extremamente performático, mas com uma barreira de entrada notoriamente alta. A ferrugem, na minha opinião, não é fácil de usar e, o que é mais importante, não é simples. Embora esteja em alta hoje em dia, apesar de 20 anos de programação e de ter dado meus primeiros passos em C e C++, não posso olhar para um pedaço de código Rust e dizer com certeza que entendo o que está acontecendo lá.

Descobri Go há cerca de cinco anos, enquanto trabalhava em um sistema baseado em Python. Embora tenha levado algumas tentativas para gostar da sintaxe, imediatamente caí na ideia de simplicidade. O objetivo do Go é ser simples de entender por qualquer pessoa em uma organização — desde o desenvolvedor júnior recém-saído da escola até o gerente de engenharia de nível sênior que apenas ocasionalmente olha o código. Além do mais, sendo uma linguagem simples, Go raramente recebe atualizações de sintaxe — a última significativa foi a adição de genéricos na v1.18, o que ocorre somente após uma década de discussões sérias. Na maior parte, quer você observe o código Go escrito há cinco dias ou cinco anos, ele é basicamente o mesmo e deve funcionar.

A simplicidade requer disciplina. Pode parecer limitante e até um tanto retrógrado no início. Especialmente quando comparado a uma expressão sucinta, como uma lista ou compreensão de dicionário em Python:

temperatures = [
    {"city": "City1", "temp": 19},
    {"city": "City2", "temp": 22},
    {"city": "City3", "temp": 21},
]

filtered_temps = {
    entry["city"]: entry["temp"] for entry in temperatures if entry["temp"] > 20
}

O mesmo código em Go requer mais código, mas idealmente deve ser uma ideia mais próxima do que o interpretador Python está fazendo por baixo dos panos:

type CityTemperature struct {
    City string
    Temp float64
}

// ...

temperatures := []CityTemperature{
    {"City1", 19},
    {"City2", 22},
    {"City3", 21},
}

filteredTemps := make(map[string]float64)
for _, ct := range temperatures {
    if ct.Temp > 20 {
        filteredTemps[ct.City] = ct.Temp
    }
}

Embora você possa escrever código equivalente em Python, uma regra não escrita em programação diz que se a linguagem fornecer uma opção mais fácil (mais concisa, mais elegante), os programadores irão gravitar em torno dela. Mas fácil é subjetivo e simples deve ser igualmente aplicável a todos. A disponibilidade de alternativas para executar a mesma ação leva a diferentes estilos de programação, e muitas vezes é possível encontrar vários estilos na mesma base de código.

Como Go é prolixo e “chato”, ele naturalmente marca outra caixa — o compilador Go tem muito menos trabalho a fazer ao compilar um executável. Compilar e executar um aplicativo Go costuma ser tão rápido, ou até mais rápido, do que carregar o interpretador Python ou a máquina virtual Java antes mesmo de executar o aplicativo real. Não é de surpreender que ser um executável nativo seja tão rápido quanto um executável pode ser. Não é tão rápido quanto seus equivalentes em C/C++ ou Rust, mas com uma fração da complexidade do código. Estou disposto a negligenciar esta pequena “desvantagem” do Go. Por último, mas não menos importante, os binários Go são vinculados estaticamente, o que significa que você pode construir um em qualquer lugar e executá-lo no host de destino — sem quaisquer tempos de execução ou dependências de biblioteca. Por uma questão de conveniência, ainda agrupamos nossos aplicativos Go em contêineres Docker. Ainda assim, eles são significativamente menores e têm uma fração do consumo de memória e CPU de seus equivalentes Python ou Java.

Como usamos Python e Go a nosso favor

A solução mais pragmática que encontramos em nosso trabalho é combinar os poderes da facilidade do Python e da simplicidade do Go. Para nós, Python é um ótimo playground de prototipagem. É onde nascem as ideias e onde as hipóteses científicas são aceitas e rejeitadas. Python é uma escolha natural para ciência de dados e aprendizado de máquina e, como lidamos com muitas dessas coisas, não faz sentido tentar reinventar a roda com outra coisa. Python também tem o Django, que atende ao seu lema de permitir o desenvolvimento rápido de aplicativos como poucas outras ferramentas (é claro, Ruby on Rails e Elixir’s Phoenix merecem uma menção digna de nota aqui).

Suponha que um projeto precise de um mínimo de gerenciamento de usuários e administração interna de dados (como a maioria dos nossos projetos). Nesse caso, começaríamos com um esqueleto do Django por causa do seu Admin integrado, o que é fantástico. Uma vez que a prova de conceito com Django começa a se assemelhar a um produto, identificamos o quanto dele pode ser reescrito em Go. Como o aplicativo Django já definiu a estrutura do banco de dados e a aparência dos modelos de dados, escrever o código Go que o complementa é bastante fácil. Depois de algumas iterações, chegamos a uma simbiose, onde os dois lados coexistem pacificamente no mesmo banco de dados e usam mensagens básicas para se comunicarem. Eventualmente, o “shell” do Django se torna um orquestrador — ele serve aos nossos propósitos de administração e aciona tarefas que são então gerenciadas pela sua contraparte Go. A parte Go atende a todo o resto, desde APIs e endpoints até a lógica de negócios e processamento de trabalhos em background.

É uma simbiose que tem funcionado bem até agora e espero que continue assim no futuro. Em um post futuro, descreverei mais alguns detalhes sobre a arquitetura em si.

Obrigado por ler!