Informações gerais
O livro foi escrito por Robert Martin, um popularizador da programação e desenvolvedor experiente. Trata-se de um livro sobre como escrever código mais limpo e organizado. Vamos dar uma olhada rápida no conteúdo do livro.
Resumo das capitulações
A primeira capítulo é puramente teórica e um pouco seca. Nela, é discutida a importância de escrever um bom código e como, a cada mês, manter um código ruim se torna cada vez mais caro — tanto em termos de dinheiro quanto de tempo.
Em seguida, fala-se sobre como nomear variáveis corretamente: elas devem refletir a intenção do programador, e ao ler o nome de uma variável, já deve ser possível entender o que está sendo armazenado e de que tipo de dado se trata. Afirma-se que deve-se evitar nomes abstratos como List, Data, entre outros. O autor também menciona rapidamente a nomeação de métodos e classes — embora isso seja mais detalhado em outros capítulos. As dicas são numerosas, e a maioria delas são lógicas e sensatas. Por um lado, é uma capítulo óbvia e trivial, por outro, talvez muito útil para iniciantes.
A seguir, o livro aborda funções. Aqui começam os temas mais controversos — quantas linhas uma função deve ter, quantos parâmetros ela pode receber. Claro que a resposta é óbvia: quanto menor e mais simples for a função, melhor. No entanto, na prática, isso nem sempre acontece. Também é discutido um conceito lógico e saudável de que uma função deve executar apenas uma ação específica. Ou seja, uma função não deve calcular a média aritmética e imprimir o resultado na tela ao mesmo tempo. Isso está alinhado aos princípios SOLID. Além disso, o autor toca em como trabalhar com condições (if, else, switch), laços de repetição e a construção try/catch. É claro que também aborda a nomeação de funções e o princípio DRY (não repetir código, sempre que possível).
Após as funções, vem um tema igualmente polêmico — os comentários: como e onde usá-los, e onde eles são desnecessários. Comentários jurídicos, de revista e outros tipos são analisados pelo autor, mostrando quando são realmente apropriados.
Se você acha que o tema de comentários é controverso, o que dizer sobre formatação? Esta pequena capítulo vem logo depois dos comentários. E se parece que o assunto será apenas sobre tabs e espaços — não é bem isso. A capítulo é bem mais informativa, com gráficos diferentes apresentados pelo autor.
"Trabalhando com objetos e estruturas de dados" — esse é o título do próximo capítulo. Abstração, assimetria de dados, a Lei de Demeter, DTO, Active Record e outros temas são discutidos nesta pequena seção. O conteúdo é mais superficial, com ênfase no fato de que o programador já deve estar familiarizado com esses conceitos.
Em seguida, o capítulo trata da análise de erros. Muitos exemplos no livro são em Java, então você não verá o tratamento de erros no estilo Golang (via if), o foco está no uso de try/catch. Se alguns capítulos atrás o tema era sobre formatação, agora trata-se de quando, onde e como usar o tratamento de exceções.
A próxima capítulo, "Limites", não fala sobre código como um todo, mas sim sobre arquitetura, mais especificamente sobre a composição e o uso de módulos. Esta seção é pequena, então quem se interessa pelas visões de Robert Martin sobre arquitetura limpa, deve procurar seu outro livro sobre o tema.
Em seguida, temos "Testes". Algumas palavras sobre TDD e, em seguida, sobre como deve ser um teste. O capítulo é pequeno e não muito informativo. Para quem se interessa por testes, posso sugerir um excelente livro, e provavelmente farei um resumo dele em breve.
Agora vem o capítulo sobre "Classes". Novamente, se você vê classes como parte do aprimoramento do código (como faz o tio Bob), o material dedicado a esta seção pode ser suficiente. Mas isso só é verdade se o desenvolvedor já estiver familiarizado com a POO. Caso contrário, se você quiser aprender mais sobre programação orientada a objetos, este capítulo pode parecer superficial ou até difícil.
Os próximos capítulos voltam a tratar de arquitetura. Não, não é a arquitetura em camadas no sentido tradicional que Martin recomenda em outro livro. Aqui, são discutidos conceitos mais básicos. O primeiro capítulo é mais sobre diagramas de blocos do que sobre código. São mencionados rapidamente alguns padrões — fábrica abstrata, injeção de dependência, proxy. No geral, esses capítulos são bons e informativos.
Em seguida, um capítulo sobre multitarefa. Mais teoria do que prática: não há muito código, e o conteúdo é principalmente teórico, e isso de maneira superficial.
Os próximos capítulos abordam refatoração de código, com exemplos de Robert Martin. E aqui, ao contrário de alguns capítulos anteriores, há uma quantidade considerável de código. O autor começa analisando a refatoração de uma ferramenta de linha de comando e depois examina algumas bibliotecas/classes para Java de desenvolvedores experientes. Mesmo para esses especialistas, Martin encontra pontos para criticar — e, na minha opinião, isso é mais uma crítica do que uma refatoração. O código já estava funcionando e tinha uma boa cobertura de testes. A mensagem principal deste capítulo: não basta escrever um código que funcione — ele deve ser fácil de manter, caso contrário, com o tempo, isso se tornará uma tarefa difícil.
A última capítulo é uma espécie de resumo, com dicas que englobam tudo o que foi discutido anteriormente: desde anotações em comentários até o trabalho com funções e testes.
Conclusão
Prós do livro
- A estrutura do livro é bem organizada. Ele é composto por 17 capítulos, com cada capítulo sendo uma leve complicação do anterior. Em outras palavras, ao aprender qualquer linguagem de programação, as pessoas começam com conceitos básicos (variáveis, comentários) e, conforme o conhecimento cresce, passam para funções, classes, assíncrono etc. Esse princípio é seguido no livro, o que é conveniente e familiar.
- A maioria das dicas é realmente útil e lógica. Alguns descobrirão muitas coisas novas, outros quase nada. Isso depende da experiência individual.
- O livro contém ilustrações. São poucas, mas mesmo as que existem têm um estilo consistente, o que é agradável.
Contras do livro
- Não se deve seguir cegamente todos os conselhos. Houve pelo menos alguns, e talvez muitos, "conselhos" com os quais não concordei ou não concordei completamente.
- O livro em si não é pequeno — tem um pouco mais de 450 páginas. E ler livros grandes pode ser difícil para muitas pessoas.
- Os exemplos de refatoração de código (remoção e adição de linhas) poderiam ser apresentados de maneira mais clara. Atualmente, as mudanças são marcadas apenas em negrito (o que foi adicionado) e com o texto riscado (o que foi removido), e talvez uma formatação no estilo de clientes git fosse mais familiar para muitas pessoas.
- Os exemplos são em Java. Não tenho nada contra isso e não tive dificuldades em entender, mas para quem não conhece a linguagem, isso pode ser um ponto negativo.
- Eu li uma versão de 2010 do livro. Talvez existam edições mais recentes. O livro que eu li está um pouco desatualizado. Ele deveria ser não apenas atualizado, mas também expandido.
Conclusão geral
Este livro não é à toa considerado um best-seller na área de desenvolvimento de código. Vale a pena ao menos folheá-lo rapidamente, ou melhor — estudá-lo atentamente. Se você não tem tempo ou disposição para ler o livro inteiro, recomendo dar uma olhada nos resumos ao final de cada capítulo e no capítulo final, que contém recomendações gerais. Após a leitura, será útil discutir as abordagens e dicas com os colegas — pois seguir cegamente as recomendações de Robert Martin pode ser não apenas inadequado, mas também errado.
