Ideas clave
Mantén limpio el código desde ahora, porque un desorden funcional encarece cada cambio futuro.
El desorden se acumula en silencio. Una funcionalidad apresurada puede funcionar hoy, pero el código enmarañado hace que el siguiente cambio sea más lento y arriesgado. Martin describe un producto popular cuyas versiones tardaban cada vez más, cuyos errores se acumulaban y cuyo rendimiento empeoraba, hasta que la empresa acabó fracasando. A medida que el desorden aumenta, contratar más personal puede empeorar las cosas: los recién llegados desconocen el diseño y la presión por avanzar rápido fomenta más soluciones improvisadas.
El verdadero volumen de trabajo está en el mantenimiento. El prólogo del libro calcula que el mantenimiento representa al menos el 80 por ciento del trabajo de software. Una reescritura completa tampoco es una salida fácil. Un equipo nuevo debe reproducir el sistema antiguo mientras este sigue cambiando, y el código nuevo también puede acabar enmarañado. El código limpio no es un adorno. Es una forma de preservar la capacidad del equipo para cambiar el producto.
El argumento económico es más convincente si se entiende como un círculo vicioso: una estructura deficiente eleva el costo de los cambios, lo que genera presión para tomar atajos, que a su vez deterioran aún más la estructura. Así, la limpieza es una práctica de gestión de riesgos, no una preferencia estilística. La advertencia sobre contratar personal para trabajar en un desorden también es aguda desde el punto de vista organizativo: aumentar la plantilla no permite transferir de inmediato el conocimiento tácito. Aun así, la limpieza no garantiza el éxito comercial, y pulir el código sin tener en cuenta el valor para el cliente puede ser un desperdicio de esfuerzo. El criterio útil es si la limpieza reduce el costo o el riesgo de cambios futuros plausibles.
Haz que los nombres y la disposición cuenten la historia antes de que tengan que hacerlo los comentarios.
Los nombres transmiten significado. Una variable llamada `d` obliga a los lectores a adivinar; un nombre que indique qué se mide y en qué unidades aporta contexto útil. El mismo principio convierte una lista opaca de matrices de enteros en celdas reconocibles de un tablero de juego, con estados nombrados y una comprobación clara de las banderas. Prefiere nombres fáciles de pronunciar, de buscar y coherentes, y que sean adecuados a su ámbito. Usa vocabulario técnico cuando los programadores lo compartan y lenguaje del dominio cuando el concepto pertenezca al mundo del usuario.
La disposición guía la atención. Las líneas en blanco separan ideas, la sangría revela la estructura y colocar juntas las funciones relacionadas evita búsquedas innecesarias. Martin compara un archivo fuente con un periódico: primero se presenta la idea principal y luego se van acumulando los detalles. Los equipos deben acordar un formato y automatizarlo cuando sea posible, para que los lectores no tengan que descifrar un nuevo dialecto visual en cada archivo.
Los nombres y la disposición funcionan como un mapa del terreno conceptual del programa. Un buen mapa no contiene todos los datos, pero ayuda al lector a predecir dónde encontrará el siguiente dato pertinente. Esa capacidad de anticipación importa porque el mantenimiento exige construir una y otra vez un modelo mental mientras se recorre código desconocido. La salvedad es que los nombres más largos y los archivos más pequeños no son automáticamente más claros. Un nombre puede convertirse en un párrafo, y una fragmentación excesiva puede dispersar una idea sencilla. La prueba es práctica: ¿esta decisión ayuda a un lector nuevo a comprender la intención sin tener que consultar una y otra vez un contexto distante?
Reduce cada función hasta que su nombre describa un paso claro.
Mantén un solo nivel de pensamiento. Una función debe expresar una única operación, con instrucciones que trabajen aproximadamente al mismo nivel de abstracción. En el ejemplo de FitNesse del libro, una rutina extensa mezclaba la búsqueda de páginas, la representación de rutas, la composición de cadenas y la salida HTML. Extraer pasos con nombres descriptivos hizo comprensible su propósito: decidir si la página es una prueba, añadir el contenido de preparación y limpieza cuando corresponda y, después, representarla. Los bloques pequeños que llaman a funciones descriptivas también reducen el anidamiento y permiten leer el código en una secuencia de arriba abajo.
Mantén modesta la interfaz. Cada argumento añade información que el lector debe seguir, así que es preferible que haya pocos o ninguno. Los indicadores booleanos suelen ocultar dos trabajos distintos. Los efectos secundarios ocultos generan sorpresas, mientras que una función que cambia el estado y además comunica un resultado desdibuja la diferencia entre comandos y consultas. Por lo general, devolver un valor transformado es más claro que modificar silenciosamente un argumento de salida.
El principio de diseño aquí no consiste simplemente en escribir poco código. Se trata de controlar la atención: cada función debería pedirle al lector que tenga presente un solo tipo de problema. Esto resulta especialmente útil al depurar, cuando el lector ya está siguiendo el estado y las causas. Sin embargo, es posible llevar demasiado lejos la preferencia del libro por las funciones diminutas. Una función extraída únicamente para repetir un detalle de implementación puede obligar a navegar más sin aportar significado. La extracción se justifica cuando da nombre a un concepto real, establece un límite de abstracción útil o facilita la comprensión de una secuencia importante.
Usa los comentarios con mesura y deja que un formato coherente revele la estructura del código.
Los comentarios se alejan de la verdad con el tiempo. El código cambia, pero sus explicaciones pueden quedarse atrás y volverse inexactas o desconectadas. Una nota que se limita a repetir lo que hace una función o una variable añade ruido; el código comentado es especialmente costoso porque los lectores no pueden saber si es un vestigio del pasado o un plan para el futuro. El control de versiones conserva las versiones antiguas, así que no hace falta abarrotar el archivo de trabajo con código obsoleto. Aun así, los comentarios tienen su lugar cuando explican la intención, advierten sobre las consecuencias o aclaran información que el código no puede expresar de manera económica.
El formato es comunicación. La coherencia en los espacios, la sangría y el orden ayuda a los lectores a distinguir las ideas principales de una clase de los detalles de implementación. El libro recomienda los archivos y las líneas cortos como tendencias útiles, no como leyes, y recalca que el estilo compartido por el equipo importa más que la ubicación de llaves que prefiera cada programador. Las herramientas de formato pueden hacer cumplir el acuerdo y mantener las revisiones de código centradas en el contenido.
La distinción clave está entre la documentación que explica una decisión y los comentarios que parafrasean la sintaxis. La primera puede preservar un razonamiento que, de otro modo, desaparecería; los segundos compiten con el código por la atención y pueden acabar siendo falsos. Por eso, mantener los comentarios forma parte del diseño, no es una tarea administrativa de limpieza. De forma similar, las convenciones de formato son una herramienta de coordinación: la coherencia reduce los pequeños costos de interpretación que se pagan en cada archivo. Sin embargo, los comentarios pueden ser esenciales para explicar restricciones poco obvias, sobre todo cuando no es posible inferir la intención con seguridad. El objetivo no es el silencio, sino una jerarquía fiable en la que el código sea la autoridad y los comentarios aporten contexto que realmente falte.
Considera las pruebas una red de seguridad que hace posible sobrevivir a los rediseños.
Las pruebas protegen los cambios. Una batería que se ejecuta automáticamente permite a los desarrolladores modificar la estructura y comprobar que el comportamiento establecido sigue intacto. El libro describe un equipo que trataba el código de prueba como desechable. Cuando las pruebas se enmarañaron, mantenerlas se volvió penoso, se abandonó la batería y los desarrolladores empezaron a temer mejorar el código de producción. Aumentaron los defectos y el código se deterioró. Por eso, las pruebas necesitan el mismo cuidado que el código que protegen.
Haz que las pruebas sean legibles y fiables. Una prueba útil permite identificar con facilidad la preparación, la acción y el resultado esperado. Mantén las pruebas rápidas, independientes, repetibles y con comprobaciones propias, y escríbelas cerca del código que ejercitan. Prueba un concepto significativo a la vez y examina los casos límite en lugar de confiar solo en el camino feliz. El desarrollo guiado por pruebas coloca una prueba fallida antes del cambio en el código de producción y luego añade únicamente la implementación necesaria para satisfacerla, manteniendo frecuentes los ciclos de retroalimentación.
Las pruebas hacen más que detectar regresiones. Dan permiso para refactorizar al hacer visibles las consecuencias de los cambios. Esto conecta de forma poderosa la verificación con el diseño: el código difícil de probar suele tener dependencias ocultas o responsabilidades poco claras. Pero una batería que pasa no demuestra que el software satisfaga las necesidades del usuario. Las pruebas pueden ser claras, rápidas y exhaustivas y, aun así, codificar una premisa equivocada. Su autoridad depende de la calidad de las preguntas sobre el comportamiento que plantean; por eso, los requisitos ambiguos deben hacerse explícitos en vez de convertirse silenciosamente en aserciones.
Refactoriza en pequeños pasos verificados, no con una reescritura heroica.
Que funcione es solo un borrador. El analizador de argumentos de línea de comandos de Martin, Args, empezó como un modesto analizador de valores booleanos. Al añadir opciones de cadena y de entero, se propagaron la lógica repetida y una gestión de errores enmarañada. En vez de seguir acumulando funcionalidades, añadió una abstracción común para organizar los argumentos y remodeló el programa mediante pequeños cambios, comprobando las pruebas entre paso y paso. El diseño final surgió del refinamiento, no de empezar desde cero.
Las pruebas revelan defectos y también protegen los cambios. En el estudio de caso SerialDate, una revisión inicial de la cobertura mostró que las pruebas existentes ejercitaban apenas cerca de la mitad de las instrucciones ejecutables. Una batería independiente elevó la cobertura a aproximadamente el 92 por ciento y sacó a la luz errores en los límites de las fechas, incluido un cálculo del día de la semana que devolvía la fecha inicial cuando debería haber devuelto la siguiente fecha en que se daba ese día. El proceso de reparación también mejoró los nombres, redistribuyó responsabilidades y eliminó código sin uso.
La refactorización incremental se parece a la experimentación controlada: se cambia una variable del diseño, se observa si el comportamiento permanece estable y se conserva el resultado útil. Así se limita el número de causas posibles cuando aparece una regresión. Los estudios de caso también muestran por qué la cobertura es una herramienta de diagnóstico, no una puntuación de calidad. Ejecutar más líneas puede revelar puntos ciegos, pero solo las aserciones bien elegidas establecen comportamientos significativos. Por tanto, una secuencia disciplinada requiere tanto seguridad mecánica como criterio para decidir qué debería hacer el programa, en especial en los límites, donde las reglas intuitivas suelen fallar.
Asigna a cada clase una responsabilidad clara y oculta los detalles tras abstracciones útiles.
Cuenta las razones para cambiar. El Principio de responsabilidad única establece que una clase debe tener una razón principal para cambiar. Un panel de control que administra tanto una interfaz de usuario como la información sobre la versión del software puede dividirse para que cada aspecto evolucione de forma independiente. Las clases cohesionadas mantienen juntos los datos y el comportamiento relacionados, mientras que las clases pequeñas facilitan encontrar qué parte se ve afectada por un cambio.
Elige deliberadamente entre objetos y estructuras de datos. Los objetos ocultan su representación y ofrecen comportamiento; las estructuras de datos exponen sus campos para que se usen directamente. Ningún estilo es mejor en todas las situaciones. Un sistema de figuras al que se añaden figuras nuevas con frecuencia se beneficia de los objetos polimórficos, mientras que, si lo habitual es añadir operaciones, las estructuras de datos y las funciones externas pueden simplificar el diseño. Al iniciar el sistema, mantén la construcción de objetos y la conexión de dependencias separadas del comportamiento en tiempo de ejecución. Así, la arquitectura resulta más fácil de probar y modificar.
El principal beneficio arquitectónico es el razonamiento local. Cuando una clase es responsable de una función coherente, el lector puede entender un cambio sin tener que cargar mentalmente toda la aplicación. La distinción entre objetos y estructuras de datos evita que el diseño se convierta en una cuestión de modas: la elección adecuada depende de si es más probable que varíen los tipos o las operaciones. También hay un costo que contrarresta esas ventajas. Demasiadas clases diminutas pueden dificultar la navegación, y una abstracción sin variaciones previsibles puede ser maquinaria innecesaria. Un buen diseño reduce la complejidad de los cambios probables, en lugar de maximizar la abstracción por sí misma.
Deja que el manejo de errores proteja la lógica principal en vez de ocultarla.
Separa las rutas de error. Devolver códigos de error obliga a quienes llaman a inspeccionar cada resultado y suele anidar condicionales alrededor de la operación principal. Las excepciones pueden trasladar la recuperación a un manejador aparte y dejar más clara la secuencia normal. Los tipos de error deberían reflejar qué necesita capturar quien llama, y los mensajes deberían identificar la operación fallida y aportar contexto útil. Envolver una biblioteca de terceros permite traducir sus numerosas excepciones a una interfaz más reducida, controlada por la aplicación.
Diseña para evitar las excepciones rutinarias. Si una ausencia habitual, como la falta de gastos de comida, puede representarse mediante un objeto especial que proporcione el valor de la dieta diaria, el cálculo principal ya no necesita una rama especial. De igual manera, devolver null traslada a quienes llaman la función la obligación de repetir comprobaciones y abre la posibilidad de errores. Prefiere un resultado vacío explícito o una excepción con sentido, y evita pasar null cuando el método no tiene una forma sólida de recuperarse.
El manejo de errores es más claro cuando distingue los fallos inusuales de las variaciones normales. El objeto de caso especial es valioso porque traslada una regla del dominio al límite donde se entiende la condición excepcional, en lugar de obligar a quienes llaman a repetirla. Los envoltorios también crean una interfaz estable alrededor de API externas volátiles. Aun así, las excepciones tienen costos: las capturas demasiado amplias pueden ocultar defectos, y usarlas para el flujo de control habitual oscurece el comportamiento esperado. La pregunta práctica es si quien llama puede tomar medidas de recuperación significativas. Si no puede, quizá el diseño necesite una mejor representación de la situación normal o un límite de fallo más claro.
Reduce al mínimo el estado compartido, porque el código concurrente puede fallar entre pasos normales.
La concurrencia separa lo que ocurre del momento en que ocurre. Puede mejorar el rendimiento cuando una tarea espera una entrada o una respuesta de la red mientras otra puede usar el procesador. Pero ni siquiera un incremento sencillo es necesariamente indivisible: dos hilos pueden leer el mismo valor, calcular cada uno el mismo valor siguiente y sobrescribirse entre sí. El problema es difícil de reproducir porque la planificación de los hilos da lugar a muchos órdenes de ejecución posibles.
Reduce el peligro desde su origen. Mantén el código que tiene en cuenta los hilos separado de la lógica ordinaria del negocio, restringe el acceso a los datos compartidos y, cuando sea práctico, prefiere el trabajo independiente o las copias. Usa colecciones seguras para los hilos y bibliotecas de ejecución consolidadas, en vez de improvisar mecanismos de sincronización. Mantén pequeñas las secciones protegidas, planifica con antelación cómo se detendrá el sistema y prueba con cargas y plataformas diversas. Cambiar deliberadamente la temporización de los hilos puede ayudar a descubrir fallos que las pruebas habituales no detectan.
El cambio de perspectiva más útil consiste en dejar de tratar la concurrencia como una versión más rápida del código ordinario. Cambia el conjunto de comportamientos posibles, de modo que la corrección depende de intercalaciones que el lector no puede deducir en una lectura lineal. Por eso, el aislamiento y la titularidad restringida son herramientas más potentes que limitarse a añadir bloqueos por todas partes. Las pruebas de estrés y las alteraciones de la temporización pueden sacar a la luz fallos infrecuentes, pero que una prueba pase repetidamente no demuestra que el sistema sea seguro. La práctica más sólida combina un diseño deliberado del estado, conocimiento de las bibliotecas y pruebas repetidas, y considera los fallos esporádicos una señal, no mala suerte.
Análisis
Código limpio se entiende mejor como un manual para preservar la capacidad de un equipo de comprender y modificar el software. Su afirmación central es económica: la legibilidad, las pruebas y una estructura disciplinada no son retoques que se añaden después de la entrega. Forman parte de la maquinaria que permite seguir entregando en el futuro. El libro defiende esta idea mediante una progresión que va de decisiones pequeñas, como elegir el nombre de una variable, a estructuras mayores, como los límites entre clases, el inicio del sistema y la ejecución concurrente. Su relato recurrente es el de la reparación: examinar código funcional pero poco manejable, identificar el origen de las dificultades, hacer una pequeña transformación y verificar que el comportamiento se conserva.
La contribución más sólida es la conexión entre la calidad del código y el riesgo de los cambios. Los nombres reducen el esfuerzo interpretativo. Las funciones pequeñas hacen visibles la intención y el flujo de control. Las pruebas vuelven menos intimidantes los cambios estructurales. Los límites contienen la incertidumbre procedente de bibliotecas, infraestructura y servicios externos. No son reglas independientes, sino formas que se refuerzan mutuamente para reducir la cantidad de datos que un desarrollador debe tener presentes a la vez. Los estudios de caso Args y SerialDate concretan este método y muestran que el diseño mejora mediante decisiones sucesivas y comprobadas, no con un único estallido de inspiración.
No todas las recomendaciones del libro deberían tratarse como leyes universales. Las funciones diminutas, los pocos argumentos, las clases mínimas y los comentarios reducidos al mínimo pueden convertirse en dogmas si se desligan de su propósito. Una descomposición excesiva puede dispersar un concepto; los comentarios demasiado escuetos pueden omitir el razonamiento; una batería de pruebas extensa puede preservar supuestos obsoletos. El propio texto reconoce distintas escuelas de pensamiento y compensaciones, sobre todo al elegir entre representaciones orientadas a objetos y procedimentales. Esa apertura es importante.
Los ejemplos en Java de 2007 también sitúan algunos consejos en su contexto histórico. Las características modernas de los lenguajes, el análisis estático, el formato automatizado, las herramientas de gestión de dependencias y las bibliotecas de concurrencia pueden aliviar ciertas cargas, pero no pueden decidir si un nombre comunica la intención o si un límite refleja una verdadera frontera de cambio. Por tanto, la lección duradera no consiste en imitar todos los ejemplos. Consiste en procurar que el código sea comprensible, comprobable y poco costoso de modificar, y después aplicar el criterio propio para decidir qué tareas de limpieza sirven realmente a ese propósito.
Resumen de reseñas
Código limpio es muy apreciado como lectura esencial para los desarrolladores de software y ofrece valiosas ideas para escribir código legible y fácil de mantener. Aunque se elogia su consejo práctico sobre convenciones para nombrar, diseño de funciones y pruebas, algunos lectores lo consideran demasiado centrado en Java y, en ocasiones, extremista en sus recomendaciones. Los estudios de caso han tenido una acogida dispar: a algunos les resultaron útiles y a otros no les impresionaron tanto. A pesar de sus defectos, muchos desarrolladores lo consideran una lectura imprescindible que ha mejorado significativamente sus prácticas de programación y su comprensión del oficio del software.
También leyeron
Glosario
Principio de responsabilidad única
un motivo principal para cambiarUna clase o módulo debe tener una responsabilidad principal, es decir, un motivo principal por el que tendría que cambiar. El principio fomenta agrupar el comportamiento que cambia por la misma razón y separar el que probablemente evolucione de manera independiente. Es una guía para la cohesión y la gestión de cambios, no una exigencia de que cada clase contenga un solo método.
Ley de Deméter
limitar el conocimiento de los colaboradoresUn método debe comunicarse con los objetos que posee directamente, crea, recibe o con los que está estrechamente relacionado, en vez de recorrer cadenas de otros objetos. El objetivo es reducir el conocimiento de la estructura interna. En lugar de atravesar varios objetos para obtener un dato, quien llama le pide a un colaborador que realice la operación necesaria.
Inyección de dependencias
suministrar las dependencias desde fueraUna técnica de diseño en la que un objeto recibe los servicios o colaboradores que necesita, en lugar de construirlos o localizarlos por sí mismo. Un constructor, un método setter o un contenedor suministra esas dependencias durante la configuración. Esto separa la construcción de objetos del comportamiento de la aplicación y facilita reemplazar, configurar y probar las implementaciones.
F.I.R.S.T.
cualidades de las pruebas fiablesUn recurso mnemotécnico para recordar cinco características de las pruebas limpias: rápidas, independientes, repetibles, autovalidables y oportunas. Las pruebas rápidas se ejecutan con frecuencia; las independientes no dependen del orden de ejecución; las repetibles funcionan en distintos entornos; las autovalidables indican claramente si se aprueban o fallan; y las oportunas se escriben cerca del código de producción que ejercitan.
Patrón de caso especial (Special Case Pattern)
representar una excepción como datos normalesUna técnica de diseño que proporciona un objeto con un comportamiento sensato ante una condición inusual pero prevista. Así, el código cliente usa la misma operación sin comprobar repetidamente si se da esa condición especial. El ejemplo del libro es un objeto de gastos que devuelve una cantidad de dieta diaria cuando no hay gastos de comidas, evitando que esa regla forme parte del cálculo principal de quien lo llama.
Pruebas de aprendizaje
pruebas que exploran una API externaPruebas pequeñas y específicas, escritas para descubrir y registrar el comportamiento de un paquete de terceros. Funcionan como experimentos controlados mientras los desarrolladores aprenden a usar una interfaz desconocida, y pueden volver a ejecutarse después de una actualización para revelar cambios incompatibles. Ponen a prueba la comprensión y el uso previsto que hace el equipo de la dependencia, en vez de intentar verificar toda su implementación.
Diseño simple (Simple Design)
diseño perfeccionado mediante cuatro prioridadesUn enfoque de diseño presentado como un conjunto ordenado de prioridades: asegurarse de que el sistema supere sus pruebas, eliminar la duplicación, expresar con claridad la intención del programador y evitar clases y métodos innecesarios. El orden importa. Las pruebas y la claridad tienen prioridad sobre reducir al mínimo el número de elementos del programa, mientras que la refactorización permite que el diseño surja mediante pequeños cambios verificados.
Preguntas frecuentes
¿De qué trata Código limpio: manual de artesanía ágil de software?
- Enfoque en la artesanía del software: El libro destaca la importancia de escribir código limpio y fácil de mantener como sello de profesionalidad en el desarrollo de software.
- Principios y prácticas: Presenta diversos principios, patrones y prácticas que ayudan a los programadores a escribir código que no solo funcione, sino que también sea fácil de leer y entender.
- Ejemplos del mundo real: Incluye numerosos ejemplos de código bueno y malo que muestran cómo transformar código desordenado en código limpio mediante la refactorización y prácticas disciplinadas.
¿Por qué debería leer Código limpio, de Robert C. Martin?
- Mejorar las habilidades de programación: Leer el libro puede mejorar significativamente tus habilidades de programación, pues enseña a escribir código más fácil de mantener y entender.
- Desarrollo profesional: Es un recurso valioso para quienes desean avanzar en su carrera de desarrollo de software, ya que fomenta una mentalidad de artesanía y calidad.
- Consejos prácticos: El libro ofrece consejos prácticos que pueden aplicarse de inmediato a las prácticas de programación, por lo que es una guía útil tanto para programadores principiantes como experimentados.
¿Cuáles son las ideas clave de Código limpio?
- Nombres significativos: El libro recalca la importancia de usar nombres que revelen la intención para las variables, funciones y clases, a fin de mejorar la legibilidad y la facilidad de mantenimiento del código.
- Funciones pequeñas: Las funciones deben ser pequeñas y centrarse en una sola tarea, siguiendo el principio de «hacer una sola cosa» para mejorar la claridad y reducir la complejidad.
- Gestión de errores: Martin defiende el uso de excepciones en lugar de códigos de retorno para gestionar errores, lo que ayuda a mantener limpia y despejada la lógica principal del código.
¿Cuáles son las mejores citas de Código limpio y qué significan?
- «El código limpio es cuestión de disciplina»: Esta cita subraya que escribir código limpio exige un esfuerzo constante y apego a las mejores prácticas, en lugar de depender únicamente de la suerte o el talento.
- «Los comentarios no compensan un código malo»: La idea es que, si el código está mal escrito, ningún número de comentarios puede compensar su falta de claridad y estructura.
- «Deja el campamento más limpio de lo que lo encontraste»: Esta metáfora anima a los desarrolladores a mejorar la base de código con cada cambio, para que se mantenga limpia y fácil de conservar a lo largo del tiempo.
¿Cómo define Código limpio el código limpio?
- Legible y comprensible: El código limpio se define como código fácil de leer y entender, que permite a otros desarrolladores captar rápidamente su propósito y funcionamiento.
- Complejidad mínima: Debe tener una complejidad mínima; cada función y clase debe centrarse en una sola responsabilidad, lo que facilita probarlo y mantenerlo.
- Bien estructurado: El código limpio está bien estructurado y sigue convenciones coherentes de formato y nombres que mejoran su claridad y reducen la carga cognitiva del lector.
¿Qué es la regla de los Boy Scouts en Código limpio?
- Mejora continua: La regla de los Boy Scouts establece que los desarrolladores deben «dejar el campamento más limpio de lo que lo encontraron». Esto significa que cada vez que trabajes con código, debes procurar mejorarlo.
- Los pequeños cambios importan: Puede bastar con cambiar el nombre de una variable para que sea más clara o refactorizar una función pequeña; así se contribuye a la limpieza general de la base de código.
- Responsabilidad profesional: Seguir esta regla refleja una actitud profesional hacia la calidad y el mantenimiento del código y fomenta una cultura de mejora continua en el equipo.
¿Qué es el Principio de responsabilidad única (SRP) en Código limpio?
- Definición del SRP: El SRP establece que «una clase debe tener un solo motivo para cambiar, y solo uno». Esto significa que cada clase debe centrarse en una única responsabilidad o funcionalidad.
- Ventajas del SRP: Seguir el SRP mejora la organización del código y facilita entenderlo, probarlo y mantenerlo. También reduce el riesgo de que los cambios en un área afecten partes del código que no guardan relación.
- Orientación para su aplicación: Martin ofrece consejos prácticos para identificar responsabilidades y refactorizar clases de modo que sigan el SRP, ayudando a que el código se mantenga limpio y manejable.
¿Cómo aborda Código limpio la gestión de errores?
- Usar excepciones: El libro recomienda usar excepciones en lugar de códigos de retorno para gestionar errores, lo que ayuda a mantener limpia y despejada la lógica principal del código.
- Separación de responsabilidades: La gestión de errores debe estar separada de la lógica principal del código, para que los desarrolladores puedan centrarse en la funcionalidad principal sin verse abrumados por comprobaciones de errores.
- Proporcionar contexto: Las excepciones deben aportar contexto suficiente para entender el origen y la naturaleza del error, lo que facilita diagnosticar y resolver los problemas cuando surgen.
¿Qué papel tienen las pruebas en Código limpio?
- Fundamento del código limpio: Las pruebas se consideran una disciplina fundamental para escribir código limpio. Garantizan que el código se comporte según lo previsto y ayudan a detectar problemas pronto durante el desarrollo.
- Pruebas rápidas y fiables: El libro subraya que las pruebas deben ser rápidas y fiables para fomentar su ejecución frecuente. Esto ayuda a mantener limpia la base de código y reduce el riesgo de introducir errores.
- Pruebas autovalidables: Las pruebas deben diseñarse para autovalidarse, es decir, indicar claramente si el código funciona correctamente. Esto reduce la ambigüedad y aumenta la confianza en el código.
¿Cómo sugiere Código limpio gestionar las dependencias?
- Principio de inversión de dependencias (DIP): El libro explica que «los módulos de alto nivel no deben depender de los módulos de bajo nivel. Ambos deben depender de abstracciones». Este principio fomenta el uso de interfaces y clases abstractas para reducir el acoplamiento.
- Uso de la inyección de dependencias: Martin recomienda usar la inyección de dependencias para gestionarlas, lo que permite crear código más flexible y fácil de probar. Este enfoque desacopla la creación de dependencias de su uso.
- Ventajas de gestionar las dependencias: Al gestionar las dependencias de manera eficaz, los desarrolladores pueden crear sistemas más fáciles de mantener y ampliar, lo que da lugar a código más limpio y robusto.
¿Cuáles son algunos olores de código habituales que identifica Código limpio?
- Código duplicado: Es un olor de código importante que indica falta de abstracción. El libro aconseja eliminar la duplicación para mejorar la facilidad de mantenimiento y reducir errores.
- Métodos largos: Los métodos demasiado largos pueden resultar difíciles de entender y mantener. El libro propone dividirlos en funciones más pequeñas y manejables.
- Comentarios excesivos: Aunque los comentarios pueden ser útiles, los excesivos o redundantes suelen indicar que el código no es claro por sí mismo. El objetivo debe ser escribir código que se explique solo y requiera un mínimo de comentarios.
¿Cómo puedo aplicar en mis propios proyectos los principios de Código limpio?
- Empieza con cambios pequeños: Comienza aplicando los principios del código limpio a secciones pequeñas de tu base de código. Refactoriza una clase o función cada vez para mejorar la legibilidad y la facilidad de mantenimiento.
- Escribe primero las pruebas: Adopta prácticas de desarrollo guiado por pruebas (TDD) escribiendo las pruebas antes de implementar nuevas funcionalidades. Así te aseguras de que el código siempre esté cubierto por pruebas y contribuyes a mantener su calidad.
- Refactoriza con regularidad: Haz de la refactorización una parte habitual del proceso de desarrollo. Busca continuamente oportunidades para mejorar la estructura del código y eliminar duplicaciones, manteniendo la base de código limpia y eficiente.
Descargar PDF
Descargar EPUB
.epub es ideal para leer libros electrónicos en teléfonos, tabletas y lectores electrónicos.