Porque Amamos Go! ❤
Published: 2023-04-12 17:36:37

#   
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](https://pt.wikipedia.org/wiki/Rob_Pike), [Ken Thompson](https://pt.wikipedia.org/wiki/Ken_Thompson) e [Robert Griesemer](https://de.wikipedia.org/wiki/Robert_Griesemer) mantiveram a sintaxe de Go semelhante ao C. No final de 2008 *Russ Cox* [](https://en.wikipedia.org/wiki/Go_%28programming_language%29)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](https://pt.wikipedia.org/wiki/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*](https://en.wikipedia.org/wiki/Go_%28programming_language%29)*,* [*APL*](https://pt.wikipedia.org/wiki/APL_%28linguagem_de_programa%C3%A7%C3%A3o%29)*,* [*BCPL*](https://pt.wikipedia.org/wiki/BCPL)*,* [*C*](https://pt.wikipedia.org/wiki/C_%28linguagem_de_programa%C3%A7%C3%A3o%29)*, CSP,* [*Limbo*](https://pt.wikipedia.org/wiki/Limbo_%28linguagem_de_programa%C3%A7%C3%A3o%29)*,* [*Modula*](https://pt.wikipedia.org/wiki/Modula)*,* [*Newsqueak*](https://en.wikipedia.org/wiki/Newsqueak)*,* [*Oberon*](https://pt.wikipedia.org/wiki/Oberon_%28linguagem_de_programa%C3%A7%C3%A3o%29)*,* [*occam*](https://pt.wikipedia.org/wiki/Occam_%28linguagem_de_programa%C3%A7%C3%A3o%29)*,*[*Pascal*](https://en.wikipedia.org/wiki/Pascal_%28programming_language%29)*,* [*Smalltalk*](https://pt.wikipedia.org/wiki/Smalltalk) *e* [*Cristal*](https://en.wikipedia.org/wiki/Crystal_%28programming_language%29)*,* 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.

```go
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*](https://pt.wikipedia.org/wiki/Tratamento_de_exce%C3%A7%C3%A3o)*,* [*Herança*](https://pt.wikipedia.org/wiki/Heran%C3%A7a_%28programa%C3%A7%C3%A3o%29)*,* [*programação genérica*](https://pt.wikipedia.org/wiki/Programa%C3%A7%C3%A3o_gen%C3%A9rica)*,*[*assertion*](https://pt.wikipedia.org/wiki/Asser%C3%A7%C3%A3o) *e* [*sobrecarga*](https://pt.wikipedia.org/wiki/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](https://github.com/golang/go/wiki/ExperienceReports) para novos recursos e tudo relacionado ao ecossistema da linguagem. O código fonte de Go está disponível no [GitHub](https://github.com/golang/go) . A documentação sobre como você pode contribuir com o idioma é fornecida [aqui](https://golang.org/doc/contribute.html).

# 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](https://pt.wikipedia.org/wiki/Rob_Pike) “[Concorrência não é Paralelismo](https://vimeo.com/49718712)”.

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**.

```go
/*
* 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*** ❤