Em 2007, alguns dos programadores do Google analisaram suas opções para escrever software e não gostaram do que viram. Eles precisavam gerenciar milhões de linhas de código que estariam constantemente armazenando e enviando dados para a world wide web. O código faria malabarismos com milhares ou talvez milhões de conexões em redes por todo o globo. Os caminhos de dados estavam cheios de desafios de casos de corrida e simultaneidade.
As linguagens de programação existentes não ajudavam muito. Elas foram criadas para jogos ou gerenciamento de desktops, ou muitas das outras tarefas comuns de um mundo antes do navegador da web. Suas arestas e modos de falha deixaram os programadores do Google loucos o suficiente para começarem a perguntar se poderia haver uma maneira melhor. Havia algo que pudesse lidar com as tarefas de E/S em apenas algumas linhas com toda a segurança de que o Google precisava?
A resposta para essa pergunta foi não. E então eles criaram Golang, uma linguagem simples que é superficialmente similar a C ou Java. As versões públicas começaram a aparecer em 2009 e a primeira versão 1.0 foi lançada em 2012. Hoje, o Google continua investindo na linguagem, e a versão estável mais recente no momento em que este texto foi escrito é 1.22.5.
Dentro do Google, a linguagem Go alimenta grandes blocos da infraestrutura, e também foi adotada por muitos programadores fora do Google. A linguagem recentemente subiu para o top 10 do índice Tiobe. Ela está na oitava posição no momento em que este texto foi escrito.
Toda essa fortuna escandalosa rendeu muitos aplausos — mas também algumas pedras e flechas. Em muitos casos, os mesmos recursos trazem tanto menosprezo quanto elogios. O que alguns desenvolvedores amam no Go, outros odeiam tanto quanto.
8 razões pelas quais os desenvolvedores amam ou odeiam a linguagem Go
- É fácil aprender
- Não tem favoritos
- A sintaxe baseada em C
- (Muitas) regras
- Tratamento de erros extra
- A biblioteca padrão
- O tamanho do executável
- Grande pai Google
Go é fácil de aprender
Os designers do Go criaram deliberadamente uma linguagem que seria rápida de aprender, porque não tinha muitos recursos complexos ou idiossincrasias. Em vez de adicionar sinos e apitos ao Go, eles escolheram despojar a linguagem, perto do mínimo necessário para realizar seu trabalho no Google. Isso significava dizer “não” a boas ideias e focar em uma visão idealizada do que os programadores deveriam precisar.
Por que alguns amam isso: Uma linguagem mais simples é mais fácil para novos programadores e membros da equipe aprenderem. Há menos recursos ou construções para dominar e isso significa que programadores habilidosos podem aprender a linguagem em um dia. A equipe de projetos é mais fácil porque cachorros velhos podem aprender os novos truques do Go rapidamente. Não só isso, mas o código é frequentemente mais fácil de ler, mesmo porque não há estruturas estranhas ou arcanas que aparecem em lugares estranhos.
Por que alguns odeiam isso: Simples não é necessariamente ruim, é apenas o que foi deixado de fora. Uma bruxa escolheria um livro de feitiços resumido? Um quarterback escolheria um playbook com apenas algumas jogadas? Alguns programadores acham que programar com Go é como programar com uma mão amarrada nas costas. A linguagem não tem toda a inteligência que outros designers de linguagem entregaram ao mundo, e esse é um preço alto a pagar.
Go não tem favoritos
Os desenvolvedores originais queriam criar uma linguagem pequena, e fizeram isso às custas de muitos recursos favoritos encontrados em outras linguagens. Go é uma linguagem simplificada. Ela faz o que você precisa, mas evita os sinos e assobios.
Por que alguns amam isso: Muitos desenvolvedores elogiam a simplicidade do Go. O Go não exige que eles ganhem ou mantenham expertise em dezenas de recursos para serem proficientes. Se eles lerem algum código, não descobrirão construções que nunca viram antes.
Por que alguns odeiam isso: Todo mundo tem alguns recursos e truques favoritos, mas as chances são de que Go não os ofereça. Desenvolvedores às vezes reclamam que poderiam realizar a mesma coisa que fariam em Go com apenas uma linha de COBOL ou Java, ou alguma outra linguagem favorita.
Sintaxe baseada em C
Os criadores do Go têm raízes profundas no mundo do Unix, e isso fica evidente. A sintaxe é bem familiar para qualquer um que tenha usado C ou qualquer uma das linguagens como Java ou C# que tomaram emprestado do C. As chaves e a digitação do Go serão confortáveis para essa equipe. A equipe de design removeu algumas das arestas do C tradicional e simplificou alguns dos detalhes para que parecesse e fosse mais moderno, mas, na maior parte, o Golang se encaixa perfeitamente na tradição que começou com o C.
Por que alguns amam isso: Programadores que cresceram com o estilo C entenderão intuitivamente muito do Go. Eles serão capazes de aprender a sintaxe muito rapidamente e podem passar seu tempo aprendendo as poucas maneiras como o Go limpou alguns dos cantos irritantes do C ou Java. O que há para não amar?
Por que alguns odeiam isso: De muitas maneiras, Python foi projetado para ser a antítese de C. Não há sinais de pontuação para delinear blocos de código e a digitação é deliberadamente dinâmica. Qualquer um que ame a abordagem Python encontrará muito o que não gostar em Go. Dessa perspectiva, programar com Go parece um ou três passos para trás.
Go tem (muitas) regras
Desde o início, os criadores do Go queriam definir não apenas a sintaxe, mas também muito do estilo e dos padrões de uso da linguagem. Eles produziram, por exemplo, uma biblioteca de formatação padrão para desencorajar batalhas sobre a maneira correta de recuar o código Go. Eles fizeram a curadoria de listas de expressões idiomáticas e encorajaram os programadores a usar as melhores. Eles também baniram explicitamente alguns hábitos que são meramente desaprovados por outras linguagens, como variáveis não utilizadas ou dependências cíclicas. O processo de construção do Go é programado para parar quando descobre esses elementos na base de código.
Por que alguns amam isso: As regras fortemente idiomáticas do Go garantem que o código será mais fácil de entender. As equipes terão menos brigas sobre estilo porque há menos opções ou motivos para evoluir seu próprio estilo pessoal.
Por que alguns odeiam isso: Todas essas regras e convenções extras parecem uma camisa de força. Por que uma variável não utilizada é um problema? Se o compilador pode detectá-la, ele pode removê-la sem me incomodar. É tão ruim para os programadores terem um pouco de liberdade em suas vidas?
Go tem tratamento de erros extra
Grande parte da programação moderna inclui a construção de caminhos extras para o código tomar quando os erros aparecem. O código roda normalmente até que algo dê errado. Quando um erro acontece, ele deve se recuperar. Ele pode apenas pausar um pouco, ou pode desistir completamente. Construir sistemas automatizados requer a introspecção para saber quando as coisas estão funcionando ou falhando.
Go adota uma abordagem inovadora ao encorajar os programadores a escrever dois caminhos para a mesma função. Um bom código Go explica tanto a abordagem normal quanto o que deve acontecer quando um erro surge. Os programadores Go gostam de dizer que “erros são valores regulares” porque eles são parte do mesmo código. Há até mesmo um sistema de tipos separado para erros que permite aos programadores criar formas mais específicas de erros e, em seguida, explicar como eles devem ser tratados.
Por que alguns amam isso: A abordagem Go reconhece que erros existem e encoraja o programador a fazer um plano para lidar com eles. Isso encoraja os programadores a planejar com antecedência e construir o tipo de resiliência que resulta em um software melhor.
Por que alguns odeiam isso: O tratamento desnecessário de erros torna as funções Go mais gordas e difíceis de entender. Frequentemente, cada função em uma cadeia profunda deve incluir código similar que esteja fazendo mais ou menos a mesma coisa com o mesmo erro. Outras linguagens como Java ou Python encorajam os programadores a “jogar” os erros na cadeia para um bloco específico que irá “capturá-los”, o que pode resultar em um código mais limpo.
A biblioteca padrão
Não é apenas a sintaxe do Go que foi projetada para ser um padrão simples, mas poderoso, que une as equipes. A biblioteca padrão inclui suporte para muitas das principais tarefas comuns para programação de microsserviços baseados na web. As rotinas de entrada e saída começam com malabarismo de pacotes de rede de baixo nível e lidam com todas as tarefas de complexidade crescente, como lidar com o protocolo HTTPS ou decodificar dados JSON. Configurar um servidor web completo leva apenas algumas linhas de código porque tudo está incluído no “net/http“parte da biblioteca.
Por que alguns amam isso:Quando muitos dos recursos padrão são manipulados pela biblioteca padrão, a maior parte do código é mais fácil de ler porque ninguém está escrevendo sua própria versão ou discutindo sobre qual pacote ou biblioteca de terceiros é melhor.
Por que alguns odeiam isso: É difícil reclamar de uma pilha tão boa de código, mas os rabugentos gostam de apontar que a competição é um bom indicador de demanda e inovação. O fato de algumas linguagens suportarem múltiplos pacotes lidando com a mesma tarefa indica um interesse profundo e uma cultura rica.
O tamanho do executável
Um dos objetivos da equipe Go era facilitar a implantação de programas Go e eles conseguiram isso agrupando tudo em um executável. Tudo está pronto para rodar porque todas as rotinas de biblioteca do Go estão incluídas na compilação padrão.
Ao longo dos anos, desenvolvedores que não gostam de executáveis com dezenas ou até centenas de megabytes de tamanho encontraram maneiras de remover as partes desnecessárias. Dá um pouco mais de trabalho definir os sinalizadores corretos e incluir etapas extras no processo de construção, mas pode ser feito.
Por que alguns amam isso: Espaço em disco é barato. Implantar código em locais estranhos pode ser um pesadelo quando versões diferentes de bibliotecas são instaladas. Desenvolvedores Go nos economizam muito tempo construindo apenas um arquivo executável.
Por que alguns odeiam isso: Quantas cópias das bibliotecas Go estão no meu disco? Se eu tiver 100 programas, isso significa 100 cópias. Em algum momento, a eficiência é uma consideração. Sim, o espaço em disco está mais barato do que nunca, mas a largura de banda da memória e o cache continuam sendo os principais problemas para a velocidade de execução.
Grande pai Google
O Golang foi desenvolvido no Google e a grande empresa continua sendo uma de suas principais apoiadoras, enviando o compilador e grande parte da cadeia de ferramentas. Há algum suporte de fora do Google, como o GopherJS, um transpilador que transforma Go em JavaScript. Mas, na maior parte, muito do esforço de desenvolvimento do Go vem diretamente de dentro do Google.
Por que alguns amam isso: Uma grande parte do trabalho hoje envolve escrever código para as constelações de servidores e clientes, o mesmo tipo que é uma parte tão grande da carga de trabalho do Google. Se Go é bom para o Google, também é bom para aqueles de nós que estão trabalhando da mesma forma. Se os engenheiros do Google construíram algo que eles amariam, qualquer um com projetos semelhantes amará da mesma forma.
Por que alguns odeiam isso: Não é que as pessoas não gostem do Google em si, é só que os programadores desconfiam de autoridades centralizadas. Problemas como bloqueio de fornecedor e falta de controle são questões sérias para qualquer um que esteja tentando curar uma pilha de tecnologia. Toda a generosidade do Google ainda deixa os programadores desconfiados, especialmente quando outras opções de linguagem têm grandes comunidades de código aberto construídas em torno delas.
