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