<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Joan Llenas Masó on Medium]]></title>
        <description><![CDATA[Stories by Joan Llenas Masó on Medium]]></description>
        <link>https://medium.com/@joanllenas?source=rss-bd41560150cb------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*zo6DaTIylbkiYyRT-xsriA.jpeg</url>
            <title>Stories by Joan Llenas Masó on Medium</title>
            <link>https://medium.com/@joanllenas?source=rss-bd41560150cb------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 02:22:45 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@joanllenas/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Slaying a UI Antipattern with Angular]]></title>
            <link>https://medium.com/@joanllenas/slaying-a-ui-antipattern-with-angular-4c7536fafc54?source=rss-bd41560150cb------2</link>
            <guid isPermaLink="false">https://medium.com/p/4c7536fafc54</guid>
            <category><![CDATA[angular]]></category>
            <category><![CDATA[ui-ux]]></category>
            <category><![CDATA[elm]]></category>
            <category><![CDATA[union-types]]></category>
            <dc:creator><![CDATA[Joan Llenas Masó]]></dc:creator>
            <pubDate>Mon, 12 Feb 2018 00:34:34 GMT</pubDate>
            <atom:updated>2018-12-17T22:24:31.546Z</atom:updated>
            <content:encoded><![CDATA[<p><em>[Update Dec 17, 2018: Check the new </em><a href="https://github.com/joanllenas/ngx-remotedata"><em>ngx-remotedata</em></a><em> library]</em></p><p>Kris Jenkins <a href="http://blog.jenkster.com/2016/06/how-elm-slays-a-ui-antipattern.html">How Elm slays a UI antipattern</a> blog post about fixing the UI states when loading remote data has been around for almost a couple of years now and its popularity has transcended the Elm ecosystem. There are a few blog posts explaining how to achieve the same results with other languages / frameworks but none of them are based on Angular2+. In this article I’ll try to explain how to achieve something similar with Angular and TypeScript.</p><h3>The example</h3><p>The example is an application that gives you the sunrise and sunset times of the current day given the latitude and longitude of any place in the world.</p><p>The UI displays a Loading message while the data is being loaded and it also supports displaying an error in case an error occurs.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Z9x4PIU4V9YQ6Wzz64tjjA.png" /><figcaption>Example application</figcaption></figure><h3>The Boolean approach</h3><p>Before giving you the final solution let’s see an intermediate working version of the application in which we handle the remote data UI states using booleans.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fstackblitz.com%2Fedit%2Fangular-br9sag%3Fembed%3D1&amp;url=https%3A%2F%2Fstackblitz.com%2Fedit%2Fangular-br9sag&amp;image=https%3A%2F%2Fc.staticblitz.com%2Fassets%2Ficon-664493542621427cc8adae5e8f50d632f87aaa6ea1ce5b01e9a3d05b57940a9f.png&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=stackblitz" width="745" height="400" frameborder="0" scrolling="no"><a href="https://medium.com/media/dab234245240d1745bf3af6bb791730d/href">https://medium.com/media/dab234245240d1745bf3af6bb791730d/href</a></iframe><p>What illustrates the <em>boolean approach</em> in this example is the SunriseState in the sunriseSunset.service.ts file, which we use to express all possible UI states.<br><em>( actually it should have been called SunriseSunsetService </em>¯\_(ツ)_/¯ <em>)</em></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/30c143190fce44ce767c709ed19bb698/href">https://medium.com/media/30c143190fce44ce767c709ed19bb698/href</a></iframe><p>Let’s see what each property means:</p><ul><li><strong>isLoading</strong>: It‘s true while the remote data is being fetched.</li><li><strong>error</strong>: It‘s either null (no errors) or any string (there are errors).</li><li><strong>data</strong>: It’s either null (no data) or an object (there is data).</li></ul><p>There are a few problems with this approach but the main one is that it is possible to create <strong>invalid states</strong> such:</p><pre>{<br>  isLoading: true,<br>  error: &#39;Fatal error&#39;,<br>  data: {}<br>}</pre><p>As we can see our template also uses complex *ngIf statements in order to make sure that we are displaying exactly what we should.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4aa6c627ce3de841821360247d553c88/href">https://medium.com/media/4aa6c627ce3de841821360247d553c88/href</a></iframe><h3>The RemoteData approach</h3><p>The final solution uses an adaptation of Kris Jenkins’ RemoteData library. I have done it in a way that is effective but it is far from being as type safe as it would be if we were using Elm.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fstackblitz.com%2Fedit%2Fangular-hk12s8%3Fembed%3D1&amp;url=https%3A%2F%2Fstackblitz.com%2Fedit%2Fangular-hk12s8&amp;image=https%3A%2F%2Fc.staticblitz.com%2Fassets%2Ficon-664493542621427cc8adae5e8f50d632f87aaa6ea1ce5b01e9a3d05b57940a9f.png&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=stackblitz" width="745" height="400" frameborder="0" scrolling="no"><a href="https://medium.com/media/7727d1bfdd1e0152d114a1e9bea47e56/href">https://medium.com/media/7727d1bfdd1e0152d114a1e9bea47e56/href</a></iframe><p>The key part that illustrates this approach is the RemoteData Union Type declaration:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/971a790e05883453d651c14d815f4d29/href">https://medium.com/media/971a790e05883453d651c14d815f4d29/href</a></iframe><p>Using this approach we are able to refactor our service to use one single property to describe the current UI state, effectively <strong>making it impossible to represent invalid states</strong>.</p><pre>state: RemoteData&lt;string, ServiceResult&gt; = new NotAsked();</pre><p>We’ve also added a new initial UI state <em>not asked</em> that tells the UI that it is our first visit and we haven’t even attempted to load any data yet.</p><p>Our template has also been simplified. Instead of using combinations of boolean checks in our *ngIf statements we now use a single pipe for each state.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c757993fad8a13ed0de39859f60e5842/href">https://medium.com/media/c757993fad8a13ed0de39859f60e5842/href</a></iframe><h3>Recap</h3><ul><li>The full project can be found in this <a href="https://github.com/joanllenas/Slaying-a-UI-Antipattern-with-Angular">github repo</a>.</li><li>If you want to check the first version without RemoteData check <a href="https://github.com/joanllenas/Slaying-a-UI-Antipattern-with-Angular/tree/671816dec7787263e4c7762346031f3bfe9b28e0">this commit</a>.</li><li>Kris Jenkins <a href="http://blog.jenkster.com/2016/06/how-elm-slays-a-ui-antipattern.html">original article</a>.</li><li>Follow me on <a href="https://twitter.com/joanllenas">twitter</a> / <a href="https://github.com/joanllenas">github</a>.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4c7536fafc54" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Un sorbo de TEA: introducción a Elm (II)]]></title>
            <link>https://medium.com/@joanllenas/https-medium-com-joanllenas-un-sorbo-de-tea-intro-elm-2-a013606bb88e?source=rss-bd41560150cb------2</link>
            <guid isPermaLink="false">https://medium.com/p/a013606bb88e</guid>
            <category><![CDATA[introduction]]></category>
            <category><![CDATA[redux]]></category>
            <category><![CDATA[functional-programming]]></category>
            <category><![CDATA[elm]]></category>
            <dc:creator><![CDATA[Joan Llenas Masó]]></dc:creator>
            <pubDate>Sat, 06 Jan 2018 13:59:52 GMT</pubDate>
            <atom:updated>2018-01-31T15:08:43.310Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/950/1*UT1gl2Vu3Rq6FzeR44VSUQ.png" /><figcaption>Una taza de TEA cargadita</figcaption></figure><p>Continuando con el <a href="https://medium.com/@joanllenas/https-medium-com-joanllenas-un-sorbo-de-tea-intro-elm-b64fa7c031a2">ejemplo del contador del artículo anterior</a> vamos a añadir una nueva características al proyecto. Queremos que el usuario pueda decidir en cuánto se incrementa el contador y para ello tendrá dos opciones:</p><ul><li>Entrar el valor de incremento deseado en un campo numérico.</li><li>Seleccionar un checkbox que active que el incremento sea aleatorio.</li></ul><p>Estas nuevas características nos servirán como excusa para introducir varios conceptos importantes. Para presentarlos partiremos <a href="https://ellie-app.com/kpyDm6Vzga1/4">del proyecto Ellie</a> del artículo anterior. Te invito a que <a href="https://ellie-app.com/kpyDm6Vzga1/4">lo abras</a> y vayas añadiendo / modificando según vayamos avanzando.</p><p>En este artículo desarrollaremos el primer punto:</p><h3>Entrar el valor de incremento</h3><p>Para que el usuario pueda entrar el valor de incremento tendremos que hacer lo siguiente:</p><ul><li>Añadir el campo numérico en la vista.</li><li>Disponer de un nuevo atributo en el modelo para albergar el valor de incremento.</li><li>Disponer de un nuevo tipo de mensaje para poder recoger los cambios en el nuevo campo numérico.</li></ul><h4>Incremento</h4><p>En la parte del <strong>modelo</strong> es fácil satisfacer las nuevas necesidades, simplemente añadimos un nuevo atributo incremento al record userRecord.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NUH5WIAG-dl_5VQrXl00sg.png" /></figure><p>Disponiendo de incremento ya podemos modificar la función de <strong>update</strong> para que lo utilice.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NMMICEJpoYTev1SKpoBjxA.png" /></figure><p>En este punto ya podemos compilar y jugar con el valor de incremento para incrementar el contador con diferentes valores. Nada complicado.</p><h4>Campo numérico</h4><p>El siguiente paso es crear un campo numérico y usarlo para modificar incremento. Para ello vamos a tener que crear un nuevo mensaje que será enviado desde el campo input y que transportará el valor numérico que hayamos entrado. La parte de la vista quedaría así:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*14C_AzqThQ2xqrxJpV-acQ.png" /></figure><p>Cosas a destacar de esta nueva parte del código:</p><ul><li>input es una función del módulo Html, como div o button, y recibe los mismos parámetros: lista de atributos y lista de hijos (vacía en este caso).</li><li>Como type es una palabra reservada en Elm la función para el atributo <em>type</em> lleva un underscore: type_.</li><li>La función del atributo value, que al igual que _type forma parte del módulo Html.attributes, espera un String y por eso hacemos la conversión del valor numérico de incremento, que es de tipo Int, con toString. <br><a href="http://package.elm-lang.org/packages/elm-lang/core/latest/Basics#toString">toString</a> es una función que forma parte de la librería estándar de Elm (no hace falta importarla) y sirve para convertir a String cualquier valor. Recibe un único parámetro que es lo que queremos convertir a cadena de texto.</li><li>onInput, del módulo Html.Events, es un <em>event handler</em> que envía el valor del campo al que pertenece como parámetro de un mensaje. Es decir, al cambiar el valor del input por ejemplo a 5 se enviará el mensaje CambiarIncremento con un <em>payload</em> de 5 a la función de Update. <br>Veamos cómo se declara un mensaje parametrizado.</li></ul><h4>Declaración del mensaje parametrizado</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kv74HhhJo-3PF_2oynzfpA.png" /></figure><p>Como se puede ver se declara con el nombre del mensaje, un espacio y luego tantos tipos como el mensaje requiera separados por espacios. <br>Otro ejemplo de mensaje sería:</p><pre>MensajeCon5Parametros Int String Float Usuario Pedido</pre><p>Los tipos soportados como parámetro de un mensaje son todos los primitivos como String, Int, Float,Bool, etc.. y otra clase de tipos personalizados (definidos por nosotros) llamados <em>type alias</em>.</p><h4>Record types</h4><p>Un <em>record type</em> es la declaración del tipo de un record. Es decir, nos permite declarar de forma explícita los tipos que componen el record.</p><p>Como se puede ver a continuación la sintaxis es muy parecida a la de un record.</p><pre>type alias Usuario = <br>  { id : Int<br>  , nombre : String<br>  , email : String<br>  }</pre><p>Para instanciarlo haríamos como si Usuario fuera una función y sus atributos sus parámetros:</p><pre>john = Usuario 1 &quot;John Doe&quot; &quot;me@john.com&quot;</pre><p>Una vez tenemos la instancia podemos operar con él como si fuera un <em>record</em>.</p><pre>john.nombre // &quot;John Doe&quot;<br>{ john | nombre = &quot;John Moe&quot; } // Usuario 1 &quot;John Moe&quot; &quot;me@john.com&quot;</pre><p>Ahora veamos cómo se utilizan los mensajes parametrizados en la función de Update.</p><h4>Uso del mensaje parametrizado</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ymoOfELwuoiiQUDrADW-dw.png" /></figure><p>En esta parte hemos introducido un par de cosas: el mensaje parametrizado y el tipo Result.</p><p>Como ya vimos en el <a href="https://medium.com/@joanllenas/https-medium-com-joanllenas-un-sorbo-de-tea-intro-elm-b64fa7c031a2">artículo anterior</a> los mensajes sirven para invocar la función de Update apuntando a una rama concreta del <em>case statement</em>.</p><p>En el caso de un mensaje con parámetros, como es el caso de CambiarIncremento, funciona exactamente de la misma forma pero con el añadido que la rama a la que apuntamos recibe tantos argumentos como parámetros tenga el mensaje, en este caso solo uno, incr, que es el valor numérico (que nos viene como String) del campo input que lanzó CambiarIncremento.</p><h4>Tipo Result</h4><p><a href="http://package.elm-lang.org/packages/elm-lang/core/latest/Result">Result</a> es un módulo de la librería estándar de Elm (no hace falta importarlo). En este módulo, entre otras cosas, hay definido el <em>type</em> <a href="http://package.elm-lang.org/packages/elm-lang/core/latest/Result">Result</a> que sirve para representar valores de computaciones que podrían fallar.</p><p>Un Result puede ser o bien Ok o bien Err y ambos son tipos parametrizados. El type en si tiene esta forma:<br><em>(no es exactamente así pero por ahora ya nos sirve)</em></p><pre>type Result<br>    = Ok value<br>    | Err error</pre><p>Si es Ok devuelve el valor del resultado, si es Err devuelve un mensaje de error.</p><p>Hay muchas funciones standard de Elm que retornan un Result, básicamente cualquier función cuya operación pueda falla. Esta clase de tipos contenedor es lo que le permite a Elm ser un lenguaje sin excepciones en tiempo de ejecución porque, como veremos a continuación, nos obligan a tratar obligatoriamente <strong>todos los casos</strong> en las operaciones potencialmente peligrosas.</p><blockquote>No Runtime Exceptions!</blockquote><p>Ok, pero a la hora de usar el resultado a nosotros no nos interesa trabajar con Result directamente, queremos lo que lleva dentro, el valor (o error) que contiene. ¿Cómo lo hacemos? Pues bien, existen dos formas. Una es sacando el valor con un <em>case statement</em> mediante <em>pattern matching</em>.<br>(<a href="https://ellie-app.com/jqw2Ts8H4a1/0">proyecto Ellie</a> de ejemplo)</p><pre>resultado = <br>  case String.toInt &quot;22&quot; of<br>    Err msg -&gt; <br>      0<br>    Ok num -&gt;<br>      num + 1</pre><pre>-- Resultado contiene 23 porque `String.toInt` &quot;22&quot; devuelve `Ok 22`</pre><p>Aquí es importante remarcar que no puedes dejar de tratar el caso Err porque tienes prisa o porque se te ha olvidado, el compilador te obliga a cubrir <strong>todos los casos</strong> haciendo así que tu programa sea más robusto.</p><p>La otra forma de sacar el valor del contenedor Result es utilizando la función <a href="http://package.elm-lang.org/packages/elm-lang/core/latest/Result#withDefault">withDefault</a>, que es la forma que estamos utilizando en el ejemplo por ser menos verbosa pero que viene a hacer lo mismo.<br>La función recibe dos parámetros, el primero es el valor por defecto que devolverá en caso de Err y el segundo es un Result.<br>Si el Result es un Ok la función devolverá el valor que transporta Ok, si es un Err entonces la función devolverá el valor por defecto que le hemos pasado.</p><h3>Recapitulando</h3><p>Hemos aprendido:</p><ul><li>Como declarar y utilizar mensajes parametrizados.</li><li>Qué son los <em>record types</em>.</li><li>Como ejecutar código Elm desde el DOM a través de <em>event handlers</em>.</li><li>Como hacer conversiones entre tipos de forma segura.</li><li>Qué son los tipos contenedor como Result y cómo extraer su valor.</li></ul><h3>Código</h3><p>Si te ha dado pereza escribir todo el código aquí presentado he creado este <a href="https://ellie-app.com/bnm8dnWj8a1/0">proyecto <em>Ellie</em></a>, por si quieres jugar un poco con él.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/39ab516f0767a7e262381e33e8e0c27b/href">https://medium.com/media/39ab516f0767a7e262381e33e8e0c27b/href</a></iframe><h3>¿Qué más?</h3><p>En el siguiente artículo implementaremos la segunda característica de la que hablábamos al principio</p><ul><li>Seleccionar un checkbox que active que el incremento sea aleatorio.</li></ul><p>Con esta nueva característica utilizaremos la arquitectura Elm en un modo extendido introduciendo los famosos <em>efectos </em>a través de subscripciones y comandos. La cosa se pondrá interesante :)</p><h3>Social</h3><p>Puedes mantenerte en contacto conmigo y enterarte cuando publique nuevos artículos a través de mis perfiles:</p><ul><li><a href="https://twitter.com/joanllenas">Joan Llenas Masó (@joanllenas) | Twitter</a></li><li><a href="https://github.com/joanllenas">joanllenas (Joan Llenas)</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a013606bb88e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Un sorbo de TEA: introducción a Elm (I)]]></title>
            <link>https://medium.com/@joanllenas/https-medium-com-joanllenas-un-sorbo-de-tea-intro-elm-b64fa7c031a2?source=rss-bd41560150cb------2</link>
            <guid isPermaLink="false">https://medium.com/p/b64fa7c031a2</guid>
            <category><![CDATA[redux]]></category>
            <category><![CDATA[functional-programming]]></category>
            <category><![CDATA[introduction]]></category>
            <category><![CDATA[elm]]></category>
            <dc:creator><![CDATA[Joan Llenas Masó]]></dc:creator>
            <pubDate>Thu, 04 Jan 2018 22:27:43 GMT</pubDate>
            <atom:updated>2018-07-23T13:29:36.686Z</atom:updated>
            <content:encoded><![CDATA[<p>¿Has creado alguna aplicación con Redux o una de sus implementaciones? Si la respuesta es si entonces debes saber que ya conoces bastante acerca de Elm y su arquitectura (The Elm Architecture o TEA para abreviar) ya que Dan Abramov <a href="https://redux.js.org/#influences">se inspiró</a> en ella cuando creó Redux, aquí podrás averiguar el porqué. Si la respuesta es no entonces esta es una buena oportunidad para ver de qué va todo esto.</p><h3>Elm</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*4i1VIa-6QuC8BjQgRf3Ebw.png" /><figcaption>Logo de Elm</figcaption></figure><p>Pero ¿qué es Elm para empezar? En <a href="http://elm-lang.org/">su web</a> dicen:</p><blockquote>A delightful language for reliable webapps</blockquote><p>Extendiendo esta definición un poco más podríamos decir que <em>Elm es un lenguaje de programación funcional que compila a Javascript especialmente ideado para crear aplicaciones web robustas.</em></p><ul><li><strong>Lenguaje de programación funcional</strong>: esto significa que todo el código que escribes es funcional por defecto, no tienes que hacer ningún esfuerzo extra. Esto es así porque el lenguaje no es multiparadigma como JS, es decir, no puedes hacer Programación Orientada a Objetos con Elm (no hay clases u objetos), solo Programación Funcional pura.<br>Es importante destacar también que al diseñar el lenguaje se puso un gran énfasis en hacerlo fácil de usar y de aprender, a diferencia de otros lenguajes funcionales la curva de aprendizaje de Elm es suave, para empezar a hacer cosas solo se necesitan ganas y disponer de un rato para jugar con los ejemplos básicos.</li><li><strong>Compila a Javascript</strong>: el código Elm se convierte a Javascript en un proceso de <em>build</em> parecido al que se hace con ES6+, Typescript, Flow, etc.. Elm dispone de un set de herramientas <a href="https://www.npmjs.com/package/elm">basadas en npm</a> para llevar a cabo este proceso.</li><li><strong>Especialmente ideado para crear webapps</strong>: Elm nace de un <a href="https://www.seas.harvard.edu/sites/default/files/files/archived/Czaplicki.pdf">trabajo de investigación</a> realizado por su autor, Evan Czaplicki, en el que desarrolla cómo debería implementarse un lenguaje de programación para crear clientes web.</li><li><strong>Robusto</strong>: Gracias a su compilador y su sistema de tipos el código Elm no produce excepciones en tiempo de ejecución.</li></ul><blockquote>No Runtime Exceptions</blockquote><h4>Sintaxis</h4><p>Antes de sumergirnos en los detalles de cómo se crea una aplicación con la arquitectura Elm es necesario conocer algo de su sintaxis y algunos conceptos básicos y la mejor forma de hacerlo es mostrando algo de código.</p><p>No vamos a entrar en los detalles del sistema de build de Elm en este artículo pero puedes jugar con el código aquí presentado utilizando <strong>Ellie</strong>, un rollo JSFiddle pero para Elm.<br>Este ejemplo lo puedes cargar <a href="https://ellie-app.com/fL2TwCtD9a1/0">mediante este enlace</a>.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/08a444a3c85867ec1001aadd97cd9532/href">https://medium.com/media/08a444a3c85867ec1001aadd97cd9532/href</a></iframe><h4><strong>Cabecera del módulo</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/1*a4GKKl3DP9sGRTgqKePGJQ.png" /></figure><p>Todos los archivos <strong>*.elm</strong> son módulos (una colección de <em>cosas Elm </em>que se exponen al exterior) y se definen con esa cabecera.</p><p>En este caso el archivo se llamaría <strong>Main.elm</strong>, si se llamara <strong>Ejemplo.elm</strong> la cabecera sería module Ejemplo exposing (..).</p><p>No hablaremos de la porción exposing(..) porque no es importante ahora mismo pero ahí podríamos declarar exactamente lo que hacemos visible a otros módulos.</p><h4><strong>Importar otros módulos</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/1*dx3zU31q8Qw4Xa8GrSndKQ.png" /></figure><p>Para usar cosas de otros módulos tienes que traerlas de forma explícita al módulo en el que estás con un import, muy parecido a lo que haríamos en ES6+.</p><p>En este caso en la línea 15 estamos usando la función text que pertenece al módulo Html por eso lo importamos.</p><p>No hablaremos de la porción exposing(..) porque no es importante ahora pero ahí podríamos declarar exactamente qué nos queremos traer, definir alias para lo que estamos importando y otras cosas.</p><h4>Funciones</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/1*9y4UoeI1YZpkiWWUDWIjLQ.png" /></figure><p>Las funciones se definen con un nombre, una lista de argumentos separados por espacio, un signo de igual y a continuación el cuerpo de la función.</p><pre>nombreFuncion arg1 arg2 arg3 = cuerpoDeLaFuncion</pre><p>Las funciones SIEMPRE retornan un valor y no hace falta decirlo de forma explicita con return.</p><p>La razón por la que esto es así es porque el único propósito de las funciones en Elm es calcular algo y devolver el resultado, para producir <a href="https://es.wikipedia.org/wiki/Efecto_secundario_(inform%C3%A1tica)">efectos secundarios</a> existen otros mecanismos que veremos en otra ocasión. Y si, esto tiene una serie de implicaciones y es una de las primeras cosas a las que cuesta acostumbrarse.</p><h4>Records</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/1*qebOxHwY9Wxa_olgt57h2A.png" /></figure><p>Los <a href="http://elm-lang.org/docs/records"><em>records</em></a> (registros en castellano) son pares de clave-valor accesibles por notación de punto, muy parecidos a los objetos de JS pero con algunas diferencias:</p><ul><li><strong>Son inmutables</strong> (no se pueden modificar): si quieres modificar su valor tienes que pasarlo por una función que devolverá una copia nueva del record con las modificaciones aplicadas.</li><li><strong>No son extendibles</strong>: Al operar con un record no puedes añadirle o quitarle miembros. Por ejemplo no podrías añadir surname al record userRecord al operar con él en una función, menos aún intentar quitarle la propiedad name ya que para empezar no existen en Elm los conceptos de null, undefined o delete. <em>No runtime expections</em>, ¿recuerdas? :)</li><li><strong>Sus tipos son fijos</strong>: Al operar con un record no puedes cambiar el tipo de sus miembros. Por ejemplo no podrías asignar 100 a userRecord.name porque éste espera un String y 100 es un Int.</li></ul><h4>Punto de entrada</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/1*d_dMKE18QwjlIEjtYyYC8g.png" /></figure><p>main es el único punto de entrada de todo programa y es una función que debe estar definida en el archivo principal de nuestro proyecto, que no recibe parámetros y que devuelve la representación html del DOM, en el caso que nos ocupa devuelve un nodo de texto, que es el resultado de llamar a la función text pasándole como parámetro el resultado de la llamada a la función sayHello pasándole el record userRecord.</p><p>Como se puede ver los paréntesis ayudan al compilador a entender que solo le pasamos un parámetro a la función text, no dos. <br>Existen otras formas más elegantes de hacer lo mismo pero no hablaremos de ello en esta ocasión.</p><h3>La arquitectura Elm</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/950/1*BIiLd3zS8mZNRsaSe7fVXw.png" /><figcaption>Una taza de TEA calentita</figcaption></figure><p>En el sitio web definen muy bien qué es la TEA:</p><blockquote>La arquitectura Elm es un sencillo patrón sobre el que construir aplicaciones web. Facilita la modularidad, la reutilización de código y el testeo. El resultado final es que permite crear aplicaciones web complejas de forma sencilla que se mantienen bien a través del tiempo mientras se refactoriza y se añaden características.</blockquote><p>La arquitectura separa la lógica del programa en tres bloques claramente separados:</p><ul><li><strong>Model:</strong> el estado de la aplicación.</li><li><strong>Update:</strong> la función que actualiza el estado.</li><li><strong>View:</strong> la función que renderiza el estado a Html.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/521/1*SA3mAX7DyDIbY12Hrh2L5A.png" /></figure><p>Para ilustrar el funcionamiento básico veremos el típico ejemplo del contador (puedes jugar con el código en este <a href="https://ellie-app.com/kpyDm6Vzga1/4">proyecto Ellie</a>):</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2333f89fc4283cb06f91e5414b47e0fd/href">https://medium.com/media/2333f89fc4283cb06f91e5414b47e0fd/href</a></iframe><p>A continuación voy a explicar las diferentes partes pero obviando lo que ya sabemos del ejemplo anterior.</p><h4>Importar otros módulos (II)</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/1*yyUv46BmXFuFF2s520EXBw.png" /></figure><p>Contrastando con el ejemplo anterior aquí vemos dos imports nuevos: Html.Attributes y Html.Events. Y quizás te preguntes ¿por qué los importamos si ya hemos importado Html?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Dy1OKQcXgumV5o8wpsat0w.png" /></figure><p>Pues bien, como se puede ver en esta representación de la estructura de archivos donde se sitúan los módulos, el nombre del módulo se corresponde con el nombre de todas las carpetas desde la raíz del proyecto hasta el nombre del archivo, éste incluido.</p><p>Así funciona la nomenclatura de módulos en Elm, que es de obligado cumplimiento para que el compilador no se queje.</p><h4>Modelo</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/1*qlbhwZsKCSkyl0lYuu-qbA.png" /></figure><p>El Modelo de la tríada <em>View&gt;Update&gt;Model</em> puede ser tan simple como esto o tan complejo como requiera tu aplicación.</p><p>En aplicaciones grandes los modelos de otros módulos pueden componerse para formar estructuras más complejas.</p><h4>Update</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/1*BzE5b5fuk1MYJ4s4iM3Qgg.png" /></figure><p>Veamos las distintas responsabilidades que conforman el proceso de actualización en la arquitectura Elm:</p><ul><li><strong>Los mensajes</strong></li></ul><p>Dentro de Elm la generación del DOM es un efecto secundario al que no tenemos acceso alguno, el DOM queda totalmente aislado y fuera del alcance de nuestras funciones, por suerte Elm proporciona un mecanismo para que podamos comunicarnos desde el DOM a nuestro código mediante mensajes.</p><p>Los mensajes en Elm son de un tipo de dato especial llamado <a href="https://en.wikipedia.org/wiki/Tagged_union"><em>Union Type</em></a><em>.</em> Son una enumeración de varias opciones (también llamadas <em>type constructors</em>) identificadas con un nombre, muy parecido a los <em>enums</em> de otros lenguajes pero más potente.</p><p>Los <em>Union Types</em> se declaran con la palabra reservada type, el nombre que le queramos dar, un signo de igual y luego uno o más nombres separados por el operador pipe |.</p><p>Los mensajes que definamos luego serán utilizados en la función de Update para decidir qué camino tomamos dentro de una serie de opciones (lo vemos en el siguiente punto).</p><ul><li><strong>La función de Update</strong></li></ul><p>Cuando el runtime de Elm recibe un mensaje éste automáticamente hace una llamada a la función Update de la tríada <em>View&gt;Update&gt;Model;</em> en este caso la función se llama actualizar; pasándole como parámetros el mensaje recibido y el estado actual de la aplicación (el modelo). Entonces la función se ocupa de actualizar y retornar el modelo basándose en la información que le proporciona el mensaje que se le ha enviado.</p><p>Dentro de la función vemos una nueva estructura case mensaje of llamada <em>case statement,</em> que viene a ser algo parecido a un switch, aunque da mucho más juego.</p><p>Lo que un <em>case statement</em> hace básicamente es buscar entre todos sus <em>case</em> uno que coincida con el mensaje que se le ha pasado. Este proceso se llama <em>pattern matching</em>.<br>En el ejemplo que nos ocupa significa que al clicar los botones del contador, que son los que envían los mensajes, se ejecutará el <em>case</em> Incrementar cuando llegue el mensaje Incrementar y el <em>case</em> Decrementar cuando llegue el mensaje Decrementar.</p><p>Finalmente, dentro de los <em>case</em> podemos ver la sintaxis de actualización del modelo, que es visiblemente distinta a lo que estaríamos acostumbrados de JS.</p><p>Cabe remarcar que el <em>case statement</em> es una expresión y que resuelve a un valor, por lo tanto la función de Update devuelve el valor resultante de la evaluación del <em>case statement</em> (recordad que las funciones siempre devuelven algo), que en este caso es el nuevo modelo.</p><h4>View</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/1*AoM5NOrPJCRifZ9acGCucQ.png" /></figure><p>Tras ejecutarse la función de Update el runtime de Elm recoge el nuevo valor del modelo y ejecuta automáticamente la función View de la tríada <em>View&gt;Update&gt;Model</em>; en nuestro caso la función vista; pasándole el nuevo modelo recibido para finalmente calcular y devolver la nueva representación del DOM al runtime para que lo pinte por pantalla.</p><p>En esta función cabe destacar la forma en que se declara la estructura del DOM. Son simples funciones!</p><p>La librería Html de Elm contiene funciones para todos los elementos y atributos de la especificación html pero antes de ver los detalles vamos a introducir dos nuevos tipos: las listas y las tuplas.</p><ul><li><strong>List</strong>: Las listas son parecidas a los Arrays de JS pero solo pueden contener elementos de un mismo tipo.<br>También se declaran con corchetes miLista = [ 1, 2, 3 ].</li><li><strong>Tuple</strong>: Una tupla es una enumeración fija de elementos de uno o varios tipos distintos.<br>Se declaran entre paréntesis miTupla = ( 1, &quot;hola&quot;, False ).</li></ul><p>Ahora que conocemos las listas y las tuplas podemos entender la firma de las funciones de los elementos html:</p><pre>nombreTagHtml listaAtributos listaHijos<br>       |            |            |<br>    función       arg1          arg2</pre><ul><li><strong>listaAtributos</strong> es una lista de funciones de atributos como style , class o onClick.</li><li><strong>listaHijos</strong> es una lista con funciones de otros elementos html anidados como div, span o h1.</li></ul><p>La lista de atributos está compuesta por funciones cada una con distintas firmas. En el caso de style por ejemplo recibe una lista de tuplas (String, String).</p><pre>span [ style [ ( &quot;padding&quot;, &quot;5px&quot; ), ( &quot;color&quot;, &quot;blue&quot; ) ] []</pre><p>En el caso de class en cambio recibe un String.</p><pre>div [ class &quot;col-sm&quot; ] [ text &quot;Hola&quot; ]</pre><p>Otro tipo de atributo a destacar son los que envían mensajes como el <strong>click</strong> de los botones.</p><pre>button [ onClick Incrementar ] [ text &quot;Incrementar contador&quot; ]</pre><p>Es posible parametrizar los mensajes que se envían desde del DOM de forma que transporten valores pero esto queda fuera del ámbito de este artículo.</p><h3>Inicialización del programa</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/1*g4PDX8rp59sfnDH0fEXNXQ.png" /></figure><p>Para acabar solo queda conectar las tres partes <em>View&gt;Update&gt;Model</em> con el runtime de Elm y para ello se tiene que llamar a la función beginnerProgram del módulo Html pasándole nuestros model, view y update.</p><p>Existen otras funciones con más parámetros que permiten aumentar la arquitectura para que soporte parametrización desde JS o la ejecución de efectos como conexiones a sockets o peticiones Http pero esto queda para otro artículo.</p><h3>Recapitulando</h3><p>Hemos aprendido unas cuantas cosas:</p><ul><li>Qué es Elm.</li><li>Sintaxis y estructura básica de un programa Elm.</li><li>La arquitectura Elm y sus actores / conceptos asociados.</li></ul><h4>¿Redux, reducido?</h4><p>Si eres usuario de Redux te habrás dado cuenta que el flujo unidireccional de la arquitectura Elm es muy parecido al de Redux y habrás notado también el poco código que hemos escrito en comparación con todo el boilerplate al que estás acostumbrado. La razón de esto es que todo lo que intentamos hacer de forma artificial en Redux es nativo en Elm, no requiere librerías externas ni voluntad para cumplir con todos las normas y convenciones que se deben seguir para hacer un Redux de forma correcta.</p><h3>¿Qué más?</h3><p>Si te has quedado con ganas de más <a href="https://medium.com/@joanllenas/https-medium-com-joanllenas-un-sorbo-de-tea-intro-elm-2-a013606bb88e">ya puedes leer el siguiente artículo</a> en el que evolucionaremos un poco este ejemplo para introducir algunos conceptos nuevos entre los que destacamos:</p><ul><li><strong>Mensajes parametrizados</strong>: para poder pasar datos a nuestras desde el DOM a nuestras funciones.</li><li><strong>Conversiones</strong>: veremos como convertir strings a números de forma segura con Elm.</li><li><strong>Tipos contenedor</strong>: Relacionado con las conversiones, introduciremos el tipo Result que forma parte de la librería standard de Elm y se usa extensivamente para encapsular resultado de operaciones que pueden fallar.</li></ul><h3>Social</h3><p>Mantente en contacto y entérate cuando publique nuevos artículos:</p><ul><li><a href="https://twitter.com/joanllenas">Joan Llenas Masó (@joanllenas) | Twitter</a></li><li><a href="https://github.com/joanllenas">joanllenas (Joan Llenas)</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b64fa7c031a2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Yet another TypeScript introduction]]></title>
            <link>https://medium.com/@joanllenas/yet-another-typescript-introduction-c461dad7dde4?source=rss-bd41560150cb------2</link>
            <guid isPermaLink="false">https://medium.com/p/c461dad7dde4</guid>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[typescript]]></category>
            <category><![CDATA[introduction]]></category>
            <dc:creator><![CDATA[Joan Llenas Masó]]></dc:creator>
            <pubDate>Sun, 05 Mar 2017 01:08:17 GMT</pubDate>
            <atom:updated>2017-03-08T15:58:42.810Z</atom:updated>
            <cc:license>https://creativecommons.org/licenses/by-sa/4.0/</cc:license>
            <content:encoded><![CDATA[<blockquote>TypeScript is a typed superset of JavaScript that compiles to plain JavaScript.</blockquote><p>The slogan on the <a href="https://www.typescriptlang.org/">www.typescriptlang.org</a> website front page reveals two essential TS aspects:</p><ul><li>TS is a language and a compiler.</li><li>All TS is valid JavaScript.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/250/1*ROyAd3txLik3dZD4h3DRQA.png" /><figcaption>TypeScript is a superset of JavaScript</figcaption></figure><p>As the name suggests, TS is all about types, and its only purpose is making sure that your code is<a href="https://en.wikipedia.org/wiki/Type_safety"> type safe</a> and to achieve this goal it uses a couple of tricks.</p><h3>Type inference</h3><p>The most important thing you have to rely on when using TS is<a href="https://en.wikipedia.org/wiki/Type_inference"> type inference</a>.</p><p>The TS compiler can infer (figure out) the type of many expressions in your program without the need of any effort from your side. When that happens, it will make sure that throughout your code, any operation you make with that expression is consistent with its inferred type, even when JavaScript would allow that operation by implicitly applying some weird type coercion.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9827037c9649d52a29854576ef07071d/href">https://medium.com/media/9827037c9649d52a29854576ef07071d/href</a></iframe><h3>Type annotations</h3><p>More often than not fellow programmers will argue that writing and adding type annotations takes time, adds overhead and even makes code less readable. Well, I will have to agree on that: more keystrokes are always worse, type annotations add noise to our codebases, and some complex type definitions are just too difficult to grasp when skim-reading our code.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/1*_HJ3zs3ythkzcWFUFaE1-Q.jpeg" /></figure><p>Now, there is a balance between type safe and completely untyped code, and TS allows us to reach that Nirvana thanks to its powerful type inference and the expressiveness of its type system.</p><h4>Minimizing annotations</h4><p>Most of the time we won’t have to add type annotations to our application code, they will be provided by the libraries we use and the core of our application.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b177cddc6f4fe5568caa64ce4ceab615/href">https://medium.com/media/b177cddc6f4fe5568caa64ce4ceab615/href</a></iframe><p>As you can see in the previous example, <em>app-code.ts</em> has only one type annotation <em>HttpService&lt;User&gt;</em>, but the code is 100% type safe because TS can infer the rest.</p><p>In large scale applications, it becomes even more apparent. Having a strongly typed foundation will ensure that most of our app code will automatically get enforced by the compiler.</p><h4>Simplifying annotations</h4><p>As a TS user, I have sometimes felt overwhelmed by the complexity of some types. TypeScript has a ton of<a href="https://www.typescriptlang.org/docs/handbook/advanced-types.html"> advanced features</a> that allow type authors to be extremely expressive, but sometimes crafting expressiveness requires sacrificing readability.</p><p>Even though type signatures can get very complicated, we always have the option of hiding that complexity by using one cool TS feature called<a href="https://www.typescriptlang.org/docs/handbook/advanced-types.html#type-aliases"> type aliases</a>. Type aliases are just containers for other types.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/580f6da12f0dfca89b5364393c5046f1/href">https://medium.com/media/580f6da12f0dfca89b5364393c5046f1/href</a></iframe><p>Continuing with the previous example we have added the <em>url</em> param to the <em>save</em> method, which is just a string, but we have used a more semantically correct type <em>Url</em>.</p><p>We have also extracted the <em>Promise&lt;HttpResponse&lt;T&gt;&gt;</em> annotation to another type, for the sake of readability and reusability.</p><h3>Null, undefined under control</h3><p>The TS compiler has some built-in tools to cope with one of the most annoying things in JS development: <em>null</em> and <em>undefined</em>.</p><p>By default <em>null</em> and <em>undefined </em>can be assigned to any type, but there’s a compiler flag<a href="https://www.typescriptlang.org/docs/handbook/advanced-types.html#nullable-types"> --<em>strictNullChecks</em></a> that enforce you to explicitly declare that a given type can accept <em>null</em> or <em>undefined</em>.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8accd61b3e8a57b843423cbb6393b74f/href">https://medium.com/media/8accd61b3e8a57b843423cbb6393b74f/href</a></iframe><p>In this example, the nullable variable uses a<a href="https://www.typescriptlang.org/docs/handbook/advanced-types.html#union-types"> union type</a> to express that it allows <em>string</em> and <em>null</em> values.</p><h3>TypeScript + {your framework here}</h3><ul><li><strong>Angular 2</strong>: Authored in TS.</li><li><strong>CycleJS</strong>: Authored in TS</li><li><strong>React</strong>: The TS compiler <a href="https://www.typescriptlang.org/docs/handbook/jsx.html">supports</a> the JSX syntax, and the React APIs are available via <a href="https://www.npmjs.com/package/@types/react">typings</a>.</li><li><strong>Vue</strong>: <a href="https://vuejs.org/v2/guide/typescript.html">Officially supported</a> in v2.</li><li><strong>{your framework here}</strong>: Is your favorite framework supported? probably, <a href="https://microsoft.github.io/TypeSearch/">search here</a>.</li></ul><h3>IDE integration</h3><p>To make the most of your TS experience, relying on a good code editor is key. For what I’ve tried so far these are my recommendations:</p><ul><li><a href="https://code.visualstudio.com/">Visual Studio Code</a> (built-in support)</li><li><a href="https://www.jetbrains.com/webstorm/">WebStorm</a> (built-in support)</li></ul><p>I haven’t tried yet, but looks great:</p><ul><li><a href="http://alm.tools/">ALM tools</a> (built-in support)</li></ul><p>Other editors like Atom, Brackets, Sublime, etc probably have community plugins that provide good TS support.</p><h3>Conclusion</h3><ul><li>You don’t have to annotate all your expressions and declarations; type inference is your friend.</li><li>Be expressive, use all TS tools at your disposal but be kind to your API users.</li><li>Be explicit about null/undefined.</li><li>If you are a framework user, it probably has TS support.</li><li>Add TS support to your favorite IDE or just pick one with built-in support.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c461dad7dde4" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>