SOLID — Intermedio

Este curso está dirigido a desarrolladoras y desarrolladores de software con conocimientos previos de los principios SOLID que buscan consolidar y profundizar su aplicación en contextos reales de diseño orientado a objetos. A lo largo de las ocho horas de trabajo, la persona participante abordará cada principio SOLID desde una perspectiva práctica y crítica: refactorizará clases con responsabilidades mezcladas, extenderá diseños cerrados a modificación directa, evaluará jerarquías de herencia bajo criterios de sustitución, segregará interfaces sobredimensionadas y desacoplará módulos de alto nivel mediante inyección de dependencias. El curso cierra con un ejercicio integrador en el que todos los principios se aplican de forma coherente sobre un módulo de complejidad media, y con una reflexión argumentada sobre cuándo la aplicación estricta de SOLID puede introducir complejidad accidental innecesaria. Al finalizar, la persona será capaz de diseñar y revisar código orientado a objetos aplicando los cinco principios con criterio, justificando sus decisiones de diseño ante equipos técnicos.

1. Identificar las razones de cambio presentes en un módulo con responsabilidades mezcladas y diseñar la estructura de clases refactorizada que cumpla el principio de responsabilidad única.
2. Aplicar el principio de abierto/cerrado extendiendo un diseño existente mediante herencia o composición en al menos dos casos de uso distintos, sin modificar el código ya cerrado.
3. Evaluar jerarquías de herencia determinando cuáles cumplen o violan el principio de sustitución de Liskov a partir del comportamiento observable de las subclases en escenarios de sustitución.
4. Segregar una interfaz sobredimensionada en interfaces de cliente específicas, justificando el criterio de separación utilizado y las mejoras de acoplamiento resultantes.
5. Diseñar un módulo de alto nivel desacoplado de implementaciones concretas aplicando el principio de inversión de dependencias mediante inyección de dependencias en presencia de al menos una dependencia externa.
6. Comparar soluciones alternativas a un mismo problema de diseño argumentando cuál respeta mejor los principios de abierto/cerrado y de segregación de interfaces, y explicando las implicaciones de mantenibilidad de cada opción.
7. Integrar los cinco principios SOLID de forma coherente en el diseño completo de un módulo de complejidad media, sin violaciones detectables mediante revisión de pares.
8. Argumentar por escrito la decisión de no aplicar uno o más principios SOLID en un fragmento de código concreto, balanceando calidad de diseño frente a complejidad accidental.

Bloque 1 — Responsabilidad única y cierre a la modificación. El bloque arranca con un análisis detallado del principio de responsabilidad única: cómo identificar con precisión las razones de cambio de un módulo, qué señales en el código revelan responsabilidades mezcladas y cómo trazar la nueva estructura de clases tras la refactorización. A continuación se aborda el principio de abierto/cerrado, explorando las dos estrategias principales de extensión —herencia y composición— y aplicando cada una sobre casos de uso reales donde el código existente debe permanecer intacto. El bloque incluye ejercicios de comparación entre diseños que respetan y que violan estos dos primeros principios, de modo que la persona participante construya un criterio sólido antes de avanzar.

Bloque 2 — Sustitución de Liskov y segregación de interfaces. Este bloque examina el principio de sustitución de Liskov desde el comportamiento observable de las subclases: se estudian jerarquías de herencia problemáticas, se diseñan tests de sustitución y se argumenta cuál jerarquía cumple el contrato y cuál lo rompe, y por qué. Seguidamente se trabaja el principio de segregación de interfaces: se parte de interfaces sobredimensionadas reales, se identifican los distintos perfiles de cliente, se aplican los criterios de separación y se mide el impacto en el acoplamiento del sistema resultante. Ambos principios se estudian también de forma comparada, evaluando soluciones alternativas a un mismo problema para razonar sobre mantenibilidad y cohesión.

Bloque 3 — Inversión de dependencias, integración y juicio crítico. El bloque final profundiza en el principio de inversión de dependencias: qué significa que un módulo de alto nivel dependa de abstracciones y no de concreciones, cómo se implementa la inyección de dependencias en presencia de servicios externos y qué patrones facilitan el desacoplamiento sin añadir burocracia innecesaria. Sobre esta base, la persona participante afronta el ejercicio integrador: diseñar desde cero un módulo de complejidad media aplicando los cinco principios de forma simultánea y coherente, sometiendo el resultado a revisión de pares guiada. El bloque cierra con una sesión de reflexión crítica en la que se argumenta, con base técnica, cuándo la aplicación de SOLID puede ser contraproducente y cómo equilibrar rigor de diseño con pragmatismo en proyectos reales.

• Ordenador con acceso a un entorno de desarrollo (IDE) configurado para el lenguaje orientado a objetos de referencia del curso.
• Versión estable del lenguaje y su gestor de dependencias instalados localmente o acceso a un entorno en la nube equivalente (p. ej. Gitpod, GitHub Codespaces).
• Repositorio de ejercicios del curso clonado antes de la primera sesión (enlace facilitado en la plataforma).
• Acceso a un framework de testing unitario compatible con el lenguaje utilizado.
• Navegador actualizado para acceder a los materiales, vídeos y herramienta de revisión de pares de la plataforma.

• Conocimiento de los cinco principios SOLID a nivel conceptual (cubierto en SOL01 o equivalente).
• Familiaridad con los conceptos de herencia, composición e interfaces en un lenguaje orientado a objetos.
• Capacidad de leer y escribir código orientado a objetos de complejidad básica-media.
• Noción básica de lo que constituye un test unitario y cómo ejecutarlo.