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!

    Introdução à Computação Da Lógica aos jogos com Ruby

    Guilherme Silveira
    Livro de Introdução a Computação com Ruby

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

    Conteúdo

    Em uma sociedade global que esbanja desenvolvimento tecnológico, aprender a programar passa a ser um conhecimento estratégico. Pensamentos transformados em linhas de código se tornam programas, jogos, sites e aplicativos. O homem pensa em ir até Marte e mergulha nos mistérios da ciência. Na fronteira de tudo isso, está o código.

    Neste livro, Guilherme Silveira ensina as principais matérias introdutórias dos cursos de computação, fazendo você criar seus primeiros jogos de computador. Entenda como seu programa toma decisões e domine o fluxo de sua execução com recursão. Decifre toda a sequência de um programa de computador entendendo a sua pilha de execução e domine a lógica por trás da criação de software.

    Saiba o que você vai aprender

     

    Sumário

    • 1 - Introdução
    • 1.1 - Programação
    • 1.2 - Para o professor
    • 1.3 - Quem sou eu
    • 1.4 - Agradecimentos
    • 2 - Prefácio por Fábio Akita
    • 3 - Jogo da adivinhação
    • 3.1 - O jogo: entrada e saída básica
    • 3.2 - Será que acertou? O operador de comparação ==
    • 3.3 - Operador de atribuição e variáveis
    • 3.4 - Operadores de comparação
    • 3.5 - Entrada e saída
    • 3.6 - O que são funções
    • 3.7 - Refatoração: \n
    • 3.8 - Interpretador ou compilador
    • 3.9 - Resumindo
    • 4 - Controle de fluxo
    • 4.1 - Mas e se... if e else
    • 4.2 - Code smell: comentários
    • 4.3 - Condições aninhadas (nested ifs)
    • 4.4 - Code smell: copy e paste
    • 4.5 - O laço for (loop)
    • 4.6 - Aplicando o laço for ao nosso programa
    • 4.7 - Code smell: Magic numbers
    • 4.8 - Refatoração: extrair variável
    • 4.9 - Quebrando o laço com o break
    • 4.10 - Resumindo
    • 5 - Funções
    • 5.1 - Funções
    • 5.2 - Boa prática: encapsulamento de comportamento
    • 5.3 - Escopo de variáveis
    • 5.4 - Code smell: variáveis sem controle de escopo e variáveis globais
    • 5.5 - Retorno de função
    • 5.6 - Variáveis locais
    • 5.7 - Extraindo mais uma função
    • 5.8 - Boa prática: early return
    • 5.9 - Pequenas refatorações específicas da linguagem
    • 5.10 - Resumindo: o poder da extração de código
    • 5.11 - Resumindo
    • 6 - Arrays
    • 6.1 - Criando e manipulando arrays
    • 6.2 - Aplicando o array ao nosso jogo
    • 6.3 - Facilidades de um array
    • 6.4 - Simplificando nosso código de array
    • 6.5 - Arrays e Strings
    • 6.6 - Interpolação de Strings
    • 6.7 - Funções e métodos
    • 6.8 - Testando métodos no IRB
    • 6.9 - Resumindo
    • 7 - Pontos e matemática
    • 7.1 - Ponto flutuante
    • 7.2 - Simulação do código
    • 7.3 - Matemática
    • 7.4 - Unless... e a dupla negação
    • 7.5 - Número aleatório
    • 7.6 - Operadores matemáticos
    • 7.7 - Sistema de tipos
    • 7.8 - Resumindo
    • 8 - Binário
    • 8.1 - Binário
    • 8.2 - Binário e letras
    • 8.3 - Bits: 8, 16, 32, 64
    • 8.4 - Bits e números com ponto flutuante
    • 8.5 - Hexadecimal
    • 8.6 - Bits e imagens
    • 8.7 - Resumindo
    • 9 - Nível de dificuldade e o case
    • 9.1 - Case...when...end
    • 9.2 - Escopo de variável local
    • 9.3 - Trapaceando
    • 9.4 - Corrigindo o número sorteado
    • 9.5 - While: jogando diversas vezes
    • 9.6 - loop do...end
    • 9.7 - Resumindo
    • 10 - Arte ASCII: jogo da adivinhação
    • 10.1 - Melhorando nossa interface com o usuário
    • 11 - Exercícios extras: jogo da adivinhação
    • 11.1 - Melhorando o jogo de adivinhação
    • 11.2 - Outros desafios
    • 12 - Jogo da forca
    • 12.1 - Chute de uma palavra completa e a comparação com ==
    • 12.2 - Encontrando um algoritmo
    • 12.3 - Implementando o algoritmo
    • 12.4 - Boa prática: explorando a documentação
    • 12.5 - next... Evitando chutes repetidos
    • 12.6 - Resumindo
    • 13 - Responsabilidades
    • 13.1 - Mostrando parte da palavra secreta
    • 13.2 - Separando a interface com o usuário da lógica de negócios
    • 13.3 - Extraindo a lógica de negócios
    • 13.4 - Extraindo a lógica de um chute válido
    • 13.5 - Implementação: mostrando parte da palavra secreta
    • 13.6 - Resumindo
    • 14 - Entrada e saída de arquivo: palavras aleatórias e o top player
    • 14.1 - Lendo um arquivo de palavras, nosso dicionário
    • 14.2 - Limpando a entrada de dados
    • 14.3 - Processamento e memória devem ser otimizadas?
    • 14.4 - Escrita para arquivo: o melhor jogador
    • 14.5 - Lendo o melhor jogador
    • 14.6 - Refatoração: extrair arquivo
    • 14.7 - A pilha de execução
    • 14.8 - Resumindo
    • 15 - Arte ASCII: jogo da forca
    • 15.1 - Melhorando nossa interface com o usuário
    • 16 - Exercícios extras: jogo da forca
    • 16.1 - Melhorando o jogo da forca
    • 16.2 - Outros desafios
    • 17 - Foge-foge, um jogo baseado no Pacman
    • 17.1 - Definindo a base do jogo e o mapa
    • 17.2 - Array de array: matriz
    • 17.3 - Movimento
    • 17.4 - Refatorando
    • 17.5 - O vazio, o nulo
    • 17.6 - Laço funcional básico
    • 17.7 - Extraindo a posição
    • 17.8 - Refatorando
    • 17.9 - Passagem por referência ou valor?
    • 17.10 - Detecção de colisão com o muro e o fim do mapa
    • 17.11 - Refatorando com || e &&
    • 17.12 - Duck typing na prática
    • 17.13 - for i x for linha
    • 17.14 - Resumindo
    • 18 - Botando os fantasmas para correr: arrays associativos, duck typing e outros
    • 18.1 - Array associativo: case e +1, -1
    • 18.2 - Movimento dos fantasmas: o desafio no duck typing
    • 18.3 - Movimento dos fantasmas: reutilização de função
    • 18.4 - Fantasma contra fantasma?
    • 18.5 - Resumindo
    • 19 - Matrizes e memória
    • 19.1 - Teletransportando fantasmas: cuidados a tomar com a memória
    • 19.2 - Corrigindo o teletransporte
    • 19.3 - Copiando nosso mapa
    • 19.4 - Movendo os fantasmas na matriz copiada
    • 19.5 - Refatorando o movimento do fantasma
    • 19.6 - O fantasma cavaleiro
    • 19.7 - Movimento aleatório dos fantasmas
    • 19.8 - Quando o herói perde
    • 19.9 - Retorno nulo ou opcional?
    • 19.10 - Resumindo
    • 20 - Estruturas e classes: uma introdução a Orientação a Objetos
    • 20.1 - A bagunça dos defs
    • 20.2 - Extraindo uma primeira estrutura
    • 20.3 - Usando uma estrutura
    • 20.4 - Code smell: feature envy
    • 20.5 - Boa prática: buscar quem invoca antes de refatorar
    • 20.6 - Boa prática: Tell, don't ask
    • 20.7 - Atributos e attr_accessor
    • 20.8 - Estrutura ou Classe?
    • 20.9 - A verdade por trás de métodos, funções e lambdas
    • 20.10 - Resumindo
    • 21 - Destruindo os fantasmas: o mundo da recursão
    • 21.1 - Destruindo os fantasmas
    • 21.2 - Andando para a direita
    • 21.3 - Recursão infinita
    • 21.4 - A base da recursão
    • 21.5 - Base da recursão: distância quatro ou muro
    • 21.6 - Recursão para todos os lados: busca em profundidade
    • 21.7 - Resumindo
    • 22 - Exercícios extras: jogo do foge-foge
    • 22.1 - Melhorando o Jogo do foge-foge
    • 22.2 - Outros desafios
    • 23 - Como continuar
    • 23.1 - Praticar
    • 23.2 - Estrutura de dados e algoritmos
    • 23.3 - Orientação a Objetos?
    • 23.4 - Competições de programação da ACM
    • 23.5 - Outra linguagem?
    • 23.6 - Compartilhe e boa jornada
    • 24 - Apêndice — Instalando o Ruby
    • 24.1 - Instalação no Windows
    • 24.2 - Instalação no Linux
    • 24.3 - Instalação no Mac OS X
    • 24.4 - O editor de texto

    Autor

    Guilherme Silveira

    Guilherme Silveira é líder técnico na Caelum e no Alura, cofundador do GUJ.com.br e um dos criadores do VRaptor. Especializou-se na área de ensino de desenvolvimento de software e é um dos principais autores dos cursos online do Alura. Ele pode ser encontrado no twitter em @guilhermecaelum.

    Dados do produto

    Número de páginas:
    293
    ISBN:
    978-85-5519-016-2
    Data publicação:
    05/2015
    Submeter errata Fórum de discussões

    Compartilhe!

    Compartilhe no Facebook Compartilhe no Twitter

    Impulsione sua carreira aprendendo também...

    Livro de Ruby
    Ruby
    +
    Livro Aprenda a programar com Python
    Aprenda a programar com Python
    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