<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Geampiere Jaramillo on Medium]]></title>
        <description><![CDATA[Stories by Geampiere Jaramillo on Medium]]></description>
        <link>https://medium.com/@geampiere?source=rss-87946446efc8------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*UkoZrlVyGyD2Dh1F</url>
            <title>Stories by Geampiere Jaramillo on Medium</title>
            <link>https://medium.com/@geampiere?source=rss-87946446efc8------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 11:09:32 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@geampiere/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Patrones de Diseño en Java]]></title>
            <link>https://geampiere.medium.com/patrones-de-dise%C3%B1o-en-java-02bb0172af1c?source=rss-87946446efc8------2</link>
            <guid isPermaLink="false">https://medium.com/p/02bb0172af1c</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[backend-development]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[productivity]]></category>
            <dc:creator><![CDATA[Geampiere Jaramillo]]></dc:creator>
            <pubDate>Thu, 28 May 2026 15:02:08 GMT</pubDate>
            <atom:updated>2026-05-28T15:02:08.082Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JchoKv4RG3oIof4TF3CNdQ.png" /></figure><p>Los patrones de diseño son soluciones reutilizables a problemas comunes en el desarrollo de software. En Java, dominar estos patrones es fundamental para construir aplicaciones mantenibles, escalables y fáciles de extender.</p><p>En este blog aprenderás qué son los patrones de diseño, sus categorías principales y ejemplos prácticos aplicados en Java.</p><h3>¿Qué son los patrones de diseño?</h3><p>Los patrones de diseño son soluciones probadas que ayudan a resolver problemas recurrentes en el desarrollo de software.</p><p>No son código listo para copiar y pegar, sino guías o estructuras que permiten escribir software más limpio y mantenible.</p><h3>Beneficios principales</h3><ul><li>Código reutilizable</li><li>Bajo acoplamiento</li><li>Mayor mantenibilidad</li><li>Mejor organización</li><li>Escalabilidad</li><li>Comunicación más clara entre desarrolladores</li></ul><h3>Clasificación de los patrones de diseño</h3><p>Los patrones de diseño se dividen en tres grandes categorías:</p><pre>1. Creacionales<br>2. Estructurales<br>3. Comportamiento</pre><h3>1. Patrones Creacionales</h3><p>Los patrones creacionales se enfocan en la creación de objetos.</p><p>Su objetivo es abstraer y controlar cómo se instancian las clases.</p><h3>Singleton</h3><p>El patrón Singleton garantiza que exista una única instancia de una clase.</p><h3>Ejemplo en Java</h3><pre>public class DatabaseConnection {<br><br>    private static DatabaseConnection instance;<br><br>    private DatabaseConnection() {}<br><br>    public static DatabaseConnection getInstance() {<br>        if (instance == null) {<br>            instance = new DatabaseConnection();<br>        }<br>        return instance;<br>    }<br>}</pre><h3>Casos de uso</h3><ul><li>Configuraciones globales</li><li>Conexiones compartidas</li><li>Caché</li><li>Logging</li></ul><h3>Ventajas</h3><ul><li>Control total de la instancia</li><li>Menor consumo de memoria</li></ul><h3>Desventajas</h3><ul><li>Puede dificultar testing</li><li>Riesgo de alto acoplamiento</li></ul><h3>Factory Method</h3><p>El patrón Factory Method delega la creación de objetos a una fábrica.</p><h3>Ejemplo</h3><pre>interface Notification {<br>    void send();<br>}<br><br>class EmailNotification implements Notification {<br>    public void send() {<br>        System.out.println(&quot;Enviando email&quot;);<br>    }<br>}<br><br>class SmsNotification implements Notification {<br>    public void send() {<br>        System.out.println(&quot;Enviando SMS&quot;);<br>    }<br>}<br><br>class NotificationFactory {<br><br>    public static Notification create(String type) {<br>        if (type.equals(&quot;email&quot;)) {<br>            return new EmailNotification();<br>        }<br><br>        return new SmsNotification();<br>    }<br>}</pre><h3>Ventajas</h3><ul><li>Reduce acoplamiento</li><li>Facilita extensión</li><li>Mejora mantenibilidad</li></ul><h3>Casos de uso</h3><ul><li>APIs</li><li>Integraciones</li><li>Sistemas con múltiples implementaciones</li></ul><h3>Builder</h3><p>Builder permite construir objetos complejos paso a paso.</p><h3>Ejemplo</h3><pre>public class User {<br><br>    private String name;<br>    private String email;<br>    private int age;<br><br>    public static class Builder {<br><br>        private String name;<br>        private String email;<br>        private int age;<br><br>        public Builder name(String name) {<br>            this.name = name;<br>            return this;<br>        }<br><br>        public Builder email(String email) {<br>            this.email = email;<br>            return this;<br>        }<br><br>        public Builder age(int age) {<br>            this.age = age;<br>            return this;<br>        }<br><br>        public User build() {<br>            User user = new User();<br>            user.name = this.name;<br>            user.email = this.email;<br>            user.age = this.age;<br>            return user;<br>        }<br>    }<br>}</pre><h3>Ventajas</h3><ul><li>Objetos más legibles</li><li>Evita constructores gigantes</li><li>Facilita inmutabilidad</li></ul><h3>Muy usado en</h3><ul><li>Spring Boot</li><li>Lombok</li><li>APIs modernas</li></ul><h3>2. Patrones Estructurales</h3><p>Los patrones estructurales ayudan a organizar clases y objetos para formar estructuras más flexibles.</p><h3>Adapter</h3><p>Adapter permite que dos interfaces incompatibles trabajen juntas.</p><h3>Ejemplo</h3><pre>interface PaymentProcessor {<br>    void pay();<br>}<br><br>class PaypalService {<br>    public void makePayment() {<br>        System.out.println(&quot;Pago con PayPal&quot;);<br>    }<br>}<br><br>class PaypalAdapter implements PaymentProcessor {<br><br>    private PaypalService service;<br><br>    public PaypalAdapter(PaypalService service) {<br>        this.service = service;<br>    }<br><br>    @Override<br>    public void pay() {<br>        service.makePayment();<br>    }<br>}</pre><h3>Casos de uso</h3><ul><li>Integraciones externas</li><li>APIs legacy</li><li>Microservicios</li></ul><h3>Decorator</h3><p>Decorator agrega funcionalidades a un objeto dinámicamente.</p><h3>Ejemplo</h3><pre>interface Coffee {<br>    String description();<br>}<br><br>class BasicCoffee implements Coffee {<br>    public String description() {<br>        return &quot;Café básico&quot;;<br>    }<br>}<br><br>class MilkDecorator implements Coffee {<br><br>    private Coffee coffee;<br><br>    public MilkDecorator(Coffee coffee) {<br>        this.coffee = coffee;<br>    }<br><br>    public String description() {<br>        return coffee.description() + &quot; + leche&quot;;<br>    }<br>}</pre><h3>Ventajas</h3><ul><li>Flexible</li><li>Evita herencia excesiva</li><li>Fácil extensión</li></ul><h3>Facade</h3><p>Facade proporciona una interfaz simplificada para sistemas complejos.</p><h3>Ejemplo</h3><pre>class PaymentService {<br>    void processPayment() {}<br>}<br><br>class NotificationService {<br>    void sendEmail() {}<br>}<br><br>class OrderFacade {<br><br>    private PaymentService payment = new PaymentService();<br>    private NotificationService notification = new NotificationService();<br><br>    public void completeOrder() {<br>        payment.processPayment();<br>        notification.sendEmail();<br>    }<br>}</pre><h3>Casos de uso</h3><ul><li>Sistemas complejos</li><li>APIs empresariales</li><li>Microservicios</li></ul><h3>3. Patrones de Comportamiento</h3><p>Estos patrones se enfocan en la comunicación entre objetos.</p><h3>Observer</h3><p>Observer define una relación uno a muchos entre objetos.</p><p>Cuando un objeto cambia, los demás son notificados automáticamente.</p><h3>Ejemplo</h3><pre>interface Observer {<br>    void update(String message);<br>}<br><br>class UserObserver implements Observer {<br><br>    public void update(String message) {<br>        System.out.println(message);<br>    }<br>}</pre><h3>Casos de uso</h3><ul><li>Eventos</li><li>Notificaciones</li><li>Kafka</li><li>RabbitMQ</li></ul><h3>Strategy</h3><p>Strategy permite cambiar algoritmos dinámicamente.</p><h3>Ejemplo</h3><pre>interface PaymentStrategy {<br>    void pay();<br>}<br><br>class CreditCardPayment implements PaymentStrategy {<br>    public void pay() {<br>        System.out.println(&quot;Pago con tarjeta&quot;);<br>    }<br>}<br><br>class PaypalPayment implements PaymentStrategy {<br>    public void pay() {<br>        System.out.println(&quot;Pago con PayPal&quot;);<br>    }<br>}</pre><h3>Ventajas</h3><ul><li>Código flexible</li><li>Fácil extensión</li><li>Bajo acoplamiento</li></ul><h3>Command</h3><p>Command encapsula solicitudes como objetos.</p><h3>Ejemplo</h3><pre>interface Command {<br>    void execute();<br>}<br><br>class SaveCommand implements Command {<br><br>    public void execute() {<br>        System.out.println(&quot;Guardando información&quot;);<br>    }<br>}</pre><h3>Casos de uso</h3><ul><li>Colas de tareas</li><li>Sistemas de eventos</li><li>CQRS</li></ul><h3>Patrones más utilizados en Spring Boot</h3><p>Spring Boot utiliza muchos patrones internamente.</p><h3>Algunos ejemplos</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YGLaCzD0UxNhutJQGp-M7w.png" /></figure><h3>Buenas prácticas usando patrones</h3><h3>1. No abusar de los patrones</h3><p>No todo necesita un patrón de diseño.</p><h3>2. Priorizar simplicidad</h3><p>La mejor solución suele ser la más simple.</p><h3>3. Aplicar SOLID</h3><p>Los patrones funcionan mejor junto a principios SOLID.</p><h3>4. Pensar en mantenibilidad</h3><p>Los patrones deben ayudar al equipo.</p><h3>¿Qué patrones deberías aprender primero?</h3><p>Si estás empezando con Java, enfócate en:</p><ol><li>Singleton</li><li>Factory</li><li>Builder</li><li>Strategy</li><li>Observer</li></ol><p>Son los más utilizados en aplicaciones reales.</p><h3>Conclusión</h3><p>Los patrones de diseño son herramientas fundamentales para cualquier desarrollador Java.</p><p>Dominar estos patrones permite escribir aplicaciones más limpias, flexibles y fáciles de mantener.</p><p>Lo más importante no es memorizar patrones, sino entender cuándo realmente aportan valor.</p><p>Un buen desarrollador no utiliza patrones por moda, sino para resolver problemas reales de forma elegante y sostenible.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=02bb0172af1c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Arquitecturas en Java]]></title>
            <link>https://geampiere.medium.com/arquitecturas-en-java-76c24ed04964?source=rss-87946446efc8------2</link>
            <guid isPermaLink="false">https://medium.com/p/76c24ed04964</guid>
            <category><![CDATA[architecture]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[backend-development]]></category>
            <category><![CDATA[microservices]]></category>
            <dc:creator><![CDATA[Geampiere Jaramillo]]></dc:creator>
            <pubDate>Wed, 27 May 2026 15:37:12 GMT</pubDate>
            <atom:updated>2026-05-27T15:37:12.961Z</atom:updated>
            <content:encoded><![CDATA[<p>Java sigue siendo uno de los lenguajes más utilizados en el desarrollo empresarial gracias a su estabilidad, ecosistema maduro y capacidad para construir sistemas escalables. Sin embargo, elegir una buena arquitectura es igual de importante que elegir el lenguaje.</p><p>En este blog veremos las arquitecturas más utilizadas en Java, sus ventajas, desventajas y cuándo conviene utilizar cada una.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Vl8ptCb9q6jjgn-UJXkmyg.png" /></figure><h3>¿Qué es una arquitectura de software?</h3><p>La arquitectura de software define cómo se organiza una aplicación, cómo se comunican sus componentes y cómo se toman decisiones técnicas importantes.</p><p>Una buena arquitectura permite:</p><ul><li>Escalabilidad</li><li>Mantenibilidad</li><li>Seguridad</li><li>Facilidad de pruebas</li><li>Despliegues más simples</li><li>Separación de responsabilidades</li></ul><p>En el ecosistema Java existen múltiples estilos arquitectónicos dependiendo del tipo de proyecto.</p><h3>1. Arquitectura Monolítica</h3><p>La arquitectura monolítica es una de las más tradicionales en Java.</p><p>En este modelo toda la aplicación se desarrolla y despliega como una única unidad.</p><h3>Estructura típica</h3><pre>Aplicación Java<br> ├── Controllers<br> ├── Services<br> ├── Repositories<br> ├── Entities<br> └── Configurations</pre><h3>Tecnologías comunes</h3><ul><li>Spring Boot</li><li>Spring MVC</li><li>Hibernate</li><li>JPA</li><li>Maven</li><li>Gradle</li></ul><h3>Ventajas</h3><ul><li>Fácil de desarrollar al inicio</li><li>Menor complejidad operativa</li><li>Más sencillo para equipos pequeños</li><li>Despliegue único</li></ul><h3>Desventajas</h3><ul><li>Difícil de escalar grandes proyectos</li><li>Acoplamiento alto</li><li>Deploys más riesgosos</li><li>Compilaciones más lentas</li></ul><h3>¿Cuándo usarla?</h3><ul><li>MVPs</li><li>Startups</li><li>Sistemas internos pequeños</li><li>Equipos pequeños</li></ul><h3>2. Arquitectura en Capas (Layered Architecture)</h3><p>Es probablemente la arquitectura más usada en proyectos Java empresariales.</p><p>Divide la aplicación en capas bien definidas.</p><h3>Capas comunes</h3><pre>Presentation Layer<br>        ↓<br>Business Layer<br>        ↓<br>Persistence Layer<br>        ↓<br>Database</pre><h3>Ejemplo con Spring Boot</h3><pre>@RestController<br>@RequestMapping(&quot;/users&quot;)<br>public class UserController {<br><br>    private final UserService userService;<br><br>    public UserController(UserService userService) {<br>        this.userService = userService;<br>    }<br><br>    @GetMapping<br>    public List&lt;User&gt; getUsers() {<br>        return userService.findAll();<br>    }<br>}</pre><h3>Ventajas</h3><ul><li>Código organizado</li><li>Fácil mantenimiento</li><li>Separación clara de responsabilidades</li><li>Fácil de aprender</li></ul><h3>Desventajas</h3><ul><li>Dependencias entre capas</li><li>Puede generar lógica duplicada</li><li>Menos flexible en sistemas complejos</li></ul><h3>Casos de uso</h3><ul><li>Sistemas bancarios</li><li>ERPs</li><li>APIs empresariales</li><li>Backends tradicionales</li></ul><h3>3. Arquitectura Hexagonal (Ports and Adapters)</h3><p>La arquitectura hexagonal busca desacoplar la lógica de negocio de las tecnologías externas.</p><p>Fue propuesta por Alistair Cockburn.</p><h3>Idea principal</h3><p>La lógica de negocio debe ser independiente de:</p><ul><li>Bases de datos</li><li>Frameworks</li><li>APIs externas</li><li>UI</li><li>Mensajería</li></ul><h3>Estructura</h3><pre>Adapters<br>            ↓<br>Ports → Domain ← Ports<br>            ↑<br>         Adapters</pre><h3>Ejemplo simplificado</h3><h3>Puerto</h3><pre>public interface PaymentRepository {<br>    void save(Payment payment);<br>}</pre><h3>Dominio</h3><pre>public class PaymentService {<br><br>    private final PaymentRepository repository;<br><br>    public PaymentService(PaymentRepository repository) {<br>        this.repository = repository;<br>    }<br><br>    public void process(Payment payment) {<br>        repository.save(payment);<br>    }<br>}</pre><h3>Adaptador</h3><pre>@Repository<br>public class JpaPaymentRepository implements PaymentRepository {<br><br>    @Override<br>    public void save(Payment payment) {<br>        // implementación JPA<br>    }<br>}</pre><h3>Ventajas</h3><ul><li>Muy testeable</li><li>Bajo acoplamiento</li><li>Independiente del framework</li><li>Fácil migración tecnológica</li></ul><h3>Desventajas</h3><ul><li>Mayor complejidad inicial</li><li>Más abstracciones</li><li>Curva de aprendizaje más alta</li></ul><h3>¿Cuándo usarla?</h3><ul><li>Sistemas complejos</li><li>Microservicios</li><li>Dominios críticos</li><li>Aplicaciones financieras</li></ul><h3>4. Clean Architecture</h3><p>La Clean Architecture fue popularizada por Robert C. Martin (Uncle Bob).</p><p>Su objetivo es proteger el dominio de negocio.</p><h3>Principio fundamental</h3><p>Las dependencias siempre apuntan hacia el centro.</p><h3>Capas</h3><pre>Frameworks &amp; Drivers<br>Interface Adapters<br>Use Cases<br>Entities</pre><h3>Características</h3><ul><li>Independencia de frameworks</li><li>Independencia de la base de datos</li><li>Muy mantenible</li><li>Alta separación de responsabilidades</li></ul><h3>Ejemplo de Use Case</h3><pre>public class CreateUserUseCase {<br><br>    private final UserRepository repository;<br><br>    public CreateUserUseCase(UserRepository repository) {<br>        this.repository = repository;<br>    }<br><br>    public void execute(User user) {<br>        repository.save(user);<br>    }<br>}</pre><h3>Ventajas</h3><ul><li>Escalable</li><li>Fácil testing</li><li>Código mantenible</li><li>Excelente separación de responsabilidades</li></ul><h3>Desventajas</h3><ul><li>Mucha estructura</li><li>Overengineering en proyectos pequeños</li><li>Requiere experiencia</li></ul><h3>Ideal para</h3><ul><li>Grandes empresas</li><li>Sistemas críticos</li><li>Aplicaciones de larga duración</li><li>Equipos grandes</li></ul><h3>5. Arquitectura de Microservicios</h3><p>La arquitectura de microservicios divide un sistema en múltiples servicios pequeños e independientes.</p><p>Cada servicio:</p><ul><li>Tiene su propia lógica</li><li>Puede tener su propia base de datos</li><li>Se despliega independientemente</li><li>Escala independientemente</li></ul><h3>Ejemplo</h3><pre>Auth Service<br>User Service<br>Payment Service<br>Notification Service</pre><h3>Tecnologías comunes en Java</h3><ul><li>Spring Boot</li><li>Spring Cloud</li><li>Kafka</li><li>RabbitMQ</li><li>Docker</li><li>Kubernetes</li><li>Eureka</li><li>OpenFeign</li></ul><h3>Ventajas</h3><ul><li>Escalabilidad independiente</li><li>Despliegues independientes</li><li>Mejor resiliencia</li><li>Equipos autónomos</li></ul><h3>Desventajas</h3><ul><li>Complejidad distribuida</li><li>Observabilidad más difícil</li><li>Manejo de fallos más complejo</li><li>Mayor costo operativo</li></ul><h3>¿Cuándo usar microservicios?</h3><ul><li>Sistemas grandes</li><li>Muchas integraciones</li><li>Alto tráfico</li><li>Equipos múltiples</li><li>Escalabilidad avanzada</li></ul><h3>6. Event-Driven Architecture</h3><p>En esta arquitectura los servicios se comunican mediante eventos.</p><h3>Ejemplo</h3><pre>Usuario realiza pago<br>        ↓<br>Payment Service publica evento<br>        ↓<br>Notification Service consume evento<br>        ↓<br>Email enviado</pre><h3>Tecnologías comunes</h3><ul><li>Apache Kafka</li><li>RabbitMQ</li><li>AWS SQS</li><li>AWS SNS</li></ul><h3>Ventajas</h3><ul><li>Sistemas desacoplados</li><li>Escalabilidad alta</li><li>Excelente rendimiento</li><li>Comunicación asíncrona</li></ul><h3>Desventajas</h3><ul><li>Debugging complejo</li><li>Eventual consistency</li><li>Requiere observabilidad avanzada</li></ul><h3>Casos de uso</h3><ul><li>Fintech</li><li>E-commerce</li><li>Sistemas en tiempo real</li><li>Notificaciones</li></ul><h3>7. Arquitectura Serverless en Java</h3><p>Java también puede ejecutarse en arquitecturas serverless.</p><p>Aquí el proveedor cloud administra la infraestructura.</p><h3>Servicios populares</h3><ul><li>AWS Lambda</li><li>Azure Functions</li><li>Google Cloud Functions</li></ul><h3>Ventajas</h3><ul><li>Escalado automático</li><li>Menor administración</li><li>Pago por uso</li><li>Ideal para eventos</li></ul><h3>Desventajas</h3><ul><li>Cold starts</li><li>Limitaciones de ejecución</li><li>Complejidad en debugging</li></ul><h3>Casos ideales</h3><ul><li>Procesamiento de eventos</li><li>Automatizaciones</li><li>APIs pequeñas</li><li>Tareas programadas</li></ul><h3>Comparación de Arquitecturas</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6lUCZX6LEBWfBao4vgfosg.png" /></figure><h3>¿Qué arquitectura debería elegir?</h3><p>No existe una arquitectura perfecta para todos los escenarios.</p><p>La mejor arquitectura depende de:</p><ul><li>Tamaño del proyecto</li><li>Cantidad de usuarios</li><li>Presupuesto</li><li>Tiempo de desarrollo</li><li>Experiencia del equipo</li><li>Necesidades de escalabilidad</li></ul><h3>Recomendación práctica</h3><h3>Si estás empezando</h3><p>Usa:</p><ul><li>Monolito</li><li>Arquitectura en capas</li><li>Spring Boot</li></ul><h3>Si el sistema crece</h3><p>Migra gradualmente hacia:</p><ul><li>Hexagonal</li><li>Clean Architecture</li><li>Microservicios</li></ul><h3>Si manejas alta concurrencia</h3><p>Combina:</p><ul><li>Microservicios</li><li>Kafka</li><li>Event-driven</li><li>Kubernetes</li></ul><h3>Buenas prácticas en arquitecturas Java</h3><h3>1. Aplicar SOLID</h3><p>Los principios SOLID ayudan a crear sistemas mantenibles.</p><h3>2. Usar inyección de dependencias</h3><p>Spring Framework facilita el desacoplamiento.</p><h3>3. Separar dominio de infraestructura</h3><p>Evita mezclar lógica de negocio con frameworks.</p><h3>4. Implementar observabilidad</h3><p>Usa:</p><ul><li>Logs estructurados</li><li>Prometheus</li><li>Grafana</li><li>OpenTelemetry</li></ul><h3>5. Automatizar despliegues</h3><p>Implementa CI/CD usando:</p><ul><li>GitHub Actions</li><li>Jenkins</li><li>GitLab CI</li></ul><h3>Tecnologías recomendadas para aprender</h3><h3>Backend</h3><ul><li>Spring Boot</li><li>Spring Security</li><li>Spring Cloud</li><li>Hibernate</li><li>JPA</li><li>Quarkus</li></ul><h3>Mensajería</h3><ul><li>Kafka</li><li>RabbitMQ</li></ul><h3>DevOps</h3><ul><li>Docker</li><li>Kubernetes</li><li>Terraform</li><li>AWS</li></ul><h3>Testing</h3><ul><li>JUnit</li><li>Mockito</li><li>Testcontainers</li></ul><h3>Observabilidad</h3><ul><li>Grafana</li><li>Prometheus</li><li>OpenTelemetry</li></ul><h3>Conclusión</h3><p>Java ofrece un ecosistema extremadamente poderoso para construir aplicaciones modernas y escalables.</p><p>Elegir la arquitectura correcta puede marcar la diferencia entre un sistema fácil de mantener y uno difícil de evolucionar.</p><p>Para proyectos pequeños, un monolito bien estructurado suele ser suficiente. Para sistemas empresariales complejos, arquitecturas como Hexagonal, Clean Architecture y Microservicios ofrecen ventajas importantes en escalabilidad y mantenibilidad.</p><p>Lo más importante no es seguir tendencias, sino entender las necesidades reales del negocio y construir soluciones sostenibles.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=76c24ed04964" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[React vs Next.js: Dos herramientas, un propósito diferente]]></title>
            <link>https://geampiere.medium.com/react-vs-next-js-dos-herramientas-un-prop%C3%B3sito-diferente-1a5d72ca0099?source=rss-87946446efc8------2</link>
            <guid isPermaLink="false">https://medium.com/p/1a5d72ca0099</guid>
            <category><![CDATA[architecture]]></category>
            <category><![CDATA[nextjs]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Geampiere Jaramillo]]></dc:creator>
            <pubDate>Sat, 16 May 2026 18:58:08 GMT</pubDate>
            <atom:updated>2026-05-16T18:58:08.919Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bUBwepanjpBeAcxCbPsnTw.png" /></figure><blockquote><strong><em>Durante mucho tiempo usé React para todo. Funcionaba. Hasta que dejó de ser suficiente.</em></strong></blockquote><p>Había proyectos donde React resolvía exactamente lo que necesitaba. Interfaces dinámicas, estado bien manejado, componentes reutilizables. El flujo era cómodo y lo conocía bien.</p><p>Pero llegaron proyectos donde los mismos patrones empezaron a generar fricción. El SEO era un dolor constante. Los tiempos de carga no eran los esperados. La configuración antes de escribir código útil se sentía cada vez más larga.</p><p>Cuando empecé a trabajar con Next.js en el día a día, muchas de esas fricciones simplemente desaparecieron. No porque Next.js sea mejor — sino porque responde preguntas que React nunca se propuso responder.</p><h3>¿Qué es cada uno?</h3><h3>React</h3><p>React es una <strong>biblioteca de JavaScript</strong> para construir interfaces de usuario. No es un framework completo — es solo la capa de vista. Te da los componentes, el sistema de estado y el renderizado. Todo lo demás — routing, fetching de datos, optimización, estructura de carpetas — lo decides tú.</p><p>Esa flexibilidad es su mayor fortaleza. Y también su mayor trampa.</p><h3>Next.js</h3><p>Next.js es un <strong>framework construido sobre React</strong>. Toma React como base y le agrega todo lo que le falta: routing basado en archivos, renderizado en el servidor, generación estática, optimización de imágenes, API routes, y mucho más.</p><p>No reemplaza a React — lo extiende. Todo lo que sabes de React funciona en Next.js.</p><h3>La diferencia que más se siente en el día a día</h3><h3>Routing</h3><p>Con React puro necesitas instalar y configurar React Router manualmente:</p><pre>// React — configuración manual de rutas<br>import { BrowserRouter, Routes, Route } from &#39;react-router-dom&#39;;</pre><pre>function App() {<br>  return (<br>    &lt;BrowserRouter&gt;<br>      &lt;Routes&gt;<br>        &lt;Route path=&quot;/&quot; element={&lt;Home /&gt;} /&gt;<br>        &lt;Route path=&quot;/about&quot; element={&lt;About /&gt;} /&gt;<br>        &lt;Route path=&quot;/blog/:id&quot; element={&lt;BlogPost /&gt;} /&gt;<br>      &lt;/Routes&gt;<br>    &lt;/BrowserRouter&gt;<br>  );<br>}</pre><p>Con Next.js simplemente creas archivos en la carpeta app/ o pages/ y las rutas existen automáticamente:</p><pre>app/<br>├── page.tsx          →  /<br>├── about/<br>│   └── page.tsx      →  /about<br>└── blog/<br>    └── [id]/<br>        └── page.tsx  →  /blog/:id</pre><p>Sin configuración. Sin imports adicionales. El sistema de archivos es el router.</p><h3>Renderizado</h3><p>Esta es la diferencia más importante para aplicaciones reales.</p><p><strong>React (CSR — Client Side Rendering):</strong> El servidor envía un HTML casi vacío. El navegador descarga el JavaScript, lo ejecuta, y recién entonces renderiza la interfaz. El usuario ve una pantalla en blanco mientras tanto.</p><pre>// React — los datos se cargan en el cliente<br>function BlogPost({ id }) {<br>  const [post, setPost] = useState(null);</pre><pre>  useEffect(() =&gt; {<br>    fetch(`/api/posts/${id}`)<br>      .then(res =&gt; res.json())<br>      .then(data =&gt; setPost(data));<br>  }, [id]);</pre><pre>  if (!post) return &lt;div&gt;Cargando...&lt;/div&gt;;<br>  return &lt;article&gt;{post.content}&lt;/article&gt;;<br>}</pre><p><strong>Next.js (SSR / SSG):</strong> El servidor genera el HTML completo antes de enviarlo al navegador. El usuario ve contenido real desde el primer momento.</p><pre>// Next.js — los datos se obtienen en el servidor<br>async function BlogPost({ params }: { params: { id: string } }) {<br>  const post = await fetch(`https://api.example.com/posts/${params.id}`);<br>  const data = await post.json();</pre><pre>  return &lt;article&gt;{data.content}&lt;/article&gt;;<br>}</pre><p>Sin estado de carga. Sin pantalla en blanco. Sin useEffect para datos que deberían estar ahí desde el inicio.</p><h3>SEO</h3><p>Este punto es crítico para cualquier proyecto que necesite ser encontrado en Google.</p><p>Con React puro, los motores de búsqueda reciben un HTML vacío y deben esperar a que JavaScript se ejecute para ver el contenido. Muchos crawlers no esperan — simplemente indexan una página vacía.</p><p>Con Next.js, el HTML llega completo al crawler desde el primer request. El contenido está ahí, listo para ser indexado.</p><pre>// Next.js — metadata para SEO directamente en el componente<br>export const metadata = {<br>  title: &#39;Mi artículo | Blog&#39;,<br>  description: &#39;Una descripción clara para los motores de búsqueda&#39;,<br>  openGraph: {<br>    title: &#39;Mi artículo&#39;,<br>    images: [&#39;/og-image.jpg&#39;],<br>  },<br>};</pre><h3>Comparación directa</h3><p>Criterio React Next.js Tipo Biblioteca UI Framework full-stack Routing Manual (React Router) Automático (file-based) Renderizado Solo cliente (CSR) CSR, SSR, SSG, ISR SEO Difícil sin configuración extra Nativo y optimizado API Routes No incluido Incluido Optimización de imágenes Manual Automática con &lt;Image&gt; Curva de aprendizaje Baja Media (requiere conocer React primero) Flexibilidad de estructura Total Opinionated Ideal para SPAs, dashboards internos Webs públicas, e-commerce, blogs, apps</p><h3>Los modos de renderizado de Next.js</h3><p>Una de las razones por las que Next.js destaca es que no te obliga a elegir un solo modo de renderizado. Puedes mezclarlos dentro del mismo proyecto según lo que necesita cada página.</p><p><strong>SSG — Static Site Generation</strong> El HTML se genera en tiempo de build. Ideal para contenido que no cambia frecuentemente: blogs, landings, documentación.</p><pre>// Esta página se genera una sola vez en el build<br>async function BlogIndex() {<br>  const posts = await getPosts();<br>  return &lt;PostList posts={posts} /&gt;;<br>}</pre><p><strong>SSR — Server Side Rendering</strong> El HTML se genera en cada request. Ideal para contenido personalizado o que cambia constantemente.</p><pre>// Esta página se regenera en cada visita<br>async function Dashboard() {<br>  const data = await getUserDashboard();<br>  return &lt;DashboardView data={data} /&gt;;<br>}</pre><p><strong>ISR — Incremental Static Regeneration</strong> La mezcla perfecta: se genera estáticamente pero se revalida cada cierto tiempo.</p><pre>// Se regenera cada 60 segundos en segundo plano<br>export const revalidate = 60;</pre><pre>async function ProductPage({ params }) {<br>  const product = await getProduct(params.id);<br>  return &lt;ProductView product={product} /&gt;;<br>}</pre><h3>¿Cuándo usar React puro?</h3><p>React sin Next.js sigue siendo la elección correcta en varios escenarios:</p><ul><li><strong>Dashboards internos</strong> que no necesitan SEO y tienen usuarios autenticados</li><li><strong>Aplicaciones de una sola página</strong> donde el contenido es completamente dinámico</li><li><strong>Proyectos donde ya existe un backend separado</strong> y solo necesitas la capa de UI</li><li><strong>Equipos que quieren control total</strong> sobre cada decisión de arquitectura</li><li><strong>Prototipos rápidos</strong> donde la configuración mínima es prioritaria</li></ul><h3>¿Cuándo usar Next.js?</h3><p>Next.js es la mejor opción cuando:</p><ul><li>El proyecto necesita <strong>SEO real</strong> — blogs, e-commerce, páginas de marketing</li><li>Quieres <strong>mejor rendimiento</strong> desde el primer render</li><li>Necesitas <strong>API routes</strong> sin configurar un servidor separado</li><li>El proyecto incluye tanto páginas públicas como áreas autenticadas</li><li>Quieres <strong>optimización de imágenes, fuentes y scripts</strong> sin trabajo manual</li><li>Estás construyendo algo que va a crecer y necesitas una base sólida</li></ul><h3>Lo que nadie te dice</h3><p>Next.js tiene una curva de aprendizaje real. El App Router, los Server Components, la diferencia entre &#39;use client&#39; y &#39;use server&#39;, la hidratación, los layouts anidados — son conceptos que toman tiempo entender bien.</p><p>Si no tienes una base sólida de React, ir directo a Next.js puede ser confuso. El orden importa:</p><pre>1. Entiende React → componentes, props, estado, hooks<br>2. Construye algo real con React puro<br>3. Topa con sus limitaciones (SEO, performance, routing)<br>4. Entonces Next.js va a tener sentido completo</pre><p>No es que uno sea mejor que el otro en absoluto. Es que <strong>Next.js responde problemas que React puro no resuelve por diseño</strong>.</p><h3>Conclusión</h3><p>React y Next.js no son rivales. Next.js es React con superpoderes específicos: renderizado en el servidor, routing automático, SEO nativo, y una arquitectura pensada para producción desde el día uno.</p><p>Si estás construyendo una SPA interna o un prototipo, React puro es suficiente. Si estás construyendo algo público que necesita cargarse rápido, posicionarse en buscadores y escalar — Next.js es la decisión correcta.</p><p>La pregunta no es cuál es mejor. La pregunta es <strong>qué problema estás resolviendo</strong>.</p><blockquote>“React te da las piezas. Next.js te da el tablero donde encajan.”</blockquote><p><em>¿Estás usando React, Next.js o ambos en tus proyectos? Me interesa leer tu experiencia en los comentarios.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1a5d72ca0099" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Vibe Coding: Qué es y cómo está cambiando el desarrollo]]></title>
            <link>https://geampiere.medium.com/vibe-coding-qu%C3%A9-es-y-c%C3%B3mo-est%C3%A1-cambiando-el-desarrollo-8e89fcc662ff?source=rss-87946446efc8------2</link>
            <guid isPermaLink="false">https://medium.com/p/8e89fcc662ff</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[open-code]]></category>
            <category><![CDATA[desarrollo-web]]></category>
            <category><![CDATA[vibe-coding]]></category>
            <dc:creator><![CDATA[Geampiere Jaramillo]]></dc:creator>
            <pubDate>Fri, 15 May 2026 20:24:19 GMT</pubDate>
            <atom:updated>2026-05-15T20:24:19.234Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KSSuREqRLTGz3ztdaUG54Q.png" /></figure><blockquote><strong><em>Antes de adoptarlo en mi día a día, pensé que era solo otra tendencia. Me equivoqué.</em></strong></blockquote><p>Llevaba años escribiendo código de la forma tradicional: editor abierto, documentación en otra pestaña, Stack Overflow en otra. Funcionaba, pero era lento. Cada característica nueva significaba horas de configuración, búsquedas, prueba y error.</p><p>Entonces empecé a experimentar con Vibe Coding y mi flujo de trabajo cambió por completo.</p><p>Andrej Karpathy – uno de los fundadores de OpenAI – fue quien puso nombre a esto con un tweet que generó debate en toda la comunidad tecnológica:</p><blockquote>“Existe un nuevo tipo de programación que yo llamo programación de vibraciones, en la que te dejas llevar por completo por las vibraciones, adoptas las exponenciales y te olvidas incluso de que el código existe.”Al principio lo leí con escepticismo. Hoy es parte de cómo trabajo todos los días.</blockquote><h3>¿Qué es el Vibe Coding?</h3><blockquote>El <strong>Vibe Coding</strong> es una forma de programar donde describe lo que quieres en lenguaje natural — como si le hablaras a una persona — y una IA genera el código por ti.</blockquote><p>No escribes for loops. No memorizas la sintaxis. No debuggeas por horas un punto y coma faltante.</p><p>Tú dices: <em>“Quiero una página web que muestre una lista de tareas, que pueda agregar y eliminar elementos, y que se vea moderna”.</em></p><p>Y la IA lo construye.</p><p>Herramientas como <strong>Cursor</strong> , <strong>Claude Code</strong> , <strong>Higgsfield</strong> u <strong>OpenCode</strong> hacen esto posible hoy mismo.</p><h3>¿Por qué es relevante si apenas estás empezando?</h3><p>Tradicionalmente, aprender a programar significaba:</p><ol><li>Aprender sintaxis de un lenguaje</li><li>Entender estructuras de datos y algoritmos.</li><li>Meses o años de práctica antes de construir algo “real”</li></ol><p>El Vibe Coding cambia ese orden. Ahora puedes:</p><ol><li><strong>Construir algo real desde el día uno.</strong></li><li>Aprender la teoría mientras ves el código generado</li><li>Iterar rápido y ver resultados inmediatos</li></ol><p>No reemplace aprender a programar, pero sí baja la barrera de entrada a casi cero.</p><h3>¿Cómo funciona en la práctica?</h3><p>Imagina que quieres construir una aplicación sencilla para registrar tus gastos personales. Así se vería el proceso con Vibe Coding:</p><h3>Sin Vibe Coding (forma tradicional)</h3><pre>Semana 1-2:  Aprender  HTML  y  CSS  básico <br>Semana 3-4:  Aprender  JavaScript <br>Semana 5-6:  Aprender  a  manipular  el  DOM <br>Semana 7:    Finalmente  construir  algo  funcional</pre><h3>Codificación Vibe de Con</h3><pre>Día 1 : Describe tu idea a la IA <br>        → &quot;Crea una app de gastos con categorías, <br>           totales y un diseño limpio&quot;<br>        <br>         La IA genera el código completo. <br>        Tú lo revisas , preguntas qué hace cada parte ,<br>         pides cambios , aprendes en el proceso.</pre><h3>Las herramientas que forman parte del ecosistema.</h3><p>Hay varias herramientas que se usan hoy en día para hacer Vibe Coding orientado a páginas web y aplicaciones. Cada una resuelve el problema desde un ángulo distinto.</p><h3>1. Cursor</h3><p>Un editor de código con IA integrado. Funciona sobre la base de VS Code, por lo que el entorno resulta familiar. Permite interactuar con el código en lenguaje natural — hacer preguntas, pedir cambios, entender partes específicas — sin salir del editor.</p><h3>2. Código Claude</h3><p>Un agente que opera desde la terminal. Lee el contexto del proyecto completo — archivos, dependencias, estructura — y genera o modifica código en consecuencia. Se usa principalmente en proyectos donde la coherencia entre distintas partes del código es importante.</p><h3>3. Higgsfield</h3><p>Orientado a la generación de interfaces visuales. A partir de una descripción, produzca componentes y diseños listos para integrar. Se usa bastante en la parte de diseño y maquetado de páginas web y apps.</p><h3>4. OpenCode</h3><p>Un agente de código abierto que corre en terminal. A diferencia de las opciones anteriores, es configurable y permite conectarse con distintos modelos de IA. Es una alternativa para quienes prefieren más control sobre las herramientas que usan.</p><h3>Lo que el Vibe Coding NO es</h3><p>Aquí viene la parte honesta que muchos artículos omiten.</p><p><strong>No es magia.</strong> La IA comete errores. A veces genera código que no funciona, que tiene errores, o que no hace exactamente lo que pediste. Necesitas aprender a identificar esos errores.</p><p><strong>No reemplace lo básico.</strong> Cuanto más sepas de programación, mejores instrucciones darás a la IA y mejor podrás evaluar lo que genera. Los mejores usuarios de Vibe Coding son programadores con experiencia, no personas que nunca han tocado código.</p><p><strong>No sirve para todo.</strong> Sistemas complejos, código de alta seguridad, optimizaciones de rendimiento — ahí la IA tiene límites claros. <em>La analogía perfecta: el Vibe Coding es como tener un GPS.</em></p><p><em>Te lleva del punto A al B sin que sepas cada calle. Pero si el GPS falla, si hay un desvío inesperado, necesitas entender aunque sea lo básico de orientación para no perderte.</em></p><h3>El flujo de trabajo ideal para un principiante. Si estás empezando, te recomiendo este flujo:</h3><p><strong>1. Describe con claridad lo que quieres</strong></p><p>Mientras más específicos sean, mejor será el resultado.</p><p>❌ <em>“Hazme una aplicación”</em> ✅ <em>“Crea una aplicación web con React que tenga una lista de tareas. Cada tarea debe tener una casilla de verificación para marcarla como completada y un botón para eliminarla. Usa un diseño minimalista con fondo blanco.”</em></p><p><strong>2. Lee el código que genera la IA</strong></p><p>No copias y pegues sin leer. Pregúntale a la IA que te explique cada parte. Ese es el momento de aprendizaje real.</p><p><strong>3. Pide cambios incrementales</strong></p><p>No trates de construir todo de un golpe. Ve parte por parte.</p><p><strong>4. Rompe cosas a propósito</strong></p><p>Modifica el código generado, experimenta, y qué pasa. Los errores son tu mejor maestro.</p><p><strong>5. Aprende la teoría en paralelo</strong></p><p>Usa plataformas como freeCodeCamp, The Odin Project o roadmap.sh para entender los conceptos detrás del código que estás viendo.</p><h3>¿El Vibe Coding va a reemplazar a los programadores?</h3><p>La respuesta corta: <strong>no</strong> .</p><p>La respuesta larga: va a cambiar radicalmente qué tipo de programadores tienen más valor.</p><p>Los desarrolladores que sepan usar IA como una herramienta de amplificación — que puedan dar contexto preciso, evaluar el resultado, detectar errores y tomar decisiones arquitectónicas — van a ser más productivos que nunca.</p><p>Los que ignoran estas herramientas van a quedar en desventaja.</p><p>Para alguien que recién empieza, el mensaje es claro: <strong>aprende a programar Y aprende a usar IA</strong> . No son caminos opuestos, son complementarios.</p><h3>Por dónde empezar hoy mismo</h3><p>Si quieres dar tu primer paso con Vibe Coding esta semana, aquí tienes un plan concreto:</p><ol><li><strong>Elige una de las herramientas mencionadas</strong> e instálala o ábrela en el navegador</li><li><strong>Describe una aplicación simple</strong> que te gustaría tener: una lista de tareas, un contador de hábitos, una calculadora de propinas.</li><li><strong>Lee el código generado</strong> y pídele a la IA que te explique las partes que no entiendas</li><li><strong>Pide un cambio</strong> : cambia el color, agrega una función nueva, modifica el texto</li><li><strong>Repite</strong> con algo un poco más complejo cada vez</li></ol><p>El objetivo no es entender todo desde el inicio. El objetivo es <strong>empezar a construir</strong> y aprender en el proceso.</p><h3>Conclusión</h3><p>El Vibe Coding no es el futuro, <strong>es el presente</strong> . Y para alguien que está comenzando en programación, representa una oportunidad única: puedes construir cosas reales mientras aprendes, ver resultados inmediatos, y mantener la motivación que tan frecuentemente muere en el tutorial número tres.</p><p>Úsalo como trampolín, no como muleta. Construye, pregunta, aprende, rompe cosas. Esa curiosidad es lo que separa a un desarrollador que crece de uno que se estanca.</p><blockquote>&quot;La mejor forma de aprender a programar siempre fue construyendo cosas. El Vibe Coding solo hace que ese primer paso sea más pequeño&quot;.</blockquote><p><em>¿Ya probaste alguna herramienta de Vibe Coding? ¿Cuál fue tu experiencia? Cuéntame en los comentarios.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8e89fcc662ff" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Monolito Modular vs Microservicios en NestJS]]></title>
            <link>https://geampiere.medium.com/monolito-modular-vs-microservicios-en-nestjs-88072aa7e848?source=rss-87946446efc8------2</link>
            <guid isPermaLink="false">https://medium.com/p/88072aa7e848</guid>
            <category><![CDATA[nestjs]]></category>
            <category><![CDATA[architecture]]></category>
            <category><![CDATA[microsoft-azure]]></category>
            <category><![CDATA[backend]]></category>
            <dc:creator><![CDATA[Geampiere Jaramillo]]></dc:creator>
            <pubDate>Fri, 15 May 2026 03:14:51 GMT</pubDate>
            <atom:updated>2026-05-15T03:14:51.568Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2JLWQMtxXmZZ7FAdyPx05A.png" /></figure><blockquote><strong><em>NestJS fue diseñado deliberadamente para que puedas empezar simple y crecer sin reescribir.</em></strong><em> Esta es la historia de cómo aprovecharlo.</em></blockquote><p>Cuando empiezas un nuevo proyecto backend, uno de los primeros debates que aparece es: <em>¿monolito o microservicios?</em></p><h3>¿De qué estamos hablando exactamente?</h3><p>Antes de comparar, alineemos definiciones:</p><ul><li><strong>Monolito modular</strong>: una sola aplicación desplegada como una unidad, pero con el código organizado en módulos con fronteras claras. Un módulo por dominio de negocio.</li><li><strong>Microservicios</strong>: múltiples aplicaciones independientes que se comunican por la red (HTTP, mensajería, gRPC). Cada servicio se despliega, escala y actualiza de forma autónoma.</li></ul><p>La confusión más común es pensar que “monolito” significa “código desorganizado”. No tiene nada que ver. Un monolito puede estar perfectamente estructurado — y en NestJS, eso es la norma, no la excepción.</p><h3>Monolito modular con NestJS</h3><p>NestJS fue hecho a medida para el monolito modular. Su sistema de módulos te fuerza a pensar en términos de dominios desde el primer día.</p><h3>Estructura típica</h3><pre>src/ <br>├── app. module .ts <br>├── users/ <br>│ ├── users. module .ts <br>│ ├── users.controller.ts <br>│ ├── users.service.ts <br>│ └── entities/user.entity.ts <br>├── orders/ <br>│ ├── orders. module .ts <br>│ ├── orders.controller.ts <br>│ ├── orders.service.ts <br>│ └── entities/ order .entity.ts <br>└── payments/ <br>    ├── payments. módulo .ts <br>    ├── payments.service.ts <br>    └── dto/payment.dto.ts</pre><p>Cada dominio vive en su propio módulo con sus controladores, servicios y entidades. La comunicación entre módulos se hace mediante inyección de dependencias — sin pasar por la red.</p><h3>Comunicación entre módulos</h3><pre>// orders.module.ts — importa UsersModule para usar su servicio <br>@Module ({ <br>  imports : [UsersModule], <br>  controllers : [OrdersController], <br>  providers : [OrdersService], <br>}) <br>export class OrdersModule {}</pre><pre>// orders.service.ts <br>@Injectable() <br>export class OrdersService { <br>  constructor( <br>    private readonly usersService: UsersService, <br>  ) {}</pre><pre>  async createOrder(userId: string, items: OrderItem[]) {<br>    // Llamada directa en memoria — sin latencia de red<br>    const user = await this.usersService.findOne(userId);<br>    if (!user) throw new NotFoundException(&#39;Usuario no encontrado&#39;);<br>    // ... lógica de negocio<br>  }<br>}</pre><p>La llamada a usersService.findOne() es una función en memoria. Sin serialización, sin latencia, sin puntos de fallo de red.</p><h3>Pros y contras</h3><p><strong>✅ Ventajas:</strong></p><ul><li>Desarrollo inicial rápido, un solo repositorio</li><li>Depuración local simple — un proceso, un log</li><li>Sin latencia entre módulos</li><li>Transacciones de base de datos nativas (sin Saga)</li><li>Un solo pipeline de CI/CD</li></ul><p><strong>⚠️ Desventajas:</strong></p><ul><li>Escala como unidad entera (no puedes escalar solo el módulo de pagos)</li><li>Builds y deploys más lentos a medida que crece</li><li>Una falla no contenida puede tumbar todo el proceso</li></ul><h3>Microservicios con NestJS</h3><p>NestJS tiene soporte de primera clase para microservicios a través de @nestjs/microservices, que soporta TCP, Redis, RabbitMQ, Kafka, gRPC, NATS y más.</p><h3>Arquitectura general</h3><pre>┌─────────────────┐<br>                  │   API Gateway   │<br>                  └────────┬────────┘<br>           ┌───────────────┼───────────────┐<br>           ▼               ▼               ▼<br>   ┌──────────────┐ ┌──────────────┐ ┌──────────────┐<br>   │users-service │ │orders-service│ │payments-svc  │<br>   │   :3001      │ │   :3002      │ │   :3003      │<br>   └──────────────┘ └──────────────┘ └──────────────┘<br>           │               │               │<br>           └───────────────┴───────────────┘<br>                           │<br>                  ┌────────▼────────┐<br>                  │  RabbitMQ/Kafka │<br>                  └─────────────────┘</pre><h3>Configurar un microservicio</h3><pre>// users-service/main.ts<br>import { NestFactory } from &#39;@nestjs/core&#39;;<br>import { Transport, MicroserviceOptions } from &#39;@nestjs/microservices&#39;;</pre><pre>async function bootstrap() {<br>  const app = await NestFactory.createMicroservice&lt;MicroserviceOptions&gt;(<br>    AppModule,<br>    {<br>      transport: Transport.RMQ,<br>      options: {<br>        urls: [&#39;amqp://localhost:5672&#39;],<br>        queue: &#39;users_queue&#39;,<br>        queueOptions: { durable: false },<br>      },<br>    },<br>  );<br>  await app.listen();<br>}<br>bootstrap();</pre><h3>Comunicación entre servicios</h3><pre>// orders-service: llama al users-service vía MessagePattern<br>@Injectable()<br>export class OrdersService implements OnModuleInit {<br>  private usersClient: ClientProxy;</pre><pre>  onModuleInit() {<br>    this.usersClient = this.clientProxy.get(&#39;USERS_SERVICE&#39;);<br>  }</pre><pre>  async createOrder(userId: string) {<br>    // Llamada asíncrona al microservicio de usuarios<br>    const user = await firstValueFrom(<br>      this.usersClient.send({ cmd: &#39;get_user&#39; }, { userId }),<br>    );<br>    // ... continuar con el pedido<br>  }<br>}</pre><pre>// users-service: expone el MessagePattern<br>@Controller()<br>export class UsersController {<br>  @MessagePattern({ cmd: &#39;get_user&#39; })<br>  getUser(data: { userId: string }) {<br>    return this.usersService.findOne(data.userId);<br>  }<br>}</pre><h3>Pros y contras</h3><p><strong>✅ Ventajas:</strong></p><ul><li>Escalado independiente por servicio</li><li>Despliegue independiente — el equipo de pagos despliega sin coordinar con usuarios</li><li>Aislamiento de fallos</li><li>Equipos autónomos y paralelos</li></ul><p><strong>⚠️ Desventajas:</strong></p><ul><li>Complejidad operacional alta (necesitas orquestación, service discovery, observabilidad distribuida)</li><li>Latencia de red entre servicios</li><li>Transacciones distribuidas complejas — necesitas el patrón Saga</li><li>Overhead de infraestructura: Kubernetes, brokers de mensajería, tracing</li></ul><h3>Comparación cara a cara</h3><p>Criterio Monolito Modular Microservicios Velocidad de desarrollo inicial ✅ Alta ❌ Baja Escalado independiente ❌ Todo o nada ✅ Por servicio Latencia interna ✅ Cero (en memoria) ❌ Red + serialización Transacciones ACID ✅ Nativas ❌ Saga / 2PC necesario Testing local ✅ Simple ⚠️ Requiere orquestación Curva de aprendizaje ✅ Baja ❌ Alta Fault isolation ❌ Un crash afecta todo ✅ Fallas contenidas Observabilidad ✅ Un solo log stream ❌ Requiere distributed tracing Ideal para equipos pequeños ✅ Sí ❌ No recomendado</p><h3>¿Cuándo usar cada uno?</h3><h3>Elige monolito modular si…</h3><ul><li>El equipo tiene menos de 10 ingenieros</li><li>El dominio de negocio aún está evolucionando (no conoces bien las fronteras)</li><li>Necesitas lanzar rápido — MVP, startup, validación de mercado</li><li>No tienes un equipo de DevOps/SRE dedicado</li><li>Los módulos comparten muchos datos entre sí</li><li>Los costos de infraestructura son una restricción real</li></ul><h3>Elige microservicios si…</h3><ul><li>El sistema lleva tiempo en producción y las fronteras de dominio están muy claras</li><li>Equipos distintos necesitan desplegar sin coordinar entre ellos</li><li>Algunos componentes tienen demandas de escalado radicalmente distintas</li><li>Tienes requisitos de compliance que requieren aislamiento de datos</li><li>Tienes DevOps/SRE dedicado con experiencia en sistemas distribuidos</li></ul><p><strong><em>Antipatrón clásico — Distributed Monolith:</em></strong><em> empezar con microservicios sin conocer bien las fronteras del dominio resulta en servicios que se llaman síncronamente entre sí para cada operación, transacciones distribuidas que no pueden fallar, y despliegues que deben coordinarse igual que en un monolito. Lo peor de ambos mundos. Martin Fowler lo documenta extensamente.</em></p><h3>Estrategia de migración: del monolito al microservicio</h3><p>La mayor ventaja de NestJS es que <strong>la misma estructura modular que usas en el monolito es la base para extraer microservicios</strong>. La estrategia más segura es el patrón <em>Strangler Fig</em>: extraes módulos de forma incremental sin detener el sistema.</p><h3>Paso 1 — Empieza con el monolito bien modularizado</h3><pre>// app.module.ts<br>@Module({<br>  imports: [<br>    UsersModule,<br>    OrdersModule,<br>    PaymentsModule,<br>  ],<br>})<br>export class AppModule {}</pre><h3>Paso 2 — Abstrae la comunicación con interfaces</h3><p>La clave es que los consumidores de un servicio no sepan si están hablando con una implementación local o remota.</p><pre>// Interfaz agnóstica al transporte<br>export interface IUsersService {<br>  findOne(id: string): Promise&lt;User&gt;;<br>  create(dto: CreateUserDto): Promise&lt;User&gt;;<br>}</pre><pre>// Implementación local (monolito)<br>@Injectable()<br>export class UsersService implements IUsersService { ... }</pre><pre>// Implementación remota (microservicio) — mismo contrato<br>@Injectable()<br>export class UsersClientService implements IUsersService {<br>  findOne(id: string) {<br>    return firstValueFrom(<br>      this.client.send({ cmd: &#39;get_user&#39; }, { id }),<br>    );<br>  }<br>}</pre><h3>Paso 3 — Swap en el módulo sin tocar a los consumidores</h3><pre>@Module({<br>  providers: [<br>    {<br>      provide: &#39;IUsersService&#39;,<br>      // Monolito:  useClass: UsersService<br>      useClass: UsersClientService, // ← ya es microservicio<br>    },<br>  ],<br>})<br>export class OrdersModule {}</pre><p>OrdersService sigue inyectando IUsersService sin cambiar una sola línea. Solo cambias el proveedor en el módulo.</p><p>Con este patrón puedes extraer servicios de forma gradual, validar en producción, y revertir si algo sale mal — sin una migración big bang.</p><h3>Conclusión</h3><p>No existe una arquitectura universalmente superior. La pregunta correcta no es <em>“¿microservicios o monolito?”</em> sino <em>“¿qué arquitectura resuelve los problemas que tengo hoy?”</em></p><p>El <strong>monolito modular</strong> es la elección correcta para la mayoría de proyectos en sus etapas tempranas. Permite moverse rápido, mantener coherencia y reducir la carga cognitiva del equipo.</p><p>Los <strong>microservicios</strong> son una solución a problemas organizacionales y de escala específicos — no una meta en sí misma. Introduce esa complejidad solo cuando el dolor de no tenerla supere el costo de operarla.</p><p>Y NestJS, con su arquitectura modular, soporte nativo para múltiples transportes y el patrón de abstracción mostrado aquí, te da el lujo de <strong>comenzar simple y evolucionar sin reescribir</strong>. Esa es su mayor ventaja.</p><blockquote><strong><em>Regla de oro:</em></strong><em> </em>“Empieza con el monolito modular más limpio que puedas construir. Tus futuros microservicios ya están definidos en tus módulos.”</blockquote><p><em>¿Tienes experiencia migrando de monolito a microservicios en N</em></p><p><em>estJS? Me interesa leer tu historia en los comentarios.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=88072aa7e848" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[SQL vs NoSQL: ¿Cuál elegir para tu próximo proyecto?]]></title>
            <link>https://geampiere.medium.com/sql-vs-nosql-cu%C3%A1l-elegir-para-tu-pr%C3%B3ximo-proyecto-01ad6cef047e?source=rss-87946446efc8------2</link>
            <guid isPermaLink="false">https://medium.com/p/01ad6cef047e</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[database]]></category>
            <category><![CDATA[productivity]]></category>
            <dc:creator><![CDATA[Geampiere Jaramillo]]></dc:creator>
            <pubDate>Thu, 16 Apr 2026 14:57:34 GMT</pubDate>
            <atom:updated>2026-04-16T14:57:34.017Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/768/1*njLBKRr9RaS74xjumQ3MOQ.png" /></figure><p>Cuando se trata de bases de datos, dos de las opciones más populares son <strong>SQL</strong> (Structured Query Language) y <strong>NoSQL</strong> (Not Only SQL). Ambas tienen ventajas y desventajas, y la elección de una sobre otra depende de las necesidades específicas de tu aplicación. En este blog, exploraremos las diferencias clave entre las bases de datos SQL y NoSQL, sus casos de uso y cómo elegir la más adecuada para tu proyecto.</p><h3>¿Qué es SQL?</h3><p><strong>SQL</strong> (Structured Query Language) se refiere a bases de datos <strong>relacionales</strong> que organizan los datos en <strong>tablas</strong> relacionadas entre sí. Las bases de datos SQL son altamente estructuradas, lo que significa que cada dato debe seguir un esquema predefinido con relaciones claras entre las tablas. Las bases de datos SQL son conocidas por su capacidad para manejar <strong>transacciones</strong> complejas y <strong>consultas avanzadas</strong>.</p><h4>Ejemplos de bases de datos SQL:</h4><ul><li><strong>MySQL</strong></li><li><strong>PostgreSQL</strong></li><li><strong>SQL Server</strong></li><li><strong>SQLite</strong></li></ul><h4>Características principales de SQL:</h4><ol><li><strong>Modelo Relacional</strong>: Los datos están organizados en <strong>tablas</strong> con filas y columnas. Cada tabla puede tener <strong>relaciones</strong> con otras tablas, y los datos pueden ser recuperados utilizando <strong>consultas SQL</strong>.</li><li><strong>Esquema Fijo</strong>: El esquema de la base de datos debe definirse antes de insertar los datos, y las tablas deben seguir una estructura predecible.</li><li><strong>ACID</strong>: SQL ofrece <strong>transacciones ACID</strong> (Atomicidad, Consistencia, Aislamiento, Durabilidad), lo que significa que las operaciones en la base de datos son <strong>seguras y fiables</strong>.</li><li><strong>Consultas Complejas</strong>: Las bases de datos SQL permiten realizar consultas complejas utilizando <strong>joins</strong>, <strong>subconsultas</strong>, <strong>agregaciones</strong> y otras operaciones.</li></ol><h4>Casos de uso de SQL:</h4><ul><li><strong>Aplicaciones empresariales</strong> que requieren <strong>alta consistencia</strong> y <strong>transacciones</strong>.</li><li><strong>Sistemas bancarios</strong> donde la integridad de los datos es crucial.</li><li><strong>Aplicaciones de gestión</strong> que necesitan relaciones complejas entre los datos (por ejemplo, sistemas de gestión de inventarios, ERPs).</li><li><strong>Aplicaciones que requieren cumplimiento de normativas</strong> (como GDPR, HIPAA), que necesitan mantener la integridad y el control de los datos.</li></ul><h3>¿Qué es NoSQL?</h3><p><strong>NoSQL</strong> (Not Only SQL) se refiere a bases de datos <strong>no relacionales</strong> que ofrecen una mayor flexibilidad en el almacenamiento y la consulta de datos. A diferencia de las bases de datos SQL, NoSQL no utiliza un esquema rígido ni relaciones entre tablas. En lugar de eso, se enfocan en almacenar datos en <strong>documentos</strong>, <strong>pares clave-valor</strong>, <strong>columnas</strong> o <strong>grafos</strong>.</p><h4>Ejemplos de bases de datos NoSQL:</h4><ul><li><strong>MongoDB</strong> (orientada a documentos)</li><li><strong>Redis</strong> (clave-valor)</li><li><strong>Cassandra</strong> (columnar)</li><li><strong>Neo4j</strong> (gráfica)</li></ul><h4>Características principales de NoSQL:</h4><ol><li><strong>Modelo de Datos Flexible</strong>: NoSQL permite almacenar datos <strong>no estructurados</strong> o <strong>semi-estructurados</strong>. Los documentos pueden tener diferentes campos sin seguir un esquema fijo.</li><li><strong>Escalabilidad Horizontal</strong>: Las bases de datos NoSQL están diseñadas para <strong>escalar horizontalmente</strong>, lo que significa que pueden distribuirse en múltiples servidores para manejar grandes volúmenes de datos.</li><li><strong>Alta Disponibilidad</strong>: NoSQL a menudo emplea técnicas de <strong>replicación</strong> y <strong>particionamiento</strong> para garantizar que los datos estén disponibles incluso cuando algunos nodos fallan.</li><li><strong>Consistencia Eventual</strong>: En lugar de garantizar una consistencia fuerte como en las bases de datos SQL, NoSQL suele optar por una <strong>consistencia eventual</strong>, lo que significa que los datos pueden no estar completamente sincronizados en todos los nodos de la base de datos en un momento dado.</li></ol><h4>Casos de uso de NoSQL:</h4><ul><li><strong>Aplicaciones web en tiempo real</strong>, como <strong>mensajería instantánea</strong> o <strong>notificaciones push</strong>.</li><li><strong>Big Data</strong> y <strong>análisis en tiempo real</strong> de grandes volúmenes de datos no estructurados (por ejemplo, logs, sensores IoT).</li><li><strong>Redes sociales</strong> y <strong>plataformas de contenido</strong> que requieren <strong>escalabilidad</strong> y flexibilidad en el almacenamiento de datos.</li><li><strong>Sistemas distribuidos</strong> y <strong>sistemas de alta disponibilidad</strong> que necesitan una rápida recuperación ante fallos.</li></ul><h3>Diferencias clave entre SQL y NoSQL</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YT_F2kCY7EnsnfVed3xX6Q.png" /></figure><h3>¿Cuándo elegir SQL?</h3><p>Deberías elegir una base de datos <strong>SQL</strong> cuando tu aplicación:</p><ul><li><strong>Necesite integridad de datos y transacciones</strong> ACID (por ejemplo, sistemas financieros o sistemas bancarios).</li><li><strong>Tenga una estructura de datos bien definida</strong>, con relaciones claras entre las entidades (usuarios, productos, pedidos).</li><li><strong>Requiera consultas complejas</strong> que involucren varias tablas con relaciones (joins, subconsultas, etc.).</li><li><strong>No necesite escalabilidad horizontal masiva</strong>, sino más bien una escalabilidad vertical (aumentando los recursos de un solo servidor).</li></ul><h3>¿Cuándo elegir NoSQL?</h3><p>Deberías elegir una base de datos <strong>NoSQL</strong> cuando tu aplicación:</p><ul><li><strong>Maneje grandes volúmenes de datos</strong> no estructurados o semiestructurados, como logs, datos de sensores IoT o contenido multimedia.</li><li><strong>Requiera una alta escalabilidad horizontal</strong>, ya que las bases de datos NoSQL están diseñadas para ser distribuidas y manejar grandes cantidades de tráfico y datos.</li><li><strong>Necesite alta disponibilidad</strong> y recuperación rápida ante fallos (ideal para aplicaciones distribuidas y con grandes cantidades de usuarios simultáneos).</li><li><strong>Tenga datos cambiantes</strong> y no requiera un esquema rígido o una estructura predefinida.</li></ul><h3>Conclusión</h3><p>La elección entre <strong>SQL</strong> y <strong>NoSQL</strong> depende en gran medida de las necesidades específicas de tu aplicación. Si tu proyecto requiere transacciones complejas, integridad de datos y relaciones bien definidas, <strong>SQL</strong> es la mejor opción. Por otro lado, si tu aplicación necesita manejar grandes volúmenes de datos con un esquema flexible y requiere escalabilidad horizontal, <strong>NoSQL</strong> puede ser más adecuado.</p><p>No hay una respuesta única para todos los casos; incluso algunas aplicaciones pueden beneficiarse de un enfoque <strong>híbrido</strong>, utilizando ambas tecnologías según los requisitos de cada parte del sistema. Por ejemplo, podrías usar una base de datos <strong>SQL</strong> para manejar las transacciones financieras y una base de datos <strong>NoSQL</strong> para almacenar logs o datos en tiempo real.</p><p>Al comprender las fortalezas y limitaciones de ambas opciones, podrás tomar la decisión más informada sobre qué tipo de base de datos utilizar para tu proyecto.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=01ad6cef047e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Principios SOLID en NestJS]]></title>
            <link>https://geampiere.medium.com/principios-solid-en-nestjs-a419ed3a1088?source=rss-87946446efc8------2</link>
            <guid isPermaLink="false">https://medium.com/p/a419ed3a1088</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[tips]]></category>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[backend]]></category>
            <category><![CDATA[principles]]></category>
            <dc:creator><![CDATA[Geampiere Jaramillo]]></dc:creator>
            <pubDate>Wed, 28 May 2025 15:12:12 GMT</pubDate>
            <atom:updated>2025-05-28T15:12:12.370Z</atom:updated>
            <content:encoded><![CDATA[<p>Cuando trabajamos en proyectos de software, mantener el código organizado y escalable es esencial. <strong>SOLID</strong> es un conjunto de principios que ayudan a mejorar la calidad del código. En este blog, exploramos cómo aplicar <strong>SOLID</strong> en <strong>NestJS</strong> para escribir código limpio, fácil de mantener y expandir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MJVdjTh5DQo-BPmPf9uEFg.png" /></figure><h3>1. Single Responsibility Principle (SRP): Responsabilidad Única</h3><p>Cada clase debe tener <strong>una sola responsabilidad</strong>. Esto hace que el código sea más fácil de entender y cambiar.</p><p><strong>Ejemplo en NestJS:</strong></p><pre>@Injectable()<br>export class UserService {<br>  constructor(private readonly userRepository: UserRepository) {}<br><br>createUser(data: CreateUserDto) {<br>    this.userRepository.save(data); // Responsabilidad: Manejo de datos de usuario<br>  }<br>}</pre><p>Aquí, UserService se enfoca solo en la lógica relacionada con usuarios, sin mezclar responsabilidades como validaciones o reglas de negocio.</p><h3>2. Open/Closed Principle (OCP): Abierto/Cerrado</h3><p>Las clases deben estar <strong>abiertas a la extensión</strong>, pero <strong>cerradas para su modificación</strong>. Puedes añadir nuevas funcionalidades sin alterar el código existente.</p><p><strong>Ejemplo en NestJS:</strong></p><pre>interface PaymentStrategy {<br>  processPayment(amount: number): void;<br>}<br><br>class CreditCardPayment implements PaymentStrategy {<br>  processPayment(amount: number) {<br>    console.log(`Processing $${amount} via Credit Card`);<br>  }<br>}<br><br>@Injectable()<br>export class PaymentService {<br>  constructor(private paymentStrategy: PaymentStrategy) {}<br><br>executePayment(amount: number) {<br>    this.paymentStrategy.processPayment(amount);<br>  }<br>}</pre><p>Aquí, si agregas un nuevo método de pago, solo extiendes PaymentStrategy, sin tocar la clase PaymentService.</p><h3>3. Liskov Substitution Principle (LSP): Sustitución de Liskov</h3><p>Las clases derivadas deben ser <strong>sustituibles</strong> por sus clases base sin romper la funcionalidad.</p><p><strong>Ejemplo en NestJS:</strong></p><pre>class Animal {<br>  makeSound() {}<br>}<br><br>class Dog extends Animal {<br>  makeSound() {<br>    console.log(&#39;Bark&#39;);<br>  }<br>}</pre><p>Puedes usar un Dog donde esperas un Animal sin problemas. Las clases derivadas deben seguir el comportamiento esperado.</p><h3>4. Interface Segregation Principle (ISP): Segregación de Interfaces</h3><p>No obligues a los clientes a implementar interfaces que no usan. Divide las interfaces grandes en interfaces más pequeñas.</p><p><strong>Ejemplo en NestJS:</strong></p><pre>interface PaymentProcessor {<br>  processPayment(amount: number): void;<br>}<br><br>class CreditCardProcessor implements PaymentProcessor {<br>  processPayment(amount: number) {<br>    console.log(`Processing $${amount} via Credit Card`);<br>  }<br>}<br><br>class PaypalProcessor implements PaymentProcessor {<br>  processPayment(amount: number) {<br>    console.log(`Processing $${amount} via PayPal`);<br>  }<br>}</pre><p>Aquí, las interfaces son específicas y solo contienen los métodos que realmente se usan.</p><h3>5. Dependency Inversion Principle (DIP): Inversión de Dependencias</h3><p>Los módulos de <strong>alto nivel</strong> no deben depender de los de <strong>bajo nivel</strong>. Ambos deben depender de <strong>abstracciones</strong>.</p><p><strong>Ejemplo en NestJS:</strong></p><pre>interface Logger {<br>  log(message: string): void;<br>}<br><br>@Injectable()<br>export class MyService {<br>  constructor(private readonly logger: Logger) {}<br><br>executeAction() {<br>    this.logger.log(&#39;Action executed&#39;);<br>  }<br>}</pre><p>En este caso, MyService depende de la abstracción Logger y no de una implementación concreta, lo que hace que sea más fácil cambiar el tipo de logger sin afectar el servicio.</p><h3>Conclusión</h3><p>Aplicar los principios <strong>SOLID</strong> en <strong>NestJS</strong> te ayuda a mantener tu código limpio, flexible y fácil de mantener. Si sigues estos principios, tu aplicación será más fácil de escalar, probar y modificar, lo que te permitirá adaptarte rápidamente a los cambios sin introducir errores.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a419ed3a1088" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Patrones de Diseño en NestJS]]></title>
            <link>https://geampiere.medium.com/patrones-de-dise%C3%B1o-en-nestjs-c0bcdc56bc56?source=rss-87946446efc8------2</link>
            <guid isPermaLink="false">https://medium.com/p/c0bcdc56bc56</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[nestjs]]></category>
            <category><![CDATA[design-patterns]]></category>
            <category><![CDATA[backend]]></category>
            <dc:creator><![CDATA[Geampiere Jaramillo]]></dc:creator>
            <pubDate>Tue, 27 May 2025 15:41:52 GMT</pubDate>
            <atom:updated>2025-05-27T15:41:52.075Z</atom:updated>
            <content:encoded><![CDATA[<p>Cuando desarrollamos aplicaciones backend en <strong>NestJS</strong>, uno de los mayores desafíos es crear una arquitectura escalable, fácil de mantener y extensible. Una forma de abordar estos problemas es mediante el uso de <strong>patrones de diseño</strong>, que nos permiten crear soluciones más flexibles, desacopladas y reutilizables.</p><p>Exploraremos los patrones de diseño más comunes que puedes implementar en tus aplicaciones NestJS, como la <strong>inyección de dependencias</strong>, <strong>singleton</strong>, <strong>decoradores</strong>, <strong>estrategias de pago</strong>, entre otros. Aprenderás cómo aplicar estos patrones para mejorar la calidad de tu código y facilitar su mantenimiento a largo plazo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CTKQIbn-uXX-agk_z59QVw.png" /></figure><h4>1. Inyección de Dependencias (Dependency Injection — DI)</h4><p>La <strong>inyección de dependencias</strong> es uno de los pilares de NestJS. Este patrón permite que las clases dependan de otros objetos sin tener que crearlos explícitamente, lo que facilita el desacoplamiento y la reutilización de componentes.</p><p><strong>¿Cómo funciona en NestJS?</strong> NestJS maneja la inyección de dependencias mediante el contenedor de dependencias de <strong>TypeScript</strong>. Cada vez que inyectas un servicio en otro mediante el constructor de la clase, NestJS se encarga de instanciar la clase y pasarla como dependencia.</p><p><strong>Ejemplo</strong>:</p><pre>import { Injectable } from &#39;@nestjs/common&#39;;<br>import { Controller, Get } from &#39;@nestjs/common&#39;;<br>import { MyService } from &#39;./my.service&#39;;<br><br>@Injectable()<br>export class MyService {<br>  getHello(): string {<br>    return &#39;Hello, World!&#39;;<br>  }<br>}<br><br><br>@Controller()<br>export class MyController {<br>  constructor(private readonly myService: MyService) {}<br><br>@Get()<br>  getHello(): string {<br>    return this.myService.getHello();<br>  }<br>}</pre><p><strong>Ventajas</strong>:</p><ul><li><strong>Desacoplamiento</strong>: No es necesario que una clase conozca las implementaciones de sus dependencias.</li><li><strong>Escalabilidad</strong>: Fácil de escalar y mantener cuando agregamos nuevas dependencias.</li><li><strong>Pruebas unitarias</strong>: Permite la sustitución de servicios reales por mock services durante las pruebas.</li></ul><h4>2. Singleton</h4><p>El patrón <strong>Singleton</strong> asegura que una clase tenga una única instancia a lo largo de toda la aplicación. En NestJS, esto se aplica automáticamente cuando se utilizan los servicios.</p><p><strong>Ejemplo</strong>:</p><pre>import { Injectable } from &#39;@nestjs/common&#39;;<br><br>@Injectable()<br>export class MySingletonService {<br>  private counter = 0;<br><br>increment() {<br>    this.counter++;<br>    return this.counter;<br>  }<br><br>getCounter() {<br>    return this.counter;<br>  }<br>}</pre><p><strong>Ventajas</strong>:</p><ul><li><strong>Consistencia</strong>: Mantiene el estado compartido de una clase a lo largo de toda la aplicación.</li><li><strong>Control de recursos</strong>: Ideal para gestionar recursos que no deben ser duplicados, como conexiones a bases de datos.</li></ul><h4>3. Decorator Pattern</h4><p>En NestJS, los <strong>decoradores</strong> son fundamentales. Este patrón se utiliza para agregar funcionalidades a las clases y métodos sin alterar su estructura original. NestJS hace uso intensivo de decoradores para definir rutas, interceptores, validaciones, etc.</p><p><strong>Ejemplo</strong>:</p><pre>import { Controller, Get, Param } from &#39;@nestjs/common&#39;;<br><br>@Controller(&#39;users&#39;)<br>export class UserController {<br>  @Get(&#39;:id&#39;)<br>  getUser(@Param(&#39;id&#39;) id: string): string {<br>    return `User ID: ${id}`;<br>  }<br>}</pre><p><strong>Ventajas</strong>:</p><ul><li><strong>Legibilidad</strong>: Los decoradores hacen que el código sea más legible y organizado.</li><li><strong>Flexibilidad</strong>: Permite agregar funcionalidad de manera flexible y modular sin modificar el código base.</li></ul><h4>4. Strategy Pattern</h4><p>El patrón <strong>Strategy</strong> define una familia de algoritmos, los encapsula y los hace intercambiables. En NestJS, este patrón puede usarse para cambiar la lógica de un servicio dependiendo de diferentes estrategias.</p><p><strong>Ejemplo</strong>:</p><pre>interface PaymentStrategy {<br>  pay(amount: number): string;<br>}<br><br>@Injectable()<br>export class CreditCardPayment implements PaymentStrategy {<br>  pay(amount: number): string {<br>    return `Paid ${amount} using Credit Card`;<br>  }<br>}<br><br>@Injectable()<br>export class PayPalPayment implements PaymentStrategy {<br>  pay(amount: number): string {<br>    return `Paid ${amount} using PayPal`;<br>  }<br>}<br><br>@Injectable()<br>export class PaymentService {<br>  constructor(private readonly paymentStrategy: PaymentStrategy) {}<br><br>  processPayment(amount: number): string {<br>    return this.paymentStrategy.pay(amount);<br>  }<br>}</pre><p><strong>Ventajas</strong>:</p><ul><li><strong>Flexibilidad</strong>: Permite cambiar el comportamiento del sistema sin modificar su estructura.</li><li><strong>Extensibilidad</strong>: Se pueden agregar nuevas estrategias fácilmente sin afectar el código existente.</li></ul><h4>5. Observer Pattern</h4><p>El patrón <strong>Observer</strong> es útil cuando varios objetos necesitan ser notificados cuando el estado de otro objeto cambia. En NestJS, esto se puede lograr usando eventos y listeners.</p><p><strong>Ejemplo</strong>:</p><pre>import { Injectable } from &#39;@nestjs/common&#39;;<br>import { EventEmitter } from &#39;events&#39;;<br><br>@Injectable()<br>export class MyService {<br>  private eventEmitter = new EventEmitter();<br><br>constructor() {<br>    this.eventEmitter.on(&#39;userCreated&#39;, (user) =&gt; {<br>      console.log(&#39;User Created:&#39;, user);<br>    });<br>  }<br><br>createUser(user: any) {<br>    // Lógica de creación del usuario<br>    this.eventEmitter.emit(&#39;userCreated&#39;, user);<br>  }<br>}</pre><p><strong>Ventajas</strong>:</p><ul><li><strong>Desacoplamiento</strong>: Los observadores pueden reaccionar a los eventos sin necesidad de conocer la lógica interna del sujeto.</li><li><strong>Escalabilidad</strong>: Facilita agregar nuevas funcionalidades mediante la suscripción a eventos.</li></ul><h4>6. Command Pattern</h4><p>El patrón <strong>Command</strong> encapsula una solicitud como un objeto, lo que permite parametrizar los clientes con diferentes solicitudes. En NestJS, este patrón puede ser útil para crear comandos que gestionen procesos complejos.</p><p><strong>Ejemplo</strong>:</p><pre>class CreateUserCommand {<br>  constructor(public readonly username: string, public readonly email: string) {}<br>}<br><br>@Injectable()<br>export class UserService {<br>  executeCreateUserCommand(command: CreateUserCommand): void {<br>    // Lógica para crear un usuario<br>    console.log(`Creating user with username: ${command.username} and email: ${command.email}`);<br>  }<br>}</pre><p><strong>Ventajas</strong>:</p><ul><li><strong>Desacoplamiento</strong>: Separa la solicitud de la ejecución, lo que permite un mayor control sobre las acciones.</li><li><strong>Reusabilidad</strong>: Los comandos pueden ser reutilizados en diferentes partes de la aplicación.</li></ul><h3>Conclusión</h3><p>Los <strong>patrones de diseño</strong> son una herramienta poderosa para crear aplicaciones backend escalables y fáciles de mantener. En <strong>NestJS</strong>, puedes aprovechar estos patrones para estructurar tu código de manera modular, desacoplada y eficiente. Al aplicar estos patrones, no solo mejorarás la calidad de tu código, sino que también facilitarás el trabajo en equipo, las pruebas y el mantenimiento a largo plazo.</p><p>La clave está en saber cuándo y cómo aplicar cada patrón en función de las necesidades de tu proyecto. Experimenta con estos patrones y observa cómo mejoran la arquitectura de tu aplicación NestJS.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c0bcdc56bc56" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Operadores y Métodos para Manipular Arreglos en JavaScript]]></title>
            <link>https://geampiere.medium.com/operadores-y-m%C3%A9todos-para-manipular-arreglos-en-javascript-fa11c1c74ffe?source=rss-87946446efc8------2</link>
            <guid isPermaLink="false">https://medium.com/p/fa11c1c74ffe</guid>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[web-development]]></category>
            <dc:creator><![CDATA[Geampiere Jaramillo]]></dc:creator>
            <pubDate>Tue, 13 May 2025 15:28:49 GMT</pubDate>
            <atom:updated>2025-05-13T15:28:49.912Z</atom:updated>
            <content:encoded><![CDATA[<p>Cuando trabajamos con JavaScript, ya sea en el frontend con frameworks como React o en el backend con NestJS, una de las estructuras de datos más comunes son los <strong>arreglos (array)</strong>. Los arreglos nos permiten almacenar colecciones de datos y ofrecen una amplia gama de operadores y métodos para manipularlos de forma eficiente.</p><p>Veremos los principales <strong>operadores y métodos que puedes usar con arrays</strong> para transformar, filtrar, combinar y analizar información.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7543rBMDYVWiR3U7DiP7XA.png" /></figure><h3>📌 ¿Qué es un Arreglo?</h3><p>Un arreglo en JavaScript es una colección ordenada de elementos. Puede contener cualquier tipo de dato: números, strings, objetos, incluso otros arrays.</p><pre>const numeros = [1, 2, 3, 4, 5];<br>const mezcla = [1, &#39;texto&#39;, true, null, [6, 7]];</pre><h3>🧩 Operadores Útiles para Arreglos</h3><h3>1. Spread Operator (...)</h3><p>Permite clonar o combinar arreglos de forma muy legible.</p><pre>const a = [1, 2];<br>const b = [3, 4];<br>const combinado = [...a, ...b]; // [1, 2, 3, 4]</pre><h3>2. Destructuring</h3><p>Extrae elementos individuales de un array fácilmente.</p><pre>const [primero, segundo] = [10, 20, 30]; // primero = 10, segundo = 20</pre><h3>🔄 Métodos Comunes para Manipular Arreglos</h3><h3>🔹 Métodos de Mutación (modifican el arreglo original)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/944/1*eSQAtUiCRV5s7nRqBRGHQg.png" /></figure><pre>const frutas = [&#39;manzana&#39;, &#39;banana&#39;];<br>frutas.push(&#39;naranja&#39;); // [&#39;manzana&#39;, &#39;banana&#39;, &#39;naranja&#39;]<br>frutas.splice(1, 1, &#39;pera&#39;); // [&#39;manzana&#39;, &#39;pera&#39;, &#39;naranja&#39;]</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VqfTfd8HPBAOJieen_XR1Q.png" /></figure><pre>const numeros = [1, 2, 3, 4, 5];<br><br>const dobles = numeros.map(n =&gt; n * 2); // [2, 4, 6, 8, 10]<br>const pares = numeros.filter(n =&gt; n % 2 === 0); // [2, 4]<br>const suma = numeros.reduce((acc, n) =&gt; acc + n, 0); // 15</pre><h3>🔹 Métodos de Iteración y Transformación</h3><p>MétodoUso principalforEach()Ejecuta una función por cada elemento.map()Transforma los elementos y retorna un nuevo array.filter()Retorna elementos que cumplen una condición.reduce()Reduce el array a un solo valor.find()Retorna el primer elemento que cumple la condición.some()¿Algún elemento cumple la condición?every()¿Todos los elementos cumplen la condición?</p><pre>const numeros = [1, 2, 3, 4, 5];<br><br>const dobles = numeros.map(n =&gt; n * 2); // [2, 4, 6, 8, 10]<br>const pares = numeros.filter(n =&gt; n % 2 === 0); // [2, 4]<br>const suma = numeros.reduce((acc, n) =&gt; acc + n, 0); // 15</pre><h3>🔹 Métodos de Búsqueda</h3><pre>const letras = [&#39;a&#39;, &#39;b&#39;, &#39;c&#39;];<br>letras.includes(&#39;b&#39;);  // true<br>letras.indexOf(&#39;c&#39;);   // 2</pre><h3>🔹 Métodos de Conversión</h3><pre>const palabras = [&#39;hola&#39;, &#39;mundo&#39;];<br>palabras.join(&#39; &#39;);  // &#39;hola mundo&#39;</pre><h3>🧠 Tip: Métodos No Destructivos vs. Destructivos</h3><ul><li><strong>No destructivos</strong>: map(), filter(), slice(), concat(), etc.</li><li><strong>Destructivos</strong>: push(), pop(), splice(), sort(), etc.</li></ul><p>Prefiere métodos no destructivos si deseas mantener la inmutabilidad (algo clave en programación funcional y frameworks modernos).</p><h3>🧪 Bonus: Métodos Avanzados</h3><p>map() y flatMap()</p><pre>const anidado = [1, [2, 3], [4, 5]];<br>anidado.flat(); // [1, 2, 3, 4, 5]<br><br>const duplicados = [1, 2, 3].flatMap(n =&gt; [n, n]); // [1, 1, 2, 2, 3, 3]</pre><h3>🚀 Conclusión</h3><p>Manipular arreglos de forma efectiva es una habilidad esencial para cualquier desarrollador JavaScript. Ya sea que estés creando una API con NestJS o manipulando datos en el frontend, dominar estos operadores y métodos te permitirá escribir código más claro, funcional y eficiente.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fa11c1c74ffe" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Vinculación de Métodos en NestJS: Qué Es y Cuándo Usarla]]></title>
            <link>https://geampiere.medium.com/vinculaci%C3%B3n-de-m%C3%A9todos-en-nestjs-qu%C3%A9-es-y-cu%C3%A1ndo-usarla-09228e30a592?source=rss-87946446efc8------2</link>
            <guid isPermaLink="false">https://medium.com/p/09228e30a592</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[backend]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[nodejs]]></category>
            <dc:creator><![CDATA[Geampiere Jaramillo]]></dc:creator>
            <pubDate>Thu, 08 May 2025 15:03:37 GMT</pubDate>
            <atom:updated>2025-05-08T15:03:37.565Z</atom:updated>
            <content:encoded><![CDATA[<p>En el desarrollo con <strong>NestJS</strong>, una plataforma Node.js orientada a arquitectura modular y basada en clases, uno de los conceptos que puede causar confusión a los desarrolladores es la <strong>vinculación de métodos</strong> (method binding). Este blog explica qué es, cuándo se necesita, y cómo manejarla correctamente.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*q5aTLKD6UGC2-fXnJltPKA.png" /></figure><h3>¿Qué es la Vinculación de Métodos?</h3><p>En JavaScript y TypeScript, el valor de this dentro de un método puede cambiar dependiendo de cómo y dónde se invoque ese método. La <strong>vinculación de métodos</strong> se refiere a asegurar que el this dentro del método siempre apunte a la instancia correcta de la clase, especialmente cuando ese método se pasa como callback.</p><h3>Problema Clásico: Callback con setInterval</h3><pre>@Injectable()<br>export class MyService {<br>  private count = 0;<br><br>increment() {<br>    this.count++;<br>    console.log(&#39;Count:&#39;, this.count);<br>  }<br><br>start() {<br>    setInterval(this.increment, 1000); // &#39;this&#39; está indefinido aquí<br>  }<br>}</pre><p>En este ejemplo, this.increment pierde su contexto de clase cuando se pasa como callback a setInterval. Esto resulta en un error o un comportamiento inesperado.</p><h3>Soluciones Comunes en NestJS</h3><h3>1. Usar bind(this)</h3><pre>start() {<br>  setInterval(this.increment.bind(this), 1000);<br>}</pre><p>bind asegura que this dentro de increment siga apuntando a la instancia de MyService.</p><h3>2. Usar funciones flecha</h3><pre>increment = () =&gt; {<br>  this.count++;<br>  console.log(&#39;Count:&#39;, this.count);<br>};</pre><p>Las funciones flecha no tienen su propio this, sino que heredan el de su contexto de creación, lo cual evita el problema sin necesidad de usar bind.</p><h3>Cuándo Necesitas Vincular Métodos</h3><ul><li>Al pasar métodos como <strong>callbacks</strong> a funciones asíncronas como setTimeout, setInterval, o event handlers.</li><li>Al usar métodos en <strong>listeners personalizados</strong>.</li><li>Cuando usas métodos como <strong>middleware o hooks</strong> que pierden su contexto.</li></ul><h3>Buenas Prácticas</h3><ul><li>En servicios o controladores, considera usar <strong>funciones flecha</strong> para mantener this correctamente.</li><li>Usa bind(this) si necesitas pasar un método como callback y no quieres cambiar su definición.</li><li>Evita abusar de funciones flecha dentro de clases si necesitas herencia o pruebas unitarias que dependan de métodos tradicionales.</li></ul><h3>Conclusión</h3><p>NestJS facilita la gestión del estado y las dependencias, pero el comportamiento de this en JavaScript sigue siendo un factor a considerar. Comprender y aplicar correctamente la vinculación de métodos ayuda a evitar errores sutiles y a escribir código más limpio y mantenible. Ya sea mediante bind(this) o funciones flecha, elegir la estrategia adecuada depende del contexto y del diseño de tu aplicación.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=09228e30a592" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>