Código simples - Navalha de Occam para desenvolvedores

Hoje muitas ferramentas/linguagens para desenvolvimento de software fornecem uma facilidade tão grande que alguns desenvolvedores conseguem inserir complexidade onde era simples. Vamos discutir essas práticas de complexidade desnecessária, seja no código, seja na infraestrutura, seja no modo de pensar onde ainda algumas vezes perdura um sentimento de que a complexidade estaria associada á código mais 'profissional' ou 'hacker', quando as soluções mais simples se mostram cada vez mais melhores para desenvolvimento de software a curto, médio e longo prazo.

Transcript

1. Código simples Navalha de Occam para desenvolvedores
2. Eustáquio Rangel @taq eustaquiorangel@gmail.com
3. Navalha de Occam Formulada pelo filósofo medieval Guilherme de Occam (por vezes grafado Ockham), a lex parsimoniae (lei da parcimônia) é um princípio, solucionador de problemas, filosófico reducionista, que permite distinguir entre teorias equivalentes e pode ser utilizado como técnica para formulação de modelos teóricos. Em resumo, entre duas teorias com resultados iguais, que explicam ou preveem os mesmos fenômenos, devemos escolher a mais simples.
4. "Pluralitas non est ponenda sine neccesitate" "Pluralidade não deve ser colocada sem necessidade"
7. Complexidade ciclomática Complexidade ciclomática (ou complexidade condicional) é uma métrica de software usada para indicar a complexidade de um programa de computador. Desenvolvida por Thomas J. McCabe em 1976, ela mede a quantidade de caminhos de execução independentes a partir de um código fonte. Essa complexidade é computada através do grafo de fluxo de controle do programa: os nós do grafo correspondem a grupos indivisíveis de comandos, e uma aresta direcionada conecta dois nós se o segundo comando pode ser executado imediatamente após o primeiro. A complexidade ciclomática também pode ser aplicada a funções, módulos, métodos ou classes individuais de um programa. Uma estratégia de teste de software formulada por McCabe é testar cada caminho independente de um programa, de forma que a quantidade de casos de teste será a complexidade ciclomática do programa. https://pt.wikipedia.org/wiki/Complexidade_ciclom%C3%A1tica
8. def hello_world puts "Hello world" end http://blog.8thcolor.com/en/2013/06/did-you-say-complexity-eh/ def hello(name) if name puts "Hello #{name}" end end
9. def hello(name) return unless name puts "Hello #{name}" end https://refactoring.com/catalog/replaceNestedConditionalWithGuardClauses.html
10. Tests are refactoring best friends
11. YAGNI https://pt.wikipedia.org/wiki/YAGNI YAGNI é uma abreviação da expressão de língua inglesa You Ain't Gonna Need It. Em engenharia de software, é uma orientação de trabalho que sugere aos programadores que não adicionem funcionalidades ao código fonte de um programa até que estas sejam realmente necessárias. Ron Jeffries afirma que sempre se deve implementar coisas que se realmente precisa, nunca o que se prevê que um dia irá ser preciso.
12. KISS https://pt.wikipedia.org/wiki/YAGNI Keep It Simple, Mantenha Simples em português (ou : KISS principle acrônimo em inglês de: Keep It Simple, Stupid, ou seja, Mantenha Simples, Estúpido) é um princípio geral que valoriza a simplicidade do projeto e defende que toda a complexidade desnecessária seja descartada. Serve como fórmula útil em diversas áreas como o desenvolvimento de software, a animação, a engenharia no geral e no planejamento estratégico e táctico. Também é aplicado na Literatura, na Música e nas Artes em geral.
13. "Simplicidade é o último grau de sofisticação" Leonardo Da Vinci
14. "Tudo deve ser feito da forma mais simples possível, mas não mais simples que isso" Albert Einstein
15. "A perfeição é alcançada não quando não há mais nada para adicionar, mas quando não há mais nada que se possa retirar" Antoine de Saint-Exupéry
16. “Em programação, a elegância não é um luxo mas sim uma qualidade que decide entre o sucesso e o fracasso.” Edsger Dijkstra
18. https://xkcd.com/1988/
19. Real-World Maintainable Software https://www.oreilly.com/programming/free/real-world-maintainable-software.csp The software development industry is increasingly realizing that success depends on a project’s long-term viability. To help with that effort, the Software Improvement Group (SIG) has identified ten guidelines for delivering code that’s easy to maintain and adapt over time. “It introduces 10 guidelines on writing maintainable ‘real-world’ software that are actually just basic junior level stuff that's centered only on the happy path development.” “That's what I'm striving for and I think the book lacks a lot in monitoring, analytics, continuous integration, continuous deployment and etc. All ‘real’ in my opinion, maintainable software parts that were not mentioned.” https://www.goodreads.com/book/show/32192028-real-world-maintainable-software
20. Vamos conhecer as 10 regras para “júniors” Que muitos “sêniors” por aí não se importam por acharem muito básicas, mesmo que não as apliquem e foquem em apagar os incêndios depois!
21. Escreva pequenas unidades de código Unidades pequenas são mais fáceis de analisar, testar e reutilizar. Métrica sugerida: não mais que 15 linhas por método 1
22. Escreva unidades simples de código Unidades com menos pontos de decisões são mais fáceis de analisar e testar. Quanto mais pontos de decisões/caminhos/branches, mais difícil fica entender o código. 2
23. Escreva código apenas uma vez O famoso DRY, Don't Repeat Yourself. Duplicação deve ser evitada. Além de aumentar consideravelmente o trabalho, pois as alterações também tem que serem feitas nas cópias, é uma causa forte de bugs de regressão. 3
24. Mantenha as interfaces enxutas Evite muitos parâmetros na assinatura de um método. Métodos com assinaturas enxutas são melhores para utilizar e testar. 4
25. Separe os interesses em módulos Módulos e classes com baixo acoplamento são mais fáceis de modificar. Se você não pode explicar o que a classe faz de maneira simples, ela representa mais que um conceito, ou um muito genérico ou abstrato. 5
26. Acoplamento fraco de componentes Parecida com a anterior, mas ao invés de classes e módulos, componentes Alto nível de abstração para evitar que os componentes saibam muito dos detalhes de implementação, deixando eles mais independentes. 6
27. Mantenha o balanço dos componentes Nem pouco, nem muito. Poucos trazem complexidade, muitos trazem falta de controle. 7
28. Mantenha a sua base de código pequena Que acaba sendo consequência das outras regras. Uma maneira de alcançar isso é evitar “future proofing”, que é adicionar à aplicação funcionalidades (que inclusive podem ser relacionadas com otimização prematura) que ainda não foram requisitadas mas que os desenvolvedores acham que vão ser necessárias no futuro. Como recomendação para sistemas Java, o SIG estabelece no máximo 175000 (vixi!) linhas de código. 8
29. Automatize seus testes Rodar os testes de forma manual não funciona. Testes automatizados dão feedback imediato e aumentam a confiança em refatorar o código. 9
30. Escreva código limpo Não é somente uma questão de estilo, indentação ou nomes de variáveis. É antes de mais nada, uma questão de compreensão. O código deve mostrar claramente qual sua finalidade e evitar dúvidas ou mesmo armadilhas, permitindo que qualquer um que o ler vai entender rapidamente e será capaz de o modificar sem fazer erros descuidados. 10
31. Obrigado! :-) @taq eustaquiorangel@gmail.com