Go: A linguagem que mais cresce para backend
Go foi projetado pelo Google em 2007 para melhorar a produtividade de programação em uma era de multicore, rede de máquinas e grandes bases de código. Os designers queriam abordar críticas de outras línguagens em uso no Google, mas manter suas características úteis. Os criadores Rob Pike, Ken Thompson e Robert Griesemer mantiveram a sintaxe de Go semelhante ao C. No final de 2008 Russ Cox juntou-se a equipe e ajudou a mudar a linguagem e as bibliotecas de protótipo para realidade.
A linguagem Go foi lançada em 2009 com propósito de facilitar a resolução de problemas quando o assunto é desenvolvimento em camadas de rede, escalabilidade, desempenho, produtividade e o mais importante, concorrência. O próprio Rob Pike declarou que “Go foi projetado para tratar de um conjunto de problemas de engenharia de software a que estávamos expostos na construção de grandes softwares de servidor”.
Go teve influências de diversas linguagens de programação e paradigmas diferentes, dentre elas: Alef, APL, BCPL, C, CSP, Limbo, Modula, Newsqueak, Oberon, occam,Pascal, Smalltalk e Cristal, percebe-se que utilizaram do que tinham de melhor e criou algo novo e enxuto, com o mínimo necessário para resolver os problemas propostos, sem perder sua simplicidade. Acredito que isto podemos chamar de inovação. Go inovou ao quebrar os paradigmas de linguagens e implementar algo novo de forma simples e muito poderosa.
package mainimport "fmt"func main() {
fmt.Println("Hello all folks!")
}
Menos é exponencialmente mais
A equipe de desenvolvedores do Go dizem que sua criação é uma tentativa de tornar os programadores mais produtivos. Melhorando o processo de desenvolvimento de software no Google. O primeiro objetivo foi criar uma linguagem melhor para enfrentar os desafios da simultaneidade escalável, ou seja software que lida com muitas preocupações simultaneamente, um exemplo seria a coordenação de mil servidores back-end enviando tráfego de rede todo o tempo.
Manter a linguagem Go pequena permite objetivos mais importantes. Ser pequeno torna o Go mais fácil de aprender, mais fácil de entender, mais fácil de implementar, mais fácil de reimplementar, mais fácil de depurar, mais fácil de ajustar e mais fácil de evoluir. Fazer menos permite mais. É uma expressão utilizada pela equipe de desenvolvimento do Go: “Do Less. Enable More” seria o equilíbrio entre os universo de problemas existentes e o que Go poderá ajudar a resolver bem tais problemas. Go explicitamente não foi projetado para resolver todos os problemas, em vez disso fizeram o suficiente para que possamos criar as próprias soluções personalizadas com facilidade, mas deixando bem claro que Go não pode fazer tudo.
Alvoroço na comunidade Go
Foram deixadas de fora diversas características das linguagens modernas,*contrariando e indo em direção oposta das outras linguagens atuais, algumas funcionalidades como: *o uso de declarações de imutabilidade, tipos de dados de correspondência de padrões, generics, tratamento de exceção, Herança, programação genérica,assertion e sobrecarga de métodos e diversos outros pontos. Todos os recursos acima foram criticados e apontados para os criadores de Go, que responderam: “Essas omissões foram simplificações que contribuíram e contribuem para a força de Go”. Há muitas coisas na linguagem e bibliotecas Go que diferem das práticas modernas, foi uma decisão da equipe de desenvolvimento do Go: “às vezes vale a pena tentar uma abordagem diferente”.
Todos estão convidados a ajudar e contribuir se assim desejar. Os interessados podem abrir propostas para novos recursos e tudo relacionado ao ecossistema da linguagem. O código fonte de Go está disponível no GitHub . A documentação sobre como você pode contribuir com o idioma é fornecida aqui.
Concorrência é diferente de paralelismo
Uma das famosas frases é: *“Concorrência é sobre lidar com muitas coisas ao mesmo tempo. Paralelismo é fazer muitas coisas ao mesmo tempo”.*Concorrência é a composição de cálculos de execução independente. Concorrência é uma maneira de estruturar software, e definitivamente não é paralelismo embora permita o paralelismo.
Se você tiver apenas um processador, seu programa ainda pode ser concorrente, mas não pode ser paralelo. Por outro lado, um programa concorrente bem escrito pode ser executado de forma eficiente em paralelo em um multiprocessador. Sugiro dar uma conferida neste vídeo de uma palestra do Rob Pike “Concorrência não é Paralelismo”.
Concorrência em Go é muito poderosa e também simples de codar está foi a intensão dos engenheiros que desenvolveram Go. A resolução de muitos problemas é bem mais eficiente utilizando concorrência e este é o poder de Go, por isto, se tornou um Deus quando o assunto é concorrência. Devido a isto, problemas englobados neste universo serão resolvidos com muita eficiência e o mais importante, com muito pouco recurso computacional.
O exemplo abaixo é um clássico quando nos referimos a concorrência, quando queremos balancear CPU e E/S usamos este parttern Fan-out.
O que é Fan-out ?
São múltiplas funções podem ler do mesmo canal até que esse canal seja fechado, isso é chamado de fan-out . Isso fornece uma maneira de distribuir o trabalho entre um grupo de trabalhadores para paralelizar o uso da CPU e E/S.
/*
* Example Worker
* @package main
* @author @jeffotoni
*/
// In this example we'll look at how to implement
// a _worker pool_ using goroutines and channels.
package main
import "fmt"
import "time"
// Here's the worker, of which we'll run several
// concurrent instances. These workers will receive
// work on the `jobs` channel and send the corresponding
// results on `results`. We'll sleep a second per job to
// simulate an expensive task.
func worker(id int, jobs <-chan int, results chan<- int) {
for j := range jobs {
fmt.Println("worker", id, "started job", j)
time.Sleep(time.Second)
fmt.Println("worker", id, "finished job", j)
results <- j * 2
}
}
func main() {
// In order to use our pool of workers we need to send
// them work and collect their results. We make 2
// channels for this.
jobs := make(chan int, 100)
results := make(chan int, 100)
// This starts up 3 workers, initially blocked
// because there are no jobs yet.
for w := 1; w <= 3; w++ {
go worker(w, jobs, results)
}
// Here we send 5 `jobs` and then `close` that
// channel to indicate that's all the work we have.
for j := 1; j <= 5; j++ {
jobs <- j
}
close(jobs)
// Finally we collect all the results of the work.
for a := 1; a <= 5; a++ {
<-results
}
}
Pontos positivos de Go:
Não possui Generics;
Não possui sobrecarga do operador;
Não possui aritmética de ponteiros;
Não é explícito o gerenciamento de Threads;
Possui inferência de tipos;
As Dependências são claras;
A sintaxe é limpa;
A semântica é clara;
A composição e não herança;
GC Nativo (Garbage collector);
Possui Goroutines;
Suporte nativo a programação concorrente;
Funções de Primeira Classe (podemos passar funções como parâmetros);
Multiplataforma;
Open Source;
Curva de Aprendizado muito baixa ou seja fácil de aprender;
Altamente produtivo;
Resolve problemas de escalabilidade;
Pode diminui seus custos de servidores drasticamente;
Diversos problemas pensados na perspectiva Go torna-se muito mais fáceis de tratar e resolvê-los;
Possui somente 25 Palavras reservadas;
Multi-paradigma: concorrente, funcional, imperativa, orientada a objeto;
Memory Safe.
Sabemos que diversos pontos acima serão criticados, mas na prática e com o tempo percebemos que todas as simplificações omitidas tornaram Go uma linguagem ainda mais poderosa. Para projetos simples ou complexos Go sempre será uma excelente alternativa, pois torna tudo mais simples e enxuto, fácil de codar e dar manutenção.
Go é amor ❤
Top comments (0)