<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Posts on metroSetenta</title>
    <link>https://metrosetenta.es/post/</link>
    <description>Recent content in Posts on metroSetenta</description>
    <generator>Hugo</generator>
    <language>en-us</language>
    <lastBuildDate>Fri, 23 Jan 2026 08:02:54 +0100</lastBuildDate>
    <atom:link href="https://metrosetenta.es/post/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>Las releases no están ligadas a Scrum</title>
      <link>https://metrosetenta.es/blog/las-releases-no-estan-ligadas-a-scrum/</link>
      <pubDate>Thu, 22 Jan 2026 00:00:00 +0000</pubDate>
      <guid>https://metrosetenta.es/blog/las-releases-no-estan-ligadas-a-scrum/</guid>
      <description>&lt;p&gt;En desarrollo de software es habitual asumir que las releases forman parte natural del proceso de &lt;em&gt;Scrum&lt;/em&gt;; que ocurren al final de un sprint, que agrupan todas las historias planificadas o que representan el último estado del flujo de trabajo. Sin embargo, esta asociación es más cultural que real. Aunque lo parezca, &lt;strong&gt;las releases no dependen de &lt;em&gt;Scrum&lt;/em&gt;, ni del estado de tus historias, ni de lo que hayas decidido planificar en un sprint.&lt;/strong&gt;&lt;/p&gt;</description>
    </item>
    <item>
      <title>La batalla entre producción y calidad</title>
      <link>https://metrosetenta.es/blog/la-batalla-entre-produccion-y-calidad/</link>
      <pubDate>Fri, 21 Feb 2025 00:00:00 +0000</pubDate>
      <guid>https://metrosetenta.es/blog/la-batalla-entre-produccion-y-calidad/</guid>
      <description>&lt;p&gt;La batalla entre producción y calidad no es exclusiva del desarrollo de software; se da en todas las industrias. En la manufactura, por ejemplo, Henry Ford revolucionó la producción con la línea de ensamblaje, permitiendo fabricar automóviles a una velocidad sin precedentes. Sin embargo, este enfoque sacrificaba la personalización y, en algunos casos, la durabilidad de los vehículos. En la industria de la moda, las marcas de fast fashion logran lanzar nuevas colecciones en semanas, pero a menudo a costa de la calidad de los materiales y la sostenibilidad.&lt;/p&gt;&#xA;&lt;p&gt;En el desarrollo de software, esta tensión también existe: algunos desarrolladores priorizan la entrega rápida de funcionalidades, mientras que otros se enfocan en la solidez y estabilidad del código. Como Product Owner, tu papel es comprender estos dos enfoques y gestionarlos adecuadamente para el éxito de tu proyecto.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Registro de decisiones arquitectónicas</title>
      <link>https://metrosetenta.es/blog/registro-de-decisiones-arquitectonicas/</link>
      <pubDate>Fri, 03 Jan 2025 00:00:00 +0000</pubDate>
      <guid>https://metrosetenta.es/blog/registro-de-decisiones-arquitectonicas/</guid>
      <description>&lt;p&gt;En un proyecto de software, las decisiones de alto nivel las puedes documentar en un formato estándar conocido como &lt;strong&gt;ADR (Architecture Decision Record)&lt;/strong&gt;. Los &lt;a href=&#34;https://learn.microsoft.com/en-us/azure/well-architected/architect-role/architecture-decision-record&#34;&gt;ADR&lt;/a&gt; son documentos cortos y claros que capturan información clave sobre decisiones arquitectónicas y de diseño importantes. A continuación, te explico cómo puedes documentar y compartir estas decisiones:&lt;/p&gt;</description>
    </item>
    <item>
      <title>Casos de uso de Web 3.0: aplicaciones actuales y futuras</title>
      <link>https://metrosetenta.es/blog/casos-uso-web-3-0/</link>
      <pubDate>Fri, 30 Aug 2024 00:02:00 +0000</pubDate>
      <guid>https://metrosetenta.es/blog/casos-uso-web-3-0/</guid>
      <description>&lt;p&gt;Web 3.0, la tercera generación de internet, está revolucionando la manera en que interactuamos en línea, proporcionando un ecosistema más descentralizado, seguro y transparente. A medida que esta tecnología avanza, surgen nuevas aplicaciones que aprovechan las características únicas de Web 3.0, cambiando radicalmente diversas industrias y servicios. A continuación, exploramos algunos de los casos de uso más destacados de Web 3.0, tanto actuales como futuros.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Importancia de la Descentralización en Web 3.0</title>
      <link>https://metrosetenta.es/blog/importancia-de-la-descentralizacion-web-3-0/</link>
      <pubDate>Fri, 30 Aug 2024 00:01:00 +0000</pubDate>
      <guid>https://metrosetenta.es/blog/importancia-de-la-descentralizacion-web-3-0/</guid>
      <description>&lt;p&gt;La &lt;strong&gt;descentralización&lt;/strong&gt; es uno de los pilares más importantes de Web 3.0. A diferencia de los modelos centralizados de Web 2.0, donde los datos y el poder se concentran en manos de unas pocas entidades, Web 3.0 se basa en la distribución del control a través de una red de nodos independientes. Pero, ¿por qué es tan crucial la descentralización para la próxima generación de internet?&lt;/p&gt;</description>
    </item>
    <item>
      <title>Principios Fundamentales de Web 3.0</title>
      <link>https://metrosetenta.es/blog/principios-fundamentales-web-3-0/</link>
      <pubDate>Fri, 30 Aug 2024 00:00:00 +0000</pubDate>
      <guid>https://metrosetenta.es/blog/principios-fundamentales-web-3-0/</guid>
      <description>&lt;p&gt;Web 3.0, la evolución más reciente de internet, se basa en varios principios fundamentales que buscan transformar la forma en que interactuamos con la web. Estos principios no solo redefinen la estructura técnica de internet, sino que también promueven un cambio en cómo se gestionan los datos, la privacidad y la seguridad en línea.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Diferencias entre Web 2.0 y Web 3.0</title>
      <link>https://metrosetenta.es/blog/diferencias-web-2-0-y-web-3-0/</link>
      <pubDate>Thu, 29 Aug 2024 00:01:00 +0000</pubDate>
      <guid>https://metrosetenta.es/blog/diferencias-web-2-0-y-web-3-0/</guid>
      <description>&lt;p&gt;A medida que la tecnología evoluciona, también lo hace la forma en que interactuamos con internet. &lt;strong&gt;Web 2.0&lt;/strong&gt; y &lt;strong&gt;Web 3.0&lt;/strong&gt; representan dos etapas distintas en el desarrollo de la web, cada una con características y filosofías únicas que las diferencian.&lt;/p&gt;</description>
    </item>
    <item>
      <title>¿Qué es Web 3.0?</title>
      <link>https://metrosetenta.es/blog/que-es-web-3-0/</link>
      <pubDate>Thu, 29 Aug 2024 00:00:00 +0000</pubDate>
      <guid>https://metrosetenta.es/blog/que-es-web-3-0/</guid>
      <description>&lt;p&gt;Web 3.0, también conocida como la tercera generación de internet, es una evolución de la web tradicional hacia un entorno más descentralizado, seguro y transparente. A diferencia de Web 2.0, que se centra en la creación de contenido y la interacción social a través de plataformas centralizadas, Web 3.0 utiliza tecnologías de &lt;strong&gt;blockchain&lt;/strong&gt; y &lt;strong&gt;contratos inteligentes&lt;/strong&gt; para crear aplicaciones y servicios que no dependen de una autoridad central.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Código que no quieras compartir</title>
      <link>https://metrosetenta.es/blog/codigo-que-no-quieras-compartir/</link>
      <pubDate>Mon, 11 Dec 2023 07:07:07 +0000</pubDate>
      <guid>https://metrosetenta.es/blog/codigo-que-no-quieras-compartir/</guid>
      <description>&lt;p&gt;¿Te ha pasado en alguna ocasión que no quieres compartir modificaciones de código? Te cuento mi caso.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Notas personales del proyecto</title>
      <link>https://metrosetenta.es/blog/notas-personales-del-proyecto/</link>
      <pubDate>Mon, 04 Dec 2023 07:07:07 +0000</pubDate>
      <guid>https://metrosetenta.es/blog/notas-personales-del-proyecto/</guid>
      <description>&lt;p&gt;En ocasiones podemos disponer de una buena documentación, una wiki del proyecto o cualquier plataforma de colaboración que nos permita consultar y compartir información técnica, configuraciones, procesos de gestión&amp;hellip; Pero seamos sinceros, documentar no es lo que más nos gusta a los ingenieros de desarrollo de software y estas opciones no siempre están disponibles para nosotros. Por otro lado, &lt;strong&gt;es posible que quieras disponer de algunas notas personales, scripts de automatización o incluso configuraciones personales para el proyecto donde estás colaborando&lt;/strong&gt;.&lt;/p&gt;</description>
    </item>
    <item>
      <title>El motivo de los mecanismos de consenso en Blockchain</title>
      <link>https://metrosetenta.es/blog/el-motivo-de-los-mecanismos-de-consenso-en-blockchain/</link>
      <pubDate>Mon, 06 Nov 2023 07:07:07 +0000</pubDate>
      <guid>https://metrosetenta.es/blog/el-motivo-de-los-mecanismos-de-consenso-en-blockchain/</guid>
      <description>&lt;p&gt;El &lt;strong&gt;doble gasto&lt;/strong&gt; (&lt;em&gt;double spending&lt;/em&gt;) es un concepto crítico en el entorno de blockchain y las criptomonedas. Se refiere al acto de gastar el mismo token digital, por ejemplo una criptomoneda, dos veces o más. En un sistema de pago tradicional como el dinero en efectivo, en la compra se transfiere directamente el bien utilizado como modo de pago, y al dejar de poseerlo es imposible volver a gastarlo. Por otro lado, en las transacciones bancarias centralizadas hay una entidad que registra y controla todos los movimientos, cuidando así de evitar el doble gasto, pero en las redes blockchain descentralizadas, y por tanto donde no existe dicha entidad, evitarlo es un desafío significante.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Breve descripción de Blockchain</title>
      <link>https://metrosetenta.es/blog/breve-descripci%C3%B3n-de-blockchain/</link>
      <pubDate>Tue, 02 May 2023 07:07:07 +0100</pubDate>
      <guid>https://metrosetenta.es/blog/breve-descripci%C3%B3n-de-blockchain/</guid>
      <description>&lt;p&gt;Blockchain es una tecnología descentralizada que permite almacenar y compartir información de forma segura.&lt;/p&gt;&#xA;&lt;p&gt;Atendiendo a su diseño &lt;strong&gt;no existe un único actor con la capacidad de acceder a la información y gestionarla&lt;/strong&gt;, por tanto, se debe establecer un mecanismo de consenso entre todos los actores capaces para realizar dichas acciones. Esto es lo que le otorga a Blockchain su caracter descentralizado.&lt;/p&gt;&#xA;&lt;p&gt;&lt;strong&gt;Cuando se alcanza una determinada cantidad de información a almacenar, esta se empaqueta en un bloque junto un hash del contenido del último bloque existente&lt;/strong&gt;. Este modo de ordenar y almacenar datos es lo que le otorga el nombre de cadena de bloques. También confiere seguridad pues, al modificar el contenido de cualquier bloque, el hash que hace referencia a dicho contenido en el bloque posterior será incorrecto y, por tanto, se detectará una manipulación no deseada.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Rendimiento de los componentes funcionales en React</title>
      <link>https://metrosetenta.es/blog/rendimiento-de-los-componentes-funcionales-en-react/</link>
      <pubDate>Mon, 20 Jun 2022 07:07:07 +0100</pubDate>
      <guid>https://metrosetenta.es/blog/rendimiento-de-los-componentes-funcionales-en-react/</guid>
      <description>&lt;p&gt;El compromiso del equipo de &lt;a href=&#34;https://reactjs.org/&#34;&gt;React&lt;/a&gt;, desde la aparición de los componentes funcionales, siempre ha sido hacer que estos fueran más eficientes que los componentes basados en clases. De hecho, si le preguntas a cualquier desarrollador que use React, seguro que afirma convencido que son mucho más rápido y eficientes, aunque la realidad es que, en el momento de escribir estas líneas, &lt;strong&gt;apenas existe una diferencia de segundos entre componentes funcionales y componentes basados en clases&lt;/strong&gt;. Teniendo en cuenta que esto es inapreciable para el usuario final, no deberías temer por el rendimiento de tu aplicación si necesitas usar algún componente basado en clases, a pesar de que los componentes funcionales son técnicamente más rápidos y eficientes.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Reconciliación y algoritmo diferencial en React</title>
      <link>https://metrosetenta.es/blog/reconciliacion_y_algoritmo_diferencial_en_react/</link>
      <pubDate>Fri, 17 Jun 2022 07:07:07 +0100</pubDate>
      <guid>https://metrosetenta.es/blog/reconciliacion_y_algoritmo_diferencial_en_react/</guid>
      <description>&lt;p&gt;Si has usado &lt;a href=&#34;https://reactjs.org/&#34;&gt;React&lt;/a&gt; para desarrollar aplicaciones web seguro que ya sabes que cuando un componente es modificado, ésta biblioteca de código de &lt;em&gt;Javascript&lt;/em&gt; crea un DOM virtual para compararlo con el DOM actual y, de este modo, calcular si es necesario actualizarlo. &lt;strong&gt;A este proceso de actualizar el DOM actual cuando es necesario, para mantenerlo sincronizado con el DOM virtual, se le llama &lt;a href=&#34;https://es.reactjs.org/docs/reconciliation.html&#34;&gt;Reconciliación&lt;/a&gt;&lt;/strong&gt;.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Gestión de final de línea en Git</title>
      <link>https://metrosetenta.es/blog/gestion_de_final_de_linea_en_git/</link>
      <pubDate>Sun, 06 Mar 2022 20:34:02 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/gestion_de_final_de_linea_en_git/</guid>
      <description>&lt;p&gt;Creo que no es la primera vez que te cuento que, habitualmente, en las empresas del sector los equipos se plataforman con sistemas operativos &lt;em&gt;Windows&lt;/em&gt;. En Windows las líneas de código finalizan con un retorno de carro y un salto de línea, &lt;strong&gt;CRLF&lt;/strong&gt;, pero en &lt;em&gt;Linux&lt;/em&gt; y &lt;em&gt;Mac&lt;/em&gt;, dichos finales se representan únicamente con saltos de línea, &lt;strong&gt;LF&lt;/strong&gt;. En la gestión de un proyecto donde los programadores usan distintos sistemas operativos, o simplemente deseas mantener un tipo de fin de línea distinto al del sistema operativo que estas usando en el desarrollo, puede ser muy frustrante gestionar los cambios entre versiones de código. Esto se debe a que Git interpretará cambios en cada línea del código, pues donde había simplemente &lt;em&gt;LF&lt;/em&gt;, tu editor colocó &lt;em&gt;CRLF&lt;/em&gt;, y no podrás discernir los cambios reales. Git, sin embargo, dispone de una configuración para gestionar estos casos relativos a los finales de línea, &lt;strong&gt;core.autocrlf&lt;/strong&gt;.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Internacionalización de un proyecto Vue</title>
      <link>https://metrosetenta.es/blog/internacionalizacion-de-un-proyecto-vue/</link>
      <pubDate>Sat, 05 Mar 2022 10:23:02 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/internacionalizacion-de-un-proyecto-vue/</guid>
      <description>&lt;p&gt;Para empezar, y como curiosidad, te cuento que en la abreviatura &lt;strong&gt;i18n&lt;/strong&gt; el número 18 hace referencia a las letras que se encuentran entre la primera y última letra de la palabra i&lt;em&gt;nternacionalitatio&lt;/em&gt;n.&lt;/p&gt;&#xA;&lt;p&gt;La internacionalización de un proyecto de software es algo en cuya implementación no se suele prestar toda la atención requerida. Habitualmente sólo se gestiona el aspecto más básicos que permita mostrar los textos en distintos idiomas, y hay otros aspectos, como la gestión de la pluralización, que quedan olvidados.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Clonado Superficial de repositorio Git</title>
      <link>https://metrosetenta.es/blog/clonado-superficial-de-repositorio-git/</link>
      <pubDate>Tue, 17 Aug 2021 10:23:02 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/clonado-superficial-de-repositorio-git/</guid>
      <description>&lt;p&gt;En ocasiones te puede tocar trabajar en un proyecto cuyo repositorio cuenta ya con varios años de historia. Clonar este tipo de proyectos puede terminar en un error debido a la cantidad de datos a ser transferidos y, por tanto, es preferible hacer un clonado superficial. &lt;em&gt;&lt;strong&gt;Un clonado superficial de un repositorio Git consiste en clonar únicamente parte de la historia del repositorio&lt;/strong&gt;&lt;/em&gt;, y lo puedes hacer con una instrucción similar a la que sigue:&lt;/p&gt;</description>
    </item>
    <item>
      <title>Liberar espacio de WSL</title>
      <link>https://metrosetenta.es/blog/liberar-espacio-de-wsl/</link>
      <pubDate>Wed, 11 Aug 2021 12:48:02 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/liberar-espacio-de-wsl/</guid>
      <description>&lt;p&gt;En muchas empresas es habitual plataformar únicamente el sistema operativo &lt;em&gt;Windows&lt;/em&gt; en los equipos facilitados a los empleados, de modo que, si quieres disponer de las bondades de &lt;em&gt;Linux&lt;/em&gt; para desarrollar tu trabajo, la opción más factible es usar el susbsitema Linux que Windows incluye, &lt;a href=&#34;https://docs.microsoft.com/en-us/windows/wsl/&#34;&gt;WSL&lt;/a&gt;. Desde su segunda versión &lt;em&gt;WSL&lt;/em&gt; se ejecuta en una máquina virtual que intenta ser lo más liviana posible, pero que usa un archivo &lt;a href=&#34;https://www.arysontechnologies.com/blog/how-to-open-vhdx-file/&#34;&gt;vhdx&lt;/a&gt; que crece con el uso de dicho subsistema y, aunque liberes espacio en el subsistema &lt;em&gt;Linux&lt;/em&gt;, la realidad es que no vas a recuperar espacio de tu disco duro si no manipulas directamente el archivo &lt;em&gt;vhdx&lt;/em&gt;.&#xA;Lo primero que necesitas es saber dónde se encuentra dicho archivo. En el caso de que estés usando una distribución Ubuntu, la dirección será similar a esto:&lt;/p&gt;</description>
    </item>
    <item>
      <title>Espacio de nombres</title>
      <link>https://metrosetenta.es/blog/espacio-de-nombres/</link>
      <pubDate>Fri, 25 Jun 2021 08:30:06 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/espacio-de-nombres/</guid>
      <description>&lt;p&gt;En informática, este término hace referencia a un &lt;strong&gt;contenedor abstracto de identificadores únicos&lt;/strong&gt;. Los lenguajes que gestionan espacios de nombres especifican las reglas que determinan a que espacio de nombre pertenece un identificador, de modo que pueden manejar grandes cantidades de estos sin que haya colisión entre ellos, es decir, asegurándose de que son identificadores únicos, a pesar de que algunos de ellos usen la misma designación.&lt;/p&gt;&#xA;&lt;p&gt;Te explico mejor con un ejemplo: Dos personas, Rebeca y Andrés, que pertenecen a empresas distintas, pueden tener un mismo número de empleado, digamos el 456. En este caso la empresa representaría el espacio de nombre, y 456, el número de empleado, representaría el identificador único. Aunque se trata de la misma designación para ambos empleados, 456, no existe colisión porque Rebeca es el empleado 456 de la empresa A, y Andrés es también el 456, pero en la empresa B.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Dominio del problema</title>
      <link>https://metrosetenta.es/blog/dominio-del-problema/</link>
      <pubDate>Mon, 21 Jun 2021 12:07:46 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/dominio-del-problema/</guid>
      <description>&lt;p&gt;En el ámbito de los sistemas de información, el dominio del problema es el &lt;strong&gt;conjunto de conceptos, interrelacionados entre sí, que se necesita conocer para comprender el negocio del cliente&lt;/strong&gt;. Es decir, son todos aquellos conocimientos que están implicados en la correcta comprensión de la necesidad del cliente y, por tanto, son necesarios para proponer una correcta solución.&#xA;Un buen ejemplo podría ser el dominio del problema al desarrollar un aplicación para una clínica médica privada, donde habría de manejar correctamente conceptos como póliza, paciente, cita, diagnóstico&amp;hellip;&lt;/p&gt;</description>
    </item>
    <item>
      <title>Hola mundo al estilo Deno</title>
      <link>https://metrosetenta.es/blog/hola-mundo-al-estilo-deno/</link>
      <pubDate>Sat, 13 Feb 2021 22:59:22 +0100</pubDate>
      <guid>https://metrosetenta.es/blog/hola-mundo-al-estilo-deno/</guid>
      <description>&lt;p&gt;Es habitual, cuando se aprende un lenguaje de programación, escribir una pequeña aplicación mostrando el mensaje &amp;ldquo;¡Hola mundo!&amp;rdquo;. En el caso de &lt;a href=&#34;https://deno.land&#34;&gt;Deno&lt;/a&gt;, vamos a hacer algo un poco diferente para ejecutar tu primer programa con esta tecnología. Ya te conté &lt;a href=&#34;https://metrosetenta.es/blog/que-es-deno/&#34;&gt;aquí&lt;/a&gt; que &lt;em&gt;Deno&lt;/em&gt; ofrece un servicio de repositorios a través de &lt;a href=&#34;https://deno.land/x/&#34;&gt;https://deno.land/x/&lt;/a&gt;, y vamos a usar un programa ejemplo que tienen publicado con el nombre de &lt;em&gt;welcome&lt;/em&gt;. &lt;strong&gt;¡Para que Deno lo descarge, lo compile y lo ejecute, sólo necesitamos escribir una línea!&lt;/strong&gt;:&lt;/p&gt;</description>
    </item>
    <item>
      <title>Configurar en Git un repositorio remoto Subversion</title>
      <link>https://metrosetenta.es/blog/configurar-en-git-un-repositorio-remoto-subversion/</link>
      <pubDate>Sat, 06 Feb 2021 20:15:46 +0100</pubDate>
      <guid>https://metrosetenta.es/blog/configurar-en-git-un-repositorio-remoto-subversion/</guid>
      <description>&lt;p&gt;Hay varios motivos por los cuales podrías querer traer la información de un repositorio de código, versionado con &lt;a href=&#34;https://subversion.apache.org/&#34;&gt;Subversion&lt;/a&gt;, a tu repositorio de código versionado con &lt;a href=&#34;https://git-scm.com/&#34;&gt;Git&lt;/a&gt;, desde sincronizar ambos repositorios durante un periodo de transición de gestor de versiones hasta, simplemente, aprovechar las características de git para la gestión de ramas antes de subir nuevo código al repositorio de &lt;em&gt;Subversion&lt;/em&gt;. Estos motivos son los que justifican la existencia de &lt;a href=&#34;https://git-scm.com/docs/git-svn&#34;&gt;git-svn&lt;/a&gt;, una característica de &lt;em&gt;Git&lt;/em&gt; que nos proporciona comandos para gestionar un flujo bidireccional entre &lt;em&gt;Git&lt;/em&gt; y &lt;em&gt;Subversion&lt;/em&gt;.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Configurar credenciales de repositorios privados en Maven</title>
      <link>https://metrosetenta.es/blog/configurar-credenciales-de-repositorios-privados-en-maven/</link>
      <pubDate>Thu, 28 Jan 2021 23:07:31 +0100</pubDate>
      <guid>https://metrosetenta.es/blog/configurar-credenciales-de-repositorios-privados-en-maven/</guid>
      <description>&lt;p&gt;Son muchísimos los proyectos que, en el momento de escribir este artículo, utilizan &lt;a href=&#34;https://maven.apache.org/&#34;&gt;Maven&lt;/a&gt; para gestionar su gestión de dependencias su construcción. Maven permite, además, la encriptación y gestión de contraseñas, lo cual es muy útil para poder acceder a repositorios privados, como los gestionados con &lt;a href=&#34;https://www.sonatype.com/nexus/repository-pro&#34;&gt;Nexus&lt;/a&gt;, que pueden requerir autorización. Para esto, únicamente necesitas crear un par de archivos en la carpeta &lt;strong&gt;${user.home}/.m2&lt;/strong&gt;, y cuyos nombres serán &lt;strong&gt;settings-security.xml&lt;/strong&gt; y &lt;strong&gt;settings.xml&lt;/strong&gt;.&lt;/p&gt;&#xA;&lt;p&gt;Vamos a comenzar con &lt;strong&gt;settings-security.xml&lt;/strong&gt;, que es el que va a contener una &lt;em&gt;contraseña maestra&lt;/em&gt; de nuestra elección. Podemos crearla con el comando &lt;strong&gt;mvn&lt;/strong&gt; de &lt;em&gt;Maven&lt;/em&gt;.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Ionic React</title>
      <link>https://metrosetenta.es/blog/ionic-react/</link>
      <pubDate>Tue, 17 Nov 2020 14:12:23 +0100</pubDate>
      <guid>https://metrosetenta.es/blog/ionic-react/</guid>
      <description>&lt;p&gt;Ya sabes que &lt;a href=&#34;https://metrosetenta.es/blog/que-es-ionic&#34;&gt;Ionic&lt;/a&gt; se integra perfectamente con los tres principales frameworks de front en el momento de escribir este artículo, &lt;a href=&#34;https://angular.io/start&#34;&gt;Angular&lt;/a&gt;, &lt;a href=&#34;https://reactjs.org/&#34;&gt;React&lt;/a&gt; y, recientemente, con &lt;a href=&#34;https://vuejs.org/&#34;&gt;Vue.js&lt;/a&gt;. Centrándonos en &lt;a href=&#34;://ionicframework.com/react&#34;&gt;Ionic React&lt;/a&gt;, habría que destacar varios aspectos. En definitiva se trata de React, y esto significa que usa los estándares abiertos de la web y las capacidades integradas en los navegadores, por tanto es compatible com millones de bibliotecas de código web. &lt;strong&gt;Ionic React cotinene más de una centena de componentes de interfaz de usuario optimizados para ser utilizados con React, usa la pila estandar de herremientas de React, como react-dom o react-router, y puedes preparar tu aplicación para ser utilizada en &lt;a href=&#34;https://es.wikipedia.org/wiki/IOS&#34;&gt;iOS&lt;/a&gt;, &lt;a href=&#34;https://es.wikipedia.org/wiki/Android&#34;&gt;Android&lt;/a&gt;, &lt;a href=&#34;https://www.electronjs.org/&#34;&gt;Electron&lt;/a&gt; y &lt;a href=&#34;https://es.wikipedia.org/wiki/Aplicaci%C3%B3n_web_progresiva&#34;&gt;PWA&lt;/a&gt;&lt;/strong&gt;.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Qué es Ionic</title>
      <link>https://metrosetenta.es/blog/que-es-ionic/</link>
      <pubDate>Sun, 15 Nov 2020 20:06:31 +0100</pubDate>
      <guid>https://metrosetenta.es/blog/que-es-ionic/</guid>
      <description>&lt;p&gt;&lt;a href=&#34;https://ionicframework.com/what-is-ionic&#34;&gt;Ionic&lt;/a&gt; se define a sí mismo como un entorno de trabajo con el que puedes crear aplicaciones móviles y aplicaciones web progresivas de alto rendimiento. Su filosofía está muy basada en la web, pues entiende que es el entorno de ejecución más probado y estable que existe, de modo que &lt;strong&gt;cualquier desarrollador que tenga conocimientos de &lt;a href=&#34;https://es.wikipedia.org/wiki/HTML&#34;&gt;HTML&lt;/a&gt;, &lt;a href=&#34;https://es.wikipedia.org/wiki/JavaScript&#34;&gt;JavaScript&lt;/a&gt; y &lt;a href=&#34;https://es.wikipedia.org/wiki/Hoja_de_estilos_en_cascada&#34;&gt;CSS&lt;/a&gt; pude desarrollar aplicaciones para distintas plataformas y dispositivos&lt;/strong&gt;. Es más, Ionic puede ser usado con los entornos de trabajo de Javascript más utilizados, &lt;a href=&#34;https://angular.io/start&#34;&gt;Angular&lt;/a&gt;, &lt;a href=&#34;https://reactjs.org/&#34;&gt;React&lt;/a&gt; y, recientemente, con &lt;a href=&#34;https://vuejs.org/&#34;&gt;Vue.js&lt;/a&gt;. La posibilidad de usar las capacidades nativas de un dispositivo, como podría ser la cámara del teléfono inteligente, se añaden gracias al uso de &lt;a href=&#34;https://cordova.apache.org/&#34;&gt;Apache Cordova&lt;/a&gt; o &lt;a href=&#34;https://capacitorjs.com/&#34;&gt;Capacitor&lt;/a&gt;.&lt;/p&gt;</description>
    </item>
    <item>
      <title>El operador Elvis de Groovy</title>
      <link>https://metrosetenta.es/blog/el-operador-elvis-de-groovy/</link>
      <pubDate>Thu, 16 Jul 2020 08:22:43 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/el-operador-elvis-de-groovy/</guid>
      <description>&lt;p&gt;El &lt;em&gt;operador Elvis&lt;/em&gt; es una abreviatura del operador ternario. Un caso en el que suele utilizarse de manera habitual es para devolver un valor que es &lt;em&gt;sensible por defecto&lt;/em&gt; cuando una expresión se resuelve como &lt;em&gt;false&lt;/em&gt;. Un sencillo ejemplo:&lt;/p&gt;&#xA;&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;&#34;&gt;&lt;code class=&#34;language-Groovy&#34; data-lang=&#34;Groovy&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#75715e&#34;&gt;// Con el operador ternario, tienes que repetir el valor a asignar&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#75715e&#34;&gt;&lt;/span&gt;mostrarNombre &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; usuario&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#a6e22e&#34;&gt;nombre&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;?&lt;/span&gt; usuario&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#a6e22e&#34;&gt;nombre&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;:&lt;/span&gt; &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#39;Anónimo&amp;#39;&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#75715e&#34;&gt;//Con el operador de Elvis, el valor que se prueba y se usa si no es falso&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#75715e&#34;&gt;&lt;/span&gt;mostrarNombre &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; usuario&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#a6e22e&#34;&gt;nombre&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;?:&lt;/span&gt; &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#39;Anónimo&amp;#39;&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;El uso del operador Elvis reduce la verbosidad de tu código y los riesgos de errores, en caso de refactorizaciones, al eliminar la necesidad de duplicar la expresión que se prueba, tanto en la condición, como en el valor de retorno positivo.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Qué es una imagen Docker</title>
      <link>https://metrosetenta.es/blog/que-es-una-imagen-docker/</link>
      <pubDate>Fri, 10 Jul 2020 19:04:34 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/que-es-una-imagen-docker/</guid>
      <description>&lt;p&gt;Una &lt;em&gt;imagen Docker&lt;/em&gt; es una plantilla o esquema a partir del cual podemos generar un contenedor Docker, es decir, podemos generar un entorno aislado que está diseñado para ejecutar una o más apliaciones de forma óptima. La imágenes se crean a partir de un archivo, al que se denomina &lt;em&gt;Dockerfile&lt;/em&gt;, usando el comando &lt;strong&gt;docker build&lt;/strong&gt;. Una vez que has generado tu &lt;em&gt;imagen&lt;/em&gt; puedes almacenarla en repositorio de imágenes Docker. En &lt;a href=&#34;https://hub.docker.com/&#34;&gt;Docker Hub&lt;/a&gt;, por ejemplo, puedes almacenar tus imágenes de manera privada o pública.&#xA;Si visitas Docker Hub verás que puedes usar muchísimas imágenes de forma gratuita sin tener que crear tus propias imágenes. Muchas de estas imágenes son oficiales, desarrolladas y distribuidas por equipos desarrolladores de una tecnología específica. Desde bases de datos a herramientas DevOps, pasando por servicios de mensajería e, incluso, sistemas operativos, tienen una &lt;em&gt;imagen&lt;/em&gt; preparada para ser descargada y usada en Docker Hub. Puedes disponer rápidamente de una instancia de Jenkins descargando su &lt;em&gt;imagen&lt;/em&gt; oficial&amp;hellip;&lt;/p&gt;</description>
    </item>
    <item>
      <title>La clase Expando de Groovy</title>
      <link>https://metrosetenta.es/blog/la-clase-expando-de-groovy/</link>
      <pubDate>Fri, 10 Jul 2020 15:23:21 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/la-clase-expando-de-groovy/</guid>
      <description>&lt;p&gt;¿Te imaginas una clase de &lt;a href=&#34;http://www.groovy-lang.org/&#34;&gt;Groovy&lt;/a&gt; a la que le puedes añadir, en tiempo de ejecución, propiedades y métodos? Pues eso es lo que te ofrece su clase &lt;em&gt;Expando&lt;/em&gt;, cuyo uso es muy similar al modo en el que, en &lt;em&gt;JavaScript&lt;/em&gt;, se usan objetos instanciando la variable &lt;em&gt;Object&lt;/em&gt;.&lt;/p&gt;&#xA;&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;&#34;&gt;&lt;code class=&#34;language-Groovy&#34; data-lang=&#34;Groovy&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#75715e&#34;&gt;// Define la classe Expando con dos propiedades:&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#75715e&#34;&gt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;def&lt;/span&gt; blog &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;new&lt;/span&gt; Expando&lt;span style=&#34;color:#f92672&#34;&gt;(&lt;/span&gt;titulo &lt;span style=&#34;color:#f92672&#34;&gt;:&lt;/span&gt; &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;metroSetenta&amp;#34;&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;,&lt;/span&gt; subtitulo &lt;span style=&#34;color:#f92672&#34;&gt;:&lt;/span&gt; &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;Arquitectura y diseño de software&amp;#34;&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;)&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#75715e&#34;&gt;// Añade una nueva propiedad a Expando:&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#75715e&#34;&gt;&lt;/span&gt;blog&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#a6e22e&#34;&gt;url&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt;&lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;metrosetenta.es&amp;#34;&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#75715e&#34;&gt;// Incluye un método con un cierre:&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#75715e&#34;&gt;&lt;/span&gt;blog&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#a6e22e&#34;&gt;toString&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;={&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;  &lt;span style=&#34;color:#66d9ef&#34;&gt;return&lt;/span&gt; &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;&amp;#34;&amp;#34;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#e6db74&#34;&gt;    Título del blog:    ${titulo}&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#e6db74&#34;&gt;    Subtítulo del blog: ${subtitulo}&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#e6db74&#34;&gt;    URL del blog:       ${url}&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#e6db74&#34;&gt;  &amp;#34;&amp;#34;&amp;#34;&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;}&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;println &lt;span style=&#34;color:#f92672&#34;&gt;(&lt;/span&gt;blog&lt;span style=&#34;color:#f92672&#34;&gt;)&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;Observa en el pequeño ejemplo de arriba que el constructor usa una notación similar a los mapas Groovy y, que los métodos, son implementados usando cierres (closures). Puedes probar este pequeño ejemplo guardándolo en un archivo para ejecutarlo con el comando groovy.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Patrones creacionales</title>
      <link>https://metrosetenta.es/blog/patrones-creacionales/</link>
      <pubDate>Thu, 09 Jul 2020 19:42:53 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/patrones-creacionales/</guid>
      <description>&lt;p&gt;Los patrones de diseño creacionales son aquellos que nos proponen soluciones para problemas relacionados con la instanciación de objetos. Automatizar el proceso de construcción de un objeto complejo, limitar la instaciación de una clase a un único objeto al que se pueda acceder de manera global o usar un objeto como prototipo para crear otros objetos similares son algunos de los usos de los patrones de diseño creacionales.&lt;/p&gt;&#xA;&lt;ul&gt;&#xA;&lt;li&gt;&#xA;&lt;p&gt;&lt;strong&gt;Factory Method&lt;/strong&gt; (&lt;em&gt;Método de fabricación&lt;/em&gt;): Si necesitamos un objeto de un tipo, pero desconocemos cual es el objeto concreto que vamos a necesitar en el momento del diseño, este es nuestro patrón. Donde dije tipo puedes poner, por ejemplo, conexión a base de datos, y puedes sustituir objeto concreto por conexión a Oracle Database, conexión a MySQL, conexión a PostgreSQL&amp;hellip;&lt;/p&gt;</description>
    </item>
    <item>
      <title>Monitorizar peticiones en Redmine</title>
      <link>https://metrosetenta.es/blog/monitorizar-peticiones-en-redmine/</link>
      <pubDate>Thu, 09 Jul 2020 15:07:39 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/monitorizar-peticiones-en-redmine/</guid>
      <description>&lt;p&gt;En ocasiones necesitas conocer la evolución de una petición o tarea en &lt;a href=&#34;https://www.redmine.org/&#34;&gt;Redmine&lt;/a&gt;, en la que no estás involucrado, mediante notificaciones por correo electrónico. Es posible hacerlo porque &lt;strong&gt;Redmine te facilita la posibilidad de monitorizar peticiones o tareas&lt;/strong&gt;. Para ello, dirígete a la petición a la que deseas hacer seguimiento y, en la parte inferior, al final del cuerpo de la petición, pulsa en el enlace &lt;em&gt;Monitorizar&lt;/em&gt; que se encuentra junto al icono de la estrella.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Subcomandos de Deno</title>
      <link>https://metrosetenta.es/blog/subcomandos-de-deno/</link>
      <pubDate>Wed, 08 Jul 2020 20:30:48 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/subcomandos-de-deno/</guid>
      <description>&lt;p&gt;Hoy voy a ampliar los &lt;a href=&#34;https://metrosetenta.es/tags/deno/&#34;&gt;artículos sobre Deno&lt;/a&gt; que hay en el blog comentandote los subcomandos disponibles en esta herramienta. Si ya has instalado y configurado Deno, y dispones del comando &lt;em&gt;deno&lt;/em&gt; en tu consola, el primer subcomando que debes probar es &lt;em&gt;help&lt;/em&gt;.&lt;/p&gt;&#xA;&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;&#34;&gt;&lt;code class=&#34;language-Bash&#34; data-lang=&#34;Bash&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;$ deno help&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;Entre otras cosas, te va a facilitar un listado de subcomandos similar al que sigue:&lt;/p&gt;&#xA;&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;&#34;&gt;&lt;code class=&#34;language-Text&#34; data-lang=&#34;Text&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;  bundle         Bundle module and dependencies into single file&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;  cache          Cachea las dependencias&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;  completions    Genera autocompletados de la consola de comandos&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;  doc            Muestra la documentación para un módulo&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;  eval           Evalúa un script&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;  fmt            Formatea archivos fuente&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;  help           Imprime la ayuda general o la de un subcommando dado&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;  info           Muestra información sobre el caché o información relacionada con un archivo fuente&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;  install        Instalar script como un ejecutable&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;  lint           Aplicar resaltado de código a archivos fuente&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;  repl           Bucle leer, evaluar e imprimir&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;  run            Ejecuta un programa desde un nombre de archivo o una URL. Usa &amp;#39;-&amp;#39; como nombre de archivos para leer de la entrada estandar&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;  test           Ejecuta las pruebas&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;  types          Imprime las declaraciones de TypeScripts en tiempo de ejecución&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;  upgrade        Actualiza el ejecutable deno a una versión dada&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;Algo más sobre el subcomando &lt;em&gt;help&lt;/em&gt; es que si lo usas con cualquiera de los subcomandos listados más arriba, te facilitará información más detallada sobre dicho subcomando y su sobre uso. Por ejemplo, si queremos saber algo más sobre el subcomando eval, podemos ejecutar el siguiente comando:&lt;/p&gt;</description>
    </item>
    <item>
      <title>¿Qué es Docker?</title>
      <link>https://metrosetenta.es/blog/que-es-docker/</link>
      <pubDate>Wed, 08 Jul 2020 19:06:02 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/que-es-docker/</guid>
      <description>&lt;p&gt;&lt;a href=&#34;https://www.docker.com/&#34;&gt;Docker&lt;/a&gt; es, posiblemente, la herramienta que revolucionó el modo en el que desplegamos y distribuimos aplicaciones. Asegurarnos de que el entorno en el que se van a ejecutar nuestras aplicaciones es óptimo para ellas ha sido siempre un esfuerzo asociado al desarrollo de software. El uso de máquinas virtuales supuso el acercamiento más satisfactorio antes de Docker, pero el rendimiento se veía comprometido por el esfuerzo que suponía, para el sistema operativo huesped, levantar y gestionar un sistema operativo completo en el que ajustar el entorno deseado y ejecutar nuestra aplicación. &lt;strong&gt;Con Docker, ejecutamos nuestras aplicaciones en entornos aislados, &lt;em&gt;contenedores&lt;/em&gt;, que si bien no son máquinas virtuales, se asemejan muchísimo, pero con la ventaja de aprovechar nuestro sistema operativo todo lo posible en lugar de tener que gestionar un completo sistema operativo inquilino&lt;/strong&gt;.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Patrones de diseño</title>
      <link>https://metrosetenta.es/blog/patrones-de-diseno/</link>
      <pubDate>Sun, 05 Jul 2020 13:08:40 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/patrones-de-diseno/</guid>
      <description>&lt;p&gt;Los patrones de diseño son un concepto que empezó a manejar el arquitecto britano-americano Christopher Alexander en 1966. Mucho más tarde, en 1994, con la publicación de &lt;a href=&#34;https://en.wikipedia.org/wiki/Design_Patterns&#34;&gt;Design Patterns: Elements of Reusable Object-Oriented Software&lt;/a&gt;, dicho concepto comenzó a ganar popularidad en el mundo del desarrollo de software. Este libro fué escrito por cuatro autores que posteriormente serían conocidos como la pandilla de los cuatro (Gang of Four): Erich Gamma, Richard Helm, Ralph Johnson y John Vlissides. &lt;strong&gt;Los patrones de diseño aportan soluciones generales y reutilizables para problemas comunes&lt;/strong&gt;. No se trata de porciones de código, sino de algo más genérico: La descripción de un problema y de una solución, que ha sido probada, a ese problema. Comprender un patrón, identificar cuando es útil, aplicarlo y adaptarlo a un caso concreto es tarea de aquel que lo estudia. El uso adecuado de estos patrones, por tanto, puede acelerar el proceso de diseño y desarrollo de software, pues al aportar paradigmas que han sido probados como eficaces evitan invertir tiempo en buscar una solución partiendo desde cero.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Gestión de memoria de la máquina virtual de Java</title>
      <link>https://metrosetenta.es/blog/gestion-de-memoria-de-la-maquina-virtual-de-java/</link>
      <pubDate>Thu, 02 Jul 2020 12:43:50 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/gestion-de-memoria-de-la-maquina-virtual-de-java/</guid>
      <description>&lt;p&gt;Al espacio de memoria donde Java almacena objetos se denomina &lt;strong&gt;heap&lt;/strong&gt;. El heap se crea cuando la &lt;em&gt;maquina virtual de java&lt;/em&gt;, &lt;strong&gt;JVM&lt;/strong&gt;, se inicia, y puede aumentar o disminuir de tamaño durante la ejecución de la aplicación. Cuando se llena este espacio de memoria Java inicia el proceso de recolección de basura, &lt;strong&gt;Garbage Collector&lt;/strong&gt;. Durante la recogida de basura, los objetos que ya no se utilizan son eliminados, creando así espacio para nuevos objetos. La JVM puede iniciarse con unos parámetros para gestionar la memoria. Con &lt;strong&gt;Xmx&lt;/strong&gt; configuramos el tamaño máximo del heap y con &lt;strong&gt;Xms&lt;/strong&gt; el tamaño mínimo.&#xA;La JVM tiene, también, un espacio permanente para alojar objetos, el &lt;strong&gt;Permanent Generation&lt;/strong&gt; o &lt;strong&gt;Metaspace&lt;/strong&gt; desde Java 8. Será el espacio donde se alojan las clases y los métodos.&#xA;Un ejemplo de configuración de estos parámetros sería como sigue:&lt;/p&gt;</description>
    </item>
    <item>
      <title>Renombrar un repositorio remoto en Git</title>
      <link>https://metrosetenta.es/blog/renombrar-un-repositorio-remoto-en-git/</link>
      <pubDate>Thu, 02 Jul 2020 12:24:45 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/renombrar-un-repositorio-remoto-en-git/</guid>
      <description>&lt;p&gt;&lt;strong&gt;origin&lt;/strong&gt; es la palabra con la que git nombra por defecto un repositorio remoto cuando lo clonas. Renombrar este repositorio como, por ejemplo, &lt;strong&gt;gitlabMetroSetenta&lt;/strong&gt; es una buena idea, porque &lt;em&gt;origin&lt;/em&gt; parece una palabra reservada de &lt;em&gt;Git&lt;/em&gt; y puede causar confusiones. Para comprobar con detalle los repositorios remotos que has configurado en un proyecto git, usa el siguiente comando:&lt;/p&gt;&#xA;&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;&#34;&gt;&lt;code class=&#34;language-Bash&#34; data-lang=&#34;Bash&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;git remote -v&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;Para renombrar un repositorio remoto &lt;em&gt;origin&lt;/em&gt; como &lt;em&gt;miRepositorioRemoto&lt;/em&gt; puedes usar este otro:&lt;/p&gt;</description>
    </item>
    <item>
      <title>Mejorando las búsquedas en Vim</title>
      <link>https://metrosetenta.es/blog/mejorando-las-busquedas-en-vim/</link>
      <pubDate>Sat, 13 Jun 2020 18:56:21 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/mejorando-las-busquedas-en-vim/</guid>
      <description>&lt;p&gt;Vamos a mejorar un poco las búsqueda de porciones de código dentro de nuestros proyectos y, para ello, vamos a comenzar por la entrada de datos que le damos a &lt;a href=&#34;http://github.com/junegunn/fzf&#34;&gt;fzf&lt;/a&gt;. Te presento a &lt;a href=&#34;https://github.com/BurntSushi/ripgrep&#34;&gt;ripgrep&lt;/a&gt;, una herramienta de búsquedas que tiene un rendimiento increible en comparación con otras parecidas como &lt;strong&gt;ugrep&lt;/strong&gt; o &lt;strong&gt;ack&lt;/strong&gt;. Ripgrep usa el archivo &lt;em&gt;.gitignore&lt;/em&gt; por defecto, lo que le dá un enfoque muy Desarrollo para la búsqueda de código. &lt;a href=&#34;https://github.com/BurntSushi/ripgrep#installation&#34;&gt;Aquí&lt;/a&gt; tienes los diferentes métodos de instalación. Una vez que hayas aplicado el mejor para tu máquina, prueba a ejecutar, por ejemplo, el comando &lt;strong&gt;rg return&lt;/strong&gt; en la carpeta de uno de tus proyectos, donde &lt;em&gt;rg&lt;/em&gt; ejecutará ripgrep y &lt;em&gt;return&lt;/em&gt; será el criterio de búsqueda. ¡A mí me pareció impresionante, especialmente, por su velocidad!&lt;/p&gt;</description>
    </item>
    <item>
      <title>Target Not Found en Pamac</title>
      <link>https://metrosetenta.es/blog/target-not-found-en-pamac/</link>
      <pubDate>Sat, 13 Jun 2020 11:35:50 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/target-not-found-en-pamac/</guid>
      <description>&lt;p&gt;Pues nada, que andaba probando programas para crear gifs y, como no me convencieron los que probé del repositorio oficial de &lt;a href=&#34;https://manjaro.org/&#34;&gt;Manjaro&lt;/a&gt;, pues busqué alguno en &lt;a href=&#34;https://aur.archlinux.org/&#34;&gt;AUR&lt;/a&gt;, el repositorio de usuarios de &lt;a href=&#34;https://www.archlinux.org/&#34;&gt;Arch&lt;/a&gt;. En la interfaz gráfica de &lt;a href=&#34;https://wiki.manjaro.org/index.php/Pamac&#34;&gt;pamac&lt;/a&gt; pulsé la opción para refrescar las base de datos e instalar las actualizaciones pendientes. Desde ese momento, cualquier intento de instalación de cualquier software, utilizando los repositorios de AUR, me devolvían el siguiente error:&lt;/p&gt;&#xA;&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;&#34;&gt;&lt;code class=&#34;language-Text&#34; data-lang=&#34;Text&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;target not found&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;Lo cierto es que nunca he necesitado cacharrear en profundidad con los gestores de paquetes de software y, por este motivo, me costó dar con el problema y solucionarlo. Desde la interfaz gráfica de pamac no tenía ninguna opción para ayudarme a dar con la solución, así que, con ayuda de la documentación, probé a instalar paquetes del AUR usándo pamac desde la consola. Así fué como encontré la siguiente pista.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Sacándole más partido a fzf en Vim</title>
      <link>https://metrosetenta.es/blog/sacandole-mas-partido-a-fzf-en-vim/</link>
      <pubDate>Fri, 05 Jun 2020 19:41:43 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/sacandole-mas-partido-a-fzf-en-vim/</guid>
      <description>&lt;p&gt;En &lt;a href=&#34;https://metrosetenta.es/blog/busqueda-de-archivos-en-vim/&#34;&gt;éste&lt;/a&gt; artículo ya te conté que es &lt;a href=&#34;http://github.com/junegunn/fzf&#34;&gt;fzf&lt;/a&gt; y como usarlo en &lt;a href=&#34;https://www.vim.org/&#34;&gt;Vim&lt;/a&gt; para buscar archivos dentro de tu proyecto, pero lo cierto es que podemos aplicarlo para muchísimos más usos. Mediante &lt;a href=&#34;https://github.com/junegunn/fzf.vim&#34;&gt;fzf.vim&lt;/a&gt; puedes tener configurados varios comandos en Vim, sin estar familiarizado con Vimscript, que ponen a tu disposición las aplicaciones más comunes de fzf en este editor de texto.&lt;/p&gt;&#xA;&lt;p&gt;Como siempre, si usas el gestor de conectables &lt;a href=&#34;https://github.com/junegunn/vim-plug&#34;&gt;vim-plug&lt;/a&gt;, que aprendimos a instalar &lt;a href=&#34;https://metrosetenta.es/blog/como-instalar-vim-plug-para-vim&#34;&gt;aquí&lt;/a&gt;, es muy sencillo conectar fzf.vim. La primera línea instalará el conectable de vim del repositorio básico de fzf. Comprueba si ya la tenías en tu configuración con anterioridad.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Búsqueda difusa</title>
      <link>https://metrosetenta.es/blog/busqueda-difusa/</link>
      <pubDate>Thu, 04 Jun 2020 22:45:14 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/busqueda-difusa/</guid>
      <description>&lt;p&gt;Seguro que estás acostumbrado a usar criterios de búsquedas y a aplicar filtros a un conjunto de datos. Cada vez que usas un búscador como &lt;a href=&#34;https://www.google.es/&#34;&gt;Google&lt;/a&gt; o &lt;a href=&#34;https://duckduckgo.com/&#34;&gt;DuckDuckGo&lt;/a&gt; lo haces. &lt;strong&gt;Habitualmente los criterios de búsqueda son aplicados usando algoritmos muy rígidos&lt;/strong&gt;, que devuelven resultados donde las coincidencias de los datos con dichos criterios son exactas. Deja que te hable ahora sobre la &lt;strong&gt;búsqueda difusa (Fuzzy search), donde los algoritmos aplicados son más indulgentes&lt;/strong&gt;, consiguiendo así que podamos lograr resultados a los que no accederíamos con los métodos expuestos anteriormente.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Javascript con Vim: Formateando el código</title>
      <link>https://metrosetenta.es/blog/javascript-con-vim-formateando-el-codigo/</link>
      <pubDate>Fri, 29 May 2020 21:53:39 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/javascript-con-vim-formateando-el-codigo/</guid>
      <description>&lt;p&gt;&lt;a href=&#34;https://prettier.io/&#34;&gt;Prettier&lt;/a&gt; es una herramienta de formateo de código de gran popularidad en el ecosistema JavaScript. Mediante unas &lt;a href=&#34;https://prettier.io/docs/en/options.html&#34;&gt;opciones&lt;/a&gt; especificadas en su archivo de configuración podemos conseguir que todos los archivos de código formateados con Prettier luzcan idéntico sangrado (indent), tipo de comillas, uso de espacios, ancho de líneas, y demás aspectos de estilo. Para disponer de Prettier únicamente tienes que añadirlo a tu proyecto.&lt;/p&gt;&#xA;&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;&#34;&gt;&lt;code class=&#34;language-Bash&#34; data-lang=&#34;Bash&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;$ npm install --save-dev --save-exact prettier&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#75715e&#34;&gt;# or globally&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;$ npm install --global prettier&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;Puedes ejecutar Prettier mediante su &lt;a href=&#34;https://prettier.io/docs/en/cli.html&#34;&gt;CLI&lt;/a&gt;, o puedes &lt;em&gt;engancharlo&lt;/em&gt; para que se ejecute justo antes de una confirmación de cógido de &lt;a href=&#34;https://git-scm.com&#34;&gt;Git&lt;/a&gt;, un &lt;a href=&#34;https://prettier.io/docs/en/precommit.html&#34;&gt;pre-commit hook&lt;/a&gt;, pero la intención de este artículo es usarlo en &lt;a href=&#34;https://www.vim.org&#34;&gt;Vim&lt;/a&gt; para que dé formato a tu archivo de código cuando lo guardas.&lt;/p&gt;</description>
    </item>
    <item>
      <title>JavaScript con Vim: Corrigiendo el código</title>
      <link>https://metrosetenta.es/blog/javascript-con-vim-corrigiendo-el-codigo/</link>
      <pubDate>Fri, 29 May 2020 07:57:33 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/javascript-con-vim-corrigiendo-el-codigo/</guid>
      <description>&lt;p&gt;Los programas de análisis y correción de código son nombrados en inglés como &lt;strong&gt;linters&lt;/strong&gt;. Un corrector de este tipo te ayuda a identificar errores potenciales en tu código sin necesidad de ejecutarlo, evitar patrones problemáticos e, incluso, cumplir con una guía de estilo. En JavaScript, el linter más usado se llama &lt;a href=&#34;https://eslint.org/&#34;&gt;ESLint&lt;/a&gt;, y puedes instalarlo siguiendo los pasos &lt;a href=&#34;https://eslint.org/docs/user-guide/getting-started&#34;&gt;aquí&lt;/a&gt; indicados. Por defecto, ESLint está configurado mediante un juego de &lt;a href=&#34;https://eslint.org/docs/rules/&#34;&gt;reglas&lt;/a&gt; que, comprobando si el código las cumple, gestionan los problemas más comunes. Por supesto, puedes personalizar estas reglas para solucionar problemas específicos; de hecho, existen paquetes de configuración de ESLint, como &lt;a href=&#34;https://www.npmjs.com/package/eslint-config-airbnb-base&#34;&gt;Airbnb&lt;/a&gt;, y es posible que se ajusten a tus necesidades, ahorrándote mucho tiempo en hacer esta tarea.&lt;/p&gt;</description>
    </item>
    <item>
      <title>JavaScript con Vim: Resaltando la sintaxis</title>
      <link>https://metrosetenta.es/blog/javascript-con-vim-resaltando-la-sintaxis/</link>
      <pubDate>Wed, 27 May 2020 14:54:01 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/javascript-con-vim-resaltando-la-sintaxis/</guid>
      <description>&lt;p&gt;Aunque Vim soporta sintaxis básica para JavaScript, cuando trabajes con especificaciones modernas del lenguaje o bibliotecas como React, que usa JSX, notarás que no funciona todo lo bien que esperas. Una buena opción para realatar la sintaxis de JavaScript en Vim es &lt;a href=&#34;https://github.com/sheerun/vim-polyglot&#34;&gt;Polyglot&lt;/a&gt;, un conectable que gestiona otros conectables, de sintaxis en este caso, cargándolos bajo demanda para evitar afectar al rendimiento de tu editor de texto. Gracias a Polyglot, si cambias de framework de JavaScript, o si gestionas archivos de otro lenguaje, no es necesario que instales nuevos conectables, porque él lo gestionará de un  modo sencillo.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Hugo y el buscador: Presentando el widget de búsqueda</title>
      <link>https://metrosetenta.es/blog/hugo-y-el-buscador-presentando-el-widget-de-busqueda/</link>
      <pubDate>Sat, 23 May 2020 19:42:04 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/hugo-y-el-buscador-presentando-el-widget-de-busqueda/</guid>
      <description>&lt;p&gt;Como ya te expliqué en &lt;a href=&#34;https://metrosetenta.es/blog/sobre-categorias-y-etiquetas/&#34;&gt;este&lt;/a&gt; artículo, al retomar este blog quería mejorar la navegación y, para ello, decidí implementar un buscador que permitiera localizar contenido de la manera más eficaz posible. El tema con el que está generado el blog, &lt;a href=&#34;https://github.com/Vimux/Mainroad/&#34;&gt;Mainroad&lt;/a&gt;, incluye la posibilidad de renderizar un buscador en la barra lateral con un sencillo ajuste en el archivo de configuración de Hugo, config.toml.&lt;/p&gt;&#xA;&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;&#34;&gt;&lt;code class=&#34;language-Toml&#34; data-lang=&#34;Toml&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;[&lt;span style=&#34;color:#a6e22e&#34;&gt;Params&lt;/span&gt;.&lt;span style=&#34;color:#a6e22e&#34;&gt;sidebar&lt;/span&gt;]&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;  &lt;span style=&#34;color:#75715e&#34;&gt;# Enable widgets in given order&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;  &lt;span style=&#34;color:#a6e22e&#34;&gt;widgets&lt;/span&gt; = [&lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;image&amp;#34;&lt;/span&gt;, &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;search&amp;#34;&lt;/span&gt;, &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;categories&amp;#34;&lt;/span&gt;]&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;La caja de búsqueda es sencilla, me gusta el estilo, pero cuando se visualiza el blog en una pantalla más pequeña la barra lateral que la contiene se muestra debajo de los primeros posts. &lt;strong&gt;Yo prefiero que el buscador esté siempre visible, desde el inicio, para que de este modo se pueda acceder al contenido rápidamente sin tener que navegar a la parte inferior del blog&lt;/strong&gt;, así que probé a sacar la caja de búsqueda de la barra lateral y colocarla debajo del título, justo antes del primer artículo. Gracias a que el widget de búsqueda esta escrito en su propio &lt;em&gt;partial&lt;/em&gt;, es sencillo probar la caja de búsqueda, en esa ubicación, añadiendo una única línea de código en la plantilla base del blog.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Hugo, generador de sitios estáticos</title>
      <link>https://metrosetenta.es/blog/hugo-generador-de-sitios-estaticos/</link>
      <pubDate>Sat, 23 May 2020 18:36:35 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/hugo-generador-de-sitios-estaticos/</guid>
      <description>&lt;p&gt;&lt;a href=&#34;https://gohugo.io/&#34;&gt;Hugo&lt;/a&gt; se presenta como el constructor de sitios web más rápido del mundo. Está escrito con &lt;a href=&#34;https://golang.org/&#34;&gt;Go&lt;/a&gt; y genera sitios de forma estática con la intención de ofrecer mejor rendimiento, seguridad y facilidad de uso. &lt;strong&gt;Por cada petición que recibe un sitio generado dinámicamente su servidor HTTP crea un nuevo archivo HTML&lt;/strong&gt;. Con el tiempo estos generadores de sitios dinámicos comenzaron a almacenar algunas páginas en caché para mejorar el rendimiento. En tanto que &lt;strong&gt;Hugo no genera las páginas dinámicamente, sino que renderiza todos los archivos HTML en tu computadora&lt;/strong&gt;, podemos definirlo como un generador de sitios estáticos. Es como si un generador de sitios dinámicos almacenara todas las páginas en caché. Este método te permite revisar todas las páginas en local tal cual serán enviadas al cliente y, además, el servidor HTTP las servirá usándo únicamente una fracción de cómputo y memoria de la que necesitaría un sitio generado dinámicamente.&lt;/p&gt;</description>
    </item>
    <item>
      <title>El misterioso netrwhist</title>
      <link>https://metrosetenta.es/blog/el-misterioso-netrwhist/</link>
      <pubDate>Sat, 23 May 2020 14:42:49 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/el-misterioso-netrwhist/</guid>
      <description>&lt;p&gt;Cuando gestionaba mis &lt;a href=&#34;https://dotfiles.github.io/&#34;&gt;dotfiles&lt;/a&gt; era habitual encontrarme, entre los archivos modificados, al misterioso &lt;em&gt;netrwhist&lt;/em&gt;. Antes que nada debes de saber que &lt;a href=&#34;https://www.vim.org/scripts/script.php?script_id=1075&#34;&gt;netrw&lt;/a&gt; es un script conectable a vim, que está  orientado a redes y que permite lectura, escritura y navegación. &lt;em&gt;netrwhist&lt;/em&gt; es el archivo donde netrw guarda un histórico de los directorios que fueron modificados. netrw tiene bastantes opciones de configuración:&lt;/p&gt;&#xA;&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;&#34;&gt;&lt;code class=&#34;language-Bash&#34; data-lang=&#34;Bash&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;let g:netrw_banner &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;0&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;let g:netrw_liststyle &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;3&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;let g:netrw_browse_split &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;4&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;let g:netrw_altv &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;1&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;let g:netrw_winsize &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;25&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;let g:netrw_dirhistmax  &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;10&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;let g:netrw_dirhist_cnt &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;6&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;Un modo de no versionar este histórico es usar el parámetro de configuración &lt;em&gt;netrw_home&lt;/em&gt; para guardar su histórico fuera del repositorio dotfiles.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Consultar con Git los archivos modificados</title>
      <link>https://metrosetenta.es/blog/consultar-con-git-los-archivos-modificados/</link>
      <pubDate>Wed, 20 May 2020 19:21:32 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/consultar-con-git-los-archivos-modificados/</guid>
      <description>&lt;p&gt;Hace poco un compañero me preguntó cómo podía &lt;strong&gt;consultar los archivos que había gestionado en un desarrollo, desde la versión que había partido, hasta la versión actual en la que se encontraba&lt;/strong&gt;. Consultando un poco dimos con esta opción,&lt;/p&gt;&#xA;&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;&#34;&gt;&lt;code class=&#34;language-Bash&#34; data-lang=&#34;Bash&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;$ git diff 0819dfcb 20620b5b --name-only&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;Y el resultado era exáctamente el que buscábamos, nombres de los archivos que habian sufrido algún tipo de modificación entre los dos commits que le estábamos pasando al comando &lt;em&gt;git diff&lt;/em&gt;.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Breve pensamiento sobre SEO</title>
      <link>https://metrosetenta.es/blog/breve-pensamiento-sobre-seo/</link>
      <pubDate>Sun, 17 May 2020 18:45:29 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/breve-pensamiento-sobre-seo/</guid>
      <description>&lt;p&gt;Cuando estas desarrollando software y te encuentras por primera vez con un problema que tienes que resolver, &lt;strong&gt;puedes dedicar unos 20 minutos a navegar por la red, buscando, probando y valorando la información necesaria para conseguir la solución correcta&lt;/strong&gt;. En ocasiones debes construir dicha solución con porciones y modificaciones de otras propuestas que no se adaptan correctamente al problema concreto que necesitas solucionar.&lt;/p&gt;&#xA;&lt;p&gt;Si después de hacer esto, dedicas un poco de tiempo a escribir sobre ello, &lt;strong&gt;puedes disponer de la información en caso de que te haga falta en el futuro y, además, ayudar a otras personas que podrían encontrarse con la misma dificultad que te encontraste tú&lt;/strong&gt;.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Sobre categorías y etiquetas</title>
      <link>https://metrosetenta.es/blog/sobre-categorias-y-etiquetas/</link>
      <pubDate>Sun, 17 May 2020 18:20:28 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/sobre-categorias-y-etiquetas/</guid>
      <description>&lt;p&gt;&lt;strong&gt;El modo en el que se suele recomendar el uso de las etiquetas en un blog, que es el que he venido adoptando hasta hace poco, está muy enfocado en obtener buenas clasificaciones en los resultados de buscadores&lt;/strong&gt;. Al retomar el blog este ha sido un aspecto al que quería darle un enfoque distinto, dejando de lado las recomendaciones para una estrategia &lt;a href=&#34;https://es.wikipedia.org/wiki/Posicionamiento_en_buscadores&#34;&gt;SEO&lt;/a&gt; convencional.&lt;/p&gt;&#xA;&lt;p&gt;Con el nuevo enfoque quería facilitar la navegación, a la par que mejorar la experiencia de usuario, y para conseguirlo me he visto obligado a involucrar también a las categorías de mi blog. El principal usuario de mi blog soy yo mismo, pues lo uso para anotar soluciones a problemas que he encontrado y detalles importantes sobre todo lo que aprendo referente a mi profesión, y esto me hace volver frecuentemente a él para realizar consultas.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Instala y gestiona múltiples versiones de Deno</title>
      <link>https://metrosetenta.es/blog/instala-y-gestiona-multiples-versiones-de-deno/</link>
      <pubDate>Sat, 16 May 2020 21:28:13 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/instala-y-gestiona-multiples-versiones-de-deno/</guid>
      <description>&lt;p&gt;¿Qué te parece si vemos en acción a &lt;a href=&#34;https://deno.land/&#34;&gt;Deno&lt;/a&gt;, el pequeño diplodocus del que hablamos en el &lt;a href=&#34;https://metrosetenta.es/blog/que-es-deno/&#34;&gt;artículo anterior&lt;/a&gt;? El primer paso, como no puede ser de otro modo, es instalarlo en tu equipo, y para esto  dispones de varias opciones que se adaptan a tu sistema operativo o a tus preferencias. Los usuarios de Linux pueden hacerlo facilmente desde la consola, al igual que los de macOS que, además, pueden usar &lt;a href=&#34;https://brew.sh/&#34;&gt;Homebrew&lt;/a&gt;. Para Windos existe la posibilidad de usar PoweShell, &lt;a href=&#34;https://chocolatey.org/&#34;&gt;Chocolatey&lt;/a&gt; o &lt;a href=&#34;https://scoop.sh/&#34;&gt;Scoop&lt;/a&gt;. En este post nos centraremos en Linux.&#xA;El comando de instalación es sencillo, y únicamente necesitas tener instalado &lt;a href=&#34;https://curl.haxx.se/&#34;&gt;curl&lt;/a&gt;:&lt;/p&gt;</description>
    </item>
    <item>
      <title>¿Qué es Deno?</title>
      <link>https://metrosetenta.es/blog/que-es-deno/</link>
      <pubDate>Wed, 13 May 2020 18:12:09 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/que-es-deno/</guid>
      <description>&lt;p&gt;&lt;a href=&#34;https://deno.land&#34;&gt;Deno&lt;/a&gt; se define a sí mismo como un &lt;strong&gt;seguro sistema o entorno de ejecución para JavaScript y Typescript&lt;/strong&gt;. El creador originar de &lt;a href=&#34;https://nodejs.org/en/&#34;&gt;Node.js&lt;/a&gt;, &lt;a href=&#34;https://tinyclouds.org/&#34;&gt;Ryan Dahl&lt;/a&gt;, fue quien anunción esta nueva herramienta en 2018, así que es inevitable fijarse en el juego del intercambio de sílabas (No-de / De-no), a pesar del divertido dino que usa como logo, que puede despistar. Pero ¿Por qué querría Dahl crear otra vez Node.js, un software que cuenta con un apoyo y una aceptación suficientes para hacerlo exitoso por décadas? Pues parece que alguna espinita se le quedó clavada, vamos a ver cual puede ser.&lt;/p&gt;</description>
    </item>
    <item>
      <title>1 desafio 4 aspectos</title>
      <link>https://metrosetenta.es/blog/1-desafio-4-aspectos/</link>
      <pubDate>Sun, 10 May 2020 19:39:56 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/1-desafio-4-aspectos/</guid>
      <description>&lt;p&gt;Al iniciar el proceso de diseño de una arquitectura software, la primera dificultad que debes acometer es &lt;strong&gt;definir con sencillez la necesidad que nuestro desarrollo va a solucionar y cómo va a hacerlo&lt;/strong&gt;. Este paso es realmente importante, y no imaginas la cantidad de ocasiones que se pasa por alto, lo cual provoca dificultades en fases posteriores del desarrollo e, incluso, el fracaso de algunos proyectos. &lt;strong&gt;El mejor modo de comenzar a hacerlo es dividir el desafío propuesto en cuatro aspectos fundamentales&lt;/strong&gt;:&lt;/p&gt;</description>
    </item>
    <item>
      <title>Definicion de arquitecura software</title>
      <link>https://metrosetenta.es/blog/definicion-de-arquitecura-software/</link>
      <pubDate>Sun, 10 May 2020 19:25:25 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/definicion-de-arquitecura-software/</guid>
      <description>&lt;p&gt;Lo normal es que tu expectativa de lo que vas a encontrar a continuación dependa de tu experiencia en el desarrollo de software. El concepto de arquitectura de software puede llegar a ser muy distinto dependiendo de la persona que lo use: &lt;strong&gt;Lo que comprende un desarrollador como arquitectura puede llegar a ser muy distinto de la idea de un probador o un técnico en devops&lt;/strong&gt;. Esto hace que publicar una definición básica del concepto de arquitectura de software sea ciertamente arriesgado pero, basándome en lo que me gustaría haber encontrado cuando empecé a estudiarla, y amparado en que existe algún punto común, pues para todos implica la definición de una estructura, me atrevo a darte la que sigue:&lt;/p&gt;</description>
    </item>
    <item>
      <title>No versiones archivos ajenos al proyecto</title>
      <link>https://metrosetenta.es/blog/no-versiones-archivos-ajenos-al-proyecto/</link>
      <pubDate>Thu, 19 Mar 2020 19:12:00 +0100</pubDate>
      <guid>https://metrosetenta.es/blog/no-versiones-archivos-ajenos-al-proyecto/</guid>
      <description>&lt;p&gt;El título de esta entrada suena realmente lógico y no merece profundizar más en él, pero ¿Cómo puedes hacerlo? El problema es que en ocasiones, en la carpeta del proyecto, guardas archivos de configuración que si bien no son propios del proyecto, sí que son necesarios, y resulta cómodo tenerlos en dicha ubicación. &lt;strong&gt;Desde mi punto de vista, las configuraciones de los distintos IDEs son el caso más común de esto que te comento&lt;/strong&gt;.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Modificando el mensaje de varios commits con un único comando</title>
      <link>https://metrosetenta.es/blog/modificando-el-mensaje-de-varios-commits-con-un-unico-comando/</link>
      <pubDate>Tue, 15 Oct 2019 08:39:00 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/modificando-el-mensaje-de-varios-commits-con-un-unico-comando/</guid>
      <description>&lt;p&gt;Sin duda, &lt;a href=&#34;https://git-scm.com/&#34;&gt;Git&lt;/a&gt; es una herramienta potentísima para el control de versiones, y conocer bien su funcionamiento nos facilita muchísimo el trabajo a la hora de escribir, probar y corregir código. Algunas de sus funcionalidades, las más avanzadas, son menos usadas y, por ello, tienden a conocerse menos.&#xA;&lt;strong&gt;Algo que me obliga a ir a la documentación de &lt;em&gt;Git&lt;/em&gt; de cuando en cuado es la necesidad de modificar el mensaje en varios &lt;em&gt;commits&lt;/em&gt;&lt;/strong&gt;. Recuerdo que la primera vez que lo necesité fue cuando, en un daily (reunión diaria típica de la metodología &lt;a href=&#34;https://es.wikipedia.org/wiki/Scrum_%28desarrollo_de_software%29&#34;&gt;Scrum&lt;/a&gt;) un compañero nos pidió al resto que los mensajes de todos los &lt;em&gt;commits&lt;/em&gt; comenzaran con el número de issue (es algo así como un número de ticket en &lt;a href=&#34;https://www.atlassian.com/software/jira&#34;&gt;Jira&lt;/a&gt;). &lt;strong&gt;En ese momento yo estaba terminando un &lt;em&gt;feature&lt;/em&gt; con más de 10 &lt;em&gt;commits&lt;/em&gt;, y pensé que hacerlo de uno en uno, usando &lt;em&gt;reword&lt;/em&gt; en un &lt;em&gt;rebase interactivo&lt;/em&gt;, sería muy tedioso&lt;/strong&gt;. Ahora, si estoy programando algo y aún no tengo ese número de &lt;em&gt;issue&lt;/em&gt;, uso un &lt;em&gt;placeholder&lt;/em&gt; para recordar que tengo que poner el número de &lt;em&gt;issue&lt;/em&gt; en el lugar que ocupa, y una vez que dispongo de dicho número, uso el siguiente comando de &lt;em&gt;Git&lt;/em&gt;, &lt;strong&gt;filter-branch&lt;/strong&gt;:&lt;/p&gt;</description>
    </item>
    <item>
      <title>Navegando por la parrilla de los espacios de trabajo</title>
      <link>https://metrosetenta.es/blog/navegando-por-la-parrilla-de-los-espacios-de-trabajo/</link>
      <pubDate>Mon, 14 Oct 2019 23:34:00 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/navegando-por-la-parrilla-de-los-espacios-de-trabajo/</guid>
      <description>&lt;p&gt;Algo que recuerdo tedioso de mi época de probar distintas distribuciones de &lt;em&gt;Linux&lt;/em&gt; es configurar los atajos de teclado. &lt;a href=&#34;https://i3wm.org/&#34;&gt;I3&lt;/a&gt; es la primera opción a valorar para quienes tocan el ratón lo mínimo e imprescindible, pero &lt;em&gt;Gnome&lt;/em&gt; ha avanzado bastante en este aspecto, y, como es el entorno de escritorio que uso actualmente, te voy a comentar como he configurado en él los espacios de trabajo.&lt;/p&gt;&#xA;&lt;p&gt;En mi distribución de &lt;em&gt;Linux&lt;/em&gt;, &lt;em&gt;Manjaro&lt;/em&gt;, pulsando la tecla &lt;em&gt;Super&lt;/em&gt; (habitualmente ilustrada con una ventana, y conocida como tecla &lt;em&gt;Win&lt;/em&gt; en &lt;em&gt;Windows&lt;/em&gt;) dispones de un buscador en el sistema operativo. Si comienzas a teclear el nombre de la aplicación &lt;strong&gt;Add/Remove Software&lt;/strong&gt;, la verás sugerida y seleccionable en un instante. En esta aplicación dispones de la posibilidad de buscar paquetes de software haciendo click en el icono de la lupa. Ahí, únicamente teclea &lt;strong&gt;Workspaces grid&lt;/strong&gt; y te aparecerán distintas opciones para construir una parrilla con tus escritorios. Yo personalmente estoy usando &lt;a href=&#34;https://github.com/mzur/gnome-shell-wsmatrix&#34;&gt;Gnome shell vsmatrix&lt;/a&gt;.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Manjaro y la conexión wifi</title>
      <link>https://metrosetenta.es/blog/manjaro-y-la-conexion-wifi/</link>
      <pubDate>Wed, 09 Oct 2019 17:23:00 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/manjaro-y-la-conexion-wifi/</guid>
      <description>&lt;p&gt;Pues no estaba equivocado respecto a la instalación de Manjaro, no. Ha sido mucho más rápido que montar Arch y, tras probarlo, tengo que decir que estoy bastante contento con las opciones de configuración y administración que ofrece. Únicamente he tenido una experiencia negativa hasta el momento de escribir esto, y es que al hacer un escaner de las redes wifi ¡No podía ver ninguna red wifi disponible! Así que tocó investigar un poco. La solución pasaba por desactivar los módulos &lt;strong&gt;rtw88&lt;/strong&gt; y &lt;strong&gt;rtwpci&lt;/strong&gt;, que fueron instalados junto al kernel, y que no funionaban correctamente con mi tarjeta &lt;strong&gt;rtl8822be&lt;/strong&gt;. Para ello los tenía que añadir a la blacklist del kernel, y atendiendo a la documentación de Arch, lo hice añadiendo estas líneas al archivo &lt;strong&gt;/etc/modprobe.d/blacklist.conf&lt;/strong&gt; que yo mismo tuve que crear:&lt;/p&gt;</description>
    </item>
    <item>
      <title>Comprobando una imagen de disco</title>
      <link>https://metrosetenta.es/blog/comprobando-una-imagen-de-disco/</link>
      <pubDate>Mon, 07 Oct 2019 11:29:00 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/comprobando-una-imagen-de-disco/</guid>
      <description>&lt;p&gt;Es habitual que las distribuciones Linux ofrezcan, entre sus opciones de descarga, una imagen de disco. Esta imagen de disco la podemos &amp;ldquo;quemar&amp;rdquo; en un CD/DVD, y también la podemos preparar como ejecutable en un pequeño USB portátil. No obstante, &lt;strong&gt;debemos tener en cuenta que si la imagen de disco se descargó incorrectamente, o fué contaminada, en el mejor de los casos no podremos instalar el sistema operativo elegido o, incluso, podríamos instalar un sistema operativo con errores.&lt;/strong&gt; Para evitar esto, solemos disponer de la posibilidad de comprobar la integridad del archivo con un hash.&lt;/p&gt;</description>
    </item>
    <item>
      <title>¿Por qué Manjaro?</title>
      <link>https://metrosetenta.es/blog/por-que-manjaro/</link>
      <pubDate>Wed, 02 Oct 2019 17:17:00 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/por-que-manjaro/</guid>
      <description>&lt;p&gt;Lo cierto es que cuando adquirí el nuevo portátil para trastear en casa con él, &lt;strong&gt;mi primera idea fué la de instalar Arch Linux con i3-gaps, pero finalmente me he decantado por instalar Manjaro&lt;/strong&gt; por los siguiente motivos. Con Arch, se aprende muchisimo sobre instalar, mantener y reparar el sistema operativo, pero lo cierto es que queria dedicar mi tiempo a otros aspectos, y con Arch me quedaba por delante instalar los paquetes básicos, configurar el sistema, zona horaria, configuración de red, localización, sistema de inicio&amp;hellip; Por otro lado, &lt;strong&gt;me gusta la filosofía rolling release, pero es cierto que en ocasiones puede crear inestabilidad en el sistema al actualizar un paquete&lt;/strong&gt;.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Portátil para estudios y proyectos</title>
      <link>https://metrosetenta.es/blog/portatil-para-estudios-y-proyectos/</link>
      <pubDate>Wed, 02 Oct 2019 16:46:00 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/portatil-para-estudios-y-proyectos/</guid>
      <description>&lt;p&gt;En mi actual trabajo no puedo usar un sistema operativo distinto de Microsoft Windows 10 enterprise, y el portátil que tengo en casa, por ser compartido, no lo puedo trastear todo lo que quisiera. Por este motivo, y por lo que añoro Linux, he adquirido un nuevo portátil, sin sistema operativo instalado, para mis estudios y proyectos. Estas son algunas especificaciones.&lt;/p&gt;&#xA;&lt;p&gt;&lt;strong&gt;Marca y modelo&lt;/strong&gt;&#xA;Asus Vivobook X510qa-br010&#xA;15.6/amd A12-9720p/8gb/ssd256gb/sin So&lt;/p&gt;</description>
    </item>
    <item>
      <title>Inyección de funciones</title>
      <link>https://metrosetenta.es/blog/inyeccion-de-funciones/</link>
      <pubDate>Tue, 04 Jun 2019 09:43:00 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/inyeccion-de-funciones/</guid>
      <description>&lt;p&gt;Ya te comenté en &lt;a href=&#34;https://metrosetenta.es/2018/12/caracteristicas-funcionales-de.html&#34;&gt;este pequeñísimo artículo&lt;/a&gt; que las funciones tratadas como objetos de primera clase es una de las características que permiten programar con Javascript de un modo funcional. Esto nos permite, por ejemplo, &lt;strong&gt;pasar funciones como argumentos de otras funciones, y ahí es donde se produce la inyección de funciones&lt;/strong&gt; que da título a este artículo.&lt;/p&gt;&#xA;&lt;p&gt;La función &lt;em&gt;sort&lt;/em&gt; nos permite mostrar un ejemplo de este concepto. A continuación la función &lt;em&gt;sort&lt;/em&gt; en acción:&lt;/p&gt;</description>
    </item>
    <item>
      <title>Currying</title>
      <link>https://metrosetenta.es/blog/currying/</link>
      <pubDate>Wed, 15 May 2019 20:39:00 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/currying/</guid>
      <description>&lt;p&gt;Pues no, no se trata de un deporte de disco sobre hielo usando escobas, y tampoco es una práctica consistente en sazonar todas las comidas con la misma especia. &lt;strong&gt;En el cálculo lambda se usan funciones con un único parámetro. En posts venideros sobre conexión de funciones conoceremos el motivo, pero ahora centrémonos en aprender como superar esta limitación gracias al currying&lt;/strong&gt;.&lt;/p&gt;&#xA;&lt;p&gt;El amigo Haskell Curry, además del lenguaje Haskell desarrolló este concepto. ¿Cómo podríamos emular una función que suma tres número recibidos como parámetros, igual a la del ejemplo que sigue, usándo exclusivamente funciones con un único parámetro?&lt;/p&gt;</description>
    </item>
    <item>
      <title>Función lambda</title>
      <link>https://metrosetenta.es/blog/funcion-lambda/</link>
      <pubDate>Tue, 14 May 2019 09:56:00 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/funcion-lambda/</guid>
      <description>&lt;p&gt;Buscando un poco en la red, seguro que encuentras algún lugar donde se otorge al cálculo lambda el título de lenguaje de programación mas pequeño que existe. Básicamente se trata de un esquema para definir funciones y una regla de transformación simple mediante la sustitución de variables.&lt;/p&gt;&#xA;&lt;p&gt;&lt;strong&gt;Una función tiene un aspecto tal que así en cálculo lambda: &lt;em&gt;λx.1+x&lt;/em&gt;&lt;/strong&gt;. La variable entre el carácter &lt;em&gt;λ&lt;/em&gt; y el punto es el parámetro de la función, y la expresión de esta es lo que sigue a dicho punto. Para aplicar esta función le facilitamos un argumento, por ejemplo 14, y lo podemos representar con el uso de paréntesis: &lt;em&gt;(λx.1+x)(14)&lt;/em&gt;. El resultado en este caso sería 15.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Polyfills</title>
      <link>https://metrosetenta.es/blog/polyfills/</link>
      <pubDate>Tue, 05 Feb 2019 06:22:00 +0100</pubDate>
      <guid>https://metrosetenta.es/blog/polyfills/</guid>
      <description>&lt;p&gt;&lt;strong&gt;Un polyfill es un script de código que sirve para emular una característica que un desarrollador necesita en un navegador cuando este no dispone de ella de forma nativa&lt;/strong&gt;. En su mayoría, los polyfills están escritos en javascript, y nos permiten desarrollar apliaciones web centrados en nuevos estándares, pues suplen la carencia de los navegadores más antiguos en el momento de implementarlos.&lt;/p&gt;&#xA;&lt;p&gt;El uso de polyfills invita a usar una detección de características del navegador, en lugar de comprobar su versión,  puesto que con su uso &lt;strong&gt;únicamente habría que comprobar si el navegador, sea cual sea, y sea cual sea su versión, dispone de la cualidad que necesitamos en nuestro desarrollo, y de no ser así, usaríamos un polyfill que la emulara&lt;/strong&gt;.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Hoisting de Javascript</title>
      <link>https://metrosetenta.es/blog/hoisting-de-javascript/</link>
      <pubDate>Sat, 05 Jan 2019 13:05:00 +0100</pubDate>
      <guid>https://metrosetenta.es/blog/hoisting-de-javascript/</guid>
      <description>&lt;p&gt;Explicado de un modo muy breve, consiste en que javascript, en el momento de compilar el código, prioriza las declaraciones de variables, siendo lo primero a tratar dentro de cada contexto. Es importante tener en cuenta que esto no aplica para las asignaciones, únicamente para la declaración. Estudia el siguiente script:&lt;/p&gt;&#xA;&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;&#34;&gt;&lt;code class=&#34;language-JavaScript&#34; data-lang=&#34;JavaScript&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#75715e&#34;&gt;/*&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#75715e&#34;&gt; * Logamos &amp;#39;undefined&amp;#39; por que la declaración de x ha sido alzada&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#75715e&#34;&gt; * por encima de esta función, pero no su asignación. Observa,&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#75715e&#34;&gt; * no obstante, que no recibimos un error de referencia a x a pesar&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#75715e&#34;&gt; * de que la línea dónde se declara y asigna está justo debajo.&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#75715e&#34;&gt; */&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#a6e22e&#34;&gt;console&lt;/span&gt;.&lt;span style=&#34;color:#a6e22e&#34;&gt;log&lt;/span&gt;(&lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;x:&amp;#34;&lt;/span&gt;, &lt;span style=&#34;color:#a6e22e&#34;&gt;x&lt;/span&gt;)&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;var&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;x&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;Primera asignación&amp;#34;&lt;/span&gt;;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#75715e&#34;&gt;//Ahora sí logamos &amp;#39;Primera asignación&amp;#39;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#75715e&#34;&gt;&lt;/span&gt;&lt;span style=&#34;color:#a6e22e&#34;&gt;console&lt;/span&gt;.&lt;span style=&#34;color:#a6e22e&#34;&gt;log&lt;/span&gt;(&lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;x:&amp;#34;&lt;/span&gt;, &lt;span style=&#34;color:#a6e22e&#34;&gt;x&lt;/span&gt;)&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;(&lt;span style=&#34;color:#66d9ef&#34;&gt;function&lt;/span&gt; () {&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt; &lt;span style=&#34;color:#75715e&#34;&gt;/* No logamos &amp;#39;Primera asignación&amp;#39; sino &amp;#39;undefined&amp;#39;, porque la&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#75715e&#34;&gt;  * segunda declaración ha sido elevada al inicio de su contexto,&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#75715e&#34;&gt;  * sobrescribiendo a la primera declaración y asignación.&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#75715e&#34;&gt;  */&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;  &lt;span style=&#34;color:#a6e22e&#34;&gt;console&lt;/span&gt;.&lt;span style=&#34;color:#a6e22e&#34;&gt;log&lt;/span&gt;(&lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;x:&amp;#34;&lt;/span&gt;, &lt;span style=&#34;color:#a6e22e&#34;&gt;x&lt;/span&gt;);&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;  &lt;span style=&#34;color:#66d9ef&#34;&gt;var&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;x&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;Segunda asignación&amp;#34;&lt;/span&gt;;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;  &lt;span style=&#34;color:#75715e&#34;&gt;// Ahora sí, logamos &amp;#39;Segunda asignación&amp;#39;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#75715e&#34;&gt;&lt;/span&gt;  &lt;span style=&#34;color:#a6e22e&#34;&gt;console&lt;/span&gt;.&lt;span style=&#34;color:#a6e22e&#34;&gt;log&lt;/span&gt;(&lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;x:&amp;#34;&lt;/span&gt;, &lt;span style=&#34;color:#a6e22e&#34;&gt;x&lt;/span&gt;);&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;}());&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;</description>
    </item>
    <item>
      <title>Peculiaridades en los lenguajes de programación</title>
      <link>https://metrosetenta.es/blog/peculiaridades-en-los-lenguajes-de-programacion/</link>
      <pubDate>Sat, 05 Jan 2019 12:19:00 +0100</pubDate>
      <guid>https://metrosetenta.es/blog/peculiaridades-en-los-lenguajes-de-programacion/</guid>
      <description>&lt;p&gt;Con este post quiero inaugurar una sección donde tratar las peculiaridades de los distintos lenguajes de programación. Me refiero con la palabra peculiaridades a aquellos detalles que, en ocasiones, no se tienen presente cuando se está desarrollando, especialmente cuando se manejan distintos lenguajes en poco espacio de tiempo o cuando se comienza a desarrollar con un nuevo lenguaje que no se conoce en profundidad. Esto puede llevar a comportamientos extraños, o que no alcanzamos a comprender, en nuestra aplicación, y por tanto muy difíciles de resolver. Para comenzar, he elegido el &lt;a href=&#34;https://www.metrosetenta.es/blog/hoisting-de-javascript&#34;&gt;hoisting de javascript&lt;/a&gt;.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Características funcionales de Javascript</title>
      <link>https://metrosetenta.es/blog/caracteristicas-funcionales-de-javascript/</link>
      <pubDate>Sun, 23 Dec 2018 20:02:00 +0100</pubDate>
      <guid>https://metrosetenta.es/blog/caracteristicas-funcionales-de-javascript/</guid>
      <description>&lt;p&gt;Javascript no fué creado como un lenguaje de programación funcional, pero dispone de ciertas características que nos permiten programar en un estilo funcional al usarlo. Te las listo con la intención de escribir un post sobre cada una de ellas y enlazarlo aquí abajo:&lt;/p&gt;&#xA;&lt;ul&gt;&#xA;&lt;li&gt;Las funciones son objetos de primera clase&lt;/li&gt;&#xA;&lt;li&gt;Recursión&lt;/li&gt;&#xA;&lt;li&gt;Funciones flecha (Arrow functions)&lt;/li&gt;&#xA;&lt;li&gt;Clausuras (Closures)&lt;/li&gt;&#xA;&lt;li&gt;El operador spread&lt;/li&gt;&#xA;&lt;/ul&gt;</description>
    </item>
    <item>
      <title>Entiende esto antes de estudiar programación funcional</title>
      <link>https://metrosetenta.es/blog/entiende-esto-antes-de-estudiar-programacion-funcional/</link>
      <pubDate>Sun, 23 Dec 2018 19:52:00 +0100</pubDate>
      <guid>https://metrosetenta.es/blog/entiende-esto-antes-de-estudiar-programacion-funcional/</guid>
      <description>&lt;p&gt;La programación funcional es un modo distinto de escribir sofware que puede resultar difícil de aprender. La mayoría del software producido actualmente es una secuencia de órdenes ejecutadas de un modo determinado y, cuyo resultado, se obtiene creando y manipulando objetos. &lt;strong&gt;En la programación funcional (FP) el resultado se obtiene evaluando expresiones que están compuestas de funciones&lt;/strong&gt;.&#xA; Es habitual pasar funciones como parámetros de otras funciones, o devolverlas como resultados; Se opta por la recursión en lugar de hacer bucles, y en el cuerpo de las funciones se evita modificar objetos o el uso de variables globales, de tal manera que el uso de estas no conlleve efectos secundarios, habitualmente referidos en la literatura técnica como &lt;em&gt;side effects&lt;/em&gt;.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Tabulación coloreada en Visual Studio Code</title>
      <link>https://metrosetenta.es/blog/tabulaci%C3%B3n-coloreada-en-visual-studio-code/</link>
      <pubDate>Mon, 17 Dec 2018 16:34:00 +0100</pubDate>
      <guid>https://metrosetenta.es/blog/tabulaci%C3%B3n-coloreada-en-visual-studio-code/</guid>
      <description>&lt;p&gt;&lt;a href=&#34;https://marketplace.visualstudio.com/items?itemName=oderwat.indent-rainbow&#34;&gt;Indent Rainbow&lt;/a&gt; es una extensión de Visual Studio Code, de uso general, que sirve para darle color a las tabulaciones. Es muy útil para mejorar la legibilidad del código, especialmente para conocer en que ámbito te estás moviendo o donde comienzan y finalizan ciertos elementos del código.&lt;/p&gt;&#xA;&lt;p&gt;&lt;a href=&#34;https://4.bp.blogspot.com/-whaC3TW6aGU/XBfB4y8y0UI/AAAAAAAAZT0/nMJ7cag_CuwLoShOVZekaZuwiCMwL1-vwCLcBGAs/s1600/Capture.PNG&#34;&gt;&lt;img src=&#34;https://4.bp.blogspot.com/-whaC3TW6aGU/XBfB4y8y0UI/AAAAAAAAZT0/nMJ7cag_CuwLoShOVZekaZuwiCMwL1-vwCLcBGAs/s1600/Capture.PNG&#34; alt=&#34;&#34;&gt;&lt;/a&gt;&lt;/p&gt;&#xA;&lt;p&gt;A continuación puedes ver el ajuste por defecto de la extensión, pero, como casi todo en Visual Studio Code, es algo configurable a tu gusto.&lt;/p&gt;</description>
    </item>
    <item>
      <title>¿Dónde diablos cerraba este paréntesis?</title>
      <link>https://metrosetenta.es/blog/donde-diablos-cerraba-este-parentesis/</link>
      <pubDate>Sun, 09 Dec 2018 19:17:00 +0100</pubDate>
      <guid>https://metrosetenta.es/blog/donde-diablos-cerraba-este-parentesis/</guid>
      <description>&lt;p&gt;Si escribes javascript seguro que en tu código hay una gran cantidad de paréntesis, llaves y corchetes. Con &lt;a href=&#34;https://marketplace.visualstudio.com/items?itemName=CoenraadS.bracket-pair-colorizer-2&#34;&gt;Bracket Pair Colorizer 2&lt;/a&gt;, una genial extensión de Visual Studio Code, dispondrás de la posibilidad de identificarlos rápidamente mediante colores, y tiene un buen número de elementos configurables, como una línea vertical que delimita el ámbito de estos elementos. Es una extensión muy recomendable, así que, ya estás tardando en probarla.&lt;/p&gt;&#xA;&lt;p&gt;&lt;img src=&#34;https://github.com/CoenraadS/Bracket-Pair-Colorizer-2/raw/master/images/example.png&#34; alt=&#34;Screenshot&#34; title=&#34;Bracket Pair Colorizer&#34;&gt; &lt;/p&gt;</description>
    </item>
    <item>
      <title>El verdadero valor de un desarrollador</title>
      <link>https://metrosetenta.es/blog/el-verdadero-valor-de-un-desarrollador/</link>
      <pubDate>Tue, 18 Sep 2018 17:59:00 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/el-verdadero-valor-de-un-desarrollador/</guid>
      <description>&lt;p&gt;If you think you are worth what you know, you are very wrong. Your knowledge today does not have much value beyond a couple of years. Your value is what you can learn and how can you easily adapt to the changes this profession brings so often.&lt;/p&gt;&#xA;&lt;p&gt;&lt;em&gt;Si crees que vales lo que sabes, estás muy equivocado. Tu conocimiento no tiene mucho valor más allá de un par de años. Tu valor es lo que puedes aprender y cómo puedes adaptarte fácilmente a los cambios que esta profesión trae con tanta frecuencia.&lt;/em&gt;&lt;/p&gt;</description>
    </item>
    <item>
      <title>Comparación directa de errores en Go</title>
      <link>https://metrosetenta.es/blog/comparacion-directa-de-errores-en-go/</link>
      <pubDate>Tue, 12 Jun 2018 16:19:00 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/comparacion-directa-de-errores-en-go/</guid>
      <description>&lt;p&gt;Es un fallo habitual, en el manejo de errores dentro de Go, realizar comparasiones de strings contra el mensaje del error que quieres reconocer, pero lo cierto es que, &lt;strong&gt;el modo más acertado de discernir que error estas manejando, es hacer una comparación de tipos de error dentro de una sentencia case&lt;/strong&gt;.&lt;/p&gt;&#xA;&lt;p&gt;¿Quiero decir entonces que puedo gestionar distintos tipos de error? Claro que sí. Fíjate que, &lt;strong&gt;en Go, todo lo que inplemente la interface &lt;em&gt;error&lt;/em&gt; es un error&lt;/strong&gt;. Además, puedes comprobar por tí mismo que es una interface muy sencilla:&lt;/p&gt;</description>
    </item>
    <item>
      <title>Comprobación de tipo de error en Go</title>
      <link>https://metrosetenta.es/blog/comprobacion-de-tipo-de-error-en-go/</link>
      <pubDate>Tue, 12 Jun 2018 16:19:00 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/comprobacion-de-tipo-de-error-en-go/</guid>
      <description>&lt;p&gt;Es un fallo habitual, en el manejo de errores dentro de Go, realizar comparasiones de strings contra el mensaje del error que quieres reconocer, pero lo cierto es que, &lt;strong&gt;el modo más acertado de discernir que error estas manejando, es hacer una comparación de tipos de error dentro de una sentencia case&lt;/strong&gt;.&lt;/p&gt;&#xA;&lt;p&gt;¿Quiero decir entonces que puedo gestionar distintos tipos de error? Claro que sí. Fíjate que, &lt;strong&gt;en Go, todo lo que inplemente la interface &lt;em&gt;error&lt;/em&gt; es un error&lt;/strong&gt;. Además, puedes comprobar por tí mismo que es una interface muy sencilla:&lt;/p&gt;</description>
    </item>
    <item>
      <title>Canales en Go</title>
      <link>https://metrosetenta.es/blog/canales-en-go/</link>
      <pubDate>Mon, 16 Apr 2018 16:45:00 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/canales-en-go/</guid>
      <description>&lt;p&gt;&lt;strong&gt;Los canales son la característica que Go nos facilita para comunicar entre sí goroutines y poder sincronizar su ejecución.&lt;/strong&gt;&lt;/p&gt;&#xA;&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;&#34;&gt;&lt;code class=&#34;language-Go&#34; data-lang=&#34;Go&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;var&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;c&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;chan&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;string&lt;/span&gt; = make(&lt;span style=&#34;color:#66d9ef&#34;&gt;chan&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;string&lt;/span&gt;)&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;&lt;strong&gt;El tipo canal se representa con la palabra chan y, a continuación, el tipo de los datos que viajaran a través de dicho canal&lt;/strong&gt;. En el ejemplo de arriba he declarado la variable c, que contendrá un canal para transferir datos de tipo string. En la misma línea de código he usado make para crear dicho canal que, como puedes observar, se asigna a la variable c.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Go testing</title>
      <link>https://metrosetenta.es/blog/go-testing/</link>
      <pubDate>Fri, 13 Apr 2018 13:56:00 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/go-testing/</guid>
      <description>&lt;p&gt;Go incluye un programa llamado &lt;em&gt;go test&lt;/em&gt; que te será de gran utilidad para poner a prueba funciones de tu código. &lt;strong&gt;Esto es realmente útil para asegurarte de que todo funciona como debería hacerlo después de añadir características o de realizar cambios importantes en tu desarrollo&lt;/strong&gt;. Para poder fabricar un ejemplo con el uso de &lt;em&gt;go test&lt;/em&gt;, supongamos que has escrito un archivo llamado &lt;em&gt;math.go&lt;/em&gt;, y que dicho archivo contiene una función que sirve para calcular el promedio de un conjunto de números:&lt;/p&gt;</description>
    </item>
    <item>
      <title>State en React</title>
      <link>https://metrosetenta.es/blog/state-en-react/</link>
      <pubDate>Wed, 04 Apr 2018 10:26:00 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/state-en-react/</guid>
      <description>&lt;p&gt;Ya has visto como configurar componentes con &lt;a href=&#34;https://www.metrosetenta.es/blog/props-en-react.html&#34;&gt;props en React,&lt;/a&gt; pero ¿cómo puedes definir comportamientos o interacciones con dichos componentes? Para ello necesitas que los componentes puedan definir su estado, y con las props es imposible, pues no pueden ser modificadas por el componente, sólo por su componente padre. Para esto existe &lt;strong&gt;this.state&lt;/strong&gt;, donde los componentes pueden disponer de datos privados modificables a traves de la función &lt;strong&gt;this.setState()&lt;/strong&gt;.&lt;/p&gt;&#xA;&lt;p&gt;Ya sabes que función usar para ajustar this.state, pero ¿Cómo podrías definir un estado inicial del componente? Bien, pues para eso disponemos del &lt;strong&gt;constructor de clase&lt;/strong&gt;. En la función render comprobamos el estado del componente para decidir como va a ser mostrado, y ahora viene la magia: &lt;strong&gt;cuando modificamos el estado de un componente, automáticamente se volverán a renderizar todos sus componentes hijos y el propio componente&lt;/strong&gt;. Esto, además, es bastante ágil gracias al DOM virtual de React.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Props en React</title>
      <link>https://metrosetenta.es/blog/props-en-react/</link>
      <pubDate>Tue, 03 Apr 2018 22:22:00 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/props-en-react/</guid>
      <description>&lt;p&gt;React es una biblioteca de JavaScript que se basa en la fabricación y combinación de componentes para construir interfaces de usuario. Cada componente se define por separado en un archivo javascript, y tiene un aspecto similar a este que sigue, el cual se encontraría en el archivo listaCompra.js:&lt;/p&gt;&#xA;&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;&#34;&gt;&lt;code class=&#34;language-React&#34; data-lang=&#34;React&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;import&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;React&lt;/span&gt;, { &lt;span style=&#34;color:#a6e22e&#34;&gt;Component&lt;/span&gt; } &lt;span style=&#34;color:#a6e22e&#34;&gt;from&lt;/span&gt; &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#39;react&amp;#39;&lt;/span&gt;;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;import&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;Articulo&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;from&lt;/span&gt; &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#39;./Articulo&amp;#39;&lt;/span&gt;;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;class&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;ListaCompra&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;extends&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;Component&lt;/span&gt; {&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;  &lt;span style=&#34;color:#a6e22e&#34;&gt;render&lt;/span&gt;() {&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#66d9ef&#34;&gt;return&lt;/span&gt; (&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;      &amp;lt;&lt;span style=&#34;color:#f92672&#34;&gt;ul&lt;/span&gt;&amp;gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        &amp;lt;&lt;span style=&#34;color:#f92672&#34;&gt;Articulo&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;cantidad&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt;&lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;1&amp;#34;&lt;/span&gt;&amp;gt;&lt;span style=&#34;color:#a6e22e&#34;&gt;Pan&lt;/span&gt;&amp;lt;/&lt;span style=&#34;color:#f92672&#34;&gt;Articulo&lt;/span&gt;&amp;gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        &amp;lt;&lt;span style=&#34;color:#f92672&#34;&gt;Articulo&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;cantidad&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt;&lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;6&amp;#34;&lt;/span&gt;&amp;gt;&lt;span style=&#34;color:#a6e22e&#34;&gt;Leche&lt;/span&gt;&amp;lt;/&lt;span style=&#34;color:#f92672&#34;&gt;Articulo&lt;/span&gt;&amp;gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        &amp;lt;&lt;span style=&#34;color:#f92672&#34;&gt;Articulo&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;cantidad&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt;&lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;2&amp;#34;&lt;/span&gt;&amp;gt;&lt;span style=&#34;color:#a6e22e&#34;&gt;Huevos&lt;/span&gt;&amp;lt;/&lt;span style=&#34;color:#f92672&#34;&gt;Articulo&lt;/span&gt;&amp;gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;      &amp;lt;/&lt;span style=&#34;color:#f92672&#34;&gt;ul&lt;/span&gt;&amp;gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    );&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;  }&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;}&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;&lt;strong&gt;Las propiedades, que veremos en el código escritas como props, se usan para configurar componentes, y son pasadas desde los componentes padres a los componentes hijos&lt;/strong&gt;. Es importante recordar que el componente hijo no puede modificarlas, el propietario es el componente padre.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Buscador de texto en Vim</title>
      <link>https://metrosetenta.es/blog/buscador-de-texto-en-vim/</link>
      <pubDate>Thu, 02 Nov 2017 12:47:00 +0100</pubDate>
      <guid>https://metrosetenta.es/blog/buscador-de-texto-en-vim/</guid>
      <description>&lt;p&gt;Otro recurso importante que vas a necesitar en &lt;a href=&#34;https://www.vim.org/&#34;&gt;Vim&lt;/a&gt; es un buscador de textos. Ante el hecho de que el proyecto que permitía el uso de &lt;em&gt;&lt;a href=&#34;https://github.com/ggreer/the_silver_searcher&#34;&gt;El surfero de plata&lt;/a&gt;&lt;/em&gt; en vim, &lt;em&gt;&lt;a href=&#34;https://github.com/rking/ag.vim&#34;&gt;ag.vim&lt;/a&gt;&lt;/em&gt;, ha quedado obsoleto, te podrías decantar por &lt;em&gt;&lt;a href=&#34;https://github.com/mileszs/ack.vim&#34;&gt;ack.vim&lt;/a&gt;&lt;/em&gt;. Con ack.vim puedes hacer uso de &lt;em&gt;&lt;a href=&#34;https://beyondgrep.com/&#34;&gt;ack&lt;/a&gt;&lt;/em&gt;, que no es ni más ni menos que un &lt;em&gt;&lt;a href=&#34;https://es.wikipedia.org/wiki/Grep&#34;&gt;grep&lt;/a&gt;&lt;/em&gt; optimizado para programadores.&lt;/p&gt;&#xA;&lt;p&gt;Instalar &lt;em&gt;ack&lt;/em&gt; es bastante sencillo en distribuciones &lt;em&gt;Linux&lt;/em&gt; deribadas de &lt;em&gt;Debian&lt;/em&gt;.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Búsqueda de archivos en vim</title>
      <link>https://metrosetenta.es/blog/busqueda-de-archivos-en-vim/</link>
      <pubDate>Thu, 26 Oct 2017 17:37:00 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/busqueda-de-archivos-en-vim/</guid>
      <description>&lt;p&gt;&lt;a href=&#34;http://github.com/junegunn/fzf&#34;&gt;fzf&lt;/a&gt; se define a sí mismo como un &lt;a href=&#34;https://metrosetenta.es/blog/busqueda-difusa/&#34;&gt;buscador difuso&lt;/a&gt; de línea de comandos para propósitos generales. Más detalladamente, &lt;strong&gt;se trata de un filtro para líneas de comandos Unix, que puedes aplicar a listas, archivos, procesos, históricos de comandos, etcétera&lt;/strong&gt;.&lt;/p&gt;&#xA;&lt;p&gt;Lo puedes instalar en tu carpeta &lt;em&gt;home&lt;/em&gt; clonando su repositorio en GitHub de la siguiente manera:&lt;/p&gt;&#xA;&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;&#34;&gt;&lt;code class=&#34;language-Bash&#34; data-lang=&#34;Bash&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;$ git clone --depth &lt;span style=&#34;color:#ae81ff&#34;&gt;1&lt;/span&gt; https://github.com/junegunn/fzf.git ~/.fzf&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;Luego sólo tienes que ejecutar el script de instalación:&lt;/p&gt;</description>
    </item>
    <item>
      <title>Cómo instalar vim-plug para Vim</title>
      <link>https://metrosetenta.es/blog/como-instalar-vim-plug-para-vim/</link>
      <pubDate>Mon, 23 Oct 2017 17:11:00 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/como-instalar-vim-plug-para-vim/</guid>
      <description>&lt;p&gt;&lt;strong&gt;&lt;em&gt;&lt;a href=&#34;https://github.com/junegunn/vim-plug&#34;&gt;vim-plug&lt;/a&gt;&lt;/em&gt; es un gestor de paquetes para &lt;em&gt;&lt;a href=&#34;https://www.vim.org/&#34;&gt;Vim&lt;/a&gt;&lt;/em&gt;&lt;/strong&gt; con características muy interesantes. Lo tienes disponible &lt;em&gt;&lt;a href=&#34;https://github.com/junegunn/vim-plug&#34;&gt;aquí&lt;/a&gt;&lt;/em&gt;, donde puedes encontrar toda la información necesaria para usarlo. Su instalación en sistemas Unix se puede realizar con un sencilo comando:&lt;/p&gt;&#xA;&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;&#34;&gt;&lt;code class=&#34;language-Bash&#34; data-lang=&#34;Bash&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;$ curl -fLo ~/.local/share/nvim/site/autoload/plug.vim --create-dirs &lt;span style=&#34;color:#ae81ff&#34;&gt;\\&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;Una vez instalado sólo tienes que ajustarlo en el archivo de configuración de Vim. Aqui abajo tienes un ejemplo con alguna información:&lt;/p&gt;&#xA;&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;&#34;&gt;&lt;code class=&#34;language-Bash&#34; data-lang=&#34;Bash&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34; Inicia la configuración usando el comando call plug#begin(),&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;&lt;/span&gt; con el cual puedes especificar el directorio donde se colocarán&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34; los conectables que queremos usar en nuestro editor.&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;&lt;/span&gt; En el caso concreto de Vim puedes usarlo así.&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;call plug#begin&lt;span style=&#34;color:#f92672&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#39;~/.vim/plugged&amp;#39;&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;)&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34; A continuación se solicitarán los conectables necesarios. Hay muchos&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;&lt;/span&gt; modos de hacerlo, por ejemplo, usando una dirección URL de Github.&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;Plug &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#39;https://github.com/junegunn/vim-github-dashboard.git&amp;#39;&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34; Finalmente cierra el archivo de configuración con el&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;&lt;/span&gt; comando call plug#end&lt;span style=&#34;color:#f92672&#34;&gt;()&lt;/span&gt;.&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;call plug#end&lt;span style=&#34;color:#f92672&#34;&gt;()&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;Para probarlo abre Vim y ejecuta el comando PlugInstall. Verás un panel lateral donde se iniciará la instalación de los conectables indicados en el archivo de configuración de Vim.&lt;/p&gt;</description>
    </item>
    <item>
      <title>El workspace de Go</title>
      <link>https://metrosetenta.es/blog/el-workspace-de-go/</link>
      <pubDate>Tue, 12 Sep 2017 12:48:00 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/el-workspace-de-go/</guid>
      <description>&lt;p&gt;Estoy convencido de que tienes un estilo personal para organizar tu código, pero cuando trabajas con Go, es conveniente que te adaptes al estilo de su wokspace. &lt;strong&gt;El workspace de Go es una carpeta que se compone, a su vez, de otras tres carpetas: &lt;em&gt;bin&lt;/em&gt;, &lt;em&gt;pkg&lt;/em&gt; y &lt;em&gt;src&lt;/em&gt;&lt;/strong&gt;. Mi workspace, o espacio de trabajo, para los proyectos escritos en Go es &lt;em&gt;~/Documents/projects/go&lt;/em&gt;, por tanto, ahí creé la carpeta &lt;em&gt;src&lt;/em&gt;, en la cual guardo los distintos trabajos escritos en este lenguaje.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Cuentos de bichos: Estrategia de gestión de errores</title>
      <link>https://metrosetenta.es/blog/cuentos-de-bichos-estrategia-de-gestion-de-errores/</link>
      <pubDate>Tue, 22 Nov 2016 15:59:00 +0100</pubDate>
      <guid>https://metrosetenta.es/blog/cuentos-de-bichos-estrategia-de-gestion-de-errores/</guid>
      <description>&lt;p&gt;En entradas anteriores te comenté el origen de los errores de software y realicé una pequeña y divertida clasificación. Hoy sigo con la temática bichos para recomendarte una aproximación interesante al modo de gestionar aquellos errores que, en ocasiones, puedan aparecer en tu código. Hay cuatro preguntas fundamentales que deberías hacerte a ti mismo para definir tu estrategia en lo referente a la gestión de cada casuística de error en tu desarrollo:&lt;/p&gt;</description>
    </item>
    <item>
      <title>Cuentos de bichos: Bestiario</title>
      <link>https://metrosetenta.es/blog/cuentos-de-bichos-bestiario/</link>
      <pubDate>Wed, 20 Jul 2016 15:42:00 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/cuentos-de-bichos-bestiario/</guid>
      <description>&lt;h3 id=&#34;heisenbug&#34;&gt;Heisenbug&lt;/h3&gt;&#xA;&lt;h4 id=&#34;fisonomía&#34;&gt;Fisonomía&lt;/h4&gt;&#xA;&lt;p&gt; Toma su nombre del físico especializado en mecánica cuántica Werner Heisenberg, quien dedujo que el mero hecho de observar un sistema de una manera determinada altera el estado de éste. Cuando se usan herramientas durante el proceso de depuración para localizar y eliminar bichos, se producen pequeñas diferencias respecto al entorno de producción, es decir, con respecto al entorno final en el cual deberá funcionar nuestro dispositivo de software. El Heisenbug es especialista en aprovechar cualquiera de estas leves diferencias para mostrar comportamientos distintos que confundan al programador o para simplemente desaparecer.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Cuentos de bichos: Mariposas en el código</title>
      <link>https://metrosetenta.es/blog/cuentos-de-bichos-mariposas-en-el-codigo/</link>
      <pubDate>Tue, 19 Jul 2016 11:06:00 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/cuentos-de-bichos-mariposas-en-el-codigo/</guid>
      <description>&lt;p&gt; La polilla, una de esas pequeñas mariposas nocturnas que se sienten atraídas por la luz y cuya larva destruye la materia donde anida, es un lepidóptero. En fin, que es un bicho. En telegrafía, y en las primeras compañías telefónicas, era habitual usar la expresión &amp;ldquo;bichos en el cable de teléfono&amp;rdquo; para referirse al ruido y las interferencias en la comunicación. Si bien es cierto que la palabra inglesa «bug» ya fue usada para indicar un defecto industrial, y que el mismísimo Thomas Edison dispuso de ella con esta finalidad, es probable que fuera Grace Murray Hopper quien la aplicó por vez primera al ámbito de la informática. Ésta licenciada en física trabajaba como programadora en el Mark II, uno de esos primeros ordenadores que estaba formado por componentes electrónicos y electromecánicos, cuando investigando la causa de un fallo en el mastodóntico computador de IBM, halló una polilla bloqueando el relé 70 del panel F. El hecho se documentó de modo metódico, y el insecto quedó inmortalizado en una foto junto a un texto que rezaba &amp;ldquo;primera vez que se encuentra (en un ordenador) un «bug» de verdad&amp;rdquo;. Así comenzó la leyenda del primer bug informático conocido.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Sin documentos no hay hockey</title>
      <link>https://metrosetenta.es/blog/sin-documentos-no-hay-hockey/</link>
      <pubDate>Mon, 04 Jul 2016 15:33:00 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/sin-documentos-no-hay-hockey/</guid>
      <description>&lt;p&gt;En su libro “Advanced PHP programming”, George Schlossnagle hace la siguiente afirmación:&lt;/p&gt;&#xA;&lt;p&gt;En mi empresa, el código producido para los clientes no se considera completo hasta que toda su interfaz externa de programación de la aplicación (API) y cualquier idiosincrasia interna están totalmente documentadas.&lt;/p&gt;&#xA;&lt;p&gt;Esta declaración de Schlossnagle es una buena señal de lo importante que puede llegar a ser la gestión de la documentación del código fuente dentro de un proyecto de desarrollo de software.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Tabular blandito</title>
      <link>https://metrosetenta.es/blog/tabular-blandito/</link>
      <pubDate>Fri, 08 Jan 2016 12:42:00 +0100</pubDate>
      <guid>https://metrosetenta.es/blog/tabular-blandito/</guid>
      <description>&lt;p&gt;Pues eso, que me gusta tabular blandito. Seguro que coincides conmigo en que sangrar el código, es decir, comenzar ciertos renglones más a la derecha que otros, es un modo más que efectivo de organizar y facilitar su lectura. Tanto es así, que esta técnica forma parte de la sintaxis del lenguaje de programación Python.&lt;/p&gt;&#xA;&lt;p&gt;La tecla tabulador de las antiguas máquinas de escribir, al ser pulsada, introducía automáticamente una cantidad determinada de espacios. Actualmente, con el uso de las computadoras, en prácticamente todos los editores de texto podemos elegir entre tabular blando o duro. La primera opción imita el funcionamiento de las antiguas máquinas de escribir: introducir una cantidad determinada de espacios. Esto quiere decir que tabular en cuatro caracteres es lo mismo que pulsar la barra de espacio cuatro veces. En el segundo caso, con la tabulación dura, el espacio sangrado funciona como un bloque indivisible de cuatro espacios. Aunque visualmente nos van a resultar idénticos voy a mostrate a continuación que no lo son y, por este motivo, la elección del tipo de tabulación es importante en los desarrollos de software.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Código andamio</title>
      <link>https://metrosetenta.es/blog/codigo-andamio/</link>
      <pubDate>Sat, 01 Jun 2013 00:34:00 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/codigo-andamio/</guid>
      <description>&lt;p&gt;Te presento una técnica bastante extendida entre los programadores anglosajones de lenguaje C, y que se podría traducir como código andamio. Consiste en definir, mediante una directiva del preprocesador, una constante durante el código fuente. En el caso que nos ocupa se le suele nombrar DEBUG y el valor puede ser, por ejemplo, 1.&lt;/p&gt;&#xA;&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;&#34;&gt;&lt;code class=&#34;language-C&#34; data-lang=&#34;C&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#75715e&#34;&gt;#define DEBUG 1  &#xA;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;A partir de ahora, puedes crear tus propios puntos de testeo del siguiente modo.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Interruptores hardware en Arduino</title>
      <link>https://metrosetenta.es/blog/interruptores-hardware-en-arduino/</link>
      <pubDate>Sat, 20 Apr 2013 08:53:00 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/interruptores-hardware-en-arduino/</guid>
      <description>&lt;p&gt; Piensa en tu placa Arduino ejecutando alegremente y ad libitum el bloque Loop que le ordenaste. En un momento dado necesitas que lo deje todo y realice una acción concreta. Por ejemplo, un láser que al ser interrumpido activa una alarma. Bien, pues para conseguir esto disponemos de un tipo de función avanzada que se llama &lt;em&gt;ISP&lt;/em&gt; (Rutina de interrupción de servicio).&lt;/p&gt;&#xA;&lt;p&gt;Vayamos por partes. Lo primero que necesitamos es adjuntar un interruptor a nuestro código. Para ello usamos la función &lt;em&gt;attachInterrupt(interruptor, función, modo)&lt;/em&gt;. En arduino Uno podemos usar los pines 2 y 3 para conectar el hardware que ordenará la ejecución de nuestra ISP. En el primer parámetro esta función, el parámetro &lt;em&gt;interruptor&lt;/em&gt;, debemos aclarar de que interruptor estamos hablando, por tanto escribe 0 si tu láser está conectado en el pin 2, o escribe 1 si lo está en el pin 3.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Función constrain() para arduino</title>
      <link>https://metrosetenta.es/blog/funci%C3%B3n-constrain-para-arduino/</link>
      <pubDate>Thu, 04 Apr 2013 22:46:00 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/funci%C3%B3n-constrain-para-arduino/</guid>
      <description>&lt;p&gt;Cuando recibimos los diferentes niveles de intensidad eléctrica de un sensor en uno de nuestros pines analógicos, el Analogic to digital converter (modificador de analógico a digital) de nuestro microcontrolador transforma esa intensidad en un dato digital almacenado en 10 bits. Por tanto, tenemos una escala de valores posibles desde 0 hasta 1023, donde 0 equivale a 0 voltios y 1023 equivale a 5 voltios (o el valor máximo establecido con la función  analogReference()).&lt;/p&gt;</description>
    </item>
    <item>
      <title>Usando la etiqueta de enlace como botón</title>
      <link>https://metrosetenta.es/blog/usando-la-etiqueta-de-enlace-como-boton/</link>
      <pubDate>Mon, 24 Sep 2012 19:06:00 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/usando-la-etiqueta-de-enlace-como-boton/</guid>
      <description>&lt;p&gt;Al usar una etiqueta para crear un enlace en HTML y hacerlo funcionar como un botón, serás capaz de observar que el área donde el usuario puede cliquear coincide con la altura y ancho del texto del enlace. Esto se debe a que esta etiqueta se visualiza en línea de forma predeterminada, pero es posible modificarla para darle un diseño más atractivo de cara al usuario cambiando el tipo de visualización, en el código CSS del enlace, al tipo bloque:&lt;/p&gt;</description>
    </item>
    <item>
      <title>SQL injection múltiple</title>
      <link>https://metrosetenta.es/blog/sql-injection-multiple/</link>
      <pubDate>Thu, 20 Sep 2012 17:07:00 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/sql-injection-multiple/</guid>
      <description>&lt;p&gt;Vamos a abordar juntos otro par de párrafos sobre SQL injection. En esta ocasión te escribo sobre una variante de esta técnica que se basa en la posibilidad de ejecutar varias consultas, usando el estándar SQL, separadas entre sí con el signo de puntuación punto y coma (;).&lt;/p&gt;&#xA;&lt;p&gt;Con una pequeña y rápida prueba, un hacker puede comprobar si nuestro formulario es vulnerable a SQL injection, y si debe  usar una comilla sencilla (‘) o comillas dobles (“). Una vez hecho esto únicamente ha de separar el valor legítimo del código malicioso usando dicha comilla, y con el punto y coma finalizar la consulta legítima para iniciar una nueva consulta con la función que el hacker desee realizar sobre la base de datos. Parece difícil, pero cuando veas un ejemplo verás que es realmente sencillo.&lt;/p&gt;</description>
    </item>
    <item>
      <title>¿Es PEAR la pera?</title>
      <link>https://metrosetenta.es/blog/es-pear-la-pera/</link>
      <pubDate>Wed, 12 Sep 2012 19:02:00 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/es-pear-la-pera/</guid>
      <description>&lt;p&gt; PEAR se define a sí mismo, al inicio de su página web (&lt;a href=&#34;http://pear.php.net&#34;&gt;http://pear.php.net&lt;/a&gt;), como  un marco y un sistema de distribución de componentes PHP reutilizables. PEAR son las siglas de PHP Extension and Application Repository, y su logotipo, aprovechando el juego de palabras, es una simpática pera. En alguna ocasión te escribiré acerca  de PEAR en este blog (si no lo he hecho ya), y por este motivo hoy te lo presento de un modo liviano.&lt;/p&gt;</description>
    </item>
    <item>
      <title>El fundamento de SQL injection</title>
      <link>https://metrosetenta.es/blog/el-fundamento-de-sql-injection/</link>
      <pubDate>Tue, 11 Sep 2012 18:47:00 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/el-fundamento-de-sql-injection/</guid>
      <description>&lt;p&gt;Estoy convencido de que si lo piensas detenidamente coincidirás conmigo en que, usualmente, la finalidad de nuestras aplicaciones es la de servir  a nuestros usuarios de interfaz para  el manejo de extensas bases de datos. Estas bases de datos están diseñadas para facilitar la consulta y el transporte de información hacia el usuario y, en sentido opuesto, para recibir y almacenar información entregada por el mismo. Cada vez que un usuario consulta o envía información a la base de datos de tu aplicación, está participando en la construcción de un código que ejecutará una acción en dicha base de datos. Ahora que hemos dicho esto, pregúntate ¿podría un usuario ilegítimo aprovechar esta pequeña participación para desvirtuar el código y hackear tu base de datos?.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Longitud y formato también importan</title>
      <link>https://metrosetenta.es/blog/longitud-y-formato-tambien-importan/</link>
      <pubDate>Fri, 07 Sep 2012 22:02:00 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/longitud-y-formato-tambien-importan/</guid>
      <description>&lt;p&gt; Te cuento más cosas a tener en cuenta cuando procesas información recibida de tus usuarios. En primer lugar quiero que sepas que es conveniente que chequees la longitud de los valores recibidos para prevenir ataques de denegación de servicio o de desbordamiento de buffer. En PHP se puede usar la función strlen() para comprobar la longitud del dato recibido antes de procesarlo.&lt;/p&gt;&#xA;&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;&#34;&gt;&lt;code class=&#34;language-Java&#34; data-lang=&#34;Java&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;If (strlen($edad) &lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; 3 ) exit ($edad . &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34; es un valor inválido para el campo edad&amp;#34;&lt;/span&gt;;)&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt; Y ahora hablemos del formato. Cuando comprobamos el tipo de variable y su longitud puede parecer que tenemos todo el trabajo hecho, pero no  es del todo cierto. Una fecha de nacimiento y un correo electrónico pueden estar contenidos en una variable del tipo cadena de caracteres, pero tienen aspectos bien distintos, formatos diferentes. La fecha puede estar separada por barras, usar dos caracteres para indicar el día en cifras, tres para indicar el mes en letras y dos para indicar el año en cifras; algo así como 12/jun/78. El correo electrónico contiene dos secciones bien diferencias por el signo @ y finaliza con un punto y una extensión del tipo com, es, tv, org, etc. Otro ejemplo: &lt;a href=&#34;mailto:metroSetenta@gmail.com&#34;&gt;metroSetenta@gmail.com&lt;/a&gt;. En el momento en que nuestro código debe interactuar con el de otras aplicaciones como, por ejemplo, gestores de correos, bases de datos o sistemas subyacentes, el formato usado es esencial para la prevención de errores y brechas de seguridad.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Comprobar el tipo de datos recibidos</title>
      <link>https://metrosetenta.es/blog/comprobar-el-tipo-de-datos-recibidos/</link>
      <pubDate>Sun, 29 Jul 2012 21:02:00 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/comprobar-el-tipo-de-datos-recibidos/</guid>
      <description>&lt;p&gt; Este es uno de esos pasos que ya te conté que tienes que dar para conseguir el correcto y seguro funcionamiento de tu aplicación. No es necesario tener un nivel de formación en informática a la altura de poder generar errores del tipo buffer overflow, porque si tu aplicación espera un valor numérico y un usuario maligno introduce texto, lo mejor que puede pasar es que tu programa no funcione correctamente. Se trata, pues, de una gran brecha potencial en la seguridad de tu aplicación. Los tipo de datos, a grandes rasgos se pueden dividir en tres: Cadenas de texto, números y booleanos.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Tu aplicación contra la gestión de variables inesperadas</title>
      <link>https://metrosetenta.es/blog/tu-aplicacion-contra-la-gestion-de-variables-inesperadas/</link>
      <pubDate>Sat, 21 Jul 2012 20:18:00 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/tu-aplicacion-contra-la-gestion-de-variables-inesperadas/</guid>
      <description>&lt;p&gt; En entradas anteriores hice alusión al modo en el que un usuario ilegítimo de tu aplicación web puede hacer tentativas muy básicas de hacking del estilo que sigue:&lt;/p&gt;&#xA;&lt;pre tabindex=&#34;0&#34;&gt;&lt;code&gt;http://servidor/aplicacion?administrador=TRUE&#xA;&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;Seguro que esto te hace reflexionar sobre la importancia de no admitir y gestionar variables inesperadas, así que te muestro a continuación un pequeño código para excluir automáticamente valores inapropiados de tus scripts, pudiendo así asumir con certeza que el entorno global está saneado, incluso aunque el atacante remplace el código de tu web para enviar valores no esperados. La idea consiste en listar las variables esperadas por nuestro código en un array, y posteriormente usarlo para chequear las variables recibidas. ¡Es como una lista de invitados a una sala de fiestas pija!. Aunque este ejemplo está en PHP, como casi siempre, te recuerdo que la idea es fácilmente transportable a cualquier lenguaje de programación.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Declaración de variables y seguridad</title>
      <link>https://metrosetenta.es/blog/declaracion-de-variables-y-seguridad/</link>
      <pubDate>Sat, 14 Jul 2012 16:19:00 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/declaracion-de-variables-y-seguridad/</guid>
      <description>&lt;p&gt; Son muchos los lenguajes de programación en los cuales no es necesario declarar las variables antes de que estas sean usadas. Si escribes tus códigos en un lenguaje que resulte flexible en este aspecto que te explico, y dispones de la posibilidad de configurarlo de modo que sea obligatorio declarar las variables antes de usarlas, ¡es mejor que no dejes de hacerlo!. Te muestro un código en PHP a modo de ejemplo:&lt;/p&gt;</description>
    </item>
    <item>
      <title>Cinco detalles a cuidar al recibir datos de tus usuarios</title>
      <link>https://metrosetenta.es/blog/cinco-detalles-a-cuidar-al-recibir-datos-de-tus-usuarios/</link>
      <pubDate>Sat, 07 Jul 2012 09:55:00 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/cinco-detalles-a-cuidar-al-recibir-datos-de-tus-usuarios/</guid>
      <description>&lt;p&gt; Son muchísimas las ocasiones en las que nuestras aplicaciones solicitan a los usuarios algún tipo de información: Nombre, correo electrónico, texto de opinión, nueva contraseña… Usualmente lo hacemos a través de formularios que contienen distintos campos a rellenar, campos que nuestras aplicaciones van a recibir y posteriormente van a procesar; por tanto, estos campos, que son manipulables por los usuarios, representan una vía a través de la cual se puede amenazar la seguridad de nuestras aplicaciones. Entonces ¿que es lo más básico a tener en cuenta al usar estos campos de entradas de datos?.&lt;/p&gt;</description>
    </item>
    <item>
      <title>La estética MAYA</title>
      <link>https://metrosetenta.es/blog/la-estetica-maya/</link>
      <pubDate>Wed, 16 May 2012 06:31:00 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/la-estetica-maya/</guid>
      <description>&lt;p&gt; La estética MAYA es un concepto Estudio sobre la belleza. Fue propuesto por Raymond Loewy, y se fundamenta en una sencilla idea: Dentro de los conceptos estéticos ya aceptados, todos tendemos a preferir aquellos que son más modernos. Entre otras cosas, esto implica que los conceptos estéticos no son usualmente bienvenidos en el momento de nacer, sino que requieren un proceso de maduración y aceptación paulatina. Es por este motivo que, al diseñar tu aplicación, el uso de muchas innovaciones estéticas simultáneas ayudará a desconcertar a tus usuarios. Por otro lado, si carece de toda novedad en su diseño, tu aplicación no supondrá ningún estímulo para los usuarios.&#xA; &lt;/p&gt;</description>
    </item>
    <item>
      <title>Seguridad informática absoluta y gestión del riesgo</title>
      <link>https://metrosetenta.es/blog/seguridad-informatica-absoluta-y-gestion-del-riesgo/</link>
      <pubDate>Tue, 08 May 2012 21:33:00 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/seguridad-informatica-absoluta-y-gestion-del-riesgo/</guid>
      <description>&lt;p&gt; Es posible que después de leer lo que sigue no vuelvas a teclear con tranquilidad el número de tu tarjeta de crédito en ninguna página web, pero hoy te quiero desvelar que la seguridad absoluta no existe en la informática contemporánea. Esto es así hasta el punto de que los expertos en seguridad informática hablan de la gestión del riesgo, y no de su eliminación completa. ¿Por que?.&lt;/p&gt;&#xA;&lt;p&gt; No importa si programas en Java o en PHP, incluso da igual si te has decantado por hacerlo con Ruby on rails o con el Net framework de Microsoft, porque indiferentemente al lenguaje y entorno de programación que uses, finalmente todo se traduce en ceros y unos. Si, así es, todo se reduce a impulsos eléctricos gestionados por un CPU, y el pequeño cerebro de nuestra computadora no sabrá distinguir si realmente todos y cada uno de los binarios que procesa cumplen con las sanas intenciones del legítimo programador de un software en ejecución o, por el contrario, se trata de un añadido malintencionado que aprovecha la más mínima vulnerabilidad de cualquiera de los procesos que corren en el sistema. Entonces ¿es imposible crear un programa perfectamente seguro, sin vulnerabilidades?.&lt;/p&gt;</description>
    </item>
    <item>
      <title>El usuario evalua e interpreta los diseños</title>
      <link>https://metrosetenta.es/blog/el-usuario-evalua-e-interpreta-los-dise%C3%B1os/</link>
      <pubDate>Mon, 23 Apr 2012 18:36:00 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/el-usuario-evalua-e-interpreta-los-dise%C3%B1os/</guid>
      <description>&lt;p&gt; Tan sencillo como reza el título. Cuando ofreces una interfaz gráfica a un usuario, éste se forja una opinión sobre su aspecto y hace una rápida interpretación del modo en el que funciona. El camino que se sigue para desarrollar el diseño de una aplicación informática es muy parecido al usado en sus proyectos por un arquitecto de antes del año 1900: Abordar el problema de la funcionalidad y, desde esta base, solventar posteriormente el asunto de la emotividad.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Crawlers, Bugs y capturadores web</title>
      <link>https://metrosetenta.es/blog/crawlers-bugs-y-capturadores-web/</link>
      <pubDate>Tue, 17 Apr 2012 18:14:00 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/crawlers-bugs-y-capturadores-web/</guid>
      <description>&lt;p&gt; En ocasiones los datos perseguidos por un hacker se encuentran repartidos en más de un servidor. Esto le obligará a rastrear la ubicación de las distintas partes y a obtener la información necesaria de cada servidor para poder acceder a su objetivo. Los programas que usan los hackers para automatizár esas acciones son los llamados web crawlers, y se usan para desentrañar toda la arquitectura de sitios web.&lt;/p&gt;&#xA;&lt;p&gt;Una vez que el hacker dispone de toda la información básica necesaria, realiza una búsqueda de información sobre las posibles vulnerabilidades de sus objetivos. Generalmente se tratan de errores de software, y por este motivo se les denominan bugs. Tienes que saber que existen aplicaciones, genéricamente llamadas bugs trackers, que se usan para el seguimiento y gestión de estos bugs. Es facil encontrar en la red bugs trackers enfocados a facilitar el hacking, e igualmente, es fácil encontrar programas diseñados para explotar los bugs de diferentes aplicaciones (exploits), especialmente de servidores.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Métodos de los protocolos web y hacking</title>
      <link>https://metrosetenta.es/blog/metodos-de-los-protocolos-web-y-hacking/</link>
      <pubDate>Wed, 11 Apr 2012 06:28:00 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/metodos-de-los-protocolos-web-y-hacking/</guid>
      <description>&lt;p&gt;Ya sabes que tu user’s agent puede usar el protocolo HTTP para hacer una solicitud a un servidor (request), y que éste nos facilitará una respuesta adecuada a dicha solicitud (response). A continuación te presentaré los métodos que usa tu user´s agent para realizar diferentes solicitudes al servidor, pero antes debes conocer un detalle, existen actualmente cuatro versiones del protocolo HTTP, y en las más antiguas no están disponible todos los métodos te paso a presentar.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Protocolos web y seguridad</title>
      <link>https://metrosetenta.es/blog/protocolos-web-y-seguridad/</link>
      <pubDate>Fri, 06 Apr 2012 14:36:00 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/protocolos-web-y-seguridad/</guid>
      <description>&lt;p&gt; Hay algo que debes de tener siempre presente si quieres responsabilizarte de la seguridad de tus aplicaciones, o de la seguridad de las aplicaciones de terceros: debes superar, o igualar al menos, los conocimientos de cualquier hacker potencial de dichas aplicaciones. Centrándonos en la web, es básico conocer el protocolo de comunicación que esta usa, pues un hacker lo dominará perfectamente. World wide web es una de la partes más activas de internet, y hace uso de dos protocolos: HTTP y HTTPS.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Variables de entorno y CGI</title>
      <link>https://metrosetenta.es/blog/variables-de-entorno-y-cgi/</link>
      <pubDate>Tue, 03 Apr 2012 06:10:00 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/variables-de-entorno-y-cgi/</guid>
      <description>&lt;p&gt; Las siglas CGI (Common Gateway Interface) significan Interfaz de entrada común, y definen un estándar usado para que los usuarios web puedan intercambiar datos con una aplicación alojada en un servidor web. A continuación un buen ejemplo de aplicación que usa el estándar CGI:&lt;/p&gt;&#xA;&lt;p&gt; El usuario está buscando en su navegador web una farmacia cercana, y para ello introduce los datos de su domicilio en un formulario y pulsa el botón enviar. La aplicación CGI (que así la llaman por usar este estándar) que se encuentra alojada en el servidor web recibe la solicitud de fulanito, luego hace una consulta a una base de datos basándose en ella y envía a fulanito una web con los resultados perfectamente expuestos y ordenados.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Lo más básico contra ataques web</title>
      <link>https://metrosetenta.es/blog/lo-mas-basico-contra-ataques-web/</link>
      <pubDate>Mon, 02 Apr 2012 19:17:00 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/lo-mas-basico-contra-ataques-web/</guid>
      <description>&lt;p&gt;Son muchas las herramientas a disposición de un hacker para explotar vulnerabilidades a tu aplicación web, por esto, son muchas las posibilidades que tiene de realizar un ataque exitoso con un mínimo de conocimientos. Toma notas, porque esto es lo más básico que debes considerar para ir empezando a trabajar la seguridad de tus aplicaciones web:&lt;/p&gt;&#xA;&lt;p&gt;Filtra los caracteres peligrosos de cualquier dato ingresado por los usuarios de tu aplicación, y no olvides hacer lo mismo con los campos ocultos de formularios si los sueles usar.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Diseños reproducibles</title>
      <link>https://metrosetenta.es/blog/disenos-reproducibles/</link>
      <pubDate>Sun, 01 Apr 2012 21:56:00 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/disenos-reproducibles/</guid>
      <description>&lt;p&gt;Hay un modo sencillo y rápido para detectar posibles errores en el diseño de tus aplicaciones: ”si no puedes reproducir tu diseño en la realidad palpable, algo debe estar mal”. Observa como el uso de las sombras, en las ventanas de la imagen más a la izquierda, resulta desconcertante. Prueba a tomar dos folios e intenta reproducir con ellos la posición de las ventanas indicadas.&lt;/p&gt;&#xA;&lt;p&gt;Comprueba cómo la imagen que se encuentra más a la derecha reproduce con mayor acierto las sombras proyectadas, evitando el desconcierto del modelo anterior y clarificando cual es la ventana más cercana y cual es la que se encuentra al fondo.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Compresiones intuitivas</title>
      <link>https://metrosetenta.es/blog/compresiones-intuitivas/</link>
      <pubDate>Sat, 31 Mar 2012 01:28:00 +0200</pubDate>
      <guid>https://metrosetenta.es/blog/compresiones-intuitivas/</guid>
      <description>&lt;p&gt;  Conocer la forma en la que el cerebro percibe e interpreta sombras, colores, formas, etc. es una poderosa herramienta de diseño. En el momento de tomar decisiones relacionadas con el diseño, debes ser capaz de incluir y valorar compresiones intuitivas (percived afforance). Te aclaro de que se trata con un ejemplo: una señal octogonal de color rojo practicamente no necesita la palabra STOP en el centro, pues su forma y color característico son suficiente para que el usuario pueda intuir el significado. Observa, por otro lado, lo desconcertante que puede ser una señal de stop de color azul y cuadrada.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Planificar la experiencia</title>
      <link>https://metrosetenta.es/blog/planificar-la-experiencia/</link>
      <pubDate>Thu, 22 Mar 2012 20:50:00 +0100</pubDate>
      <guid>https://metrosetenta.es/blog/planificar-la-experiencia/</guid>
      <description>&lt;p&gt; Antes de abarcar otras cuestiones relacionadas con el diseño, necesitas planificar la experiencia que va a tener el usuario a través de tu aplicación. Esto es algo que raramente se planifica y, sin embargo, es esencial para el éxito de cualquier web o aplicación de escritorio. Hasta tal punto esto es así, que los usuarios casi siempre optan por las webs o las aplicaciones que les seducen frente a otras más rápidas, robustas, seguras o con mayores posibilidades. Una cuidada plantificación de la experiencia, por parte de los desarrolladores, es el primer paso para conseguir seducir al usuario.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Aplicaciones atractivas</title>
      <link>https://metrosetenta.es/blog/aplicaciones-atractivas/</link>
      <pubDate>Mon, 12 Mar 2012 18:07:00 +0100</pubDate>
      <guid>https://metrosetenta.es/blog/aplicaciones-atractivas/</guid>
      <description>&lt;p&gt; Por fin has terminado de programar, pero notas que aún falta algo. La aplicación está funcionando correctamente, las soluciones en el código son elegantes y los posibles errores están controlados. La interfaz que interactua con el usuario es agradable de usar, intuitiva y manejable; pero algo no va bien. El número de interesados es bajo, no se registran nuevos usuarios o no descargan tu aplicación. Los usuarios que se han registrado no la usan con frecuencia o migran rápidamente a otras aplicaciones similares, y por supuesto no obtienes de ellos sus recomendaciones para otros usuarios potenciales y, no obtienes un buen feedback. Entonces ¿que es lo que está fallando?.&lt;/p&gt;</description>
    </item>
  </channel>
</rss>
