Ideas clave
Mantén el código limpio, porque el atajo que entregas hoy encarece cada cambio
El atajo aparente se acumula. Martin sostiene que el código apresurado y enmarañado ralentiza cada cambio posterior. Recuerda un producto de software que gozó de popularidad y cuyas versiones tardaban cada vez más en salir, cuyos errores persistían y cuyos bloqueos aumentaban. Un antiguo empleado atribuyó el declive a una base de código difícil de ampliar. A medida que crece el desorden, los cambios se vuelven más arriesgados, los equipos avanzan más despacio y contratar más personal puede agravar el problema, porque quienes se incorporan deben trabajar con un diseño que no entienden.
Reescribir no es empezar de cero por arte de magia. En el escenario de rediseño del libro, un equipo nuevo construye un reemplazo mientras el sistema antiguo sigue cambiando. La carrera puede durar años, y el reemplazo puede heredar el mismo desorden. La alternativa práctica es seguir mejorando el código a medida que cambia, en vez de tratar la limpieza como un proyecto para más adelante.
Lo llamativo es el argumento económico que subyace al lenguaje de la artesanía: cada decisión poco clara genera trabajo para quienes lean el código en el futuro, y ese coste se distribuye a lo largo de la vida del producto. Se parece al mantenimiento preventivo en ingeniería, donde las inspecciones pequeñas reducen la probabilidad de una avería costosa. El argumento es más sólido cuando un equipo mantendrá el código durante cierto tiempo. Un prototipo que se va a desechar tiene otra estructura de costes, así que la limpieza debe responder al uso previsto y no convertirse en un ritual por sí misma.
Escribe para quien lee el código, no solo para el compilador, y haz que la intención se pueda encontrar
El trabajo consiste, sobre todo, en leer. Martin calcula que los programadores pasan más de diez veces más tiempo leyendo código que escribiéndolo. El siguiente cambio depende de entender lo que ya existe, así que la legibilidad no es un adorno. Los nombres deben indicar qué representa un valor, qué hace una función y cómo se usa un resultado. Por ejemplo, una variable de tiempo debería identificar tanto el intervalo como su unidad, en vez de dejar que un comentario explique esos datos.
Haz que sea fácil encontrar el significado. Prefiere nombres fáciles de pronunciar y distintivos antes que abreviaturas crípticas, series numéricas arbitrarias o nombres que solo satisfacen al compilador. Un contador de bucle puede ser breve si su ámbito es diminuto; un valor usado en muchos lugares necesita un nombre que se pueda buscar. Un formato coherente y las convenciones del equipo ayudan a reconocer la estructura sin tener que aprender de nuevo cada archivo.
El código legible reduce la cantidad de información que una persona debe mantener en la memoria de trabajo mientras sigue un cambio. Por eso, nombrar es una forma de diseñar interfaces: el identificador suele ser la primera explicación que ve quien colabora. El libro también vincula el estilo local con la confianza del equipo, pues una disposición coherente permite prever dónde encontrar cada concepto. Sin embargo, hay un límite. Los nombres largos no son automáticamente más claros, y un exceso de detalles en ellos puede ocultar una operación local sencilla. La claridad depende del concepto y de su ámbito.
Mantén las funciones lo bastante pequeñas para expresar un paso claro cada vez
Una función, un nivel. Una función debería describir una sola operación, y sus pasos internos deberían expresarse con el siguiente nivel de detalle. Martin lo demuestra al convertir una rutina enmarañada de renderizado HTML en una breve secuencia que identifica las páginas de prueba, incluye el material de preparación y limpieza, y devuelve el resultado renderizado. Las funciones más pequeñas hacen visible el propósito sin obligar a quien lee a descifrar primero el manejo de cadenas de bajo nivel.
Reduce el esfuerzo de interpretación. Procura usar pocos argumentos, evita los indicadores booleanos que hacen que una función se comporte de dos maneras y mantén separados los comandos que cambian el estado de las consultas que devuelven información. Los efectos secundarios ocultos son especialmente costosos: una función llamada «comprobar contraseña» no debería restablecer subrepticiamente la sesión de quien usa el sistema. Las excepciones también pueden separar el tratamiento de errores del algoritmo ordinario.
La estructura narrativa es más que una preferencia estilística. Una secuencia bien ordenada permite pasar de la política al mecanismo, del mismo modo que una buena explicación presenta una afirmación antes de sus pruebas. Las funciones pequeñas también facilitan las pruebas y la reutilización. Pero extraer funciones puede llevarse demasiado lejos: un programa dividido en innumerables envoltorios triviales puede obligar a saltar de una definición a otra. La prueba útil no es un límite universal de líneas, sino si cada unidad tiene un propósito coherente que se pueda nombrar sin limitarse a repetir su implementación.
Asigna a cada clase un único motivo para cambiar y elige su forma deliberadamente
Cuenta las responsabilidades, no los métodos. El principio de responsabilidad única establece que una clase debería tener un único motivo para cambiar. Un panel con solo unos pocos métodos puede combinar, aun así, tareas no relacionadas, como administrar una ventana y mostrar los números de versión del software. Separar el comportamiento relativo a las versiones crea una unidad más pequeña y de propósito más claro. Alta cohesión significa que los datos y métodos de una clase están relacionados; los grupos inconexos indican que quizá haya otra clase oculta dentro.
Elige objetos o estructuras de datos según el tipo de cambio que esperas. Los objetos ocultan los datos y exponen el comportamiento, lo que facilita añadir tipos nuevos. Las estructuras de datos exponen sus campos y permiten añadir operaciones nuevas sin modificar cada tipo. Ningún estilo es siempre superior. Mezclar ambos produce híbridos que no ocultan ni los datos ni las responsabilidades, y además dificultan los dos tipos de cambio.
Esto corrige de manera útil la idea de que el diseño orientado a objetos consiste en convertir cada sustantivo en un objeto. La cuestión de fondo es dónde es probable que se produzcan los cambios. Si suelen aparecer nuevos tipos de comportamiento, los datos expuestos con operaciones separadas pueden resultar más sencillos; si suelen aparecer nuevos tipos de datos, los objetos polimórficos pueden concentrar los cambios. La prueba de responsabilidad también es práctica, pero puede ser subjetiva. El límite de una clase es una hipótesis sobre cambios futuros, no una ley que garantice la arquitectura correcta.
Mantén las pruebas lo bastante limpias para proteger los cambios y evitar que se vuelvan otro sistema heredado
Las pruebas preservan la libertad de mejorar. El desarrollo guiado por pruebas, o TDD, consiste en escribir una prueba que falla antes de implementar el comportamiento de producción, añadir solo el código necesario para hacerla pasar y luego perfeccionar el resultado mientras las pruebas siguen pasando. Martin describe un ciclo rápido de prueba e implementación. Las pruebas no son andamios desechables. Un equipo dejó que su código de prueba se enmarañara; con el tiempo, los desarrolladores descartaron la batería de pruebas, perdieron confianza en los cambios y dejaron de mejorar el código de producción.
Haz que las pruebas sean legibles y fiables. El libro recomienda pruebas rápidas, independientes, repetibles y con comprobación automática, escritas cerca del código que especifican. La estructura preparar-ejecutar-comprobar ayuda a ver la configuración inicial, la acción y el resultado esperado. Prueba un concepto principal cada vez y mantén las aserciones lo bastante enfocadas como para que un fallo señale un comportamiento claro.
Las pruebas funcionan como memoria ejecutable. Preservan lo que el equipo cree que el software debe hacer, incluso después de que las personas que lo crearon se hayan marchado. Su valor es tanto técnico como social: una prueba comprensible aporta a quien revisa pruebas para aceptar un cambio. La advertencia es que las pruebas aprobadas no demuestran una corrección total. Una batería de pruebas refleja los casos que sus autores previeron, por lo que las comprobaciones de límites, los patrones de fallo y la revisión humana siguen siendo complementos importantes de la automatización.
Refactoriza en pequeños pasos verificados, no con reescrituras heroicas
Lo que funciona aún es un borrador. En el estudio de caso del analizador de línea de comandos, la primera versión manejaba correctamente las opciones booleanas. Al añadir opciones de cadena y de número entero, se multiplicaron los casos especiales hasta que la implementación se volvió difícil de manejar. En lugar de añadir más funciones, Martin hizo una pausa y extrajo una abstracción común para gestionar argumentos. Se ejecutaron pruebas después de pequeños cambios, manteniendo estable el comportamiento mientras se reasignaban responsabilidades y desaparecía la lógica duplicada.
Deja que las pruebas orienten la limpieza. En una revisión aparte de una clase de fechas, las pruebas originales cubrían aproximadamente la mitad de las instrucciones ejecutables. Las pruebas adicionales revelaron errores en los límites, incluido un cálculo del día de la semana que devolvía la fecha actual cuando debería haber encontrado la siguiente ocurrencia. Las prioridades del diseño sencillo que propone el libro son mantener las pruebas aprobadas, eliminar duplicaciones, hacer clara la intención y evitar clases o métodos innecesarios. Los estudios de caso muestran que perfeccionar el código suele implicar probar un cambio, comprobarlo y revisarlo.
La refactorización incremental se parece a la experimentación controlada: se cambia una variable, se observa el resultado y se conserva una base de referencia conocida y fiable. Así, el trabajo depende menos de la memoria y la confianza. También se hace visible una diferencia clave entre una reescritura y una transformación: se protege el comportamiento mientras cambia la estructura. Aun así, las pruebas aprobadas solo informan en la medida en que su cobertura y sus aserciones sean adecuadas. El ejemplo de las fechas es valioso precisamente porque unas pruebas más amplias revelaron defectos que la batería original no había dejado ver.
Usa comentarios para explicar los motivos, nunca para disimular código confuso
El código debería explicarse por sí mismo. Un comentario que repite una instrucción evidente añade ruido, mientras que uno que queda desactualizado puede inducir a más error que el silencio. Si un comentario explica que una condición comprueba si alguien cumple los requisitos para recibir una prestación, quizá la condición sea más clara como función con un buen nombre. Los nombres, las funciones pequeñas y los valores intermedios explícitos suelen explicar la intención con más fiabilidad que la prosa colocada junto a código denso.
Conserva los comentarios que aportan contexto que falta. Los avisos legales, la documentación de las API públicas, las advertencias sobre consecuencias poco evidentes y las explicaciones de por qué se tomó una decisión sorprendente pueden ser útiles. Elimina los registros de cambios obsoletos, el código comentado, los encabezados ruidosos y las notas TODO que nadie revisa. El control de versiones puede conservar el código eliminado; el archivo fuente no tiene por qué servir también de archivo histórico.
La distinción más sólida aquí es la que separa describir qué hace el código de explicar por qué existe una decisión. Lo primero suele duplicar la implementación; lo segundo puede preservar un contexto que la implementación no permite descubrir. Esto coincide con las prácticas de documentación en trabajos críticos para la seguridad, donde los motivos importan porque quienes mantengan el sistema en el futuro quizá se enfrenten a restricciones que ya no sean visibles. Sin embargo, la postura contraria a los comentarios puede llevarse demasiado lejos. El código claro no siempre puede comunicar políticas, supuestos del dominio o una solución provisional deliberada, así que conviene reservar un lugar para los motivos concisos cuando sigan siendo válidos.
Haz explícitos los fallos y mantén despejado el flujo normal
Separa el manejo de errores del algoritmo. Los códigos de retorno obligan a quien llama a comprobar cada operación y suelen anidar condiciones de éxito alrededor del trabajo principal. Las excepciones pueden llevar el tratamiento de fallos a una ruta distinta, mientras que un contexto de error útil identifica qué operación falló y por qué. Envolver una API de terceros puede traducir varias excepciones específicas de un proveedor a un único tipo que la aplicación pueda manejar de manera coherente.
No hagas que la ausencia sea ambigua. Devolver null impone a cada cliente una obligación oculta e invita a que se olviden comprobaciones. Por ejemplo, si no hay empleados, una lista vacía permite recorrerla sin riesgos y sin bifurcar el flujo. Para una situación especial legítima, un objeto específico puede proporcionar el comportamiento habitual; por ejemplo, un resultado de gastos de comida que ofrece una cantidad fija de viáticos cuando no existe ninguna solicitud de reembolso por comida. Evita aceptar entradas null a menos que la interfaz lo exija explícitamente.
Este enfoque trata los errores como parte de la interfaz y no como residuos molestos de la implementación. Resulta especialmente eficaz cuando quienes llaman al código pueden responder de manera significativa al fallo y las excepciones aportan suficiente contexto para diagnosticarlo. El enfoque de los casos especiales también reduce las ramificaciones al representar una ausencia válida mediante un valor utilizable. Los sistemas de tipos modernos pueden hacer más explícitas estas elecciones, pero ninguna representación elimina la necesidad de decidir si un suceso es excepcional, esperado o recuperable.
Crea puntos de separación en torno a las bibliotecas y el arranque para mantener localizados los cambios
Mantén las suposiciones externas en los bordes. Una colección de propósito general, como un mapa, puede permitir operaciones o valores que la aplicación no quiere. Un pequeño envoltorio específico de la aplicación puede exponer solo el comportamiento necesario y mantener en un único lugar las conversiones de tipos, las reglas de tipos y los detalles de la biblioteca. Las pruebas de aprendizaje son experimentos pequeños para comprobar cómo se comporta una API desconocida antes de que el código de producción dependa de ella. Por ejemplo, las pruebas de log4j revelaron detalles de configuración que la documentación por sí sola no había aclarado.
Separa la construcción del uso. Construye y conecta los objetos principales en una zona de arranque, una fábrica o un contenedor de inyección de dependencias. Así, la aplicación puede usar objetos de dominio sencillos sin saber cómo se ensambla cada dependencia. Si todavía no existe una API, define la interfaz que necesita la aplicación y conecta con el proveedor futuro mediante un adaptador.
Un límite es tanto un punto de separación técnico como un lugar para gestionar la incertidumbre. Los envoltorios reducen la cantidad de lugares afectados por un cambio de proveedor, mientras que las pruebas de aprendizaje convierten un comportamiento no documentado en pruebas reproducibles. Separar el arranque de la ejecución también facilita probar la lógica de la aplicación sin construir el sistema entero. La contrapartida es el coste de las abstracciones: envolver todos los tipos de una biblioteca o adoptar prematuramente un marco de trabajo grande puede crear más mecanismos que protección. Encapsula un límite cuando reduzca el coste de los cambios de forma significativa o evite usos indebidos.
Trata la concurrencia como un problema de diseño distinto, no como un interruptor de velocidad
El estado compartido crea rutas de ejecución ocultas. Si dos hilos incrementan el mismo identificador, ambos pueden leer el valor anterior antes de que ninguno escriba, lo que genera un duplicado y pierde una actualización. El libro calcula que hay 12.870 posibles intercalaciones de instrucciones de código de bytes para un incremento sencillo con dos hilos, lo que ilustra por qué una línea que parece indivisible puede no ser atómica. La concurrencia ayuda cuando el trabajo puede solaparse con esperas, como durante el acceso a la red; no acelera automáticamente el trabajo limitado por el procesador.
Reduce las oportunidades de interferencia. Mantén separado el código que maneja hilos, limita los datos compartidos, usa copias o datos independientes para las tareas siempre que sea posible y mantén pequeñas las secciones sincronizadas. Aprende el modelo de ejecución y las herramientas de la biblioteca pertinentes. Prueba con distintas cantidades de hilos, plataformas y cargas, y trata los fallos poco frecuentes como pruebas reales, en vez de descartarlos como casos aislados.
La idea central del capítulo es que la concurrencia amplía el conjunto de secuencias posibles que el programa debe soportar. Por eso, el aislamiento y las interfaces controladas valen más que distribuir mecanismos de bloqueo ingeniosos por el código de la aplicación. La mejora del rendimiento depende de las circunstancias: el trabajo paralelo puede ocultar tiempos de espera, pero los hilos adicionales también generan coordinación y contención. El diseño más responsable empieza por identificar el cuello de botella y el estado compartido, y luego usa pruebas para cuestionar las suposiciones sobre la planificación, en vez de suponer que una ejecución satisfactoria demuestra que todo es seguro.
Análisis
Código limpio se entiende mejor como un libro sobre cómo controlar el coste de los cambios. Todas sus técnicas concretas, desde los nombres precisos hasta las interfaces acotadas, reducen la cantidad de contexto oculto que una persona que desarrolle en el futuro deberá reconstruir. La narración del libro refuerza esta tesis con productos deteriorados, funciones desmesuradas, un analizador de línea de comandos rescatado mediante la refactorización y una lógica de fechas cuyos defectos solo aparecieron al ampliar las pruebas. Los casos importan porque los consejos se presentan como una práctica artesanal, no como una lista de verificación que produce calidad por arte de magia.
La síntesis más duradera es un ciclo de retroalimentación: expresar con claridad la intención, probar el comportamiento, introducir una pequeña mejora estructural y verificar que el comportamiento siga intacto. La legibilidad facilita inspeccionar los defectos y las responsabilidades. Las pruebas hacen menos intimidante la limpieza. Los límites pequeños impiden que los cambios externos se propaguen. Estas prácticas se refuerzan entre sí, por lo que tratar las pruebas o el formato como un retoque opcional socava el sistema en su conjunto.
El libro tiene opiniones marcadas, y algunas de sus reglas conviene tratarlas como criterios predeterminados, no como absolutos. Las funciones muy pequeñas pueden fragmentar el flujo de control. Las abstracciones pueden multiplicarse sin aportar flexibilidad útil. Los comentarios pueden conservar una justificación del dominio que los nombres no pueden transmitir. Incluso la mejor arquitectura depende de los tipos de cambio a los que el sistema se enfrente realmente. Los propios estudios de caso del libro muestran un criterio más sensato que el cumplimiento rígido: inspeccionar el código, poner a prueba las suposiciones, hacer un cambio localizado y evaluar el resultado.
Su tesis profesional más amplia es que la velocidad y el cuidado no son opuestos cuando el software debe evolucionar. La medida pertinente no es cuán rápido se escribe el código, sino con qué facilidad puede un equipo entenderlo, modificarlo de manera segura y verificarlo. Por tanto, la limpieza no es perfección visual. Es una inversión continua para que el siguiente cambio siga siendo comprensible y asequible.
Resumen de reseñas
Código limpio recibe, en general, críticas positivas por sus principios para escribir código legible y fácil de mantener. Los lectores valoran los consejos prácticos sobre nombres, funciones y pruebas. Entre las críticas más habituales están su enfoque en Java y algunas directrices demasiado estrictas. Muchos lo consideran una lectura imprescindible para los desarrolladores, aunque a algunos programadores con experiencia les resulta menos útil. Algunos elogian los casos prácticos y los ejemplos de refactorización, mientras que otros los consideran excesivos. En conjunto, los críticos coinciden en que el libro ofrece ideas valiosas sobre la calidad del código, aunque no todas sus sugerencias sean aplicables en todos los casos.
También leyeron
Glosario
criterio para el código (code-sense)
criterio para refactorizarLa capacidad, adquirida con la práctica, de reconocer código confuso o enrevesado, imaginar alternativas mejores y elegir una secuencia de cambios que preserve el comportamiento y lo mejore. El libro presenta esta capacidad como una habilidad que se desarrolla mediante la práctica repetida, no como un instinto que se adquiere memorizando reglas.
regla del Boy Scout
dejar el código mejorUn principio de mantenimiento que pide a los desarrolladores que hagan una pequeña mejora cada vez que trabajan en una parte del código. El cambio no tiene por qué ser grande: un nombre más claro, una función más breve o la eliminación de código duplicado pueden evitar el deterioro gradual si se repite esta práctica.
regla del descenso gradual
ordenar por nivel de abstracciónUna forma de organizar las funciones para que el lector pueda pasar de una operación de alto nivel a los pasos de nivel inferior que la implementan. Cada función llama al siguiente nivel de detalle o lo introduce, de modo que el archivo fuente se lee como una explicación cada vez más específica.
principio de responsabilidad única
un motivo para cambiarUn principio de diseño según el cual una clase o módulo debe tener una sola responsabilidad, entendida como un motivo principal por el que tendría que cambiar. Orienta la delimitación de las clases: los comportamientos que cambian por motivos distintos son candidatos a separarse en unidades diferentes.
ley de Demeter
limitar la navegación entre objetosUna heurística de diseño que desaconseja que un método navegue por varios objetos para llegar a un detalle interno. Un módulo debería comunicarse principalmente con sus propios métodos, los objetos que crea, los argumentos que recibe y los objetos que contiene directamente, en vez de depender del grafo de objetos de un colaborador.
F.I.R.S.T.
cinco cualidades de las pruebasUn acrónimo para las cualidades de las pruebas unitarias limpias: rápidas, independientes, repetibles, autoevaluables y oportunas. En conjunto, estas cualidades hacen que sea práctico ejecutar las pruebas con frecuencia, que sea sencillo diagnosticar sus resultados y que estén estrechamente relacionadas con el código cuyo comportamiento especifican.
pruebas de aprendizaje
sondear API externasPruebas pequeñas que se escriben para explorar y confirmar cómo se comporta una biblioteca de terceros cuando se usa del modo que espera una aplicación. Permiten convertir en pruebas ejecutables las suposiciones sobre una interfaz desconocida, ayudan a distinguir el comportamiento de la biblioteca de los errores de la aplicación y pueden detectar cambios incompatibles tras actualizar la biblioteca.
inyección de dependencias
proporcionar las dependencias desde fueraUn enfoque de gestión de dependencias en el que un objeto no construye ni localiza a sus propios colaboradores. Una rutina de inicio o un contenedor crea los objetos necesarios y los proporciona mediante constructores o métodos de asignación, separando la construcción de objetos del comportamiento de la aplicación durante la ejecución.
patrón de caso especial (Special Case Pattern)
encapsular excepciones previstasUna técnica para representar una situación excepcional legítima mediante un objeto que proporciona el comportamiento adecuado, de modo que quienes lo llaman no necesiten una rama aparte. Por ejemplo, una consulta de gastos puede devolver un objeto de gastos de comidas que proporcione un total por dieta cuando no se haya registrado ningún gasto de comidas.
separación entre comandos y consultas
separar los cambios de las consultasUn principio de diseño que asigna una sola función a cada función: cambiar el estado de un objeto o devolver información sobre él. Combinar ambas cosas puede volver ambigua una llamada, sobre todo cuando se usa como condición una operación que cambia el estado. Separar ambas funciones facilita la comprensión tanto del código como de su intención.
Preguntas frecuentes
¿De qué trata «Código limpio»?
- Enfoque en el código limpio: «Código limpio», de Robert C. Martin, hace hincapié en escribir código que sea fácil de leer, comprender y mantener.
- Profesionalismo al programar: Sostiene que el código limpio es una señal de profesionalismo en el desarrollo de software.
- Consejos prácticos: El libro ofrece pautas, ejemplos y casos prácticos para ayudar a los desarrolladores a escribir código limpio y eficiente.
¿Por qué debería leer «Código limpio»?
- Mejorar las habilidades de programación: Enseña a escribir código limpio, eficiente y fácil de mantener.
- Aprender de expertos: Forma parte de la serie de Robert C. Martin, conocida por su enfoque técnico y pragmático.
- Beneficios a largo plazo: Escribir código limpio reduce los costos de mantenimiento y hace que usted sea un desarrollador más valioso.
¿Cuáles son las principales conclusiones de «Código limpio»?
- Legibilidad del código: Hace hincapié en que el código debe ser fácil de leer y comprender.
- Principio de responsabilidad única: Propone que cada clase o función tenga un solo motivo para cambiar.
- Mejora continua: Anima a los desarrolladores a mejorar continuamente su código, siguiendo la regla del Boy Scout.
¿Cómo define «Código limpio» el código limpio?
- Elegancia y eficiencia: El código limpio se describe como elegante y eficiente, y con dependencias mínimas.
- Legible y fácil de mantener: Debería leerse como una prosa bien escrita y dejar clara la intención del diseñador.
- Enfocado y con un único propósito: Cada función, clase y módulo debería tener un propósito único y claro.
¿Qué es el principio de responsabilidad única en «Código limpio»?
- Un motivo para cambiar: Una clase o módulo debería tener un solo motivo para cambiar, y solo uno.
- Mejora la cohesión: Garantiza que las clases sean cohesivas, con métodos y variables estrechamente relacionados.
- Facilita el mantenimiento: Hace que el código sea más fácil de mantener y ampliar, y reduce el impacto de los cambios.
¿Qué es la «regla del Boy Scout» que se menciona en «Código limpio»?
- Mejora continua: Sugiere dejar el código más limpio de lo que estaba al encontrarlo.
- Pequeños cambios graduales: Anima a hacer pequeñas mejoras, como cambiar el nombre de variables o dividir funciones.
- Responsabilidad profesional: Se presenta como una responsabilidad profesional para garantizar que el código sea fácil de mantener.
¿Qué enfoque adopta «Código limpio» respecto al desarrollo guiado por pruebas (TDD)?
- Disciplina fundamental: El TDD es crucial para escribir código limpio y fiable.
- Tres leyes del TDD: Escribir primero una prueba que falle, escribir código para que la prueba pase y, después, refactorizar.
- Beneficios: Ayuda a detectar errores pronto y mejora el diseño del código.
¿Qué son los «olores del código» según «Código limpio»?
- Definición: Indicadores de posibles problemas que dificultan la legibilidad o el mantenimiento.
- Ejemplos: Métodos largos, clases grandes y código duplicado.
- Cómo abordar los olores: Ofrece heurísticas y técnicas de refactorización para mejorar la calidad del código.
¿Cómo propone «Código limpio» gestionar las excepciones?
- Preferir las excepciones: Usar excepciones en lugar de códigos de error para disponer de más contexto y facilitar su gestión.
- Proporcionar contexto: Incluir mensajes y contexto significativos al lanzar excepciones.
- Evitar las excepciones comprobadas: Sugiere usar excepciones no comprobadas para lograr un código más limpio.
¿Qué función cumplen las pruebas unitarias en «Código limpio»?
- Garantizar la calidad del código: Las pruebas unitarias garantizan que el código funcione como se espera y siga siendo fácil de mantener.
- Desarrollo guiado por pruebas: Promueve escribir pruebas antes del código de producción.
- Pruebas limpias y legibles: Las pruebas deberían ser tan limpias y legibles como el código de producción.
¿Qué función cumple la refactorización en «Código limpio»?
- Mejora continua: La refactorización mejora la estructura y la legibilidad del código sin cambiar su funcionalidad.
- Técnicas: Ofrece técnicas como extraer un método y cambiar el nombre de una variable para mejorar la calidad del código.
- Refactorizar sin miedo: Con pruebas exhaustivas, los desarrolladores pueden refactorizar con confianza.
¿Cuáles son las mejores citas de «Código limpio» y qué significan?
- «El código limpio hace bien una sola cosa». Hace hincapié en la concentración y la claridad del código.
- «Deja el campamento más limpio de lo que lo encontraste». Anima a mejorar continuamente el código.
- «Sabes que estás trabajando con código limpio cuando cada rutina que lees resulta ser, más o menos, lo que esperabas». Destaca la importancia de la legibilidad y la previsibilidad.
Descargar PDF
Descargar EPUB
.epub es ideal para leer libros electrónicos en teléfonos, tabletas y lectores electrónicos.