Use o código e tenha 10% de desconto!

Programando em Go Crie aplicações com a linguagem do Google

Caio Filipini
Capa

Google 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:
185
ISBN:
978-85-66250-49-7
Data publicação:
06/2014

Compartilhe!

Compartilhe no Facebook Compartilhe no Twitter