Programando em Go Crie aplicações com a linguagem do Google
Caio FilipiniGoogle Go
Créditos
O Gopher utilizado na capa deste livro é criação de Renee French (http://reneefrench.blogspot.com/) e licenciado sob Creative Commons Attributions 3.0 (https://creativecommons.org/licenses/by/3.0/).
Prefácio
Go tem sido fundamental no meu dia a dia escrevendo programas concorrentes e plataformas (systems programming). É uma linguagem que favorece a criação de programas paralelos, leves, rápidos, simples de entender, de distribuir (um simples binário compilado estaticamente) e de manter.
Honestamente, porém, minhas primeiras impressões gerais sobre a linguagem não foram das melhores. A ausência de funcionalidades encontradas em outras linguagens mais sofisticadas me incomodava. Algumas bem polêmicas e controversas, como a de tipos genéricos e o tratamento de erros simples sem exceções. Não é incomum ter que escrever uma ou outra linha de código a mais em Go do que seria necessário em outra linguagem. Não é uma linguagem otimizada para programas curtos, mas sim para programas escaláveis.
No início, o modo com que Go lida com concorrência e paralelismo foi o que despertou meu interesse na linguagem. Channels e goroutines são primitivas extremamente poderosas que continuam influenciando bastante a forma com que escrevo programas concorrentes, inclusive em outras linguagens. E eu tenho certeza de que vão influenciar a forma com que você escreve programas também.
O resto não parecia ter nada de especial quando comparado com outras linguagens. Mas, com o tempo, fui aprendendo a apreciar a simplicidade de Go. Demorou um pouco até me cair a ficha de que a ausência de funcionalidades que trariam complexidade foi (e continua sendo) uma decisão explícita de seus principais mantenedores. Isso faz com que Go seja uma linguagem relativamente fácil de aprender e geralmente existe apenas uma (ou poucas) forma(s) clara(s) de se resolver os problemas e escrever código em Go, a maioria delas usando apenas o que já está disponível na biblioteca padrão.
Quando me dá vontade de reclamar de que Go não tem essa ou aquela funcionalidade, lembro-me o quão simples é ler e entender programas escritos em Go. Lembro-me também de quanta discussão desnecessária se evita no dia a dia com outros programadores sobre como código deveria ser escrito. Uma vez que se entende e aceita a mentalidade por trás da linguagem, times conseguem focar em escrever código que resolve problemas de verdade de forma simples de manter, em vez de gastar tempo discutindo preferências pessoais e de estilo de código.
Go, na minha opinião, representa um ótimo balanço entre pragmatismo e funcionalidades. É uma escolha perfeita para programas que precisam sobreviver por muito tempo, na mão de muitas pessoas e times diferentes.
Já tive o prazer de trabalhar diretamente com o Caio, que é um excelente programador e faz realmente um bom trabalho em apresentar a linguagem.
Bom proveito e feliz programação!
Fabio Kung
Agradecimentos
À minha esposa Gabriela, pela paciência e todo o apoio.
Ao Francisco Capuano, pelo exemplo e inspiração.
À minha avô Arlinda e ao meu tio Washington, por permitirem que eu pudesse estudar e me apaixonar pela minha profissão.
A toda a minha família por acreditar e confiar em mim, sempre.
E a todos que, de forma direta ou indireta, contribuíram para a escrita deste livro; em especial: Guilherme Conte, Anderson Leite, Reinaldo Braga, Bruno Grasselli, Luca Pette, Adriano Almeida e Paulo Silveira.
Sumário
- 1 - Introdução
- 1.1 - Por que Go...?
- 1.2 - Instalação
- 1.3 - O primeiro programa em Go
- 2 - Explorando a sintaxe básica
- 2.1 - Estrutura do capítulo
- 2.2 - If e expressões lógicas
- 2.3 - Arrays e slices
- 2.4 - Exemplo 1: conversor de medidas
- 2.5 - Criando funções básicas
- 2.6 - Exemplo 2: quicksort e funções
- 3 - Indo além: mais exemplos
- 3.1 - Exemplo 3: mapas e estatísticas
- 3.2 - Exemplo 4: pilhas e tipos customizados
- 4 - Coleções: arrays, slices e maps
- 4.1 - Arrays
- 4.2 - Slices
- 4.3 - Maps
- 5 - Criando novos tipos
- 5.1 - Novos nomes para tipos existentes
- 5.2 - Conversão entre tipos compatíveis
- 5.3 - Criando abstrações mais poderosas
- 5.4 - Structs
- 5.5 - Interfaces
- 5.6 - Duck typing e polimorfismo
- 5.7 - Um exemplo da biblioteca padrão: io.Reader
- 6 - Funções
- 6.1 - A forma básica
- 6.2 - Valores de retorno nomeados
- 6.3 - Argumentos variáveis
- 6.4 - Funções de primeira classe
- 6.5 - Funções anônimas
- 6.6 - Closures
- 6.7 - Higher-order functions
- 6.8 - Tipos de função
- 6.9 - Servindo HTTP através de funções
- 7 - Concorrência com goroutines e channels
- 7.1 - Goroutines
- 7.2 - Channels
- 7.3 - Buffers
- 7.4 - Controlando a direção do fluxo
- 7.5 - Select
- 7.6 - Temporizadores e timeouts
- 7.7 - Sincronizando múltiplas goroutines
- 7.8 - Concorrência, paralelismo e GOMAXPROCS
- 7.9 - Recapitulando
- 8 - Mão na massa: encurtador de URLs
- 8.1 - Estrutura do projeto
- 8.2 - Criando o servidor
- 8.3 - Criando URLs curtas
- 8.4 - Redirecionando para as URLs originais
- 8.5 - Apresentando o pacote url
- 8.6 - Especificando a implementação do repositório
- 8.7 - Criando identificadores curtos
- 8.8 - Implementando o repositório em memória
- 9 - Compilando e executando o projeto
- 9.1 - Entendendo o processo de compilação
- 9.2 - Instalando o executável no sistema
- 9.3 - Aprendendo mais
- 10 - Colhendo estatísticas
- 10.1 - Realizando a contagem no repositório
- 10.2 - Registrando os acessos no servidor
- 10.3 - Serializando JSON
- 10.4 - Visualizando as estatísticas como JSON
- 11 - Refatorando o código
- 11.1 - Substituindo variáveis globais
- 11.2 - Reduzindo a duplicação de código
- 11.3 - Escrevendo logs
- 11.4 - Flexibilizando a inicialização do servidor
- 12 - Próximos passos
- 12.1 - Aprendendo mais
Dados do produto
- Número de páginas:
- 190
- ISBN:
- 978-85-66250-49-7
- Data publicação:
- 06/2014