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

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

Guilherme Silveira

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.

 

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

veja mais detalhes

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

Compartilhe!

Compartilhe no Facebook Compartilhe no Twitter