Casa do Código - Livros e Tecnologia

  • Programação
  • Lógica
  • Java
  • .NET
  • PHP
  • Games
  • OO
  • Funcional
  • Python
  • Outros
  • Todos
  • Mobile
  • iOS
  • Android
  • Multiplataforma
  • Outros
  • Todos
  • Front-end
  • HTML e CSS
  • JavaScript
  • Outros
  • Todos
  • Infraestrutura
  • Web
  • Dados
  • Outros
  • Todos
  • Business
  • Startups
  • Marketing Digital
  • Gestão
  • Agile
  • Outros
  • Todos
  • Design & UX
  • Você tem 0 itens na sacola 0 Abrir navegação por categorias e busca Ir para ao topo da página

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

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

    Caio Filipini
    Livro de Google Go

    *Você terá acesso às futuras atualizações do livro.

    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:
    190
    ISBN:
    978-85-66250-49-7
    Data publicação:
    06/2014
    Fórum de discussões

    Compartilhe!

    Compartilhe no Facebook Compartilhe no Twitter

    *Você terá acesso às futuras atualizações do livro.

    altLogoFooter

    Links da
    Casa do Código

    • Meus ebooks
    • Sobre a Casa do Código
    • Todos os livros
    • Nossas coleções
    • Quero escrever um livro ou fazer parceria
    • Perguntas Frequentes
    • Política de Privacidade
    • Fale conosco

    Nas redes sociais

    • /CasaDoCodigo
    • @casadocodigo
    • @casadocodigo

    Receba novidades e lançamentos

    Este site aceita Pix, Cartão de Crédito, Débito

    • pagarme
    • paypal

    Grupo Alura

    • Educação em Tecnologia

      • FIAP
      • Casa do Código
      • PM3 - Cursos de Produto
    • Mais Alura

      • Alura Start
      • Alura Língua
      • Alura Para Empresas
      • Alura LATAM
    • Comunidade

      • Tech Guide
      • 7 days of code
      • Hipsters ponto Jobs
    • Podcasts

      • Hipsters ponto Tech
      • Dev sem Fronteiras
      • Layers ponto Tech
      • Like a Boss
      • Scuba Dev