Introdução

Desenvolvedores da Web vindos de um background puramente JavaScript escolheriam naturalmente o Node.js como sua linguagem de back-end preferida. Como um ambiente de tempo de execução baseado em JavaScript, ele representa o caminho mais fácil para os desenvolvedores de front-end codificarem a funcionalidade de back-end. Hoje em dia, porém, existem muitas opções para desenvolvedores de front-end que buscam uma pilha completa.

Devido aos seus paradigmas e filosofia, a linguagem de programação Go pode não vir à mente como uma escolha principal. Como tal, os desenvolvedores de front-end podem evitar pegá-lo, especialmente aqueles que estão apenas entrando no desenvolvimento de pilha completa.

Neste artigo, exploraremos esses paradigmas e recursos e por que vale a pena dar o Go um tiro para desenvolvimento web back-end/full-stack. Também exploraremos alguns novos padrões, a experiência do desenvolvedor de Go e o que esperar de um desenvolvedor de front-end escolhendo Go pela primeira vez.

Casos de uso para Go

Todas as linguagens de programação foram criadas para abordar um conjunto de casos de uso ou resolver problemas específicos. Go brilha em áreas onde a eficiência e o desempenho são as principais prioridades, pois pode ser compilado rapidamente em código de máquina. Portanto, não requer um intérprete ou uma máquina virtual.

Graças aos seus recursos de compilação, o código Go pode ser facilmente implantado em uma infraestrutura de servidor e atualizado em várias instalações de acordo. Ele também oferece suporte a várias arquiteturas de sistema operacional e processador, o que é realmente um grande benefício.

Além disso, Go se tornou a linguagem preferida para software de infraestrutura de código aberto, com alguns dos maiores e mais populares projetos sendo escritos inteiramente em Go. Docker, por exemplo, é escrito inteiramente em Go.

Outra das grandes coisas sobre Go é que ele dá ao programador um controle considerável sobre o layout e alocação de memória-muito mais do que é típico em outras linguagens coletadas de lixo.

Go implementa coleta de lixo, simultaneidade, gerenciamento de pilha e assim por diante por meio de seu sistema de tempo de execução. A coleta de lixo automática torna o código simultâneo muito mais fácil de escrever, e Go resolveu esse problema do desenvolvedor no nível de design de linguagem com sua capacidade de gerenciar adequadamente a memória alocada.

Na verdade, o design da linguagem influencia diretamente a facilidade de uso e a rapidez com que podemos construir um POC para nossos projetos. Go brilha nesse aspecto com um conjunto de recursos exclusivos destinados a aplicativos altamente resilientes e escaláveis.

A seguir, exploraremos a simultaneidade, um recurso muito importante e muito falado no Go-especialmente para desenvolvedores que estão acostumados com a natureza síncrona do JavaScript.

Simultaneidade: um recurso fundamental do Go

A simultaneidade permite que um programa organize sua execução em vários fluxos separados e comunique ações ou atividades entre eles. As técnicas de programação simultânea são uma boa maneira de usar a CPU com eficiência e melhorar o desempenho do aplicativo. É um recurso essencial para aplicativos de escala empresarial ou aplicativos que precisam lidar com milhares de solicitações simultaneamente.

A simultaneidade é construída no núcleo da própria linguagem Go por meio de goroutines e canais. Basicamente, as goroutines permitem que os aplicativos executem várias tarefas simultaneamente. Eles são threads de execução baratos e leves. Isso proporciona à linguagem um melhor desempenho em termos de taxa de transferência, latência e confiabilidade.

Se você tentou implementar simultaneidade em outras linguagens de programação, especialmente JavaScript , você entende que é bastante complexo fazer isso. Em contraste, gerar uma goroutine é tão simples quanto adicionar a palavra-chave go antes de uma função. Vejamos um exemplo abaixo.

 import"fmt" pacote principal func doSomething (str sting) { para i:=1; i <=3; i ++ { fmt.Printf ("% s:% d", str, i) }
} func main () { //chamando esta função da maneira normal doSomething ("Hello") //Executando dentro de uma rotina go vá fazer alguma coisa ("Mundo") go func () { fmt.Print ("Rotinas Go são fantásticas") } ()
}
//adiciona valor de retorno para func 

Como mencionamos anteriormente, as primitivas de simultaneidade Go por meio de goroutines e canais facilitam a programação simultânea. A capacidade de tirar proveito de sua arquitetura de processador multicore e memória eficiente estão entre os principais motivos pelos quais o código Go está executando alguns dos aplicativos mais usados ​​atualmente.

Na verdade, de acordo com seu site , Go foi construído para sistemas em rede para desempenho avançado e uso total de máquinas com vários núcleos:

“Isso significa que todo programa Go vem com ferramentas já integradas que podem fazer com que os programas que escrevemos tenham um desempenho melhor, se utilizados adequadamente pelos desenvolvedores.”

Observe que, paradoxalmente, pode haver apenas uma thread em um programa, mas milhares de goroutines. Se qualquer goroutine naquele thread bloquear, digamos, aguardando a entrada do usuário, outro thread do sistema operacional será criado e as goroutinas restantes serão movidas para o novo thread do sistema operacional. Tudo isso é cuidado pelo tempo de execução e nós, como programadores, somos abstraídos desses detalhes intrincados, pois temos uma API limpa para trabalhar.

Claro, realizar ações em um goroutine significa que ele precisará ser capaz de se comunicar com outros goroutines. Para fazer isso, Go fornece canais.

Os canais são conduítes que permitem que duas goroutines simultâneas se comuniquem, enviando e recebendo valores. A sintaxe channel <- pode ser usada para enviar um valor para um canal, enquanto a sintaxe <-channel pode ser usada para ler algo de um canal, assim:

 pacote principal
importar"fmt"
func main () {
//faça um novo canal
mensagens:=make (string chan)
go func () {
//escrever para o canal
mensagem <-"Olá, mundo!"
} ()
//ler do canal
mensagem:=<-mensagens
fmt.Printf ("Recebi a mensagem% s", mensagem)
} 

N.B. , ao ler de um canal, nós o bloqueamos até recebermos uma mensagem. O emissor e o receptor devem estar prontos; ou seja, não podemos enviar até que haja um receptor correspondente para esse canal.

Por que os desenvolvedores de front-end devem aprender Go

Para os novatos em Go, criar aplicativos básicos é uma brisa e também é igualmente simples começar e desenvolver algo rapidamente. Go foi projetado para ser desta forma: ele tem uma velocidade de compilação muito alta, suporte imediato para recursos como simultaneidade e coleta de lixo e, é claro, Go tem uma sintaxe muito simples e clara.

Se você está acostumado com o estilo de programação orientado a objetos, encontrará conceitos familiares em Go. Possui tipos e métodos na forma de estruturas , que podem permitir um objeto-estilo de programação orientado. Não há hierarquias de tipo; os métodos em Go são mais gerais porque podem ser definidos para qualquer tipo de dados, até mesmo tipos integrados.

As estruturas têm métodos e propriedades, semelhantes a classes em linguagens de programação orientadas a objetos típicas. Por exemplo:

trabalhador do pacote

 importar"fmt" tipo Person struct { String de nome Idade interna
} função (p * Person) Talk (frase string) { return fmt.Sprintf ("% s diz:% s", p.Nome, frase)
} 

Aqui, Person é um tipo de struct com os campos Name e A``ge . Talk é um método definido na estrutura Person que imprime algo. Podemos usar isso como:

 pessoa:=& Pessoa {"Vivan", 22}
pessoa.Talk ("Go is awesome") 

Vamos detalhar alguns outros motivos pelos quais Go mostrou um rápido crescimento em popularidade nos últimos anos, e por que os desenvolvedores de front-end que procuram uma pilha completa devem escolher Go.

Fácil gerenciamento de pacotes

Os programas Go são construídos a partir de pacotes , cujas propriedades permitem o gerenciamento eficiente de dependências. O conjunto de ferramentas Go possui um sistema integrado para gerenciar conjuntos com versão de pacotes relacionados, conhecidos como módulos. Os módulos foram introduzidos no Go 1.11 e estão prontos para uso em produção desde 1.14 .

Para criar um projeto usando módulos, execute go mod init . Este comando cria um arquivo go.mod que rastreia as versões de dependência. Para adicionar, fazer upgrade ou downgrade de uma dependência, execute go get -por exemplo, go get golang.org/x/[email protected] . Consulte o site oficial do Go para obter mais informações sobre como criar um módulo e guias adicionais sobre gerenciando dependências com módulos .

Menos construções de linguagem e palavras-chave

Menos construções e palavras-chave significam que é fácil pegar Go e ser produtivo em um curto espaço de tempo. Go é semelhante a C em termos de velocidade e sintaxe. Tem cerca de 25 palavras-chave, facilitando a escrita e, no geral, é uma linguagem clara e simples que permite aos desenvolvedores escrever código legível e sustentável.

A linguagem restringe a maneira como você pode fazer algumas coisas, embora esse compromisso na flexibilidade produza maior simplicidade. Isso pode significar escrever um pouco mais de código, mas existem soluções claras. Go força a consistência, o que contribui para sua legibilidade e manutenção.

Go é opinativo e recomenda uma forma idiomática de realizar coisas. Eles vêm diretamente da equipe Go com base no design da linguagem; Effective Go mostra alguns deles. Ele favorece a composição em vez da herança, e seu sistema de tipos é elegante e permite que comportamentos sejam adicionados ou recursos estendidos para se adequar a um caso de uso específico sem acoplar fortemente os componentes.

Ao contrário de outras linguagens, Go prioriza a legibilidade e a manutenção. Os criadores do Go adicionaram à linguagem apenas os recursos que são relevantes e não tornam a linguagem complexa.

Novas adições à biblioteca padrão são raras, por exemplo, e a barreira para inclusão é alta. Os criadores argumentaram que o código incluído na biblioteca padrão tem um grande custo de manutenção contínua. A biblioteca padrão Go está sujeita à promessa de compatibilidade do Go 1 (bloqueio de correções para quaisquer falhas na API) e ao Go cronograma de lançamento .

Isso evita que as correções de bugs na biblioteca padrão sejam disponibilizadas aos usuários rapidamente. Como resultado, o novo código deve residir fora da biblioteca padrão e ser acessível por meio do go get comando. Esse código pode ter seus próprios mantenedores, ciclo de lançamento e garantias de compatibilidade.

NB , os usuários podem descobrir mais sobre os pacotes e ler sua documentação em godoc.org .

Como outro exemplo para demonstrar os recursos bem pensados ​​da linguagem, quando um nome de função em um pacote Go começa com uma letra maiúscula, isso significa que pode ser exportado, enquanto todas as funções com nomes em minúsculas não podem. E por último, mas não menos importante, Go agora oferece suporte a genéricos .

Tipo forte por padrão

Go é uma linguagem com tipagem estática. O compilador trabalha muito para garantir que o código não apenas compile corretamente, mas que as conversões de tipo e a compatibilidade também sejam cuidadas. Isso ajuda a evitar os problemas que você enfrenta em linguagens digitadas dinamicamente como JavaScript, em que você descobre os problemas apenas quando o código é executado.

Análise de código estático

Go depende muito da análise de código estático. Os exemplos incluem godoc para documentação, gofmt para formatação de código, golint para linting de estilo de código e muitos outros. A análise de código estático dá ao desenvolvedor uma sensação de segurança e paz de espírito ao fazer as coisas.

Utilitários de teste de código embutidos

O teste é uma obrigação para qualquer programa, então você deve adicionar funções de teste junto com as funções reais cada vez que você escreve um código. Go fornece um mecanismo simples para escrever testes de unidade em paralelo com o código, o que torna a escrita de testes muito fácil.

O conjunto de ferramentas também fornece suporte para entender a cobertura de código por seus testes, testes de comparação e escrever código de exemplo que é usado na geração de documentação de código.

Para criar um arquivo de teste, crie um novo arquivo terminando em _test.go no mesmo diretório que as fontes do seu pacote. Dentro desse arquivo, importe teste e grave funções do formulário. Podemos executar go test nesse mesmo diretório. O script encontra as funções de teste, cria um binário de teste e o executa.

 func TestFoo (t * testing.T) { } 

N.B. , Go fornece uma maneira de testar os pacotes que você escreve. Com apenas o comando go test , você pode testar o código escrito em qualquer arquivo * _test.go .

Desempenho

À medida que você começa a criar aplicativos de qualidade de produção, o Go aumenta perfeitamente. Seja um pequeno microsserviço ou um aplicativo corporativo extenso, Go oferece desempenho superior.

Os recursos do Go que contribuem para seu nível geral de desempenho incluem simultaneidade, otimizações de compilador, E/S sem bloqueio, mecanismos de armazenamento eficientes para valores, seu sistema de tempo de execução e outros. Go não tem máquina virtual e compila em código de máquina, então os programas são executados rapidamente.

Como mencionamos anteriormente, Go tem um coletor de lixo embutido que monitora e identifica a memória ocupada que não é mais necessária e a libera para reutilização. Isso reduz o risco de vulnerabilidades de segurança devido ao encapsulamento de código e também fornece um gerenciamento de memória eficaz.

Mecanismo de modelagem HTML integrado

Go vem com um mecanismo de modelagem HTML integrado, que pode ser encontrado no pacote html/template . A sintaxe não é intuitiva no início, especialmente vindo de um plano de fundo de front-end, mas na verdade é bem simples e faz o trabalho perfeitamente.

Grandes equipes podem oferecer suporte facilmente a aplicativos Go

O código Go tem uma sintaxe clara e organizada e requer pouco esforço para aprender, então os desenvolvedores com quem você já trabalha podem aprender tudo o que precisam em apenas alguns dias. Isso também ajudará os desenvolvedores a oferecer suporte facilmente aos aplicativos existentes.

Além disso, Go tem vários cursos online disponíveis e muitas ferramentas para trabalhar, incluindo documentação automática, análise de código estático, ambiente de teste integrado, detecção de condição de corrida e assim por diante.

Outro recurso interessante do Go é que ele se recusa a compilar programas com variáveis ​​ou importações não utilizadas, trocando a conveniência de curto prazo por velocidade de construção de longo prazo e clareza do programa. A presença de uma variável não utilizada pode indicar um bug, enquanto as importações não utilizadas apenas tornam a compilação mais lenta, um efeito que pode se tornar substancial à medida que um programa acumula código (e mais desenvolvedores) ao longo do tempo.

Como você pode ver, o Go oferece uma série de vantagens tanto para os desenvolvedores quanto para as partes interessadas nos negócios. Esse é um dos motivos pelos quais o idioma recentemente aumentou sua popularidade Go não é uma linguagem perfeita ainda, no entanto. Você deve considerar as desvantagens do Go antes de decidir usá-lo em seu projeto.

Pensamentos finais

O Projeto Go não é apenas a especificação da linguagem, mas também uma cadeia de ferramentas e um ecossistema que consiste em bibliotecas padrão e bibliotecas externas terceirizadas fornecidas por organizações e indivíduos. O principal motivo por trás da criação da linguagem foi ajudar a gerenciar grandes bases de código e melhorar a produtividade do desenvolvedor.

Go tem visto uma adoção significativa de grandes projetos e, graças às suas ferramentas, ecossistema e design de linguagem, os programadores estão se movendo constantemente em direção a ele, especialmente para construir uma infraestrutura grande e altamente escalável. Começar com Go é simples para qualquer desenvolvedor de experiência, e a página inicial Go tem instruções sobre tudo, desde instalar o conjunto de ferramentas até aprendizagem sobre Go em geral.

Go também é uma linguagem simples, mas opinativa. Sua inferência automática de tipo é bastante semelhante à de linguagens dinâmicas, portanto, oferece uma sensação familiar para desenvolvedores de JavaScript. Além disso, a documentação automática do Go nos permite ter o código documentado automaticamente no mesmo nível de qualidade que a biblioteca padrão e APIs integradas.

Por último, com a biblioteca padrão forte, ela é incrível na criação de APIs/back-ends. Go também é multiplataforma-é executado em Linux, macOS e Windows-e vem integrado com ferramentas úteis para linting de código, geração de código, construção, teste e muito mais.

Para obter mais detalhes sobre por que os desenvolvedores de front-end que estão mudando para full-stack devem escolher Go, verifique a página de perguntas frequentes da documentação de Go . Obrigado!

A postagem Primeiros passos com Go para desenvolvedores de front-end apareceu primeiro no LogRocket Blog .

Source link