Buenas prácticas

Artículos en los que trato de explicar mi forma de desarrollar software de la mejor forma dentro de mis posibilidades.

Artículos etiquetados con good-practices

• Code Opinion (03 Apr 2024)
  
• Teoría de constraints y mejora de equipos (16 Mar 2024)
  
• Functional options en Go (26 Jan 2024)
  
• Aislarse del sistema de archivos y una técnica de testing (15 Jan 2024)
  
• Haciendo un spike para crear una librería de Go (13 Jan 2024)
  
• ¿Cuantos parámetros por función? (27 Dec 2023)
  
• Interfaces en Go (18 Dec 2023)
  
• Refactoring para quienes no refactorizan 3 (03 Dec 2023)
  
• Refactor para quienes no refactorizan 2 (29 Nov 2023)
  
• Refactoring para quienes no refactorizan (26 Nov 2023)
  
• Como añadir features en arquitectura hexagonal (08 Nov 2023)
  
• Cuando y como testear métodos privados (19 Oct 2023)
  
• Creando un adaptador driver en una aplicación hexagonal (11 Oct 2023)
  
• Los tests mentirosos (27 Sep 2023)
  
• Intentando llegar a buen puerto con Arquitectura Hexagonal y BDD (11 Jun 2023)
  
• Una aplicación hexagonal construida con BDD (1) (10 Jun 2023)
  
• De condicionales a polimorfismo (31 May 2023)
  
• Refactoriza rompiendo cosas (28 May 2023)
  
• Cobertura de test rápida con Golden Master (14 May 2023)
  
• Tests y repositorios (28 Mar 2023)
  
• Desacoplarse del sistema (24 Mar 2023)
  
• Como mejorar tus tests (22 Jan 2023)
  
• Dungeon 15. Problemas con null y modelando una mano (18 Jan 2023)
  
• Sobre herencia, composición y cosas de encapsulación (12 Jan 2023)
  
• Dungeon 14. Salir con un tesoro. Parte 2 (04 Jan 2023)
  
• Dungeon 13. Salir con un tesoro. Parte 1 (20 Dec 2022)
  
• Decoradores en Python (16 Dec 2022)
  
• Dungeon 12. Otra revisión de código (13 Dec 2022)
  
• Dungeon 11. Power-ups y un poco de orden (08 Dec 2022)
  
• Dungeon 10. Eventos para controlarlos a todos (06 Dec 2022)
  
• Dungeon 9. El camino equivocado (03 Dec 2022)
  
• Dungeon 8. Energía y feature flags (23 Nov 2022)
  
• Dungeon 7. Code Review (20 Nov 2022)
  
• Dungeon 6. Builders al rescate (16 Nov 2022)
  
• Dungeon 5. Laberintos y deuda técnica (13 Nov 2022)
  
• Dungeon 4. Una historia de usuario (12 Nov 2022)
  
• Dungeon 3. Compaginar diseño y delivery (11 Nov 2022)
  
• Dungeon 2. The Walking Skeleton (10 Nov 2022)
  
• Dungeon 1. Empezando por algún sitio (09 Nov 2022)
  
• Desarrollo iterativo e incremental (05 Nov 2022)
  
• Generar representaciones de un objeto sin exponer getters (20 Oct 2022)
  
• Object Calisthenics. Comentarios finales (12 Oct 2022)
  
• Object Calisthenics. No user getters, setters o propiedades públicas (10 Oct 2022)
  
• Object Calisthenics. No más de dos variables de instancia por clase (08 Oct 2022)
  
• Object Calisthenics. Mantener todas las entidades pequeñas (07 Oct 2022)
  
• Object Calisthenics. No usar abreviaturas (06 Oct 2022)
  
• Object Calisthenics. Un punto por línea (04 Oct 2022)
  
• Object Calisthenics. Colecciones de primera clase (02 Oct 2022)
  
• Object Calisthenics. Empaquetar primitivas en objetos (30 Sep 2022)
  
• Object Calisthenics. No usar la palabra clave ELSE (29 Sep 2022)
  
• Object Calisthenics. Solo un nivel de indentación. (28 Sep 2022)
  
• Más allá de la pirámide de tests (23 Sep 2022)
  
• Mis problemas gestionando errores en Golang (14 Sep 2022)
  
• Constructores limpios (03 Apr 2022)
  
• Como hacer una kata de código (31 Mar 2022)
  
• El patrón State (05 Oct 2021)
  
• Arreglando una suite de tests rota (17 May 2021)
  
• De abstracciones y duplicaciones (23 Jan 2021)
  
• El falso dilema. Calidad versus velocidad (01 Jan 2021)
  
• Las seis preguntas para comentar tu código (20 Nov 2020)
  
• Escribir código a prueba de futuro (05 Nov 2020)
  
• Escribir código a prueba de futuro 2 (05 Nov 2020)
  
• Mi código en producción ya es legacy (26 Oct 2020)
  
• Trabajar con legacy y entender el dominio 3 (27 Sep 2020)
  
• Trabajar con legacy y entender el dominio 2 (22 Sep 2020)
  
• Trabajar con legacy y entender el dominio (19 Sep 2020)
  
• Más allá de SOLID, los principios olvidados (12 Sep 2020)
  
• Pong en Python. Recuperarse de un sprint fallido (30 Aug 2020)
  
• Más allá de SOLID, los consejos prácticos (30 Aug 2020)
  
• Más allá de SOLID, los cimientos (15 Aug 2020)
  
• Más allá de SOLID, principios básicos (09 Aug 2020)
  
• Pong en Python. Refinamiento y sprint desbocado (05 Aug 2020)
  
• Value Objects con Doctrine (27 Jul 2020)
  
• Pong en Python. Ramas y bugs (28 Jun 2020)
  
• Pong en Python. Agilidad y prioridades (21 Jun 2020)
  
• Pong en Python. Desarrollo ágil (14 Jun 2020)
  
• Pong en Python. Nuevas features, nuevos tests (13 Jun 2020)
  
• Pong en Python. Eliminando deuda técnica. (07 Jun 2020)
  
• Pong en Python. Mejorando la aplicación (06 Jun 2020)
  
• Pong en Python. Separando el legacy en Scenes (06 Jun 2020)
  
• Pong en Python. Reubicar el legacy y automatizar los tests (04 Jun 2020)
  
• Pong en Python. Los prototipos como punto de partida de un proyecto de software (01 Jun 2020)
  
• Pong en Python. Convivencia entre legacy y código nuevo (01 Jun 2020)
  
• Tests y excepciones (26 Feb 2020)
  
• Construir confianza en el código, test a test (07 Feb 2020)
  
• De ddd a DDD paso a paso 2. Del repositorio al dominio. (03 Jan 2020)
  
• De directory driven a DDD paso a paso (17 Dec 2019)
  
• Alien Value Object para traducir valores entre sistemas (14 Dec 2019)
  
• DDD no es lo que te han contado (06 Dec 2019)
  
• DDD, el lenguaje ubicuo (24 Nov 2019)
  
• Cositas de Orientación a Objetos con Swift (21 Nov 2019)
  
• DDD, identificando el dominio y los subdominios (12 Nov 2019)
  
• Una introducción a Domain Driven Design (08 Nov 2019)
  
• Object Calisthenics para adelgazar las clases (03 Nov 2019)
  
• Object Calisthenics para mejorar el diseño de las clases (20 Oct 2019)
  
• Cláusulas de guarda con asserts (24 Jun 2019)
  
• Refactor cotidiano (8). Dónde poner el conocimiento (28 Apr 2019)
  
• Refactor cotidiano (7). Refactoriza de single return a return early (14 Apr 2019)
  
• La dualidad del testing (05 Apr 2019)
  
• Refactor cotidiano (6). Aplica Tell, Don't Ask y la Ley de Demeter (30 Mar 2019)
  
• Como introducir o aumentar el testing en tu aplicación (23 Mar 2019)
  
• Refactor cotidiano (5). Refactoriza a Enumerables (09 Mar 2019)
  
• Refactor cotidiano (4). Sustituye escalares por objetos (13 Jan 2019)
  
• Refactor cotidiano (3). Acondiciona las condicionales (08 Dec 2018)
  
• Refactor cotidiano (2). Mejora los nombres (01 Dec 2018)
  
• Refactor cotidiano (1). Fuera comentarios (24 Nov 2018)
  
• Refactor cotidiano (24 Nov 2018)
  
• Refactor 101. The camp rule (05 Nov 2018)
  
• La elección de los casos para testear (01 Nov 2018)
  
• Arquitectura de una aplicación PHP (02 Sep 2018)
  
• El drama de los objetos anémicos (02 Sep 2018)
  
• Cómo poner nombres (20 Jun 2018)
  
• Refactorizar trata sobre conocimiento y significado (12 Jun 2018)
  
• Dependencias y acoplamiento (05 Jun 2018)
  
• Clean testing (03 Jun 2018)
  
• Programar sin ifs (09 May 2018)
  
• Sobre la expresividad del código (01 May 2018)
  
• Manejar excepciones (22 Feb 2018)