Go: A linguagem que mais cresce para backend

Go foi projetado pelo Google em 2007 para melhorar a produtividade de programao em uma era de multicore, rede de mquinas e grandes bases de cdigo. Os designers queriam abordar crticas de outras lnguagens em uso no Google, mas manter suas caractersticas 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 prottipo para realidade.

A linguagem Go foi lanada em 2009 com propsito de facilitar a resoluo de problemas quando o assunto desenvolvimento em camadas de rede, escalabilidade, desempenho, produtividade e o mais importante, concorrncia. O prprio Rob Pike declarou que Go foi projetado para tratar de um conjunto de problemas de engenharia de software a que estvamos expostos na construo de grandes softwares de servidor.

Go teve influncias de diversas linguagens de programao 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 mnimo necessrio para resolver os problemas propostos, sem perder sua simplicidade. Acredito que isto podemos chamar de inovao. 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 criao 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 escalvel, ou seja software que lida com muitas preocupaes simultaneamente, um exemplo seria a coordenao de mil servidores back-end enviando trfego de rede todo o tempo.

Manter a linguagem Go pequena permite objetivos mais importantes. Ser pequeno torna o Go mais fcil de aprender, mais fcil de entender, mais fcil de implementar, mais fcil de reimplementar, mais fcil de depurar, mais fcil de ajustar e mais fcil de evoluir. Fazer menos permite mais. uma expresso utilizada pela equipe de desenvolvimento do Go: Do Less. Enable More seria o equilbrio entre os universo de problemas existentes e o que Go poder ajudar a resolver bem tais problemas. Go explicitamente no foi projetado para resolver todos os problemas, em vez disso fizeram o suficiente para que possamos criar as prprias solues personalizadas com facilidade, mas deixando bem claro que Go no pode fazer tudo.

Alvoroo na comunidade Go

Foram deixadas de fora diversas caractersticas das linguagens modernas,*contrariando e indo em direo oposta das outras linguagens atuais, algumas funcionalidades como: *o uso de declaraes de imutabilidade, tipos de dados de correspondncia de padres, generics, tratamento de exceo, Herana, programao genrica,assertion e sobrecarga de mtodos e diversos outros pontos. Todos os recursos acima foram criticados e apontados para os criadores de Go, que responderam: Essas omisses foram simplificaes que contriburam e contribuem para a fora de Go. H muitas coisas na linguagem e bibliotecas Go que diferem das prticas modernas, foi uma deciso da equipe de desenvolvimento do Go: s vezes vale a pena tentar uma abordagem diferente.

Todos esto convidados a ajudar e contribuir se assim desejar. Os interessados podem abrir propostas para novos recursos e tudo relacionado ao ecossistema da linguagem. O cdigo fonte de Go est disponvel no GitHub . A documentao sobre como voc pode contribuir com o idioma fornecida aqui.

Concorrncia diferente de paralelismo

Uma das famosas frases : *Concorrncia sobre lidar com muitas coisas ao mesmo tempo. Paralelismo fazer muitas coisas ao mesmo tempo.*Concorrncia a composio de clculos de execuo independente. Concorrncia uma maneira de estruturar software, e definitivamente no paralelismo embora permita o paralelismo.

Se voc tiver apenas um processador, seu programa ainda pode ser concorrente, mas no 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 vdeo de uma palestra do Rob Pike Concorrncia no Paralelismo.

Concorrncia em Go muito poderosa e tambm simples de codar est foi a intenso dos engenheiros que desenvolveram Go. A resoluo de muitos problemas bem mais eficiente utilizando concorrncia e este o poder de Go, por isto, se tornou um Deus quando o assunto concorrncia. Devido a isto, problemas englobados neste universo sero resolvidos com muita eficincia e o mais importante, com muito pouco recurso computacional.

O exemplo abaixo um clssico quando nos referimos a concorrncia, quando queremos balancear CPU e E/S usamos este parttern Fan-out.

O que Fan-out ?

So mltiplas funes 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 mainimport "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:

• No possui Generics;

• No possui sobrecarga do operador;

• No possui aritmtica de ponteiros;

• No explcito o gerenciamento de Threads;

• Possui inferncia de tipos;

• As Dependncias so claras;

• A sintaxe limpa;

• A semntica clara;

• A composio e no herana;

• GC Nativo (Garbage collector);

• Possui Goroutines;

• Suporte nativo a programao concorrente;

• Funes de Primeira Classe (podemos passar funes como parmetros);

• Multiplataforma;

• Open Source;

• Curva de Aprendizado muito baixa ou seja fcil 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 fceis 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 sero criticados, mas na prtica e com o tempo percebemos que todas as simplificaes 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, fcil de codar e dar manuteno.

Go amor