<?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 Pablo León on Medium]]></title>
        <description><![CDATA[Stories by Pablo León on Medium]]></description>
        <link>https://medium.com/@PabloLeonPsi?source=rss-383115e1da4f------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*_Q1b1gUST4192IFO.jpg</url>
            <title>Stories by Pablo León on Medium</title>
            <link>https://medium.com/@PabloLeonPsi?source=rss-383115e1da4f------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 01:12:40 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@PabloLeonPsi/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[Alguien está rellenando tu hoja de personaje]]></title>
            <link>https://medium.com/@PabloLeonPsi/alguien-est%C3%A1-rellenando-tu-hoja-de-personaje-ed1d46af0ee1?source=rss-383115e1da4f------2</link>
            <guid isPermaLink="false">https://medium.com/p/ed1d46af0ee1</guid>
            <category><![CDATA[learning]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Pablo León]]></dc:creator>
            <pubDate>Thu, 26 Mar 2026 09:57:14 GMT</pubDate>
            <atom:updated>2026-03-26T09:59:30.871Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Hoja de personaje y dados para un juego de rol" src="https://cdn-images-1.medium.com/max/1024/1*ZPjEp6si-SpCK3wpLSWfOw.jpeg" /></figure><p>¿Cuándo fue la última vez que elegiste qué aprender sin que el contexto te empujara hacia ello? No me refiero a una formación impuesta por tu empresa. Me refiero a esa presión más sutil, la de abrir LinkedIn un lunes por la mañana y sentir que todo el mundo lleva ya varias semanas adelantado a ti en algo que tú ni sabías que existía.</p><p>Agentes, MCPs, optimización de tokens, nuevas herramientas que aparecen y desaparecen antes de que puedas aprenderte el nombre. El ritmo no para, y a su alrededor se construye una jerarquía silenciosa de lo que “importa” ahora mismo en el sector. Nadie te apunta con una pistola. Nadie te dice explícitamente qué tienes que estudiar este fin de semana. Pero el entorno habla, y habla alto.</p><p>Y en algún momento, casi sin darte cuenta, dejas de preguntarte qué quieres aprender. Empiezas a preguntarte qué se supone que deberías estar aprendiendo.</p><p>Esta mañana, mientras desayunaba, pensé que esto me resultaba familiar, pero de otro sitio completamente distinto.</p><p>Cuando empiezas una campaña de rol, hay un momento que me encanta: la creación del personaje. Tienes delante una hoja en blanco, un mundo por explorar, y una pregunta preciosa: ¿quién quieres ser en esta aventura? Investigas, imaginas, te ilusionas con una especialidad que conecta contigo, con un camino que sientes que va a hacer la partida memorable.</p><p>Y entonces abres un foro. O alguien del grupo te dice que “eso no escala bien en los tramos finales de la campaña”. O simplemente observas que los demás llevan builds muy parecidas entre sí, probadas y validadas, y sientes que la tuya, la que habías imaginado, quizás es demasiado rara. Demasiado arriesgada. Y redistribuyes los puntos. Por si acaso.</p><p>Esto tiene nombre en la cultura gamer: el meta-juego. Jugar no lo que disfrutas o lo que imaginaste, sino lo que dicta el entorno como óptimo en este momento. Y cuanto más ruidoso es ese entorno, más difícil es escuchar tu propia voz al otro lado.</p><p>Pues bien, llevo un tiempo sintiendo que en el sector tech estamos viviendo exactamente eso.</p><p>El problema del meta-juego no es solo que te aleja de lo que disfrutas. Es lo que ocurre cuando todo un equipo, o todo un sector, converge hacia las mismas habilidades, las mismas herramientas, las mismas respuestas.</p><p>Cuando todos llevan la misma build, todos piensan desde el mismo ángulo. Y los problemas complejos rara vez tienen una única solución válida. Tienen soluciones que dependen de quién está mirando, desde dónde, y con qué bagaje. Un equipo donde todo el mundo ha invertido sus puntos en lo mismo es un equipo que llegará siempre a las mismas conclusiones, incluso cuando esas conclusiones no sean las más adecuadas.</p><p>En el desarrollo de software esto tiene consecuencias reales. La persona que dedicó tiempo a entender bien el diseño de dominio ve el problema de una forma que quien solo conoce la herramienta de moda no puede ver. Quien tiene una base sólida en testing encuentra antes dónde está la fragilidad. Quien ha explorado el desarrollo frontend entiende la conversación con el producto de una manera distinta. Esas perspectivas no son ruido. Son precisamente lo que evita que un equipo quede atrapado en su propio punto ciego.</p><p>Pero cuando el entorno señala en una única dirección con suficiente insistencia, esas inversiones empiezan a sentirse como una rareza. Como tiempo mal gastado. Y poco a poco, la diversidad de caminos se estrecha.</p><p>Y volviendo la vista atrás, pienso en algo que me hace reflexionar:</p><p>Recuerdo una campaña en la que alguien del grupo eligió un camino que nadie habría recomendado en ningún foro. No era eficiente, no era la opción obvia, y más de una vez durante la aventura nos preguntamos si esa elección nos iba a pasar factura. Sin embargo, hubo momentos en esa campaña que no habrían existido de otra manera. Giros que nadie vio venir. Soluciones que surgieron precisamente porque alguien había llegado a ese punto desde un sitio distinto al del resto. La partida fue más rica, más imprevisible, más memorable. Exactamente por eso.</p><p>Y cuando miro hacia los equipos de desarrollo en los que mejor he trabajado, veo el mismo patrón. No eran los equipos donde todos sabían lo mismo. Eran los equipos donde cada persona había construido su propio camino, y esa diversidad se notaba en cómo abordaban los problemas. Alguien que venía del frontend y alguien que venía del diseño de dominio y alguien que se había obsesionado con testing no llegaban al mismo sitio ante un problema difícil. Y esa tensión, lejos de ser un obstáculo, era exactamente lo que necesitaban.</p><p>La build subóptima, a veces, es la que salva la partida.</p><p>No tengo una respuesta clara sobre qué hacer con todo esto. Y creo que ese no es el punto.</p><p>El punto es reconocer que la presión existe, aunque nadie te la esté imponiendo explícitamente. Que el entorno construye jerarquías silenciosas sobre lo que vale y lo que no, sobre lo que es relevante ahora mismo y lo que puede esperar. Y que en medio de ese ruido, es muy fácil perder de vista la pregunta que debería estar al principio de cualquier decisión de aprendizaje: ¿esto conecta con quien quiero ser como profesional, o simplemente es lo que toca esta temporada?</p><p>No digo que ignorar el contexto sea la respuesta. La IA está transformando el sector y sería ingenuo mirarlo desde lejos con los brazos cruzados. Pero hay una diferencia entre explorar algo porque genuinamente te llama la atención, porque ves cómo encaja en tu camino, y explorarlo porque sientes que si no lo haces te estás quedando atrás.</p><p>La próxima vez que abras un curso, un repositorio, o un artículo sobre lo último que está sonando, quizás vale la pena pausar un segundo y preguntarse: ¿quién está rellenando mi hoja de personaje ahora mismo?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ed1d46af0ee1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Green Software: El poder silencioso de nuestras decisiones]]></title>
            <link>https://medium.com/@PabloLeonPsi/green-software-el-poder-silencioso-de-nuestras-decisiones-285d19cd972a?source=rss-383115e1da4f------2</link>
            <guid isPermaLink="false">https://medium.com/p/285d19cd972a</guid>
            <category><![CDATA[software-craftsmanship]]></category>
            <category><![CDATA[green-software]]></category>
            <dc:creator><![CDATA[Pablo León]]></dc:creator>
            <pubDate>Thu, 26 Mar 2026 09:33:27 GMT</pubDate>
            <atom:updated>2026-03-26T09:33:27.732Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="El poder silencioso de nuestras decisiones en el código" src="https://cdn-images-1.medium.com/max/1024/1*lJ_kdKSmbF7XpNLBV-LHFQ.png" /><figcaption>El poder silencioso de nuestras decisiones en el código</figcaption></figure><p>Cada línea de código que escribes, cada consulta que ejecutas, cada build que dispones consume energía. Y esa energía tiene un precio que no aparece en tu factura.</p><p>Si es tu primera vez escuchando esto, permíteme una pregunta: ¿cuántas veces has optimizado un algoritmo por rendimiento sin pensar en el consumo energético? Probablemente muchas. ¿Y cuántas veces lo has hecho pensando en su impacto ambiental? Probablemente ninguna.</p><p>No es culpa tuya, nadie nos lo enseña. Pero las cosas están cambiando… O pueden hacerlo</p><h3>Un poco de contexto (y números)</h3><p>Vivimos en un momento cuanto menos peculiar. Estamos viviendo la paradoja de un sector que se alza con la promesa de transformar el mundo a través de la tecnología, pero que a su vez se está convirtiendo en uno de los mayores consumidores de energía del planeta.</p><p>Voy a acompañar esto con algunos datos:</p><ul><li>El software es el responsable de aproximadamente el <strong>3% de la huella global de carbono</strong> actualmente. Pero las proyecciones estiman que <strong>podría llegar al 14%</strong> en 2040 si continuamos con el ritmo actual.</li><li>Los centros de datos consumen anualmente la misma cantidad de electricidad que un país del tamaño de España.</li><li>Entrenar un modelo de lenguaje natural como ChatGPT equivale a unos 125 vuelos transatlánticos (ida y vuelta ✈️) o al carbono que producen cinco coches durante su ciclo de vida completo 🚗</li></ul><p>Estos ejemplos y otros muchos datos son en última instancia el reflejo de las decisiones de arquitectura, de infraestructura, de código, de <strong>Nuestras decisiones</strong>.</p><p>Lo importante aquí es, que si el problema viene de nuestras manos, también las soluciones.</p><h3>Green Software: Una re-definición necesaria</h3><p>Cuando hablamos de “software verde” o “desarrollo sostenible”, no estamos hablando de un conjunto de reglas restrictivas o de hacer menos software. Sino que hablamos de algo mucho más poderoso: de <strong>hacer software inteligente.</strong></p><p>La Green Software Foundation, fundada en 2021, lo define así:</p><blockquote><em>Construir un ecosistema de confianza compuesto de personas, estándares, herramientas y mejores prácticas para crear y construir software verde.</em></blockquote><p>El pensamiento y la literatura que hay detrás de esto es extensa, pero se podría simplificar de este modo: Green Software es la filosofía de crear soluciones tecnológicas que resuelven problemas humanos <strong>sin hipotecar la capacidad del planeta para resolver los propios.</strong></p><p>No se trata de renunciar a la innovación, obviamente, sino de innovar de forma consciente, y para sostener este pensamiento encontramos tres pilares:</p><p><strong>Eficiencia energética</strong>: Optimizar el consumo de recursos computacionales. Hacer más con menos (Es lo que siempre quisimos como desarrolladoras/es, pero además con un propósito).</p><p><strong>Optimización de recursos</strong>: Desde la gestión del almacenamiento hasta las conexiones de red, pasando por la reducción de tiempos de ejecución. Cada milisegundo ahorrado en tu aplicación es energía que no se desperdicia.</p><p><strong>Decisiones conscientes</strong>: En cada fase del desarrollo, desde la arquitectura hasta la elección de los proveedores, preguntarnos no sólo “¿Funciona?” sino “¿Cuál es el costo real de que funcione?”</p><h3>Por qué debería importarte (más allá de la culpa)</h3><p>En este punto, muchos artículos sobre sostenibilidad pierden a su audiencia (a mi también en más de una ocasión). Hablan de culpa, de responsabilidad moral, levantan la pancarta de “debemos salvar el planeta”. Y esto está bien, es muy importante, pero la verdad es que esto tiene otros beneficios muy tangibles que van más allá de dormir tranquila/o por las noches 😴.</p><p><strong>Para desarrolladores/as y equipos técnicos:</strong> Si optimizas tu código por sostenibilidad, obtienes como bonus aplicaciones más rápidas, más eficientes, que escalan mejor. Es el mismo trabajo pero con doble recompensa. Además, trabajar con conciencia técnica en estas áreas te hace mejor profesional.</p><p><strong>Para CTOs y líderes técnicos/as:</strong> La optimización de servidores y almacenamiento reduce costes operativos significativamente. Hablamos de miles de euros al año que puedes reorientar hacia innovación. Green Software no es un gasto, es inversión.</p><p><strong>Para la empresa:</strong> Cada vez más clientes preguntan por el compromiso ambiental de sus proveedores. Cada vez más regulaciones exigen reportes de huella de carbono. Posicionarte en Green Software hoy es tener ventaja competitiva mañana.</p><p><strong>Para todos:</strong> Formar parte de una comunidad que se preocupa por el impacto real de lo que hace. Eso importa más de lo que creemos.</p><h3>Prácticas sostenibles: dónde empieza la acción 💡</h3><p>No necesitas revolucionar tu Stack tecnológico mañana. Empieza pequeño, empieza donde estés.</p><h3>En tu código en general (y concretamente en Node.js, mi stack actual)</h3><ul><li>Evita bucles innecesarios y reduce la carga de memoria</li><li>Usa Streams de datos en lugar de cargar archivos completos en memoria</li><li>Revisa tus dependencias: cada paquete innecesario es CPU que se ejecuta sin razón</li><li>Reduce la deuda técnica; el software obsoleto que sigue ejecutándose sigue consumiendo</li><li>Sé selectivo con middlewares; no los apliques globalmente si solo ciertos endpoints los necesitan</li><li>Elige herramientas de compilación modernas (esbuild, swc) que optimicen mejor que tsc tradicional</li></ul><h3>En tus consultas y datos</h3><p>Cada query a base de datos es un ciclo de CPU. Pequeños cambios generan impacto:</p><ul><li>Cachea respuestas cuando tenga sentido</li><li>Añade índices donde se realicen búsquedas frecuentes</li><li>Evita SELECT * si solo necesitas ciertas columnas</li><li>Piensa en estrategias de caché antes de multiplicar llamadas a BD</li></ul><h3>En tus dependencias y utilidades</h3><p>A veces la magia está en elegir mejor, no en hacer más:</p><ul><li>Usa tree-shakeable libraries (lodash-es en lugar de lodash)</li><li>Reemplaza herramientas lentas por versiones optimizadas (Pino es 5 veces más rápido que console.log)</li><li>Revisa qué necesitas realmente; muchas librerías incluyen funcionalidad que nunca usas</li></ul><h3>En tu infraestructura y cloud</h3><p>AWS, Azure, GCP: todos tienen huella de carbono. Elige sabiamente 🧐:</p><ul><li>Selecciona regiones con energía renovable (eu-west-1 en AWS, por ejemplo)</li><li>Usa políticas de ciclo de vida: archivos poco accedidos a almacenamiento más barato (Glacier)</li><li>Prefiere Lambdas a servidores siempre encendidos esperando requests</li><li>Considera instancias basadas en ARM en lugar de x86 cuando sea posible</li><li>Abierto a reflexión: ¿es mejor deploy continuo (minimiza riesgo pero aumenta consumo) o batch deploys (menos consumo, más riesgo acumulado)?</li></ul><h3>Más allá del código</h3><ul><li><strong>Conciencia</strong>: No puedes mejorar lo que no conoces. Aprende, lee, cuestiona y comparte tus inquietudes con tu equipo, tu comunidad, etc</li><li><strong>IA responsable</strong>: No uses GPT para preguntas que puedes resolver con una búsqueda o para algo que ya preguntaste ayer. Considera el costo real</li><li><strong>Infraestructura sostenible</strong>: Apoya cambios en tu organización hacia proveedores con energía renovable</li><li><strong>Extensión de vida útil</strong>: Cuida tu hardware; un dispositivo que dura más años es más sostenible</li></ul><h3>El papel silencioso de los agentes de cambio</h3><p>Aquí es donde quiero terminar con una reflexión.</p><p>A veces nos miramos al espejo y pensamos que nuestras acciones individuales no importan. Que somos demasiado pequeños frente a un problema de escala planetaria. Que cambiar nuestro código no va a “salvar el mundo”.</p><p>Y tienes razón. No lo hará.</p><p>Pero aquí viene lo importante: <strong>tú no actúas solo/a</strong>. Cada vez que decides optimizar tu código pensando en energía, estás normalizando una conversación. Cada línea de código eficiente que escribes es un precedente en tu equipo. Cada pregunta que haces sobre el impacto ambiental de una decisión técnica es una semilla que germinará en otros.</p><p>Los movimientos de cambio nunca empiezan con decisiones globales. Empiezan con personas que deciden hacer las cosas diferente en su círculo más cercano.</p><p>Y ese círculo empieza en tu teclado.</p><p>No te propongo que dejes de hacer software. Te propongo que <strong>lo hagas de forma que valga la pena que lo hicieras</strong>. Que cada línea de código sea un voto por un planeta más sostenible, incluso si ese voto parece insignificante hoy.</p><p>Porque en cinco años, cuando esto haya dejado de ser una curiosidad y sea el estándar, querrás poder decir que fuiste de los que lo vieron venir.</p><h3>Dos invitaciones para terminar</h3><p><strong>Una reflexión personal:</strong> Piensa en una decisión técnica que tomes regularmente. Una que repites sin cuestionarte. Ahora pregúntate: ¿podría hacerla de forma más eficiente energéticamente? ¿Cuál sería el primer paso?</p><p><strong>Una invitación a la comunidad:</strong> Si esto te resuena, no lo guardes. Comparte. Hablemos de Green Software en equipos, en charlas técnicas, en decisiones de arquitectura. Necesitamos más voces en esto, no menos.</p><p>Green Software no es un destino. Es una dirección. Y cada uno de nosotros decide si andamos en ella.</p><h3>Algunos recursos para profundizar</h3><ul><li><a href="https://greensoftware.foundation/">Green Software Foundation</a> — La comunidad que lidera esto</li><li><a href="https://github.com/Green-Software-Foundation/awesome-green-software">Awesome Green Software</a> — Recursos de la GSF</li><li><a href="https://www.cloudcarbonfootprint.org/">Cloud Carbon Footprint</a> — Mide tu huella de carbono en cloud</li><li><a href="https://www.oaklean.io/">Oaklean</a> — Visualiza el consumo energético de tu código en desarrollo</li><li><a href="https://alfredoartiles.substack.com/p/green-software-development">Alfredo Artiles — Green Software Development</a> — Una ponencia motivadora con profundización técnica</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=285d19cd972a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[La Developer Experience es de buenas personas]]></title>
            <link>https://medium.com/@PabloLeonPsi/la-developer-experience-es-de-buenas-personas-ebb335cf91ef?source=rss-383115e1da4f------2</link>
            <guid isPermaLink="false">https://medium.com/p/ebb335cf91ef</guid>
            <category><![CDATA[developer-experience]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Pablo León]]></dc:creator>
            <pubDate>Tue, 25 Mar 2025 12:31:22 GMT</pubDate>
            <atom:updated>2025-03-25T12:31:22.267Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oFQsRSzuRHYS1Ft3vRuf-A.png" /><figcaption>Una guía para buenas personas</figcaption></figure><p>Cuando hablamos de <strong>Developer Experience (DX)</strong>, muchas veces pensamos en herramientas, entornos de desarrollo optimizados y atajos de teclado que nos hacen trabajar más rápido. Y sí, todo eso es importante. Pero para mí, la DX va mucho más allá de la productividad individual.</p><p>La <strong>Developer Experience es ser buena gente.</strong> Se trata de optimizar nuestro flujo de trabajo, pero también de fomentar la colaboración, reducir errores y hacer que el día a día de quienes trabajan con nuestro código — ya sea hoy o dentro de meses — sea mejor.</p><p>Creo que esto se entiende mejor con ejemplos, así que aquí van algunos de los aspectos que en mi opinión marcan la diferencia en la DX:</p><h3>✍️ Documentación de APIs: Deja un buen legado</h3><p>Si trabajas con APIs, <strong>documenta</strong>. Y no me refiero solo a dejar que el IDE genere comentarios en el código. Quien consuma tu API (sea una compañera, alguien externo o tú dentro de seis meses) agradecerá saber qué espera cada endpoint, qué devuelve y qué tipo de autenticación requiere.</p><p>Herramientas como <a href="https://swagger.io/"><strong>Swagger</strong></a> o <a href="https://www.postman.com/"><strong>Postman</strong></a> pueden ayudar a documentar y probar APIs de forma sencilla y automatizable. Esto reduce la dependencia del conocimiento individual y evita la frustración.</p><p>Como ejemplo de excelencia en este ámbito está la documentación de Stripe. Si trabajas con su API, lo notarás enseguida: todo está claro, es navegable y con una buena estructura, lo que facilita enormemente el desarrollo.</p><h3>📜 Un buen Changelog evita sorpresas incómodas</h3><p>Tener un historial de cambios bien mantenido ayuda a entender la evolución de un proyecto y a prever qué puede romperse si actualizamos una dependencia.</p><p>Esto se puede automatizar con herramientas como <a href="https://semantic-release.gitbook.io/semantic-release"><strong>Semantic Release</strong></a> y convenciones como <a href="https://www.conventionalcommits.org/en/v1.0.0/"><strong>Conventional Commits</strong></a>, que generan el changelog automáticamente a partir de los mensajes de los commits. Así, además de registrar qué cambios se hicieron, indicamos si son cambios críticos, mejoras o simples refactorizaciones.</p><h3>🛟 Los lenguajes tipados son un salvavidas</h3><p>Lenguajes como <strong>TypeScript</strong> nos permiten detectar errores en tiempo de desarrollo, reduciendo el margen de fallo y facilitando la lectura del código. Además, nos permiten aprovechar el autocompletado del IDE y mejorar la inferencia de tipos.</p><p>Si usas un lenguaje tipado, <strong>aprovéchalo bien</strong>: evita los any, explora los tipos utilitarios y minimiza la incertidumbre en el código (Las sorpresas mejor en los regalos de cumpleaños)</p><h3>📐 Un Design System no es solo para grandes empresas</h3><p>Tener un <strong>Design System</strong> bien definido nos permite mantener coherencia entre diseño y desarrollo. Aunque sea algo interno, contar con una única fuente de verdad para estilos y componentes facilita la escalabilidad y el mantenimiento del código.</p><p>Herramientas como <a href="https://storybook.js.org/"><strong>Storybook</strong></a> son un gran aliado para documentar y probar componentes, fomentando buenas prácticas desde el principio.</p><h3>🤝 Configurar tu entorno de desarrollo es un acto de generosidad</h3><p>Personalizar tu <strong>IDE</strong> con extensiones útiles (linters, formateadores, herramientas de depuración) mejora la experiencia de desarrollo. La mayoría de los IDEs modernos tienen utilidades por defecto para cualquier lenguaje, pero apoyarnos en este tipo de herramientas nos facilita el trabajo y puede evitar distintos problemas.</p><p>Además, es clave compartir la misma configuración de linter y formateo en el equipo. Si cada persona tiene un formato distinto, el control de versiones se vuelve un caos.</p><p>Aquí es donde los <a href="https://githooks.com/"><strong>hooks</strong></a><strong> de Git</strong> pueden ser grandes aliados. Automatizar la ejecución de linters, formatters o incluso tests antes de hacer un commit nos asegura que el código en el repositorio cumple unos mínimos de calidad sin esfuerzo extra.</p><h3>🧐 No ignores la ergonomía digital</h3><p>Por último, un aspecto que a menudo pasamos por alto: <strong>tu salud visual</strong>.</p><p>Pasamos horas delante del código, así que elegir una tipografía y un tema que reduzcan la fatiga ocular es una mejora tangible en la DX. No subestimes el impacto de pequeños cambios en tu configuración que pueden mejorar tu bienestar a largo plazo.</p><blockquote><em>Al final (IMHO), la Developer Experience no trata solo de optimizar comandos y escribir más rápido. Se trata de facilitar la vida a las personas que trabajan con código, incluyéndote a ti mismo, ahora y en el futuro. Mejorar la DX significa ganar en velocidad, pero también en calidad del producto y, sobre todo, en calidad de vida.</em></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ebb335cf91ef" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Apuntes sobre Arquitecturas Limpias (de Software)— Vol 1]]></title>
            <link>https://medium.com/@PabloLeonPsi/apuntes-sobre-arquitecturas-limpias-de-software-vol-1-1a91131933e2?source=rss-383115e1da4f------2</link>
            <guid isPermaLink="false">https://medium.com/p/1a91131933e2</guid>
            <category><![CDATA[clean-code]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[clean-architecture]]></category>
            <dc:creator><![CDATA[Pablo León]]></dc:creator>
            <pubDate>Sun, 19 Apr 2020 11:00:40 GMT</pubDate>
            <atom:updated>2020-04-19T11:00:40.982Z</atom:updated>
            <content:encoded><![CDATA[<p>Me gustaría compartir algunos apuntes acerca de Arquitecturas Limpias y por qué considero que pueden aportarnos mucho en el desarrollo de software (y trataré de hacerlo mediante bloques como éste)</p><p>Pero para hablar de Arquitecturas Limpias es importante empezar entendiendo a qué nos referimos con <em>Arquitectura de Software</em> (AS). La AS se entiende, de forma sintetizada, como un conjunto de especificaciones o reglas que aplicamos voluntariamente a la hora de diseñar las clases y estructuras de una aplicación. Por tanto estaremos hablando en términos de un diseño lógico que aplicamos como desarrolladores que no viene impuesto por la tecnología con la que trabajemos.</p><p>Inevitablemente esta práctica implica un mayor esfuerzo y un coste de tiempo inicial, por lo que está más orientada a proyectos a largo plazo en los que si buscamos un mayor nivel de testabilidad y mantenibilidad del código, y no tanto a proyectos más sencillos como podría ser un portfolio web donde no tiene tanto sentido añadir esta ‘dificultad’</p><h3>Y bien ¿Por qué aplicar Arquitectura de Software?</h3><p>En cualquier proyecto a gran escala es inevitable encontrarnos con funcionalidades que tienen una cierta complejidad inherente (realizar un cálculo, seguir un flujo condicional..), pero si no establecemos unas reglas de diseño que estén claras, es muy fácil que acabemos encontrando que un problema que podría tener una complejidad inherente mínima se convierte en una ‘<a href="http://www.laputan.org/mud/mud.html#BigBallOfMud"><em>Big Ball of Mud</em></a>’ derivada de una gran complejidad accidental. Esto finalmente se traduce en un mayor coste de tiempo y en el arrastre de gran deuda técnica</p><p>Las Arquitecturas Limpias coinciden en la definición de varias capas en la aplicación, las cuales se comunican entre sí y además están sometidas a una regla de dependencia</p><figure><img alt="Esquema de arquitecturas limpias" src="https://cdn-images-1.medium.com/max/647/1*bw2LfdaV9UZJQEUvP-Qs4w.png" /><figcaption>Esquema Arquitecturas Limpias</figcaption></figure><p><strong>Regla de Dependencia</strong>: Lo que haya en una capa interior no puede conocer lo que haya en otra capa más exterior</p><p>Si nuestras Entidades se encuentran en el núcleo de la aplicación o arquitectura, no pueden “salir” a conocer servicios del framework que nos aporte por ejemplo la lectura de cabeceras HTTP o la persistencia en Base de Datos, ya que entonces estaríamos contaminando nuestro Dominio con detalles de la Infraestructura.</p><p>En este sentido, los principios <strong>SOLID</strong> nos ofrecen una buena manera de respetar esta regla, en concreto el Principio de Inversión de Dependencias (DIP) nos sugiere el uso de interfaces, que quedarían dentro del dominio e implementaciones de éstas que quedarían en la infraestructura</p><h3>¿Qué encontramos en el núcleo de la arquitectura?</h3><p><strong>Entidades</strong>: Son elementos con identidad propia dentro de nuestro dominio (Usuario, Libro, Reserva…), esto implica que un objeto puede estar representado como entidades distintas (Usuario, Jugador, Cliente…)</p><p><strong>Interfaces</strong>: Serían los contratos (puertos en Arquitectura Hexagonal) que pasaremos a nuestros casos de uso y que nos permitirán desacoplarnos de implementaciones concretas</p><p><strong>Servicios de Dominio</strong>: Se trata de aquellas reglas de negocio o comportamientos de nuestro dominio que no pueden encapsularse en una entidad, ya se por su complejidad o porque afecte a varias entidades. Este tipo de servicios son completamente ajenos a servicios de terceros</p><p><strong>Eventos de Dominio</strong>: Son mensajes que notifican acerca de algo que ha sucedido en el dominio y que podría ser interesante para otra parte de la aplicación (Se ha creado un usuario, se ha procesado una operación, se ha prestado un libro…) y por tanto se prestan a generar acciones derivadas</p><h3>¿Qué encontramos en la capa de aplicación o de caso de uso?</h3><p><strong>Servicios de Aplicación</strong>: Representan los distintos casos de uso que pueden darse dentro de nuestra aplicación. Es decir, son acciones atómicas que los interesados de la aplicación querrían realizar (Crear un usuario, realizar una operación, reservar un libro…). Estos servicios serán los encargados de orquestar la lógica en torno a ese caso de uso concreto como persistir o recuperar información de BD</p><p><strong>Objetos de transferencia de datos</strong>: Dentro de esta clasificación encontramos una pequeña diferenciación:</p><ul><li><strong>DTOs</strong>: Son objetos mutables (podremos modificarlos tras ser instanciados) que nos permiten la comunicación con terceros</li><li><strong>Requests/Responses</strong>: Estos objetos son inmutables y están más orientados a la comunicación entre capas de nuestra arquitectura</li></ul><p><strong>Buses de comunicación</strong>: También pertenecen a esta capa el Bus de Eventos y, si procede, los derivados de aplicar CQRS (Command/Query Responsibility Segregation)</p><p>Finalmente, en la capa de <strong>Infraestructura</strong> se encuentran las implementaciones concretas de las interfaces (contratos), constituyen así los adaptadores (término proveniente de la Arquitectura Hexagonal) para conectar dichas interfaces con los componentes externos (repositorios de BD, sistema de colas, particularidades del framework…)</p><p>El hecho de aplicar este tipo de arquitecturas nos brinda importantes beneficios:</p><ul><li>Mantenibilidad: Ya que nuestro dominio no se verá en ningún momento afectado por cambios en la infraestructura</li><li>Cambiabilidad de los adaptadores (Implementaciones concretas)</li><li>Reusabilidad de los puertos (Interfaces / Casos de uso)</li><li>Testabilidad: Al no acoplar nuestros casos de uso a la infraestructura, podremos “mockearla” con facilidad</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1a91131933e2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Una aproximación a la Programación Orientada a Aspectos]]></title>
            <link>https://medium.com/@PabloLeonPsi/una-aproximaci%C3%B3n-a-la-programaci%C3%B3n-orientada-a-aspectos-a62d377ebe79?source=rss-383115e1da4f------2</link>
            <guid isPermaLink="false">https://medium.com/p/a62d377ebe79</guid>
            <category><![CDATA[development]]></category>
            <category><![CDATA[poa]]></category>
            <category><![CDATA[programming-paradigms]]></category>
            <category><![CDATA[spring]]></category>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[Pablo León]]></dc:creator>
            <pubDate>Sat, 09 Feb 2019 11:58:29 GMT</pubDate>
            <atom:updated>2019-02-23T12:34:28.959Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*_3CQR6bqlHa6xOZH" /><figcaption>Photo by <a href="https://unsplash.com/@csoref?utm_source=medium&amp;utm_medium=referral">Colton Duke</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Dicho de un modo formal, la Programación Orientada a Aspectos (POA) puede definirse como un paradigma que busca obtener una adecuada modularización de los conceptos involucrados dentro de una aplicación.</p><p>Podemos traducir esta presentación en algo un poco menos abstracto: Lo que pretende es conseguir la separación entre los requerimientos funcionales y no funcionales, de tal modo que lleguemos a un mayor entendimiento de los conceptos, eliminemos la dispersión de código y construyamos implementaciones que sean más comprensibles, adaptables y reutilizables.</p><p>Bien, hablar de paradigmas de programación y código más modular nos puede llevar casi inevitablemente a pensar en la <a href="https://es.wikipedia.org/wiki/Programaci%C3%B3n_orientada_a_objetos">Programación Orientada a Objetos</a> (POO). No profundizaré mucho en este paradigma (aunque da para escribir libros y libros), pero podemos afirmar que su piedra angular es el concepto de <a href="https://es.wikipedia.org/wiki/Clase_(inform%C3%A1tica)">clases</a> y <em>jerarquías de clases</em>, lo que nos lleva a contar con elementos importantes como la <em>Herencia</em> entre clases, el <em>Polimorfismo</em> o la <em>Encapsulación</em>. En definitiva en la POO hablamos de un proceso de abstracción en el que se busca que cada clase cumpla con una única funcionalidad dentro de nuestra aplicación.</p><p>Este paradigma ofrece grandes ventajas en el desarrollo de software de calidad y aplicaciones más complejas, así que, si está tan bien, ¿Por qué cambiar? ¿Para qué tocarlo si funciona? Pues la respuesta es básicamente la misma razón por la que en su momento surgió:</p><blockquote>Hay limitaciones que debemos superar, porque no es lo mismo un código que funciona, a uno que está bien hecho.</blockquote><p>La herencia entre clases nos permite modularizar nuestro sistema, y esto es algo que reduce en parte las dependencias, una característica importante, pero veremos que en una aplicación nos vamos a encontrar que surgen algunas responsabilidades que tienen que hacer muchas clases, y es siempre la misma responsabilidad, por lo que empiezas a añadir código repetitivo dentro de los cuerpos de los métodos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/1*-BhJLenklZ9bfBLy1XuaJw.jpeg" /><figcaption>Funcionalidad transversal</figcaption></figure><p>La <em>seguridad</em> en nuestra aplicación puede ser un ejemplo bastante claro (como cuando debemos validar a un usuario antes de acceder a diversos métodos). Finalmente acabamos topándonos con ciertas funcionalidades, funcionalidades transversales que se repiten no sólo dentro de nuestra clase, sino en múltiples clases.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/563/1*ACfIY85PnTq9hbEtTaj2Xg.png" /><figcaption>Repetición de código en nuestra aplicación</figcaption></figure><p>Comprobar la autenticación de usuarios, gestión de sesiones, logueo de actividad… Esto al final afecta al desarrollo de nuestro software.</p><p>Código repetido, con una estructura mucho menos definida de lo que esperábamos y un código más enmarañado, además a la larga será difícil de modificar y mantener, por no hablar de la escalabilidad de la aplicación.</p><p>¿Qué es lo que nos trajo la Programación Orientada a Aspectos? No se trata de un estilo de programación distinto a las técnicas de programación que le preceden, sino que es un paradigma que agrega nuevos elementos para permitir la modularización de los asuntos transversales. Desde su propia perspectiva, una aplicación consiste en un conjunto de requerimientos funcionales modulares (código base), más un conjunto de asuntos transversales de difícil modularización (aspectos)</p><p>Veámoslo con un ejemplo, supongamos una clase BankAccount, en ella tendremos funcionalidades básicas como ‘doDeposit’ ‘doTransfer’ ‘doQuery’...</p><p>Es lógico pensar que querremos guardar un registro de las actividades realizadas o validar el rol de los usuarios, ¿No?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/634/1*f6txg30_S_QqVlitPoY0ng.png" /><figcaption>Nuestro dummy</figcaption></figure><p>Una funcionalidad que al fin y al cabo se repetirá no sólo en distintas funciones, sino también en distintas clases de nuestra aplicación. Por lo que, siguiendo buenas prácticas, extraeremos estas responsabilidades a una clase a parte (ServiceLogger, ServiceValidation…). Estas clases finalmente supondrán la adición de dependencias en nuestra clase CuentaBancaria.</p><p>Pero es posible llevarlo un poco más allá, y en lugar de hacer múltiples inicializaciones y llamadas a métodos en nuestro código fuente, extraer esta funcionalidad y hacer que ésta sea inyectada en el código cuando haga falta de forma dinámica.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/603/1*Kw341OsIYbLCrNjnxr-w5Q.png" /><figcaption>nuestro Aspecto</figcaption></figure><p>En este ejemplo podemos ver cómo tenemos una funcionalidad que se ejecutará dentro de nuestro código antes de cualquier función que comience por ‘do..’ como en nuestras funciones ‘doTransfer’ o ‘doDeposit’.</p><h3>Conceptos importantes dentro de este paradigma…</h3><p>Un <strong>aspecto</strong> es esa funcionalidad modular de la que hemos hablado anteriormente, sería la clase que agrupa aquellos consejos que vamos a manejar de forma relacionada.</p><p>El <strong>punto de corte</strong>, por su parte, define los consejos que se van a aplicar a cada punto de cruce, puede especificarse de distintas formas: Expresiones regulares, nombres o incluso dinámicamente en tiempo de ejecución según el valor de ciertos parámetros.</p><p>El <strong>punto de enlace</strong> es un punto de ejecución dentro de nuestra aplicación donde nuestro aspecto puede conectar añadiendo su funcionalidad (dónde vamos a ‘inyectar’ un elemento transversal de nuestra aplicación).</p><p>El <strong>consejo</strong> es el método que se va a ejecutar dentro de nuestro aspecto, la acción a realizar. Por ejemplo: guardar un registro del usuario que ha accedido a X función. Podemos encontrar diferentes tipos de consejos en función de cuando actúen: <em>Before, After, Around, AfterThrowing, AfterReturning…</em></p><p>Por otro lado, una <strong>Introducción</strong> es otro elemento interesante de este enfoque, ya que cuando realizamos una acción sobre un punto de enlace, podemos introducir variables o métodos a una clase ya existente.</p><p>Hay otros dos elementos de gran interés e importancia que veremos a continuación.</p><h4>Inversión de Control (IOC)</h4><p>En la Inversión de Control, es el framework el que toma el control de la aplicación, el que define el flujo de actuación o el ciclo de vida de una petición. Así, será el propio framework el que ejecute el código de usuario. Este enfoque suele relacionarse con el denominado <em>principio de Hollywood</em>:</p><blockquote><em>“Don’t call us, we’ll call you”</em></blockquote><p>en el sentido de que no somos nosotros quienes hacemos fastidiosas llamadas a esas funcionalidades repetitivas, sino que nos son suministradas cuando es necesario.</p><p>La IoC juega un papel bastante importante en la extensibilidad del código, ya que entre otras cosas, nos permite ampliar la funcionalidad de nuestro sistema sin tener que modificar las clases existentes.</p><h4>Inyección de Dependencias</h4><p>Por otro lado, según el patrón de Inyección de Dependencias, se plantea que éstas no deben instanciarse dentro de nuestro código, sino que deben ser inyectadas en el mismo. Esta ‘inyección’ puede hacerse de dos maneras, a través de constructores o de setters, aunque lo recomendado es hacerlo a través de constructor.</p><p>Para simplificar esto, este patrón hace uso de un servicio que nos permite definir cómo se construyen los objetos y bajo qué nombre queremos poder acceder a ellos, y éste servicio se encarga del resto. A groso modo, puede entenderse como un array que contiene todas las posibles dependencias dentro de nuestra aplicación.</p><p>Uno de los principios básicos de la programación y de buenas prácticas es la separación de código por responsabilidades. Pues bien, podemos afirmar que la inyección de dependencias parte de éste principio.</p><p>Lo que nos dice es que los objetos nunca deben construir aquellos otros objetos que necesitan para funcionar. Esa parte de creación de los objetos se debe hacer en otro lugar diferente a la inicialización de un objeto.</p><p>El contenedor de dependencias nos permite que la instanciación de un objeto sea tan simple como una llamada a un método. ¿Dónde está la magia? El contenedor de dependencias simplemente tiene todos los objetos que nuestra aplicación pueda necesitar para crear cualquier objeto complejo.</p><p>Para comprender mejor las implicaciones de estos conceptos imaginemos por una instante que contamos con una clase de alto nivel <em>Fabric</em>, ésta depende de la clase de bajo nivel <em>Car</em>.</p><p>Toda la lógica de la solución se implementa en la clase de alto nivel, y cualquier modificación en las clases de bajo nivel va a repercutir no sólo sobre la definición de la de alto nivel, sino sobre la propia lógica de la aplicación, cuando debería ser la clase de alto nivel la que forzase el cambio de las clases de bajo nivel sin comprometer la lógica de la aplicación. Además, la clase de alto nivel sería difícilmente reusable debido a este acoplamiento. Sencillamente y resumiendo, la clase <em>Fabric</em> no debería depender de la clase Car.</p><h4>¿Qué necesitamos para trabajar con este paradigma?</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/725/1*7IYuwz7Zw2XerKmq39gr6w.png" /><figcaption>Esquema: Código base — Lenguaje de aspectos — Tejedor de aspectos</figcaption></figure><p>Lo que necesitamos es un lenguaje base sobre el que se va a desarrollar la aplicación (<em>Java, Python, PHP…</em>), es importante tener en cuenta que no necesariamente necesitaremos hacer uso de la POO. Además, necesitaremos uno o más lenguajes de aspectos como AspectJ o Aspyct , y por último un ‘<em>Tejedor de aspectos</em>’ o Weaver, que será el encargado de tejer la funcionalidad transversal de los aspectos dentro de nuestras clases.</p><p>Dentro de los weaver podemos encontrar dos formas de actuar:</p><ul><li>Entrelazado dinámico (Run-time weaver)</li><li>Entrelazado estático (Compile-time weaver).</li></ul><p>Existen múltiples frameworks que hacen uso de estos elementos y aprovechan o permiten aprovechar éste paradigma integrando éstos weaver y la sintaxis necesaria para trabajar con ellos. Spring es un ejemplo de ello.</p><p><a href="https://spring.io/"><strong>Spring</strong></a> es un framework de desarrollo que nos permite crear aplicaciones webs en Java. Se compone de múltiples herramientas y módulos que facilitan la generación de código automático para algunas tareas básicas como el acceso a Bases de Datos o Endpoints. Además, se trata de un proyecto de código abierto. Una de las ventajas de utilizar este tipo de frameworks es que gracias a su gran modularidad, no es necesario que implementemos todos los módulos disponibles si no los requerimos en nuestra aplicación.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*FgKYYwaHCvqzuC8gDcr1QQ.png" /><figcaption>El ecosistema de Spring Framework</figcaption></figure><p>La piedra angular de este framework es el <strong>Contenedor de Inversión de Control </strong>(IoC), por el cual se le considera una herramienta idónea para el desarrollo de aplicaciones en el marco de la POA.</p><p>Su propósito es instanciar, inicializar y conectar objetos de la aplicación, además de añadir algunas características adicionales de Spring en el tiempo de vida de los objetos. Los objetos creados y gestionados por el contenedor se denominan <a href="https://spring.io/understanding/POJO"><em>Beans</em></a>.</p><p>Los beans son objetos de tipo <em>Pojo</em>. para realizar su tarea, el IoC necesita de información que le indique cómo instanciar y conectar los beans. A esta información se le llama ‘Metadatos de configuración’, y se puede aportar basándose en ficheros xml, o bien anotaciones, o incluso mediante objetos Java.</p><p>En el siguiente repositorio del master en ingeniería web de la U.P.M podemos ver un ejemplo de una implementación haciendo uso de anotaciones.</p><p>[<a href="https://github.com/miw-upm/betca-spring3">Enlace</a>]</p><h4>¿Qué ventajas e inconvenientes nos ofrece la POA?</h4><p>Personalmente considero que este paradigma tiene a su favor el ofrecernos una potente herramienta para modularizar nuestros programas, por muy extensos o complicados que sean, haciendo así que las dependencias sean mínimas. Por tanto, hará que el código fuente sea mucho más limpio.</p><p>Además permite agilizar el proceso de creación de aplicaciones cuando hay muchas personas involucradas en el mismo proyecto.</p><p>Otro punto clave es que puede integrarse con cualquier otro paradigma de programación, en el ejemplo anterior podía verse junto a la POO, pero no sería el único caso.</p><p>Finalmente, este tipo de programación facilita enormemente el desarrollo de tests de calidad.</p><blockquote><strong>Código limpio y mas testeable, creación ágil de proyectos, e integración de múltiples paradigmas</strong></blockquote><p>Respecto a las desventajas de este paradigma, podemos ver que presenta un Antipatrón de diseño, es decir, las acciones se encuentran a distancia del propio código fuente. Esto hace que sea difícil de comprender dicho código para cualquier persona ajena a él, puesto que el programa hace tareas que no están en los métodos que deberían estar. Imaginad que probáis un método y de repente la aplicación hace más de lo que parecía hacer.</p><p>Finalmente, puede resultar complicado identificar cuándo es óptimo utilizar este paradigma de forma eficiente.</p><blockquote><strong>Difícil comprensión de código e identificación de proyectos óptimos</strong></blockquote><p>Finalmente me gustaría dejar <a href="https://www.youtube.com/watch?v=oFm4qtfyUh4&amp;t=10s">aquí</a> el enlace a un video en el que podéis ver una explicación muy interesante de la POA. Espero que esta aproximación os ayude a comprender de qué se trata este paradigma y cual es la utilidad que puede ofrecernos en el desarrollo de aplicaciones.</p><p>Seguiré estudiando y trabajando para tratar de ofrecer otras publicaciones donde profundizar mas y compartir lo aprendido de la mejor forma posible.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a62d377ebe79" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Descubriendo Git (mas allá del add-commit-push)]]></title>
            <link>https://medium.com/@PabloLeonPsi/descubriendo-git-mas-all%C3%A1-del-add-commit-push-6efaed8ae26e?source=rss-383115e1da4f------2</link>
            <guid isPermaLink="false">https://medium.com/p/6efaed8ae26e</guid>
            <category><![CDATA[git]]></category>
            <dc:creator><![CDATA[Pablo León]]></dc:creator>
            <pubDate>Wed, 03 Oct 2018 10:56:08 GMT</pubDate>
            <atom:updated>2018-10-03T10:56:08.905Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9nLIAbAbPLAEZfmTwEQP1A.png" /><figcaption>Mapa del metro de Tokio (o un gráfico de cualquier de nuestros repositorios)</figcaption></figure><p>Hace tiempo leí una frase que citaba algo así como “Si puedo explicarlo, significa que lo entiendo”, y bajo esta premisa me he propuesto escribir siempre que me sea posible acerca de todo lo que estudie/investigue/rompa.</p><p>En esta ocasión le ha tocado de nuevo el turno a Git, puesto que estuve realizando un pequeño curso de <a href="http://www.udemy.com/">Udemy</a> para refrescar conocimientos y adquirir otros nuevos.</p><ul><li>git commit — amend -m ‘mensaje_1’ → nos permite añadir un commit con el commit ‘mensaje_1’, evitándonos en ocasiones múltiples commits innecesarios.</li><li>git checkout — fichero → nos permite eliminar los cambios realizados en el fichero.</li><li>git checkout <em>hash — </em>fichero → nos recupera el fichero a la versión del commit identificado por el hash.</li><li>git revert hash → por su parte, este comando deshace o revierte el commit identificado por el hash.</li><li>git reset HEAD <em>fichero → </em>Extrae el fichero del commit actual.</li><li>git reset — mixed <em>hash →</em> resetea el commit indicado por el hash, pero mantiene los cambios en el área de trabajo (stashed area).</li></ul><p>Si queremos saber a qué commit se está apuntando actualmente en nuestra rama (master por ejemplo), podemos consultar el fichero .git/refs/heads/master de nuestro repositorio.</p><p>Uno de los preceptos bajo el cual utilizamos un control de versiones es favorecer el orden y la visualización de nuestra aplicación, por lo que el uso de comandos como ‘<strong>clean</strong>’ deberían estar siempre entre nuestras herramientas frecuentes.</p><ul><li>git clean -n → nos muestra los archivos que hay en el area de trabajo pero no en el staged, por lo que deberían eliminarse.</li><li>git clean -f → elimina todos los archivos no subidos al stage o al repositorio.</li></ul><p>Para la <strong>visualización</strong> de nuestras versiones podemos hacer uso del comando ls-tree:</p><ul><li>git ls-tree master^ → nos permite ver el contenido de la versión anterior de la carpeta del repositorio</li><li>git ls-tree master~3 → nos permite ver el contenido de hace tres versiones de la carpeta del repositorio</li></ul><p>A nivel de consulta de <strong>logs</strong>, existen muchas opciones, en mi caso las que me parecen más interesantes son:</p><ul><li>git log — oneline → muestra 1 commit por línea</li><li>git log — since=3.days → muestra los commits de los últimos tres días.</li><li>git log — stat — summary → muestra las estadísticas y totales</li><li>git log — graph → permite una visualización gráfica del histórico de nuestras versiones.</li><li>git log — oneline — graph — all — decorate → permite una visualización similar a la del anterior comando, pero de un modo más compacto.</li></ul><p>Otro elemento importante en el control de versiones es el manejo de nuestras ramas, por lo que estos comandos pueden suponer una gran ayuda cuando queremos una gestión clara y fácil de seguir.</p><ul><li>git diff — color-words branch1..branch2 → Nos permite ver diferencias entre dos ramas</li><li>git branch — merged → Nos permite ver qué ramas están incluidas por completo en nuestra rama actual</li><li>git branch -m nombreviejo nombrenuevo → Con este comando podemos cambiar el nombre de la rama por otro diferente</li><li>git branch -d branch → Eliminado de rama<br> no se puede eliminar una rama con cambios no integrados</li><li>git branch -D branch → Fuerza el eliminado aunque haya cambios no integrados</li><li>git merge — abort → Con este comando podremos deshacer un intento de merge con conflictos.</li></ul><p>Finalmente, trataremos el stash, con frecuencia tendremos que recurrir a stashear nuestros cambios para realizar diferentes operaciones en nuestras ramas y repositorios sin que los conflictos nos desquicien.</p><ul><li>git stash save ‘nombre para el stash’ → Se hace stash asignando un nombre<br> los cambios en stash pueden volcarse en otras ramas si lo deseamos, no solo en la actual.</li><li>git stash pop → recupera el contenido guardado en el stash y lo elimina de éste área.</li><li>git stash apply → Actúa igual que git stash pop, pero sin eliminarlo del area de stash.</li><li>git stash drop id → Elimina un stash concreto</li><li>git stash clear → Elimina todos los cambios del area de stash</li><li>git branch branch-local branch-remoto → Creamos un branch local apuntando al remoto</li><li>git push origin — delete branch-remoto → Elimina el branch remoto indicado .</li></ul><p>Estos son algunos comandos útiles que considero interesantes a la hora de trabajar con git, especialmente si nos gusta operar desde la terminal de comandos. Espero que sean de utilidad, o cuanto menos despierten una cierta inquietud que os haga experimentar con ellos y llegar a dominarlos, llegar a dominar git mas allá de la secuencia</p><p><em>git add * / git commit -m ‘cambios’ / git push origin master</em></p><p>Gracias por haber llegado hasta aquí, un saludo!.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6efaed8ae26e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Dear John Doe, Thanks for all]]></title>
            <link>https://medium.com/@PabloLeonPsi/dear-john-doe-thanks-for-all-4cdbc1ea9c3e?source=rss-383115e1da4f------2</link>
            <guid isPermaLink="false">https://medium.com/p/4cdbc1ea9c3e</guid>
            <category><![CDATA[development]]></category>
            <category><![CDATA[motivation]]></category>
            <category><![CDATA[inspiration]]></category>
            <category><![CDATA[github]]></category>
            <dc:creator><![CDATA[Pablo León]]></dc:creator>
            <pubDate>Mon, 25 Jun 2018 17:25:01 GMT</pubDate>
            <atom:updated>2018-06-25T17:25:01.809Z</atom:updated>
            <content:encoded><![CDATA[<p>Estaba convencido de que mi próximo artículo sería bastante más técnico que los anteriores… Pero en lo que consigo ser un buen programador, seguiré siendo un escritor empedernido.</p><p>Pero como siempre, trataré de unir todos los cabos que me rondan y darle un sentido a todo esto.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nvqklB9KW14zMgdXmPgvVA.jpeg" /><figcaption>Edison y Homer Simpson</figcaption></figure><p>Y es que todo surgió en ese camino a ser un web developer. Hace tiempo que me vino a la mente aquél capítulo de los Simpsons en el que Homer quiere ser un gran inventor y como fuente de inspiración/motivación cuelga un poster de Thomas Edison en el que se muestran los logros conseguidos por éste y el largo camino que al protagonista le restaba para llegar a ser como él… ¿Dónde encontraría a grandes referentes en el desarrollo de software? ¿Cómo identificar a las/los rockstar de la programación?</p><p>Lejos de los ancestrales Gates, Wozniak, Torvalds.. Necesitaba referentes contemporáneos, pero la mayor parte del tiempo, los grandes nombres que despuntaban no eran sino el estandarte de un navío repleto de remeros anónimos, un currículo más propio del marketing que del desarrollo. Y ésto me llevó al siguiente estadio de la búsqueda: No quería colgar la foto de portada de las revistas de informática del quiosco, quería observar con respeto a toda esa gente que hacía algo más que escribir código o vender un gran software…</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/1*UFqA6hSj7KqzQtouP5jfwA.jpeg" /><figcaption>Comienza la búsqueda</figcaption></figure><p>Así que me puse manos a la obra, iniciaba la búsqueda de gente que hiciera algo grande, no sólo un gran código, sino grandes acciones, gente que aportara algo al mundo que le rodeara, y sobre todo, que no lo hiciera (o no simplemente) por beneficio económico o por propio ego… ¿Una tarea difícil?</p><p>Al final no lo fue tanto, y es que por suerte tenía ante mí la mejor herramienta posible: <a href="http://github.com/">Github</a> (no puedo pasar sin agradecer a mi hermano que me lo descubriera hace casi un par de años). Un lugar en el que puedes ver qué hace la gente en temas de desarrollo, en qué proyectos andan metidos, qué propósito tienen éstos, a qué otras personas siguen, qué otros proyectos observan…</p><p>No es la primera vez que lo comento en alguna red social, me encanta entrar en github y ver en qué anda metida la gente.. Esa gente a la que considero referentes, mis ejemplos a seguir.. Y No, no aparecen en la portada de ninguna gran revista, no ocupan los grandes artículos de los blogs de tecnología, pero que sin embargo están cambiando el mundo, están haciendo algo mejor de él desde el mismo sector en el que hoy por hoy me muevo..</p><p>Quizás quede feo, pero lo cierto es que debo admitir que no falta un toque de stalkeo en toda esta historia, el lado positivo es que no hay nada oculto, es una suerte cuando la gente da charlas sobre lo que hace, comparte lo que ha aprendido o en lo que está trabajando, sube sus códigos a un repositorio… Gente que cuelga cursos enteros de forma gratuita! Sus propios libros! …De mayor quiero ser como ellos.</p><p>Así que en resumidas cuentas, puedo decir que tengo muy presentes a ciertas personas, en absoluto lejanas, que son grandes referentes para mí, ejemplos de aquello en lo que espero convertirme algún día, historias reales, tangibles.. rostros anónimos que a los que hoy no nombraré, pero que afortunadamente puedo saludarles, escucharles en directo o en diferido..</p><p>Hay una frase de 2pac que me gusta recordar, la tenía presente mientras estudiaba para ser psicólogo, y la tengo presente mientras trato de convertirme en desarrollador web..</p><blockquote>“No estoy diciendo que voy a cambiar el mundo, pero garantizo que encenderé la llama en el cerebro que sí lo hará”.</blockquote><p>Gracias por vuestra constancia, por tratar de encender pequeñas llamas dentro de la gente, estais cambiando el mundo, sin gritar, sin vender humo.. Sino con hechos. Algunos de vosotros ya lo sabeis de mi propia voz, pero me habeis convencido, motivado y enganchado… Por supuesto no quedará en palabras.</p><p>Nos vemos pronto!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4cdbc1ea9c3e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Mi primer día con Github]]></title>
            <link>https://medium.com/@PabloLeonPsi/mi-primer-d%C3%ADa-con-github-5a11ae2bd250?source=rss-383115e1da4f------2</link>
            <guid isPermaLink="false">https://medium.com/p/5a11ae2bd250</guid>
            <category><![CDATA[git]]></category>
            <category><![CDATA[self-learning]]></category>
            <category><![CDATA[developer]]></category>
            <category><![CDATA[github]]></category>
            <dc:creator><![CDATA[Pablo León]]></dc:creator>
            <pubDate>Fri, 27 Oct 2017 08:55:16 GMT</pubDate>
            <atom:updated>2017-10-27T08:55:16.631Z</atom:updated>
            <content:encoded><![CDATA[<p>A veces los inicios son desconcertantes y caóticos. Cuando llegué al mundo de la programación, una de las primeras cosas que descubrí fue Github, una plataforma de desarrollo colaborativo basada en el sistema de control de versiones Git.</p><p>La primera vez que entré y revisé algunos repositorios lo que me vino a la cabeza es que era un escaparate para programadores (cuanto me quedaba por aprender…); como fuera, estaba claro que era una herramienta fundamental para cualquiera que fuese a escribir miles de líneas de código, por lo que estaba claro: Tenía que aprender a manejarme en Github.</p><p><strong>Octocat 1 — Pablo 0</strong><br>Como en casi todo en esta vida, puedes aprender al estilo burocrático (lee, entra en ese link que te lleva a otra información, vuelve, dirígete al siguiente link, descansa y tómate un café) o hacerlo al modo punk (hazlo a tu manera, deprisa y, si falla, ciérralo todo y echa a correr). Mi primer error fue tomar la segunda opción.<br>No es necesario leerte toda la documentación de la que dispone Github, ni aprender en un fin de semana todos los entresijos del control de versiones, pero si que hay que llevar un par de cosas claras:<br>El control de versiones permite registrar los cambios que se llevan a cabo sobre un archivo o conjunto de archivos a lo largo del tiempo y facilitar funcionalidades distintas, de tal modo que pueda accederse a cualquiera de estas versiones más adelante. Esto significa que la mayoría de los comandos y funciones que encontraremos están dirigidas a gestionar las diferentes ramas (branch) de un proyecto, así que antes de empezar a crear y fusionar ramas, es importante tener claro los distintos flujos por los que discurren nuestras versiones del proyecto. <br>En mi caso, no tenía claro de donde hacia donde se movían las versiones, ni qué era lo que hacían los principales comandos, así que una vez que seguí los primeros pasos (subir el primer documento a tu repositorio), todo pasó a ser un pequeño caos en el que la mitad del código se fue al traste, había clones del documento y mi consola de comandos no hacía más que protestar porque el documento que trataba de subir parecía no existir.<br>En fin, para evitaros alguna que otra derrota contra git, os muestro la funcion de algunos de los comandos que más utilizareis cuando comenceis con vuestro control de versiones:</p><blockquote>commit: Envia los datos del working directory al repositorio local<br>push: Sincroniza los cambios del repositorio local a otro repositorio remoto.<br>fetch: Sincroniza los cambios de un repositorio remoto al repositorio local.<br>pull: Sincroniza los cambios de un repositorio remoto al working directory.<br>checkout: Actualiza el workind directory con los datos del repositorio local.</blockquote><p>Además, esta imagen quizás ayude a visualizar la dirección y el impacto de dichos comandos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/738/1*lWS_YsYDgGNzwleoSK8jOg.png" /></figure><p><strong>Octocat 1 — Pablo 1 (Vendetta)</strong></p><p>Creo que fue en el tercer repositorio cuando comencé a asimilar y automatizar la secuencia para subir mis proyectos a repositorios remotos (lo que después se convirtió en una cascada de ejercicios de clase que había que subir a diario).<br><em>git add *</em> (donde * eran los ficheros a subir, los conejillos de indias)<br><em>git status</em> (comprobación de estado)<br><em>git commit -m “comentario”</em> (ten cuidado con los comentarios, serán una huella en el cemento)<br><em>git status</em> (no te canses de comprobar)<br><em>git push origin master</em> (subimos los cambios al repositorio remoto)</p><p>Cuando trabajas en soledad, utilizando tus repositorios como meros “almacenes”, tienes suficiente con ésta mecánica, y en el peor de los casos, tendrás que lanzar un ‘<em>git fetch</em>’ para bajarte la versión del código que tenías en el repositorio remoto a tu repositorio local. Resulta interesante poder comprobar cuando realizaste tus últimos commit, para esto tenemos el comando ‘<em>git log</em>’ que para mí podía traducirse en ¿Subí el código antes o después de haber hecho aquél microcambio que ha desencadenado el caos en el programa?<br>Vereis una lísta con indicaciones como ésta:</p><blockquote>commit cbb5c050748ab77623dba750f36d54a44239a113<br>Author: Pablo &lt;######@gmail.com&gt;<br>Date: Wed Oct 25 09:14:26 2017 +0200</blockquote><blockquote>Modificado metodo contarPalabras</blockquote><p>Aquí es donde cobra más sentido el cuidado con lo que ponemos en nuestros commit, si lo hacemos bien, sabremos qué es lo que hicimos en ese momento, no es lo mismo encontrar un ‘subiendo codigo’ que un ‘corregido error casting variables’.</p><p>En definitiva, no hace falta que trabajes con un amplio grupo de trabajo, ni siquiera hace falta que tu programa tenga 10 clases interconectadas, usar Git te permite gestionar tu código, y si te dedicas al desarrollo web, será tu compañero fiel a diario, acostumbrate a usarlo desde tus primeros proyectos y ve experimentando poco a poco, es mejor arriesgarse a perder tu hermoso ‘<em>holaMundo.js</em>’ que comenzar a manejarse con el control de versiones cuando caiga en tus manos el código de tus 10 compañeros de trabajo.<br>Además, considero que es una buena forma de que tu y cualquiera que entre en tus repositorios públicos podáis ir comprobando la progresión de tu código.</p><p>Fin del 1er tiempo, nos vemos después del descanso…</p><p>Gracias por entrar!.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5a11ae2bd250" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Manos o Puños ¿Qué vas a ser?]]></title>
            <link>https://medium.com/@PabloLeonPsi/manos-o-pu%C3%B1os-qu%C3%A9-vas-a-ser-d679b5f2e2b9?source=rss-383115e1da4f------2</link>
            <guid isPermaLink="false">https://medium.com/p/d679b5f2e2b9</guid>
            <category><![CDATA[effort]]></category>
            <category><![CDATA[motivación]]></category>
            <category><![CDATA[perseverance]]></category>
            <category><![CDATA[personal-growth]]></category>
            <category><![CDATA[motivation]]></category>
            <dc:creator><![CDATA[Pablo León]]></dc:creator>
            <pubDate>Sun, 08 Oct 2017 07:25:14 GMT</pubDate>
            <atom:updated>2017-10-08T07:30:27.622Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zJ0JHOjWW4hn5A9WuUN-1A.jpeg" /><figcaption>by dmcneil - helping hand</figcaption></figure><p>Decía un antiguo dicho que la mano que te sostiene está hecha de la misma materia que el puño que te golpea, pero que es absolutamente distinta la esencia que esconden mas allá de la piel. Así, cabría preguntarse: ¿Qué vas a hacer con aquello que te está brindando la vida?<br> <br> A veces la atmósfera se condensa como un lago de miel amarga, cada paso se convierte en un esfuerzo y las pocas manos que aparecen van a parar al cuello, clavando tus pies aún más profundo, y entonces la duda ronda tu mente “¿por qué a todos los puentes de este valle les han brotado aduanas y peajes?”. Correrías a toda prisa y vaciarías tus bolsillos en el mostrador para tener alguna vez la misma facilidad, pero sientes que no te queda ni un céntimo de aire en la cartera.<br> Con los zapatos enredados en la oscura jalea contemplas la meta, ves la luz al final del túnel y una balanza que nada más sopesa que hayas sido capaz de llegar al final, ¿Nadie le habló de los mil caminos que llevaban hasta allí? ¿Nadie le contó sobre la caja negra que recoge cada sendero entre la meta y el pistoletazo de salida? Era un dulce camino hasta que el néctar se hizo brea espinada.<br> <br> Si, es cierto, te cuesta respirar, y las heridas te escuecen incluso podrías llegar a preguntarte… ¿Merezco intentarlo?<br> La respuesta es: si, por supuesto, demonios que si! y si unos dedos van a hendirse en la llaga, recuerda.. si sangras es porque estás vivo, y si la soga se estrecha en torno a tu cuello, recuerda.. si te queda aliento, aun puedes gritar un día más.<br> Así que no abandones, no importa si estás solo, no importa si el camino es una cuesta arriba bajo la lluvia, si estás vivo, tienes la oportunidad de hacer algo más en este mundo, tienes la posibilidad de cambiar las cosas.<br> Recuerdo a menudo (y otras me obligo a recordar) las palabras de Bob Marley “La gente que esta tratando de hacer este mundo peor no se toman ni un día libre, ¿Cómo podría tomármelo yo?, Hay que iluminar la oscuridad”. Sería sencillo hincar la rodilla en el suelo y autoconvencerse de que es lo correcto, pero no estamos hechos para tomar el camino fácil, por más manos que quieran cubrir el cielo, ¿podrías olvidar que el sol sigue brillando más allá?<br> <br> Lucho porque no me gusta lo que veo, lucho porque si no lo hiciera, mi estancia en este mundo no tendría sentido alguno. quizás no sea el mejor, pero soy testarudo, quizás no sea la solución, pero me niego a ser parte del problema…<br> Decía Tupac aquello de “No estoy diciendo que voy a cambiar el mundo, pero garantizo que encenderé la llama del cerebro que si lo hará”. Quizás no desaparezca todo lo malo que nos rodea, pero ¿Acaso por eso deberíamos dejar que lo devore todo?<br> <br> A veces ayuda dejar en voz alta los pensamientos, repetirse ante uno mismo.. “puedes, y lo harás”.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d679b5f2e2b9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Mentor y Aprendiz. La misma persona]]></title>
            <link>https://medium.com/@PabloLeonPsi/mentor-y-aprendiz-la-misma-persona-b46075a94084?source=rss-383115e1da4f------2</link>
            <guid isPermaLink="false">https://medium.com/p/b46075a94084</guid>
            <category><![CDATA[motivation]]></category>
            <category><![CDATA[mentoring]]></category>
            <category><![CDATA[web-development]]></category>
            <dc:creator><![CDATA[Pablo León]]></dc:creator>
            <pubDate>Wed, 20 Sep 2017 18:13:15 GMT</pubDate>
            <atom:updated>2017-09-20T18:13:15.979Z</atom:updated>
            <content:encoded><![CDATA[<p>Como graduado en Psicología, siempre he tenido pasión por observar la conducta de las personas en su día a día, comprender por qué hacen lo que hacen, saber qué les mueve en aquellas decisiones que marcan un hábito, un patrón distintivo en cada uno. Al fin y al cabo, aquello que hacemos o no es lo que nos define.</p><p>Pero es ahora, inmerso en mi formación como Desarrollador Web, y lejos de la (en mi opinión) obsoleta docencia universitaria, cuando he encontrado un rasgo que me ha fascinado tanto como para dar el salto y escribir sobre ello. Me refiero al caso de la mentoría, y no hablo de ese rol legal o de obligado cumplimiento, sino de todo lo contrario, centro la atención en aquellas personas que con mayor o menor frecuencia hacen un punto y a parte en sus vidas para enseñar algo a los demás.</p><p>Desde que comencé esta nueva etapa educativa, he sido asiduo a todo tipo de eventos relacionados con la materia: Talleres, Charlas, Reuniones… Lugares donde siempre encontraba un denominador común, allí delante había alguien que se estaba ofreciendo libremente a enseñar algo, con mayor o menor profundidad, y con mayor o menor formalidad, pero se situaba ante mí y el resto de asistentes, invirtiendo un tiempo de su vida en enseñarnos algo. Lo que me fascinaba y sigue fascinándome es la satisfacción intrínseca que parece producirles, podían comenzar su charla temblando como un flan, pero terminaban con una sonrisa que delataba una recompensa que ninguno podía ver o palpar, su premio no estaba hecho de metal ni papel.</p><p>A veces, en el mayor de los casos para ser honesto, quien estaba ahí de pie no era más que otro estudiante más, un alumno con una gran inquietud y aún mas ganas de compartir lo que había aprendido, y siempre, en todas las ocasiones, nos hablaba un aprendiz.</p><p>Porque es lo que somos, lo que siempre seremos, porque tener la capacidad de enseñar algo, no significa en absoluto que no tengas nada más que aprender, ni siquiera en aquello de lo que estés enseñando. Se enseña para que otros aprendan, pero también se hace para aprender uno mismo.</p><p>Es algo que me encanta ver, cómo a una persona le gusta algo tanto que se lanza a aprender sobre ello, tanto como para ser capaz de explicarselo a otros después, y que acto seguido se siente a escuchar como otra persona toma el relevo. Y es que, como dicta un viejo pero acertado dicho, “si eres capaz de explicarlo, significa que lo entiendes”, y además es satisfactorio, tremendamente satisfactorio. La sensación de haber aportado algo a otras personas, de haber puesto tu grano de arena para que otros mañana puedan dar ese paso es una experiencia que merece la pena vivir. No importa de donde vengas, no importa qué estés haciendo, siempre habrá alguien mas sabio que tu al que escuchar y alguien mas inexperto que tu al que enseñar.</p><p>Este, además de mi primer aporte a la comunidad, es en parte un pequeño agradecimiento a todos aquellos aprendices que no dudan en enseñarnos algo, a los que se atreven a dar un salto por esa motivación intrínseca… Aprende, Comparte y Diviertete!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*V9t3HXgD-HE05vPtuluoew.png" /><figcaption>Tumisu — Help (Pixabay)</figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b46075a94084" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>