Como Ser Um Programador Melhor

Um manual para programadores que se importam com código

Como Ser Um Programador Melhor
Como Ser Um Programador Melhor

Como Ser Um Programador Melhor

Compartilhar

Autor: Pete Goodliffe

ISBN impresso: 978-85-7522-415-1
ISBN ebook: 978-85-7522-764-0
Ano: 2015
Páginas: 384
Preço impresso: R$ 99,00 O ebook deste livro está disponível na Amazon.

10 opiniões | Opine sobre este livro

Descrição do livro

Se você é apaixonado por programação e quer se aperfeiçoar nisso, está com a fonte de informações perfeita. Pete Goodliffe, autor de Code Craft, apresenta um conjunto de técnicas e abordagens úteis para a arte da programação que irá ajudá-lo a impulsionar a sua carreira e a melhorar o seu bem-estar.

Goodliffe apresenta conselhos sólidos, aprendidos em 15 anos de programação profissional. Os capítulos independentes do livro cobrem o espectro da vida de um desenvolvedor de software – lidar com código, conhecer os negócios e melhorar o desempenho – sem ideias tendenciosas sobre qualquer linguagem ou mercado. Independentemente de ser um desenvolvedor experiente, um profissional novato ou um programador por hobby, você encontrará dicas valiosas em cinco categorias independentes:

• Técnicas no nível de codificação para compor linhas de código, testar, depurar e lidar com a complexidade.

• Práticas, abordagens e atitudes: manter a simplicidade, trabalhar bem em equipe, reutilizar e criar códigos maleáveis.

• Táticas para aprender de maneira eficiente, comportar-se de modo ético, encontrar desafios e evitar a estagnação.

• Maneiras práticas de completar tarefas: usar as ferramentas certas, saber qual é a aparência de “pronto” e procurar ajuda dos colegas.

• Hábitos para trabalhar bem com outras pessoas e encarar o desenvolvimento como uma atividade social.

Ver menos ▲

Sumário

  • Introdução
  • Capítulo 1 ■ Importar-se com o código
  • Parte I você escreve(código);
  • Capítulo 2 ■ Mantendo as aparências
    • A apresentação é eficaz
    • É uma questão de comunicação
    • Layout
      • Crie uma boa estrutura
      • Consistência
    • Nomes
      • Evite redundância
      • Seja claro
      • Seja idiomático
      • Seja preciso
    • Torne-se apresentável
    • Conclusão
  • Capítulo 3 ■ Escreva menos código!
    • Por que devemos nos importar?
    • Lógica oscilante
    • Duplicação
    • Código morto
    • Comentários
    • Verbosidade
    • Design ruim
    • Espaços em branco
    • Então o que devemos fazer?
    • Conclusão
  • Capítulo 4 ■ Melhore o código removendo-o
    • Indulgência no código
    • Não é ruim, é inevitável
    • E daí?
    • Despertando os mortos
    • Extração cirúrgica
    • Conclusão
  • Capítulo 5 ■ O fantasma de um código do passado
    • Apresentação
    • O estado da arte
    • Idioms
    • Decisões de design
    • Bugs
    • Conclusão
  • Capítulo 6 ■ Percorrendo um caminho
    • Uma pequena ajuda de meus amigos
    • Procure pistas
    • Aprenda fazendo
      • Frutos ao alcance das mãos
      • Inspecione o código
      • Estude e depois aja
      • Teste antes
      • Organize a casa
      • Documente o que você encontrar
    • Conclusão
  • Capítulo 7 ■ Chafurdando na lama
    • Fareje os sinais
    • Entrando na fossa
    • A avaliação diz que
    • Trabalhando em terreno arenoso
    • Limpando a sujeira
    • Fazendo ajustes
    • Código ruim? Programadores ruins?
  • Capítulo 8 ■ Não ignore esse erro!
    • Maneiras de informar erros
    • A loucura
    • As desculpas
    • Conclusão
  • Capítulo 9 ■ Espere pelo inesperado
    • Erros
    • Threading
    • Encerramento
    • A moral da história
  • Capítulo 10 ■ Caça aos bugs
    • Uma preocupação econômica
    • Um grama de prevenção
    • Caça aos bugs
      • Coloque armadilhas
      • Aprenda a fazer divisões binárias
      • Empregue a arqueologia de software
      • Teste, teste, teste
      • Invista em ferramentas afiadas
      • Remova códigos para excluí-lo da análise de causa
      • A limpeza evita uma infecção
      • Estratégias oblíquas
      • Não se apresse
    • Bugs que não podem ser reproduzidos
    • Conclusão
  • Capítulo 11 ■ É hora de testar
    • Por que testar?
      • Reduzindo o ciclo de feedback
      • Código para testar código
      • Quem escreve os testes?
    • Tipos de teste
    • Quando os testes devem ser escritos
    • Quando executar os testes
    • O que deve ser testado
    • Bons testes
    • Como é a aparência de um teste?
      • Nomes de testes
    • A estrutura dos testes
      • Faça a manutenção dos testes
      • Selecionando um framework de teste
    • Nenhum código é uma ilha
    • Conclusão
  • Capítulo 12 ■ Lidando com a complexidade
    • Círculos
    • Caso de estudo: reduzindo a complexidade dos círculos
    • Linhas
    • E por fim: as pessoas
    • Conclusão
  • Capítulo 13 ■ Um conto de dois sistemas
    • A Metrópole Confusa
      • Incompreensibilidade
      • Falta de coesão
      • Acoplamento desnecessário
      • Problemas com o código
      • Problemas além do código
      • Um cartão-postal de Metrópole
    • Cidade do Design
      • Localizando as funcionalidades
      • Consistência
      • Expandindo a arquitetura
      • Adiando as decisões de design
      • Mantendo a qualidade
      • Administrando a dívida técnica
      • Os testes moldam o design
      • Prazo para o design
      • Trabalhando com o design
    • E daí?
  • Parte II A prática leva à perfeição
  • Capítulo 14 ■ Desenvolvimento de software é
    • Esse negócio de software (comida)
    • Desenvolvimento de software é... uma arte
    • Desenvolvimento de software é... uma ciência
    • Desenvolvimento de software é... um esporte
    • Desenvolvimento de software é... uma brincadeira de criança
    • Desenvolvimento de software é... uma obrigação
    • Excesso de metáforas
  • Capítulo 15 ■ Jogando segundo as regras
    • Precisamos de mais regras!
    • Defina as regras
  • Capítulo 16 ■ Mantenha a simplicidade
    • Designs simples
      • Simples de usar
      • Evita usos indevidos
      • O tamanho importa
      • Caminhos mais curtos no código
      • Estabilidade
    • Linhas de código simples
    • Mantenha a simplicidade e não a estupidez
    • As suposições podem reduzir a simplicidade
    • Evite uma otimização prematura
    • Suficientemente simples
    • Uma conclusão simples
  • Capítulo 17 ■ Use o seu cérebro
    • Não seja estúpido
    • Evite o descuido
    • Você tem permissão para pensar!
  • Capítulo 18 ■ Nada está gravado a ferro e fogo
    • Mudanças sem medo
    • Mude a sua atitude
    • Faça a mudança
      • Crie o design visando a mudanças
      • Ferramentas para fazer alterações
      • Escolha suas batalhas
    • Mais alterações
  • Capítulo 19 ■ Um estudo sobre reutilização de código
    • Caso de reutilização 1: copiar e colar
    • Caso de reutilização 2: faça o design visando à reutilização
    • Caso de reutilização 3: promover e refatorar
    • Caso de reutilização 4: compre ou reinvente a roda
  • Capítulo 20 ■ Controle eficiente de versões
    • Use-o ou você se arrependerá
    • Escolha um, qualquer um
    • Armazenando os itens corretos
      • Resposta um: armazene tudo
      • Resposta dois: armazene o mínimo possível
      • Armazenando versões de software
      • Layout do repositório
    • Utilize bem o sistema de controle de versões
      • Faça commits atômicos
      • Enviando as mensagens corretas
      • Componha bons commits
    • Branches: vendo o bosque no lugar das árvores
    • Um lar para o seu código
    • Conclusão
  • Capítulo 21 ■ Marcando um gol
    • Desenvolvimento de software: jogando adubo
    • Uma falsa dicotomia
    • Corrija a equipe para corrigir o código
    • Disponibilizando um build para a equipe de QA
      • Teste o seu trabalho antes
      • Tenha um propósito ao disponibilizar uma versão
      • Mais pressa, menos velocidade
      • Automatize
      • Respeite
    • Ao receber um relatório de falha
    • Nossas diferenças nos tornam mais fortes
    • Peças do quebra-cabeça
  • Capítulo 22 ■ O curioso caso do código congelado
    • Atrás do congelamento de código
    • Uma nova ordem mundial
    • Formas de congelamento
    • Branches são apropriados
    • Mas o código não está realmente congelado!
    • Duração do congelamento
    • Sinta o congelamento
    • O fim se aproxima
    • Anticongelamento
    • Conclusão
  • Capítulo 23 ■ Por favor, libere a versão
    • Parte do processo
    • Uma engrenagem na máquina
      • Passo 1: inicie a disponibilização de versão
      • Passo 2: prepare a versão
      • Passo 3: gere a versão
      • Passo 4: empacote a versão
      • Passo 5: implante a versão
    • Disponibilize versões cedo e com frequência
    • E tem mais
  • Parte III Envolvendo-se pessoalmente
  • Capítulo 24 ■ Viva para amar o aprendizado
    • O que você deve aprender?
    • Aprendendo a aprender
    • Modelos de aprendizado
      • O portfólio de conhecimento
    • Ensine para aprender
    • Faça para aprender
    • O que aprendemos?
  • Capítulo 25 ■ Desenvolvedores orientados a testes
    • Esclarecendo a questão
    • O sucesso gera complacência
    • É hora do exame
    • Desenvolvedores orientados a testes
    • Conclusão
  • Capítulo 26 ■ Aprecie o desafio
    • É a motivação
    • Qual é o desafio?
    • Não faça isso!
    • Sinta-se desafiado
    • Conclusão
  • Capítulo 27 ■ Evite a estagnação
    • Suas habilidades são o seu investimento
    • Um exercício para o leitor
    • Segurança no emprego
  • Capítulo 28 ■ O programador ético
    • Atitude em relação ao código
    • Questões legais
    • Atitude em relação às pessoas
      • Colegas de equipe
      • Gerente
      • Empregador
      • Você
    • O juramento de Hipocódigo
    • Conclusão
  • Capítulo 29 ■ Amor pelas linguagens
    • Ame todas as linguagens
    • Ame sua linguagem
    • Cultivando o relacionamento com a sua linguagem
      • Amor e respeito
      • Compromisso
      • Comunicação
      • Paciência
      • Valores compartilhados
    • Uma metáfora perfeita?
    • Conclusão
  • Capítulo 30 ■ Postura dos programadores
    • Postura básica diante do computador
      • A postura de debugging
      • Quando a situação estiver realmente ruim
      • Para aqueles que trabalham a noite toda
      • Intervenção do alto
      • Voltando ao normal
      • É hora do design
    • Vista cansada
    • Conclusão
  • Parte IV Conseguir que tudo seja feito
  • Capítulo 31 ■ Mais inteligente, e não mais árduo
    • Escolha suas batalhas
    • Táticas de batalha
      • Reutilize sabiamente
      • Faça com que o problema seja de outra pessoa
      • Faça somente o que for necessário
      • Use uma solução rápida
      • Priorize
      • O que é realmente necessário?
      • Uma tarefa de cada vez
      • Mantenha o seu código pequeno (e simples)
      • Não adie os problemas deixando que eles se acumulem
      • Automatize
      • Evitando erros
      • Comunique-se
      • Evite um esgotamento
      • Ferramentas poderosas
    • Conclusão
  • Capítulo 32 ■ Estará pronto quando estiver pronto
    • Já terminamos?
    • Desenvolvendo para trás: decomposição
    • Defina “pronto”
    • Simplesmente faça
  • Capítulo 33 ■ Dessa vez, eu consigo
    • Desenvolvimento em uma ilha deserta
    • Fique na base da montanha
  • Parte V Uma meta de pessoas
  • Capítulo 34 ■ O poder das pessoas
    • O que você deve fazer
    • Conheça seus experts
    • Campo de visão 20/20
  • Capítulo 35 ■ Ser responsável
    • Alongando a metáfora
    • A responsabilidade ajuda
    • Código++
    • Fazendo com que dê certo
    • Definindo o padrão
    • Os próximos passos
    • Conclusão
  • Capítulo 36 ■ Fale!
    • Código é comunicação
      • Falando com as máquinas
      • Falando com os animais
      • Falando com ferramentas
    • Comunicação interpessoal
      • Maneiras de conversar
      • Observe o seu linguajar
      • Linguagem corporal
      • Comunicação paralela
    • Conversas nas equipes
    • Falando com o cliente
    • Outras formas de comunicação
    • Conclusão
  • Capítulo 37 ■ Manifestos
    • Um manifesto genérico para o desenvolvimento de software
    • Tudo bem, tudo bem
    • Os manifestos
    • É sério?
    • A conclusão
  • Capítulo 38 ■ Ode ao código
    • Codificação é um problema de pessoas
  • Epílogo
    • Atitude
    • Vá em frente e codifique
  • Sobre o autor
  • Colofão
Ver sumário completo ▼

Sobre o autor

Pete Goodliffe

Pete Goodliffe é programador, colunista que escreve sobre desenvolvimento de software, músico e autor. Ele jamais permanece no mesmo ponto da cadeia alimentar de software. Pete é autor de uma coluna chamada “Becoming a Better Programmer” (Como ser um programador melhor) para uma revista, colaborou com vários livros sobre desenvolvimento de software… Ver perfil completo ▶

Opinião dos leitores

Victor A P O

Esse não é um livro de programação. É um livro sobre programação. De programador para programador. Apesar de praticamente não conter código, o livro é melhor aproveitado se você for um programador com uma boa experiência. O autor, dinâmica e descontraidamente, discute desde boas práticas de estilos de código, comentários, linguagens, CVS, testes, passando por questões éticas, até a postura, comunicação e bons círculos de amigos programadores. Recomendo.

Marcelo A

Certamente um dos meus livros preferidos sobre programação, por não falar sobre linguagem específica, mas principalmente sobre todo o trabalho envolvido na programação como controle de versão, fontes, como encontrar e corrigir erros, documentação e comunicação com a equipe.

Michel L S de B

Bom livro para iniciantes.

Emerson C M

Ótimo livro.

Ver todas ▼