Merge pull request #10 from RodrigoSotelo10/main

Trabajo Rodrigo Sotelo

Author: IoTeacher

docs/temas/Estudio de casos sobre refactorización de proyectos legacy/ANEXO.md

@@ -0,0 +1,18 @@
+# 📎 ANEXOS
+- Alumno: Rodrigo Sotelo
+- Matricula: 21212053
+
+## Prompt utilizado
+
+“Necesito elaborar un estudio de casos sobre refactorización de proyectos legacy para un curso de Patrones de Diseño. El documento debe estar en formato académico, con introducción, desarrollo de varios casos, análisis crítico y conclusiones. Agrega ejemplos de código en C# que ilustren el antes y después de aplicar patrones como Strategy o Facade, Usa un estilo claro
+
+## Reflexión sobre el uso de LLMs 🤔
+
+El uso de ChatGPT permitió **estructurar mejor las ideas** y **organizar el contenido** de manera clara y coherente. Fue especialmente útil para generar **ejemplos de código en C#** y relacionar los casos con los **patrones de diseño** más adecuados.
+
+Aun así, la herramienta tiene limitaciones:
+
+- Algunas respuestas iniciales fueron **demasiado generales** y requirieron **ajustes manuales**.  
+- **No sustituye** la revisión crítica ni la personalización del contenido.
+
+En conclusión, considero que este tipo de herramientas son un **apoyo válido** siempre que se utilicen de manera ética ⚖️, reconociendo su uso y adaptando los resultados al contexto del curso.

docs/temas/Estudio de casos sobre refactorización de proyectos legacy/readme.md

@@ -0,0 +1,154 @@
+# 📑 Estudio de Casos sobre Refactorización de Proyectos Legacy
+
+**Alumno:** Rodrigo Sotelo Rubio  
+**Matrícula:** 21212053
+
+---
+
+## 1. Introducción 
+
+En este documento presento un análisis sobre la refactorización de proyectos legacy, explorando casos prácticos donde se aplicaron patrones de diseño para mejorar la calidad, mantenibilidad y escalabilidad del software.
+
+Un sistema legacy, aunque funcional, suele tener problemas de deuda técnica ⚠️, acoplamiento excesivo o falta de pruebas automatizadas. La refactorización, apoyada en patrones de diseño, es una estrategia clave para extender la vida útil de estos sistemas y alinearlos con las necesidades actuales.
+
+---
+
+## 2. Estudio de Casos 🛠️
+
+### Caso 1: Sistema bancario con código spaghetti 🍝
+
+- **Problema:** el sistema tenía múltiples métodos duplicados y clases monolíticas difíciles de mantener.  
+- **Refactorización aplicada:** introducción del patrón Facade para unificar accesos a subsistemas.  
+- **Resultado:** el código se volvió más claro 📝, con menor acoplamiento y mayor facilidad para agregar nuevas funcionalidades.
+
+---
+
+### Caso 2: Aplicación web sin pruebas unitarias 🐞
+
+- **Problema:** cualquier cambio en el código generaba errores en producción porque no había pruebas.  
+- **Refactorización aplicada:** se aplicó Inyección de Dependencias y se implementó el patrón Strategy para manejar reglas de negocio sin condicionales extensos.  
+- **Resultado:** se logró escribir pruebas unitarias ✅ y reducir drásticamente los errores en producción.
+
+**Ejemplo en C# 💻**
+
+**Código legacy con condicionales:**
+
+```csharp
+public class CalculadoraPrecio
+{
+    public double Calcular(string tipoCliente, double monto)
+    {
+        if (tipoCliente == "VIP")
+        {
+            return monto * 0.8; // 20% de descuento
+        }
+        else if (tipoCliente == "Regular")
+        {
+            return monto * 0.9; // 10% de descuento
+        }
+        else
+        {
+            return monto; // sin descuento
+        }
+    }
+}
+```
+
+**Código refactorizado:**
+
+
+```csharp
+public interface IDescuentoStrategy
+{
+    double AplicarDescuento(double monto);
+}
+
+public class DescuentoVIP : IDescuentoStrategy
+{
+    public double AplicarDescuento(double monto) => monto * 0.8;
+}
+
+public class DescuentoRegular : IDescuentoStrategy
+{
+    public double AplicarDescuento(double monto) => monto * 0.9;
+}
+
+public class SinDescuento : IDescuentoStrategy
+{
+    public double AplicarDescuento(double monto) => monto;
+}
+
+public class CalculadoraPrecio
+{
+    private readonly IDescuentoStrategy _estrategia;
+
+    public CalculadoraPrecio(IDescuentoStrategy estrategia)
+    {
+        _estrategia = estrategia;
+    }
+
+    public double Calcular(double monto) => _estrategia.AplicarDescuento(monto);
+}
+
+// Uso
+class Program
+{
+    static void Main()
+    {
+        var calculadora = new CalculadoraPrecio(new DescuentoVIP());
+        Console.WriteLine(calculadora.Calcular(1000)); // Imprime 800
+    }
+}
+
+```
+
+### Caso 3: Migración de un monolito a microservicios ⚡
+
+- **Problema:** el monolito en Java no podía escalar adecuadamente y los tiempos de respuesta eran altos.
+- **Refactorización aplicada:** se utilizó el patrón Strangler Fig, migrando módulos de forma gradual a microservicios.
+- **Resultado:** se logró una arquitectura moderna 🏗️, más flexible y preparada para la escalabilidad.
+
+
+## 3. Tabla Comparativa 📊
+La siguiente tabla compara los casos estudiados, mostrando los problemas encontrados en los sistemas legacy, las refactorizaciones aplicadas, los patrones de diseño utilizados y los resultados obtenidos. Permite visualizar de manera resumida cómo cada estrategia contribuye a mejorar la calidad, mantenibilidad y escalabilidad del software.
+
+| Caso | Problema              | Refactorización aplicada          | Patrón usado  | Resultado                                |
+| ---- | --------------------- | --------------------------------- | ------------- | ---------------------------------------- |
+| 1    | Código spaghetti      | Simplificación de accesos         | Facade        | Menor acoplamiento y mayor claridad      |
+| 2    | Sin pruebas unitarias | Inyección de dependencias + tests | Strategy      | Reducción de errores y más confiabilidad |
+| 3    | Monolito rígido       | Migración progresiva              | Strangler Fig | Arquitectura moderna y escalable         |
+
+## 4. Análisis Crítico 🧐
+La refactorización es más que un proceso técnico: es una estrategia de sostenibilidad del software.
+
+### Ventajas: ✅
+
+- **Reduce deuda técnica.**
+- **Facilita el mantenimiento y escalabilidad.**
+- **Permite aplicar pruebas automatizadas.**
+
+### Limitaciones: ⚠️
+
+- **Requiere inversión de tiempo y personal capacitado.**
+- **Puede ser difícil en sistemas críticos con poca documentación.**
+- **En los casos revisados, el uso de patrones como Facade, Strategy y Strangler Fig permitió transformar sistemas rígidos en arquitecturas más limpias y modernas.**
+
+## 5. Conclusiones 🏁
+
+Los sistemas legacy representan un reto, pero con una refactorización adecuada se pueden mantener competitivos.
+Los patrones de diseño son aliados esenciales para guiar la modernización de estos proyectos.
+Refactorizar no solo mejora la legibilidad, sino que establece una estrategia de evolución sostenible.
+
+
+
+
+
+
+
+
+
+
+
+
+
+