<?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 Adrián Alonso on Medium]]></title>
        <description><![CDATA[Stories by Adrián Alonso on Medium]]></description>
        <link>https://medium.com/@adrianalonsodev?source=rss-f754bd174f5------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*tauzNuagQHoYLmIq_CYltw.jpeg</url>
            <title>Stories by Adrián Alonso on Medium</title>
            <link>https://medium.com/@adrianalonsodev?source=rss-f754bd174f5------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 01:42:39 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@adrianalonsodev/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[From Zero to Hero]]></title>
            <link>https://adrianalonsodev.medium.com/from-zero-to-hero-922d01f3c08c?source=rss-f754bd174f5------2</link>
            <guid isPermaLink="false">https://medium.com/p/922d01f3c08c</guid>
            <category><![CDATA[dunning-kruger-effect]]></category>
            <category><![CDATA[tech-leadership]]></category>
            <category><![CDATA[leadership]]></category>
            <category><![CDATA[career-development]]></category>
            <category><![CDATA[management-and-leadership]]></category>
            <dc:creator><![CDATA[Adrián Alonso]]></dc:creator>
            <pubDate>Wed, 04 Oct 2023 10:34:10 GMT</pubDate>
            <atom:updated>2023-10-04T10:40:39.447Z</atom:updated>
            <content:encoded><![CDATA[<p>Durante el mes de agosto me dediqué a preparar mi charla <strong><em>“From Zero to Hero”</em></strong>. Tuve el honor de presentarla en la <a href="https://pulpocon.es/workshop/adrian-alonso"><strong><em>PulpoCon 2023</em></strong></a>, que se celebró en Vigo en el mes de septiembre , y unas semanas después, la volví a compartir en la comunidad de <a href="https://js.almeria.dev/"><strong><em>AlmeriaJS</em></strong></a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*uMPY-zaqlkyL8WOjYf1UWA.jpeg" /><figcaption>Presentando la slide de Individual Contributors en PulpoCon 2023</figcaption></figure><p>Por lo general, siempre he preparado material más técnico, pero esta vez quería hacer algo diferente y hablar sobre liderazgo, gestión de equipos, sesgos cognitivos y gestión de expectativas en roles de management.</p><p>En este artículo intentaré resumir los puntos clave que abordé en la charla, incluyendo bibliografía y referencias para profundizar más en el tema e inmortalizar el contenido.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pWAhc6fSmwMZCyYCMQqH6A.jpeg" /><figcaption>Presentación en la comunidad AlmeriaJS</figcaption></figure><h3>¿Cuántos habéis estado en un proyecto sin objetivos?</h3><p>Con esta <strong>pregunta</strong> quise empezar a remover sentimientos en la audiencia.</p><p>Y quería profundizar en cuestiones como:</p><ul><li><em>¿Por qué estamos desarrollando esta feature?</em></li><li><em>¿Quién tomó esta decisión y por qué?</em></li><li><em>¿Por qué elegimos esta tecnología?</em></li><li><em>¿Cuál es el propósito de este cambio?</em></li></ul><p>A veces, veo <strong>equipos poco cohesionados</strong> en los que cada miembro persigue sus propios intereses. El típico desarrollador que se enfoca en herramientas y problemas técnicos, pero no en las necesidades del proyecto. Los roles de management que dan opiniones de manera <em>random</em>, sin un criterio claro. Equipos que muestran una falta de cohesión y una clara brecha entre sus miembros.</p><p>El problema más común que encuentro en los equipos es la falta de un objetivo claro. Para mí, es fundamental <strong>definir objetivos</strong> tanto a nivel colectivo como individual. Establecer objetivos nos permite <strong>dirigir nuestras acciones y esfuerzos hacia lo que deseamos lograr</strong> y darle sentido al conjunto.</p><blockquote>Caer en la rutina y realizar tareas por inercia, sin cuestionar el <em>“por qué”</em>, nos llevará a la desidia.</blockquote><p>Sin embargo, tampoco debemos obsesionarnos con los objetivos; es importante encontrar un <strong>equilibrio</strong> entre metas realistas y disfrutar del camino que nos lleva a alcanzarlas.</p><p>En un equipo de desarrollo, el papel del <strong>Engineering Manager</strong> es fundamental. Este rol debe identificar estos problemas y buscar soluciones, establecer losobjetivos, cuestionar lo que se hace y mantener al equipo enfocado en un horizonte claro. Además debe de conocer en qué punto del camino se encuentra cada miembro de su equipo.</p><h3>Parte 1. El camino del developer</h3><p><strong>¡DISCLAIMER!</strong> Cualquier parecido con la realidad es mera casualidad. No pretendo herir sentimientos, sino compartir mi humilde visión y experiencia adquirida durante estos años como ingeniero de software.</p><p>La verdad es que nunca me han gustado las etiquetas de “junior”, “mid” o “senior” que se utilizan para determinar tu salario, jerarquía o incluso para incluirlas en tu perfil de LinkedIn. Creo que estas etiquetas no se ajustan de la misma manera en todas las empresas y están más relacionadas con lo que aportas y tu madurez profesional que con lo que sabes.</p><p>Considero que se pueden poseer diferentes habilidades en diferentes niveles. Pero,<strong> ¿dónde está la línea que separa uno de otro? ¿Solo se define mediante un aumento salarial o un nuevo contrato?</strong></p><p>Por desgracia o por fortuna, los seres humanos tendemos a etiquetar y categorizar desde nuestros orígenes. Lo hacemos para <strong>simplificar la complejidad</strong> de nuestro entorno, tomar decisiones de manera más eficiente y buscar patrones.</p><p>Es importante tener en cuenta que cada persona es única y que siempre existen matices. En el siguiente texto, intentaré describir lo que entiendo y espero de cada uno de estos tres niveles.</p><h4>Junior</h4><p>Los juniors suelen ser <strong>personas enérgicas y con alta motivación</strong>, acaban de salir de su formación, están descubriendo algo nuevo y les llena.</p><p>Cada pequeño logro representa para ellos una gran recompensa, pero también es común que anhelen <strong>resultados inmediatos</strong>. Es importante reconocer que todos enfrentamos desafíos y errores en nuestro camino, y para un junior, estos obstáculos pueden llegar a ser paralizantes. Es fundamental brindarles el apoyo necesario para superar estos bloqueos.</p><p>También son personas con reglas fijas (el famoso <a href="https://adrianalonso.es/arquitectura-del-software/antipatrones/antipatrones-de-desarrollo-software-golden-hammer/"><strong>Golden Hammer</strong></a>). Cuando descubren una nueva solución para resolver un problema, a menudo intentan aplicarla a todas las situaciones posteriores. Esto se debe en parte a su falta de contexto y a una visión más amplia para comprender completamente la complejidad de un problema. Gran parte de su aprendizaje se basa en la metodología de prueba y error.</p><p>Los roles junior requieren s<strong>upervisión y orientación</strong>. No debemos olvidar que necesitan un buen mentor y una incorporación efectiva en los equipos. Es esencial que los otros miembros del equipo brinden el apoyo y la paciencia necesarios, ya que, de lo contrario, podrían caer en la frustración.</p><blockquote><strong>El junior de hoy será el senior del mañana</strong></blockquote><h4>Mid</h4><p>El mid es un animal <em>mid-tológico, </em>pocos se identifican con este nivel. Tampoco existen muchas ofertas laborales que busquen específicamente este nivel, pero existen y están entre nosotros. <em>¡A veces somos nosotros!</em></p><p>En esta etapa, uno se vuelve cada vez más <strong>autónomo, competente y resolutivo</strong>. Se comienza adquirir una visión más completa de lo que se está construyendo y se necesita menos orientación. Puede enfocarse en una parte específica del problema y asumir la responsabilidad de la misma.</p><p>Sin embargo, el desafío en este nivel es que puede caer en la complacencia si siempre se le asignan las mismas tareas. Es crucial motivarlos con <strong>nuevos retos</strong> y fomentar una <strong>cultura de aprendizaje</strong> y desarrollo de investigación para que puedan probar cosas nuevas y descubrir nuevas herramientas.</p><p>Los profesionales en el nivel “Mid” a veces pueden caer en la falta de humildad y sobreestimar sus habilidades. Aquí es donde se aplica lo que se conoce como el<strong> efecto Dunning-Kruger,</strong> un sesgo cognitivo que identifica a personas incompetentes que no son conscientes de su incompetencia.</p><p><strong>¿Cuántos de nosotros conocemos el síndrome del impostor? ¿Cuántos lo hemos experimentado? </strong>Pues este sesgo es precisamente lo contrario; es esencialmente lo que tradicionalmente se conoce en nuestros tiempos como <em>“cuñadismo”</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xnLdEWnZjp67Mf3f7bmLsQ.jpeg" /><figcaption><a href="https://discourse.forosaluddigital.cl/t/el-efecto-dunning-kruger-relacion-entre-estupidez-y-vanidad/407">https://discourse.forosaluddigital.cl/t/el-efecto-dunning-kruger-relacion-entre-estupidez-y-vanidad/407</a></figcaption></figure><p><strong>¿Alguna vez has ignorado una advertencia porque “ya lo sabías” o has ignorado una crítica porque sentías que sabía más? </strong>Cuidado con el exceso de confianza y mantener la humildad bajo control. En tecnología estamos en constante aprendizaje, la <a href="https://es.wikipedia.org/wiki/Beta_perpetuo">beta perpetua</a> del ser humano.</p><p>Pero esto no es algo nuevo, grandes pensadores descubrieron este sesgo hace muchos años:</p><blockquote>Daría todo lo que sé por la mitad de lo que ignoro. (Descartes)<br>Solo se que no se nada (Socrates)</blockquote><p><strong>¿Se esconde una inhabilidad cognitiva bajo la prepotencia de los individuos “dominantes” y bajo la excesiva humildad de los individuos «dominados»?</strong></p><h4>Senior</h4><p><strong><em>¿Qué es ser senior?</em></strong> Es una respuesta complicada, cada empresa tiene su propia visión de la seniority. En algunas consultoras, dos años trabajando con una tecnología pueden considerarte como el “senior” del equipo, mientras que en procesos de selección te pueden descartar si no tienes al menos cinco años de experiencia con una tecnología en particular.</p><p><strong><em>¿Una persona muy buena técnicamente que se cierra una semana en una solución, genera cuellos de botella y no la comparte con nadie es ser Senior?</em></strong></p><blockquote>Si quieres ir rápido, ve solo, si quieres llegar lejos, ve acompañado.</blockquote><p>A veces llegamos a senior, somos los mejores, no escuchamos a nadie y nos centramos en la solución. Pasamos del síndrome del impostor al arrogante.</p><p>Un aspecto fundamental es que la <em>seniority</em> no está exclusivamente relacionada con el c<strong>onocimiento técnico</strong> específico. Desde mi perspectiva, un <em>“senior”</em> es alguien que ha <strong>convertido el conocimiento en intuición</strong>, lo que a mi me gusta llamar un <em>“perro viejo”</em>.</p><p>Está capacitado para <strong>alinearse</strong> con las necesidades reales, <strong>servir</strong> al equipo, saber cuándo es el momento de intervenir, <strong>mentorizar</strong> a sus compañeros y tener una <strong>visión</strong> sobre las decisiones que se toman.Es resolutivo, se comunica bien y entiende el valor del negocio, y comienza a tener buenas <em>soft skills</em>. <strong>Asume el liderazgo</strong> cuando nadie lo asume. Se comporta de manera <strong>proactiva</strong>, no espera a que los problemas aparezcan.</p><p>En este nivel se poseen habilidades de <strong>comunicación</strong> sólidas, se comprende el <strong>valor del negocio</strong> y se desarrollan buenas <strong>habilidades interpersonales</strong>. Además, asume el liderazgo cuando nadie más lo hace y se comporta de manera proactiva, anticipándose a los problemas en lugar de esperar a que aparezcan.</p><p>Es fundamental que los managers estén muy cerca de estos perfiles y promuevan los valores y la cultura de la empresa. Deben proporcionar los mecanismos adecuados para que la comunicación fluya y estar atentos a sus preocupaciones.</p><p>Es importante evitar a toda costa que el “senior” se convierta en el<strong> héroe del equipo</strong>, ya que la responsabilidad debe ser compartida por todos los miembros del equipo.</p><h3>Parte 2. Arquetipos de Engineering Manager</h3><p><em>¿Y ahora qué?</em> Has alcanzado el nivel senior, te interesa el management y te han ascendido/promocionado (esto no es del todo cierto, es un cambio de rol).</p><p>Sin embargo, el rol y la etiqueta de “manager” pueden variar significativamente según la empresa. Asumes tu nuevo puesto, pero te surgen miles de preguntas:</p><ul><li>¿Cuales son ahora tus responsabilidades?</li><li>¿Cómo sabes si lo harás bien?</li><li>¿Estás cubriendo todas las necesidades?</li><li>¿Qué necesita el equipo?</li><li>¿Cómo sabré enfrentarme a un nuevo problema?</li><li>¿Cómo me adelanto a los conflictos?</li><li>¿Tengo que seguir programando?</li></ul><p><strong>¿Y qué etiqueta deberías poner en tu perfil de LinkedIn? </strong>Identificar qué nombre darle a tu rol e identificar tus responsabilidades puede ser complicado y depende de cada empresa. Te invito a visitar el sitio web <a href="https://progression.fyi/"><strong>progression.fyi</strong></a>, donde muchas compañías comparten públicamente los nombres de sus roles, los diferentes niveles y los caminos de carrera.</p><p>Los<strong> career path</strong> proporcionan transparencia y visibilidad sobre tu plan de desarrollo profesional, así como claridad sobre lo que se espera de ti tanto en tu rol actual como en el futuro. También pueden ayudarte a crecer y avanzar dentro de una empresa, brindando un propósito, significado y una sensación de pertenencia.</p><p>Además, están surgiendo <strong>frameworks</strong> para definir habilidades y diferentes niveles de responsabilidad para los managers. Esto es una forma interesante de medir y establecer las expectativas para cada rol. Ver el ejemplo de <a href="https://www.engineeringladders.com/">https://www.engineeringladders.com/</a></p><p>Entre los atributos importantes a considerar para evaluar el desempeño y el nivel de <em>seniority</em> en el equipo se encuentran:</p><ul><li>Experiencia en la industria.</li><li>Conocimiento técnico.</li><li>Mentoría.</li><li>Influencia.</li><li>Construcción de consenso.</li><li>Resolución de conflictos.</li><li>Comunicación.</li><li>Eficiencia.</li><li>Responsabilidad.</li><li>Planificación y estrategia.</li><li>Presupuesto.</li><li>Motivación.</li><li>Autenticidad.</li></ul><p>Estos atributos son esenciales para medir y evaluar el rendimiento y la seniority de los equipos y seguir evolucionando en los puntos en los que no destaquemos.</p><p><strong>Los arquetipos de Patrick Kua</strong></p><p>Esta sección está inspirada en el artículo <a href="https://www.patkua.com/blog/5-engineering-manager-archetypes/"><strong>“5 engineering manager archetypes”</strong></a> de Patrick Kua, en el cual define diferentes tipos de <em>Engineering Managers</em> según sus responsabilidades dentro de un equipo.</p><p><strong>Patrick Kua</strong> es un líder tecnológico que descubrí mientras leía su libro “<a href="https://www.amazon.com/Talking-Tech-Leads-Novices-Practitioners/dp/150581748X">Talking with Tech Leads: From Novices to Practitioners</a>”. Ofrece un material valioso y presenta puntos clave de su libro y en conferencias como esta: <a href="https://www.youtube.com/watch?v=F81W-JcRgXM"><strong>Enlace a la conferencia</strong></a>.</p><p>Las responsabilidades de un manager dentro del equipo pueden variar significativamente según <strong>la madurez de la compañía, el tamaño del equipo y su estructura.</strong></p><p>Podemos pensar en estos arquetipos como <strong>patrones de diseño</strong> en el mundo del software, es decir, estructuras comunes que se pueden encontrar una y otra vez. Cada arquetipo ofrece una combinación diferente de fortalezas que resultan útiles en distintas circunstancias.</p><ul><li>El <strong>“Tech Lead EM”</strong> es un líder técnico que también asume el rol de un “Engineering Manager” (EM). Se encarga de guiar la dirección técnica de un producto, escribir código y liderar a los miembros del equipo. Además, se enfoca en la arquitectura y la deuda técnica, creando un equipo de alto rendimiento.</li><li>El <strong>“Team Lead EM”</strong> es una combinación de líder técnico y líder de equipo. Mientras que el Tech Lead se enfoca en aspectos técnicos, el líder de equipo se concentra en el crecimiento y la gestión de personas. Pueden trabajar juntos para equilibrar estos roles y crear un equipo sólido.</li><li>El <strong>“Delivery Manager EM”</strong> se encuentra en organizaciones orientadas a proyectos o fechas. Se enfoca en cumplir plazos y manejar múltiples partes interesadas. A menudo, tiene experiencia en gestión de proyectos y puede delegar tareas técnicas o de equipo.</li><li>El <strong>“Product Manager EM” </strong>trabaja junto a un manager de producto para decidir qué y cómo desarrollarlo. Se centran en el “cómo” y pueden especializarse en productos técnicos. Pasan tiempo con usuarios finales y partes interesadas para refinar el <em>roadmap</em> producto.</li><li>El <strong>“Leads of Leads EM”</strong> lidera grupos más grandes, de 9 a 30 personas. Coordina equipos y estructuras de soporte, trabajando estrechamente con equipos de negocios y productos para maximizar la efectividad. Puede ser una evolución de otro arquetipo y a menudo se le llama <em>“Head of Engeneering</em>” o similar.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mR80bpUzBCoXvUeHiPxSSA.png" /></figure><p>En resumen, estos arquetipos describen diferentes roles de liderazgo en ingeniería y gestión de equipos, cada uno con un enfoque particular en aspectos técnicos, de equipo o de entrega, según las necesidades de la organización y el tamaño del equipo.</p><p>Es esencial reflexionar sobre la necesidad real de la compañía y del equipo mas allá del nombre del rol y estar dispuesto a adaptarse, alineando siempre las expectativas con lo que se necesita lograr. La flexibilidad y la adaptabilidad son cualidades valiosas en el liderazgo de equipos.</p><h3>Parte 3. Herramientas</h3><p>Y para terminar, hablemos de herramientas. Herramientas que pueden ser útiles en tu camino como manager, y que desearía haber conocido cuando asumí este tipo de rol por primera vez.</p><p>Si bien tenemos a nuestra disposición miles de plataformas, cursos y artículos sobre cómo trabajar con tecnología, a menudo carecemos de suficiente formación y conocimiento compartido sobre cómo liderar.</p><h4>Architecture Decision Records</h4><p>Un registro de decisión arquitectónica (ADR) es un documento que describe una elección que hace el equipo sobre un aspecto importante de la arquitectura de software que planean construir. Cada ADR describe la decisión arquitectónica, su contexto y sus consecuencias. Los ADR tienen estados y, por lo tanto, siguen un ciclo de vida. Para ver un ejemplo de ADR, consulte el apéndice.</p><p>El proceso ADR genera una colección de registros de decisiones arquitectónicas. Esta colección crea el registro de decisiones. El registro de decisiones proporciona el contexto del proyecto, así como información detallada sobre la implementación y el diseño. Los miembros del proyecto hojean los titulares de cada ADR para obtener una visión general del contexto del proyecto. Leen los ADR para profundizar en las implementaciones de proyectos y las opciones de diseño.</p><p>Cuando el equipo acepta un ADR, se vuelve inmutable. Si los nuevos conocimientos requieren una decisión diferente, el equipo propone una nueva ADR. Cuando el equipo acepta el nuevo ADR, reemplaza el ADR anterior.</p><p>La generación de consenso utilizando Architecture Decision Records (ADR) es una práctica importante en el proceso de toma de decisiones arquitectónicas en el desarrollo de software. Los ADR son un mecanismo que ayuda a documentar y comunicar decisiones críticas sobre la arquitectura de un sistema, y también pueden servir como una herramienta efectiva para lograr el consenso entre los miembros del equipo de desarrollo.</p><h4>Delegation Board</h4><p>Es una herramienta que ayuda a asignar tareas y responsabilidades de manera equitativa entre los miembros del equipo. La matriz de delegación permite identificar las fortalezas y habilidades de cada persona y asignarles tareas en función de sus capacidades, promoviendo así un equilibrio en la carga de trabajo y el crecimiento profesional.</p><p>También ayuda a establecer expectativas claras. Te ayuda a asegurarte de que las expectativas para cada persona estén claras. Define claramente qué se espera de cada miembro del equipo en términos de resultados, responsabilidad y cualquier otro detalle relevante.</p><h4>Kudo box</h4><p>Es un reconocimiento escrito y público a un compañero por algo que ha aportado al equipo.</p><p>Un Kudo no solo se otorga de arriba hacia abajo, sino de igual a igual y de abajo hacia arriba. En todos los departamentos y organizaciones, cualquiera puede reconocer el trabajo de otra persona. Es una forma de romper las limitaciones jerárquicas y alentar a todos a ofrecer comentarios positivos instantáneos.</p><p>Los incentivos aseguran que las personas dejen de hacer cosas solo por el placer de trabajar, pero las recompensas que desencadenan una motivación intrínseca son más efectivas, más sostenibles y, por lo general, cuestan menos dinero.</p><h4>Mood chart</h4><p>Los gráficos de estado de ánimo, también conocidos como gráficos emocionales o de sentimientos, pueden ser herramientas valiosas para que los equipos de desarrollo de software realicen un seguimiento y comprendan el estado emocional de los miembros del equipo a lo largo del tiempo. Estos gráficos ayudan a los equipos a identificar patrones, abordar problemas y mejorar la colaboración y la productividad. Así es como se pueden usar los gráficos de estado de ánimo en los equipos de desarrollo de software:</p><p>Con el tiempo, estos datos se pueden agregar y visualizar para identificar tendencias en las emociones de los miembros del equipo. Si la mayoría del equipo constantemente reporta estados de ánimo bajos, podría indicar problemas subyacentes que deben abordarse.</p><p>La incorporación de gráficos de estado de ánimo en los equipos de desarrollo de software puede ayudar a crear un entorno de trabajo más empático y solidario, lo que en última instancia conduce a una mejor colaboración, una mejor moral y una mayor productividad.</p><p>Sin embargo, es fundamental complementar los datos del gráfico de estado de ánimo con otras formas de comunicación y retroalimentación para obtener una comprensión integral de la dinámica del equipo y las necesidades individuales.</p><h3><strong>Conclusión</strong></h3><p>Es esencial reconocer que liderar equipos es una habilidad que se puede aprender y mejorar con el tiempo. Al invertir en tu desarrollo como líder, podrás enfrentar los desafíos de manera efectiva y brindar un ambiente de trabajo más productivo y satisfactorio para tu equipo. Conocer a tu equipo es esencial y tu capacidad de adaptarte a las necesidades y características de tu compañía harán que el camino sea mas fácil.</p><p>Aquí dejo el video de la charla que se grabó en El Cable (Andalucia Open Future)👇</p><p><a href="https://www.youtube.com/watch?v=iPsMv2f7hpY">https://www.youtube.com/watch?v=iPsMv2f7hpY</a></p><h3>Bibliografía</h3><p><a href="https://apiumhub.com/es/tech-blog-barcelona/lecciones-aprendidas-en-arquitectura-de-software-entrevista-patrick-kua/">https://apiumhub.com/es/tech-blog-barcelona/lecciones-aprendidas-en-arquitectura-de-software-entrevista-patrick-kua/</a></p><p><a href="https://www.patkua.com/blog/the-definition-of-a-tech-lead/">https://www.patkua.com/blog/the-definition-of-a-tech-lead/</a></p><p><a href="https://www.patkua.com/blog/5-engineering-manager-archetypes/#:~:text=View%20the%20role%20of%20the,the%20Lead%20of%20Leads%20EM">https://www.patkua.com/blog/5-engineering-manager-archetypes/#:~:text=View%20the%20role%20of%20the,the%20Lead%20of%20Leads%20EM</a>.</p><p><a href="https://medium.com/@kurtisnusbaum/what-makes-a-senior-software-engineer-b65c88c539c">https://medium.com/@kurtisnusbaum/what-makes-a-senior-software-engineer-b65c88c539c</a></p><p><a href="https://web.archive.org/web/20181228052103/https://www.stackoverflowbusiness.com/blog/what-defines-a-senior-developer">https://web.archive.org/web/20181228052103/https://www.stackoverflowbusiness.com/blog/what-defines-a-senior-developer</a></p><p><a href="https://www.altexsoft.com/blog/business/software-engineer-qualification-levels-junior-middle-and-senior/">https://www.altexsoft.com/blog/business/software-engineer-qualification-levels-junior-middle-and-senior/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=922d01f3c08c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Emulando una cola SQS en una aplicación NestJS]]></title>
            <link>https://adrianalonsodev.medium.com/emulando-una-cola-sqs-en-una-aplicaci%C3%B3n-nestjs-8f23203259ac?source=rss-f754bd174f5------2</link>
            <guid isPermaLink="false">https://medium.com/p/8f23203259ac</guid>
            <category><![CDATA[sqs]]></category>
            <category><![CDATA[message-queue]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[pub-sub]]></category>
            <category><![CDATA[consumer]]></category>
            <dc:creator><![CDATA[Adrián Alonso]]></dc:creator>
            <pubDate>Tue, 19 Jan 2021 18:11:30 GMT</pubDate>
            <atom:updated>2021-01-22T16:35:00.647Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*yNldBVqxrK3THRhI.jpg" /></figure><p>La complejidad y requisitos de las aplicaciones de hoy en día nos imponen <strong>nuevos retos</strong> tratando de testearlas en nuestros entornos locales. Los mayores desafíos nos los encontramos cuando queremos probar nuestro <em>software</em> de manera <em>end to end</em>, sobre todo si la infraestructura se compone de servicios en la nube. Sin embargo, la mayor parte de las veces <a href="https://adrianalonso.es/devops/desplegando-una-aplicacion-nodejs-dockerizada-en-clouding-io/"><strong>docker</strong></a> entra a nuestro rescate, ofreciéndonos imágenes construidas que nos pueden ayudar a emular el comportamiento de estos servicios.</p><p>Específicamente, para trabajar con AWS podemos encontrar soluciones completas como <strong>Localstack</strong> ( <a href="https://localstack.cloud/">https://localstack.cloud/</a>). Este servicio emula gran parte de los servicios de <strong>AWS</strong> exponiendo <em>endpoints</em> contra los que podemos emular nuestra infraestructura, la automatización de esta con <strong>Terraform</strong> o poder realizar pruebas de nuestro <em>software </em><strong><em>end to end</em></strong> en nuestro proceso de integración continua sin depender del proveedor <em>cloud</em>.</p><p>En este post, hablaremos de una solución más ligera para emular el comportamiento de una cola <strong>AWS SQS</strong> totalmente compatible con nuestro <em>consumer</em> construido en <strong>Typescript</strong> y dentro del contexto de una aplicación <strong>NestJS</strong>.</p><h3>¿Qué es una cola SQS?</h3><p><strong>SQS</strong>, acrónimo de<em> Simple Queue Service</em>, es un servicio de AWS para gestionar colas de mensajes. Este tipo de servicios sirve generalmente para desacoplar nuestro <em>software</em>, procesar mensajes de manera asíncrona y escalar nuestro <em>software</em> de manera independiente. El estilo de mensajería se basa en el patrón <strong>PubSub</strong>, en el cual un <em>publisher</em> deja mensajes en un <em>topic</em>, sin conocer al destinatario. Posteriormente unos <em>consumers/subscribers</em> leen de esas colas procesando el mensaje y eliminándolo de estas.</p><p>SQS es la solución que nos ofrece AWS, pero tenemos servicios de idéntico comportamiento en <strong>Azure</strong> con <strong>Azure Queue Storage</strong> o en <strong>Google Cloud Platform</strong> con<strong> Cloud PubSub</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/694/0*kev5X5nVr_qqDRba.png" /></figure><h3>Emulando la cola SQS</h3><p>Para emular nuestra cola sin depender de AWS vamos a usar <strong>ElasticMQ</strong>. ElasticMQ es un sistema de colas ligero que almacena los mensajes temporalmente en memoria.</p><p>ElasticMQ sigue la semántica de AWS SQS, y la gran ventaja de esto es que podemos utilizar el SDK de AWS contra este servicio. Los mensajes en SQS se reciben sondeando la cola. Cuando se recibe un mensaje, se bloquea durante un período de tiempo específico (Si el mensaje no se elimina durante ese tiempo, volverá a estar disponible para su entrega. <em>visibilityTimeout</em>).</p><p>El enfoque en este tipo de colas es asegurarse de que los mensajes se entreguen a los destinatarios. Sin embargo, puede suceder que un mensaje se entregue dos veces (por ejemplo, sí un Es por eso que debemos cumplir con el principio de <em>consumer</em> muere después de recibir un mensaje y procesarlo, pero antes de eliminarlo). <strong>idempotencia,</strong> es decir, que no se vean afectadas negativamente el <em>consumer</em> procesa el mismo mensaje más de una vez.</p><p>A continuación, se muestra cómo quedaría nuestro docker-compose.yml donde se incluye el servicio SQS utilizando una imagen dockerizada (https://github.com/roribio/alpine-sqs) conectado con el servicio node que levanta nuestra api.</p><pre>version: &quot;3.4&quot;<br>services:<br>  api:<br>    build:<br>      context: .<br>      dockerfile: Dockerfile.dev<br>    environment:<br>      AWS_ACCESS_KEY_ID: ${AWS_ACCESS_KEY_ID}<br>      AWS_SECRET_ACCESS_KEY:${AWS_SECRET_ACCESS_KEY}<br>      AWS_SQS_REGION: eu-west-2<br>      AWS_SQS_ENDPOINT: &quot;<a href="http://sqs:9324/">http://sqs:9324</a>&quot;<br>      AWS_SQS_QUEUE_NAME: service-queue<br>    ports:<br>      - &quot;8080:8080&quot;<br>    depends_on:<br>      - sqs<br>  sqs:<br>    image: roribio16/alpine-sqs<br>    ports:<br>      - &quot;9324:9324&quot;<br>      - &quot;9325:9325&quot;<br>    volumes:<br>      - ./infra/sqs/elasticmq.conf:/opt/config/elasticmq.conf</pre><p>Como se puede ver, en la imagen alpine-sqs expone dos puertos 9324 y 9325 . El primero es usado como <em>endpoint</em> para consumirlo http://sqs:9324 y el segundo expone una interfaz web para depurar los mensajes que llegan a la cola.</p><p>Además, incluiremos un fichero de configuración mapeando en nuestro volumen el fichero /opt/config/elasticmq.conf donde configuraremos nuestras colas y su comportamiento:</p><pre>include classpath(&quot;application.conf&quot;)                                            <br>                                           <br>node-address {                                              <br>   protocol = http                                              <br>   host = &quot;*&quot;                                                <br>   port = 9324                                              <br>   context-path = &quot;&quot;                                            <br>}                                            <br>                                            <br>rest-sqs {                                                <br>   enabled = true                                              <br>   bind-port = 9324                                            <br>   bind-hostname = &quot;0.0.0.0&quot;                                      <br>   // Possible values: relaxed, strict                          <br>   sqs-limits = strict                                            <br>}                                            <br>                                            <br>queues {                                                <br>   default {                               <br>     defaultVisibilityTimeout = 10 seconds                     <br>     delay = 5 seconds                           <br>     receiveMessageWait = 0 seconds                               <br>   }                                                <br>   service-queue {                          <br>     defaultVisibilityTimeout = 10 seconds                    <br>     delay = 5 seconds                           <br>     receiveMessageWait = 0 seconds                               <br>   }                                            <br>}</pre><p>En este fichero definimos las colas y sus características como el tiempo de visibilidad, el <em>delay</em> o el tiempo de espera. Una vez levantado podemos ver a través de la interfaz 9325 los mensajes que llegan a la cola para poder depurar correctamente el formato de los mensajes y la cantidad.</p><p>Para mandar un mensaje a la cola podemos utilizar el CLI de AWS, indicando el <em>endpoint</em>, la cola y el cuerpo del mensaje:</p><pre>aws --endpoint-url <a href="http://localhost:9324/">http://localhost:9324</a> sqs send-message --queue-url <a href="http://localhost:9324/queue/service-queue">http://localhost:9324/queue/service-queue</a> --message-body &quot;&quot;</pre><h3>Implementando en consumer en NestJS</h3><p>Una vez tenemos la cola lista, debemos de implementar un consumer para leer y procesar los mensajes de esta cola. NestJS tiene una solución para implementar consumers de mensajes con AMQP ( <a href="https://docs.nestjs.com/microservices/rabbitmq">https://docs.nestjs.com/microservices/rabbitmq</a>), sin embargo no ofrece un interfaz para manejar colas SQS. Por ello debemos de hacer uso de la api del SDK de AWS de Node para implementar el consumo de mensajes haciendo uso de una estrategia de <strong>short polling</strong>.</p><p>Existen algunas soluciones no oficiales de nest como <a href="https://github.com/yannkaiser/nestjs-aws-sqs">https://github.com/yannkaiser/nestjs-aws-sqs</a> o <a href="https://github.com/aiandev/sqs-consumer-nestjs">https://github.com/aiandev/sqs-consumer-nestjs</a> que podrían ayudarnos. Sin embargo, se decidió implementar una solución totalmente independiente. Este es el código de ejemplo de una clase abstracta con la funcionalidad necesaria para leer mensajes de una cola SQS:</p><pre>import { Logger, OnApplicationBootstrap, OnApplicationShutdown } from &#39;<a href="http://twitter.com/nestjs/common">@nestjs/common</a>&#39;<br>import { AWSError, SQS } from &#39;aws-sdk&#39;<br>import { PromiseResult } from &#39;aws-sdk/lib/request&#39;</pre><pre>export default abstract class SQSQueue implements OnApplicationBootstrap, OnApplicationShutdown {<br>  protected readonly logger = new Logger(SQSQueue.name, true)<br>  protected queueUrl: string<br>  protected polling = false<br>  protected timeoutRef: NodeJS.Timeout = null<br>  protected service: SQS</pre><pre>constructor(<br>    protected readonly queueName: string,<br>    protected readonly region: string,<br>    protected readonly timeout = 100</pre><pre>) {<br>    this.service = new SQS({ endpoint: process.env.AWS_SQS_ENDPOINT, region })<br>  }</pre><pre>async onApplicationBootstrap(): Promise&lt;void&gt; {<br>    this.logger.log(`Initiating queue consumer with name ${this.queueName}`)</pre><pre>this.polling = true<br>    this.queueUrl = (<br>      await this.service<br>        .getQueueUrl({<br>          QueueName: this.queueName,<br>        })<br>        .promise()<br>    ).QueueUrl</pre><pre>this.logger.log(`Reading messages from ${this.queueUrl}`)</pre><pre>this.timeoutRef = setTimeout(async () =&gt; this.poll(), this.timeout)</pre><pre>}</pre><pre>onApplicationShutdown(): void {<br>    this.polling = false<br>    clearTimeout(this.timeoutRef)<br>  }</pre><pre>public async poll(): Promise&lt;void&gt; {<br>    const result: SQS.ReceiveMessageResult = await this.receiveMessage()<br>    try {<br>      await this.handleSQSResponse(result)<br>    } catch (err) {<br>      Logger.error(err)<br>    }</pre><pre>if (this.polling) this.timeoutRef = setTimeout(() =&gt;; this.poll(), this.timeout)<br>  }</pre><pre>private async handleSQSResponse(result: SQS.ReceiveMessageResult): Promise&lt;void&gt;; {<br>    if (!result.Messages || result.Messages.length === 0) return<br>    await Promise.all(result.Messages.map(this.handleMessage.bind(this)))<br>  }</pre><pre>private async receiveMessage(): Promise&lt;PromiseResult&lt;SQS.ReceiveMessageResult, AWSError&gt;&gt;; {<br>    return this.service<br>      .receiveMessage({<br>        QueueUrl: this.queueUrl,<br>      })<br>      .promise()<br>  }</pre><pre>protected async handleMessage(message: SQS.Message): Promise&lt;void&gt;; {<br>    await this.handle(message)</pre><pre>await this.service<br>      .deleteMessage({<br>        QueueUrl: this.queueUrl,<br>        ReceiptHandle: message.ReceiptHandle,<br>      })<br>      .promise()<br>  }</pre><pre>protected abstract async handle(message: SQS.Message): Promis&lt;void&gt;;</pre><pre>}</pre><p>OnApplicationBootstrap y OnApplicationShutdown son dos interfaces que nos permiten engancharnos a los evento lanzados cuando la aplicación se termina de levantar y cuando se apaga el servicio. Estas interfaces las utilizamos para arrancar el polling cuando nuestra aplicación esté levantada. Estas interfaces nos obligan a implementar los métodos async onApplicationBootstrap():Promise&lt;void&gt;y OnApplicationShutdown():void donde arrancará y finalizará la lectura de nuestra cola. Tras recibir los mensajes almacenados en la cola se ejecutará el método handleMessage.</p><p>El método handleMessage se encarga de recibir el mensaje de la cola, llamar al manejador abstracto que se encarga de manejar el tipo de mensaje, ejecutar la lógica del manejador y eliminar el mensaje para no volver a ser recibido..</p><p>Para implementar nuestra lógica, crearemos una nueva clase que extienda de SQSQueue e implementaremos la lógica adecuada implementando el método handle . Un ejemplo de implementación concreta de un consumer puede ser el siguiente:</p><pre>import { Inject, Logger } from &#39;<a href="http://twitter.com/nestjs/common">@nestjs/common</a>&#39;<br>import { SQS } from &#39;aws-sdk&#39;<br>import SQSQueue from &#39;./sqs/sqs.queue&#39;</pre><pre>export default class CallbackSQS extends SQSQueue {</pre><pre>async handle(message: SQS.Message): Promise&lt;void&gt; {<br>    this.logger.log(`Handling message ${message.MessageId} with body : ${message.Body}`)<br>    // your code here<br>  }<br>}</pre><p>Dentro del contexto de una aplicación NestJS, esta clase CallbackSQS se establecería como un provider importado por el módulo correspondiente.</p><h3>Conclusión</h3><p>Como hemos visto a lo largo del artículo, es muy<strong> sencillo emular comportamientos</strong> de servicios en la nube apoyándonos en la cantidad de imágenes que podemos encontrar en . Es esencial, que podamos desarrollar en nuestros entornos locales sin depender de nuestra nube, pudiendo realizar pruebas completas de nuestro software. Esto nos dará la flexibilidad y libertad de poder trabajar y asegurar el adecuado comportamiento y la calidad necesaria para confiar en nuestro software.</p><h3>Recursos</h3><p><a href="https://medium.com/@ashwanihere/managing-sqs-consumers-in-a-nodejs-application-3c1466d00077">Managing SQS Consumers in a NodeJS Application</a></p><p><a href="https://medium.com/better-programming/how-to-emulate-aws-sqs-for-development-in-dockerized-ruby-on-rails-app-c0c16aadb84c">https://medium.com/better-programming/how-to-emulate-aws-sqs-for-development-in-dockerized-ruby-on-rails-app-c0c16aadb84c</a></p><p><em>Originally published at </em><a href="https://adrianalonso.es/desarrollo-web/apis/emulando-cola-sqs-aplicacion-nestjs/"><em>https://adrianalonso.es</em></a><em> on January 19, 2021.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8f23203259ac" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Renderizando la web en 2020]]></title>
            <link>https://adrianalonsodev.medium.com/renderizando-la-web-en-2020-ed96a6d70748?source=rss-f754bd174f5------2</link>
            <guid isPermaLink="false">https://medium.com/p/ed96a6d70748</guid>
            <category><![CDATA[meetup]]></category>
            <category><![CDATA[jamstack]]></category>
            <category><![CDATA[nextjs]]></category>
            <category><![CDATA[rendering]]></category>
            <category><![CDATA[front-end-development]]></category>
            <dc:creator><![CDATA[Adrián Alonso]]></dc:creator>
            <pubDate>Mon, 07 Dec 2020 11:54:29 GMT</pubDate>
            <atom:updated>2020-12-07T11:54:29.385Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*cxeahL5Bi314AtHV.jpeg" /></figure><p>Como desarrolladores de software, nos solemos enfrentar con decisiones en nuestros proyectos que afectarán a toda la arquitectura de estos de una u otra manera. Una de las decisiones principales que deben de tomarse en el planteamiento de un proyecto web es dónde implementar la lógica y el renderizado del frontend. Esta decisión puede no ser tan evidente a veces y debemos analizar nuestro escenario para encontrar la estrategia más adecuada para renderizar nuestra web.</p><p>En el último año, ha cogido gran fuerza la estrategia <strong>JAMstack</strong> (<a href="https://jamstack.org/">https://jamstack.org/</a>). Generalmente esta aproximación contempla una web únicamente desarrollada con JavaScript, APIs y lenguaje de marcado. Estos sitios suelen construirse con generadores de sitios estáticos como pueden ser <em>Jekyll, Hugo, Nuxt, Next, Gatsby</em>, entre otros.</p><p>Lo que todos estos sites tienen en común es que no dependen de un backend que está renderizando la web en cada <em>request</em>, liberándose así de costes de infraestructura. Otra característica que representa a estos sites JAMStack es, generalmente, la utilización de <a href="https://adrianalonso.es/desarrollo-web/cms/que-es-headless-cms-y-descubriendo-ez-platform/"><strong><em>Headless CMS</em></strong></a><strong><em> </em></strong>(<a href="https://headlesscms.org/">https://headlesscms.org/</a>) para recuperar la fuente de datos estáticos en el momento de build.</p><p>Para comprender mejor el tipo de arquitectura que podemos elegir cuando tomamos este tipo de decisión, necesitamos tener un fuerte conocimiento de cada enfoque, identificar cuáles son sus ventajas y desventajas y trabajar con una terminología coherente para identificarlos correctamente.</p><p>Las diferencias entre cada uno de estos enfoques de renderizando ayudan a tomar la decisión acertada para tu arquitectura, sobre todo vista desde el punto de vista del performance y del coste de la infraestructura. Descubriremos cómo elegir la mejor estrategia desde un modelo tradicional como SSR hasta un modelo más innovador como CSR.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FonZuGPwc8fg&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DonZuGPwc8fg&amp;image=http%3A%2F%2Fi.ytimg.com%2Fvi%2FonZuGPwc8fg%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/7971966f701d032a2b58edc07d8d0049/href">https://medium.com/media/7971966f701d032a2b58edc07d8d0049/href</a></iframe><h3>Estrategias de renderizado web</h3><p>Para ello, lo primero que necesitamos entender son las siglas/nomenclaturas que utilizamos para identificar inequívocamente cada estrategia de renderizado:</p><ul><li><strong>SSR: Server-Side Rendering</strong>: se renderiza el HTML del cliente totalmente en el lado servidor. Esta aproximación suele ser el modelo de webs tradicionales.</li><li><strong>CSR: Client-Side Rendering</strong>: se renderiza la aplicación completamente en el navegador haciendo uso de Javascript y la gestión del DOM. Comúnmente conocidas como Single Page Applications.</li><li><strong>Rehydration</strong>: esta estrategia es un híbrido de las dos anteriores en el que se aprovecha el HTML y los datos renderizados desde el lado servidor, hidratándose con una aplicación javascript que se monta encima de esta.</li><li><strong>Prerendering</strong>: en esta estrategia se renderiza la web en tiempo de construcción creando un artefacto que puede servirse de una manera totalmente estática.</li></ul><h3>Glosario de métricas sobre el performance</h3><p>Existen una serie de métricas de performance que son muy importantes para analizar cada una de las estrategias de renderizado anteriores y que vamos a ver cómo se relacionan con cada uno de ellos.</p><ul><li><strong>TTFB: Time to First Byte</strong>. El tiempo entre que pinchas un enlace y el primer byte de contenido llega al navegador.</li><li><strong>FP: First Paint</strong>. Es el tiempo que tarda en pintarse el primer píxel que haga visible la web al usuario.</li><li><strong>FCP: First Contentful Paint.</strong> Es el tiempo que tarda en ser visible el contenido que hemos solicitado.</li><li><strong>TTI: Time To Interactive</strong>. Es el tiempo que tarda una página en ser interactiva.</li></ul><h3>SSR: Server Side Rendering</h3><p><strong>Server Side Rendering </strong>es una estrategia en la que se genera el HTML completo para una página en el servidor en respuesta a una url y su navegación. Esto evita viajes de ida y vuelta adicionales para la obtención de datos y la creación de plantillas en el cliente, ya que se maneja antes de que el navegador obtenga una respuesta. Suele ser el modelo de webs tradicionales y el renderizado de CMSs clásicos como WordPress o Drupal</p><p>Esta estrategia produce un<em> FP (First Paint)</em> y un <em>FCP (First Contentful Paint)</em> muy rápido. La ejecución de la lógica de página y la representación en el servidor hace posible evitar el envío de mucho <em>JavaScript</em> al cliente, lo que ayuda a lograr un <em>tiempo de interacción (TTI)</em> rápido, ya que no requieren de tanta interacción, aunque no siempre es así.</p><p>Con la respuesta del servidor en realidad solo está enviando texto y enlaces al navegador del usuario, sin embargo la construcción de este estado global lo convierte a veces en un proceso pesado de renderización que perjudica radicalmente al Time to First Byte.</p><p>Estos problemas de rendimiento se suelen solventar con algún tipo de software de aceleramiento HTTP como puede ser Varnish o Nginx. También algunos frameworks dan soluciones para implementar una implementación caché HTTP como puede ser Symfony con su componente <em>Http Cache Component</em>. (<a href="https://symfony.com/doc/current/http_cache.html">https://symfony.com/doc/current/http_cache.html</a>)</p><h3>CSR: Client Side Rendering</h3><p><strong>Client Side Rendering</strong> es una estrategia en la que se genera el HTML de las páginas completamente en el lado cliente apoyándose en JavaScript. Toda la responsabilidad sobre la obtención de datos, la creación de templates o el enrutamiento se llevan al lado cliente en lugar del servidor. Estas aplicaciones suelen ser comúnmente conocidas como<a href="https://adrianalonso.es/desarrollo-web/single-page-app-vs-multi-page-app/"> Single Page Applications (SPA)</a> y su origen nace a raíz del auge de frameworks Javascript como <strong>React, </strong><a href="https://adrianalonso.es/meetups/review-del-workshop-introduccion-angular/"><strong>Angular</strong></a><strong> o </strong><a href="https://adrianalonso.es/desarrollo-web/por-que-vue-js-esta-ganando-tanta-popularidad/"><strong>Vue</strong></a>.</p><p>CSR puede tener algunas desventajas en la carga para dispositivos móviles, ya que estas aplicaciones requieren de la construcción en el lado cliente por lo que hace un uso intensivo del navegador. La cantidad de Javascript tiende a crecer a medida que crece la aplicación, por lo que cuanto más grande es nuestra aplicación más lenta se puede volver. Sin embargo, para solventar estos problemas podemos considerar estrategias como <em>code-splitting o lazy load:</em> partiendo nuestro build de tal manera que “servimos solo lo que necesita, cuando se necesita”.</p><p>Este tipo de estrategias son ideales para aplicaciones privadas como paneles de administración, aplicaciones corporativas, intranets… donde la necesidad es que la interacción sea buena y fluida. Para mejorar el rendimiento se apoyan en soluciones de caché en el lado cliente como <strong>Local Storage y Service Workers</strong>, para ofrecer una buena experiencia de usuario.</p><p>Estas soluciones suelen tener un rápido <em>TTFB</em>, ya que sirven un HTML delgado y un Javascript generalmente cacheado por el navegador que construye completamente nuestra aplicación. Esta construcción a veces genera un <em>TTI</em> alto, ya que se requiere de un tiempo de carga inicial que puede demorarse unos segundos, hasta que nuestra aplicación esté lista y con los datos necesarios para arrancar.</p><h3>Rehidratación: Entre el CSR y el SSR</h3><p>La rehidratación es una técnica de renderizado híbrido, la cual intenta posicionarse en el medio de SSR y CSR, aprovechando lo mejor de cada mundo.</p><p>Las peticiones son manejadas por una capa servidor que genera el HTML del servidor como en el modelo SSR, obteniendo las ventajas de una primera renderización rápida y completa de la web, satisfaciendo requisitos SEO. Posteriormente en el lado cliente, la capa Javascript se encarga de recuperar el renderizado y los datos siendo a partir de ese momento el responsable del renderizado con una técnica que se conoce como rehidratación.</p><p>Algunos frameworks y herramientas modernas hacen posible esta estrategia que permite renderizar la misma aplicación tanto en el lado cliente como en el lado servidor. Los desarrolladores de React pueden usar renderToString() o soluciones creadas encima, como <strong>Next.js</strong> para la representación del servidor. Los desarrolladores de Vue también cuentan con su homólogo Nuxt, y Angular cuenta con su tecnología Universal.</p><p>El principal inconveniente de esta estrategia es que puede tener un impacto negativo significativo en TTI. A pesar de mejorar considerablemente el FP, este tipo de renderizado a menudo se ve engañoso ya que parece cargado e interactivo, pero en realidad no puede responder a las entradas de eventos hasta que se ejecuta completamente el javascript del lado del cliente. Este proceso puede llevar algunos segundos en dispositivos móviles.</p><p>Sin embargo, aprovechando estrategias como la hidratación progresiva, que permite rehidratar componentes aprovechando la API de <em>Intersection Observer</em>, se puede optimizar y paliar bastante los problemas en el tiempo de interacción.</p><h3>Prerendering</h3><p>El <strong>prerendering o renderizad</strong>o estático ocurre en la etapa de build. Esta estrategia se encarga de producir un archivo HTML separado para cada URL en el momento de construcción del site. Estos HTML pregenerados, se pueden alojar en CDNs para aprovechar el almacenamiento en caché y servir a gran velocidad una versión completa del website, sin depender de una infraestructura pesada.</p><p>Esta estrategia ofrece un FP y FPC muy rápido, lo que ha provocado una gran acogida, estos tiempos son beneficiosos para la experiencia de usuario y el SEO. A semejanza de soluciones como SSR, también logra alcanzar un tiempo de carga muy rápido (TTFB), ya que el HTML de una página no tiene que generarse al vuelo, si no que ya se encuentra preconstruido. En este escenario el TTI es variable y depende de la cantidad de JS del lado del cliente</p><p>Existen multitud de soluciones para el renderizado estático que ha aparecido en los últimos años. Uno de los más conocidos es <em>GatsbyJS</em>, el cual permite sentir a los desarrolladores que la aplicación se procesa dinámicamente en lugar de generarse como un paso de compilación. Sin embargo, existen multitud de soluciones como NextJS, Hugo o Jekyll que también ofrecen implementar este tipo de sites.</p><p>Una de las desventajas del renderizado estático es que se deben generar archivos HTML individuales para cada URL. Esto puede ser a veces un desafío o incluso inviable cuando es difícil predecir cuáles serán todo el mapa de URLs con anticipación, o para sitios con una gran cantidad de páginas únicas y con contenido cambiante.</p><p>Sin embargo los puntos principales por los que esta estrategia se ha puesto de moda:</p><ul><li><strong>Alto Rendimiento:</strong> las páginas no se construyen al vuelo, sino en la etapa de build, por lo que se minimiza el TTFB y los ficheros reconstruidos se sirven a través de una red global CD.</li><li><strong>Alta seguridad:</strong> con esta aproximación el lado servidor se puede abstraer reduciendo las áreas de ataque</li><li><strong>Barato y escalable</strong>: los despliegues son muy sencillos, ya que solo hay que servir un build estáticos de ficheros html, css y Javascript, además más barato porque solo necesitamos alojarlo en un CDN, que requiere menos coste que una aproximación que requiere de cómputo para el renderizado.</li></ul><h3>Jamstack en la vida real: Gatsbylius</h3><p><strong>Gatsbylius </strong>es una iniciativa open-source que une un generador de sites estático con un framework PHP para construir e-commerces. Esta tecnología une lo dinámico de un e-commerce y lo estático de un generador, para conseguir que la experiencia web de un site de comercio electrónico sea exquisita.</p><p>Esta solución se vende como la solución<em> e-commerce</em> más rápida apoyándose en hombros de gigantes como <strong>Gatsby</strong> y <a href="https://adrianalonso.es/desarrollo-web/sylius-asociando-gastos-adicionales-al-metodo-de-pago/"><strong>Sylius</strong></a>. y ofreciendo una arquitectura desacoplada con un <strong>headless e-commerce</strong> y basado en un frontend en React.</p><p>Este tipo de soluciones están marcando tendencia y delatan que JAMstack ha llegado para quedarse y ser una opción para distintos tipos de soluciones.</p><h3>Consideraciones SEO</h3><p>Los desarrolladores a menudo tenemos en cuenta el impacto SEO al elegir una estrategia para renderizar nuestras webs. Las soluciones que pasan por el renderizado por servidor que ofrece una experiencia de aspecto completo, ayudan a los rastreadores a interpretar e indexar con facilidad en los buscadores. Actualmente muchos rastreadores son capaces de entender Javascript, pero existen limitaciones, que rompen una lanza en favor a soluciones como <strong><em>SSR o Prerendering</em> </strong>para cumplir con estos requisitos, por ello es un factor muy importante a tener en cuenta en la arquitectura de nuestras aplicaciones, más allá del propio performance.</p><h3>Conclusión</h3><p>Al tratar de decidir un enfoque para el renderizado, debemos de analizar y comprender cuáles son los requisitos y las necesidades del proyecto. Debemos de buscar el equilibrio para encontrar qué estrategia nos compensa a medio/largo plazo. También, nunca hay que apostar por una sola estrategia como cual bala de plata, sino que podemos partir de distintos frontales en función de las necesidades. Por ejemplo un site con landings estáticos, un blog de contenido tradicional y una PWA CSR.</p><p>Una vez elegida una estrategia, debemos de tener muy en cuenta sus características para tratar de paliar sus inconvenientes principales, utilizando estrategias de medición constante con herramientas como Lighthouse.</p><h3>Recursos</h3><p><a href="https://lemoncode.net/lemoncode-blog/2018/7/6/server-side-rendering-ii-implementacion-react-next">https://lemoncode.net/lemoncode-blog/2018/7/6/server-side-rendering-ii-implementacion-react-next</a></p><p><a href="https://lemoncode.net/lemoncode-blog/2018/5/13/server-side-rendering-i-conceptos">https://lemoncode.net/lemoncode-blog/2018/5/13/server-side-rendering-i-conceptos</a></p><p><a href="https://developers.google.com/web/tools/puppeteer/articles/ssr">https://developers.google.com/web/tools/puppeteer/articles/ssr</a></p><p><a href="https://altalogy.com/blog/client-side-rendering-vs-server-side-rendering/">Client-Side Rendering versus Server-Side Rendering!</a></p><p><strong>Post publicado en:</strong> <a href="https://adrianalonso.es/desarrollo-web/renderizando-la-web-en-2020/">https://adrianalonso.es/desarrollo-web/renderizando-la-web-en-2020/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ed96a6d70748" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Sylius Promotion Component, o cómo inspirarse en un proyecto Open Source]]></title>
            <link>https://adrianalonsodev.medium.com/sylius-promotion-component-o-c%C3%B3mo-inspirarse-en-un-proyecto-open-source-117d85393311?source=rss-f754bd174f5------2</link>
            <guid isPermaLink="false">https://medium.com/p/117d85393311</guid>
            <category><![CDATA[sylius]]></category>
            <category><![CDATA[ecommerce]]></category>
            <category><![CDATA[design-patterns]]></category>
            <category><![CDATA[open-source]]></category>
            <dc:creator><![CDATA[Adrián Alonso]]></dc:creator>
            <pubDate>Mon, 07 Dec 2020 11:46:55 GMT</pubDate>
            <atom:updated>2020-12-13T12:34:22.252Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*vnPlZgztqdrGLVKt.png" /></figure><p>Hace unas semanas, dentro del contexto del proyecto en el que actualmente trabajo, se propuso diseñar una funcionalidad basada en descuentos y promociones. Nuestra arquitectura basada en <a href="https://adrianalonso.es/arquitectura-del-software/buenas-practicas-de-desarrollo-para-el-rendimiento-de-microservicios/">microservicios</a> con el stack NestJS y Typescript está basada en la premisa de desacoplar al máximo los conceptos para una <strong>mantenibilidad</strong> adecuada y un <strong>proceso evolutivo</strong> que nos permita escalar nuestro diseño de forma ágil y adaptado al contexto de un equipo dividido en dos <em>squads</em>.</p><p>Para ello, se analizaron los requisitos a <strong><em>corto y medio plazo</em></strong> que requeriría nuestro proceso de compra y escenarios que <em>“Negocio”</em> podría plantear para aplicar estos descuentos. Aún siendo un MVP, se buscaba plantear un diseño lo más flexible posible que nos permitiera ofrecer al equipo de Marketing la <strong>flexibilidad</strong> de plantear estrategias de promociones que requirieran el menor esfuerzo de desarrollo posible.</p><h3>Poniendo en valor las experiencias pasadas</h3><p>Como suele decir la generación pasada, <strong><em>“la experiencia es un grado”</em></strong>. Más allá de dedicarse al desarrollo <em>software</em> y haber podido trabajar con diferentes tecnologías, considero que lo más importante es el haberse enfrentado a problemáticas distintas y saber adaptar el conocimiento adquirido para resolver nuevos problemas. En este punto, me gustaría recomendar este post acerca de lo que significa tener una verdadera experiencia laboral: <a href="https://dpersonas.com/2017/01/31/sirve-de-algo-la-experiencia-o-en-estos/">https://dpersonas.com/2017/01/31/sirve-de-algo-la-experiencia-o-en-estos/</a></p><p>Sacando de la chistera esas experiencias del pasado, aproveché mi experiencia trabajando con soluciones<em> e-commerce</em> y decidí confiar una vez más en <a href="https://adrianalonso.es/desarrollo-web/sylius-asociando-gastos-adicionales-al-metodo-de-pago/">Sylius</a>, <em>framework open source</em> para la construcción de <em>e-commerce</em> basado en <a href="https://adrianalonso.es/desarrollo-web/descubre-las-novedades-que-traera-symfony-4/"><em>Symfony</em></a> del cual ya he hablado anteriormente en este blog.</p><p>Sylius se basa en <a href="https://docs.sylius.com/en/latest/components_and_bundles/components/index.html">una serie de componentes</a>, todos ellos desacoplados entre sí y que, trabajando en conjunto, ofrecen una solución <em>e-commerce</em> completa. <strong>¿Por qué confiar en un proyecto como este?</strong> Pues porque nace de una comunidad con más de<strong> 600 contribuidores, una base de 250 <em>plugins</em> y 6000 estrellas en </strong><a href="https://github.com/Sylius/Sylius"><strong>Github</strong></a>, lo que nos asegura que ha habido muchas mentes pensantes trabajando en conjunto para ofrecer la solución más extensible.</p><h3>Sylius Promotion Component</h3><p>Uno de los componentes construidos en esta comunidad se trata del <strong>Promotion Component</strong> y su diseño interno es el que nos ha inspirado para construir nuestra solución, en un lenguaje y contexto distinto, pero con los mismos objetivos. Es por ello que en este post hablaré en profundidad de las bondades de este componente que nos ha permitir construir nuestro propio motor de promociones.</p><p>Este motor de promociones se basa en el concepto de componerse de un conjunto de reglas y acciones, las cuales nos ayudan a encontrar la<strong> flexibilidad de plantear nuevas reglas de negocio y componer promociones</strong> diversas combinando estas. De tal manera, que el motor se encarga de recuperar de base de datos las promociones activadas, evaluando si nuestro pedido satisface las reglas de dichas promociones y en caso satisfactorio, aplicar las aciones correspondientes.</p><p>El <strong>componente de promociones de Sylius</strong> está diseñado para ser lo más flexible posible adaptándose a las fuertes necesidades de las campañas de marketing, como ha sucedido estos días con miles de organizaciones esta ola de transformación digital. Para ello los colaboradores de este componente, liderado en su comienzo por su fundador <a href="https://twitter.com/pjedrzejewski"><strong>Paweł Jędrzejewski</strong></a> y actualmente por la comunidad <em>Open Source</em>, nos ofrecen un componente que nos ofrece funcionalidades como:</p><ul><li>Promociones acotadas en el tiempo</li><li>Descuentos fijos y porcentuales</li><li>Soporte para definir y extender acciones y reglas personalizadas</li><li>Sistema de cupones</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/0*_XVCQaiwyT79Y4uT.png" /><figcaption><em>Interfaz que nos ofrece el Backoffice de Sylius para gestionar las promociones.</em></figcaption></figure><h3>Show me the code</h3><p>Pero más allá de lo conceptual vamos a ver parte del código del componente en el que merece la pena pararse a leer y analizar.</p><p>Lo primero, para comprender el componente, necesitamos entender los servicios de los que se compone y los puntos de entrada que nos ofrece el motor. Como vemos en la documentación, podemos contar con factorías para nuestros modelos (<strong><em>PromotionActionFactory</em></strong>), repositorios para recuperar las promociones (<strong><em>RepositoryPromotion</em></strong>) o servicios para aplicar directamente una promoción. (<strong><em>PromotionApplicator</em></strong>)</p><pre>/** @var <strong>Promotion</strong>Interface $promotion */<br>$<strong>promotion</strong> <strong>=</strong> $this<strong>-&gt;</strong>container<strong>-&gt;</strong>get(&#39;sylius.factory.<strong>promotion</strong>&#39;)<strong>-&gt;</strong>createNew();<br><br>$<strong>promotion-&gt;</strong>setCode(&#39;discount_10%&#39;);<br>$<strong>promotion-&gt;</strong>setName(&#39;10% discount&#39;);<br><br>/** @var <strong>Promotion</strong>ActionFactoryInterface $actionFactory */<br>$actionFactory <strong>=</strong> $this<strong>-&gt;</strong>container<strong>-&gt;</strong>get(&#39;sylius.factory.<strong>promotion</strong>_action&#39;);<br><br>$action <strong>=</strong> $actionFactory<strong>-&gt;</strong>createPercentageDiscount(10);<br><br>$<strong>promotion-&gt;</strong>addAction($action);<br><br>$this<strong>-&gt;</strong>container<strong>-&gt;</strong>get(&#39;sylius.repository.<strong>promotion</strong>&#39;)<strong>-&gt;</strong>add($<strong>promotion</strong>);<br><br><em>// and now get the </em><strong><em>Promotion</em></strong><em>Applicator and use it on an Order (assuming that you have one)</em><br>$this<strong>-&gt;</strong>container<strong>-&gt;</strong>get(&#39;sylius.<strong>promotion</strong>_applicator&#39;)<strong>-&gt;</strong>apply($order, $<strong>promotion</strong>);</pre><h3>Punto de entrada</h3><p>Más allá de ver clases independientes con una responsabilidad clara, necesitamos encontrar un punto de entrada que orqueste estos servicios. Buceando por el repositorio nos encontramos el servicio <strong>PromotionProcessor </strong>el cual contiene un método process que recibe una interfaz <strong><em>PromotionSubjectInterface</em></strong><em>, </em>la cual puede representar un hipotético pedido. Esta clase es candidato a ser nuestro punto de entrada. Como podemos ver en el siguiente código, esta interfaz no se acopla totalmente al concepto de pedido, sino a un elemento que nos ofrece importes y una colección de promociones.</p><p>Además, este servicio hace uso de tres clases imprescindibles, las cuales asumen su responsabilidad única:</p><ul><li><strong>PreQualifiedPromotionsProviderInterface</strong>, se encarga de proveer promociones candidatas a ser aplicables</li><li><strong>PromotionEligibilityChecker</strong>, se ocupa de evaluar la satisfacibilidad del subject con el conjunto de reglas de la promoción</li><li><strong>PromotionApplicatorInterface</strong>, se responsabiliza de poder aplicar y revertir promociones</li></ul><pre>&lt;?php</pre><pre>/*</pre><pre>* This file is part of the Sylius package.</pre><pre>*</pre><pre>* (c) Paweł Jędrzejewski</pre><pre>*</pre><pre>* For the full copyright and license information, please view the LICENSE</pre><pre>* file that was distributed with this source code.</pre><pre>*/</pre><pre>declare(strict_types=1);</pre><pre>namespace Sylius\Component\Promotion\Processor;</pre><pre>use Sylius\Component\Promotion\Action\PromotionApplicatorInterface;</pre><pre>use Sylius\Component\Promotion\Checker\Eligibility\PromotionEligibilityCheckerInterface;</pre><pre>use Sylius\Component\Promotion\Model\PromotionSubjectInterface;</pre><pre>use Sylius\Component\Promotion\Provider\PreQualifiedPromotionsProviderInterface;</pre><pre>final class PromotionProcessor implements PromotionProcessorInterface</pre><pre>{</pre><pre>    /** @var PreQualifiedPromotionsProviderInterface */</pre><pre>    private $preQualifiedPromotionsProvider;</pre><pre>    /** @var PromotionEligibilityCheckerInterface */</pre><pre>    private $promotionEligibilityChecker;</pre><pre>    /** @var PromotionApplicatorInterface */</pre><pre>    private $promotionApplicator;</pre><pre>    public function __construct(</pre><pre>        PreQualifiedPromotionsProviderInterface       $preQualifiedPromotionsProvider,</pre><pre>        PromotionEligibilityCheckerInterface $promotionEligibilityChecker,</pre><pre>       PromotionApplicatorInterface $promotionApplicator</pre><pre>) {</pre><pre>     $this-&gt;preQualifiedPromotionsProvider = $preQualifiedPromotionsProvider;</pre><pre>     $this-&gt;promotionEligibilityChecker = $promotionEligibilityChecker;</pre><pre>     $this-&gt;promotionApplicator = $promotionApplicator;</pre><pre>}</pre><pre>public function process(PromotionSubjectInterface $subject): void</pre><pre>{</pre><pre>    foreach ($subject-&gt;getPromotions() as $promotion) {</pre><pre>        $this-&gt;promotionApplicator-&gt;revert($subject, $promotion);</pre><pre>    }</pre><pre>    $preQualifiedPromotions = $this-&gt;preQualifiedPromotionsProvider-&gt;getPromotions($subject);</pre><pre>    foreach ($preQualifiedPromotions as $promotion) {</pre><pre>    if ($promotion-&gt;isExclusive() &amp;&amp; $this-&gt;promotionEligibilityChecker-&gt;isEligible($subject, $promotion)) {</pre><pre>        $this-&gt;promotionApplicator-&gt;apply($subject, $promotion);</pre><pre>        return; </pre><pre>    }</pre><pre>}</pre><pre>    foreach ($preQualifiedPromotions as $promotion) {</pre><pre>         if (!$promotion-&gt;isExclusive() &amp;&amp; $this-    &gt;promotionEligibilityChecker-&gt;isEligible($subject, $promotion)) {</pre><pre>             $this-&gt;promotionApplicator-&gt;apply($subject, $promotion);</pre><pre>        }</pre><pre>    }</pre><pre>  }</pre><pre>}</pre><h3>Acciones y reglas</h3><p>Si seguimos profundizando en el repositorio encontramos dos carpetas esenciales <strong><em>Action</em></strong> y <strong><em>Checker</em></strong>, las cuales contienen las clases necesarias para manejar las acciones y las reglas respectivamente.</p><p>Lo primero que contiene una promoción es un conjunto de reglas a evaluar. Una de las implementaciones por defecto que ofrece es la de evaluar si el pedido excede de cierto importe para aplicar. Implementando la interfaz <strong>RuleCheckerInterface</strong> podremos crear todas las reglas que necesitemos dado un pedido y la configuración definida para esa regla.</p><pre>final class ItemTotalRuleChecker implements RuleCheckerInterface{</pre><pre>public const TYPE = &#39;item_total&#39;;</pre><pre>public function isEligible(PromotionSubjectInterface $subject, array $configuration): bool</pre><pre>{</pre><pre>    return $subject-&gt;getPromotionSubjectTotal() &gt;= $configuration[&#39;amount&#39;];</pre><pre>}</pre><pre>}</pre><p>Para definir acciones predefinidas debemos de basarnos en la interfaz <strong><em>PromotionActionCommandInterface </em></strong>la cual debe satisfacer dos métodos, uno para aplicar una acción de la promoción y otro para revertirla.</p><pre>use Sylius\Component\Promotion\Model\PromotionInterface;</pre><pre>use Sylius\Component\Promotion\Model\PromotionSubjectInterface;</pre><pre>interface PromotionActionCommandInterface</pre><pre>{</pre><pre>    public function execute(PromotionSubjectInterface $subject, array $configuration, PromotionInterface $promotion): bool;</pre><pre>    public function revert(PromotionSubjectInterface $subject, array $configuration, PromotionInterface $promotion): void;</pre><pre>}</pre><p>De esta manera y cumpliendo con ambas interfaces podremos construir nuestras propias reglas y acciones adaptando el motor a las necesidades de negocio.</p><h3>Conclusión</h3><p>Una de las grandes ventajas de <strong>Sylius</strong> respecto a soluciones <em>e-commerce </em>completas como <em>Magento</em> o <em>Woocomerce</em> que llevan más tiempo en el mercado, es el nivel de calidad del <em>software</em> implementado. <strong><em>Sylius</em></strong> está construido con las mejores prácticas, utilizando patrones de diseño que permiten cumplir con esa <em>developer experience</em>, pudiendo personalizar y adaptar la base <em>software</em> que nos ofrece a las necesidades reales del negocio con un<em> time to market </em>muy bajo.</p><p>Como hemos podido ver en el recorrido por sus clases principales, nos encontramos <a href="https://adrianalonso.es/arquitectura-del-software/patrones-de-diseno-chain-of-responsability/"><strong>patrones de diseño</strong></a> como <em>Factory, Repository o Command</em>, además de cumplir con principios <a href="https://adrianalonso.es/formacion/los-principios-de-desarrollo-solid-en-5-videos/"><strong>SOLID</strong></a>, para separar responsabilidad o estar abiertos a la extensión, bases fundamentales de un <em>framework</em> de esta categoría.</p><p>La gran ventaja de sentirse cómodos con estos patrones de diseño es justo lo que me ha aportado para poder trasladar una solución en un lenguaje y contexto distinto a nuestra necesidad real.</p><h3>Documentación</h3><p><a href="https://docs.sylius.com/en/latest/book/orders/promotions.html">https://docs.sylius.com/en/latest/book/orders/promotions.html</a></p><p><a href="https://github.com/Sylius/Promotion">https://github.com/Sylius/Promotion</a></p><p><strong>Este post está publicado en: </strong><a href="https://adrianalonso.es/arquitectura-del-software/patrones-de-diseno/sylius-promotion-component-open-source/#">https://adrianalonso.es/arquitectura-del-software/patrones-de-diseno/sylius-promotion-component-open-source/#</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=117d85393311" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[CI/CD — Historia de un amor loco]]></title>
            <link>https://adrianalonsodev.medium.com/ci-cd-historia-de-un-amor-loco-49475d2f0c7d?source=rss-f754bd174f5------2</link>
            <guid isPermaLink="false">https://medium.com/p/49475d2f0c7d</guid>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[continuous-improvement]]></category>
            <category><![CDATA[continuous-integration]]></category>
            <category><![CDATA[serverless]]></category>
            <category><![CDATA[continuous-deployment]]></category>
            <dc:creator><![CDATA[Adrián Alonso]]></dc:creator>
            <pubDate>Sat, 06 Jun 2020 19:05:29 GMT</pubDate>
            <atom:updated>2020-06-06T19:05:29.086Z</atom:updated>
            <content:encoded><![CDATA[<h3>CI/CD — Historia de un amor loco</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*xVlLKuqvklMKjj-M.png" /></figure><p>Hace unas semanas decidí dar mi primera charla pública gracias a la oportunidad que me había ofrecido <a href="https://www.qalovers.com/"><strong>QALovers</strong></a>. Me puse manos a la obra cuando me lo ofrecieron, pensando que podía aportar desde un punto de vista de calidad. Existen muchos frameworks de testing, muchas herramientas, pero quise ir más allá y reflexionar como realmente mi equipo aporta calidad a los productos digitales que construimos en <a href="https://clouddistrict.com/"><strong>Cloud District</strong>.</a></p><p>En este último año, el equipo técnico hemos puesto mucho esfuerzo en implantar una <strong>estrategia de CI/CD,</strong> pero echando la vista atrás, para llegar a implantar realmente esta filosofía hemos ido mejorando muchísimos aspectos de nuestro día a día que nos han ayudado a entregar un software de alta calidad.</p><p>Sobre este camino preparé la charla y a continuación os voy a contar los puntos más interesantes de esta historia de amor loco.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FrbXP6o_sTZ0%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DrbXP6o_sTZ0&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FrbXP6o_sTZ0%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/8c527a64aef2c57ea958d68d3b210c77/href">https://medium.com/media/8c527a64aef2c57ea958d68d3b210c77/href</a></iframe><h3>Antes de empezar</h3><p>Pero antes de comenzar con esta historia de amor loco, quisiera poner hincapié en algunos aspectos que pueden ayudar a implantar mejoras en el camino, o al menos hacerlo menos duro.</p><h3>Hablemos de curvas</h3><p>Durante la crisis del COVID-19, todos podemos incluir en nuestro curriculum que somos expertos en aplanar curvas. Por ello, quiero hablar de la <strong>curva de adopción de la innovación. </strong>Esta curva se trata de un modelo sociológico que clasifica a las personas en diferentes categorías en función de su disposición a adoptar una determinada tecnología, método o innovación.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/670/0*XmG8gY6kY0z7j1It.jpg" /></figure><p>Esta curva puede ayudar en muchos aspectos, sobre todo en el mundo de los emprendedores, para focalizar los esfuerzos en la atracción de un target concreto. Básicamente marca el camino para poner grandes esfuerzos en los entusiastas y <em>early adopters</em> que ayudarán a expandir nuestras ideas.</p><p>Esto mismo pasa en muchos aspectos de la vida y en una organización, en la que si quieres hacer que las cosas pasen o implantar una nueva práctica, herramienta o metodología, debes de contar con los aliados que ayuden alcanzar esa masa crítica para que nuestros objetivos tengan lugar.</p><p>Pensar en esta curva es muy útil cuando se emprende dado que te ayuda a entender hacia quiénes has de focalizar tus esfuerzos de atracción. Empezar por los entusiastas y los early adopters que nos ayudan a conseguir nuestro objetivo.</p><h3>Lecturas recomendadas</h3><p>Sobre esta capacidad de cautivar y conseguir nuestros objetivos quisiera recomendar tres lecturas que pueden ayudar a inspirarte por el camino.</p><ul><li><a href="https://www.amazon.es/dp/1484923286/ref=as_sl_pc_qf_sp_asin_til?tag=adrialon-21&amp;amp;linkCode=w00&amp;amp;linkId=ecadb31d3a37af56e5891b3ef85625b3&amp;amp;creativeASIN=1484923286"><strong>“Cómo cambiar el mundo”</strong></a><strong> de Jurgen Appelo</strong>: ¿Qué puedo hacer con esta pésima organización? Me gusta mi trabajo, pero no me gusta lo que hace la capa de gestión. ¿Cómo lo manejo? Miro a otro lado, me voy a otra empresa o intento cambiar el mundo. Jurgen Appelo es el creador de <a href="https://adrianalonso.es/project-management/lead-developer-management-3-0/">“Management 3.0”</a> y en este libro ofrece puntos claves de cómo intentar cambiar una organización desde dentro.</li><li><a href="https://www.amazon.es/gp/product/B006FLRS58/ref=as_li_qf_asin_il_tl?ie=UTF8&amp;tag=adrialon-21&amp;creative=24630&amp;linkCode=as2&amp;creativeASIN=B006FLRS58&amp;linkId=1b4eb9f7c97453d1e8fe92bebed7a31b"><strong>“El arte de cautivar”</strong></a><strong> de Guy Kawasaki.</strong> Guy implantó el concepto de “evangelizar” en los negocios tecnológicos, con la idea de atraer y focalizar a usuarios vinculados al mercado Apple. En este libro hay grandes consejos de cómo atraer al público. Y vaya si lo hicieron bien con el lanzamiento de iPhone.</li><li><a href="https://www.amazon.es/gp/product/150581748X/ref=as_li_qf_asin_il_tl?ie=UTF8&amp;tag=adrialon-21&amp;creative=24630&amp;linkCode=as2&amp;creativeASIN=150581748X&amp;linkId=df0adba5e339b612f4768707bf6f1265"><strong>“Talking with Tech Leads”</strong></a><strong> de Patrick Kua. </strong>Si te encuentras en una situación como la mía en el que estás comenzando a realizar un rol de Team Lead, este libro puede ayudarte en el camino. Este Libro relata las conversaciones con <a href="https://adrianalonso.es/project-management/review-de-talking-with-tech-leads/">Tech Leads</a> con distintos niveles de experiencia. Concretamente 35 entrevistas a diferentes Tech Leads que describen cómo encuentran el equilibrio entre el mundo técnico y el no técnico.</li></ul><h3>Code Review</h3><p><strong>Code Review</strong> es el proceso mediante el cual los distintos miembros de un equipo revisan en conjunto la implementación realizada por otra persona del equipo. Es algo ligado al software, pero este concepto se puede hacer en otras áreas de la organización como revisión de documentos funcionales, diseño, prototipos, contenido utilizando el concepto de Red Team.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/780/0*PFTdhndZQwpiKKi3.png" /></figure><p>Los <strong>Red Teams</strong> vienen del mundo del hacking y emulan a los atacantes, utilizando sus mismas herramientas o similares, explotando las vulnerabilidades de seguridad de los sistemas. Pero realmente puedes tener tus propios “Read Teams” que ayuden a sacar punta a nuestras entregas.<br>Por ejemplo, algunas recomendaciones de mi compañero<strong> Joan Llopis </strong>a la hora de presentar un documento técnico o revisar un documento técnico de un compañero, deberíamos hacernos este tipo de preguntas:</p><ul><li><em>¿Se comprende bien el contenido?</em></li><li><em>¿Cumple con los objetivos que nos hemos establecidos?</em></li><li><em>¿Está adaptado a la audiencia a la que va dirigido dicho documento?</em></li></ul><p>A nivel de software, es importante tener en cuenta algunas <a href="http://Code%20Review%20Code%20Review%20es%20el%20proceso%20mediante%20el%20cual%20los%20distintos%20miembros%20de%20un%20equipo%20revisan%20en%20conjunto%20la%20implementaci%C3%B3n%20realizada%20por%20otra%20persona%20del%20equipo.%20Es%20algo%20ligado%20al%20software,%20pero%20este%20concepto%20se%20puede%20hacer%20en%20otras%20%C3%A1reas%20de%20la%20organizaci%C3%B3n%20como%20revisi%C3%B3n%20de%20documentos%20funcionales,%20dise%C3%B1o,%20prototipos,%20contenido%20utilizando%20el%20concepto%20de%20Red%20Team.%20Los%20Red%20Teams%20vienen%20del%20mundo%20del%20hacking%20y%20emulan%20a%20los%20atacantes,%20utilizando%20sus%20mismas%20herramientas%20o%20similares,%20explotando%20las%20vulnerabilidades%20de%20seguridad%20de%20los%20sistemas.%20Pero%20realmente%20puedes%20tener%20tus%20propios%20read%20team%20que%20ayuden%20a%20sacar%20punta%20a%20nuestras%20entregas.%20Por%20ejemplo,%20algunas%20recomendaciones%20de%20mi%20compa%C3%B1ero%20Joan%20Llopis%20a%20la%20hora%20de%20presentar%20un%20documento%20t%C3%A9cnico%20o%20revisar%20un%20documento%20t%C3%A9cnico%20de%20un%20compa%C3%B1ero,%20deber%C3%ADamos%20hacernos%20este%20tipo%20de%20preguntas:%20%C2%BFSe%20comprende%20bien%20el%20contenido/?%20%C2%BFCumple%20con%20los%20objetivos%20que%20nos%20hemos%20establecidos?%20%C2%BFEst%C3%A1%20adaptado%20a%20la%20audiencia%20a%20la%20que%20va%20dirigido%20dicho%20documento?%20A%20nivel%20de%20software,%20es%20importante%20tener%20en%20cuenta%20algunas%20buenas%20pr%C3%A1cticas%20para%20hacer%20code%20review:%20https://adrianalonso.es/buenas-practicas/buenas-practicas-para-hacer-code-review-en-tu-equipo-de-desarrollo/">buenas prácticas</a> para hacer Code Review, que hemos visto en otros artículos.</p><h3>Metodología</h3><p>A continuación se muestran algunas prácticas que nos están funcionando y están impactando positivamente en nuestras entregas a través de la metodología y cultura de empresa.</p><h3>Contratos ágiles</h3><p>Los contratos ágiles tratan de romper el paradigma descrito, donde ambas partes comprenden que las estimaciones no son precisas y exactas, sumado a que los riesgos deberán ser compartidos. El contrato pasa a ser un mero trámite y se genera una confianza entre las partes.</p><p>Todos deberíamos de asumir que las estimaciones dependen de muchos factores, y aunque pueda haber barreras técnicas, principalmente considero que estas dependen mucho de la colaboración y la motivación de los equipos</p><p>Este tipo de contratos trata de reflejar principios del Manifiesto Agile, en el que se promueven iteraciones cortas que aporten valor y estén centradas en este y no en un alcance fij minimizando los riesgos de ambas partes. Es esencial que en las primeras fases empecemos con sprints de confianzas que generen esas sinergias entre clientes y proveedores</p><h3>Historias de Usuario</h3><p>Las <strong>historias de usuario</strong> son la unidad de trabajo más pequeña de un marco ágil. Es un método de toma de requisitos expresado desde la perspectiva del usuario del software.</p><p>Venimos de construir proyectos usando un documento de análisis funcional enorme complementado con unos prototipos. Pero este modelo siempre genera incertidumbres que resolver y expectativas difícil que cubrir, sin una estrecha colaboración y una acotación de los requisitos y la expectativa.</p><p>Este método archiconocido nos ayuda a establecer los alcances, junto a unos criterios de aceptación que acotan la funcionalidad. Nos apoyamos en ejemplos empleando <em>“Specification by Example”</em> para terminar de complementar esa Historia de Usuario.</p><p>Además esta unidad de medida, nos ayuda a construir <a href="https://adrianalonso.es/project-management/5-pasos-construir-user-story-mapping/"><strong>User Story Mapping</strong>s</a> para plantear los roadmaps de los <em>MVPs</em> de nuestros clientes y priorizarlos con ellos para aportar el máximo valor.</p><p>Al final trabajar sobre este marco es un <em>WIN WIN</em>, ya que el cliente construye exactamente lo que necesita, y a nosotros nos ayuda a planificar nuestros sprint, analizar las desviaciones y dar estimaciones más realistas.</p><h3>Equipos Multidisciplinares</h3><p>Otro punto importante, es trabajar en equipos multidisciplinares. Se puede definir <strong><em>“equipo multidisciplinar”</em></strong> como un conjunto de personas, con diferentes formaciones académicas y experiencias profesionales, que operan en conjunto, durante un tiempo determinado para resolver un objetivo común.</p><p>Es evidente que la diversidad de perfiles enriquece y genera distintas perspectivas y soluciones generando compromiso y trabajo en equipo. En la construcción de los productos nos ayuda a entender de manera transversal los requisitos, mejorando la comunicación entre los distintos equipos de <em>UX, UI, Desarrollo, QA o SEO.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/839/0*wYS1cgYuilSFSHE-.png" /></figure><p>Un concepto interesante es el de mesas calientes que pueden ir rotando a lo largo del tiempo. Se trata de sentarse juntos un equipo formado por perfiles distintos trabajando en el mismo proyecto. Es importante evitar totalmente silos, todas las áreas deben trabajar en conjunto en este mismo proyecto, evitando burocracias de departamentos que ralentizan el proceso.</p><h3>Atomic Web Design</h3><p>Otro aspecto importante es el uso de <a href="https://adrianalonso.es/arquitectura-del-software/atomic-web-design-o-diseno-guiado-por-componentes/"><strong>Atomic Web Design</strong></a>. Esta estrategia orientada a UI nos ayuda a construir el diseño de una interfaz web descomponiendo en unidades más pequeñas, denominados<strong> átomos, moléculas, organismos y plantillas</strong>, reutilizando estos componentes a través de la composición para generar elementos más grandes y potentes que compongan todo el diseño.</p><p>Aunque parezca ligado solo a diseño es importante tomar esta práctica de forma transversal uniendo disciplinas. En nuestros desarrollos usamos frameworks javascript orientados a componentes como ReactJS o Vue. Es importante que haya una trazabilidad entre lo diseñado y lo construido, permitiendo implementar de manera más eficiente los cambios sobre los componentes y poder realizar prototipos y pruebas de conceptos con estas piezas</p><h3>Performance Review</h3><p>En los últimos meses estamos comenzando a realizar <strong><em>Performance Reviews</em></strong>. Se tratan de revisiones del desempeño de una persona y de su contribución a la organización comparándolo con la última revisión. Creo imprescindible mantener al equipo motivado, con objetivos claros y con una progresión clara para entender sus necesidades y ayudarles en su crecimiento personal.</p><p>Es importante que estos objetivos sean alcanzables en tiempos cortos, no ser muy ambicioso y que la comunicación feedback fluya de forma constante y bidireccional apoyándonos en herramienta como el <em>OneToOne</em>.</p><p>Hace poco, debido al confinamiento, hemos puesto en práctica el uso de una herramienta de feedback que permite enviar aplausos para valorar el trabajo de los compañeros durante la semana. Este tipo de prácticas como pueden ser los <em>Celebration Grid</em>, los <em>Kudos</em> o los <em>Exploration Days</em> ayudan a sentirse realizado y dar lo mejor de uno mismo en los proyectos.</p><h3>Testing / QA</h3><h3>Cultura del Testing</h3><p>Desarrollar una <strong>cultura del testing</strong> dentro de la organización es esencial. El testing debe de verse como un aliado y no como lo primero que se descarta de un proyecto. El testing esta herramienta que nos asegura que nuestro proceso de CI/CD puede ejecutarse, poniendo cosas en producción asegurando y confiando la release que ponemos en producción</p><p>Nos podemos apoyar en herramientas como <em>TDD</em>, <em>BDD</em> o <em>Gherkin</em>, pero es esencial que el testing esté incluido en la propia tarea y que desarrollemos tests por cada bug que nos encontremos en producción</p><p>Teniendo esta base de testing en nuestras aplicaciones podemos realizar refactoring sin miedo al error, aumentando la productividad y resolviendo bugs de manera temprana. Para ello nos apoyaremos en la pirámide del testing, sin olvidarnos de tests de estrés y carga en aquellas aplicaciones que requieran un gran volumen de tráfico.</p><h3>Equipo de QA</h3><p>Además es esencial hoy en día contar con un <strong>equipo de QA</strong>, por que ya es una <strong>necesidad y no un lujo</strong>. Gracias a un equipo de QA y sus procesos aseguramos que el producto que entregamos cumple con los estándares de calidad adecuados.</p><p>Este proceso ayuda a detectar defectos antes que el producto esté en manos del cliente o de los propios usuarios, aumentando la satisfacción de estos.Es ideal que QA esté en todo el proceso, cercano desde la definición de requisitos y en todos los ámbitos asegurando la calidad de los entregables. Podéis descubrir más sobre equipos de QA a través del gran <a href="https://clouddistrict.com/qa-quality-assurance-calidad-producto-digital/">artículo</a> de mi compañera Vicky Alonso</p><h3>Continuous Integration</h3><p>Y llegamos a la Integración Continua, donde vamos a ejecutar de manera nuestro software en cada cambio para detectar problemas de manera anticipada y asegurar que todo está en orden.</p><h3>Pipeline as a code</h3><p>Para ello diseñaremos nuestros workflows de CI usando una estrategia de <strong>Pipeline as a Code,</strong> escrita en un DSL específico, generalmente YAML, que estará versionado y disponible para todos los desarrolladores. Para ello existen multitud de herramientas SaaS que ayudan a definir estos workflows: <em>CircleCI, Azure Devops, Github Actions, Travis CI, Bitbucket Pipelines.</em></p><p>Esto ayuda a dejar documentado de forma implícita como se construye el software, como se testea, que servicio se necesitan levantar, qué tipo de tareas hay que ejecutar y qué conjunto de datos necesita arrancar. Muy útil si trabajamos con software distribuido dentro de un monorepo y queremos probar la orquestación de cada pieza.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/0*jWJNF2anE9qbY5Fu.jpg" /></figure><h3>Automatizaciones</h3><p>Además de todo eso, nos ayudará a mantener la consistencia en nuestro código, validando que cumplimos con las rules que haya establecido el equipo. Para ello nos podemos apoyar en herramientas como <em>PHP-CS-Fixer, Husky o Prettier</em>.</p><p>También podemos usar herramientas de análisis estática que nos analiza de una forma objetiva la estructura de nuestro código para identificar problemas y potenciales bugs e identifica código que no se alcanza, código duplicado, variables no inicializadas. Estas herramientas son muy útiles para obtener unas primeras sensaciones de manera objetiva de un proyecto legacy o externalizado. Además a los propios <em>stakeholders</em> (PO, PM) del proyecto les podemos ofrecer cierto KPIs durante el desarrollo para dar visibilidad y transparencia de estos.</p><p>Las posibilidades dentro del proceso de integración continua son infinitas, y además de los steps clásicos, podemos incluir más procesos que apoyen a cumplir con los objetivos y requisitos del proyecto. Algún ejemplo puede ser utilizar el CLI <strong><em>Lighthouse </em></strong><em>(</em><a href="https://github.com/GoogleChrome/lighthouse"><em>https://github.com/GoogleChrome/lighthouse</em></a><em>)</em> para monitorizar nuestro performance, o <strong><em>Pa11y </em></strong><em>(</em><a href="https://github.com/pa11y/pa11y"><em>https://github.com/pa11y/pa11y</em></a><em>)</em> para auditar si cumplimos con los standards de accesibilidad.</p><h3>Continuous Deployment</h3><p>Una vez que nos aseguramos que nuestro software está funcionando correctamente, tenemos que automatizar la puesta en producción de nuestro software utilizando la filosofía de la metodología <strong><em>DevOps</em></strong>, que se centra en la colaboración, la entrega y el despliegue continuo.</p><p>Es importante para cumplir con un corto T<strong><em>ime to Marke</em></strong>t, que los ciclos de entrega sean cortos y la automatización, evitando la intervención humana nos va ayudar a reducir el riesgo.</p><p>Para no frenar los despliegues y facilitar el trabajo del equipo de QA podemos apoyarnos en “<em>branches deplo</em>y” o <em>“feature flags”</em>, que nos ayudan a activar o desactivar funcionalidad en runtime.</p><p>No debemos de olvidarnos de prácticas como la <strong>administración de la configuración y secrets, la gestión de los secrets y la <em>Infrastructure as a Code.</em></strong></p><h3>Serverless</h3><p>En nuestro escenario nos apoyamos en la computación en la nube en el modelo <strong>Serverless</strong>. <em>Serverless</em> es un modelo de ejecución de software en la nube que se responsabiliza de ejecutar nuestro código en producción mediante una asignación generalmente abstracta y dinámica de los recursos. Esta aproximación nos permite centrarnos en el propio desarrollo y evolucionarlo, sin preocuparnos de mantenimientos y operaciones sobre máquinas virtuales.</p><p>En este escenario, es importante contar con los distintos servicios que nos ofrecen las nubes desde los modelos <strong><em>PaaS</em></strong> (Platform as a Service), pasando por <strong><em>FaaS</em></strong> (Function as a Service) hasta apoyándonos en funcionalidad de servicios <strong><em>SaaS</em></strong>.</p><p>Algunos ejemplos pueden ser:</p><ul><li>Si hablamos de <strong>PaaS</strong>, uno de los pioneros fueron Heroku, pero ya todos los proveedores Cloud cuentan con este tipo de servicios como Firebase, AWS ElasticBeanstalk o Azure AppService</li><li>Si hablamos de <strong>FaaS</strong>, contamos con multitud de servicios que nos ayudan a desacoplar y apoyarnos en ellos para trabajar con arquitectura de microservicios, como pueden ser Firebase Functions, Azure Functions o AWS Lambda.</li><li>Si lo que necesitamos es no reinventar la rueda, podemos apoyarnos en muchos servicios <strong>SaaS</strong> que nos ofrecen funcionalidad que solo tenemos que integrar en nuestros desarrollos. Por ejemplo, toda la parte de mail marketing y marketing automation podemos apoyarla en servicios como <em>Sendgrid, Mailchimp o Sendinblu</em>e. Lo mismo con otros tipos de herramientas como <em>Twilio, Stripe o Zapier.</em></li></ul><p>La mayor ventaja de este modelo es que el coste no es fijo, en función de los recursos que necesite, el coste es por el uso que le des y al estar interactuando con otros servicios de la misma nube, tienen gran integración y monitorización para tener visibilidad sobre nuestra infraestructura.</p><h3>Twelve Factors</h3><p>Cuando construimos aplicaciones orientadas en la nube buscamos desarrollar aplicativos escalables, sin estado y fácilmente portables que cumplan los <strong><em>Twelve Factors</em></strong><em> </em>(<a href="https://12factor.net/es/">https://12factor.net/es/</a>) Este dodecálogo una metodología para construir aplicaciones en la nube y algunos de esos factores interesantes a tener en cuenta son:</p><ul><li><strong>Codebase: </strong>El código base de la aplicación es único, sin embargo, puede haber tantos despliegues de la aplicación como sean necesarios. Un despliegue es una instancia de la aplicación que está en ejecución. Si hay múltiples códigos base, no es una aplicación — es un sistema distribuido. Cada componente en un sistema distribuido es una aplicación, y cada uno, individualmente, puede cumplir los requisitos de una aplicación <em>“Twelve-factor”.</em></li><li><strong>Backing Service: </strong>Un <em>backing service</em> es cualquier recurso que la aplicación puede consumir a través de la red como parte de su funcionamiento habitual. Entre otros ejemplos, podemos encontrar bases de datos (como MySQL o CouchDB), sistemas de mensajería y de colas (como RabbitMQ), los servicios SMTP de email o sistemas de cache.<br>El código de una aplicación “twelve-factor” no hace distinciones entre servicios locales y de terceros. Para la aplicación, ambos son recursos conectados, accedidos mediante una URL u otro localizador o credencial almacenado en la config. Un despliegue de una aplicación “twelve-factor” debería ser capaz de reemplazar una base de datos local MySQL por una gestionada por un tercero sin ningún cambio en el código de la aplicación.</li><li><strong>Stateless: </strong>Las apps<em> “twelve-factor”</em> no tienen estado, cualquier información que necesite persistencia se debe almacenar en un ‘backing service’ con estado, habitualmente una base de datos. Algunos sistemas webs dependen de <em>“sticky sessions”</em>, esto quiere decir que cachean la información de la sesión de usuario en la memoria del proceso de la aplicación y esperan peticiones futuras del mismo visitante para redirigir al mismo proceso. Las “sticky sessions” son una violación de “twelve-factor” y no deberían usarse nunca ni depender de ellas. La información del estado de la sesión es un candidato perfecto para almacenes de información que ofrecen mecanismos de tiempo de expiración, como Memcached o Redis.</li><li><strong>Gestión de la configuración:</strong> Las aplicaciones “twelve-factor” almacenan la configuración en variables de entorno. Las variables de entorno se modifican fácilmente entre despliegues sin realizar cambios en el código; a diferencia de los ficheros de configuración, en los que existe una pequeña posibilidad de que se guarden en el repositorio de código accidentalmente. Las <em>envvars</em> son un estándar independiente del lenguaje y del sistema operativo.</li></ul><h3>Conclusión: El final del camino hacia CI/CD</h3><p>Tras este camino hemos llegado a nuestro destino en el que se prometió llegar hasta CI/CD. Tras hacer un recorrido por las distintas prácticas que creo hoy en día indispensables llegando a una conclusión: <em>Personas e interacciones, sobre procesos y tecnología y siempre buenas prácticas.</em></p><h4>Gracias a todos los que me apoyaron, dieron consejos para esta primer charla pública y asistieron al webinar. Y sobre todo gracias a todos los compañeros de Cloud District, que me hacen crecer cada día.</h4><p><strong>Artículo publicado en:</strong> <a href="https://adrianalonso.es/buenas-practicas/ci-cd-historia-de-un-amor-loco/">https://adrianalonso.es/buenas-practicas/ci-cd-historia-de-un-amor-loco/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=49475d2f0c7d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Patrones de diseño: Chain of Responsability]]></title>
            <link>https://adrianalonsodev.medium.com/patrones-de-dise%C3%B1o-chain-of-responsability-1460ee11c476?source=rss-f754bd174f5------2</link>
            <guid isPermaLink="false">https://medium.com/p/1460ee11c476</guid>
            <category><![CDATA[software-design]]></category>
            <category><![CDATA[es6]]></category>
            <category><![CDATA[software-design-patterns]]></category>
            <category><![CDATA[solid]]></category>
            <category><![CDATA[chain-of-responsibility]]></category>
            <dc:creator><![CDATA[Adrián Alonso]]></dc:creator>
            <pubDate>Sun, 06 Oct 2019 18:04:53 GMT</pubDate>
            <atom:updated>2019-10-06T18:04:53.949Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Mg2O8qnyE444FFpu.jpg" /></figure><p>En este artículo vamos a hablar del patrón de diseño<strong> “Chain of Responsability”</strong>. Como todos los patrones de diseño, nos ayudan a solucionar problemas comunes hablando un lenguaje habitual entre los desarrolladores. Personalmente, me gusta interiorizar los patrones de diseño y aunque hay bastantes ejemplos teóricos, no valoras lo que te aporta hasta que lo llegas a implementar en un caso real.</p><p>Así que hoy le toca el turno a “<em>Chain of Responsability”</em>, uno de mis favoritos, ya que me ha ayudado en muchas ocasiones a escribir un código legible y mantenible. Esta semana, he tenido que implementar una funcionalidad donde me ha vuelto a encajar a la perfección. El objetivo de este artículo es presentaros el patrón, su aplicabilidad y ver el caso de uso real.</p><h3>La definición de Chain of Responsability</h3><blockquote><em>Chain of Responsability es un patrón de diseño de comportamiento que permite pasar solicitudes a lo largo de una cadena de manejadores. Al recibir una solicitud, cada manejador decide procesar la solicitud o pasarla al siguiente controlador de la cadena.</em></blockquote><p><strong>¿Cómo traducimos esta definición?</strong> Básicamente, este patrón ayuda a encapsular acciones secuenciales sobre un objeto. Por ejemplo, en un sistema de pedidos donde hay que realizar una secuencia de pasos para una determinada acción. Un caso que se me ocurre es el de realizar un proceso de scoring sobre un pedido que puede partirse en distintos pasos.</p><p>Aunque la teoría suele mostrar un diagrama y un caso de uso específico, me gusta adaptar los patrones a las necesidades, por lo que no debemos de ser tan puristas. En este patrón, los handlers pueden directamente parar la cadena, pero también puedes hacer que pase la responsabilidad al siguiente habiendo concluida ya su acción. También puede ser que pase por toda la cadena pero solo ciertos handlers ejecuten pasos. Las posibilidades son diversas y van a depender de la necesidad de tu caso de uso.</p><h3>¿Cómo sabemos cuando usarlo?</h3><p>En mi caso suelo identificar la necesidad si tenemos un proceso basado en pasos, que tenemos que ir añadiendo verificaciones y cada vez que aumenta la funcionalidad el código empieza a estar plagado de ifs. Este patrón ayuda a identificar a separar las responsabilidades que realizar en cada paso. Por ejemplo, en el caso del scoring de un pedido, podemos identificar distintos pasos como pueden ser:</p><ul><li>¿El cliente del pedido ya tiene pedidos previos?</li><li>¿El cliente del pedido realiza el pago con método de pago habitual?</li><li>¿El pedido es superior a cierta cantidad?</li></ul><p>Lo ideal es que cada paso del proceso pueda separarse en distintas clase con una sola responsabilidad, haciendo que el pedido/petición por la cadena de manejadores y obtengamos un resultado final.</p><h3>¿Cómo lo implementamos?</h3><p>Al igual que muchos otros patrones de diseño de comportamiento, la solución se basa en la transformación de comportamientos particulares en objetos independientes llamados <em>Handlers, </em>Básicamente cada verificación del proceso debe extraerse a su propia clase con un único método que realice la acción corresponde. La solicitud, junto con sus datos y contexto, se pasa a este método como argumento para inicializar la cadena.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*7PGB4poMp_-feEy2.png" /></figure><p>Existen un montón de ejemplos de implementaciones. Recomiendo echar un vistazo la de <a href="https://refactoring.guru/design-patterns/chain-of-responsibility/php/example"><strong>refactoring.guru</strong></a> , igualmente al final del artículo incluiré un ejemplo concreto de implementación del patrón en ES6.</p><h3>Ventajas del uso del patrón</h3><p>Y una vez que tenemos implementado nuestro patrón, <em>¿Qué ventajas recibimos? ¿La jerarquía de clases que hemos creado para aplicarlo nos proporciona realmente utilidad?</em> A continuación identifico las ventajas principales y que principios SOLID cumplimos con el uso de este patrón:</p><ul><li><strong>Manejas el orden de los pasos:</strong> Controla el orden en el que se ejecutan los pasos de manera dinámica</li><li><strong>Aplicas el principio <em>Single Responsibility Principle:</em></strong> Desacopla en clases la invocación de las operaciones y la realización de la propia acción. Pudiendo testear fácilmente cada acción por separado</li><li><strong>Aplicas el principio <em>Open/Closed Principle:</em></strong> Permite ampliar con nuevos manejadores sin romper código existente, mejorando así la mantenibilidad.</li></ul><h3>Caso de uso real</h3><p>A continuación, voy a describir el caso de uso real donde he implementado este patrón. Desarrollando una aplicación React, tenía que implementar una serie de filtros sobre una serie de elementos. Por el volumen de esta serie de elementos se decidió implementar el filtrado directamente en el frontend y evitar llamadas al backend por cada interacción del usuario.</p><p>Estos filtros requerían distintos tipos de acciones, pudiendo tener dependencias entre ellos y actuando todos juntos. Además de acciones de filtrado había que implementar una serie de ordenados sobre los elementos.</p><p>Al final me abstraje del problema y lo que identifiqué es un conjunto de elementos sobre el que debía de implementarse una serie de pasos secuenciales para obtener un resultado final. De tal manera que le tocó el turno a Chain of Responsability</p><h3>Implementación</h3><p>El primer paso siempre es identificar al handler, implementando una clase abstracta con los métodos que requiera para el caso de uso. En mi caso aplicar el filtro y un método que identifique si ese handler debe ser ejecutado en función de los filtros activos por el usuario. A continuación la clase abstracta <strong><em>AbstractFilterHandler</em></strong> implementada:</p><pre>class AbstractFilterHandler {<br>  constructor() {}</pre><pre>applyFilter() {<br>    this._WARNING(&quot;applyFilter(elements, filters)&quot;);<br>  }</pre><pre>canIHandle() {<br>    this._WARNING(&quot;canIHandle(elements, filters)&quot;);<br>  }</pre><pre>_WARNING(fName = &quot;unknown method&quot;) {<br>    console.warn(&#39;WARNING! Function &quot;&#39; + fName + &#39;&quot; is not overridden in &#39; + this.constructor.name);<br>  }<br>}<br>export default AbstractFilterHandler;</pre><p>Una vez tenemos la clase abstracta debemos de implantar cada manejador específico. Para este artículo vamos a mostrar el ejemplo del manejador que filtra aquellos elementos que incluyen ciertos modelos:</p><pre>import AbstractFilterHandler from &quot;./filter&quot;;</pre><pre>class ModelsFilterHandler extends AbstractFilterHandler {<br>  applyFilter(elements, filters) {<br>    return elements.filter(a =&gt; filters.models.includes(a.model.slug));<br>  }</pre><pre>canIHandle(filters) {<br>    return filters.models &amp;&amp; filters.models.length &gt; 0;<br>  }<br>}<br>export default ModelsFilterHandler;</pre><p>Como vemos en la implementación, en el método canIHandle() indicamos que el handler solo se invocará cuando en los filtros contengan modelos. Por otro lado el método applyFilter() implementa la acción realizada sobre los elementos.</p><p>El siguiente paso es el de construir la cadena que se encarga de ejecutar el filtrado sobre los elementos y dar de alta los manejadores específicos. Para ello hemos creado la clase FilterChain:</p><pre>import * as Handlers from &quot;./filters&quot;;<br> <br>class FilterChain {<br>  constructor(elements, filters) {<br>    this.elements = elements;<br>    this.filters = filters;<br>    this.handlers = [];<br>  }<br> <br>  /**<br>   *<br>   * <a href="http://twitter.com/param">@param</a> {AbstractFilterHandler} filter<br>   */<br>  addHandler(handler) {<br>    this.handlers.push(handler);<br>  }<br> <br>  applyFilters() {<br>    let elements = this.elements;<br>    this.handlers.forEach(handler =&gt; {<br>      if (handler.canIHandle(this.filters)) {<br>        elements = handler.applyFilter(elements, this.filters);<br>      }<br>    });<br> <br>    return elements;<br>  }<br>}<br>export default FilterChain;</pre><p>Como vemos, esta clase se encarga de recibir los elementos sobre los que se realizan la acción, el contexto de los filtros activos por el usuario y los manejadores que deben de ejecutarse. El método applyFilters() será el punto de entrada para la ejecución de la cadena.</p><p>Para ejecutar el patrón en nuestro código simplemente tenemos que dar de alta el Chain y sus Handlers y llamar al método applyFilters:</p><pre>let chain = new FilterChain(elements, filters);<br>chain.addHandler(new Handlers.ModelsFilterHandler());<br>chain.addHandler(new Handlers.OrderByPriceFilterHandler());</pre><pre>let result = handler.applyFilters(elements, filters);</pre><p>Con estos sencillos pasos, hemos abstraído cada lógica de filtrado/ordenando en una clase distinta, evitando un código acoplado y sin una responsabilidad clara.</p><p>Espero que el caso de uso real os ayude a interiorizar mejor este patrón de diseño y se comience a darle más uso. Y tú <strong><em>¿Has usado alguna vez este patrón de diseño? ¿Que casos concretos te ha ayudado a solucionar? ¿Que ventajas te ha aportado?</em></strong></p><p><strong>Más información del patrón</strong></p><p><a href="https://refactoring.guru/design-patterns/chain-of-responsibility">https://refactoring.guru/design-patterns/chain-of-responsibility</a></p><p><a href="https://github.com/domnikl/DesignPatternsPHP/tree/master/Behavioral/ChainOfResponsibilities">https://github.com/domnikl/DesignPatternsPHP/tree/master/Behavioral/ChainOfResponsibilities</a></p><p><a href="https://www.joezimjs.com/javascript/javascript-design-patterns-chain-of-responsibility/">JavaScript Design Patterns: Chain of Responsibility</a></p><p><strong>Artículo publicado en</strong> <a href="https://adrianalonso.es/arquitectura-del-software/patrones-de-diseno-chain-of-responsability/">https://adrianalonso.es/arquitectura-del-software/patrones-de-diseno-chain-of-responsability/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1460ee11c476" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Buenas prácticas de desarrollo para el rendimiento de microservicios]]></title>
            <link>https://adrianalonsodev.medium.com/buenas-pr%C3%A1cticas-de-desarrollo-para-el-rendimiento-de-microservicios-a250e82f6e43?source=rss-f754bd174f5------2</link>
            <guid isPermaLink="false">https://medium.com/p/a250e82f6e43</guid>
            <category><![CDATA[best-practices]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[performance]]></category>
            <dc:creator><![CDATA[Adrián Alonso]]></dc:creator>
            <pubDate>Sun, 21 Jul 2019 15:11:33 GMT</pubDate>
            <atom:updated>2019-07-21T15:15:29.178Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ypNFraUi1OrT_cUe.jpg" /></figure><p>En el ultimo desarrollo que hemos trabajado durante meses, se planteó una <strong>arquitectura de microservicios</strong> para crear un gestor de contenidos a medida. Separar la responsabilidad en pequeños servicios nos proporcionó ciertas ventajas respecto al legacy monolítico que heredábamos, ya que nos proporcionaba al equipo trabajar sobre ciertos aspectos independientes desacoplando cada pieza. Esto proporciona ventajas que ya conocemos de este tipo de arquitecturas, como la independencia o el despliegue independiente, sin embargo no debemos de olvidarnos del rendimiento.</p><p>Aún teniendo siempre una visión global, al comienzo del desarrollo pudimos paralelizar bien el trabajo de cada desarrollador, avanzando con gran velocidad con cada uno de los servicios. Sin embargo, nos dimos cuenta que hay que tener la madurez suficiente como equipo para orquestar todos los servicios para servir la funcionalidad necesaria a cada tercero. Aunque este tipo de arquitecturas proporciona ciertas ventajas, hay que tener en mente que hay otros aspectos que pueden penalizar como pueden ser el rendimiento.</p><p>El sistema que construimos no solo iba a servir contenido a un website, si no que iba a ser fuente de consumo de muchos otros servicios. Otro día hablaremos de la arquitectura completa, pero el objetivo de este artículo es proporcionar algunos <strong>consejos de rendimiento</strong> a la hora de conectar los microservicios a través de los aprendizajes que fuimos adquiriendo.</p><h3>Utilizar el modelo CRUD en cada servicio</h3><p>Los microservicios al tener una responsabilidad acotada, son realmente buenos para utilizar el patron CRUD (Create, Read, Update, Delete) para acceder a los modelos con los que trabajamos realizando llamadas independientes por cada acción, lo que permite monitorizar correctamente la traza de llamadas. Mi recomendación es utilizar alguna herramienta que permita construir rápidamente estas operaciones como puede ser <a href="https://adrianalonso.es/desarrollo-web/es-api-platform-el-framework-adecuado-para-tu-desarrollo/"><strong>API Platform</strong></a>, agilizando el desarrollo e independizando las operaciones.</p><p>Respecto al performance, en nuestro caso abrimos dos versiones de CRUD por cada entidad. Una versión privada con mayor serializado de información y tratamiento de datos privados para ser accesibles por los distintos roles que accedían al backoffice del gestor de contenidos. Por otro lado, construimos unos endpoints de lectura públicos mucho más ligeros con la información pública necesaria. Estos endpoints estaban optimizados para las lecturas y con una pequeña capa de <a href="https://github.com/FriendsOfSymfony/FOSHttpCache">cache HTTP</a></p><h3>Proveer batch APIs</h3><p>Aún construyendo las APIs con el patrón CRUD, para proporcionar un buen rendimiento es importante poder consultar por grupos de ids las entidades. Imagina una relación 1xN, por ejemplo usuario y avatar, en la que por cada usuario tengamos que consultar a otro servicio la url de cada avatar. Para estos casos existen alternativas como desnormalizar y guardar junto al usuario esa url de avatar, pero con la complejidad de proporcionar un mecanismo de las actualizaciones en el segundo servicio.</p><p>En algunos casos utilizamos esta técnica para premiar el performance, pero en otros casos permitimos esa consulta por array de ids pudiendo recuperar en una sola llamada todos los avatares y asignándolos en el servicio de pegamento a cada usuario. Esto justamente es lo que hace React Admin por defecto en sus listados, y como utilizamos esta herramienta para la construcción del backoffice dotamos a los GET de esa funcionalidad. Por ejemplo, teníamos un servicio que gestionaba todos los assets del sistema por lo que toda entidad que debiera de tener un asset en sus listados debiera de llamar de la siguiente forma:</p><p>Request:</p><blockquote>GET /api/admin/v1/images?filter={“id”:[381168,381123,381055,381026,381023,380298,381126,381040,381041]}</blockquote><p><strong>Response</strong></p><p>[{<br> “id”: 381168,<br> “name”: “Image Name”,<br> “caption”: “Image Caption”,<br> “slug”: “image-slug”,<br> “watermakedUrl”: null,<br> “watermarked”: false,<br> “resizes”: [{<br> “url”: “<a href="https://mydomain.com/xsmall.png">https://mydomain.com/xsmall.png</a>&quot;,<br> “type”: “xsmall”,<br> “createdAt”: “2019–07–15T10:20:04+00:00”,<br> “updatedAt”: “2019–07–15T10:20:04+00:00”<br> }, {<br> “url”: “<a href="https://mydomain.com/small.png">https://mydomain.com/small.png</a>&quot;,<br> “type”: “small”,<br> “createdAt”: “2019–07–15T10:20:04+00:00”,<br> “updatedAt”: “2019–07–15T10:20:04+00:00”<br> }, {<br> “url”: “<a href="https://mydomain.com/medium.png">https://mydomain.com/medium.png</a>&quot;,<br> “type”: “medium”,<br> “createdAt”: “2019–07–15T10:20:04+00:00”,<br> “updatedAt”: “2019–07–15T10:20:04+00:00”<br> }, {<br> “url”: “<a href="https://mydomain.com/large.png">https://mydomain.com/large.png</a>&quot;,<br> “type”: “large”,<br> “createdAt”: “2019–07–15T10:20:04+00:00”,<br> “updatedAt”: “2019–07–15T10:20:04+00:00”<br> }, {<br> “url”: “<a href="https://mydomain.com/xlarge.png">https://mydomain.com/xlarge.png</a>&quot;,<br> “type”: “xlarge”,<br> “createdAt”: “2019–07–15T10:20:05+00:00”,<br> “updatedAt”: “2019–07–15T10:20:05+00:00”<br> }],<br> “asset”: {<br> “id”: 397231,<br> “headers”: {<br> “ContentType”: “image\/png”<br> },<br> “fileDir”: “<a href="https://mydomain.com/original.png">https://mydomain.com/original.png</a>&quot;,<br> “filename”: “filename.png”,<br> “creator”: null,<br> “createdAt”: “2019–07–15T10:18:41+00:00”,<br> “updatedAt”: “2019–07–15T10:18:41+00:00”,<br> “trash”: false<br> },<br> “metadatas”: [],<br> “createdAt”: “2019–07–15T10:19:14+00:00”,<br> “updatedAt”: “2019–07–15T10:19:14+00:00”,<br> “tags”: [“tag1”, “tag2”, “tag3”],<br> “trash”: false,<br> “publishedAt”: null<br> }]</p><h3>Utiliza el modelo asíncrono de peticiones</h3><p>Cuando los servicios estén listos, se necesita de un orquestador para realizar las llamadas a cada servicio y componer una feature completa. Algunos frameworks de microservicios como el de Netflix proporcionan sus <a href="https://medium.com/netflix-techblog/netflix-conductor-a-microservices-orchestrator-2e8d4771bf40">propios mecanismos</a> de orquestación. Sin embargo, si se construye uno a medida, la recomendación es si vas a interactuar con muchos microservicios para componer una respuesta, lo ideal es paralelizar las llamadas describiendo bien que requests son dependientes de cuales construyendo un modelo en el que consumamos el menor tiempo posible en construir nuestra respuesta.</p><p>En nuestro caso, además de paralelizar las peticiones, nos apoyamos en una capa sobre <a href="https://adrianalonso.es/desarrollo-web/utilizando-redis-como-sistema-de-cache-en-symfony/">Redis</a> para cachear esas responses evitando la llamada, en nuestro caso por comunicación HTTP. Para paralelizar las llamadas nos apoyamos en el modelo de promises que proporciona <a href="http://docs.guzzlephp.org/en/stable/faq.html">Guzzle</a>. Aunque es importante decir aquí que el <a href="https://symfony.com/doc/current/components/http_client.html">cliente http</a>que ha construido Symfony ya proporciona de este mecanismo (<a href="https://gist.github.com/tgalopin/a84a11ece0621b8a79ed923afe015b3c">Gist</a>) y recomiendo echarle un vistazo.</p><p>``</p><p><em>/**</em></p><p><em>* @return array</em></p><p><em>*/</em></p><p>private function executeConcurrentRequests(array $requests)</p><p>{</p><p>$client = new Client();</p><p>return Pool::batch($client, $requests, [&#39;concurrency&#39; =&gt; count($requests]);</p><p>}</p><h3>Usar la ruta mas corta</h3><p>Si se tiene control sobre la red en la que se monta la infraestructura, es importante intentar atacar internamente las rutas mas cortas evitando redirecciones, resolución de dns y proxys intermedios que añadan milisegundos adicionales. Es muy importante trabajar de la mano de los equipos de sistemas para configurar nuestras variables de entornos de manera adecuada apuntando a los nombres de servicios adecuados depende del contexto.</p><p>Si trabajamos con un proveedor de Cloud, también es muy importante tener en cuenta los datacenter donde se despliegan cada pieza para que tampoco tengamos una gran latencia de red por la ubicación. Aunque tu desarrollo funcione correctamente en una infraestructura de desarrollo, debe de probarse cuanto antes en la infraestructura real para poder detectar este tipo de problemas.</p><h3>Simplificar el modelo de seguridad</h3><p>No es bueno para el rendimiento utilizar mecanismos de seguridad que implican muchas comunicaciones de ida y vuelta para autenticar una llamada. Por lo que es importante identificar donde se requiere y donde no el modelo de autenticación e intentar simplificarlo al máximo para que cada servicio no añada unos milisegundos adicionales de validación de tokens. En nuestro caso, añadir la validación del token lo antes posibles y hacer independientes a otros servicios de esta validación confiando con otros modelos de seguridad que la petición recibida del servicio X es válida.</p><h3>Debuggear las llamadas http</h3><p>Es importante tener visibilidad sobre las llamadas que se están haciendo y el tiempo que consumen. Hay muchas herramientas para monitorizar este aspecto en tu desarrollo y depende mucho de las tecnologías que estemos usando. En nuestro caso como usamos Guzzle para realizar las llamadas http, nos proporciona en el <strong><em>Profiler de Symfony</em></strong> una pestaña adicional donde podemos ver todas las llamadas que se han realizado en el contexto de una request y el tiempo que ha llevado en responder.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ijE7Xa4tTuh48JGI.png" /></figure><h3>Conclusión</h3><p>Cuando se elige una arquitectura de software es importante identificar al comienzo del desarrollo las ventajas e inconvenientes que nos aplica, teniendo en cuenta los posibles problemas que te vas a enfrentar. Aunque confiemos en nuestras capas de cachés, es importante que cuando se consulte el dato frio, los tiempos sean aceptables para las necesidades del software. <strong><em>¡Mantén tus microservicios a dieta y paraleliza todo lo posible!</em></strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a250e82f6e43" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Review de “Talking with Tech Leads: From Novices to Practitioners”]]></title>
            <link>https://adrianalonsodev.medium.com/review-de-talking-with-tech-leads-from-novices-to-practitioners-ba18a10a54b4?source=rss-f754bd174f5------2</link>
            <guid isPermaLink="false">https://medium.com/p/ba18a10a54b4</guid>
            <category><![CDATA[lead-developers]]></category>
            <category><![CDATA[tech-leadership]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[team-leader]]></category>
            <category><![CDATA[technology]]></category>
            <dc:creator><![CDATA[Adrián Alonso]]></dc:creator>
            <pubDate>Mon, 25 Feb 2019 22:48:59 GMT</pubDate>
            <atom:updated>2019-02-25T22:48:59.022Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*l2W8xNT_RpdCkey3.jpg" /></figure><p>Hace unos meses a través de twitter encontré una recomendación del libro <strong><em>“Talking with Tech Leads: From Novices to Practitioners”</em></strong>. Cómo iba a embarcarme en una nueva experiencia laboral donde tendría que enfrentarme a este rol, decidí comprarlo para ver la perspectiva de personas con esta experiencia. Por fin he terminado el libro y quería haceros un pequeño review de lo que os podéis encontrar y algunos aprendizajes que se obtienen al finalizar el libro.</p><p>De hecho, una review en Amazon indica que es ideal para aquellos que acabamos de comenzar en este rol, así que si estáis empezando o lleváis poco tiempo, deberíais darle una oportunidad a esta lectura.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/660/0*k7k1A44DVLE44DaX.png" /></figure><h3>¿Que vas a encontrar en el libro “Talking with Tech Leads”?</h3><p>El libro se describe asimismo como un libro de <strong>Tech Leads para Tech Leads.</strong>Básicamente se trata de 35 entrevistas a diferentes Tech Leads y como encuentran el equilibrio entre el mundo técnico y el no técnico.</p><p>Estas entrevistas recorren la perspectiva desde personas que acaban de llegar al rol, hasta personas que llevan muchos años de experiencia liderando equipos de desarrollo. Estos son entrevistados y proporcionan su perspectiva sobre los<strong> retos a los que se puede llegar a enfrenta un líder técnico y cómo llegar a superarlos</strong>.</p><h3>Sobre el Autor: Patrick Kua</h3><p>El autor de este libro es <strong>Patrick Kua</strong>. Patrick actualmente es el CTO de N26 (Berlín, Alemania). Anteriormente ha sido consultor técnico en <strong><em>ThoughtWorks</em></strong>. En el libro bastantes entrevistados pertenecen a esta empresa, que para el que no la conozca, es la empresa para la que trabaja Martin Fowler.</p><p>Patrick es el autor de otros libros, como <em>The Retrospective Handbook</em> o <em>Building Evolutionary Architectures</em>. Patrick es un autor muy activo, participa en conferencias internacionales y tiene un <a href="http://www.thekua.com/atwork">blog</a> muy interesante. Podéis seguir sus novedades a través de su cuenta de Twitter <a href="https://twitter.com/patkua">@patkua</a> o ver otros libros del autor a través de <a href="https://leanpub.com/u/thekua">LeanPub.</a></p><h3>Review del libro</h3><p>El libro contiene una estructura muy interesante, ya que se encuentra dividido en<strong>bloques de entrevistas</strong> en los que se refieren a distintos aspectos del rol de Tech Lead. Hemos hablado en otros artículo sobre las habilidades necesarias para un <a href="https://adrianalonso.es/project-management/que-caracteristicas-debe-tener-un-lead-developer/">Tech Lead</a>, y en este libro se enfatiza en todas ellas, pero curiosamente se identifican las labores menos técnicas como las mas importantes del rol.</p><ul><li>En el <strong>primer bloque</strong>, se trata la evolución natural de un desarrollador con varios años de experiencia hacia el rol de Tech Lead. En esta parte los entrevistados destacan el cambio de perspectiva, la capacidad de alejarse y tener una visión global del proyecto y de la empresa y lidiar con las peculiaridades del rol, que es de escribir menos software, pero si saber transmitir el camino adecuado a los miembros del equipo.</li><li>En el <strong>segundo bloque</strong>, se dedican 100% a las personas, tan importantes para formar un equipo, y donde el Tech Lead hace un rol fundamental. Debe saber delegar en muchas ocasiones, facilitar al resto el camino hacia la buena dirección y entender que el equipo es lo más importante. Es importante conseguir ser un referente dentro del equipo para conseguir su máximo rendimiento.</li><li>El <strong>tercer bloque,</strong> se dedica a la parte más técnica. Aunque en el libro se destaca que un Tech Lead no tiene que ser el perfil con más experiencia técnica del equipo, debe de lidiar con aspectos técnicos muy importantes para los proyectos.</li><li>De hecho se destaca que en muchas empresas proponen al mejor desarrollador del equipo como Tech Lead y lo que se pierde es un gran programador, quizás no siendo la persona mas adecuada para ejercer el rol. En estas decisiones técnicas hay que aplicar conocimientos sobre arquitectura, soluciones de diseño y tener en cuenta los requisitos del propio proyecto. Además debe de tener en mente siempre la deuda técnica y la salud del proyecto, manteniendo un equilibrio entre la calidad del software y la entrega a tiempo.</li><li>El <strong>cuarto bloque</strong>, está dedicado a como el Tech Lead debe de alinearse con negocio, entender y describir correctamente las funcionalidades y servir de puente para que desarrollo y negocio se entiendan correctamente, luchando por sus propios intereses.</li></ul><h3>Lecciones aprendidas</h3><p>Finalmente, el libro concluye con ciertas<strong> lecciones y puntos claves</strong> que se obtienen a través de las 35 entrevistas. A continuación voy a listar aquellos<strong> aprendizajes</strong> que más interesantes me parecen destacar tras finalizar la lectura:</p><ul><li><strong>Mantente cerca del código:</strong> Nunca te alejes de escribir software, el equipo te respetará más si te bajas al barro y no pierdes el contacto con el día a día del código.</li><li><strong>Desarrolla un buen equipo:</strong> Como Tech Lead, eres responsable de que el equipo crezca y crear un ambiente colaborativo</li><li><strong>Escucha al equipo:</strong> Los desarrolladores pasamos mucho tiempo dando opiniones. Antes de tomar decisiones se debe consensuar con el equipo para encontrar las mejores soluciones.</li><li><strong>Aprecia las distintas habilidades</strong>: Dentro de un equipo existen distintos tipos de fortalezas y debilidades, es por ello saber identificarlas y aprovecharlas para sacar lo mejor de cada uno.</li><li><strong>Guía sobre la solución técnica:</strong> Es responsabilidad del Tech Lead compartir la visión técnica con el resto del equipo. Apóyate en pizarras y diagramas para alinear a todos los miembros.</li><li><strong>Resuelve el conflicto:</strong> Pueden ocurrir discrepancias entre miembros del equipo para resolver ciertos aspectos. Es tu responsabilidad arbitrar en estas circunstancias evitando el conflicto y buscando soluciones cómodas para todos.</li><li><strong>Manejar el riesgo técnico y tener una visión global:</strong> Habitualmente los desarrolladores nos centramos en una visión muy cercana al problema concreto que estamos resolviendo. Sin embargo, el Tech Lead debe de preocuparse de que las elecciones de hoy pueden convertirse en problemas mañana.</li><li><strong>Construye soluciones fácil de entender:</strong> Simplifica al máximo, evita la complejidad extra y busca analogías para transmitir el lado técnico al resto de <em>stakeholders</em> no técnicos, para poder tomar decisiones juntos.</li><li><strong>Entiende las necesidades de negocio:</strong> Debes de entender las necesidades de los usuarios y ver cómo una solución técnica puede impactar a los usuarios finales.</li><li><strong>Adáptate a las circunstancias:</strong> Debes de evolucionar habilidades no técnicas a las que nunca te has enfrentado, estate abierto a adaptarte a diversas situaciones.</li><li><strong>Mantente innecesario: </strong>Trata de llegar a esa situación en el que la maquinaria sigue funcionando a la perfección aunque estés ausente, no juegues al rol de héroe. Lidera para que el equipo siga funcionando sin tu constante involucramiento.</li></ul><h3>Conclusión</h3><p>Espero que este review sirva para que más personas lean este libro. Desde mi perspectiva, es un libro que refleja muy bien el punto de vista de este rol y personalmente me ha proporcionado buenos consejos para aplicar en mi día a día como Tech Lead. Si tienes alguna otra recomendación de lectura sobre el rol de Tech Lead o has leído este libro, te animo a que abramos un debate en los comentarios.</p><p><strong>Artículo publicado en: </strong><a href="https://adrianalonso.es/project-management/review-de-talking-with-tech-leads/">https://adrianalonso.es/project-management/review-de-talking-with-tech-leads/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ba18a10a54b4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Recorrido por las 10 dinámicas de Agile Inception]]></title>
            <link>https://adrianalonsodev.medium.com/recorrido-por-las-10-din%C3%A1micas-de-agile-inception-d6ebbd1af2ef?source=rss-f754bd174f5------2</link>
            <guid isPermaLink="false">https://medium.com/p/d6ebbd1af2ef</guid>
            <category><![CDATA[agile]]></category>
            <category><![CDATA[agile-inception]]></category>
            <category><![CDATA[agile-product-development]]></category>
            <category><![CDATA[mvp]]></category>
            <category><![CDATA[inception]]></category>
            <dc:creator><![CDATA[Adrián Alonso]]></dc:creator>
            <pubDate>Fri, 15 Feb 2019 22:37:16 GMT</pubDate>
            <atom:updated>2019-02-15T22:42:00.758Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Agile Inception</strong>, o también conocido como <em>Inception Deck</em>, es un conjunto de técnicas orientadas a alinear a todas las personas involucradas en un proyecto.</p><p>El <strong>objetivo</strong> de estas técnicas es el de reducir muchas de las incertidumbres que puedan surgir, ayudando a identificar los riesgos más evidentes y poniendo en común las expectativas de todos los stakeholders. Esto permite reducir considerablemente la falta de consenso, problemas de comunicación y la ambigüedad en ciertas partes del proyecto.</p><p>Estas técnicas se publicaron por primera vez en el libro <strong><em>“The Agile Samurai: How Agile Masters Deliver Great Software”</em></strong>. Se puede aplicar al iniciar cualquier tipo de proyecto, no sólo de desarrollo software, aunque está pensado especialmente en las fases conceptualización de startups porque facilita la definición de Productos Mínimos Viables (MVP).</p><p>El<strong> output de Agile Inception</strong> nos ayuda considerablemente en la identificación de funcionalidades, roadmapping y definición de una arquitectura de alto nivel. Estas técnicas se centran en <strong>comunicar los objetivos, la visión y el contexto del proyecto al equipo</strong> para que se puedan tomar decisiones inteligentes mientras se ejecuta este y proporciona a los stakeholders la información que necesitan para ayudarlos. Ya que estas técnicas son <strong>muy colaborativas</strong> se requieren de materiales como <strong><em>post-its, pizarras y rotuladores</em></strong><em> </em>para poder participar y colaborar en un escenario común.</p><p>Como he tenido que realizar en el master de “<strong><em>Gestión y Dirección de Proyectos Software</em></strong>” una práctica recorriendo cada una de las técnicas de Agile Inception, vamos a ver una pequeña descripción de cada una de las técnicas y un ejemplo con la aplicación de mensajería instantánea Whatsapp.</p><p>Mucho de los ejemplos se han construido con una herramienta online <strong>Realtime Board</strong> (<a href="https://realtimeboard.com/">https://realtimeboard.com</a>) que nos permite construir los distintos tipos escenarios simulando el uso de post-its.</p><h3>1. Why are we here?</h3><p>La primera de las preguntas que debemos hacernos en <em>Agile Inception</em> es encontrar los motivos por los que este proyecto tiene sentido para el cliente preguntándonos<strong> ¿por qué estamos aquí? </strong>Descubriendo los motivos principal de nuestro proyecto, nos va a dar el conocimiento suficiente para ayudarnos en la toma de decisiones y entender el contexto de uso. Para que la comunicación fluya en esta fase de discovering, se utilizan técnicas como World Coffee, donde los interlocutores interactúan potenciando la comunicación en distintos espacios de conversación. Otra técnica útil es el <a href="https://adrianalonso.es/project-management/tecnicas-agiles-impact-mapping/">Impact Mapping</a> el cual hablamos en posts anteriores.</p><h4>Ejemplo</h4><p>El producto que se desea construir es una aplicación de <strong>mensajería instantánea</strong> para smartphones. Cada día nos encontramos más conectados, y el objetivo es lanzar un producto que permita a <strong>millones de personas poder comunicarse</strong>. El target principal de consumo de esta aplicación es cualquier persona física con un smartphone, pero también señalar la importancia de las herramientas de comunicación dentro de las empresas.</p><p>El impulsor principal del proyecto no es otro que mejorar la comunicación de las personas de una manera sencilla, accesible y segura para todos.</p><p>Tras una sesión de<em> world coffee</em> se han obtenido los siguientes <strong><em>key points</em></strong>:</p><ul><li>Las<strong> funcionalidades principales</strong> son la mensajería vía chat, la privacidad de la comunicación, la compartición de contenido multimedia y la facilidad de uso</li><li>Los objetivos de negocio son los de tener la mayor cuota del mercado respecto otras aplicaciones de mensajería instantánea y llegar a cualquier tipo de dispositivo</li><li>Entre los requisitos no funcionales principales destacan la disponibilidad, la seguridad y la usabilidad</li><li>Entre los riesgos principales han destacado la gran competencia del sector,</li></ul><h3>2. Elevator Pitch</h3><p>En este apartado el objetivo es construir un briefing de 45 segundos que resuma el proyecto y se centre en el valor real del producto. Es importante que en este discurso nos centremos en los elementos principales que queremos transmitir. Por ello debemos de centrarnos en las necesidades, la solución propuesta, como se encuentra el mercado, cuales son los competidores y cual es nuestra propuesta de valor.</p><h4>Ejemplo</h4><p><strong>Para</strong> los usuarios habituados al uso del smartphone</p><p><strong>Quienes </strong>desean poder comunicarse con su círculo social estén donde estén</p><p><strong>Whatsapp </strong>es una aplicación móvil</p><p><strong>Que pretende </strong>posicionarse como aplicación de mensajería instántanea principal</p><p><strong>En lugar de alternativas </strong>como Telegram, Line o Skype</p><p><strong>Con el valor diferenciador </strong>de ofrecer una experiencia sencilla para todo tipo de consumidor y con una privacidad absoluta de las comunicaciones.</p><h3>3. Product Box</h3><p>En este apartado el objetivo es construir una caja de producto como si la ofreciéramos en un centro comercial, junto a sus slogans principales. Diseñar una caja de producto es un concepto relacionado con marketing que nos invita a imaginar la caja de un producto con los mensajes e imágenes necesarias como si nuestro producto estuviera empaquetado y fuera a estar expuesto de forma que resulte lo más atractivo posible para el cliente.</p><h4>Ejemplo</h4><p>Para ello se ha construido la siguiente caja, jugando con simplicidad y con un slogan con sus tres claves “comunicación instantánea y segura”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/427/0*EkjjAkfw1ACsLpuy.png" /></figure><h3>4. NOT List</h3><p>Una lista de Noes lo que hace es establecer las fronteras del producto a la hora de empezar a hablar, estableciendo un punto de referencia a las expectativas sobre lo que no se va a considerar como parte del proyecto. Esto es importante por qué es lo que nos va a determinar el alcance del proyecto.</p><h4>Ejemplo</h4><p>Para ello se ha construido el siguiente tablero con tres zonas principales: <em>En Alcance, Fuera de Alcance y Por decidir:</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/0*DlnMS31US70jb9HD.png" /></figure><p>Como vemos, hemos diferenciado entre aquellas funcionalidades que no entran dentro del desarrollo de producto, las que están claras que son necesarias y aquellas que deben de resolver si entran o no entran en el alcance. Esto proporciona una primera aproximación de las funcionalidades principales del producto que se abordarán en el desarrollo del MVP.</p><h3>5. Meet your neighbors</h3><p>Es importante que todos los stakeholders del proyecto tengan en su radar al resto. Los entornos empresariales suelen ser grandes, y habitualmente no somos capaces de identificar cuántas personas están involucradas para lograr que el proyecto sea un éxito.</p><p>Es mejor establecer pronto las relaciones entre los miembros y generar un nexo confianza entre los mismos, esto implica que a la hora de enfrentar ciertos problemas la comunicación y el compañerismo será mejor</p><h4>Ejemplo</h4><p>En nuestro caso vamos a identificar a todos los actores involucrados en el proyecto.</p><ul><li>Equipo de Desarrollo</li><li>Equipo de Diseño</li><li>Equipo de UX</li><li>Product Owner</li><li>Equipo de Analítica</li><li>Departamento de Marketing</li><li>Finanzas</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/547/0*Hwlddu00g2sFHHt5.png" /></figure><p>Como vemos, existe un equipo core formado por los equipos de desarrollo, UX y diseño, liderados por el product owner y luego stakeholders interesados en medida en la evolución del proyecto como pueden ser el equipo de marketing, de analítica y de finanzas. Hemos identificado cuanto de importante son los equipos para lograr el éxito del proyecto.</p><h3>6. Show the solution</h3><p>En este apartado se debe de trabajar en conjunto para mostrar una primera aproximación de la solución, planteando arquitectura, tecnología y herramientas que serían necesarias para la construcción del producto.</p><p>Esto conlleva generar expectativas, visualizar suposiciones, que todo los involucrados tengan claro el producto y sus principales escenarios.</p><h4>Ejemplo</h4><p>Para lograr esto, se ha trabajado junto con unas plantillas móviles para diseñar entre todos un prototipado de baja fidelidad que represente cómo sería la interacción del usuario final con nuestro producto</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/628/0*mq0HdEfzLBP3Whpe.png" /></figure><h3>7. Keep us at night</h3><p>En este apartado debemos detectar aquellas cosas que nos pueden mantener despiertos por la noche. Es el lugar adecuado para que salgan a la luz aquellos riesgos que puedan influir en el desarrollo del producto, desde todas las perspectivas posibles. De tal manera que detectando estos riesgos podremos manejarlos y tenerlos en mente durante la evolución del proyecto, siendo consciente de las posibles desviaciones que puedan conllevar.</p><h3>Ejemplo</h3><p>Para ello se ha construido una matriz de riesgo a partir de una dinámica de post its donde todos los involucrados han expuesto los posibles riesgos y etiquetados entre todos entre Bajo, Medio y Alto riesgo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/638/0*i4Np880r-4JRTrSG.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/637/1*ytHhgyjIcTNEXzFAiQMdtw.png" /><figcaption>Matriz de Riesgos</figcaption></figure><h3>8. Size it up</h3><p>En esta dinámica se trata de lograr una estimación de alto nivel de cuándo esfuerzo en recursos y tiempo puede conllevar el proyecto. No se trata de dar una estimación exacta, pero si de algo aproximado teniendo en cuenta todas las implicaciones que conlleva. Esto proporciona a los stakeholders una idea de cuánto de grande es lo que se desea construir. El objetivo no es la precisión pero si aproximar el posible tamaño.</p><h4>Ejemplo</h4><p>Para llevar a cabo esta técnica se ha construido un Gantt en el que han colaborado todos los equipos marcando ciertos hitos del proyecto con entregas funcionales.</p><p>El producto podría estar listo para lanzarse en el Q4 de 2019 aproximadamente en Septiembre. Y las funcionalidades más prioritarias tras el MVP, podrían lanzarse en dos paquetes de funcionalidades cada 3 meses.</p><p>A continuación se muestra en diagrama de Gantt de alto nivel en el que se detallan los distintos posibles hitos del proyecto. Se considera con la estimación que el desarrollo del producto abarca aproximadamente entre 9 y 15 meses.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/655/0*xyt1FZ8XjFSzIZmb.png" /></figure><h3>9. Be clear on What’s going to give</h3><p>En esta dinámica se trata de establecer ciertas prioridades en los factores claves de ejecución del proyecto, y si entran en conflicto cuales son más prioritarios. Se deben establecer estas palancas, siempre teniendo en cuenta las 4 más importantes: Presupuesto, Alcance, Tiempo y Calidad. Además en este proyecto en cuestión entran en juegos dos factores adicionales claves para el éxito del proyecto que son la experiencia de usuario y la seguridad.</p><h3>Ejemplo</h3><p>Para ello todos los involucrados han priorizado del 1 al 6 los factores que entran en juego sin poder repetir la prioridad, de tal orden que queda un orden de factores.</p><ol><li><strong>Seguridad</strong> (El factor más importante es la seguridad, ya que el valor principal debe ser el servicio de mensajería instantánea más seguro, debido a los problemas de privacidad y la legislaciones surgidas en los últimos años</li><li><strong>Calidad</strong> (Para tener un valor diferenciar el producto debe ser robusto y de calidad</li><li><strong>Tiempo </strong>(Es importante no desviarse de la estimación realizada en el Size it Up por posibles competidores</li><li><strong>Experiencia de Usuario</strong> (La experiencia de usuario debe de ser buena, pero tampoco se requiere reinventar la rueda</li><li><strong>Alcance </strong>(El alcance no preocupa siempre que existan ciertas actualizaciones planificadas tras el lanzamiento, se podría prescindir de alguna funcionalidad que no sea core</li><li><strong>Presupuesto</strong> (Ha entrado un fuerte inversor, y el presupuesto a día de hoy no hay problema para añadir más recursos al proyecto.</li></ol><h3>10. Show what it’s going to take</h3><p>En esta dinámica se trata de calcular aproximadamente el número de personas involucradas para cumplir con las necesidades en el tiempo establecido y estimar el coste que pueda conllevar.</p><h3>Ejemplo</h3><p>Tras el recorrido de las distintas dinámicas se ha establecido que el equipo podría establecerse de esta manera:</p><ul><li>3 analistas programadores (2 senior y 1 junior)</li><li>1 diseñador senior</li><li>1 UX senior</li><li>1 Product Owner</li><li>1 Tester/QA</li><li>Aportaciones puntuales del equipo de analítica y marketing</li></ul><p>Con el equipo disponible y la estimación de tiempo de 1 año de media aproximado (9 a 15 meses), podemos dar la siguiente estimación:</p><p><strong>7 personas -&gt; 12 meses -&gt; 250K</strong></p><h3>Conclusión de Agile Inception</h3><p>Como hemos podido ver, todas las técnicas de Agile Inception tienen un nexo, ya que están focalizadas en visibilizar a todos los involucrados el alcance y necesidades del proyecto. Las 5 primeras técnicas se centran en el <strong>QUÉ</strong> mientras que las otras 5 se centran en el <strong>COMO</strong>. Este tipo de sesiones son caras de llevar a cabo ya que requiere de un día entero de todos los involucrados pero las ventajas que se logran cara al producto son notables.</p><p>Si has participado en algún tipo de workshop en el que has aplicado <em>Agile Inception</em> me gustaría que colaboraras en los comentarios de este post y nos contaras tu experiencia.</p><h3># Bonus Track</h3><p>La siguiente formación de <a href="http://www.elenaranjo.com/">Elena Naranjo</a> en el canal de youtube de CICE me ha parecido realmente útil e interesante. Os recomiendo que le echéis un vistazo para profundizar en las dinámicas y en la técnica de Agile Inception y User Story Mapping</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FMylkUKnH13g%3Ffeature%3Doembed&amp;url=http%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DMylkUKnH13g&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FMylkUKnH13g%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/20746c798f83d85e2ecbac0e62e6dab4/href">https://medium.com/media/20746c798f83d85e2ecbac0e62e6dab4/href</a></iframe><h3>Referencias</h3><p><a href="https://agilewarrior.wordpress.com/2010/11/06/the-agile-inception-deck/">https://agilewarrior.wordpress.com/2010/11/06/the-agile-inception-deck/</a></p><iframe src="https://drive.google.com/viewerng/viewer?url=https%3A//www.autentia.com/wp-content/uploads/2018/07/Mazo_Inception_Deck.pdf&amp;embedded=true" width="600" height="780" frameborder="0" scrolling="no"><a href="https://medium.com/media/4fced53c073120cac875dbdb398686f3/href">https://medium.com/media/4fced53c073120cac875dbdb398686f3/href</a></iframe><p>Artículo publicado en: <a href="https://adrianalonso.es/project-management/recorrido-10-dinamicas-de-agile-inception/">https://adrianalonso.es/project-management/recorrido-10-dinamicas-de-agile-inception/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d6ebbd1af2ef" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[5 pasos para construir nuestro User Story Mapping]]></title>
            <link>https://adrianalonsodev.medium.com/5-pasos-para-construir-nuestro-user-story-mapping-2674be8aeb60?source=rss-f754bd174f5------2</link>
            <guid isPermaLink="false">https://medium.com/p/2674be8aeb60</guid>
            <category><![CDATA[user-story-mapping]]></category>
            <category><![CDATA[agile]]></category>
            <category><![CDATA[agile-techniques]]></category>
            <category><![CDATA[agile-methodology]]></category>
            <category><![CDATA[post-it-notes]]></category>
            <dc:creator><![CDATA[Adrián Alonso]]></dc:creator>
            <pubDate>Tue, 05 Feb 2019 21:35:05 GMT</pubDate>
            <atom:updated>2019-02-05T21:35:05.898Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/640/0*T57I2BgTVTcMckSA.jpg" /></figure><p><strong>User Story Mapping</strong> es una técnica que consiste en organizar el <strong><em>Product Backlog</em></strong> en dos dimensiones con el objetivo de construir un Roadmap. Este mapa se compone de dos ejes, en uno de ellos las releases(vertical) y en el otro las funcionalidades (horizontal).</p><p>Es por ello que tras la fase de <a href="https://adrianalonso.es/project-management/recorrido-10-dinamicas-de-agile-inception/">Agile Inception</a>, vamos a construir el mapa utilizando un tablero de post-its, en el que identificamos la prioridad de las historias de usuario, y el orden de implementación agrupado en releases. Esto permite mejorar la visión de producto y construir una hoja de ruta clara y compartida por el equipo.</p><p>A continuación vamos a seguir los pasos necesarios para construir nuestro <strong>User Story Mapping</strong>.</p><h3>1. Identificar objetivos</h3><p>Lo primero que debemos de realizar es <strong>definir nuestros objetivos</strong>, para ello escribimos en tarjetas las ideas a muy alto nivel, de lo que representa el producto para negocio.</p><h3>2. Identificar Actividades</h3><p>A continuación debemos de identificar las actividades de alto nivel a partir de los objetivos definidos en el punto anterior. Estas actividades denominadas <strong>“épicas”</strong>, deben de posicionarse horizontalmente de tal manera que sigan un orden literario, como si de un storytelling se tratara. Esto nos proporciona una primera foto del producto.</p><h3>3. Describir el timeline</h3><p>A continuación, seguimos <strong>descomponiendo las épicas en historias de usuario</strong> más pequeñas, que sean más concretas y definan funcionalidades más específicas. Estas historias compondrán nuestras releases, las que iremos seleccionando en cada Sprint.</p><p>Para ello se colocan las historias debajo de su épica y las ordenamos en un orden lógico desde la perspectiva del usuario.</p><h3>4. Ordenar las historias</h3><p>Una vez descompuestas y ordenadas debemos desplazarlas a lo largo del eje vertical, quedando arriba las más importantes y abajo las menos importantes. Para ello se puede usar métodos como <a href="https://adrianalonso.es/project-management/priorizacion-requisitos-software-con-moscow/">MoSCoW</a>, del que hemos hablado en este blog.</p><h3>5. Identificar Releases</h3><p>Una vez descompuestas y ordenadas, debemos de focalizarnos en las historias superiores que definirán el conjunto de funcionalidades necesarias para <strong>definir el mínimo producto viable</strong> (MVP). De esta manera trazamos líneas horizontales, agrupando las historias de usuario en “releases” que marcarán nuestra hoja de ruta y aquellas entregas de funcionalidad que debemos de ir desarrollando. Se pueden mover historias para que el “release” tenga sentido y sea consistente.</p><h3>Ejemplo de User Story Mapping</h3><p>El siguiente ejemplo, es un ejemplo desarrollado para una aplicación de mensajería instantánea.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*3imudv7ykZBut96W.jpg" /></figure><h3>Conclusión</h3><p>Como hemos podido comprobar, la técnica de <strong>User Story Mapping</strong>, permite de una manera visual y colaborativa definir el mapa de funcionalidades de un producto. De un solo vistazo, tenemos el ‘<em>big picture</em>‘ de nuestro sistema en una sola instantánea, descompuesto de las ideas más generales a las más específicas. Además, la dinámica del ordenar por prioridad, nos permite establecer las necesidades del negocio.</p><p>Una vez que tenemos plasmado nuestro mapa es muy sencillo agrupar las funcionalidades en releases para tener una hoja de ruta que seguir, aunque este proceso no debe ser estático, si no que nuestro mapping puede evolucionar en función de las necesidades del proyecto.</p><h3>Referencias</h3><p><a href="https://www.emarsys.com/en/resources/blog/drawing-houses-user-story-mapping/">https://www.emarsys.com/en/resources/blog/drawing-houses-user-story-mapping/</a></p><p><a href="https://www.caktusgroup.com/blog/2017/07/31/user-story-mapping-high-level-release-plan/">https://www.caktusgroup.com/blog/2017/07/31/user-story-mapping-high-level-release-plan/</a></p><p><a href="https://darioherrera.com/introduccion-al-user-story-mapping/">https://darioherrera.com/introduccion-al-user-story-mapping/</a></p><p><em>Artículo publicado en: </em><a href="https://adrianalonso.es/project-management/5-pasos-construir-user-story-mapping/"><em>https://adrianalonso.es/project-management/5-pasos-construir-user-story-mapping/</em></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2674be8aeb60" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>