<?xml version="1.0" encoding="UTF-8"?><feed xmlns="http://www.w3.org/2005/Atom" xml:lang="es"><title>Chemaclass - architecture</title><subtitle>Tech Lead compartiendo ideas prácticas sobre artesanía del software, TDD, liderazgo, Bitcoin e IA. Artículos, resúmenes de libros y charlas.</subtitle><link rel="self" type="application/atom+xml" href="https://chemaclass.com/es/tags/architecture/atom.xml"/><link rel="alternate" type="text/html" href="https://chemaclass.com"/><generator uri="https://www.getzola.org/">Zola</generator><updated>2023-04-14T00:00:00+00:00</updated><id>https://chemaclass.com/es/tags/architecture/atom.xml</id><entry xml:lang="es"><title>Introduciendo un Nuevo Stack Tecnológico</title><subtitle>Cómo introducir nuevas tecnologías en tu equipo</subtitle><category term="software-design" scheme="https://chemaclass.com/tags/software-design/" label="Software Design"/><category term="architecture" scheme="https://chemaclass.com/tags/architecture/" label="Architecture"/><category term="team-management" scheme="https://chemaclass.com/tags/team-management/" label="Team Management"/><category term="communication" scheme="https://chemaclass.com/tags/communication/" label="Communication"/><published>2023-04-14T00:00:00+00:00</published><updated>2023-04-14T00:00:00+00:00</updated><author><name>
Chemaclass</name></author><link rel="alternate" type="text/html" href="https://chemaclass.com/es/blog/introducing-a-new-tech-stack/"/><id>https://chemaclass.com/es/blog/introducing-a-new-tech-stack/</id><summary type="html">Cuando introduces una nueva tecnología en tu equipo, necesitas explicar el porqué y tener una estrategia clara. Va a afectar a todos.</summary><content type="html">&lt;p>Cuando introduces una nueva tecnología en tu equipo, necesitas explicar el porqué y tener una estrategia clara. Va a afectar a todos.&lt;/p>
&lt;span id="continue-reading">&lt;/span>&lt;h2 id="por-que-ese-nuevo-stack-tecnologico">¿Por qué ese nuevo stack tecnológico?
&lt;a class="heading-anchor" href="#por-que-ese-nuevo-stack-tecnologico" title="Copy link" aria-label="Link to this section">#&lt;/a>
&lt;/h2>
&lt;p>Antes de decidir, recuerda que es una decisión de equipo. Piensa en la estandarización y mantenibilidad del proyecto. Pero lo más importante: ¿qué problema quieres resolver? ¿Es porque mola? ¿O hay una necesidad real que esta tecnología resuelve?&lt;/p>
&lt;h3 id="la-direccion-de-la-tecnologia">La dirección de la tecnología
&lt;a class="heading-anchor" href="#la-direccion-de-la-tecnologia" title="Copy link" aria-label="Link to this section">#&lt;/a>
&lt;/h3>
&lt;p>Cuando propones adoptar una nueva biblioteca, framework o tecnología, hay que conocer su trasfondo y hacia dónde se dirige.&lt;/p>
&lt;p>¿Cuál es la motivación detrás de esa tecnología? ¿Por qué quieres añadirla a tu stack actual?&lt;/p>
&lt;h3 id="acoplamiento-y-dependencias">Acoplamiento y dependencias
&lt;a class="heading-anchor" href="#acoplamiento-y-dependencias" title="Copy link" aria-label="Link to this section">#&lt;/a>
&lt;/h3>
&lt;p>Al adoptar nuevas tecnologías en el día a día, es fácil acoplarse a ellas. Eso hace más difícil dar marcha atrás si después nos arrepentimos.&lt;/p>
&lt;p>No me malinterpretes: aprender y experimentar con nuevas tecnologías está genial. Pero introducirlas en tu trabajo diario es otra historia. Afecta a todo el equipo, así que hay que ser cuidadosos.&lt;/p>
&lt;p>&lt;img src="/images/blog/2023-04-14/middle.webp" alt="blog-middle" />&lt;/p>
&lt;h2 id="el-enfoque-de-la-conversacion">El enfoque de la conversación
&lt;a class="heading-anchor" href="#el-enfoque-de-la-conversacion" title="Copy link" aria-label="Link to this section">#&lt;/a>
&lt;/h2>
&lt;ul>
&lt;li>¿Qué aporta esta nueva tecnología al proyecto?&lt;/li>
&lt;li>¿Qué problema queremos resolver?&lt;/li>
&lt;li>¿Podemos resolverlo con nuestra tecnología actual?&lt;/li>
&lt;li>Si ya tenemos algo similar, ¿queremos mezclar ambas?&lt;/li>
&lt;li>¿Cuáles son los trade-offs de usarla vs. no usarla?&lt;/li>
&lt;li>¿Vale la pena la complejidad extra a largo plazo?&lt;/li>
&lt;li>¿Cuál es la estrategia para que todos se suban al carro?&lt;/li>
&lt;/ul>
&lt;h3 id="architectural-decision-records-adrs">Architectural Decision Records (ADRs)
&lt;a class="heading-anchor" href="#architectural-decision-records-adrs" title="Copy link" aria-label="Link to this section">#&lt;/a>
&lt;/h3>
&lt;p>Sea cual sea el resultado, escríbelo como un &lt;a rel="external" href="https://adr.github.io/">ADR&lt;/a> para poder revisarlo con el tiempo. Un ADR documenta las decisiones del equipo: pros, contras y los argumentos que encontrasteis juntos para decidir qué hacer y por qué.&lt;/p>
&lt;p>Los ADRs ayudan a entender decisiones antiguas. Guárdalos en el control de versiones, en el mismo proyecto si es posible. Son útiles para el equipo actual y para los nuevos que lleguen.&lt;/p>
&lt;p>&lt;img src="/images/blog/2023-04-14/footer.webp" alt="blog-footer" />&lt;/p>
&lt;aside class="kudos">
&lt;span class="kudos__icon" aria-hidden="true">🧠&lt;/span>
&lt;div class="kudos__content">
&lt;p>Gracias a mis amigos &lt;a rel="external" href="https://x.com/evrtrabajo">Manu&lt;/a>, &lt;a rel="external" href="https://x.com/Tito_Kati">Antonio&lt;/a> y &lt;a rel="external" href="https://x.com/JesusValera96">Jesus&lt;/a>, que me ayudaron a crear este resumen de ideas haciendo brainstorming juntos.&lt;/p>
&lt;/div>
&lt;/aside></content></entry><entry xml:lang="es"><title>Recipes for Decoupling</title><category term="php" scheme="https://chemaclass.com/tags/php/" label="Php"/><category term="software-design" scheme="https://chemaclass.com/tags/software-design/" label="Software Design"/><category term="architecture" scheme="https://chemaclass.com/tags/architecture/" label="Architecture"/><category term="clean-code" scheme="https://chemaclass.com/tags/clean-code/" label="Clean Code"/><published>2022-11-28T00:00:00+00:00</published><updated>2022-11-28T00:00:00+00:00</updated><author><name>
Matthias Noback</name></author><link rel="alternate" type="text/html" href="https://chemaclass.com/es/readings/recipes-for-decoupling/"/><id>https://chemaclass.com/es/readings/recipes-for-decoupling/</id><summary type="html">¿Qué es el acoplamiento y por qué nos perjudica? Este libro recopila estrategias prácticas para separar tu código de dominio de la infraestructura y mantener un sistema sano a largo plazo.</summary><content type="html">&lt;span id="continue-reading">&lt;/span>
&lt;p>¿Qué es el acoplamiento y por qué nos perjudica? ¿Cómo desacoplar de forma eficiente? Este libro recopila estrategias para separar tu código de dominio de los detalles de infraestructura. El resultado: un sistema más sano a largo plazo.&lt;/p>
&lt;p>Aprenderás a crear reglas de &lt;a rel="external" href="https://phpstan.org/">&lt;strong>PHPStan&lt;/strong>&lt;/a> desde cero. Además, el libro te guía por múltiples oportunidades de desacoplamiento:&lt;/p>
&lt;ul>
&lt;li>framework web&lt;/li>
&lt;li>frameworks cli&lt;/li>
&lt;li>validación de formularios&lt;/li>
&lt;li>orm y base de datos&lt;/li>
&lt;li>framework de testing&lt;/li>
&lt;/ul>
&lt;p>Lee más sobre el libro: &lt;a rel="external" href="https://matthiasnoback.nl/book/recipes-for-decoupling/">matthiasnoback.nl/book/recipes-for-decoupling/&lt;/a>&lt;/p>
&lt;blockquote>
&lt;p>Cómpralo aquí: &lt;a rel="external" href="https://leanpub.com/recipes-for-decoupling">leanpub.com/recipes-for-decoupling&lt;/a>&lt;/p>
&lt;/blockquote></content></entry><entry xml:lang="es"><title>Ingeniería de Software Moderna</title><subtitle>Haciendo lo que funciona para construir mejor software más rápido</subtitle><category term="software-design" scheme="https://chemaclass.com/tags/software-design/" label="Software Design"/><category term="testing" scheme="https://chemaclass.com/tags/testing/" label="Testing"/><category term="architecture" scheme="https://chemaclass.com/tags/architecture/" label="Architecture"/><category term="agile" scheme="https://chemaclass.com/tags/agile/" label="Agile"/><published>2022-06-29T00:00:00+00:00</published><updated>2022-06-29T00:00:00+00:00</updated><author><name>
David Farley</name></author><link rel="alternate" type="text/html" href="https://chemaclass.com/es/readings/modern-software-engineering/"/><id>https://chemaclass.com/es/readings/modern-software-engineering/</id><summary type="html">El desarrollo de software como práctica de ingeniería real. Para dominarlo hay que ser experto en aprender y gestionar la complejidad.</summary><content type="html">&lt;span id="continue-reading">&lt;/span>
&lt;p>El libro presenta el desarrollo de software como una práctica de ingeniería real. Para dominarlo hay que ser experto en aprender y gestionar la complejidad.&lt;/p>
&lt;h3 id="optimizar-para-aprender">Optimizar para aprender
&lt;a class="heading-anchor" href="#optimizar-para-aprender" title="Copy link" aria-label="Link to this section">#&lt;/a>
&lt;/h3>
&lt;p>El libro presenta cinco comportamientos clave para aprender mejor:&lt;/p>
&lt;ul>
&lt;li>Trabajar de forma iterativa&lt;/li>
&lt;li>Buscar feedback&lt;/li>
&lt;li>Incrementalismo&lt;/li>
&lt;li>Empirismo&lt;/li>
&lt;li>Ser experimental&lt;/li>
&lt;/ul>
&lt;p>La idea central: trabajar en pasos pequeños, recoger feedback y ajustar.&lt;/p>
&lt;h3 id="optimizar-para-gestionar-la-complejidad">Optimizar para gestionar la complejidad
&lt;a class="heading-anchor" href="#optimizar-para-gestionar-la-complejidad" title="Copy link" aria-label="Link to this section">#&lt;/a>
&lt;/h3>
&lt;p>Cinco ideas para manejar la complejidad:&lt;/p>
&lt;ul>
&lt;li>Modularidad&lt;/li>
&lt;li>Cohesión&lt;/li>
&lt;li>Separación de responsabilidades&lt;/li>
&lt;li>Ocultación de información y abstracción&lt;/li>
&lt;li>Gestión del acoplamiento&lt;/li>
&lt;/ul>
&lt;p>Gestionar la complejidad de nuestros sistemas es fundamental.&lt;/p>
&lt;h3 id="herramientas-para-apoyar-la-ingenieria">Herramientas para apoyar la ingeniería
&lt;a class="heading-anchor" href="#herramientas-para-apoyar-la-ingenieria" title="Copy link" aria-label="Link to this section">#&lt;/a>
&lt;/h3>
&lt;p>El libro profundiza en ideas como:&lt;/p>
&lt;ul>
&lt;li>Testeabilidad&lt;/li>
&lt;li>Desplegabilidad&lt;/li>
&lt;li>Control de variables&lt;/li>
&lt;li>Entrega continua&lt;/li>
&lt;/ul>
&lt;hr />
&lt;p>Un vídeo donde el autor explica las ideas principales del libro:&lt;/p>
&lt;div style="position:relative;aspect-ratio:16/9;width:100%;">
&lt;iframe
src="https://www.youtube-nocookie.com/embed/TRqYQnCfgH8"
title="YouTube video"
width="560"
height="315"
loading="lazy"
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
referrerpolicy="strict-origin-when-cross-origin"
style="position:absolute;inset:0;width:100%;height:100%;border:0;"
allowfullscreen>
&lt;/iframe>
&lt;/div></content></entry><entry xml:lang="es"><title>Topologías de Equipos</title><subtitle>Organizando equipos de negocio y tecnología para flujo rápido</subtitle><category term="team-management" scheme="https://chemaclass.com/tags/team-management/" label="Team Management"/><category term="architecture" scheme="https://chemaclass.com/tags/architecture/" label="Architecture"/><category term="devops" scheme="https://chemaclass.com/tags/devops/" label="Devops"/><category term="agile" scheme="https://chemaclass.com/tags/agile/" label="Agile"/><published>2022-03-31T00:00:00+00:00</published><updated>2022-03-31T00:00:00+00:00</updated><author><name>
Matthew Skelton</name></author><author><name>
Manuel Pais</name></author><link rel="alternate" type="text/html" href="https://chemaclass.com/es/readings/team-topologies/"/><id>https://chemaclass.com/es/readings/team-topologies/</id><summary type="html">Cómo estructurar equipos dinámicos e interacciones que permitan adaptarse rápido a nuevas condiciones y entregar software de forma ágil y segura.</summary><content type="html">&lt;span id="continue-reading">&lt;/span>
&lt;p>El libro explica cómo estructurar equipos dinámicos y sus interacciones para adaptarse rápido a nuevas condiciones y entregar software de forma ágil y segura.&lt;/p>
&lt;h2 id="estructura-de-equipo">Estructura de equipo
&lt;a class="heading-anchor" href="#estructura-de-equipo" title="Copy link" aria-label="Link to this section">#&lt;/a>
&lt;/h2>
&lt;ul>
&lt;li>Alta cohesión: agrupa las cosas relacionadas.&lt;/li>
&lt;li>Bajo acoplamiento: límites claros entre equipos.&lt;/li>
&lt;li>Carga cognitiva: es como la RAM del equipo. Si lo sobrecargas, se quema.&lt;/li>
&lt;/ul>
&lt;blockquote>
&lt;p>Para evitar cuellos de botella, asegúrate de que la carga cognitiva del equipo no sea excesiva.&lt;/p>
&lt;/blockquote>
&lt;h2 id="ley-de-conway">Ley de Conway
&lt;a class="heading-anchor" href="#ley-de-conway" title="Copy link" aria-label="Link to this section">#&lt;/a>
&lt;/h2>
&lt;ul>
&lt;li>La estructura organizacional influye en la arquitectura del software.&lt;/li>
&lt;li>Las organizaciones diseñan sistemas que copian su estructura de comunicación.&lt;/li>
&lt;li>Resultado: nadie se enfoca en la arquitectura óptima para el proyecto.&lt;/li>
&lt;li>Primero define la arquitectura, luego forma los equipos.&lt;/li>
&lt;/ul>
&lt;h2 id="el-equipo-primero">El equipo primero
&lt;a class="heading-anchor" href="#el-equipo-primero" title="Copy link" aria-label="Link to this section">#&lt;/a>
&lt;/h2>
&lt;ul>
&lt;li>Quién está en el equipo importa menos que su dinámica.&lt;/li>
&lt;li>Al medir rendimiento, el equipo importa más que las personas individuales.&lt;/li>
&lt;li>Equipo = grupo de 5-9 personas trabajando hacia metas compartidas.
&lt;ul>
&lt;li>Ver el &lt;a href="/es/blog/dunbar-number/">número de Dunbar&lt;/a>.&lt;/li>
&lt;/ul>
&lt;/li>
&lt;li>Formar un equipo toma de 2 semanas a 3 meses.&lt;/li>
&lt;li>La carga cognitiva es el esfuerzo mental total usado en la memoria de trabajo.&lt;/li>
&lt;li>3 tipos de carga cognitiva:
&lt;ul>
&lt;li>Intrínseca: fundamentos del problema. Ej: lenguaje de programación.&lt;/li>
&lt;li>Extrínseca: relacionada con el entorno. Ej: cómo desplegar.&lt;/li>
&lt;li>Germane: requiere atención especial. Ej: dominio de negocio.&lt;/li>
&lt;/ul>
&lt;/li>
&lt;li>Heurísticas:
&lt;ul>
&lt;li>3 tipos de dominio: simple, complicado, complejo.&lt;/li>
&lt;li>Si el dominio es muy grande, divídelo en subdominios.&lt;/li>
&lt;li>Un equipo puede manejar:
&lt;ul>
&lt;li>2-3 dominios simples.&lt;/li>
&lt;li>1 dominio complejo.&lt;/li>
&lt;li>Evita 2 dominios complicados; mejor divide el equipo.&lt;/li>
&lt;/ul>
&lt;/li>
&lt;/ul>
&lt;/li>
&lt;li>Define una API de equipo:
&lt;ul>
&lt;li>Código: endpoints, librerías, clientes…&lt;/li>
&lt;li>Versionado.&lt;/li>
&lt;li>Documentación.&lt;/li>
&lt;li>Prácticas y principios.&lt;/li>
&lt;li>Herramientas de comunicación.&lt;/li>
&lt;/ul>
&lt;/li>
&lt;/ul>
&lt;h2 id="topologias-de-equipo">Topologías de equipo
&lt;a class="heading-anchor" href="#topologias-de-equipo" title="Copy link" aria-label="Link to this section">#&lt;/a>
&lt;/h2>
&lt;blockquote>
&lt;p>Organiza equipos por áreas de dominio de negocio, no por conocimiento técnico o actividades.&lt;/p>
&lt;/blockquote>
&lt;ul>
&lt;li>El éxito depende tanto de los miembros como del entorno, otros equipos e interacciones.&lt;/li>
&lt;li>Divide responsabilidades para romper silos.&lt;/li>
&lt;li>Tipos de dependencias: conocimiento, tarea y recurso.&lt;/li>
&lt;li>Cuatro tipos de equipos:
&lt;ul>
&lt;li>Stream-aligned: entregar funcionalidades y productos al mercado cuanto antes.&lt;/li>
&lt;li>Enabling: desarrollar capacidades para los equipos stream-aligned.&lt;/li>
&lt;li>Complicated-subsystem: reducir la carga cognitiva de los equipos stream-aligned.&lt;/li>
&lt;li>Platform: dar autonomía a los equipos stream-aligned.&lt;/li>
&lt;/ul>
&lt;/li>
&lt;/ul>
&lt;h2 id="interacciones-de-equipo">Interacciones de equipo
&lt;a class="heading-anchor" href="#interacciones-de-equipo" title="Copy link" aria-label="Link to this section">#&lt;/a>
&lt;/h2>
&lt;ul>
&lt;li>Colaboración: trabajo cercano entre equipos con distintas habilidades.&lt;/li>
&lt;li>X-as-a-Service: propiedad clara, baja carga cognitiva.&lt;/li>
&lt;li>Facilitación: eliminar impedimentos y mejorar la calidad de las interacciones entre equipos.&lt;/li>
&lt;/ul></content></entry><entry xml:lang="es"><title>Principios de diseño de paquetes</title><subtitle>Cómo crear componentes de software reutilizables</subtitle><category term="software-design" scheme="https://chemaclass.com/tags/software-design/" label="Software Design"/><category term="architecture" scheme="https://chemaclass.com/tags/architecture/" label="Architecture"/><category term="clean-code" scheme="https://chemaclass.com/tags/clean-code/" label="Clean Code"/><published>2020-11-12T00:00:00+00:00</published><updated>2020-11-12T00:00:00+00:00</updated><author><name>
Matthias Noback</name></author><link rel="alternate" type="text/html" href="https://chemaclass.com/es/readings/packaging-design/"/><id>https://chemaclass.com/es/readings/packaging-design/</id><summary type="html">Cómo crear paquetes con la cohesión y el acoplamiento justos, útiles tanto para usuarios como mantenedores</summary><content type="html">&lt;span id="continue-reading">&lt;/span>
&lt;p>Aprende a aplicar principios de diseño a tus clases para que sean reutilizables. El libro te enseña a crear paquetes con la cohesión y acoplamiento adecuados, pensados para usuarios y mantenedores.&lt;/p>
&lt;p>La primera parte cubre los cinco principios SOLID para mejorar el diseño de clases. La segunda parte entra en las mejores prácticas de diseño de paquetes: principios de cohesión y de acoplamiento.&lt;/p>
&lt;p>Los principios de cohesión te dicen qué clases van juntas, cuándo dividir un paquete, y cuándo un grupo de clases puede llamarse “paquete”. Los de acoplamiento te ayudan a elegir bien las dependencias y evitar ciclos en el grafo de dependencias.&lt;/p>
&lt;h3 id="lo-que-aprenderas">Lo que aprenderás
&lt;a class="heading-anchor" href="#lo-que-aprenderas" title="Copy link" aria-label="Link to this section">#&lt;/a>
&lt;/h3>
&lt;ul>
&lt;li>Aplicar los principios SOLID&lt;/li>
&lt;li>Decidir si las clases pertenecen al mismo paquete&lt;/li>
&lt;li>Saber cuándo un paquete puede depender de otro&lt;/li>
&lt;/ul></content></entry><entry xml:lang="es"><title>Domain-Driven Design Distilled</title><subtitle>DDD explicado de forma clara y práctica</subtitle><category term="ddd" scheme="https://chemaclass.com/tags/ddd/" label="Ddd"/><category term="architecture" scheme="https://chemaclass.com/tags/architecture/" label="Architecture"/><category term="software-design" scheme="https://chemaclass.com/tags/software-design/" label="Software Design"/><published>2020-09-10T00:00:00+00:00</published><updated>2020-09-10T00:00:00+00:00</updated><author><name>
Vaughn Vernon</name></author><link rel="alternate" type="text/html" href="https://chemaclass.com/es/readings/domain-driven-design-distilled/"/><id>https://chemaclass.com/es/readings/domain-driven-design-distilled/</id><summary type="html">Una introducción accesible a DDD para desarrolladores, consultores y cualquiera que quiera entender el diseño guiado por dominio</summary><content type="html">&lt;p>Este libro hace que DDD cobre vida. Da igual si eres desarrollador, consultor o cliente: te ayuda a entenderlo y sacarle provecho.&lt;/p>
&lt;span id="continue-reading">&lt;/span>
&lt;hr />
&lt;p>Desarrolladores de todo el mundo lo están adoptando porque da resultados reales. Es una guía accesible que responde:&lt;/p>
&lt;ul>
&lt;li>¿Qué es DDD?&lt;/li>
&lt;li>¿Qué problemas resuelve?&lt;/li>
&lt;li>¿Cómo funciona?&lt;/li>
&lt;li>¿Cómo sacarle valor rápido?&lt;/li>
&lt;/ul>
&lt;p>Aprenderás a separar modelos de dominio con &lt;strong>Contextos Acotados&lt;/strong> (Bounded Contexts), a desarrollar un &lt;strong>Lenguaje Ubicuo&lt;/strong> dentro de cada contexto, y a lograr que &lt;strong>expertos de dominio&lt;/strong> y &lt;strong>desarrolladores&lt;/strong> colaboren para crear ese lenguaje.&lt;/p>
&lt;p>También cubre cómo usar Subdominios para manejar sistemas legacy e integrar varios Contextos Acotados definiendo relaciones entre equipos.&lt;/p>
&lt;blockquote>
&lt;p>Domain-Driven Design Distilled da vida a &lt;strong>DDD&lt;/strong>.&lt;/p>
&lt;/blockquote></content></entry><entry xml:lang="es"><title>Advanced Web Application Architecture</title><subtitle>La guía que lleva tus habilidades de código al siguiente nivel</subtitle><category term="architecture" scheme="https://chemaclass.com/tags/architecture/" label="Architecture"/><category term="php" scheme="https://chemaclass.com/tags/php/" label="Php"/><category term="software-design" scheme="https://chemaclass.com/tags/software-design/" label="Software Design"/><category term="refactoring" scheme="https://chemaclass.com/tags/refactoring/" label="Refactoring"/><published>2020-08-16T00:00:00+00:00</published><updated>2020-08-16T00:00:00+00:00</updated><author><name>
Matthias Noback</name></author><link rel="alternate" type="text/html" href="https://chemaclass.com/es/readings/advance-web-application-architecture/"/><id>https://chemaclass.com/es/readings/advance-web-application-architecture/</id><summary type="html">Cómo desacoplar tu aplicación del framework y la base de datos con PHP moderno y diseño modular</summary><content type="html">&lt;p>Este libro te ayuda a poner en forma tus aplicaciones web. Trae muchas técnicas para desacoplar tu código de la infraestructura (el framework, la base de datos, etc.).&lt;/p>
&lt;span id="continue-reading">&lt;/span>
&lt;p>La Parte 1 presenta patrones de diseño para separar código de negocio e infraestructura. La Parte 2 muestra cómo estos patrones encajan con conceptos arquitectónicos como capas, puertos y adaptadores (arquitectura Hexagonal). El libro cierra con estrategias de testing y decisiones de diseño.&lt;/p>
&lt;h3 id="lo-que-aprenderas">Lo que aprenderás
&lt;a class="heading-anchor" href="#lo-que-aprenderas" title="Copy link" aria-label="Link to this section">#&lt;/a>
&lt;/h3>
&lt;ul>
&lt;li>Separar código mezclado en código de negocio e infraestructura usando patrones.&lt;/li>
&lt;li>Dividir tu código en capas con una distinción clara entre puertos y adaptadores.&lt;/li>
&lt;li>Testear aplicaciones desacopladas.&lt;/li>
&lt;/ul>
&lt;blockquote>
&lt;p>Compra el libro: &lt;a rel="external" href="https://leanpub.com/web-application-architecture">https://leanpub.com/web-application-architecture&lt;/a>&lt;/p>
&lt;/blockquote>
&lt;hr />
&lt;h3 id="patrones-de-diseno-para-modernizar-codigo-legacy">Patrones de diseño para modernizar código legacy
&lt;a class="heading-anchor" href="#patrones-de-diseno-para-modernizar-codigo-legacy" title="Copy link" aria-label="Link to this section">#&lt;/a>
&lt;/h3>
&lt;div style="position:relative;aspect-ratio:16/9;width:100%;">
&lt;iframe
src="https://www.youtube-nocookie.com/embed/WI1QY6OMglE"
title="YouTube video"
width="560"
height="315"
loading="lazy"
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
referrerpolicy="strict-origin-when-cross-origin"
style="position:absolute;inset:0;width:100%;height:100%;border:0;"
allowfullscreen>
&lt;/iframe>
&lt;/div></content></entry><entry xml:lang="es"><title>Symfony 5</title><subtitle>Symfony 5: La Vía Rápida</subtitle><category term="php" scheme="https://chemaclass.com/tags/php/" label="Php"/><category term="symfony" scheme="https://chemaclass.com/tags/symfony/" label="Symfony"/><category term="architecture" scheme="https://chemaclass.com/tags/architecture/" label="Architecture"/><published>2020-02-20T00:00:00+00:00</published><updated>2020-02-20T00:00:00+00:00</updated><author><name>
Fabien Potencier</name></author><link rel="alternate" type="text/html" href="https://chemaclass.com/es/readings/symfony-5/"/><id>https://chemaclass.com/es/readings/symfony-5/</id><summary type="html">Una guía práctica del creador de Symfony para desarrollar aplicaciones web desde cero hasta producción.</summary><content type="html">&lt;span id="continue-reading">&lt;/span>
&lt;p>Escrito por el creador de Symfony, este libro presenta un enfoque práctico para desarrollar aplicaciones web con Symfony 5: desde cero hasta producción. Si estás descubriendo Symfony por primera vez o quieres refrescar tus conocimientos, esta guía te da una introducción completa a las aplicaciones modernas con Symfony.&lt;/p></content></entry><entry xml:lang="es"><title>Arquitectura Limpia</title><subtitle>Guía del artesano para la estructura y diseño de software</subtitle><category term="architecture" scheme="https://chemaclass.com/tags/architecture/" label="Architecture"/><category term="software-design" scheme="https://chemaclass.com/tags/software-design/" label="Software Design"/><category term="clean-code" scheme="https://chemaclass.com/tags/clean-code/" label="Clean Code"/><category term="ddd" scheme="https://chemaclass.com/tags/ddd/" label="Ddd"/><published>2018-06-04T00:00:00+00:00</published><updated>2018-06-04T00:00:00+00:00</updated><author><name>
Robert C. Martin</name></author><link rel="alternate" type="text/html" href="https://chemaclass.com/es/readings/clean-architecture/"/><id>https://chemaclass.com/es/readings/clean-architecture/</id><summary type="html">Cómo estructurar y diseñar software de forma profesional. Principios SOLID, componentes y capas explicados con claridad.</summary><content type="html">&lt;span id="continue-reading">&lt;/span>&lt;h3 id="principios-de-diseno-de-codigo-solid">Principios de diseño de código (SOLID)
&lt;a class="heading-anchor" href="#principios-de-diseno-de-codigo-solid" title="Copy link" aria-label="Link to this section">#&lt;/a>
&lt;/h3>
&lt;ul>
&lt;li>&lt;strong>Responsabilidad Única&lt;/strong>: una clase debe tener una sola razón para cambiar. O en su versión nueva: un módulo responde ante un solo actor.&lt;/li>
&lt;li>&lt;strong>Abierto-cerrado&lt;/strong>: abierta para extensión, cerrada para modificación.&lt;/li>
&lt;li>&lt;strong>Sustitución de Liskov&lt;/strong>: puedes reemplazar objetos por instancias de sus subtipos sin romper el programa.&lt;/li>
&lt;li>&lt;strong>Segregación de Interfaces&lt;/strong>: mejor muchas interfaces específicas que una general.&lt;/li>
&lt;li>&lt;strong>Inversión de Dependencias&lt;/strong>: depende de abstracciones, no de implementaciones concretas.&lt;/li>
&lt;/ul>
&lt;h3 id="principios-de-componentes">Principios de componentes
&lt;a class="heading-anchor" href="#principios-de-componentes" title="Copy link" aria-label="Link to this section">#&lt;/a>
&lt;/h3>
&lt;h4 id="cohesion-de-componentes">Cohesión de componentes
&lt;a class="heading-anchor" href="#cohesion-de-componentes" title="Copy link" aria-label="Link to this section">#&lt;/a>
&lt;/h4>
&lt;ul>
&lt;li>&lt;strong>Equivalencia Reutilización/Liberación&lt;/strong>: las clases reutilizadas juntas deben liberarse juntas. Mismo número de versión y changelog adecuado.&lt;/li>
&lt;li>&lt;strong>Cierre Común&lt;/strong>: las clases que cambian juntas van juntas. Es el principio de responsabilidad única a nivel de componente.&lt;/li>
&lt;li>&lt;strong>Reutilización Común&lt;/strong>: no obligues a los usuarios a depender de lo que no necesitan. Segregación de interfaces a nivel de componente.&lt;/li>
&lt;/ul>
&lt;h4 id="acoplamiento-de-componentes">Acoplamiento de componentes
&lt;a class="heading-anchor" href="#acoplamiento-de-componentes" title="Copy link" aria-label="Link to this section">#&lt;/a>
&lt;/h4>
&lt;ul>
&lt;li>&lt;strong>Dependencias Acíclicas&lt;/strong>: sin ciclos en el grafo de dependencias. Los ciclos fuerzan a liberar componentes juntos. Usa inversión de dependencias para romperlos.&lt;/li>
&lt;li>&lt;strong>Dependencia Estable&lt;/strong>: los componentes menos estables dependen de los más estables. Depende en dirección de la estabilidad.&lt;/li>
&lt;li>&lt;strong>Abstracciones Estables&lt;/strong>: los componentes estables deben ser abstractos. Ejemplo: una política de alto nivel que se extiende siguiendo abierto-cerrado.&lt;/li>
&lt;/ul>
&lt;h3 id="principios-de-arquitectura">Principios de arquitectura
&lt;a class="heading-anchor" href="#principios-de-arquitectura" title="Copy link" aria-label="Link to this section">#&lt;/a>
&lt;/h3>
&lt;h4 id="estableciendo-limites">Estableciendo límites
&lt;a class="heading-anchor" href="#estableciendo-limites" title="Copy link" aria-label="Link to this section">#&lt;/a>
&lt;/h4>
&lt;p>Los límites separan elementos de software: lo que importa de lo que no, lo de alto nivel de lo de bajo nivel. Si el código de alto nivel depende del de bajo nivel, los cambios se propagan hacia arriba. Ponemos un límite usando polimorfismo para invertir el flujo. Esto es el Principio de Inversión de Dependencias de SOLID.&lt;/p>
&lt;h4 id="separando-capas">Separando capas
&lt;a class="heading-anchor" href="#separando-capas" title="Copy link" aria-label="Link to this section">#&lt;/a>
&lt;/h4>
&lt;p>Cuatro capas principales (aunque puede variar):&lt;/p>
&lt;ul>
&lt;li>&lt;strong>Entidades&lt;/strong>: objetos con lógica de negocio crítica. Ejemplo: un banco que no da préstamos a clientes sin cierta puntuación crediticia. Se comparten entre aplicaciones de la empresa.&lt;/li>
&lt;li>&lt;strong>Casos de uso&lt;/strong>: reglas de negocio específicas de la aplicación. Ejemplo: la secuencia de pantallas para hacer una transferencia.&lt;/li>
&lt;li>&lt;strong>Adaptadores de interfaz&lt;/strong>: gateways, presenters, controllers. Aquí va la arquitectura MVC de la GUI y la transformación de datos entre base de datos y casos de uso.&lt;/li>
&lt;li>&lt;strong>Frameworks y drivers&lt;/strong>: frameworks web, base de datos, la vista de MVC.&lt;/li>
&lt;/ul></content></entry></feed>