Livros desenvolvimento de software

Começar. É Gratuito
ou inscrever-se com seu endereço de e-mail
Rocket clouds
Livros desenvolvimento de software por Mind Map: Livros desenvolvimento de software

1. Microsserviços preparados para produção

1.1. Princípios para disponibilidade

1.1.1. Estabilidade

1.1.1.1. Ciclo de desenvolvimento estável

1.1.1.2. Processo de implantação estável

1.1.1.3. Procedimentos estável de introdução e descontinuação

1.1.2. Confiabilidade

1.1.2.1. Processo confiável de implantação

1.1.2.2. Planejar, atenuar e proteger-se contra falhas e dependências

1.1.2.3. Roteamento e descoberta confiáveis

1.1.3. Escalabilidade

1.1.3.1. Escalas de crescimento quantitativas e qualitativas bem definidas

1.1.3.2. Identificação de gargalos e requisitos de recursos

1.1.3.3. Planejamento de capacidade cuidadoso e preciso

1.1.3.4. Tratamento escalável do tráfego

1.1.3.5. Escalamento das dependências

1.1.3.6. Armazenamento escalável dos dadosn

1.1.4. Tolerância a falhas

1.1.4.1. Identificar e se planejar para potenciais cenários de catástrofes e falhas

1.1.4.2. Identificar e resolver pontos únicos de falha

1.1.4.3. Estratégias de detecção e correção de falhas em funcionamento

1.1.4.4. Testes de resiliência por meio de testes de código, teste de carga e teste de caos

1.1.4.5. Tráfego deve ser gerenciado cuidadosamente em preparação para falhas

1.1.4.6. Incidentes e interrupções devem ser tratados de forma adequada e produtiva

1.1.5. Prontidão para catástrofes

1.1.6. Desempenho

1.1.6.1. SLAs adequados de disponibilidade

1.1.6.1.1. 2 noves

1.1.6.1.2. 3 noves

1.1.6.1.3. 4 noves

1.1.6.1.4. 5 noves

1.1.6.2. Adequado tratamento e processamento de tarefas

1.1.6.3. Utilização eficiente de recursos

1.1.7. Monitoramento

1.1.7.1. Logging e rastreamento adequados em toda a pilha

1.1.7.2. Dashboards bem projetados que sejam fáceis de entender e reflitam com precisão a saúde do serviço

1.1.7.3. Alertas eficazes e acionáveis acompanhados de roteiros

1.1.7.4. Implementar e manter uma rotação das equipes de prontidão

1.1.8. Documentação

1.1.8.1. Documentação completa, atualizada e centralizada contendo todas informações relevantes e essenciais

1.1.8.2. Compreensão organizacional nos níveis de desenvolvedor, equipe e ecossistema

1.2. Desafios microsserviços

1.2.1. Estrutura organizacional isolada Comunicação deficiente entre equipes

1.2.1.1. Lei de Conway Reversa - Estrutura da empresa reflete arquitetura de sistema

1.2.1.2. Dificuldade de montar organização operacional

1.2.1.3. Mesma equipe precisa desenvolver, operar, corrigir e monitorar

1.2.2. Aumento dramático da dispersão técnica

1.2.3. Maior capacidade de falha do sistema

1.2.4. Competição por recursos de engenharia e infraestrutura

1.3. Desafios monolítico

1.3.1. Escalabilidade

1.3.2. Falta de eficiência

1.3.3. Dificuldade de adotar novas tecnologias

1.3.4. Velocidade no desenvolvimento

1.4. Camadas

1.4.1. Camada 1: hardware

1.4.1.1. Gerenciamento de configuração

1.4.1.1.1. Ansible

1.4.1.1.2. Chef

1.4.1.1.3. Puppet

1.4.1.2. Sistema operacional

1.4.1.3. Monitoramento

1.4.1.3.1. Nagios

1.4.2. Camada 2: comunicação

1.4.2.1. Rede

1.4.2.2. DNS

1.4.2.3. RPCs

1.4.2.4. Endpoints de APIs

1.4.2.5. Service Discovery

1.4.2.5.1. etcd

1.4.2.5.2. Consul

1.4.2.5.3. Hyperbahn

1.4.2.5.4. ZooKeeper

1.4.2.6. Service registry

1.4.2.7. Balanceamento de carga

1.4.2.7.1. Aws elastic load balancear

1.4.2.7.2. Netflix eureka

1.4.2.7.3. HAProxy

1.4.2.7.4. Nginx

1.4.2.8. Troca de mensagens

1.4.2.8.1. Apache Kafka

1.4.2.8.2. RabbitMQ

1.4.3. Camada 3: plataforma de aplicação

1.4.3.1. Ferramentas internas de desenvolvimento do tipo autosserviço

1.4.3.2. Ambiente de desenvolvimento

1.4.3.3. Ferramenta de teste, empacotamento, build e liberação

1.4.3.4. Pipeline de deployment

1.4.3.5. Logging em nível de microsserviço

1.4.3.6. Monitoramento em nível de microsserviço

1.4.4. Camada 4: microsserviços

1.4.4.1. Todas as configurações específicas dos microsserviços

1.4.4.2. Microsserviços

2. Codificador limpo

2.1. Ensino, aprendizagem e habilidade

2.1.1. Ensino

2.1.1.1. Maioria dos bons programadores não saíram de universidades

2.1.1.2. Maioria dos bons programadores são autodidatas e continuam aprendizado sempre

2.1.1.3. Bons manuais

2.1.1.4. Experiências (na marra)

2.1.2. Aprendizagem

2.1.2.1. Exemplo dos médicos: residência

2.1.2.2. Mestres

2.1.2.2.1. Já assumiram liderança em mais de um projeto

2.1.2.2.2. ~10 anos

2.1.2.2.3. Sabem lidar e coordenar equipes

2.1.2.2.4. São designers e arquitetos

2.1.2.2.5. Mantém papel técnico por meio de leitura, estudo, prática, desempenho e ensino

2.1.2.3. Operadores

2.1.2.3.1. Programadores treinados, competentes e energéticos

2.1.2.3.2. ~5 anos

2.1.2.3.3. Conhecimento de tecnologia atual, mas não de muitas

2.1.2.3.4. São supervisionados por mestres

2.1.2.3.5. São professores dos aprendizes

2.1.2.4. Aprendizes

2.1.2.4.1. Começo da carreira

2.1.2.4.2. ~1 ano

2.1.2.4.3. Supervisionados por operadores

2.1.2.4.4. Não recebem tarefas, mas dão assistência

2.1.2.4.5. São ensinados nas disciplinas: TDD, refatoração, estimativas...

2.1.2.5. Realidade

2.1.2.5.1. Maioria das supervisões não são técnicas!

2.1.2.5.2. Supervisões devem ser técnicas!

2.1.2.5.3. Deve ser um programa focado no ensino, treinamento, supervisão e revisão técnica

2.1.3. Habilidade

2.1.3.1. Arte

2.1.3.2. Habilidade, qualidade, experiência e competência

2.1.3.3. Mentalidade profissional

2.1.3.4. Valores, disciplinas, técnicas, atitudes e respostas

2.1.3.5. Não se convence ninguém a se tornar um artesão de software, você deve dar o exemplo, mostrar sua arte

2.2. Projetos e equipes

2.2.1. Não divida a equipe

2.2.2. Tenha uma equipe que possa assumir vários projetos

2.2.3. É difícil montar uma equipe

2.2.4. Priorização de projetos fica por conta da empresa

2.2.5. É de responsabilidade do gestor de projeto lutar pela prioridade de seu projeto

2.3. Colaboração

2.3.1. Programadores vs Pessoas

2.3.1.1. Não nos tornamos programadores porque gostamos de pessoas

2.3.1.2. Gostamos do relacionamento previsível das máquinas

2.3.2. Programadores vs Empregadores

2.3.2.1. Esteja alinhado com as metas e objetivos do seu empregador

2.3.2.2. Se for o melhor profissional mas não estar alinhado, está fora

2.3.3. Programadores vs Programadores

2.3.3.1. Código deve ser da equipe

2.3.3.2. Seu código deve estar preparado pra qualquer um modificar

2.3.3.3. Trabalhe mais em duplas, se é útil nas emergências, é útil em todos casos

2.3.3.3.1. Saiba se a tarefa é tão trivial que não valha a pena

2.3.3.3.2. Saiba se você realmente precisa se concentrar pra finalizar

2.3.3.3.3. Saiba também quando o problema é complexo e é melhor resolver em dupla

2.4. Pressão

2.4.1. Como você gostaria que um médico agisse em uma cirurgia?

2.4.2. Mantenha a calma e decisões firmes

2.4.3. Empresa sempre irá querer a data de entrega para "eliminar" o risco

2.4.4. Você deve mostrar as probabilidades, quantificar o risco

2.4.5. Trabalho sujo e rápido nunca é bom

2.4.6. Não ficar polindo código, mas não tolere bagunça!

2.4.7. Siga as disciplinas, em tempos de crise ou não

2.4.8. Comunique sempre! O mais rápido possível!

2.4.9. Comunique caso algo dê errado e mostre os planos para colocar o trem de volta nos trilhos

2.4.10. Peça ajuda! Peça ajuda! Peça ajuda!

2.5. Estimativa

2.5.1. Ponte entre negócio e desenvolvedores

2.5.1.1. Parte dos fracassos são causados por ela

2.5.1.2. Fonte de todas desconfianças que governam essa relação

2.5.2. O que é?

2.5.2.1. Empresa enxerga como comprometimento

2.5.2.2. Desenvolvedores enxergam como palpites

2.5.2.3. Estimativas são palpites, porque não sabemos quanto tempo levará

2.5.2.4. Uma estimativa não é um número é uma DISTRIBUIÇÃO

2.5.2.4.1. Probabilidades!

2.5.3. PERT para distribuição das estimativas

2.5.4. Lei dos números grandes

2.5.4.1. Dividir tarefas em várias pequenas

2.5.4.2. A soma das tarefas menores é mais precisa

2.5.4.3. Porque os erros das tarefas pequenas tendem a se integrar

2.5.5. Provável que leve 3 dias, mas pode levar até 7 dias

2.5.5.1. E você pode TENTAR não levar mais de 5 dias?

2.5.5.2. Se você aceitar TENTAR, fez um compromisso e deve honra-lo

2.6. Gerenciamento de tempo

2.6.1. Reuniões

2.6.1.1. São necessárias

2.6.1.2. São um enorme desperdício de tempo

2.6.1.3. Objetivo de administrar seu tempo

2.6.1.3.1. Saiba recusar

2.6.1.3.2. Saiba sair quando sua presença não for mais necessária

2.6.1.3.3. Até seu gerente deve entender pois objetivo dele é você trabalhando também

2.6.1.4. Tenha sempre uma programação e uma meta

2.6.2. Foco-mana

2.6.2.1. Sono influencia

2.6.2.2. Cafeína influência

2.6.2.3. Recarga com falta de foco

2.6.3. Pomodoro

2.6.4. Cuidar com inversão de prioridades

2.6.4.1. Fazer uma atividade menos prioritária porque não está afim de fazer a mais prioritária

2.7. Estratégias de teste

2.7.1. QA faz parte da equipe

2.7.1.1. Como especificadores

2.7.1.2. Como caracterizadores

2.7.2. Pirâmide de testes de automação

2.7.2.1. 1. Testes exploratórios manuais

2.7.2.1.1. ~5%

2.7.2.1.2. Intenção de explorar o sistema em busca de inconsistências

2.7.2.2. 2. Testes de sistema

2.7.2.2.1. ~10%

2.7.2.2.2. GUI

2.7.2.2.3. Não testam regras da empresa diretamente

2.7.2.2.4. Testa se as partes estão interoperando corretamente

2.7.2.2.5. São feitos por arquitetos e principais técnicos

2.7.2.2.6. Executados com menos frequência

2.7.2.3. 3. Testes de integração

2.7.2.3.1. ~25%

2.7.2.3.2. API

2.7.2.3.3. São coreografados

2.7.2.3.4. Não testam regras da empresa

2.7.2.3.5. Testam integração entre componentes

2.7.2.3.6. Somente para sistemas muito grandes

2.7.2.3.7. Escritos por arquitetos e principais técnicos

2.7.2.3.8. Testam desempenho, taxa de transferência, etc

2.7.2.3.9. Não costumam ser executados na integração continua porque demora

2.7.2.4. 4. Testes de componentes

2.7.2.4.1. ~50%

2.7.2.4.2. API

2.7.2.4.3. Escritos pelo QA com ajuda do desenvolvimento

2.7.2.4.4. Testam componentes de negócio

2.7.2.4.5. Ferramentas

2.7.2.5. 5. Testes de unidade

2.7.2.5.1. ~100%

2.7.2.5.2. XUnit

2.7.2.5.3. Implementados por desenvolvedores

2.8. Teste de aceitação

2.8.1. Comunicando requisitos

2.8.1.1. Quando negócio recebe a funcionalidade obtém uma ideia melhor do todo e muda seu conceito inicial

2.8.1.2. Isso é o princípio da incerteza

2.8.2. Decisão prematura

2.8.2.1. Negócio quer saber exatamente o que vai receber

2.8.2.2. Desenvolvedores querem saber exatamente o que vão entregar antes de estimar

2.8.3. Ansiedade de estimativa

2.8.3.1. Desenvolvedores profissionais entendem que podem fazer estimativas com requisitos de baixa precisão

2.8.3.2. Adicionar barras de erro nas estimativas

2.8.4. Ambiguidade tardia

2.8.4.1. Deixar para definir os requisitos mais tarde possível

2.8.4.2. Mesmo assim pode haver ambiguidade até em uma conversa cara a cara

2.8.5. Definição de pronto

2.8.5.1. Acabou de codificar mas não testou?

2.8.5.2. Codificou e testou?

2.8.5.3. Codificou, testou e stakeholder aceitou?

2.8.5.4. Pronto para produção!

2.8.6. Comunicação

2.8.6.1. Transparência

2.8.6.2. Precisão

2.8.7. Automação

2.8.7.1. Sempre automatizado

2.8.7.2. Razão: custo!

2.8.8. Agressão passiva

2.8.8.1. É isso que o teste diz então é isso que vou fazer, mesmo estando errado

2.8.8.2. Não é profissional

2.8.8.3. Trabalho em equipe sempre

2.8.9. Aceitação vs Unidade

2.8.9.1. Função primária documentar design, estrutura e comportamento

2.8.9.2. Unidade: de programador para programador

2.8.9.3. Aceitação: negócio para negócio

2.8.9.4. Não são redundantes, testam as coisas por caminhos diferentes

2.8.9.5. Aceitação: BDD, Selenium, testa API, testa GUI

2.9. Prática

2.9.1. Coding dojo

2.9.1.1. Kata

2.9.1.2. Wasa

2.9.1.3. Randori

2.9.2. Ampliando experiência

2.9.2.1. Projetos de código aberto

2.9.2.2. Pratique ética - sua responsabilidade seu tempo

2.9.2.3. Pratique outros idiomas (linguagens)

2.9.3. Todos profissionais praticam

2.9.3.1. Pratique quando não está sendo pago

2.9.3.2. Pratique para ser pago e bem pago

2.9.3.3. Mantenha habilidades em dia

2.9.3.4. Adquira novas habilidades

2.10. Desenvolvimento guiado por testes (TDD)

2.10.1. Ciclo de tempo 30 segundos

2.10.2. 3 leis

2.10.2.1. 1. Não escrever nenhum código de produção até ter escrito antes um teste de unidade que detecte uma falha

2.10.2.2. 2. Não escrever mais de um teste de unidade do que o suficiente para a falha

2.10.2.3. 3. Não escrever mais códigos de produção que sejam suficientes para passar pelo atual teste de unidade

2.10.3. Benefícios

2.10.3.1. Certeza do funcionamento

2.10.3.2. Baixa taxa de injeção de defeitos

2.10.3.3. Coragem para mudanças e limpezas do código

2.10.3.4. Documentação no nível de design mais baixo

2.10.3.5. Força um design dissociado

2.10.3.5.1. Testes depois são defensivos

2.10.3.5.2. Testes antes são ofensivos

2.10.4. As vezes atrapalha

2.10.4.1. São exceções, mas se faz mais mal do que bem não faz sentido usar

2.11. Codificando

2.11.1. Preparação

2.11.1.1. 1. Seu código precisa funcionar

2.11.1.2. 2. Seu código precisa resolver o problema proposto por seu cliente

2.11.1.3. 3. Seu código precisa se enquadrar bem no sistema que já existe

2.11.1.4. 4. Seu código precisa ser inteligível para outros programadores

2.11.2. Atrapalham a codificação

2.11.2.1. Codificar cansado

2.11.2.2. Codificar preocupado

2.11.2.3. Zona de fluxo

2.11.2.3.1. Diminui a visão do todo

2.11.2.4. Interrupções

2.11.2.4.1. Fica bravo? Então está na zona de fluxo

2.11.2.4.2. TDD ajuda a voltar ao contexto

2.11.2.4.3. Se disponha a ajudar, a próxima interrupção pode ser sua

2.11.3. Depuração

2.11.3.1. Trabalhe para diminuir o tempo de depuração

2.11.3.2. Escreva testes e precisará depurar menos

2.11.3.3. Médicos não gostam de reabrir pacientes

2.11.3.4. Se você cria muitos bugs não está sendo profissional

2.11.4. Estabelecendo o ritmo

2.11.4.1. Programar é maratona, não corrida de velocidade

2.11.4.2. Saiba quando se afastar

2.11.4.2.1. Dê ao seu subconsciente criativo uma pausa do problema

2.11.4.3. Dirigindo pra casa

2.11.4.4. O banho

2.11.5. Atrasando-se

2.11.5.1. Você vai se atrasar

2.11.5.2. Esperança

2.11.5.2.1. Se a entrega é em 10ndias e sua estimativa 12 você não vai entregar

2.11.5.2.2. Não deixe que as pessoas tenham esperança

2.11.5.3. Apressar-se

2.11.5.3.1. Não fique tentando se apressar

2.11.5.3.2. Não tome atalhos, não pule etapas

2.11.5.3.3. Receita para o desastre

2.11.5.4. Hora extra

2.11.5.4.1. Não concorde a não ser que...

2.11.5.5. Falsa entrega

2.11.5.5.1. Talvez o comportamento mais antiprofissional

2.11.5.5.2. Defina TERMINAR

2.11.6. Ajuda

2.11.6.1. Ajudando os outros

2.11.6.2. Sendo ajudado

2.11.6.3. Ensino

2.12. Dizendo sim

2.12.1. Comprometimento

2.12.1.1. 3 partes

2.12.1.1.1. 1. Você diz que fará

2.12.1.1.2. 2. Você é honesto

2.12.1.1.3. 3. Você de fato o faz

2.12.1.2. Reconhecendo a falta de comprometimento

2.12.1.2.1. Preciso / deveria

2.12.1.2.2. Espero / gostaria

2.12.1.2.3. Vamos

2.12.1.3. Como soa o comprometimento

2.12.1.3.1. Você, pessoalmente, sempre tem algo sob seu controle

2.12.1.3.2. Eu irei... na...

2.12.1.3.3. Eu dependo da pessoa X pra fazer isso

2.12.1.3.4. Eu não sei de fato se isso pode ser feito

2.12.1.3.5. Às vezes, eu simplesmente não consiguirei

2.12.1.3.6. Profissionais não dizem sim pra tudo

2.13. Dizendo não

2.13.1. Papéis contraditórios

2.13.1.1. Gerentes e programadores

2.13.1.2. Encontrar meta em comum

2.13.1.2.1. Gerente: tela de login pra amanhã!

2.13.1.2.2. Dev: amanhã é impossível

2.13.1.2.3. Gerente: o que conseguimos entregar?

2.13.1.2.4. Dev: usuário e senha fixo e entra no sistema

2.13.1.2.5. Gerente: ok! Serve!

2.13.1.3. Tentar

2.13.1.3.1. A pior coisa a se falar

2.13.1.3.2. Quer dizer qie se aplicar esforço extra consegue entregar?

2.13.1.3.3. Então estava guardando esse esforço?

2.13.1.3.4. Tentar é se comprometer com esse esforço extra!

2.13.1.3.5. Tentar é afirmar que tem um plano novo. Qual é esse plano?

2.13.1.3.6. Se não tem um outro plano então está sendo desonesto, mentindo!

2.13.2. O custo de dizer sim

2.13.2.1. Expectativa?

2.13.2.2. Fica sem um plano alcançável

2.13.2.3. Resultado inesperado

2.13.2.4. Não tente ser herói

2.14. Profissionalismo

2.14.1. Ética de trabalho

2.14.1.1. Sua carreira é sua responsabilidade

2.14.1.1.1. Aprendizagem contínua

2.14.1.1.2. Pratique

2.14.1.1.3. Colaboração

2.14.1.1.4. Ensino

2.14.1.1.5. Conheça seu domínio

2.14.1.1.6. Identifique-se com seu cliente

2.14.1.1.7. Humildade

2.14.2. Não cause danos

2.14.2.1. Ao funcionamento

2.14.2.1.1. QA não deve encontrar nada

2.14.2.1.2. Teste, teste, teste e teste de novo

2.14.2.2. A estrutura

2.14.2.2.1. Software precisa ser fácil de mudar

3. Código limpo

3.1. Código limpo

3.1.1. Código representa os detalhes dos requisitos

3.1.2. Especificar requisitos de forma que máquinas possam executar

3.1.3. Premissa: um bom código importa!

3.1.4. O custo de um código ruim aumenta conforme o tempo, a produtividade diminui com o tempo

3.1.5. E daí a gerência só consegue fazer uma coisa: colocar cada vez mais gente

3.1.6. Requisitos ruins, prazos, pressão não são desculpas... A culpa é nossa mesmo

3.1.7. Difícil de engolir mas gerentes buscam compromissos nossos, que nós assumimos

3.1.8. Saber distinguir um quadro ruim de um bom não significa que saibamos pintar

3.1.9. Não basta escrever um código bom, ele precisa ser mantido bom

3.2. Nomes significativos

3.2.1. Use nomes que revelam seu propósito: leva tempo, mas economiza mais

3.2.2. Evite informações erradas: accounts ao invés de accountList pois list tem significado em programação

3.2.3. Faça distinções significativas: copyChars(a1, a2) para copyChars(source, destination)

3.2.4. Use nomes pronunciáveis: sem abreviações

3.2.5. Use nomes passíveis de busca

3.2.5.1. O tamanho de um nome deve ser proporcional ao tamanho do seu escopo

3.2.5.2. Lembrar das constantes!

3.2.6. Não utilizar notação húngara em linguagens atuais

3.2.7. Não usar prefixos em variáveis

3.2.8. Interfaces e implementações

3.2.8.1. Não usar I na frente, cliente não precisa saber que é uma interface

3.2.8.2. Utilizar alteração no nome na implementação

3.2.9. Nomes de classes devem ser substantivos e nunca verbos

3.2.10. Nomes de métodos devem ser verbos e nunca substantivos. Preferência pelo infinitivo

3.2.11. Quando construtores estiverem sobrecarregados utilize factory method e deixe-os privados

3.2.12. Selecione uma palavra por conceito para não ter fetch, retrieve e get no mesmo código

3.2.13. Use nomes a partir do domínio da solução: Repository, Factory, Visitor

3.2.14. Use nomes de domínios do problema: código representa negócio

3.3. Funções

3.3.1. Pequenas! Muito pequenas!

3.3.2. Blocos e indentação

3.3.2.1. Dentro de if else while devem ter apenas uma linha

3.3.2.2. Estruturas aninhadas no máximo um ou dois

3.3.3. Faça apenas uma coisa

3.3.3.1. Como saber se é uma coisa?

3.3.3.2. Pergunte PARA QUE serve!

3.3.3.3. Podem fazer coisas em níveis de abstrações diferentes

3.3.3.4. Quando fazem uma coisa só não podem ser divididas em seções

3.3.3.5. Uma função tem somente um mesmo nível de abstração

3.3.4. Ler o código de cima pra baixo: regra decrescente

3.3.4.1. Descendo o nível de abstração

3.3.5. Instruções switch

3.3.5.1. Deixar debaixo de uma factory criando estruturas polimórficas

3.3.5.2. Devem aparecer apenas uma única vez

3.3.6. Use nomes descritivos: nomes grandes e descritivos são melhores que longos comentários explicativos

3.3.7. Parâmetros

3.3.7.1. Quantidade ideal é zero

3.3.7.2. Depois vem um parâmetro

3.3.7.3. Seguido de dois parâmetros

3.3.7.4. Sempre que possível evitar 3 parâmetros

3.3.7.5. Para mais de 3 parâmetros deve-se ter um motivo muito especial

3.3.7.5.1. Mesmo assim não devem ser usados

3.3.7.6. Muitos parâmetros dificultam os testes também: como testar todas combinações?

3.3.7.7. Parâmetros lógicos são feios!

3.3.7.7.1. Já deixa explícito que a função faz mais de uma coisa

3.3.7.8. New Point(0,0) são componentes de um só valor

3.3.7.9. Agrupar valores em objetos

3.3.8. Evite efeitos colaterais: fazer algo que não está no nome da função

3.3.8.1. Função checkPassword que inicia uma sessão

3.3.9. Evitar parâmetros de saída

3.3.10. Prefira excessões a retorno de códigos de erro

3.3.11. Tratamento de erro é uma coisa só

3.3.11.1. Try e catch devem ter uma chamada de função abaixo só

3.3.12. Evite repetição de código!

3.4. Comentários

3.4.1. São no máximo um mal necessário

3.4.2. Quando o código expressa sua intenção, não precisamos de comentários

3.4.3. São para compensar nosso FRACASSO em nós expressar no código

3.4.4. Códigos mudam e comentários nem sempre acompanham

3.4.5. Bons comentários

3.4.5.1. Informativos

3.4.5.2. Explicação de intenção

3.4.5.3. Esclarecimento

3.4.5.4. Alerta sobre consequências

3.4.5.5. TODO

3.4.5.6. Docs em APIs

3.4.6. Maus comentários

3.4.6.1. Murmúrio: não se sabe exatamente o significado

3.4.6.2. Redundante: escrever o que o método faz e retorna se o nome já descreve isso

3.4.6.3. Enganadores: dizem que o código faz uma coisa que não faz

3.4.6.4. Imperativos: não faz sentido toda função ter comentários

3.4.6.5. Longos: exemplo histórico no início do arquivo... Existe versionador pra isso

3.4.6.6. Ruidosos: dizem o óbvio... Default constructor... Ahhh sério?

3.4.6.7. Evite comentário se é possível usar uma função ou variável

3.4.6.8. Marcadores de posição: raramente são necessários

3.4.6.9. Comentários ao lado de fechamento de bloco

3.4.6.10. Créditos e autoria: tem versionador pra isso

3.4.6.11. Código como comentário: não faça isso!

3.4.6.12. Informações não locais: coloque comentário perto do código que ele descreve, senão nunca será atualizado

3.4.6.13. Informações excessivas: não adicione discussões históricas em comentário

3.4.6.14. Cabeçalhos de funções: uma função curta não requer muita explicação

3.4.6.15. Docs em códigos não públicos: apenas entulhos e distração

3.5. Formatação

3.5.1. Deixe seu código organizado!

3.5.2. Formatação vertical: 50 mil linhas em arquivos não maiores que 500 linhas

3.5.3. Metáfora do jornal: manchete, artigos...

3.5.4. Espaçamento vertical entre conceitos

3.5.5. Continuidade vertical para mesmos conceitos

3.5.6. Distância vertical

3.5.6.1. Conceitos intimamente ligados devem ficar juntos

3.5.6.2. Declaração de variáveis: o lais pro no de onde serão utilizadas

3.5.6.3. Variáveis de instâncias: agrupadas em um só lugar

3.5.6.4. Funções dependentes: maior abstração acima e demais conforme ordem de chamada

3.5.6.5. Afinidade conceitual: exemplo sobrecargas de métodos (mesmo nome)

3.5.6.6. Ordenação vertical: maior abstração acima, baixo nível abaixo

3.5.6.7. Formatação horizontal: cerca de 120 caracteres são suficientes

3.5.6.8. Regra de equipes: programadores tem suas próprias regras, mas quando trabalham em equipe precisam respeitar as regras da equipe

3.6. Objetos e estruturas de dados

3.6.1. Abstração de dados é preferível: não dê acesso aos dados que o cliente não precisa saber

3.6.2. Antissimetria dado/objeto

3.6.2.1. Estrutura de dados expõem seus dados e não possuem funções significativas

3.6.2.2. Objetos usam abstrações para esconder seus dados e expõem funções que operam em tais dados

3.6.2.3. Código procedural dificulta a adição de novas estruturas de dados, pois todas funções precisariam ser alteradas

3.6.2.4. Código OO dificulta adição de novas funções, pois todas as classes precisam ser alteradas

3.6.2.5. Devemos saber escolher qual tipo de código é melhor em cada caso

3.6.2.6. Às vezes, você realmente deseja estruturas de dados simples com procedimentos operando nelas

3.6.3. Objetos de transferência de dados

3.6.3.1. DTOs: úteis para comunicação

3.6.3.2. Exigem traduções

3.6.3.3. São apenas estrutura de dados

3.6.4. Active Record

3.6.4.1. São estrutura de dados com métodos de navegação: save e find

3.6.4.2. São estrutura de dados e não devem ter regras de negócio neles

3.6.4.3. Crie objetos separados para as regras

3.6.5. Lei de Demeter

3.6.5.1. Fale apenas com conhecidos

3.6.5.2. Método f de uma classe C só deve chamar os métodos de

3.6.5.2.1. C

3.6.5.2.2. Um objeto criado por f

3.6.5.2.3. Um objeto passado como parâmetro pra f

3.6.5.2.4. Um objeto dentro de uma variável de instância C

3.6.5.2.5. O método NÃO deve chamar os métodos em objetos retornados por qualquer outra das funções permitidas

3.6.5.3. Train Wrecks (acidente ferroviário)

3.6.5.3.1. Quando é um objeto ele deve esconder sua estrutura interna

3.6.5.3.2. Quando é estrutura de dados ele expõe sua estrutura de dados

3.6.5.3.3. Híbridos: cuidar para não misturar estrutura de dados e objetos juntos na mesma classe

3.6.5.3.4. Estruturas ocultas: porque o cliente quer acessar aquele dado? Que tal mandar o objeto fazer aquele trabalho?

3.7. Tratamento de erro

3.7.1. Em muitos códigos o tratamento de erros DOMINA

3.7.2. DOMINA significa que tem muitos tratamentos de erros espalhados e isso dificulta o entendimento do código

3.7.3. Obscurecer a lógica está errado!

3.7.4. Use exceções em vez de retornar códigos

3.7.4.1. Dessa forma você divide as duas lógicas (sucesso e erro)

3.7.5. Use exceções não verificadas

3.7.5.1. Em Java precisa declarar as exceções lançadas

3.7.5.1.1. Isso fere o princípio Open-Closed, pois todas as classes superiores precisam ser alteradas

3.7.6. Forneça exceções com contexto

3.7.6.1. Deve saber a fonte e localização de um erro: mensagens informativas (operação e tipo de falha)

3.7.7. Defina as classes de exceções segundo as necessidades do chamador

3.7.7.1. Como sua exceção é capturada?

3.7.7.2. Criar wrapper para exceções

3.7.8. Não retorne null

3.7.8.1. Retorne um Special Case Pattern (Fowler)

3.7.8.2. Minimize as chances de um NullPointerException

3.7.8.3. Exemplo: retorne uma lista vazia ao invés de null

3.7.9. Não passe null

3.7.9.1. Ideal seria a linguagem não deixar passar null

3.7.9.2. Alternativa é seu método tratar através de afirmações (checks)

3.8. Limites

3.8.1. Uso de códigos de terceiros

3.8.1.1. Crie limites: Map tem muitos métodos e passá-lo adiante alguém pode dar um clear

3.8.1.1.1. Talvez criar uma classe para encapsular seja uma boa ideia: Sensores... Assim só poderão fazer o que você deixar

3.8.1.1.2. Caso haja uma mudança em Map, você mudará só está classe e o resto não será afetado

3.8.2. Testes de aprendizagem

3.8.2.1. Faça testes das bibliotecas ou APIs que irá utilizar

3.8.2.2. Sai de graça pois terá que aprender sobre a API mesmo, aprenda fazendo testes

3.8.2.3. Isso facilitará encapsular depois

3.8.3. Uso de código que não existe ainda

3.8.3.1. Se você sabe do que vai precisar, crie a interface e depois integre

3.8.3.2. Permite realizar mock com um objeto fake também e já realizar testes

3.9. Testes de unidade

3.9.1. 3 leis do TDD

3.9.1.1. 1. Não se deve escrever o código de produção até criar um teste de unidade de falhas

3.9.1.2. 2. Não se deve escrever mais de um teste de unidade do que o necessário para falhar, e não compilar é falhar

3.9.1.3. 3. Não se deve escrever mais códigos de produção do que o necessário para aplicar o teste de falha atual

3.9.1.4. Rotina de 30 segundos!

3.9.2. Códigos de testes são tão importantes quanto de produção

3.9.2.1. Devem ser implementados com cuidado e limpos, senão vão dificultar a manutenção no futuro

3.9.3. Testes de unidades mantém o código de produção flexíveis, reutilizáveis e passíveis de manutenção

3.9.4. Quanto maior a cobertura menor o medo de mudar

3.9.5. O que torna um teste limpo? LEGIBILIDADE

3.9.6. Código de testes devem poder ser lidos da mesma forma que os de produção

3.9.7. Padrão: arrange/act/assert

3.9.8. Padrão: given/when/then

3.9.9. Um único conceito por teste

3.9.10. FIRST

3.9.10.1. Fast (rapidez): devem executar rápido, caso contrário você não executará com frequência

3.9.10.2. Independent (independência): um teste não deve depender de outro

3.9.10.3. Repeatable (repetitividade): deve-se poder repetir o teste em qualquer ambiente

3.9.10.4. Self-validating (autovalidação): testes devem ter uma saída booleana, não sendo necessário analisar nenhum arquivo ou algo do tipo

3.9.10.5. Timely (pontualidade): testes precisam ser escritos em tempo hábil, antes do código de produção, senão pode ficar difícil e você não vai implementá-los

3.10. Classes

3.10.1. Organização

3.10.1.1. Mantenha um padrão de organização: variáveis métodos construtor...

3.10.1.2. Mantenha o padrão para o projeto/equipe

3.10.2. Encapsulamento

3.10.2.1. Mantenha privado mas caso necessário quebre para testes, eles tem prioridade

3.10.3. As classes devem ser pequenas!

3.10.3.1. O tamanho é medido em responsabilidades! Apenas 1 responsabilidade!

3.10.3.2. Escolher um bom nome é o início para definir a responsabilidade

3.10.4. Princípio da responsabilidade única

3.10.4.1. Uma função, classe ou módulo devem ter 1 e apenas 1 motivo para mudar

3.10.5. COESÃO

3.10.5.1. Pequeno número de variáveis de instância

3.10.5.2. Cada método manipula uma ou mais variáveis

3.10.5.3. Quanto mais variáveis de instância um método manipular, mais coeso ele é para a classe

3.10.5.4. Tente separar as variáveis e métodos em classes menores para que fiquem mais coesos

3.10.5.5. Separar funções grandes em pequenas normalmente nos ajudam a dividir classes também observando a coesão

3.10.5.6. Sempre que tivermos realizar uma alteração em uma classe e percebemos que é necessário refatorar, refatore!

3.10.5.7. SRP e Open-Closed sempre! Qual o motivo para mudar? No singular!

3.10.5.8. Classes concretas contém entalhes da implementação

3.10.5.9. Classes abstratas (e interfaces) representam apenas conceitos

3.10.5.10. Sempre que depender de alguém crie uma classe abstrata ou interface e faça sua classe depender desta abstração

3.11. Sistemas

3.11.1. Separa a construção e uso do sistema

3.11.1.1. Injeção de dependência

3.11.2. Desenvolvimento gradual

3.11.2.1. Pense em como é construída uma cidade

3.11.2.2. Você faria uma rua de 4 pistas logo de cara? Ou iria alargar conforme necessário?

3.11.2.3. Mito dizer que podemos conseguir um sistema "correto de primeira"

3.11.2.4. Arquitetura do sistema pode crescer gradualmente SE mantivermos uma separação devida de preocupações

3.11.3. Separar preocupações. Ex: estruturas de banco do domínio Validação da classe DTO

3.11.3.1. Uma forma é com programação orientada a aspectos: annotation do java

3.11.4. Use padrões sabiamente quando eles adicionarem um valor demonstrativo

3.11.4.1. Padrões de projeto quando você sabe que algo vai mudar mesmo

3.11.4.2. Arquitetura de microsserviços quando você sabe da necessidade dela

3.11.5. Sistemas precisam de uma linguagem específica a um domínio

3.11.5.1. DDD

3.11.5.2. DSL minimiza a distância da comunicação

3.12. Emergência

3.12.1. 4 regras de um projeto simples (Kent Beck)

3.12.1.1. 1. Efetuar todos os testes

3.12.1.1.1. Vai seguir SRP porque é mais fácil testar assim

3.12.1.1.2. Vai seguir DIP porque acoplamento alto é difícil de testar

3.12.1.1.3. Com testes podemos refatorar a todo momento

3.12.1.2. 2. Sem duplicação de código

3.12.1.2.1. Refatoração a todo momento

3.12.1.2.2. Template Method evita duplicação de código

3.12.1.3. 3. Expressar o propósito do programador

3.12.1.3.1. Quanto mais os outros entenderem menos tempo será gasto com manutenção

3.12.1.3.2. Manutenção de software sempre será o maior custo porque o negócio muda a todo momento e o software também

3.12.1.3.3. Padrões de projeto são modos de comunicação e expressividade

3.12.1.3.4. Testes de unidade bem escritos também são expressivos

3.12.1.4. 4. Minimizar o número de classes e métodos

3.12.1.4.1. Adotar uma abordagem mais pragmática e com menos dogmatismo

3.12.1.4.2. Excesso de SRP pode causar isso

3.13. Concorrência

3.13.1. Estratégia de desacoplamento, separa o que é executado de quando é executado

3.13.2. Mitos e conceitos equivocados

3.13.2.1. A concorrência sempre melhor desempenho

3.13.2.1.1. Só se houver um tempo de espera muito grande que possa ser dividido entre múltiplas threads

3.13.2.2. O projeto não muda ao criar programas concorrentes

3.13.2.2.1. Um algoritmo concorrente pode ser consideravelmente diferente de um de apenas uma thread

3.13.2.3. Entender as questões de concorrência não é importante quando se trabalha com um container web ou EJB

3.13.2.3.1. É melhor saber apenas o que seu container está fazendo e como protegê-lo da concorrência e deadlock

3.13.3. Princípios para proteção da concorrência

3.13.3.1. SRP

3.13.3.1.1. Mantenha o código voltado para concorrência separado do resto

3.13.3.2. Limite o escopo dos dados: região crítica

3.13.3.3. Use cópia dos dados

3.13.3.4. Threads devem ser o mais independentes possíveis

3.13.3.5. Conheça os métodos

3.13.3.5.1. Produtor consumidor

3.13.3.5.2. Editores e escritores

3.13.3.5.3. Dining Philosophers (problema dos filósofos)

3.13.3.6. Cuidado com dependências entre métodos sincronizados

3.13.3.6.1. Evite usar mais de um método em um objeto compartilhado

3.13.3.7. Mantenha suas seções sincronizadas as menores possíveis, pois criam bloqueio

3.13.3.8. ...

3.14. Refinamento sucessivo

3.14.1. Programar é mais uma arte do que uma ciência

3.14.2. Para fazer a versão final da redação, primeiro você faz um rascunho

3.14.3. Para fazer um código limpo, primeiro você faz um sujo

3.15. Odores e heurísticas

3.15.1. Comentários

3.15.1.1. C1: informações inapropriadas

3.15.1.2. C2: comentário obsoleto

3.15.1.3. C3: comentários redundantes

3.15.1.4. C4: comentário mal escrito

3.15.1.5. C5: código como comentário

3.15.2. Ambiente

3.15.2.1. A1: construir requer mais de uma etapa

3.15.2.2. A2: testes quererem mais de uma etapa

3.15.3. Funções

3.15.3.1. F1: parâmetros em excesso

3.15.3.2. F2: parâmetros de saída

3.15.3.3. F3: parâmetros lógicos

3.15.3.4. F4: função morta

3.15.4. Geral

3.15.4.1. G1: múltiplas linguagens em um arquivo fonte

3.15.4.2. G2: comportamento óbvio não é o implementado

3.15.4.3. G3: comportamento incorreto nos limites

3.15.4.4. G4: seguranças anuladas

3.15.4.5. G5: duplicação

3.15.4.6. G6: códigos no nível errado de abstração

3.15.4.7. G7: as classes base dependem de suas derivadas

3.15.4.8. G8: informações excessivas

3.15.4.9. G9: código morto

3.15.4.10. G10: separação vertical

3.15.4.11. G11: inconsistência

3.15.4.12. G12: entulho

3.15.4.13. G13: acoplamento artificial

3.15.4.14. G14: feature envy

3.15.4.15. G15: parâmetros seletores

3.15.4.16. G16: propósito obscuro

3.15.4.17. G17: responsabilidade mal posicionada

3.15.4.18. G18: modo estático inadequado

3.15.4.19. G19: use variáveis descritivas

3.15.4.20. G20: nomes de funções devem dizer o que elas fazem

3.15.4.21. G21: entenda o algoritmo

3.15.4.22. G22: torne dependências lógicas em físicas

3.15.4.23. G23: prefira polimorfismo a if/else ou switch/case

3.15.4.24. G24: siga as Convenções padrões

3.15.4.25. G25: substitua os números mágicos por constantes com nomes

3.15.4.26. G26: seja preciso

3.15.4.27. G27: estrutura acima de convenção

3.15.4.28. G28: encapsule as condicionais

3.15.4.29. G29: evite condicionais negativas

3.15.4.30. G30: as funções devem fazer uma coisa só

3.15.4.31. G31: acoplamentos temporais ocultos

3.15.4.32. G32: não seja arbitrário

3.15.4.33. G33: encapsule as condições de limites

3.15.4.34. G34: funções devem descer apenas um nível de abstração

3.15.4.35. G35: mantenha os dados configuráveis em níveis altos

3.15.4.36. G36: evite a navegação transitiva

3.15.5. Nomes

3.15.5.1. N1: escolha nomes descritivos

3.15.5.2. N2: escolha nomes no nível apropriado de abstração

3.15.5.3. N3: use uma nomenclatura padrão onde for possível

3.15.5.4. N4: nomes não ambíguos

3.15.5.5. N5: use nomes longos para escopos grandes

3.15.5.6. N6: evite codificações

3.15.5.7. N7: nomes devem descrever os efeitos colaterais

3.15.6. Testes

3.15.6.1. T1: testes insuficientes

3.15.6.2. T2: use uma ferramenta de cobertura

3.15.6.3. T3: não pule testes triviais

3.15.6.4. T4: um teste ignorado é uma questão sobre uma ambiguidade

3.15.6.5. T5: teste as condições de limites

3.15.6.6. T6: teste abundantemente bugs próximos

3.15.6.7. T7: padrões de falhas são reveladores

3.15.6.8. T8: padrões de cobertura de testes podem ser reveladores

3.15.6.9. T9: testes devem ser rápidos