<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Nearsoft Jobs - Medium]]></title>
        <description><![CDATA[jobs@nearsoft.com - Medium]]></description>
        <link>https://medium.com/nearsoft-jobs?source=rss----fa2c350e2dde---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Nearsoft Jobs - Medium</title>
            <link>https://medium.com/nearsoft-jobs?source=rss----fa2c350e2dde---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 21:11:16 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/nearsoft-jobs" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Automated test design]]></title>
            <link>https://medium.com/nearsoft-jobs/automated-test-design-9af5edb8e57b?source=rss----fa2c350e2dde---4</link>
            <guid isPermaLink="false">https://medium.com/p/9af5edb8e57b</guid>
            <category><![CDATA[performance-test-design]]></category>
            <category><![CDATA[nearsoft]]></category>
            <category><![CDATA[jmeter]]></category>
            <category><![CDATA[encora]]></category>
            <dc:creator><![CDATA[Jorge Amado Soria Ramirez]]></dc:creator>
            <pubDate>Sat, 15 May 2021 02:07:17 GMT</pubDate>
            <atom:updated>2021-05-15T02:07:17.669Z</atom:updated>
            <content:encoded><![CDATA[<h3>Diseño de pruebas automatizadas</h3><p>Hay varios tipos de pruebas de calidad de software que tienen que ser realizadas por humanos. Pruebas de aceptación, pruebas de experiencia de usuario (UX), pruebas A/B… todas dependen del juicio humano para la aprobación de funcionalidades particulares del producto.</p><p>Sin embargo, no todas las pruebas requieren un humano al volante. Algunas pueden ser automatizadas, dejando que la computadora se encargue de la ejecución de la prueba y la recopilación de datos. Otras <strong><em>deben</em></strong> ser automatizadas debido a la enorme cantidad de números involucrados que hacen la ejecución manual simplemente imposible. La automatización es una gran herramienta para configurar pruebas repetibles <em>ad infinitum</em>, con grandes cantidades de usuarios simulados y que producen grandes cantidades de datos para posterior análisis.</p><p>De todas maneras, incluso en pruebas automatizadas, los humanos todavía están a cargo, sobre todo al principio, en la parte de diseño. Las computadoras no diseñan pruebas de rendimiento… aún.</p><p>Entonces, mientras esperamos por las computadoras para que se adueñen también de esto, revisemos algunos tipos de test, algunos conceptos de diseño y la forma en la que pueden ser usados para hacer el testing del software más útil y menos doloroso.</p><p>Pero primero, hablemos de…</p><h3>La ley de Little</h3><p>…la cual es una proposición que dice lo siguiente:</p><p><em>El promedio de los usuarios en el sistema a largo plazo (L) es igual a la tasa de llegada de usuarios a largo plazo (λ) multiplicada por el tiempo promedio que un cliente permanece en el sistema (W)</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/132/0*mUIJknAPi47vOSvK" /></figure><p>Parece intuitivo a primera vista, pero en realidad es muy interesante dado que la relación ignora todas las complejidades que parecerían afectarla, como serian el orden de los usuarios, la forma en que se distribuyen los servicios, la diferencia en atención para cada usuario, y muchos otros factores que parecerían nublar este cálculo a primera vista.</p><p>Aunque esto aplica a todo tipo de sistema (no sólo software), su importancia es mucho más relevante para conducir una prueba de rendimiento de software apropiada.</p><p>Por ejemplo, consideremos una aplicación totalmente nueva que está a punto de someterse a pruebas de rendimiento. Una expectativa razonable para los tiempos de respuesta puede ser calculada si la concurrencia (la cantidad promedio de usuarios en el sistema) y el rendimiento (promedio de peticiones por unidad de tiempo) son conocidos (vía una aplicación de monitoreo o analítica, por ejemplo). Dados estos datos, el tiempo promedio de respuesta esperado puede encontrarse usando la ley de Little:</p><p><em>Tiempo de respuesta promedio = número promedio de usuarios en el sistema / rendimiento promedio por unidad de tiempo</em></p><p>Por supuesto, ambas métricas (usuarios en el sistema y rendimiento) pueden obtenerse a partir de un tiempo de respuesta conocido (o asumido). Esta ley es muy util para determinar el comienzo de las restricciones para cualquier prueba de rendimiento o no funcional que puede ser aplicada a un sistema.</p><p>Habiendo dicho eso, la prueba de rendimiento puede ser realizada sin aplicar la ley de Little, tomando que el sistema está ya en producción e instrumentado durante un tiempo significativo. A veces, si las métricas son conocidas debido a experiencias previas (o instrucciones de arriba) la ley de Little se puede ignorar; no debería serlo, pero es posible y con frecuencia pasa.</p><h3>Propiedades de las pruebas</h3><p>Cada plan de prueba automática requiere un poco de configuración. Algunas más que otras, dependiendo del proyecto y la profundidad deseada de la prueba en cuestión. Sería imposible hacer una lista completa de todas las propiedades de una prueba automatizada, pero podemos listar algunos de los más útiles para configurar y comparar entre sí:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*g9I53PeoXaPaWsEww0Ey_w.png" /></figure><p><em>*Como vimos antes, la ley de Little puede ser ignorada en algunas condiciones y aun así obtener resultados útiles.</em></p><p><em>**Es buena práctica hacer siempre calentamiento gradual para toda prueba con más de un puñado de usuarios. La terminación gradual de la prueba no es. obligatoria en todos los casos, pero ayuda de más de una manera, como veremos luego.</em></p><p>Los números no son precisos para ninguna de estas propiedades. Los números cambian dependiendo de muchos factores, incluyendo la complejidad de la suite de pruebas, los requerimientos de los servidores y los interesados en la prueba, las herramientas disponibles, etc. Dada esta situación es imposible fijarlos en todos los casos, pero pueden ser determinados por el tester para cada sistema o incluso, para cada ejecución.</p><h3>Pruebas</h3><p>Cada prueba tiene valores diferentes para cada propiedad, correspondiendo a la importancia comparativa de cada area y la meta de cada tipo de prueba. Revisemos cada uno de los principales tipos de prueba para poder visualizar la manera en que estas propiedades aplican a cada caso.</p><h3>Prueba de humo</h3><p>Una prueba de humo (<em>smoke test</em>) es una prueba diseñada para mostrar un problema particular en los casos normales de uso de la aplicación (los <em>happy path</em>), o para probar las principales funcionalidades de un sistema después de cada version, para asegurarse de que no hay problemas evidentes.</p><p>Las pruebas de humos son pruebas no completas ni obligatorias, con un gran resultado en relación con una baja inversion en términos de esfuerzo.</p><p>Estas pruebas son eminentemente automatizables y suficientemente simples como para ser diseñados por cualquiera en un equipo de desarrollo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HDjcXN8j6nLsIINMx1kGww.png" /></figure><p>No deberían haber errores excepto si la prueba esta diseñada para producirlos.</p><h3>Pruebas funcionales</h3><p>Estas pruebas se dirigen a comprobar la compatibilidad de las funcionalidades del sistema contra las especificaciones del usuario final. Las pruebas funcionales usualmente son simples y restringidas a una funcionalidad por prueba, aunque esto no es una regla inflexible. Dependiendo de la complejidad del sistema, una prueba funcional puede incluir un flujo de usuario completo con varias funcionalidades ejecutadas en secuencia.</p><p>Las pruebas funcionales pueden ser ejecutadas manualmente, pero también pueden ser automatizadas en un ambiente de integración continua. Esta decision depende de las necesidades del negocio y el tamaño de la suite de pruebas.</p><p>Las pruebas funcionales son más complicadas que las pruebas de humo, y requieren un conocimiento más profundo del negocio y el sistema. Siendo este el caso, las pruebas funcionales requieren personal de QA especializado, ya sea para ejecutarlas o para analizar la data resultante con o sin el cliente y desarrolladores.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-zWglJI3SCN4pPa8DdO5KQ.png" /></figure><h3>Prueba de carga</h3><p>Entrando a las pruebas no funcionales, la más común de todas es la prueba de carga. Esta es una prueba no funcional dedicada a mostrar el comportamiento de la aplicación bajo una carga normal estimada y/o bajo carga en hora pico.</p><p>Similar a las pruebas funcionales, las pruebas de carga pueden ser realistas o sintéticas. Sin embargo, escenarios demasiado largos o sofisticados tienden a introducir fragilidad e impredictibilidad, y por tanto deberían ser evitados a no ser que sean absolutamente necesarios.</p><p>Debido a su naturaleza no funcional, la tolerancia a errores en las pruebas de carga es notablemente más alta que en las pruebas funcionales o de humo. La razón para ello es simple: durante carga normal o pico un número de errores es esperado en sistemas que no sean diseñados a prueba de fallos (la inmensa mayoría). La cantidad de errores esperados es una de las métricas más difíciles de ajustar al diseñar una prueba de carga, junto a la concurrencia y los tiempo de respuesta esperados.</p><p>Las pruebas de carga pueden ser diseñadas por cualquiera, pero usualmente son la responsabilidad de los desarrolladores o QA especializados en pruebas de rendimiento, en dependencia de la dificultad de la suite de pruebas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*olnBZwX0v9NzhexvNn2K1g.png" /></figure><p>Finalmente, las pruebas de carga pueden ser automatizadas pero no hay necesidad real de hacerlo. Una prueba de carga es una prueba potencialmente costosa y debe ser administrada en cada ejecución con cuidado.</p><h3>Prueba de resistencia</h3><p>Una prueba de resistencia es ligeramente diferente de una prueba de carga en cuanto a diseño. Aunque se pueden usar los mismos escenarios de prueba, concurrencia y otras configuraciones, el objetivo de la prueba de resistencia es poner el sistema bajo carga durante un tiempo prolongado, más allá de lo esperado en producción. Este pequeño cambio en la duración de la prueba tiene consecuencias drásticas en la manera en la que los resultados deben ser analizados en comparación con una prueba de carga ordinaria de duración corta.</p><p>Al hablar de periodos “cortos” y “largos” tenemos que tener en cuenta el sistema bajo prueba. Una buena regla general es probar el sistema con una duración entre 8 y 24 horas. En contraste con las pruebas de carga (que principalmente miden tiempo de respuesta y análisis de errores), las pruebas de resistencia miden el estrés de los recursos en el servidor, las interrupciones de servicio, tipo y cantidad de cada error y comportamientos inesperados.</p><p>Las pruebas de resistencia tienen otra función importante: Sirven para medir la habilidad de recuperación del servidor después de un periodo de actividad inusualmente intenso o largo. También miden la degradación de la curva de rendimiento después de periodos extensos de tiempo. Ningún otro tipo de prueba puede proveer estos resultados.</p><p>Las pruebas de resistencia funcionan mejor combinadas con pruebas de carga. Idealmente, se usarían las pruebas de carga para obtener tiempos de respuesta y uso de recursos en el servidor, y luego estos resultados servirían para construir una base para lo que se consideraría comportamiento anormal para recursos y para la curva de degradación de rendimiento. Combinar pruebas de carga con pruebas de rendimiento utilizando los mismos escenarios de prueba también permite simplificar esta última, dado que elimina la necesidad de usar validaciones, temporizadores realistas y flujos condicionales que pueden ser evaluados en la prueba de carga.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*v_wEqPBYjhpCW2SlE6zsIA.png" /></figure><h3>Prueba de estrés</h3><p>La prueba final que vamos a ver es una prueba de estrés.</p><p>También llamada prueba de pico o <em>spike test</em>, esta prueba consiste en un corto pico de peticiones que, como el nombre lo indica, crea un estado anormalmente alto de concurrencia por un breve periodo de tiempo para estresar el sistema.</p><p>Estos picos pueden pasar una vez en la prueba, o varias veces siempre y cuando el diseño incluya un periodo comparativamente largo de recuperación entre cada uno. De hecho, la configuración con varios picos es recomendada dado que este diseño permite estresar el sistema varias veces y medir su capacidad de recuperación, resaltando potenciales problemas como pérdidas de memoria, corrupción de ficheros o pérdida de conexiones a bases de datos. Este tipo de problemas de manejos de recursos pueden perfectamente pasar desapercibidos en servidores poderosos o con picos bajos, pero se hacen mucho más visibles después de pasar por varios picos consecutivos.</p><p>Las pruebas de estrés son bastante simples de preparar, dado que no tienen que cubrir todos los casos de una aplicación, sino simplemente enfocarse en un pequeño grupo de funcionalidades que hayan sido identificadas como intensas en uso de recursos o de alto impacto en el uso del sistema.</p><p>La funcionalidad más prominente de este tipo de pruebas es el pico pronunciado en usuarios que necesita suceder en algún momento en medio de la misma. No puede durar por mucho tiempo (o se arriesga un fallo natural de los servidores sin ningún beneficio para el análisis) y debe estar precedido y sucedido por un periodo de concurrencia “normal” donde la cantidad de usuarios y carga del sistema sea semejante a las expectativas de producción o ligeramente por debajo.</p><p>La idea de estas pruebas es producir data que pueda ser analizada y contrastada en cada momento de la ejecución de la prueba.</p><p>Similar a las pruebas de resistencia, las pruebas de estrés no giran alrededor de la experiencia de usuario, la cantidad de errores (en general) o el tiempo de respuesta. Las métricas más importante para analizar durante una prueba de estrés son los recursos del servidor, los tipos de errores y los comportamientos inesperados de los servidores. Si la prueba tiene varios picos, entonces una métrica adicional puede ser la curva de degradación de rendimiento.</p><p>También similar a las pruebas de resistencia, las pruebas de estrés funcionan mejor en combinación con pruebas de carga. Una prueba de estrés puede usar los resultados de las pruebas de carga para definir lo que se considera un comportamiento anormal, trafico inesperado, capacidad de recuperación de los servidores o fuga de recursos. También permite que la prueba tenga un diseño más simple al poder obviar validaciones, temporizadores realistas y flujos de prueba sofisticados, todo lo cual se puede analizar durante la prueba de carga.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VtrOK2XPXDfXCt1uG_wa7Q.png" /></figure><h3>Finalización gradual de pruebas no funcionales</h3><p>En las pruebas de carga, estrés y resistencia es importante considerar el efecto de la finalización. La finalización de la prueba es la etapa de descarga gradual al final de la prueba, cuando los usuarios simulados comienzan a desconectarse.</p><p>La finalización de la prueba puede ser gradual o abrupta. Aunque una prueba puede cortarse abruptamente, este comportamiento muy probablemente causará inestabilidad y resultados aleatorios en los últimos minutos de la data. En dependencia de la herramienta utilizada y la escala de la prueba aplicada, esto puede significar un periodo de 10 minutos a 1 hora, donde la data puede estar inutilizable al final de la prueba debido a la inestabilidad introducida.</p><p>Para evitar este efecto, es siempre preferible que las pruebas con alta concurrencia y/o duración relativamente corta, deberían ser finalizadas gradualmente, y este periodo de finalización debe ser luego eliminado de la data a analizar para no falsear las estadísticas.</p><p>Por las mismas razones la parte de preparación gradual de la prueba también debe ser eliminada antes de analizar la data resultante. Aunque la parte de ramp up no introduce inestabilidad si está bien diseñada, es posible que falsee algunas estadísticas como el tiempo de respuesta cuando el sistema se prueba para estrés o niveles pico de concurrencia.</p><p>El uso de finalización gradual y su eliminación de la data de análisis es muy importante en las pruebas de carga. Esto se debe a que las pruebas de carga son las pruebas no funcionales más simples y las más cortas en promedio. Esto las hace más vulnerables a alteraciones estadísticas como las que incluyen un fin abrupto o una mala configuración de la preparación de los hilos de prueba.</p><p>Las pruebas de resistencia y estrés inevitablemente provocan degradación de rendimiento cerca del final, por lo cual cortar 30 minutos — 1 hora puede ser una buena práctica, se aplique finalización gradual o no. Habiendo dicho esto, usar la finalización gradual sigue siendo importante para evitar problemas con la herramienta de performance usada. Las pruebas muy largas y/o con grandes volúmenes de data producen pruebas que no solo estresan el sistema bajo prueba, sino también los recursos de la herramienta misma. Eso es especialmente visible al final de la ejecución, cuando las herramientas entran en la fase de procesamiento estadístico, generación de reportes, desconexión de servidores subordinados y otras operaciones de finalización. Introducir un proceso de finalización gradual en el diseño de la prueba suaviza el impacto de todas estas operaciones en la memoria y el CPU de los servidores de prueba, por tanto minimizando potenciales errores en los reportes y estadísticas. Esto es especialmente importante si la prueba esta integrada en un ambiente de CI/CD.</p><h3>Comparación final</h3><p>Después de haber descrito cada tipo de prueba, veamos como se ven comparadas lado a lado:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oXuUPbjNXbvPpGeyOrGAuw.png" /></figure><p>Ningún tipo de prueba es intrínsecamente mejor que las otras. En realidad, las pruebas de todo tipo pueden ser complementarias. Conocer el propósito de cada una y cuál es más aplicable a cada caso (y cuáles están dentro del alcance de la capacidad del equipo) es una gran ventaja para mejorar la calidad del software sin incrementar prohibitivamente la carga de trabajo.</p><p>Prueben frecuentemente, a profundidad, y sin abusar de sí mismos con cosas que pueden automatizarse. Las computadoras no se cansan. Úsenlas.</p><h3>Jorge Amado Soria, Software Engineer — <a href="https://medium.com/u/29f5296bd9a2">Nearsoft Jobs</a></h3><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9af5edb8e57b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nearsoft-jobs/automated-test-design-9af5edb8e57b">Automated test design</a> was originally published in <a href="https://medium.com/nearsoft-jobs">Nearsoft Jobs</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Pruebas automatizadas con JMeter y Logstalgia]]></title>
            <link>https://medium.com/nearsoft-jobs/pruebas-automatizadas-con-jmeter-y-logstalgia-1290eed14aec?source=rss----fa2c350e2dde---4</link>
            <guid isPermaLink="false">https://medium.com/p/1290eed14aec</guid>
            <category><![CDATA[jmeter]]></category>
            <category><![CDATA[performance-testing]]></category>
            <category><![CDATA[logstalgia]]></category>
            <dc:creator><![CDATA[Jorge Amado Soria Ramirez]]></dc:creator>
            <pubDate>Sat, 15 May 2021 01:50:04 GMT</pubDate>
            <atom:updated>2021-05-15T01:50:03.942Z</atom:updated>
            <content:encoded><![CDATA[<h3>Pruebas automatizadas con jMeter y Logstalgia</h3><h3>Introducción</h3><p>jMeter tiene una reputación bien ganada de ser una de las herramientas más poderosas, fácil de usar y ampliamente adoptada en el ámbito de las pruebas de rendimiento. Es versátil, fácil de aprender e infinitamente configurable.</p><p>Una aplicación un poco menos conocida de jMeter es su uso para pruebas de humo y funcionales. Esto es especialmente util como parte de una pipeline de integración continua, aunque también es válido como standalone. El enfoque modular de jMeter permite realizar todo tipo de pruebas a un API rest o un sitio web, sin la necesidad de plugins o código personalizado.</p><p>Pero, ¿cuál es la diferencia real entre pruebas de humo, funcionales y de rendimiento? Después de todo, si todas usan los mismos elementos dentro de jMeter, no pueden ser tan diferentes, ¿no? Pues, en realidad, sí, sí que pueden. La diferencia fundamental entre estas pruebas recae en el diseño de las mismas. El diseño de pruebas es una parte relativamente ignorada pero esencial de todas las pruebas automatizadas. Veamos este tema con más detalle…</p><h3>Preparación y configuración</h3><p>Para este pequeño demo, vamos a usar las siguientes herramientas:</p><ul><li>Java Virtual Machine 8 o superior (<a href="https://www.oracle.com/java/technologies/javase-downloads.html">https://www.oracle.com/java/technologies/javase-downloads.html</a>)</li><li>jMeter 5.3 o superior (<a href="https://jmeter.apache.org/download_jmeter.cgi">https://jmeter.apache.org/download_jmeter.cgi</a>)</li><li>Tomcat 8 o superior (<a href="https://tomcat.apache.org/download-80.cgi#8.5.57">https://tomcat.apache.org/download-80.cgi#</a>):</li><li>Logstalgia (<a href="https://logstalgia.io/">https://logstalgia.io/</a>):</li></ul><p>Logstalgia es la menos conocida de estas herramientas. Consiste en un pequeño visualizador de peticiones con una estética retro, que produce visuales muy interesantes para ayudar a entender logs con cualquier formato. Más adelante veremos algunas de estas visualizaciones en acción.</p><p>También necesitaremos los siguientes archivos:</p><ul><li>Plan de prueba de jMeter: Un archivo JMX de jMeter que contiene tres grupos de demostración: Uno para pruebas de humo, uno para pruebas funcionales y uno para pruebas de rendimiento. Más adelante veremos imágenes de la estructura de este documento.</li><li>Sitio web estático: Una simple colección de archivos GIF, PNG, CSS y TXT vacíos, numerados del 1 al 99.</li></ul><h3>Configuración</h3><ul><li>jMeter requiere Java, así que comencemos por instalarlo. Los detalles son diferentes según el sistema operativo, pero normalmente es un proceso sencillo. Cualquier versión de JDK o JRE 8 servirá.</li><li>Tomcat también requiere Java, así que es el próximo a instalar. De nuevo, las instrucciones particulares para la instalación difieren para cada sistema operativo. Puede ser tan fácil como un instalador auto contenido para Windows, un Homebrew para Mac o un paquete de Tomcat del repo correspondiente en Linux. O se puede instalar manualmente. Preferencia personal.</li><li>Después de instalar Tomcat, debemos ir a <em>$CATALINA_HOME/webapps</em> y copiar el sitio estático de jMeter, en una carpeta llamada <em>JMeter</em>.</li><li>Ahora necesitamos configurar la clase <em>AccessLogValve</em> em Tomcat para evitar que los logs se escriban en lotes, que es el comportamiento por defecto. Necesitamos que los logs se escriban en cuanto se reciban, no un minuto después. Para esto necesitamos ir a <em>$CATALINA_HOME/conf/server.xml, </em>encontrar la configuración de <em>AccessLogValve</em>, y adicionarle <em>buffered=”false”</em>. Deberíamos obtener algo como esto:</li></ul><pre><em>&lt;Valve className=”org.apache.catalina.valves.AccessLogValve” directory=”logs” </em><strong><em>buffered=”false”</em></strong><em> prefix=”localhost_access_log” suffix=”.txt” pattern=”%h %l %u %t &amp;quot;%r&amp;quot; %s %b” /&gt;</em></pre><ul><li>Finalmente, es hora de instalar Logstalgia. Para Windows y Linux podemos seguir las instrucciones en el sitio oficial. Para Mac, esta guía contiene información muy útil: <a href="http://macappstore.org/logstalgia/">http://macappstore.org/logstalgia/</a></li></ul><p>Después de instalar Logstalgia, necesitamos apuntarlo al log de Tomcat. Estos se encuentran normalmente en <em>$CATALINA_HOME/logs</em>, y por defecto se separan en archivos nuevos cada día. Los logs usualmente son archivos llamados <em>localhost_access_log.YYYY-MM-DD.txt</em>. Para leerlos desde Logstalgia necesitamos ejecutar el siguiente comando:</p><pre><em>tail -f localhost_access_log.YYYY-MM-DD.txt | grep logstalgia</em></pre><ul><li>Después de instalar Java, ejecutar jMeter es un problema de simplemente invocar el ejecutable descargado en <em>bin/jmeter</em>. Después de abrir jMeter, podemos abrir el plan de pruebas con extensión JMX provisto.</li></ul><p>Habiendo terminado la configuración, ¡vamos a la demostración!</p><h3>Prueba de humo</h3><p>Una prueba de humo está diseñado para tocar lo más suavemente posible cualquier endpoint de un API o sitio web. No requiere un order específico (a no ser que esté especificado por la lógica de la aplicación, como por ejemplo autenticación o flujos de compra); no tiene requisitos de idempotencia, concurrencia o repetibilidad.</p><p>Estas pruebas son simplemente diseñadas para destacar cualquier problema potencial en la implementación de los endpoints que pueda ser arreglado con facilidad antes de que el código vaya a QA o producción. De los tres tipos de prueba, este es el más usado y el que más fácil se puede integrar en un ambiente de integración continua.</p><h3><strong>¿</strong>Cómo funciona en jMeter?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/642/0*CZ6T1rn9w673v7eH" /></figure><p>jMeter maneja las pruebas de humo ejecutando un solo hilo con una sola iteración, por tanto ejecutando cada petición configurada una sola vez. En este tipo de pruebas las capacidades de jMeter están siendo subutilizadas al no tomar ventaja de sus funcionalidades multihilos.</p><p>Una cosa que usualmente se ignora cuando se construye una prueba de humo es el orden y sincronización de las peticiones. Solo por el hecho de que la prueba no tiene que representar la realidad no significa que está bien lanzar todas las peticiones a saco contra el servidor. Es recomendable adicionar un elemento Timer configurado para hacer una pausa pequeña (100ms, por ejemplo) entre petición y petición. Esto puede ayudar a evitar cosas como latencia de la red, pérdida de peticiones, tiempo de procesamiento de los servidores, timeouts y semejantes. Hay que tener en cuenta que las pruebas de humo usualmente se corren en ambientes locales o de desarrollo, que no tienen tantos recursos como un ambiente dedicado para QA, prerelease o rendimiento.</p><p>El elemento Timer, por tanto, incluye una muy necesaria pausa entre peticiones para aminorar estos efectos.</p><p>Una típica prueba de humo tiene este comportamiento:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FZR7xaPPB9TE%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DZR7xaPPB9TE&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FZR7xaPPB9TE%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="640" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/ad7ac0d040ba32171d93a5071f77152e/href">https://medium.com/media/ad7ac0d040ba32171d93a5071f77152e/href</a></iframe><p>Nótese como cada endpoint es probado uno tras otro, sin importar su funcionamiento ni posición en una secuencia de negocio. La prueba de humo es atómica, y no tiene en cuenta precedencia ni ordenamiento de los endpoints a no ser que se especifique explícitamente.</p><h3>Prueba funcional</h3><p>En contraste con las pruebas de humo, las pruebas funcionales sí se preocupan por la precedencia, el ordenamiento de los endpoints y los flujos de funcionalidad que no son estrictamente requeridos por la lógica de la aplicación. Una prueba funcional no es una prueba que simplemente toca cada endpoint, sino que trata de hacerlo en una forma que tenga sentido desde el punto de vista del usuario.</p><p>Mientras que una prueba de humo esta diseñada para encontrar errores de implementación en las funcionalidades atómicas del sistema, una prueba funcional esta diseñada para encontrar errores en la integración de dichas funcionalidades dentro de un flujo de usuario más grande.</p><p>Las pruebas funcionales pueden ser automatizadas (este es, de hecho, el principal trabajo de los especialistas de Automation) o pueden ser ejecutadas manualmente por los ingenieros de QA. En equipos más maduros puede encontrarse una mezcla saludable de pruebas de QA manuales para nuevos casos y pruebas automatizadas para encargarse de las regresiones.</p><h3>¿Como funciona en jMeter?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/484/0*l4PLQ-OvZg3uznUU" /></figure><p>El diseño de las pruebas funcional es similar al de las pruebas de humo de varias maneras: En ambas jMeter ejecuta un solo hilo y una sola iteración donde se ejecutan todos los endpoints. El principal cambio es en la agrupación de las peticiones: En vez de simplemente tocar cada endpoint uno tras otro en sucesión, una prueba funcional toca cada endpoint en sucesión lógica, de acuerdo a las necesidades del negocio. Este cambio se evidencia en la imagen siguiente, donde cada endpoint y sus recursos asociados (GIF, PNG, CSS, JS) son invocados antes de pasar al próximo endpoint.</p><p>Similar a como sucede con la prueba de humo, un Timer es usado para darle al servidor una pausa para responder y reducir la posibilidad de timeouts o peticiones perdidas.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2F-4c2ZhZYVAY%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3D-4c2ZhZYVAY&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2F-4c2ZhZYVAY%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="640" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/00a36282a1e5828f5f636392dc1ca0e4/href">https://medium.com/media/00a36282a1e5828f5f636392dc1ca0e4/href</a></iframe><p>Nótese como las peticiones se reciben una por tipo de recurso, debido a que cada grupo de recursos se agrupa por su nombre de acuerdo al simulacro de reglas de negocio del sitio utilizado. Esta prueba, al igual que las anteriores, es típicamente un solo hilo con una sola iteración.</p><p>En ciertas ocasiones una prueba funcional puede consistir en más de una ejecución de cada endpoint. Esto puede ser debido a requisitos de flujo de negocio, o para probar idempotencia o provocar ocurrencias aleatorias. En estos casos la configuración de hilo único se mantiene, pero este hilo debe ser configurado en jMeter para ejecutarse con más de una iteración en las peticiones del plan de prueba. Si solo se requiere repetir una sección, entonces esa sección se puede configurar dentro de un elemento LoopController, uno de los elementos de repetición disponibles en jMeter.</p><p>En casos aún más raros las pruebas funcionales pueden requerir un nivel muy bajo de concurrencia. Esto se hace para tratar de repetir condiciones de competencias o problemas de dependencias entre endpoints. En estos casos jMeter puede ser configurado para usar varios hilos y varias iteraciones en cada uno. Tener varios hilos con una sola iteración es arriesgarse a que ese hilo termine antes de que los otros comiencen, perdiendo la condición de prueba concurrente. Otra manera puede ser ejecutar cada hilo durante un periodo de tiempo determinado, aunque la cantidad de ejecuciones por endpoint en este caso no puede ser controlada completamente, lo cual es un problema de un tipo diferente. Elegir el trade off más conveniente forma parte del proceso de diseño.</p><p>Una prueba funcional normalmente usa unos pocos hilos (en el peor caso de 5 a 10, pero usualmente 1 ó 2). Esto significa que no hay requisitos duros de configuración multihilo, sino que quedan según la necesidad de cada sistema. Sin embargo, el requisito de configuración multihilo es duro para las pruebas de rendimiento, como veremos a continuación.</p><h3>Pruebas de rendimiento</h3><p>Estas pruebas son radicalmente diferentes de los tipos anteriores. Requieren mucho más esfuerzo de diseño, son notoriamente difíciles de automatizar, son casi exclusivamente multihilos y multi iteración, requieren muchísimo manejo de hilos y prueban idempotencia y repetibilidad de resultados. Más importante que eso, las pruebas de rendimiento esperan que ocurra una cierta cantidad de errores. Estas pruebas son, en resumen, una categoría totalmente separada de las dos anteriores.</p><p>Las pruebas de rendimiento no siempre necesitan seguir las mismas guías de negocio que las pruebas funcionales. En este sentido una prueba de rendimiento puede trabajar de la misma manera que una prueba de humo, pero con más concurrencia y carga, y con una tolerancia a errores superior a cero.</p><p>Por otro lado, algunas pruebas de rendimiento pueden seguir las guías de negocio de una prueba funciona, pero requiriendo que los flujos de negocio sean idempotentes o por lo menos, que contengan un nivel de cambio que pueda ser manejado por los elementos configurables de jMeter. Por suerte jMeter es muy flexible en cuanto a la validación de las respuestas que vienen del servidor, algunas out of the box y otras requiriendo código personalizado.</p><p>El diseño de pruebas de rendimiento es un tema extremadamente complejo que no analizaremos a profundidad. Pero es notable la manera en la que jMeter puede acomodar todos estos tipos de prueba disímiles con las mismas herramientas cada vez.</p><h3>¿Cómo funciona en jMeter?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/510/0*MSCIR1r8cU1aE-_h" /></figure><p>jMeter requiere un Timer especial para pruebas multihilos: el Constant Throughput Timer. Este elemento de configuración es especial debido a que sincroniza los parámetros de concurrencia entre todos los hilos de la prueba, no simplemente espaciar las peticiones en un hilo como un Timer estándar. Por ejemplo, mientras que un Constant Timer puede aplicar una demora fija de 400ms entre peticiones, unConstant Throughput Timer automáticamente calculará las demoras requeridas para cada hilo, de forma que la prueba en su conjunto logre un cierto objetivo de concurrencia. Estas demoras se ajustan continua y automáticamente durante el transcurso de la prueba para mantener la meta de concurrencia lo más precisamente posible. Un elemento muy conveniente y poderoso.</p><p>Mientras que teóricamente se puede hacer una prueba de rendimiento sin este Timer, eso nos llevaría peligrosamente cerca del terreno de las pruebas de estrés, que son un subtipo de las pruebas de rendimientos diseñadas para probar los limites de la capacidad de los servidores y aplicaciones, tratando de colapsarlos. Pueden ser muy similares a un ataque DDoS, los cuales también puede ser configurados en jMeter (pero por favor no lo hagan). Una prueba de rendimiento estándar, también conocida como prueba de carga, es una prueba controlada, con un espaciado entre peticiones predecible y una preparación y terminación de la carga del sistema que sigan la ley de Little. Esa es la importancia de seleccionar y configurar correctamente el tipo de Timer a usar.</p><p>El video siguiente muestra una prueba simple, de relativamente baja concurrencia:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2F1k9zpIDAI00%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3D1k9zpIDAI00&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2F1k9zpIDAI00%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="640" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/a5c38f4fa61aaffbbf2b107151fa0499/href">https://medium.com/media/a5c38f4fa61aaffbbf2b107151fa0499/href</a></iframe><p>Nótese la forma aleatoria en la cual se invocan los endpoints, así como la gran cantidad de peticiones hechas. Esta prueba en particular es una prueba con 150 hilos, en lugar de las pruebas de un solo hilo que hemos visto con anterioridad. Nótese también que se han tomado medidas para prevenir las aglomeraciones de peticiones en un periodo corto de tiempo. Las peticiones agrupadas no es un gran problema en pruebas de humo o funcionales, que tienen una pequeña cantidad de peticiones únicas. Pero en pruebas de rendimiento es absolutamente crítico mantener el alto volumen de peticiones repetidas. De otra manera, se introducen anomalías estadísticas en los resultados de las pruebas que pueden invalidar todo el ejercicio. Los Timers son de la mayor importancia para esta tarea, combinados con una herramienta de visualización que pueda integrarse con jMeter, ya sea Grafana, Kibana o Logstalgia.</p><h3>Conclusión</h3><p>Hemos mostrado la importancia del diseño de pruebas para poder utilizar apropiadamente la versatilidad de jMeter. El diseño de pruebas es un aspecto virtualmente ignorado fuera de las disciplinas de Automation y Performance, y con frecuencia no se respeta el tiempo que se necesita para realizarlo cuando se están haciendo estimaciones de tiempo para tareas de prueba. Conocer las diferencias entre los tipos de pruebas que jMeter puede manejar y cómo preparar cada una ayudará mucho a elevar la efectividad de las mismas en cada nivel del ciclo de desarrollo de aplicaciones. Espero les sea útil.</p><h3>Jorge Amado Soria, Software Engineer — <a href="https://medium.com/u/29f5296bd9a2">Nearsoft Jobs</a></h3><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1290eed14aec" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nearsoft-jobs/pruebas-automatizadas-con-jmeter-y-logstalgia-1290eed14aec">Pruebas automatizadas con JMeter y Logstalgia</a> was originally published in <a href="https://medium.com/nearsoft-jobs">Nearsoft Jobs</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Monty Hall Problem]]></title>
            <link>https://medium.com/nearsoft-jobs/the-monty-hall-problem-9046995793d9?source=rss----fa2c350e2dde---4</link>
            <guid isPermaLink="false">https://medium.com/p/9046995793d9</guid>
            <category><![CDATA[nearsoft]]></category>
            <category><![CDATA[jquery]]></category>
            <category><![CDATA[encora]]></category>
            <category><![CDATA[chartjs]]></category>
            <category><![CDATA[monty-hall-problem]]></category>
            <dc:creator><![CDATA[Jorge Amado Soria Ramirez]]></dc:creator>
            <pubDate>Thu, 13 May 2021 21:40:06 GMT</pubDate>
            <atom:updated>2021-05-13T21:40:06.172Z</atom:updated>
            <content:encoded><![CDATA[<h3>El Problema Monty Hall</h3><blockquote>El concursante debe elegir una puerta de tres. Se sabe con certeza que tras una de ellas se oculta un automóvil, y tras las otras dos hay cabras. Una vez que el concursante haya elegido una puerta, el presentador, que sabe lo que hay detrás de cada puerta, abrirá una de las dos no elegidas, mostrando una cabra. A continuación, le da la opción al concursante de cambiar de puerta o permanecer con su primera elección. ¿Debe el concursante mantener su elección original o escoger la otra puerta? ¿Hay alguna diferencia?</blockquote><p>Tratemos de resolver el problema antes de continuar leyendo. ¿Qué deberíamos hacer en esta situación? ¿Qué opción nos daría mejor chance de obtener un auto y no una cabra?</p><p>Este es el llamado <a href="https://en.wikipedia.org/wiki/Monty_Hall_problem">Problema Monty Hall</a>, un puzzle probabilístico clásico ligeramente basado en el programa de televisión americano <em>“Let’s make a Deal”</em>.</p><p>El Monty Hall es un problema en la categoría de las llamadas <em>“paradojas verídicas”</em>, un tipo de problema donde la respuesta correcta va completamente contra la intuición al punto de parecer absurda, aunque sea demostrablemente cierta.</p><p>En este caso, no hay ningún problema con la solución misma (después de todo el Monty Hall es un problema clásico ya resuelto). El mayor problema reside en la dificultad que la mayor parte de las personas presentan al aceptar la respuesta correcta… incluso después de recibir una demostración matemática de la misma.</p><h3>Solución</h3><p><strong>Los participantes que cambian de puerta tienen una probabilidad de 2 en 3 de encontrar un auto, mientras que los que mantienen su primera opción solo tienen 1 posibilidad en 3.</strong></p><p>¿Cómo es esto posible? La tabla a continuación muestra todos los posibles arreglos de “un auto, dos cabras” y los resultados de quedarse con la primera opción o cambiar de puerta:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*k_dBFzOj7mvUvRFLF_CtTg.png" /><figcaption>Mantener la selección da 1:3 posibilidades, cambiar da 2:3</figcaption></figure><p>Mantener la selección preserva la probabilidad inicial de 1:3, mientras que cambiarse aumenta las probabilidades a 2:3. Una demostración más visual puede ayudar a entender mejor esto:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*X5f4EB6tTu37NLwHBSB53g.png" /></figure><p>Como cada puerta tiene una probabilidad de 1:3 de tener un auto, la probabilidad combinada de las dos puertas no seleccionadas es de 2:3. Después de que una de estas dos puertas es abierta, la puerta que no se ha abierto contiene ahora toda la probabilidad combinada de éxito de 2:3, siendo por tanto más deseable.</p><p>¿Fácil, verdad?</p><h3>Fuentes de confusión</h3><p>Al enfrentarse con este problema por primera vez, la gran mayoría de las personas asume que cada puerta tiene la misma probabilidad de éxito todo el tiempo, y por tanto cambiar no trae consigo ninguna ventaja.</p><p>Este problema atrae la atención de científicos del conocimiento y estudiosos de la teoría de juegos. El comportamiento típico de la mayoría de las personas (quedarse con la primera opción) puede ser explicado por el <a href="https://en.wikipedia.org/wiki/Endowment_effect"><em>efecto de dotación</em></a><em> </em>(la sobreestimación del valor de un objeto que se posee contra el valor de un objeto diferente que aun no se posee; en este caso, el objeto es la puerta elegida).</p><p>Otra posible explicación puede ser el llamado <a href="https://en.wikipedia.org/wiki/Status_quo_bias"><em>sesgo de status quo</em></a><em>,</em> más popularmente conocido como “si no está roto, no lo arregles”. En este caso, significa que las personas tienden a quedarse con la selección ya hecha en vez de arriesgarse a tomar una nueva decision, a no ser que las consecuencias sean muy claras.</p><p>Otra manera muy común de equivocarse en este problema es considerar que las probabilidades están distribuidas igualmente entre todos los casos posibles. Esto hace la situación mucho más complicada, porque prima facie es soportada por la errónea conclusion de que si una persona piensa que las puertas tienen la misma probabilidad de éxito <strong>después</strong> de que una haya sido abierta, eso los haría pensar que cada puerta tiene un 50% de probabilidad de obtener un auto. Si la persona en cuestión sigue esta idea, pueden llegar a pensar que quedarse con la primera puerta o cambiar de puerta es básicamente lo mismo, lo cual, si se hace alternativamente en una serie continua de juegos con la misma frecuencia (cambiando una vez cada dos juegos, o dos veces cada cuatro, etc.) hace que la probabilidad de éxito eventualmente tienda en efecto a 50%. No se puede culpar a alguien que, obteniendo este resultado, piense que en efecto ambas puertas tienen la misma probabilidad de éxito, a pesar de que esto sea una conclusion errónea.</p><p>Como sea, en este tipo de problemas las comprobaciones empíricas son la forma más simple de obtener la realidad. Ejecutar una simulación mostrará la realidad… que es justo lo que vamos a hacer a continuación.</p><h3>Simulación</h3><p>Se dice que el famoso matemático Paul Erdõs (más conocido popularmente por el <a href="https://en.wikipedia.org/wiki/Erd%C5%91s%E2%80%93Bacon_number"><em>número Erdõs Bacon</em></a>) no se convenció de la respuesta correcta a este problema hasta que vio una simulación computarizada del mismo. Yo ciertamente no soy tan inteligente ni conozco tanto como Erdõs, pero por suerte yo puedo hacer algo que él no: crear una simulación JavaScript simple del problema para chequear la solución por mí mismo.</p><p><a href="https://monty-hall-demo.herokuapp.com/home.html">Y es justo lo que hice</a>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1AFrrbG9egyKkzHFHLCj-g.png" /><figcaption><em>Simulación de mil juegos de Monty Hall y los porcentajes correspondientes de victoria para cada caso</em></figcaption></figure><p>Esta es una página HTML con un poco de jQuery, que simula una cantidad determinable de juegos Monty Hall y muestra los resultados en 3 casos fundamentales:</p><p>· En rojo, el porcentaje de éxito si permanecemos con la primera puerta</p><p>· En azul, el porcentaje de éxito si cambiamos de puerta</p><p>· En amarillo, el porcentaje de éxito si alternamos la selección (en un juego elegimos la primera puerta, en el próximo la segunda, etc.)</p><p>Mientras más juegos se simulan, más estables se vuelven los porcentajes: 33–34% para rojo, 66–67% para azul y 49–51% para amarillo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*j3qDemP7fhTKdGiswt9tbw.png" /><figcaption>Simulación para 5 mil juegos. Las probabilidades se vuelven más estables a medida que se simulan más juegos.</figcaption></figure><p>¡Creo que hemos pasado la prueba del pudín!</p><p>El código fuente de esta pequeña simulación esta disponible en <a href="https://github.com/jorgeamadosoria/monty-hall-demo">GitHub</a>. ¡Mírenlo y diviértanse!</p><h4>Jorge Amado Soria, Software Engineer <a href="https://medium.com/u/29f5296bd9a2">Nearsoft Jobs</a></h4><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9046995793d9" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nearsoft-jobs/the-monty-hall-problem-9046995793d9">The Monty Hall Problem</a> was originally published in <a href="https://medium.com/nearsoft-jobs">Nearsoft Jobs</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Libros que deberías de considerar si quieres renovarte]]></title>
            <link>https://medium.com/nearsoft-jobs/libros-que-deber%C3%ADas-de-considerar-si-quieres-renovarte-27fb9b5ef17d?source=rss----fa2c350e2dde---4</link>
            <guid isPermaLink="false">https://medium.com/p/27fb9b5ef17d</guid>
            <category><![CDATA[book-recommendations]]></category>
            <category><![CDATA[motivation]]></category>
            <category><![CDATA[motivacional]]></category>
            <category><![CDATA[libros]]></category>
            <category><![CDATA[books]]></category>
            <dc:creator><![CDATA[Angel Morales]]></dc:creator>
            <pubDate>Thu, 13 May 2021 21:29:39 GMT</pubDate>
            <atom:updated>2021-05-13T21:29:39.622Z</atom:updated>
            <content:encoded><![CDATA[<p>Muchos de nosotros aprovechamos que inicia el año para plantearnos nuevos objetivos (llámese perder peso, leer más libros, aprender un idioma, etc.). Sin embargo, la realidad es que no tenemos por qué esperar a un año nuevo para poner manos a la obra.</p><p>En esta ocasión me gustaría compartirte qué libros me han servido en temas de productividad, relaciones sociales, comunicación e incluso han cambiado mi punto de vista y me han motivado actuar…dicho en otras palabras: <strong>me han ayudado a renovarme.</strong></p><p>No son libros técnicos sino libros prácticos que podemos aplicar en un entorno profesional y personal (¡todo el tiempo!). Sin nada más que decir, comencemos.</p><h3>Cómo ganar amigos e influir sobre las personas.</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BWYM_kHt1iAC3GgW7U693g.png" /></figure><p>Este libro ha sido etiquetado por la revista <a href="https://entertainment.time.com/2011/08/30/all-time-100-best-nonfiction-books/slide/how-to-win-friends-and-influence-people-by-dale-carnegie/">Time como uno de los 100 libros más influyentes ocupando el puesto 19.</a> ¿Podrías creer que su autor lo escribió en 1937?</p><p>A pesar de haberse publicado hace más de 85 años, <strong>Cómo ganar amigos e influir sobre las personas de Dale Carnegie</strong> contiene<strong> </strong>una serie de consejos igualmente aplicables y y vigentes en nuestros días puesto que <em>la naturaleza humana no cambia.</em></p><p>Estos consejos nos permiten mejorar las relaciones con los demás, nuestras habilidades de comunicación, como ganar aprecio, su respeto y, como su nombre lo indica, ganar amigos.</p><p>Puede que los consejos parezcan de sentido común pero es increíble que muchas personas, nosotros incluidos, caigamos en el error de no ponerlos en práctica. Eso puede explicar la toxicidad de los trabajos o en redes sociales…sin embargo, un buen antídoto es este libro.</p><h3>El club de las 5 de la mañana</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/332/1*-RmfwM-QduwK_esvNQhdoA.png" /></figure><p>Muchos hemos escuchado que la gente exitosa se levanta temprano hacer su día. Pero ¿qué serie de hábitos matutinos llevan a una persona a ser exitosa?</p><p><strong>El Club de las 5 de la mañana de Robin Sharma</strong> esta planteado como una novela donde una empresaria angustiada y deprimida en perder su negocio asiste a una conferencia motivacional del “guía” quien comparte su visión del mundo. En el evento conoce a 2 hombres: un artista quien no ha logrado despegar su carrera y un viejo excéntrico con apariencia de indigente quién asegura ser millonario. Éste último promete llevar a la empresaria y al artista a un viaje donde les compartirá sus secretos para convertirse en un rico exitoso, con suerte la empresaria y el artista podrán mejorar sus vidas.</p><p>Ahora bien, dichos secretos son aplicables para nosotros, porque de nada sirve levantarse temprano si lo primero que hacemos es ver nuestro celular. El libro nos ayudará a darnos cuenta qué áreas podemos trabajar justo después de levantarnos de la cama.</p><h3>Los 7 hábitos de la gente altamente efectiva</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/321/1*YfhYtloxtrC8NKVzgsBwTQ.png" /></figure><p>Cuando escuchamos la palabra productividad o efectividad, generalmente lo asociamos a trabajo. A producir, producir y producir.</p><p>Pero no siempre es así, podemos llevar estos conceptos a otras áreas de nuestra vida como la de ser padres y/o tener una muy buena relación con nuestros hijos o pareja. ¿Cómo lo podemos hacer?</p><p><strong>Stephen Covey </strong>comparte 7 consejos que nos ayudarán a como plantearnos nuestras metas, cómo darles una prioridad, como mejorar constantemente, cómo darnos una “misión”, porque tener una relación ganar — ganar…etc.</p><h3><strong>Hábitos atómicos</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/210/1*4oukxjiZc8yKQqZiyEl4KA.png" /></figure><p>El secreto para alcanzar nuestras metas se debe a los hábitos. En un mundo rodeado de distracciones, es difícil apegarnos a ellos.</p><p>Entonces ¿cómo le hacen las ciertas personas para ser constantes y cumplir sus metas mientras que otras no? Este best seller de <strong>James Clear, </strong>nos comparte consejos prácticos para no rendirnos con los buenos hábitos, e incluso,<strong><em> dejar aquellos que son malos.</em></strong></p><p>Además, contesta preguntas como ¿qué es el interés compuesto y qué tiene que ver con los hábitos?¿qué papel juega la motivación y el anhelo?¿qué mueve a un individuo a querer cambiar y cómo se da este proceso?</p><h3>Creativity Inc.</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/226/1*zr2-h4S8gXmliFP9tigL7Q.jpeg" /></figure><p>Uno de mis libros favoritos es <strong>Creativity Inc.</strong> de Ed Catmull, cofundador de Pixar puesto que narra la historia de esta gran empresa y los secretos de su éxito.</p><p>Y es que ¿cómo puede una empresa cuyo único “<strong><em>insumo” </em></strong>es creatividad crear<strong><em> </em></strong>películas tan exitosas y queridas como Toy Story, Buscando a Nemo, Monsters Inc., Los Increíbles…una tras otra? ¿cuál es el secreto de su éxito? ¿cómo es su cultura? ¿porqué mientras <strong>Pixar Animations</strong> le estaba yendo bien, <strong>Disney Animation Studios</strong> no?</p><p>Yo creo que este libro puede inspirarte en tu trabajo independientemente el giro que tenga tu empresa. Puesto que descubrirás que no se necesita grandes cambios o sacrificios para tener una visión exitosa como la de Pixar.</p><h3><strong>Conclusión</strong></h3><p>Las habilidades técnicas son importantes pero muchas veces podemos pasar por alto las habilidades sociales, los soft skills y la productividad. En este artículo te compartí algunos libros que nos ayudarán a ello y con suerte te inspirarán a renovarte.</p><blockquote>Claro, no bastará leerlos sino ponerlos en práctica. Teniendo humildad en reconocer en qué áreas estamos mal y necesitamos mejorar.</blockquote><p>Al final del día veremos que los beneficios de leer libros de esta naturaleza pueden ser muy satisfactorios: mejor EQ, mejores relaciones con los demás, más eficientes, productivos…etc.</p><p>¿Qué te pareció? ¿Has leído alguno de estos libros?¿Cuál te ha gustado más y porqué?¿se me escapó comentar alguno?</p><p>Espero que éste artículo te haya gustado. Si es así, te agradecería que le dieras 👍 👏 y lo compartieras a alguien que puede resultarle de utilidad.</p><p>Puedes seguirme en Twitter 🐦 como @angelmoralesk o en YouTube 🎥 donde subo videos de programación.</p><p><a href="https://www.youtube.com/channel/UCQURzUX0YhvIwzjSv5N_Fig">https://www.youtube.com/channel/UCQURzUX0YhvIwzjSv5N_Fig</a></p><p>Nos vemos en un siguiente post 😃</p><h3>Ángel Morales, Software Engineer <a href="https://medium.com/u/29f5296bd9a2">Nearsoft Jobs</a></h3><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=27fb9b5ef17d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nearsoft-jobs/libros-que-deber%C3%ADas-de-considerar-si-quieres-renovarte-27fb9b5ef17d">Libros que deberías de considerar si quieres renovarte</a> was originally published in <a href="https://medium.com/nearsoft-jobs">Nearsoft Jobs</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[De cuando intenté hacer un bot de Telegram]]></title>
            <link>https://medium.com/nearsoft-jobs/de-cuando-intent%C3%A9-hacer-un-bot-de-telegram-2c6654644bd8?source=rss----fa2c350e2dde---4</link>
            <guid isPermaLink="false">https://medium.com/p/2c6654644bd8</guid>
            <category><![CDATA[telegram-bot]]></category>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[encora]]></category>
            <category><![CDATA[programación]]></category>
            <category><![CDATA[nearsoft]]></category>
            <dc:creator><![CDATA[Thannia Blanchet]]></dc:creator>
            <pubDate>Mon, 10 May 2021 18:16:25 GMT</pubDate>
            <atom:updated>2021-05-10T18:16:25.435Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oYZXhEB6DStkwQ_iicozSA.png" /><figcaption>Dibujo para que no se vea pelón el artículo</figcaption></figure><p>En mi casa siempre salen ideas de películas que hay que ver o volver a ver y en una de esas salió la idea de hacer un bot de Telegram para ir agregando películas a la lista y ver cual seguía de poner.</p><p>Digo &quot;De cuando intenté&quot; porque ahorita tendría que correr el proyecto en mi computadora para que sirviera, así que digamos que no se concretó.</p><p>Lo siguiente lo escribo no para que aprendan a hacer un bot de Telegram, ya que el que hice digamos que puede mejorar, sino para demostrar que el trabajo mental detrás de ser developer no es necesariamente sacar código impecable de tu cabeza, como muchos creemos cuando vamos empezando.</p><p>La verdad es que jamás había intentado hacer un bot de nada pero pensé ¿Qué tan difícil puede ser? Seguro Telegram ya tiene mecanismos para hacerlo fácil… Quizá un bot igual ya exista, pero me quedó la espinita de hacerlo yo.</p><p>Bueno lo primero es que Telegram en lo que más te va a ayudar es en darte una API Key para tu bot. Siempre lo que tienes que hacer para iniciar es hablar con el BotFather, te hará algunas preguntas sobre el nombre de tu bot y al final te va a dar la API Key.</p><p>Y pues ahí fue cuando me di cuenta que necesitaba programación real para hacerlo…</p><p>Sabía los pasos de lo que quería que hiciera mi bot: Agregar y leer de una cola y poder editar. Así que como buena guerrera me puse a buscar &quot;how to make a Telegram bot&quot; en Google.</p><p>El primer resultado es un link a la documentación de Azure, pero luego luego me di cuenta que no era por ahí, porque era por si ya tenías un bot hecho en Azure, y aparte no sé qué es Azure.</p><p>Después encontré uno en Node y pensé &quot;Hey, yo sé JavaScript, puedo hacer esto&quot;. El problema es que sabía JavaScript pero no Node, así que pasé toda la tarde peleándome con el ejemplo por una variable de &quot;proccess env&quot; que, resulta, es algo de Node y sistemas de backend que yo no sabía.</p><p>Como no estaba sirviendo busqué otro ejemplo, ahora en Ruby, y dije &quot;ni pex, lo agarro y lo modifico, con que sirva&quot;, pero ni siquiera pude empezar a aprender Ruby porque nomás hacer que todo el ambiente sirviera en la Mac fue una pesadilla, como lo empecé a sentir como tarea, lo dejé así.</p><p>Al día siguiente volví a Node, pero ahora había encontrado algo bien padre: un framework llamado Telegraf que ya trae todo para trabajar con bots.</p><p>Leí algunos ejemplos y la documentación y me puse a experimentar, lo más sencillo es hacer que el bot conteste algo dependiendo de lo que le digas, pero para la tarea que me propuse necesitaba que el bot guardara información.</p><pre>bot.hears(&#39;pideme perdon&#39;, (ctx) =&gt; ctx.reply(&#39;Perdón :(&#39;));</pre><p>Lo más sencillo que se me ocurrió fue agregar y borrar de un archivo .txt, ya que ya había manejado antes el file system de Node y sabía que no era difícil (a estas alturas es más lógico simplemente escribir y borrar directo de un notepad que hacer un bot de Telegram, pero ya estaba entrada).</p><p>Así que el mentado bot creaba un archivo en mi computadora si no existía y si sí agregaba o modificaba de él la información que le dieras.</p><pre>const addMovie = new Scene(&#39;addmovie&#39;);                       addMovie.enter((ctx) =&gt; ctx.reply(&#39;¿Qué película deseas agregar?&#39;));                       addMovie.leave((ctx) =&gt; ctx.reply(&#39;Arre&#39;));                       addMovie.hears(&#39;Listo&#39;, leave());                       addMovie.hears(&#39;listo&#39;, leave());                       addMovie.on(&#39;message&#39;, (ctx) =&gt; addMovieToList(ctx));</pre><pre>async function addMovieToList(ctx) {<br>    const movieName = ctx.message.text;                         <br>try {                           <br>    fs.appendFile(&#39;peliculas.txt&#39;, `\n${movieName}`, function (err)        {                             <br>    if (err) return console.log(err);                           <br>});                           <br>await ctx.reply(`Se ha agregado ${movieName} a la cola \nEscribe otro nombre para agregar otra pelícua o &#39;listo&#39; para terminar`);                         } catch (err) {                           <br>    console.log(err)                         <br>    }                       <br>}</pre><p>Corriendo el servidor en local si le hablaba yo o alguien más al bot desde mi teléfono funcionaba como esperado; lo que debo confesar, fue muy emocionante.</p><p>El problema fue subirlo al internet y que estuviera ahí siempre corriendo y disponible, intenté con Now (ahora Vercel) pero no sirvió, además de que me quedaron bastantes dudas sobre seguridad ¿Dónde podía poner en secreto mi API key? ¿Dónde se iba a alojar ese archivo .txt?</p><p>En fin, los Devops no son mi fuerte, pero fue divertido aprender de bots.</p><h4>Thannia Blanchet, Software Engineer — <a href="https://medium.com/u/29f5296bd9a2">Nearsoft Jobs</a></h4><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2c6654644bd8" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nearsoft-jobs/de-cuando-intent%C3%A9-hacer-un-bot-de-telegram-2c6654644bd8">De cuando intenté hacer un bot de Telegram</a> was originally published in <a href="https://medium.com/nearsoft-jobs">Nearsoft Jobs</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Caso de Uso de TDD]]></title>
            <link>https://medium.com/nearsoft-jobs/caso-de-uso-de-tdd-7f6793bec7ee?source=rss----fa2c350e2dde---4</link>
            <guid isPermaLink="false">https://medium.com/p/7f6793bec7ee</guid>
            <category><![CDATA[nearsoft]]></category>
            <category><![CDATA[encora]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[tdd]]></category>
            <category><![CDATA[unit-testing]]></category>
            <dc:creator><![CDATA[Thannia Blanchet]]></dc:creator>
            <pubDate>Mon, 10 May 2021 18:06:02 GMT</pubDate>
            <atom:updated>2021-05-10T18:17:12.835Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dWowgVsu26CJI9NnyvJcsA.jpeg" /></figure><p>El Test Driven Development (Desarrollo manejado por pruebas) es una técnica de programación donde primero escribes las pruebas y luego escribes el programa para que las pase, <a href="https://cleancoders.com/episode/clean-code-episode-6-p1">el Uncle Bob lo explica mejor en uno de sus cursos</a>. Entre las ventajas del TDD se encuentra no programar de más (o cosas que no sean necesarias) y poder refactorizar sin miedo.</p><p>Esto último había sido para lo único que le había visto una clara ventaja, casi siempre que tengo que hacer pruebas pienso &quot;ugh, qué flojera, faltan las pruebas&quot;, pero si después tocaba hacer algún cambio era una maravilla ya tener las pruebas hechas y nomás correrlas para ver si el proyecto seguía sirviendo o no.</p><p>Creo que mi problema aquí es que siempre vi el TDD como un estilo de programación que sigues siempre o no, y realmente no me había topado con un momento en el que dijera &quot;ah claro, voy a hacerlo con TDD&quot;… hasta ayer.</p><p>La aplicación en la que trabajo actualmente soporta distintas maneras de mostrar tipos de cambio: Con el puro signo de dinero ($6.66), con el signo de dinero y el código después de la cantidad ($6.66 USD) y con el código antes del signo de dinero y la cantidad (USD $6.66), la intención es ampliarlo a que pueda ser el puro código de la moneda (USD 6.66) y el nombre (6.66 US dollars), así que, considerando que ya estaban las pruebas unitarias hechas para lo que ya teníamos, y conocía claramente el resultado esperado, decidí simplemente copiarlas y actualizarlas.</p><p>Así, con los mismos casos de prueba cambié el expect de &#39;$6.66&#39; a &#39;USD 6.66&#39;, por ejemplo, y las corrí.</p><p>Al principio tronaron, pero con dos o tres modificaciones AL CÓDIGO (no a las pruebas) comenzaron a pasar. Fue mucho más rápido hacer experimentos de esa manera que estar corriendo una y otra vez la aplicación y modificar el HTML a ver qué salía. Aún faltan detalles por afinar, pero lo principal del trabajo ya está hecho.</p><p>Así que no se preocupen si no hacen TDD todos los días todo el tiempo, pero ténganlo en cuenta por si alguna vez puede ser lo más apropiado para sacar rápido su trabajo.</p><h4>Thannia Blanchet, Software Engineer — <a href="https://medium.com/u/29f5296bd9a2">Nearsoft Jobs</a></h4><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7f6793bec7ee" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nearsoft-jobs/caso-de-uso-de-tdd-7f6793bec7ee">Caso de Uso de TDD</a> was originally published in <a href="https://medium.com/nearsoft-jobs">Nearsoft Jobs</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Torres de Hanoi, un algoritmo clásico]]></title>
            <link>https://medium.com/nearsoft-jobs/torres-de-hanoi-un-algoritmo-cl%C3%A1sico-26a722c58539?source=rss----fa2c350e2dde---4</link>
            <guid isPermaLink="false">https://medium.com/p/26a722c58539</guid>
            <category><![CDATA[nearsoft]]></category>
            <category><![CDATA[algoritmos]]></category>
            <category><![CDATA[encora]]></category>
            <category><![CDATA[hanoi-tower]]></category>
            <dc:creator><![CDATA[Jorge Amado Soria Ramirez]]></dc:creator>
            <pubDate>Mon, 10 May 2021 18:03:53 GMT</pubDate>
            <atom:updated>2021-05-10T18:03:53.851Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/425/0*8FRMgHMAvlCXQsQ8.jpg" /><figcaption>juguete clásico de las torres de Hanoi</figcaption></figure><p>Las Torres de Hanoi son un juego de niños antiquísimo, pero todavía usado.</p><p>Tradicionalmente consiste en tres postes verticales. En uno de los postes se apila un número indeterminado de discos (la variante más sencilla tiene 3 discos), todos diferentes y ordenados de mayor a menor desde la base.</p><p>El juego consiste en pasar todos los discos del poste inicial a otro, según tres simples reglas:</p><ol><li><em>Se puede mover solo el disco que se encuentre más arriba en cada poste.</em></li><li><em>Todos los discos deben estar en algún poste en todo momento.</em></li><li><em>Un disco mayor no puede moverse sobre uno más pequeño.</em></li></ol><p>Por divertido que sea este rompecabezas para niños, es relevante para nosotros de otra manera.</p><p>Las Torres de Hanoi son un algoritmo clásico muy utilizado en la docencia de algoritmia y técnicas de programación para demostrar el uso de la recursividad.</p><h3>Solución Recursiva</h3><p>La solución recursiva es relativamente simple de conceptualizar:</p><ol><li>Nombrar las varillas como <em>origen</em> (la varilla con los discos), <em>auxiliar</em> y <em>destino</em>.</li><li>Si queda por mover un solo disco, moverlo a la varilla <em>destino,</em> y el algoritmo termina<em>.</em></li><li>Mover todos los discos excepto el último a la varilla <em>auxiliar</em>. Esta es la primera llamada recursiva.</li><li>Mover el último disco a la varilla <em>destino</em>.</li><li>Renombrar las varillas: de <em>origen</em> a <em>auxiliar</em>, y viceversa.</li><li>Repetir desde el paso 2. Esta es la segunda llamada recursiva.</li></ol><p>Varias simulaciones y explicaciones en video de esta solución se pueden encontrar en Youtube. Personalmente me gusta esta, en inglés pero muy corta y animada:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FYstLjLCGmgg%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DYstLjLCGmgg&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FYstLjLCGmgg%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/6f73c4f19408a5325407a3c192bd26f1/href">https://medium.com/media/6f73c4f19408a5325407a3c192bd26f1/href</a></iframe><p>Cuando estudiaba, nunca pude usar las Torres para aprender recursividad. No es exactamente el ejemplo más obvio (La secuencia de Fibonacci es mucho más evidente, para empezar) pero nunca pude completamente sacármela de la cabeza hasta que no encontrase otra solución que no fuera recursiva.</p><p>Y bueno, aquí está.</p><h3>Solución iterativa</h3><p>Para la solución iterativa es útil considerar los postes en posición circular, en lugar de la tradicional disposición en línea:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/762/0*k-8TgRIgBP844tYx.jpg" /><figcaption>una disposición alternativa de las torres de Hanoi</figcaption></figure><p>Después de este ajuste, la solución es sorprendentemente simple:</p><ol><li>Decidir una dirección (a favor o en contra de las manecillas del reloj). El disco más pequeño siempre debe moverse en esta dirección.</li><li>Mover el disco más pequeño. Si hay una cantidad de discos impar, el poste al que se mueva el disco más pequeño es el poste donde terminarán estando todos los discos al final de la solución. Si hay una cantidad par, los discos terminarán en el otro poste.</li><li>Mover el único disco posible aparte del más pequeño.</li><li>Mover el disco más pequeño al próximo poste en la dirección seleccionada.</li><li>Repetir pasos 3 y 4 hasta que los discos se hayan movido al poste destino.</li></ol><p>Como se puede apreciar, la solución iterativa requiere menos abstracción, y es más simple de hacer manualmente. Incluso como algoritmo tiene algunas ventajas: Usa menos memoria que un stack de llamadas recursivas (permitiendo un número mayor de discos que la solución éstandar) y es bastante más simple de programar.</p><p>Además, no hay ninguna diferencia en la cantidad de movimientos entre la versión recursiva e iterativa dado que ambas resuelven el problema en la cantidad óptima de pasos: 2<em>ⁿ</em>-1, donde <em>n</em> es la cantidad de discos.</p><p>Claro que eso habría que demostrarlo, por lo tanto…</p><h4>Demo</h4><p>Para demostrar la solución iterativa, programé una <a href="https://hanoi-demo.herokuapp.com/">pequeñita pagina HTML</a> con un mínimo de Javascript (y un mínimo de esfuerzo en el diseño, sorry):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/768/1*0mfQ0TcqOFh2e3et5dy41w.gif" /></figure><p>El demo permite simular una solución al problema de las torres de Hanoi de manera iterativa para problemas de hasta 10 discos, con una demora variable para poder apreciar mejor el movimiento de cada disco. Además, incluye algunos links con información adicional para aprender más sobre las soluciones posibles al problema.</p><p>Esta página usa <a href="https://interactjs.io/">https://interactjs.io/</a>, una pequeña librería de Javascript que permite entre otras cosas adicionar drag-and-drop. Gracias a esto también es posible intentar una solución manual a la situación planteada, para que el usuario intente replicar los pasos de la solución automatizada, con propósitos educativos.</p><p>Finalmente, el código calcula la cantidad de movimientos que el usuario o el algoritmo han hecho hasta el momento, para que pueda compararse con la cantidad óptima de movimientos según la cantidad de discos (mostrada en la esquina superior derecha).</p><p>Por supuesto, el código está disponible en <a href="https://github.com/jorgeamadosoria/hanoi-demo">Github</a> para cualquiera que quiera consultarlo. Happy learning!</p><h4>Jorge Amado Soria, Software Engineer — <a href="https://medium.com/u/29f5296bd9a2">Nearsoft Jobs</a></h4><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=26a722c58539" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nearsoft-jobs/torres-de-hanoi-un-algoritmo-cl%C3%A1sico-26a722c58539">Torres de Hanoi, un algoritmo clásico</a> was originally published in <a href="https://medium.com/nearsoft-jobs">Nearsoft Jobs</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[NextGen JavaScript]]></title>
            <link>https://medium.com/nearsoft-jobs/nextgen-javascript-90d1590ef85c?source=rss----fa2c350e2dde---4</link>
            <guid isPermaLink="false">https://medium.com/p/90d1590ef85c</guid>
            <dc:creator><![CDATA[José Navarro]]></dc:creator>
            <pubDate>Thu, 28 Jan 2021 04:49:52 GMT</pubDate>
            <atom:updated>2021-01-28T04:49:52.755Z</atom:updated>
            <content:encoded><![CDATA[<h4>¿Qué es NextGen JavaScript y qué nuevas funcionalidades nos brinda?</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZzKbKghujJc0D-HvgeyDIA.jpeg" /></figure><p>JavaScript es uno de los lenguajes más utilizados y actualmente de los más pedidos en empresas de desarrollo de software. Por esto es importante conocer y entender las nuevas características que se introducen conforme pasan los años. En este post hablaré de la siguiente generación de JavaScript, mejor conocido como NextGen JavaScript y las nuevas características que podemos encontrar en él.</p><h4>¿Qué es JavaScript?</h4><p>JavaScript (JS) es un lenguaje de programación interpretado, orientado a objetos, débilmente tipado y dinámico. Se utiliza principalmente para permitir interactuar con las páginas web mediante el uso de scripts. JavaScript está presente en muchas de las páginas que usamos en nuestro día a día, ya que este se usa para presentar cosas como fechas y calendarios, mostrar un pdf en nuestra página, crear alertas o “pop ups”, entre otras cosas.</p><h4>NextGen JavaScript</h4><p>Ahora bien, JavaScript avanza día a día con nuevas características que permiten manejar ciertas funciones de una mejor forma, es por eso que en artículos se suele hablar de la nueva generación de JavaScript, mejor conocido como <strong>NextGen JavaScript</strong>, el cual hace referencia a la última versión de JavaScript que se está utilizando. Específicamente, NextGen JS se refiere a la última versión de ECMAScript, que es el estándar utilizado por JS para asegurar la interoperabilidad de las páginas web a través de distintos navegadores. Actualmente se utiliza la versión ES6, la cual contiene nuevas características que hacen a JS un lenguaje más claro y compacto a la hora de programar. A continuación se enlistan algunas de las más importantes.</p><h4><em>Palabras reservadas: let y const</em></h4><p>Anteriormente, solo la palabra <em>var</em> se utilizaba para definir variables. Esta era asignada globalmente y solo podía ser utilizada en la función en la que se declaraba. Con NextGen JS, ahora tenemos dos formas de declarar variables: <strong><em>let </em></strong>y <strong><em>const</em></strong>.</p><p><strong>let </strong>permite definir variables en un cierto alcance, esto dependiendo de dónde es declarada. Es decir, si esta se declara dentro de una función, la variable será solamente accesible dentro de esa función. Por ejemplo:</p><pre>let x = 20<br>miFuncion = function () {<br>    let x = 10<br>    console.log(x)<br>}</pre><pre>miFuncion()<br>console.log(x)</pre><p>La salida en la terminal sería:</p><pre>10<br>20</pre><p>Dentro de la función tiene un valor, fuera de ella tiene otro.</p><p><strong>const </strong>son variables que no cambiarán de valor; serán constantes a través de todo el programa y no serán reasignadas. Actúa similar a la palabra reservada “final” en Java.</p><h4>Funciones flecha</h4><p>Las funciones flecha o “<strong>arrow functions</strong>” por su nombre en inglés, es una sintaxis nueva para escribir funciones en JavaScript. En el ejemplo anterior se mostró una función como normalmente se declaran en JavaScript, pero con la sintaxis de flecha podemos omitir usar la palabra “function”:</p><pre>let miFuncion = () =&gt;  {<br>     let x = 10<br>     console.log(x)<br>}</pre><p>En donde los paréntesis se utilizan para pasar los argumentos necesarios a la función. En el caso de que sea solo un argumento, se pueden omitir los paréntesis y poner directamente éste. Además, si la función solamente retorna una salida, las funciones se pueden simplificar mucho más utilizando esta sintaxis, por ejemplo:</p><pre>let miFuncion = () =&gt; console.log(“Hello!”)</pre><p><strong>Palabras reservadas: import y export</strong></p><p>Estas funciones permiten manejar y editar módulos fácilmente. Se pueden exportar archivos donde algunas de sus funcionalidades son necesarias en otros módulos, esto permitiendo la reusabilidad de código. Si se desea exportar una sola función de un archivo, podemos usar la siguiente sintaxis con la palabra reservada <strong>export default</strong> y el nombre de la función:</p><pre>export default miFuncion</pre><p>En el caso de que sea necesario exportar más de una función, se utiliza lo que se llama “export nombrado”, en donde a cada export se le asigna un nombre:</p><pre>export const funcion1<br>export const funcion2</pre><p>Para importar estas funciones en otros archivos, se usa la siguiente sintaxis:</p><pre>import miFuncion from &#39;./archivo&#39;</pre><p>Si se están importando varias funciones de un solo archivo se utilizan llaves, donde dentro de ellas se encuentran todas las funciones a importar:</p><pre>import { funcion1, funcion2 } from &#39;./archivo&#39;</pre><p>En el caso de que se desea importar todas las funciones exportadas, se puede utilizar el carácter <strong>* </strong>para importar todas las funciones al archivo, donde se le tiene que dar un nombre:</p><pre>import * as nombreFunciones from &#39;./archivo&#39;</pre><p>Para hacer el llamado a una función en específico dentro de ese conjunto de funciones, se utiliza la siguiente sintaxis:</p><pre>nombreFunciones.funcion1()</pre><h4>Clases</h4><p>Para la creación de la estructura de los objetos de JavaScript se utilizan las <strong>clases</strong>. Anteriormente, las clases necesitaban de un constructor para poder visualizar su contenido, ya sean propiedades o métodos:</p><pre>class carro {</pre><pre>     constructor() {<br>     this.nombre=”Malibu”;<br>     }<br>}</pre><pre>const miCarro = new carro();<br>console.log(miCarro.nombre);</pre><p>Con esto, en la salida tendríamos en la consola la cadena “Malibu”. En la nueva generación de JS, podemos omitir la función constructora y llamar directamente las propiedades dentro de la clase, simplificando la sintaxis a la hora de crear clases:</p><pre>class carro {<br>     this.nombre=”Malibu”;<br>     }<br>}</pre><pre>const miCarro = new carro();<br>console.log(miCarro.nombre);</pre><h4>Operadores: rest y spread</h4><p>El operador <strong>spread</strong> es utilizado para separar objetos o una colección de datos para crear nuevos objetos o arreglos a partir de ellos. Este es representado por tres puntos (…). Un ejemplo fácil de comprender es mediante arreglos:</p><pre>const a = [1, 2, 3, 4];<br>const b = [5, 6, 7, 8];<br>const comb = [...a,...b];</pre><pre>console.log(comb);</pre><p>En donde la salida sería un arreglo con los elementos de los arreglos anteriores:</p><pre>[1,2,3,4,5,6,7,8]</pre><p>Esto facilita y simplifica la sintaxis para concatenar dos arreglos u objetos. Aún se puede utilizar el método “concat” que permite concatenar dos arreglos, aunque esto suele ser más complicado comparado a utilizar el nuevo operador spread.</p><p>El operador <strong>rest </strong>es representado de la misma forma que el operador spread (…), sin embargo, este se utiliza para juntar múltiples argumentos de una función en un solo arreglo. Esto permite manejar fácilmente funciones que requieren de muchos argumentos, sin mencionar que la sintaxis es mucho más clara y compacta. Por ejemplo:</p><pre>function miFuncion(...args) {<br>     for (let arg of args) {<br>        console.log(arg);<br>     }<br>}</pre><pre>miFuncion(“a”,”b”,”c”)</pre><p>De esta forma, los argumentos que se pasan a la función se pasan como un arreglo, el cual puede ser accedido mediante un índice (en este caso arg). En las funciones flecha no se puede utilizar este operador, pero en vez de él, tiene lo que se llaman <strong>parámetros rest</strong>. Estos funcionan como los argumentos normales que conocemos, pero en vez de almacenar solamente un argumento, almacena los que tú deseas a partir de cierto argumento. Esto se puede ver fácilmente con un ejemplo:</p><pre>let miFuncion = (arg1, arg2, ...listaArg) =&gt; {<br>     console.log(arg1)<br>     console.log(arg2)<br>     console.log(listaArg)<br>}</pre><pre>miFuncion(“Mayonesa”, “Mostaza”, “Galletas”, “Pollo”, “Carne”)</pre><p>En la terminal aparecería lo siguiente:</p><pre>Mayonesa<br>Mostaza<br>(3)[“Galletas”, “Pollo”, “Carne”]</pre><p>En este caso, arg1 y arg2 tomaran el valor de “Mayonesa” y “Mostaza” respectivamente, mientras que listaArg, tomará el resto de los argumentos (“Galletas”, “Pollo”, “Carne”) y los almacena en un arreglo, de la misma forma que en el ejemplo anterior.</p><h4><strong>Conclusión</strong></h4><p>Las nuevas funciones presentadas por la nueva generación de JavaScript facilitan y, sobre todo, simplifican la sintaxis en varias características que son muy utilizadas en este lenguaje. Conocer estas características no solamente ayuda a que tu código sea más fácil de entender, pero te puede ahorrar mucho tiempo conforme avances en cualquier proyecto en el que utilizas JS. Además, como developers, aprender nuevas características y actualizarse en ellas, ayuda a encontrar opciones de trabajo mucho más rápido y adaptabilidad en esos mismos.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=90d1590ef85c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nearsoft-jobs/nextgen-javascript-90d1590ef85c">NextGen JavaScript</a> was originally published in <a href="https://medium.com/nearsoft-jobs">Nearsoft Jobs</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[10 Comandos UNIX que todo programador debería conocer]]></title>
            <link>https://medium.com/nearsoft-jobs/10-comandos-unix-que-todo-programador-deber%C3%ADa-conocer-579d7cbe2013?source=rss----fa2c350e2dde---4</link>
            <guid isPermaLink="false">https://medium.com/p/579d7cbe2013</guid>
            <category><![CDATA[unix]]></category>
            <category><![CDATA[programación]]></category>
            <category><![CDATA[comandos]]></category>
            <category><![CDATA[macos]]></category>
            <category><![CDATA[linux]]></category>
            <dc:creator><![CDATA[Omar Bautista]]></dc:creator>
            <pubDate>Thu, 28 Jan 2021 01:03:49 GMT</pubDate>
            <atom:updated>2021-01-28T01:03:49.127Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6wlQhci1Pot4BWUPDpHbfw.jpeg" /></figure><p>Cuando hablamos de programación es casi inevitable tener que hacer uso de comandos ya sea en el CMD de Windows o en la Terminal de los sistemas Unix como Mac o Linux, estos últimos siendo los más populares y esto es porque Linux domina los servidores donde nuestras aplicaciones son desplegadas a lo largo y ancho del mundo.</p><p>Los servidores que almacenan y corren nuestras aplicaciones en el mundo contienen normalmente alguna distribución de Linux pero sin interfaz gráfica, es por ello que cuando queremos depurar nuestra aplicación es necesario conocer algunos comandos bastante útiles, a continuación les mostraré algunos de los que más comúnmente utilizo en mi día a día, comencemos.</p><h3>Listar directorios</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*0fns7syZ18_1xD-Q.png" /></figure><p>El comando <strong>ls</strong> nos sirve para listar el contenido de una carpeta, al ser un comando puede recibir varios argumentos, la estructura completa del comando <strong>ls </strong>es la siguiente.</p><pre>ls [OPTIONS] [FILES]</pre><p>Con este comando también podemos listar las propiedades de los archivos y carpetas dentro de un directorio con el parámetro -<strong>l</strong> el cuál desplegará información sobre:</p><ul><li>Tipo (si es carpeta iniciara con la letra <strong>d</strong> de <strong>directory</strong> en caso contrario un <strong>-</strong>)</li><li>Permisos</li><li>Dueño y grupo del archivo o carpeta</li><li>Tamaño del archivo</li><li>Fecha</li><li>Nombre</li></ul><p>Ahora bien vamos a ver algunas de las cosas que podemos hacer, por ejemplo listar en formato <strong>human readable</strong></p><pre>ls -lh</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*cSPFLNLSJNj6MLxK.png" /></figure><p>El parámetro <strong>l</strong> indica que queremos ver los resultados en formato lista, la <strong>h</strong> indica que queremos en formato <strong>human readable, </strong>ahora bien veamos como podemos listar un directorio en formato <strong>human readable</strong> y que además nos incluya los archivos ocultos de la carpeta</p><pre>ls -lha random-password</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*krr5bYexa-PYi-Hd.png" /></figure><p>Cómo podemos observar al agregar el parámetro <strong>a</strong> de <strong>all</strong> nos muestra todo el contenido de la carpeta, esto incluyes los archivos ocultos y también le estamos enviando al final cual es la carpeta de la que queremos listar el contenido en este caso <strong>random-password</strong></p><h3>Saber en qué directorio te encuentras</h3><p>Has ejecutado un montón de comandos y de repente ya no sabes donde te encuentras, o simplemente quieres ver el path completo de tu ubicación porque la necesitas para ejecutar otro comando, simplemente basta con utilizar el comando</p><p>El resultado será que te devolverá la ruta absoluta del directorio en el que te encuentras.</p><pre>pwd</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*K04amKvdmG6KDpbX.png" /></figure><h3>Entrar o moverse a un directorio</h3><p>Esta es una de las operaciones básicas que más se utilizan</p><pre>cd [RUTA_DEL_DIRECTORIO]</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*jhgkb4scg9214Gxm.png" /></figure><p>Para regresar al directorio del usuario basta con ejecutar el comando sin argumentos</p><pre>cd</pre><p>Si queremos ir un directorio abajo</p><pre>cd ..</pre><p>Si queremos movernos a un directorio que se encuentra uno o varios niveles abajo</p><pre>cd ../level1</pre><h3>Saber el ID de algún proceso en ejecución</h3><p>Hay ocasiones en que necesitamos encontrar el ID de un proceso por alguna razón, monitorearlo o quizá eliminarlo o incluso simplemente saber que realmente se está ejecutando, para esto es bastante útil el siguiente comando</p><pre>ps aux | grep &lt;NOMBRE-PROCESO-PARCIAL&gt;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*7NGrUHa64vee_n-t.png" /></figure><p>En este caso estoy buscando la ejecución de un proceso <strong>java</strong>, la información que nos muestra es una lista de los procesos y quién fue el que lo ejecutó, enseguida nos muestra el <strong>PID</strong> (process ID) también nos muestra desde donde ha sido invocado y con qué parámetros que es todo lo que podemos ver después de la hora de ejecución.</p><p>En este caso vemos 2 procesos, uno como tal es una consola de Groovy que utiliza Java por y su PID es <strong>3906</strong> el cual se muestra en la imagen remarcado, el segundo es el PID <strong>3925</strong> este es el comando que acabamos de ejecutar.</p><h3>Terminar la ejecución de un proceso</h3><p>Utilizando el comando anterior podemos ahora ejecutar un comando para terminar con la ejecución de uno o varios procesos.</p><pre>kill [PIDs separados por espacios]</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*A-vFCsccIsZDed00.png" /></figure><p>En este caso estoy utilizando el mismo proceso del ejemplo anterior, el comando <strong>kill </strong>tratará de terminar el proceso de una forma correcta y dándole la instrucción al mismo de que es tiempo de terminar la ejecución, pero los procesos a veces pueden ser rebeldes y estar causando un error en la matrix confabulando para comerse todos los recursos de nuestra maquina, para esto podemos usar el método Chuck Nurris y matar el proceso con una patada voladora de la siguiente manera.</p><pre>kill -9 [PID separados por espacios]</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*m7Au-XwMc3s4KbXV.png" /></figure><p>En este caso el parámetro <strong>-9</strong> representa que queremos forzar la terminación del proceso sin esperar a que este lo haga de forma correcta, es decir lo terminamos de manera abrupta.</p><h3>Crear un directorio</h3><p>Este comando es bastante útil para crear directorios. Es bastante simple:</p><pre>mkdir [OPTIONS] [NAME]</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*7dNqdy5XDVpeKDmV.png" /></figure><p>También podemos crear un directorio con subdirectorios utilizando el parámetro <strong>-pv</strong> en este caso el resultado será el siguiente.</p><pre>mkdir -pv level1/level2</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*lLreTeqAjO2A21ZB.png" /></figure><p><strong><em>Nota:</em></strong><em> el comando </em><strong><em>tree</em></strong><em> no es un comando como tal de Unix si no una herramienta que tengo instalada en mi terminal.</em></p><h3>Crear Archivos</h3><p>No hay mucho que decir, es tan simple como tocar un archivo y darle un nombre de la siguiente forma.</p><pre>touch [NOMBRE_DEL_ARCHIVO]</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*BuqXcQ-MyUzbKsLM.png" /></figure><p>También podemos escribir en un archivo con el comando <strong>echo </strong>de la siguiente manera.</p><pre>echo &quot;Este es un ejemplo&quot; &gt;&gt; README.md <br>tail README.md</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*lITTxYOKhkUxPLZk.png" /></figure><h3>Eliminar archivos o directorios</h3><p><strong>Durante la elaboración de este post accidentalmente</strong> borré el contenido de una carpeta donde tenía mis proyectos experimentales, siempre es importante que se aseguren de que lo que van a borrar sea realmente lo que quieren, sobre todo si se trata de una carpeta entera, aprendan de mis errores.</p><pre>rm [OPTIONS] [Directorios o archivos separados por espacios]</pre><p>Explicare primero las opciones de este comando:</p><ul><li><strong>Sin opciones</strong>, para borrar algún archivo</li><li><strong>-f</strong> para forzar la eliminación de un archivo</li><li><strong>-r</strong> cuando se quiere eliminar una carpeta y su contenido</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*zdaSq8dfWw5dbGzz.png" /><figcaption>Borrar archivo</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*e6tb-1sxY71ZJr5I.png" /><figcaption>Borrar carpeta, subcarpetas y archivos</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*qfKAs2KxVWtV8gvH.png" /><figcaption>Borrar carpeta, subcarpetas y archivos de manera forzada</figcaption></figure><p><strong>Nota: </strong>Es super importante que sepas que cuando borras algo con el comando <strong>rm </strong>este<strong> </strong>contenido<strong> no puede recuperarse</strong> a menos claro que tengas alguna herramienta que busque entre los residuos que puedan quedar en el disco duro, lo cual veo poco probable y práctico, así que todos los comando de eliminación <strong>deben de ejecutarse con extrema precaución.</strong></p><h3>Mover archivos o carpetas</h3><p>Hay ocasiones en las que queremos mover un archivo o carpeta o incluso renombrarlos, para esto podemos utilizar el comando <strong>mv </strong>este comando es bastante simple.</p><pre>mv [ORIGEN] [DESTINO]</pre><p>Veamos el siguiente ejemplo donde movemos un archivo en la siguiente estructura de archivos.</p><pre>shell <br>├── folder1 <br>│   └── README.md <br>└── folder2</pre><p>Lo que queremos es mover el archivo <strong>README.md</strong> del folder1 al folder2</p><pre>mv folder1/README.md folder2</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*YbMnyVjrLL_Y86oV.png" /></figure><p>Ahora bien vamos a renombrar el directorio folder1 a level1</p><pre>mv folder1 level1</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*bWNx3aJExTSOpgSx.png" /></figure><h3>Observar el contenido de un archivo mientras se agrega contenido en tiempo real</h3><p>Este comando en particular es uno de los que más utilizo en mi día a día, sirve para poder observar por ejemplo los logs de una aplicación a medida que se van generando.</p><p>Este comando nos mostrará la cola de los archivos, es decir, lo último que se ha escrito en este, primero describamos el comando y veamos algunos ejemplos.</p><pre>tail [OPTIONS] [NOMBRE_DEL_ARCHIVO]</pre><p>Dentro de las opciones podemos decir cuantas líneas queremos ver, por ejemplo:</p><pre>tail -10 out.log</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*2vbwFSPf5Z4ch9ec.png" /></figure><p>Ahora veamos cómo podemos ir viendo en tiempo real cuando se agrega contenido a este archivo, para eso utilizaremos el parámetro <strong>-f</strong> de <strong>follow</strong> de la siguiente forma:</p><pre>tail -0f out.log</pre><p>Aquí estoy utilizando el <strong>0 </strong>junto con la <strong>f </strong>por que no quiero ver nada de lo que ya está generado si lo que se va a generar entonces no quiero ver ninguna línea anterior.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*geiEeKye-83mBJKd.png" /></figure><p>Lo que estoy haciendo en este ejemplo es simular cómo es que otro proceso escribe un un archivo y yo estoy monitoreando la actividad en dicho archivo con el comando tail.</p><p>Muchas gracias por leerme, recuerda que también tengo un canal de <a href="https://www.youtube.com/user/Joxebus">YouTube</a> donde hablo de cosas de tecnología y actualmente estoy creando un curso de Groovy desde cero, te invito a que me sigas.</p><h3>Omar Bautista, Software Engineer</h3><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=579d7cbe2013" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nearsoft-jobs/10-comandos-unix-que-todo-programador-deber%C3%ADa-conocer-579d7cbe2013">10 Comandos UNIX que todo programador debería conocer</a> was originally published in <a href="https://medium.com/nearsoft-jobs">Nearsoft Jobs</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Dropbox + Java: una alternativa gratuita a AWS]]></title>
            <link>https://medium.com/nearsoft-jobs/dropbox-java-una-alternativa-gratuita-a-aws-32ee4de598de?source=rss----fa2c350e2dde---4</link>
            <guid isPermaLink="false">https://medium.com/p/32ee4de598de</guid>
            <category><![CDATA[aws-s3-alternatives]]></category>
            <category><![CDATA[free-file-storage]]></category>
            <category><![CDATA[javaexamples]]></category>
            <category><![CDATA[desveloper]]></category>
            <category><![CDATA[java-and-dropbox]]></category>
            <dc:creator><![CDATA[Omar Bautista]]></dc:creator>
            <pubDate>Thu, 28 Jan 2021 00:37:28 GMT</pubDate>
            <atom:updated>2021-01-28T00:37:28.454Z</atom:updated>
            <content:encoded><![CDATA[<h3>Dropbox + Java: una alternativa gratuita a S3 de AWS</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*CClSjkUht_wUYo_Sf41G2A.png" /></figure><p>Hace un tiempo estaba buscando una alternativa para un proyecto personal donde necesitaba subir imágenes, no podemos negar que AWS ofrece una gran cantidad de servicios y entre ellos ofrece buckets para almacenar nuestros archivos en la nube. Sin embargo, digamos que mi presupuesto era algo limitado <strong>($0). </strong>Dado que solo estaba haciendo una prueba de concepto me daba igual donde se guardaran mis archivos pero quería poder subirlos para poder probar mis funcionalidades.</p><p>Heroku te permite subir archivos de forma gratuita pero el filesystem se limpia cada 24 horas (si mal no recuerdo) y esto provoca que no sea una buena alternativa para subir imágenes que después quieres recuperar, digamos si estas haciendo un blog o subiendo una foto de perfil. Seguí investigando, intente con Google Drive pero la implementación no era tan amigable, AWS era demasiado caro, hasta que recordé que tenía una vieja cuenta de <a href="http://dropbox.com/"><strong>Dropbox</strong></a> y fue ahí donde pensé que quizá tenía algún tipo de API para desarrolladores que me permitiera guardar mis archivos y recuperarlos de una forma sencilla y gratis. ¡<strong>BINGO!</strong></p><h4>Descargar el proyecto de ejemplo</h4><p>Después de haberlo logrado me dí a la tarea de sacar lo más esencial del código Java y lo puse en una simple aplicación la cual únicamente sube, lista y descarga archivos. A manera de ejemplo puedes descargar el proyecto por acá para que me sigas con la configuración.</p><p><a href="https://github.com/Joxebus/DropboxFileUploader">Joxebus/DropboxFileUploader</a></p><p>El código es bastante sencillo es un proyecto Java 8 / Maven con sólo 2 clases por lo que puedes abrirlo en tu IDE favorito:</p><pre>git clone <a href="/service/mailto:git@github.com">git@github.com</a>:Joxebus/DropboxFileUploader.git</pre><h4>Configurando la cuenta de Dropbox y la app</h4><p>Primero que nada tenemos que configurar nuestra cuenta de Dropbox creando una aplicación para que pueda acceder a nuestros archivos. Para ello dirigete a la siguiente liga <a href="https://www.dropbox.com/developers/">https://www.dropbox.com/developers/</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bcrZ4o85-Z1LFb2gKzQBgw.png" /></figure><p>Una vez ahí da click sobre el botón <strong>Consola de aplicaciones, </strong>te abrirá otra ventana en donde tendrás que dar click sobre el botón <strong>Create app</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/661/1*aLRxOM5J1fe2f6Y6twE2kQ.png" /></figure><p>A continuación te aparecerá un listado donde tendras que seleccionar las siguiente opciones:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/434/1*rXPAJJHQW8E6Gf_y0S-JfQ.png" /></figure><ul><li>Scoped access</li><li>App Folder <strong>(únicamente queremos poder acceder al folder de la app)</strong></li><li>Ingresa en nombre de la aplicación</li><li>Acepta los términos y condiciones <strong>(leelos antes para estar seguro que comprendes las implicaciones)</strong></li></ul><p>Una vez terminando las acciones anteriores y tras haber aceptado los términos y condiciones te actualizará la página donde en la pestaña <strong>Settings</strong> deberás seleccionar las opciones <strong>No expiration </strong>(para Access Token Expiration) y después darás click en <strong>Generate</strong> (no compartas este <strong>TOKEN ACCESS</strong> con nadie copia el TOKEN ya que este lo utilizaremos después).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/220/1*aDbpM0OmpPd9dpt6adLFCA.png" /></figure><p>Una vez que ya tengas estos datos ve a la pestaña de <strong>Permissions</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/459/1*SH_vT9VfS-mYrlzhMJBp-A.png" /></figure><p>Aquí vamos a configurar los permisos de la aplicación, para este ejemplo necesitamos poder <strong>leer y escribir en los directorios</strong>, con esta selección también podremos listar el contenido de nuestra carpeta.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/722/1*17x9RfqWDXeuoSVyt0r7sg.png" /></figure><p>Por último vamos a la pestaña de <strong>Branding</strong> y aquí ponemos la información relevante de nuestra aplicación como en la imagen que se muestra a continuación.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1btBHCHoJpf5CHNJJM8tGQ.png" /></figure><p>Ahora si vamos a probar nuestro código.</p><h4>Configurando el proyecto Java</h4><p>Primero abrimos el proyecto que clonamos al inicio. Ahí se encuentra una clase llamada <strong>FileUploaderService </strong>en ella vamos a reemplazar algunos datos con la siguiente información:</p><pre>String <em>DROPBOX_TOKEN_ACCESS </em>= &quot;valor-del-token&quot;;<br><br>String <em>DOWNLOAD_FOLDER </em>= &quot;/tu/directorio/de/descargas&quot;;</pre><p>Cabe destacar que esta aplicación no está haciendo uso de variables de entorno para leer estas configuraciones para que sea más sencillo de comprender, pero si es necesario cambiar esto en tu propia implementación para que no reveles tu <strong>TOKEN</strong> de forma pública.</p><p>Para leer una variable de entorno lo puedes hacer de la siguiente forma:</p><pre>String variableDeEntorno = System.getenv(&quot;MI-VARIABLE&quot;)</pre><p>El directorio que utilices en la variable <strong>DOWNLOAD_FOLDER</strong><em> </em>para guardar los archivos descargados puede ser el de tu elección pero tiene que existir, <strong>esta implementación no está creando el directorio en caso de que no exista</strong> (en una próxima versión iré subiendo mejoras por lo que te recomiendo que te suscribas al repositorio).</p><p>Ahora bien, basta con que ejecutemos la clase <strong>FileUploaderMain </strong>la cual contiene el punto de entrada de este ejemplo, lo que hará es subir los archivos que se encuentran en el directorio <strong>src/resources</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/196/1*8K1X4fC2SbUz-OGQ6TaLDQ.png" /></figure><p>Posteriormente hará una descarga de los mismos en el directorio que hayas indicado en la variable <strong>DOWNLOAD_FOLDER,</strong> los archivos que subas se guardarán en la carpeta de dropbox <strong>Aplicaciones/&lt;nombre-aplicacion&gt;</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/804/1*i8_H-SESbhADMEfEkghKCg.png" /></figure><p>Cuando ejecutes el programa verás algo como lo siguiente en tu consola:</p><pre>Uploading file [Humble-Match.mp3] to dropbox <br>Uploading file [camaleon-01.jpg] to dropbox <br>Saving copy on [/Users/obautista/Desktop/dropbox] for file [Humble-Match.mp3] <br>Saving copy on [/Users/obautista/Desktop/dropbox] for file [camaleon-01.jpg]</pre><p>A la fecha de escribir este post estamos utilizando la dependencia de <strong>dropbox-core-sdk</strong> version <strong>3.1.4</strong></p><pre>&lt;dependency&gt;<br>    &lt;groupId&gt;com.dropbox.core&lt;/groupId&gt;<br>    &lt;artifactId&gt;dropbox-core-sdk&lt;/artifactId&gt;<br>    &lt;version&gt;3.1.4&lt;/version&gt;<br>&lt;/dependency&gt;</pre><h4>Conclusión</h4><p>Cómo puedes ver, esta es una alternativa para poder guardar tus archivos en la nube de forma gratuita para tus proyectos de prueba, además el SDK de Dropbox es bastante intuitivo, obviamente la más grande limitación es el espacio gratuito pero debería ser suficiente para tus experimentos.</p><p>En esta ocasión dado que el código es bastante sencillo pensé que era mejor enfocarse en la configuración. Sin embargo, si hay algo no te ha parecido lo suficientemente claro, dejame un comentario y trataré de aclarar las dudas, tambien pueden seguirme en mis redes sociales <strong>@Joxebus</strong> para <strong>Twitter / LinkedIn / Github</strong> y también date una vuelta a mi canal de <strong>YouTube</strong> donde estoy subiendo contenido de programación <a href="https://www.youtube.com/user/Joxebus">https://www.youtube.com/user/Joxebus</a></p><p>Gracias por leerme.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=32ee4de598de" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nearsoft-jobs/dropbox-java-una-alternativa-gratuita-a-aws-32ee4de598de">Dropbox + Java: una alternativa gratuita a AWS</a> was originally published in <a href="https://medium.com/nearsoft-jobs">Nearsoft Jobs</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>