Go 1.26: O 'go fix' Renascido para Modernizar seu Código Go

Apresentadora: E aí, pessoal, bem-vindos de volta ao Allur! Eu sou a Juliana Santos e hoje a gente vai mergulhar no ecossistema de uma linguagem que a gente adora aqui no programa: o Go. Sabe aquele sentimento de pegar um projeto de três, quatro anos atrás e sentir que o código parece... sei lá, "antigo"? Mesmo que ele funcione perfeitamente, os padrões mudaram, a linguagem evoluiu e aquele código que era o estado da arte agora parece um pouco datado. O grande desafio de toda tecnologia que escala rápido, como o Go, é justamente esse: como manter as nossas bases de código modernas sem gastar meses em refatoração manual? Bom, a versão 1.26 do Go trouxe uma resposta que deixou muita gente animada: o renascimento do `go fix`. Hoje vamos entender como essa ferramenta, que já era uma velha conhecida, foi revitalizada para se tornar um modernizador automático de código, inclusive ajudando a limpar aquela "sujeirinha" que as IAs às vezes deixam pra trás. E para falar sobre isso, eu trouxe um convidado que respira Go no dia a dia. Apresentadora: Hoje, eu tenho o prazer de receber aqui no Allur o Rafael Silveira. O Rafa é Engenheiro de Software Sênior na Stone, tem anos de experiência escalando microsserviços em Go e é um entusiasta ferrenho da simplicidade da linguagem. Rafa, seja muito bem-vindo ao Allur, cara! Muito massa ter você aqui. Convidado: Valeu, Juliana! O prazer é todo meu. Sou fã do Allur e fico felizão de vir aqui falar de Go, que é uma das minhas paixões. E o tema de hoje é quente, né? Porque código legado é o que não falta por aí, e o Go 1.26 chegou com o pé na porta nessa questão. Apresentadora: Com certeza! E Rafa, pra gente começar do começo: o `go fix` não é exatamente uma novidade, né? Ele já estava lá no nosso kit de ferramentas. Mas por que agora ele está sendo chamado de "revitalizado"? O que mudou de fato nessa versão 1.26? Convidado: Pois é, Ju. O `go fix` é tipo aquele herói das antigas que estava meio aposentado. No começo do Go, lá atrás, ele servia basicamente pra consertar o código quando a linguagem mudava de forma drástica e quebrava a compatibilidade. Só que o Go estabilizou muito, a promessa de compatibilidade da versão 1.0 é levada muito a sério. Então o `go fix` acabou ficando ali no cantinho, sabe? Mas agora, no Go 1.26, a equipe do Google deu um novo propósito pra ele. Ele não serve mais só pra "consertar o que quebrou", mas sim pra "modernizar o que ficou velho". Ele ficou muito mais inteligente. Ele identifica padrões que hoje são considerados menos eficientes ou menos legíveis e sugere — ou já aplica — a nova forma de escrever aquilo. Apresentadora: Cara, isso é muito massa! Porque a gente sabe que o desenvolvedor no dia a dia dificilmente tem tempo de voltar num código que está funcionando só pra deixar ele "mais bonito" ou "mais idiomático". O `go fix` então vira um aliado da produtividade, né? Convidado: Total! Tipo assim, pensa numa empresa com centenas de repositórios. É impossível você passar em todos atualizando, por exemplo, a forma como você itera em funções, que é uma das grandes novidades recentes. O `go fix` automatiza esse processo tedioso. E tem um ponto que você citou na intro que é fundamental: a inteligência artificial. Hoje a gente usa muito Copilot, ChatGPT para gerar código. Só que essas IAs, às vezes, foram treinadas com códigos de 2018, 2019... Elas cospem um código que funciona, mas que não usa as facilidades das versões mais novas do Go. O novo `go fix` entra como um filtro de qualidade final, garantindo que até o código gerado por IA esteja seguindo as melhores práticas de 2025. Apresentadora: Nossa, perfeito! Você tocou num ponto sensível. Eu sinto que às vezes a IA me dá umas soluções que parecem um "Go das cavernas" (risos). Mas fala pra gente de um exemplo prático. Eu li algo sobre os iteradores *Range-over-Function*. Como o `go fix` lida com isso? Convidado: Esse é o melhor exemplo, Ju! Pra quem não está ligado, nas versões mais recentes, o Go introduziu uma forma muito mais elegante de criar iteradores personalizados. Antes, se você queria iterar sobre uma estrutura de dados complexa, você tinha que criar umas gambiarras ou usar *callbacks* que deixavam o código meio poluído. Agora, com os iteradores nativos, o seu `for range` ficou muito mais poderoso. O que o `go fix` do 1.26 faz é olhar para aqueles seus padrões antigos de repetição e falar: "Ei, isso aqui pode virar um iterador moderno". Ele refatora a estrutura pra você. É quase como ter um desenvolvedor sênior fazendo um *code review* automático e já aplicando o *commit* de melhoria. Apresentadora: Que incrível! Mas vem cá, Rafa, eu sou uma pessoa um pouco desconfiada com automação (risos). Existe o risco desse "fix" quebrar alguma coisa? Ou a ferramenta é conservadora o suficiente pra gente confiar cegamente? Convidado: (Risos) Olha, o ceticismo é a maior virtude de um programador, né? Mas a galera do Go é muito rigorosa. O `go fix` foca em transformações que são semanticamente equivalentes. Ou seja, ele só muda a forma de escrever se ele tiver certeza que o comportamento final do programa vai ser exatamente o mesmo. Claro, a gente sempre recomenda rodar a suíte de testes depois, o que é básico, né? Mas a confiança é alta porque a ferramenta entende a árvore sintática do código, ela não faz apenas uma busca e troca de texto burra. Apresentadora: Entendi. É uma análise estrutural mesmo. E Rafa, pra quem tá ouvindo a gente e quer começar a usar isso hoje, qual é o fluxo? É só rodar um comando no terminal e pronto? Convidado: Basicamente, sim! Se você já está com o Go 1.26 instalado, você roda um `go fix ./...` no seu projeto e ele vai analisar tudo. Uma dica legal é usar a flag de *diff* antes, pra você ver o que ele pretende mudar. Aí você analisa, aprende com a ferramenta — porque ela acaba sendo uma professora de Go moderno — e depois aplica. No dia a dia de uma equipe, o ideal é até colocar isso no seu pipeline de CI/CD ou num *pre-commit hook*. Assim, nenhum código "vovô" entra no seu repositório principal. Apresentadora: "Código vovô" é ótimo! (risos). Muito bom, Rafa. Cara, papo sensacional. Eu acho que isso tira um peso enorme das costas de quem mantém grandes sistemas. Em vez de lutar contra a evolução da linguagem, a gente abraça ela com ajuda da própria ferramenta. Convidado: Exatamente, Ju. O Go sempre foi sobre simplicidade e manutenção a longo prazo. O `go fix` revitalizado é só a prova de que a equipe do Go quer que a gente foque no problema de negócio, e deixe a "faxina" do código pra eles. Apresentadora: Com certeza! Bom, a lição de hoje é clara: não deixem seu código Go virar uma peça de museu. O Go 1.26 está aí, o `go fix` está mais forte do que nunca, então deem uma chance pra ele. Se você quiser saber mais, a documentação oficial do Go 1.26 tem todos os detalhes técnicos dessas transformações. Rafa, muito obrigada por compartilhar sua experiência com a gente hoje, foi massa demais! Convidado: Valeu, Juliana! Valeu, galera. Até a próxima e bons fixes pra todo mundo! Apresentadora: É isso aí! Valeu por sintonizar o Allur, o seu podcast de tecnologia. Não esquece de seguir a gente nas redes sociais e assinar o feed pra não perder nenhum episódio sobre Go, Laravel, e tudo que há de novo no mundo dev. Até a próxima, tchau!