book

Libro de cocina de código limpio

by Maximiliano Contieri

September 2024

Intermediate to advanced

430 pages

8h 45m

Spanish

O'Reilly Media, Inc.

Book available

Read now

Unlock full access

A quién va dirigido este libroCómo está organizado este libroQué necesitas para utilizar este libroAccede a este libro en formato digitalConvenciones utilizadas en este libroUtilizar ejemplos de códigoAprendizaje en línea O'ReillyCómo contactar con nosotrosAgradecimientos
1.1. ¿Qué es el olor a código?1.2. ¿Qué es la refactorización?1.3. ¿Qué es una receta?1.4. ¿Por qué Código Limpio?1.5. Legibilidad, rendimiento o ambos1.6. Tipos de software1.7. Código generado por máquina1.8. Consideraciones sobre los nombres a lo largo del libro1.9. Patrones de diseño1.10. Paradigmas del lenguaje de programación1.11. Objetos frente a clases1.12. Modificabilidad
2.0. Introducción2.1. ¿Por qué es un modelo?2.2. ¿Por qué es abstracto?2.3. ¿Por qué es programable?2.4. ¿Por qué es parcial?2.5. ¿Por qué es explicativo?2.6. ¿Por qué se trata de la realidad?2.7. Inferir las reglas2.8. El único principio de diseño de software
3.0. Introducción3.1. Convertir Objetos Anémicos en Objetos Ricos3.2. Identificar la esencia de tus objetos3.3. Eliminar los definidores de los objetos3.4. Eliminar los generadores de código anémicos3.5. Eliminar propiedades automáticas3.6. Eliminar DTOs3.7. Completar constructores vacíos3.8. Eliminar Getters3.9. Evitar la Orgía de Objetos3.10. Eliminar propiedades dinámicas
4.0. Introducción4.1. Crear objetos pequeños4.2. Reificar los datos primitivos4.3. Reificar matrices asociativas4.4. Eliminar los abusos de las cadenas4.5. Reificar marcas de tiempo4.6. Reificar subconjuntos como objetos4.7. Reificar las validaciones de cadenas4.8. Eliminar propiedades innecesarias4.9. Crear intervalos de fechas
5.0. Introducción5.1. Cambiar var por const5.2. Declarar que las variables son variables5.3. Prohibición de cambios en la esencia5.4. Evitar las matrices const mutables5.5. Eliminar la inicialización perezosa5.6. Congelar constantes mutables5.7. Eliminar los efectos secundarios5.8. Evitar la elevación
6.0. Introducción6.1. Limitar las variables reutilizadas6.2. Eliminar líneas vacías6.3. Eliminar métodos versionados6.4. Eliminar dobles negativos6.5. Cambiar las responsabilidades equivocadas6.6. Sustitución de iteraciones explícitas6.7. Documentar las decisiones de diseño6.8. Sustituir números mágicos por constantes6.9. Separar el "qué" y el "cómo"6.10. Documentar expresiones regulares6.11. Reescribir las condiciones Yoda6.12. Eliminar métodos comediantes6.13. Evitar el infierno de las llamadas de retorno6.14. Generar buenos mensajes de error6.15. Evitar las correcciones mágicas
7.0. Introducción7.1. Expandir abreviaturas7.2. Renombrar y romper ayudantes y utilidades7.3. Cambiar el nombre de MisObjetos7.4. Cambiar el nombre de las variables de resultado7.5. Renombrar variables con nombre de tipo7.6. Renombrar nombres largos7.7. Renombrar nombres abstractos7.8. Corregir los errores ortográficos7.9. Eliminar nombres de clase de los atributos7.10. Eliminar la primera letra de clases e interfaces7.11. Renombrar Funciones Básicas / Hacer7.12. Convertir clases plurales en singulares7.13. Eliminar "Colección" de los nombres7.14. Eliminar el prefijo/sufijo "Impl de los nombres de las clases7.15. Cambiar el nombre de los argumentos según su función7.16. Eliminar nombres de parámetros redundantes7.17. Eliminar el contexto gratuito de los nombres7.18. Evitar la denominación de datos
8.0. Introducción8.1. Eliminar código comentado8.2. Eliminar comentarios obsoletos8.3. Eliminar comentarios lógicos8.4. Eliminar comentarios del Getter8.5. Convertir comentarios en nombres de funciones8.6. Eliminar comentarios dentro de los métodos8.7. Sustituir comentarios por pruebas

9.0. Introducción9.1. Cumplimiento de las normas del Código9.2. Normalización de las indentaciones9.3. Unificación de las convenciones de mayúsculas y minúsculas9.4. Escribir código en inglés9.5. Unificar el orden de los parámetros9.6. Arreglar ventanas rotas
10.0. Introducción10.1. Eliminar código repetido10.2. Eliminar ajustes/configuraciones y conmutadores de funciones10.3. Cambiar el Estado como Propiedades10.4. Eliminar la astucia del código10.5. Romper promesas múltiples10.6. Romper largas cadenas de colaboraciones10.7. Extraer un método a un objeto10.8. Cuidado con los constructores de matrices10.9. Eliminar objetos Poltergeist
11.0. Introducción11.1. Romper métodos demasiado largos11.2. Reducir el exceso de argumentos11.3. Reducir el exceso de variables11.4. Eliminar paréntesis excesivos11.5. Eliminar el exceso de métodos11.6. Romper demasiados atributos11.7. Reducir las listas de importación 11.8. Romper las funciones "Y11.9. Romper las interfaces gordas
12.0. Introducción12.1. Eliminar el código muerto12.2. Utilizar código en lugar de diagramas12.3. Refactorización de clases con una subclase12.4. Eliminar interfaces de un solo uso12.5. Eliminar los abusos del patrón de diseño12.6. Sustitución de cobros de empresas
13.0. Introducción13.1. Refactorización Reasignación de variables13.2. Hacer cumplir las condiciones previas13.3. Utilizar parámetros más estrictos13.4. Eliminar los valores por defecto de los conmutadores13.5. Evitar la modificación de colecciones durante el desplazamiento13.6. Redefinición de Hash e Igualdad13.7. Refactorización sin cambios funcionales
14.0. Introducción14.1. Sustituir los if accidentales por el polimorfismo14.2. Cambiar el nombre de las variables de indicadores de eventos14.3. Reificar variables booleanas14.4. Sustitución de las sentencias Switch/Case/Elseif14.5. Sustituir las condiciones if codificadas con colecciones14.6. Cambiar las condiciones booleanas a cortocircuito14.7. Añadir un Else implícito14.8. Reescribir el código condicional de las flechas14.9. Evitar cortocircuitos14.10. Reescribir el código de flechas anidadas14.11. Evitar que se devuelvan valores booleanos en las comprobaciones de condiciones14.12. Modificar la comparación con booleanos14.13. Extraer de ternarios largos14.14. Convertir funciones no polimórficas en polimórficas14.15. Cambiar la comparación de igualdad14.16. Reificar las condiciones comerciales codificadas14.17. Eliminar booleanos gratuitos14.18. Reescribir ternarios anidados
15.0. Introducción15.1. Crear objetos nulos15.2. Eliminar el encadenamiento opcional15.3. Convertir atributos opcionales en una colección15.4. Utilización de objetos reales en lugar de nulos15.5. Representar ubicaciones desconocidas sin utilizar nulos
16.0. Introducción16.1. Evitar los identificadores en los objetos16.2. Eliminar la optimización prematura16.3. Eliminar las optimizaciones prematuras bit a bit16.4. Reducir la sobregeneralización16.5. Cambiar las optimizaciones estructurales16.6. Retirada de los botes de ancla16.7. Extraer cachés de objetos de dominio16.8. Eliminar eventos de llamada de retorno basados en la implementación16.9. Eliminar consultas de los constructores16.10. Eliminar código de los destructores
17.0. Introducción17.1. Explicitar los supuestos ocultos17.2. Sustitución de Singletons17.3. Romper objetos de Dios17.4. Romper el cambio divergente17.5. Convertir los valores de los indicadores especiales 9999 en normales17.6. Quitar la escopeta quirúrgica17.7. Eliminar argumentos opcionales17.8. Evitar la envidia de funciones17.9. Eliminar al intermediario17.10. Mover los argumentos por defecto al final17.11. Evitar el efecto dominó17.12. Eliminar métodos accidentales en objetos de negocio17.13. Eliminar el Código de Negocio de la Interfaz de Usuario17.14. Cambiar el Acoplamiento a Clases17.15. Refactorización de grupos de datos17.16. Romper la intimidad inapropiada17.17. Convertir objetos fungibles
18.0. Introducción18.1. Reificar las funciones globales18.2. Reificar las funciones estáticas18.3. Sustituir GoTo por Código Estructurado18.4. Eliminar clases globales18.5. Modificar la creación de la fecha global
19.0. Introducción19.1. Romper la herencia profunda19.2. Romper las jerarquías del yo-yo19.3. Romper la subclasificación para reutilizar el código19.4. Sustituir la relación "is-a" por un comportamiento19.5. Eliminar clases anidadas19.6. Renombrar clases aisladas19.7. Hacer definitivas las clases concretas19.8. Definir explícitamente la herencia de clases19.9. Migrar clases vacías19.10. Retrasar la clasificación prematura19.11. Eliminar atributos protegidos19.12. Completar implementaciones vacías
20.0. Introducción20.1. Comprobación de métodos privados20.2. Añadir descripciones a las aserciones20.3. Migrar assertTrue a aserciones específicas20.4. Sustituir simulacros por objetos reales20.5. Perfeccionar las afirmaciones genéricas20.6. Eliminar pruebas defectuosas20.7. Cambiar las afirmaciones de los números flotantes20.8. Cambiar los datos de prueba por datos realistas20.9. Proteger las pruebas que violan la encapsulación20.10. Eliminar información irrelevante del test20.11. Añadir cobertura para cada solicitud de fusión20.12. Reescritura de pruebas en función de las fechas20.13. Aprender un nuevo lenguaje de programación
21.0. Introducción21.1. Eliminar el código dependiente de la producción21.2. Eliminar rastreadores de defectos21.3. Eliminar Advertencia/Desactivación Estricta21.4. Evitar y eliminar ToDos y FixMes
22.0. Introducción22.1. Eliminar bloques de excepción vacíos22.2. Eliminar excepciones innecesarias22.3. Reescribir excepciones para casos esperados22.4. Reescribir Try/Catches anidados22.5. Sustituir los Códigos de Devolución por Excepciones22.6. Reescribir el código de las flechas de excepción22.7. Ocultar los Errores de Bajo Nivel a los Usuarios Finales22.8. Limitación de los intentos de excepción
23.0. Introducción23.1. Eliminar el uso de la metaprogramación23.2. Reificar funciones anónimas23.3. Eliminar preprocesadores23.4. Eliminar métodos dinámicos
24.0. Introducción24.1. Eliminar la comprobación de tipos24.2. Tratar con valores de verdad24.3. Cambiar números flotantes a decimales
25.0. Introducción25.1. Desinfección de entradas25.2. Cambiar los identificadores secuenciales25.3. Eliminar dependencias de paquetes25.4. Sustitución de expresiones regulares malignas25.5. Proteger la deserialización de objetos

Overview

Este trabajo se ha traducido utilizando IA. Agradecemos tus opiniones y comentarios: translation-feedback@oreilly.com

A menudo, los ingenieros y arquitectos de software trabajan con bases de código grandes y complejas que necesitan escalar y mantener. Con este libro de cocina, el autor Maximiliano Contieri te lleva más allá del concepto de código limpio, mostrándote cómo identificar las oportunidades de mejora y su impacto en el código de producción. Cuando se trata de fiabilidad y evolución del sistema, estas técnicas proporcionan beneficios que se amortizan con el tiempo.

Utilizando ejemplos de la vida real en JavaScript, PHP, Java, Python y muchos otros lenguajes de programación, este libro de cocina proporciona recetas probadas que te ayudarán a escalar y mantener grandes sistemas. Cada sección abarca conceptos fundamentales como legibilidad, acoplamiento, comprobabilidad y extensibilidad, así como olores de código -síntomas de un problema que requiere especial atención- y las recetas para abordarlos.

A medida que avanzas en este libro, las recetas de refactorización y la variedad de olores de código aumentan en complejidad. Lo harás:

Comprenderás las ventajas del código limpio y aprenderás a detectar los olores de código
Aprenderás técnicas de refactorización paso a paso
Obtén ejemplos ilustrativos de código en varios lenguajes de programación modernos
Obtén un catálogo completo de los olores de código más comunes, su impacto y las posibles soluciones
Utiliza código directo al grano, favoreciendo la legibilidad y el aprendizaje