Información general
El libro fue escrito por el divulgador de programación y desarrollador experimentado Robert Martin. Es un libro sobre cómo escribir código más limpio y ordenado de manera correcta. Vamos a revisar brevemente el libro.
Resumen breve de los capítulos
El primer capítulo es puramente teórico y un poco seco. Habla sobre la importancia de escribir buen código y cómo, con cada mes que pasa, mantener código deficiente se vuelve más costoso, tanto en términos de dinero como de tiempo.
Luego se discute cómo nombrar mejor las variables: deben transmitir la intención del programador, y al leer una variable, ya debería ser claro qué almacena y de qué tipo de datos se trata. Se menciona que se deben evitar nombres abstractos como List, Data, etc. También se toca brevemente el nombramiento de métodos y clases, aunque esto se aborda con más detalle más adelante. Hay muchos consejos, la mayoría lógicos y sensatos. Por un lado, es un capítulo banal y obvio; por otro, puede ser muy útil, especialmente para principiantes.
Luego vienen las funciones. Aquí comienzan los temas más polémicos: cuántas líneas debe tener una función, cuántos parámetros debe tener. Por supuesto, la respuesta es obvia: cuanto más pequeña y simple sea la función, mejor. Sin embargo, en la práctica, esto no siempre es posible. También se menciona la idea lógica y sensata de que una función debe realizar solo una acción específica. Por ejemplo, una función no debe calcular el promedio y al mismo tiempo imprimir el resultado en pantalla. Al estilo de los principios SOLID. Además, en este capítulo, el autor aborda y da consejos sobre cómo trabajar con condiciones (if, else, switch), bucles, estructuras try/catch. Por supuesto, también se trata el tema del nombramiento de funciones y el principio DRY (no repetir código cuando sea posible).
Después de las funciones, se aborda otro tema polémico: los comentarios. Se discute cómo y dónde deben colocarse, y dónde, por el contrario, son innecesarios. El autor analiza comentarios legales, de registro y otros tipos, mostrando cuándo son realmente apropiados.
Si crees que el tema de los comentarios es controvertido, ¿qué opinas sobre el formato? Este pequeño capítulo viene después de los comentarios. Y si parece que solo se hablará de tabulaciones y espacios, no es así. El capítulo es mucho más informativo. El autor incluso incluye varios gráficos.
"Trabajo con objetos y estructuras de datos" es el título del siguiente capítulo. Se abordan temas como abstracción, asimetría de datos, la ley de Demeter, DTO, Active Record y otros. Se trata de manera superficial, y se asume que el programador ya está familiarizado con estos conceptos.
Luego viene el capítulo sobre manejo de errores. Muchos ejemplos en el libro están en Java, por lo que no encontrarás manejo de errores al estilo de Golang (con if); se presta atención principalmente a try/catch. Si hace un par de capítulos se hablaba de formato, ahora se trata de cuándo, dónde y cómo usar el manejo de excepciones.
El siguiente capítulo, "Límites", no trata sobre el código en sí, sino más bien sobre arquitectura, específicamente sobre la composición y uso de módulos. Es una sección pequeña, por lo que aquellos interesados en las opiniones de Robert Martin sobre arquitectura limpia deberían consultar su libro específico sobre el tema.
Luego vienen los "Tests". Se mencionan algunas palabras sobre TDD, y luego se discute cómo debe ser una prueba. Es un capítulo pequeño y no muy informativo. Si alguien está interesado en el tema de las pruebas, puedo recomendar un excelente libro y probablemente pronto haré una reseña sobre él.
Después, "Clases". Nuevamente, si se consideran las clases como parte de la mejora del código (como lo hace el tío Bob), el material asignado a esta sección puede ser suficiente. Pero esto es bajo la condición de que los desarrolladores ya estén familiarizados con la programación orientada a objetos. De lo contrario, si deseas estudiar la programación orientada a objetos más a fondo, esta sección puede resultar poco informativa o incluso difícil.
Los siguientes capítulos vuelven a centrarse en la arquitectura. No, no es la arquitectura en capas en el sentido habitual que Martin recomienda en su otro libro. Aquí se tratan cosas más básicas. El primero de ellos trata más sobre diferentes diagramas de flujo que sobre código. Se mencionan brevemente algunos patrones: fábrica abstracta, inyección de dependencias, proxy. En general, los capítulos resultaron ser buenos e informativos.
Luego, un capítulo sobre multihilo. Más teoría que práctica: no hay mucho código, principalmente se cubre material teórico, y de manera superficial.
Los siguientes capítulos tratan sobre la refactorización del código, con ejemplos de Robert Martin. Y aquí, a diferencia de algunos capítulos anteriores, hay demasiado código. Primero, el autor analiza la refactorización de una utilidad de línea de comandos, y luego un par de bibliotecas/clases para Java de desarrolladores experimentados y conocidos. Incluso en el código de estos especialistas, Martin encuentra cosas que criticar, y en mi opinión, son más bien críticas que refactorizaciones. Después de todo, ese código funcionaba y tenía una alta cobertura de pruebas. El mensaje principal de este capítulo es que no basta con escribir código funcional; debe ser fácil de mantener, de lo contrario, con el tiempo, se convertirá en una tarea extremadamente difícil.
El último capítulo es una especie de resumen, compuesto por consejos que incluyen todo lo discutido anteriormente: desde anotaciones en comentarios hasta trabajo con funciones y pruebas.
Conclusión
Aspectos positivos del libro
- La estructura del libro está bien elaborada. Consta de 17 capítulos, donde cada uno es una ligera complicación del anterior. En otras palabras, al aprender cualquier lenguaje de programación, las personas comienzan con lo básico (variables, comentarios), y a medida que se complica, avanzan hacia funciones, clases, asincronía, etc. Aproximadamente este mismo principio se mantiene en el libro, lo cual es conveniente y familiar.
- La mayoría de los consejos son realmente útiles y lógicos. Algunos descubrirán muchas cosas nuevas, otros casi nada. Todo depende de la experiencia individual.
- El libro contiene ilustraciones. No son muchas, pero las que hay mantienen un estilo uniforme, lo cual ya es agradable.
Aspectos negativos del libro
- No conviene seguir fanáticamente todos los consejos. Hubo al menos algunos, si no varios, “consejos” con los que no estoy del todo de acuerdo o no estoy de acuerdo en absoluto.
- El libro no es pequeño — un poco más de 450 páginas. Y para muchos, leer libros extensos no es tarea fácil.
- Los ejemplos de refactorización de código (eliminación y adición de líneas) podrían haberse presentado mejor. Actualmente, los cambios están marcados solo en negrita (añadido) y tachado (eliminado); tal vez, un formato al estilo de los clientes de Git sería más familiar para muchos.
- Se utiliza Java como lenguaje de ejemplo. No tengo nada en contra y no tuve dificultades para entenderlo, pero para quienes no están familiarizados con el lenguaje, esto puede ser una desventaja.
- Me encontré con la edición del libro del año 2010. Es posible que existan ediciones más recientes. El libro que leí está algo desactualizado. Habría que no solo actualizarlo, sino también ampliarlo.
Conclusión general
Este libro no en vano se considera un best seller en el ámbito del desarrollo de código. Vale la pena al menos hojearlo rápidamente, pero mejor aún — estudiarlo con atención. Si no tienes tiempo o ganas de leer el libro completo, recomiendo revisar los resúmenes al final de cada capítulo y el capítulo final, donde se ofrecen recomendaciones generales. Tras la lectura, puede ser útil debatir los enfoques y consejos con colegas — ya que seguir ciegamente las recomendaciones de Robert Martin no solo puede ser inapropiado, sino también erróneo.
