<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Pablo Ulloa Castro on Medium]]></title>
        <description><![CDATA[Stories by Pablo Ulloa Castro on Medium]]></description>
        <link>https://medium.com/@pabloulloacastro?source=rss-2dc038d4277e------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*qDcH5rgs4GbxJt4X.</url>
            <title>Stories by Pablo Ulloa Castro on Medium</title>
            <link>https://medium.com/@pabloulloacastro?source=rss-2dc038d4277e------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 07:39:46 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@pabloulloacastro/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[Abstracción: El primer paso a los algoritmos]]></title>
            <link>https://medium.com/@pabloulloacastro/abstracci%C3%B3n-el-primer-paso-a-los-algoritmos-787b6e3f3711?source=rss-2dc038d4277e------2</link>
            <guid isPermaLink="false">https://medium.com/p/787b6e3f3711</guid>
            <category><![CDATA[español]]></category>
            <category><![CDATA[medium-español]]></category>
            <category><![CDATA[algoritmos]]></category>
            <category><![CDATA[abstracción]]></category>
            <dc:creator><![CDATA[Pablo Ulloa Castro]]></dc:creator>
            <pubDate>Thu, 09 Jul 2020 21:51:27 GMT</pubDate>
            <atom:updated>2020-07-09T21:55:41.536Z</atom:updated>
            <content:encoded><![CDATA[<p>Este articulo es parte de una serie que intenta aclarar dudas y dar consejos en los primeros pasos de la programación, principalmente enfocado en que le sea útil a mis alumnos de la universidad.</p><p>Algo que he confirmado, es que para poder programar lo fundamental es la comprensión del problema (<em>duh!, vaya novedad</em>). Para poder realizar esto, personalmente creo que una herramienta de gran ayuda es la abstracción del problema.</p><p>Un problema de programación, muchas veces lo podemos visualizar como la implementación de un proceso generalizado, el cuál debe ser comprobable y funcional. Considerando lo fundamental de la programación, vemos que en practicamente todo lenguaje y pseudo-lenguaje de programación existen operaciones, operadores, funciones, variables y un universo de tipo de datos bajo el cual se está operando.</p><p>De esto, tomare principal atención a las funciones. Una función la podemos definir como un conjunto de operaciones realizadas a un conjunto finito de variables de entrada, que al ser procesadas entregan un único resultado comprobable. Si aplicamos la misma función a las mismas variables de entrada, debiese siempre entregar el mismo resultado. A esto se le llama una “función pura”. Nos enfocaremos en estas funciones, ya que son las más fáciles de abordar y pedagógicamente ideales.</p><p>Con esto en mente, si ignoramos la operatoria interna de una función y solo consideramos el comportamiento de esta, al saber que con una entrada X obtendremos una salida Y, estamos casualmente acercandonos a una abstracción.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*g0EAtz7JdoY7DtCfwL_Nxw.jpeg" /><figcaption>René Magritte — La traición de las imágenes</figcaption></figure><p>La abstracción en sí, consiste en la generalización de un proceso, donde nos enfocamos principalmente en <strong><em>“qué”</em></strong> más que en el <strong><em>“cómo”</em></strong>. Es decir, ignoramos la operatoria interna y nos centramos en el resultado. La gracia, es que podemos tener distintos niveles de abstracción, donde a medida que “bajamos” o “profundizamos” en la abstracción, irémos acercandonos a la respuesta del <strong><em>“cómo”</em></strong>.</p><p>Por ejemplo, Si una persona X toma una ducha higiénica, podemos ver la abstracción más generalizada de la siguiente forma:</p><pre>1: -&gt; X ingresa a un baño, y luego sale limpia</pre><p>Esta abstracción la podemos ir hilando cada vez de forma más fina, especificando el paso a paso dentro del procedimiento 1:</p><pre>1: -&gt; X ingresa a un baño, y luego sale limpia:<br>1.1: ----&gt; X ingresa al baño<br>1.2: ----&gt; X se desnuda<br>1.3: ----&gt; X ingresa a la ducha<br>1.4: ----&gt; X sale de la ducha limpia<br>1.5: ----&gt; X se seca y viste<br>1.6: ----&gt; X sale del baño</pre><p>Nuevamente, podemos ir a un nivel más profundo, especificamente en el punto 1.3 y 1.5:</p><pre>1: -&gt; X ingresa a un baño, y luego sale limpia:<br>1.1: ----&gt; X ingresa al baño<br>1.2: ----&gt; X se desnuda<br>1.3: ----&gt; X ingresa a la ducha:<br>1.3.1: -------&gt; X se lava el pelo<br>1.3.2: -------&gt; X se lava el cuerpo<br>1.4: ----&gt; X sale de la ducha limpia<br>1.5: ----&gt; X se seca y viste:<br>1.5.1: -------&gt; X se seca el cuerpo<br>1.5.2: -------&gt; X se viste<br>1.5.3: -------&gt; X se seca el pelo<br>1.6: ----&gt; X sale del baño</pre><p>De esta forma, el nivel más alto de abstracción es el procedimiento 1, el cual logramos llevar hasta dos niveles más profundo en abstracción.</p><p>Si consideramos que cada uno de estos procedimientos es una función, podemos asociar las funciones a piezas de un rompecabezas o de un juego de Lego’s, las que podemos unir entre si, formando una cadena donde la salida de una función puede ser utilizada como la entrada de otra, o puede ser utilizada como parte de la implementación de otra función.</p><p>Y si nos damos cuenta, cada vez que profundizamos dentro de una abstracción, estamos implementando parcialmente el problema. La idea es profundizar hasta un punto en el que lleguemos a procedimientos fáciles y cortos de implementar, los cuales en su conjunto entreguen como resultado la respuesta a un procedimiento más largo y complejo. Otro punto a tomar en consideración, es que idealmente estos pequeños procedimientos más especificos, sean reutilizables, de modo que sirvan para resolver otros problemas (por ejemplo los procedimientos 1.1 y 1.6 pueden ser reutilizados en caso de que quisieramos representar el procedimiento en que X se lava los dientes, va a orinar, o realiza otra actividad en el baño).</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=787b6e3f3711" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Javascript con sabor a ES6: Spread Operator, Rest Parameters y Object Destructuring]]></title>
            <link>https://medium.com/@pabloulloacastro/javascript-con-sabor-a-es6-spread-operator-rest-parameters-y-object-destructuring-1fcd860d1dfc?source=rss-2dc038d4277e------2</link>
            <guid isPermaLink="false">https://medium.com/p/1fcd860d1dfc</guid>
            <category><![CDATA[español]]></category>
            <category><![CDATA[es6]]></category>
            <category><![CDATA[medium-español]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Pablo Ulloa Castro]]></dc:creator>
            <pubDate>Mon, 31 Dec 2018 13:33:36 GMT</pubDate>
            <atom:updated>2018-12-31T13:33:36.919Z</atom:updated>
            <content:encoded><![CDATA[<p>Dentro de las múltiples bondades que podemos utilizar del estándar ES6, tenemos diversas funcionalidades aplicables a los objetos. Particularmente en esta ocasión hablaremos del Spread Operator, Rest Parameters y del concepto de Object Destructuring y cómo utilizar ambas funcionalidades.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vL4ELMaQubuwFs1eZnQmsA.jpeg" /></figure><h4>Spread Operator</h4><p>El Spread Operator corresponde a un operador el cuál distribuye los elementos de un arreglo u objeto, para asignarlos a alguna variable/constante/función.</p><p>Su sintáxis de uso es la siguiente:</p><pre>const o1 = {<br>    a1: &#39;valor1&#39;,<br>    a2: &#39;valor2&#39;,<br>}</pre><pre>const o2 = {<br>    a3: 0,<br>    ...o1,<br>}</pre><pre>console.log(o1) // {a1: &#39;valor1&#39;, a2: &#39;valor&#39;2}<br>console.log(o2) // {a3: 0, a1: &#39;valor1&#39;, a2:&#39;valor2&#39;}</pre><pre>const l1 = [1,2,3]<br>const l2 = [...l1, 4, 5]</pre><pre>console.log(l1) // [1,2,3]<br>console.log(l2) // [1,2,3,4,5]</pre><p>Una utilidad clara, es cuando se quiere copiar atributos de un objeto a otro, o cuando se quiere copiar elementos de un arreglo a otro. Para el caso de los objetos, el operador funciona además respetando los valores de atributos definidos en el objeto de destino, de modo que no sean sobreescritos por los valores de atributos del objeto que estamos entregando mediante el operador. Esto puede ser visto de forma más clara con un ejemplo:</p><pre>const o1 = {<br>    a1: &#39;valor1&#39;,<br>    a2: &#39;valor2&#39;,<br>    a3: &#39;valor3&#39;,<br>}</pre><pre>const o2 = {<br>    a1: 0,<br>    ...o1<br>}</pre><pre>console.log(o1) // {a1: &#39;valor1&#39;, a2: &#39;valor2&#39;, a3: &#39;valor3&#39;}<br>console.log(o2) // {a1: 0, a2: &#39;valor2&#39;, a3: &#39;valor3&#39;}</pre><h4>Rest Parameters</h4><p>Los Rest Parameters, al igual que el Spread Operator, son representados mediante tres puntos consecutivos, pero distan bastante de parecerse al Spread Operator. Su funcionalidad es la de unir distintos elementos a un arreglo. Normalmente se puede ver en los argumentos de una función.</p><pre>const potenciar = (exponente, ...bases) =&gt; {<br>    console.log(exponente)<br>    console.log(bases)<br>    return bases.map(x =&gt; x**exponente)<br>}</pre><pre>potenciar(3, 2, 3, 4, 5)<br>// console: 3<br>// console: [2, 3, 4, 5]<br>// return: [8, 27, 64, 125]</pre><h4>Object Destructuring</h4><p>El concepto de Object Destructuring corresponde a la capacidad que entrega ES6 de “extraer” atributos de objetos hacia variables con el mismo nombre. Es decir:</p><pre>const persona = {<br>    nombre: &#39;Juan&#39;,<br>    edad: 27<br>}</pre><pre>const { nombre, edad } = persona // aqui se crean las variables nombre y edad. Su valor corresponde al valor de los atributos de mismo nombre dentro del objeto persona</pre><pre>console.log(nombre) // &#39;Juan&#39;<br>console.log(edad) // 27</pre><p>De esta forma podemos hacer nuestro código más legible al crear variables que contengan el valor del atributo de un objeto.</p><p>NOTA: El Spread Operator y Object Destructuring entregan los valores de los atributos en forma de <em>deep copy</em>, por lo que cualquier modificación a los valores del objeto original no se verán reflejados en las variables receptoras de estas asignaciones.</p><p>Para quienes quieran ver otros artículos de la temática de Javascript con sabor a ES6:</p><ul><li><a href="https://medium.com/@pabloulloacastro/javascript-con-sabor-a-es6-arrays-1500063ab92a">Javascript con sabor a ES6: Arrays</a></li><li><a href="https://medium.com/@pabloulloacastro/javascript-con-sabor-a-es6-arrow-functions-6700414a5c1e">Javascript con sabor a ES6: Arrow functions</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1fcd860d1dfc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[React: Fetch API vs AXIOS]]></title>
            <link>https://medium.com/@pabloulloacastro/react-fetch-api-vs-axios-49946857a387?source=rss-2dc038d4277e------2</link>
            <guid isPermaLink="false">https://medium.com/p/49946857a387</guid>
            <category><![CDATA[axios]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[medium-español]]></category>
            <category><![CDATA[http-request]]></category>
            <dc:creator><![CDATA[Pablo Ulloa Castro]]></dc:creator>
            <pubDate>Sat, 24 Nov 2018 02:09:54 GMT</pubDate>
            <atom:updated>2018-11-24T02:09:54.232Z</atom:updated>
            <content:encoded><![CDATA[<p>Esta historia será un tanto distinta a las demás, será algo más práctico y directo al código, para comparar la implementación de peticiones Http utilizando Fetch API y utilizando la biblioteca Axios.</p><h4>Fetch API</h4><p>Para hacer uso de peticiones Http utilizando Fetch API, se puede hacer primero creando un cliente Http a la medida de nuestras necesidades basado en Fetch API:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4a54572123aa8ddaa416a8ac7f6d0251/href">https://medium.com/media/4a54572123aa8ddaa416a8ac7f6d0251/href</a></iframe><p>Una vez listo nuestro cliente, solo basta hacer uso de este:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b433f22090ead89b14e8b4fe149c19a0/href">https://medium.com/media/b433f22090ead89b14e8b4fe149c19a0/href</a></iframe><p>Lo importante aquí, es que si queremos actualizar el estado de nuestro componente a partir de la respuesta de una consulta Http, esto podemos hacerlo ya sea mediante la acción ejecutada por algún boton (o similar), o si se quiere cargar al momento de iniciar el componente, esto debe ser realizado en el método componentDidMount()</p><h4>Axios</h4><p>Para el caso de Axios, se puede construir un cliente similar:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/42ff3b758b330ff54520069f38cbe25c/href">https://medium.com/media/42ff3b758b330ff54520069f38cbe25c/href</a></iframe><p>Esto genera unas leves diferencias para nuestro componente:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/36359120209f7dbddf5ca416b5f59f8d/href">https://medium.com/media/36359120209f7dbddf5ca416b5f59f8d/href</a></iframe><p>Así es, la única diferencia gracias a la creación de estos clientes Http a la medida, es la ruta desde la cual importamos el cliente. Es decir, cual es el archivo fuente a utilizar, ya sea el fetch-client o el axios-client</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=49946857a387" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[React: Descubriendo Componentes]]></title>
            <link>https://medium.com/@pabloulloacastro/react-descubriendo-componentes-c158959116fe?source=rss-2dc038d4277e------2</link>
            <guid isPermaLink="false">https://medium.com/p/c158959116fe</guid>
            <category><![CDATA[react]]></category>
            <category><![CDATA[medium-español]]></category>
            <category><![CDATA[español]]></category>
            <category><![CDATA[react-components]]></category>
            <dc:creator><![CDATA[Pablo Ulloa Castro]]></dc:creator>
            <pubDate>Sun, 18 Nov 2018 17:48:28 GMT</pubDate>
            <atom:updated>2018-11-18T18:14:56.811Z</atom:updated>
            <content:encoded><![CDATA[<p>En los últimos años ha surgido un gran movimiento respecto a como diseñamos y desarrollamos las interfaces de usuario. Para esto han surgido diversas tecnologías (bibliotecas y frameworks), dentro de las cuáles destacan Angular, React y Vue. Algo que tienen en común estas tres tecnologías, es que todas mencionan como pilar base a algo denominado “Componente”, pero…</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/568/1*n74xNPqcVXkMVrVRF_STAQ.jpeg" /></figure><h4>¿Qué es un componente?</h4><p>Un componente es un segmento de nuestra interfaz de usuario, que basandose en el principio fundamental de “responsabilidad única”, cumple un objetivo claro y específico dentro de la interfaz. La idea es que los componentes sean reutilizables dentro de nuestro proyecto, y si tenemos una visión más amplia, reutilizables entre múltiples proyectos. En la siguiente imagen se identifican distintos componentes de una aplicación movil.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/684/1*Wv2y3zzKdLUpjpCNXQ1PBA.png" /><figcaption><a href="http://coenraets.org/blog/wp-content/uploads/2014/12/uimockscript.png"><em>http://coenraets.org/blog/wp-content/uploads/2014/12/uimockscript.png</em></a></figcaption></figure><p>Los componentes, ya hablando netamente dentro de React, tienen ciertas características propias de la API de React, tales como:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/303/1*NMBpLpNyHGvPdx54N0h75A.png" /></figure><ul><li>render</li><li>props</li><li>state</li><li>lifecycle events</li><li>context</li></ul><p>En React, el estado (state) de un componente suele utilizarse para las características dinámicas del mismo, por ejemplo, si queremos saber los valores que almacenan los input de un formulario, esto lo podemos ir guardando y consultando dentro del estado de un componente encargado de este formulario. Por otra parte tenemos a los props, que son parametros de creación del componente, los cuáles pueden ser entregados por componentes “padres” que contienen a nuestro componente observado.</p><p>Cuándo analizamos los componentes en los cuáles segmentamos nuestra interfaz de usuario, nos percatamos de algo: no todos los componentes manejan estado. A estos componentes se les denomina “stateless”, mientras que aquellos que se encargan de manejar estado son conocidos como “stateful”. Y adicionalmente, cada uno de este tipo de componentes hace uso de un subconjunto de las características que tienen los componentes de React:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/880/1*9irUjoYrk4S5VmHSY2gipg.png" /></figure><p>Bajo esta perspectiva, ya podemos comenzar a analizar y diferenciar componentes según su utilidad y complejidad.</p><h4>Componentes Presentacionales</h4><p>Los componentes presentacionales son componentes stateles, y su comportamiento corresponde al de las funciones puras, es decir, dado argumentos X, este siempre entregará una respuesta Y. Esto mismo se puede traducir en términos de React de la siguiente forma:</p><blockquote>Un componente presentacional, dado un conjunto de props X siempre renderizará lo mismo.</blockquote><p>Es debido a esto, que se ha vuelto una tendencia el escribir estos componentes de forma funcional:</p><pre>const EmployeeListItem = ({name, title, imgSrc}) =&gt; (<br>  &lt;div&gt;<br>    &lt;div&gt;&lt;img src={imgSrc} alt={name} /&gt;&lt;/div&gt;<br>    &lt;div&gt;&lt;h3&gt;{name}&lt;/h3&gt;&lt;h4&gt;{title}&lt;/h4&gt;&lt;/div&gt;<br>  &lt;/div&gt;<br>)</pre><h4>Contenedores</h4><p>A diferencia de los componentes presentacionales, los contenedores son componentes stateful, por lo que estos manejan lógica de estados y hacen uso del ciclo de vida de la API de React.</p><blockquote>Un contenedor se encarga de la captura de los datos y luego renderizar a sus componentes hijos.</blockquote><p>Los contenedores en la gran mayoría de los casos, hacen uso de componentes presentacionales para renderizar los datos contenidos en su estado.</p><pre>class EmployeeList extends React.Component {<br>  constructor() {<br>    super()<br>    this.state = {<br>      employees: []<br>    }<br>  }<br>  <br>  componentDidMount() {<br>    // Aqui deberia haber un llamado a API mediante fetch o axios<br>    this.setState(() =&gt; ({<br>      employees: [<br>        {<br>          name: &#39;James King&#39;,<br>          title: &#39;President and CEO&#39;,<br>          imgSrc: &#39;james.png&#39;<br>        },<br>        {<br>          name: &#39;Julie Taylor&#39;,<br>          title: &#39;VP of Marketing&#39;,<br>          imgSrc: &#39;julie.png&#39;<br>        }<br>      ]<br>    }))<br>  }<br>  <br>  render() {<br>    const { employees } = this.state<br>    return (<br>      &lt;div&gt;<br>        {employees.map(employee =&gt;<br>          (&lt;EmployeeListItem key={employee.name} {...employee} /&gt;)<br>        )}<br>      &lt;/div&gt;<br>    )<br>  }<br>}</pre><p>Demo: <a href="https://codesandbox.io/s/wqxxl6ny78">https://codesandbox.io/s/wqxxl6ny78</a></p><p>Por ahora lo dejaremos hasta aquí, en un próximo artículo veremos componentes de alto orden y componentes con callbacks en renderización</p><p>Fuentes:</p><ul><li><a href="https://www.youtube.com/watch?v=YaZg8wg39QQ">React Component Patterns by Michael Chan</a></li><li><a href="https://medium.com/teamsubchannel/react-component-patterns-e7fb75be7bb0">React component patterns</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c158959116fe" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Software en equipo: Git — stash]]></title>
            <link>https://medium.com/@pabloulloacastro/software-en-equipo-git-stash-3e6adbea821c?source=rss-2dc038d4277e------2</link>
            <guid isPermaLink="false">https://medium.com/p/3e6adbea821c</guid>
            <category><![CDATA[git]]></category>
            <category><![CDATA[medium-español]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[español]]></category>
            <dc:creator><![CDATA[Pablo Ulloa Castro]]></dc:creator>
            <pubDate>Sat, 17 Nov 2018 17:48:03 GMT</pubDate>
            <atom:updated>2018-11-17T17:48:03.948Z</atom:updated>
            <content:encoded><![CDATA[<h3>Software en equipo: Git — stash</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*Yb6kHyijPY4vMDv65Fo8cw.png" /></figure><p>Al utilizar git como herramienta de control de versiones, una de las primeras cosas que debemos aprender es a hacer un commit, lo que muchos en un inicio hacemos de forma casi automática es la secuencia git pull, git add . , git commit -m &quot;mensaje del commit&quot; , git push .</p><h4>Acompañame a ver esta triste historia</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/1*M3vmH8pQR0OeEJwQ62aQdw.jpeg" /></figure><p>Esta secuencia, almenos en mi caso particular, era algo que hice muchisimas veces casi sin pensar y efectivamente sin saber lo que ocurría realmente con git. Luego de un tiempo, cuando estaba ya haciendo la práctica profesional, un compañero menciona el comanto git stash , lo cual para mi era algo totalmente nuevo. Como es de esperar de alguien que aún no comprendía mucho sobre git, no le presté mucha atención ya que encontraba que con la secuencia pull, add, commit y push, tenia el mundo de git dominado. ¡Que grave error!</p><p>Tiempo después, comencé a trabajar en más equipos colaborativos, donde tenía problemas al hacer pull. Git me pedía hacer commit de mis cambios antes de realizar el pull, por lo que hice muchos commit de caracteristicas incompletas, y que luego de hacer el pull, en más de una ocasión tuve conflictos en la fase de merge, debido a que habia inconsistencias entre el código de mi área de trabajo y el código en el repositorio remoto. Tuve que aprender a solucionar dichos conflictos, y después darme cuenta que habia perdido parte del código descargado mediante pull por sobreescritura del merge. Otras veces tuve el mismo problema, al querer cambiar entre ramas dentro de mi propia área de trabajo local, ya que git en estos casos tambien pide hacer commit de los cambios antes de realizar el checkout.</p><p>Debe haber una solución a esto, algún mecanismo en el cuál pueda hacer pull y checkout sin la obligación de hacer commit sucios y arriesgarme a perder parte de mi código o parte del código que estoy descargando mediante el pull.</p><h4>La solución: git stash</h4><p>Cuando trabajamos con git tenemos distintos “ambientes” en los cuáles transita nuestro código fuente.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-s5rmyj_-nckv9YcdkUNZQ.png" /></figure><p>En este diagrama de secuencia se ve como nuestro código transita entre estos distintos ambientes.</p><ul><li>git add pasa el código desde el área de trabajo, al área de preparación</li><li>git commit pasa el código desde el área de preparación al repositorio local</li><li>git checkout permite cambiar entre ramas del repositorio local y actualizar el área de trabajo</li><li>git push pasa el código desde el repositorio local al repositorio remoto</li><li>git fetchpasa código desde el repositorio remoto al repositorio local</li><li>git merge une ramas y actualiza el área de trabajo, tanto ramas entre el mismo repositorio local, como los cambios de la rama actual a los cuales hicimos previamente git fetch</li><li>git pull es lo mismo que realizar git fetch seguido de git merge sobre la rama actual.</li></ul><p>Hasta aquí cubrimos nuestro flujo básico y aún no hemos trabajado con el stash.</p><ul><li>git stash toma todos los cambios que <strong>no han sido enviados al área de preparación</strong> y los envía a la pila de stash.</li><li>git stash pop toma el último estado de la pila de stash y realiza una actualización a nuestra área de trabajo con este último estado. Esto se realiza ejecutando un proceso identico al de un git merge</li></ul><p>Una vez comprendido esto, ya no deberían existir más commit a medias para cambiar entre ramas ni al realizar un pull, por lo que tampoco deberían existir problemas de perder código remoto al ejecutar un fetch o pull.</p><ul><li><a href="https://medium.com/@pabloulloacastro/software-en-equipo-git-m%C3%A1s-all%C3%A1-de-un-simple-commit-9d7702b0318a">Software en equipo: Git — más allá de un simple commit</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3e6adbea821c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Software en equipo: Git — más allá de un simple commit]]></title>
            <link>https://medium.com/@pabloulloacastro/software-en-equipo-git-m%C3%A1s-all%C3%A1-de-un-simple-commit-9d7702b0318a?source=rss-2dc038d4277e------2</link>
            <guid isPermaLink="false">https://medium.com/p/9d7702b0318a</guid>
            <category><![CDATA[spanish-medium]]></category>
            <category><![CDATA[git]]></category>
            <category><![CDATA[español]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Pablo Ulloa Castro]]></dc:creator>
            <pubDate>Thu, 27 Sep 2018 01:35:23 GMT</pubDate>
            <atom:updated>2018-11-18T21:01:34.331Z</atom:updated>
            <content:encoded><![CDATA[<h3>Software en equipo: Git — más allá de un simple commit</h3><p>En el mundo actual de desarrollo de software, es practicamente imperativo que utilicemos herramientas de control de versiones, siendo de estas Git la opción más habitual. Creo que todos como desarrolladores hemos, por lo menos, oido hablar acerca de ciertos términos de git tales como commit, push, pull, las ramas y conflictos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/512/1*FlYCf7wVanH9WHLB74JUzw.jpeg" /></figure><p>Muchas veces aprendemos git de forma autodidacta (o por lo menos creemos aprenderlo), o tenemos algún amigo o compañero desarrollador que nos va guiando en nuestros primeros pasos. Personalmente, mi experiencia ha sido más bien un híbrido, puesto que originalmente opté por el camino autodidacta pero a medida que avanzaba (y me encontraba con conflictos o errores que no comprendía) fuí pidiendo ayuda. Sin embargo, luego de saber como solucionar conflictos, como trabajar con ramas, como “volver en el tiempo” y reestablecer versiones anteriores, me di cuenta de algo: no sabía hacer commit de calidad.</p><p>Dentro de git se podría decir que la únidad básica es el commit. Todo aquel que ha trabajado con git los ha hecho, pero ¿sabemos efectivamente lo que es un commit? ¿le tomamos el valor que realmente posee? ¿cuándo es meritorio realizar commit y cuando no? Estas interrogantes me hicieron cuestionar la calidad de mi trabajo, desde la perspectiva de trabajo colaborativo. Mi síntesis (en chileno): Mis commit son penca.</p><p>Intentaré responder estas preguntas una a una, y finalmente entregaré lo que en base a mi corta experiencia, pueden ser consejos útiles para hacer buenos commit</p><h4>¿Qué es un commit?</h4><p>El commit, dentro de software, se puede comprender como una acción de “ejecutar”. Dentro de las bases de datos SQL, la acción de enviar una serie de instrucciones al servidor para que las ejecute se denomina commit. Esta es una buena analogía de lo que deberia ser un commit: el envío de una serie de instrucciones (que representan modificaciones en los nodos del proyecto) hacia una “base de datos” que contiene el historial de nuestro trabajo realizado.</p><p>Bajo esta perspectiva, el commit es el registro de lo que hacemos, o más bien, <strong>lo que queremos que quede guardado en el expediente (bitácora) de nuestro proyecto.</strong> Es importante entonces rescatar que dentro de cada commit existen la historia de modificacion de nuestro trabajo, ya sea la creación, alteración o eliminación tanto de archivos como directorios de nuestra área de trabajo.</p><h4>¿Cuál es el valor de un commit?</h4><p>Como ahora ya tenemos mayor claridad de lo que es un commit, podemos decir de forma casi inmediata que el valor de un commit es reflejar nuestro trabajo realizado. Es por esto que los commit no solo contienen los metadatos de qué hemos modificado, quién lo ha hecho y cuándo lo ha hecho, sino que tambien deben contener siempre un mensaje descriptivo de los cambios realizados. Estos mensajes generalmente son cortos, de una sola línea y no más de 70 caracteres, a pesar de que lo ideal es que tengan una primera línea breve (como la descrita recién), que hace las funciones de título/resumen, y adicionalmente separado mediante un salto de línea, un cuerpo más descriptivo de no más de 240 caracteres (algo así como un tweet).</p><p>Mediante estos mensajes descriptivos, podemos dar información a quien sea que vea nuestro registro de commits (git log) acerca de lo que hemos hecho en cada uno de estos commit, sin la necesidad de que tengan que ver el código fuente. Es por esto que los commit deben ser <strong>lo más descriptivos posible sintetizando la información en una cantidad reducida de palabras. </strong>Esta no es una tarea sencilla, especialmente si nuestro commit incluye cambios de diversa índole en nuestro proyecto. Para esto, necesitamos responder a la próxima interrogante</p><h4>¿Cuándo hacer un commit?</h4><p>Esta pregunta es la que puede tener respuestas más diversas, por lo que diré lo que a mi opinión (actualmente) considero hay que considerar al momento de hacer un commit.</p><p>Para hacer un commit, lo que personalmente considero como métrica es: solo <strong>hacer commit si he añadido/modificado algún aspecto que sume valor al software</strong>. No me refiero a valor monetario, sino más bien a valor en términos de funcionalidades, rendimiento o refactorizaciones de mejora en el código fuente. Bajo este ángulo, incluir un archivo en blanco en un commit no tiene sentido, puesto que este archivo en blanco no entrega valor al software (suponiendo que efectivamente el propósito de ese archivo no sea el estar en blanco). Asímismo, hacer un commit de una versión del software que no compile, no suma valor al software, al contrario, le estamos restando valor al dejar en evidencia una versión de software que nisiquiera funciona (y si efectivamente hacemos commit que no compilan por algún motivo específico, es importante eliminar estos commit una vez que hagamos un release o entrega de nuestro software).</p><h4>Resultado final</h4><p>Considerando todo lo anterior, los consejos serían los siguientes:</p><ul><li>Nuestros commit reflejan la seriedad de nuestro trabajo, por lo que esto deben ser tambien serios y ordenados (como debiera ser tambien nuestro código).</li><li>Un commit debe ser descriptivo y preciso, de forma que con solo leer el commit dejemos en exposición los cambios que hemos realizado en el proyecto, sin que sea necesario ver estos cambios.</li><li>Un commit debe contener cambios que sean significativos para el proyecto, por lo que debemos ser ordenados en nuestro flujo de trabajo y no hacer commit de cosas a medias</li></ul><p>Considerando esto, espero que nuestros commits pasen de verse así:</p><pre>$ git log --oneline<br>468a144 listo<br>f16efd0 creo que esta listo<br>4f4ce29 deshabilitar y preferencias de usuario funcionando 100%<br>c7355e0 falta poco<br>33ba81a agregado bloqueo al inicio de sesion<br>1805af8 agregada funciones para habilitar cuenta<br>06f29d0 botoncito nuevo<br>dd2f412 nop<br>1157e0a algo de avance para el ultimo sprint</pre><p>a verse así</p><pre>$ git log --oneline<br>468a144 TÉRMINO RELEASE 1.0.0<br>4f4ce29 agregar filtros de preferencias según usuario<br>33ba81a agregar bloqueo de botones en interfaz<br>1805af8 agregar habilitación de sesiones de usuario<br>1157e0a INICIO RELEASE 1.0.0</pre><ul><li><a href="https://medium.com/@pabloulloacastro/software-en-equipo-git-stash-3e6adbea821c">Software en equipo: Git — stash</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9d7702b0318a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Programación orientada a objetos: Patrón Builder]]></title>
            <link>https://medium.com/@pabloulloacastro/programaci%C3%B3n-orientada-a-objetos-patr%C3%B3n-builder-7fb20fe17bd8?source=rss-2dc038d4277e------2</link>
            <guid isPermaLink="false">https://medium.com/p/7fb20fe17bd8</guid>
            <category><![CDATA[español]]></category>
            <category><![CDATA[diseño-de-patrones]]></category>
            <category><![CDATA[design-patterns]]></category>
            <category><![CDATA[spanish]]></category>
            <dc:creator><![CDATA[Pablo Ulloa Castro]]></dc:creator>
            <pubDate>Wed, 19 Sep 2018 20:01:31 GMT</pubDate>
            <atom:updated>2018-09-19T20:01:31.794Z</atom:updated>
            <content:encoded><![CDATA[<p>Continuando con los patrones de diseño propuestos por el grupo de los cuatro en su <a href="https://books.google.cl/books/about/Patrones_de_dise%C3%B1o.html?id=gap_AAAACAAJ&amp;redir_esc=y">libro</a>, el siguiente patrón es igual de sencillo de implementar que el patrón singleton, pero como es de suponer, tiene un problema objetivo a resolver distinto al singleton.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*U7nXUGkfAFqt0SWmmqlL4g.jpeg" /></figure><h4>¿Qué problema resuelve este patrón?</h4><p>Este patrón tiene por objetivo facilitar la instanciación de objetos de una determinada clase o familia de clases, entrgando objetos cuyos atributos posean valores definidos sin recurrir a su llenado mediante constructores ni métodos de tipo <em>setter. </em>Por ejemplo si tenemos una clase de configuración con 5 o más atributos obligatorios para su uso, podríamos recurrir a instanciar el objeto y luego recordar el llenado de todos estos atributos, o intentar utilizar un constructor mediante el cuál demos valor a estos, pero el problema aquí es que si queremos mantener un código limpio, según estándares de buena calidad de código no deberiamos de tener métodos ni constructores que reciban más de 4 argumentos.</p><h4>Como resolver el problema:</h4><p>Este patrón posee diversas variantes, por lo que en este artículo presentaré la forma en la cuál personalmente estoy más habituado a implementarlo, lo que no significa que sea la única forma de hacerlo:</p><pre>public class Configuration {<br>    private Integer first;<br>    private Integer second;<br>    private Boolean third;<br>    private String fourth;<br>    private String fifth;<br><br>    public static ConfigurationBuilder getBuilder() {<br>        return new ConfigurationBuilder();<br>    }<br>    // asumir que <em>todo getter y setter está definido<br><br>    </em>public static class ConfigurationBuilder {<br><br>        private Configuration instance;<br><br>        private ConfigurationBuilder() {<br>            instance = new Configuration();<br>        }<br><br>        public ConfigurationBuilder first(int first) {<br>            instance.setFirst(first);<br>            return this;<br>        }<br><br>        public ConfigurationBuilder second(int second) {<br>            instance.setSecond(second);<br>            return this;<br>        }<br><br>        public ConfigurationBuilder third(boolean third) {<br>            instance.setThird(third);<br>            return this;<br>        }<br><br>        public ConfigurationBuilder fourth(String fourth) {<br>            instance.setFourth(fourth);<br>            return this;<br>        }<br><br>        public ConfigurationBuilder fifth(String fifth) {<br>            instance.setFifth(fifth);<br>            return this;<br>        }<br><br>        public Configuration build() {<br>            return instance;<br>        }<br>    }<br>}</pre><p>De esta forma, la preocupación de la construcción del objeto Configuration puede ser delegada a la clase ConfigurationBuilder . Esto puede ser más verboso, pero la diferencia se nota en su uso:</p><pre>Configuration config1 = new Configuration();<br>config1.setFirst(1);<br>config1.setSecond(0);<br>config1.setThird(false);<br>config1.setFourth(&quot;ejemplo&quot;);<br>config1.setFifth(&quot;otro ejemplo&quot;);</pre><pre>Configuration config2 = Configuration<br>    .getBuilder()<br>    .first(1)<br>    .second(0)<br>    .third(false)<br>    .fourth(&quot;ejemplo&quot;)<br>    .fifth(&quot;otro ejemplo&quot;).build();</pre><p>Este patrón puede ser aplicado de diversas formas, ya que dependiendo de la creatividad de su implementación, puede incluso ir orientando la creación de objetos de forma dinámica. Supongamos que si el valor booleano del atributo third es falso, no sea necesario llenar el atributo fourth pero sí el atributo fifth, y que lo opuesto ocurra cuando third sea verdadero. Adicionalmente, los atributos first y second los ingresaremos desde el método getBuilder():</p><pre>public class Configuration {<br>    private Integer first;<br>    private Integer second;<br>    private Boolean third;<br>    private String fourth;<br>    private String fifth;<br><br>    public static ConfiguracionBuilder getBuilder(Integer first, Integer second) {<br>        return new ConfiguracionBuilder(first, second);<br>    }<br>    // asumir que <em>todo getter y setter está definido<br><br>    </em>public static class ConfiguracionBuilder {<br><br>        private Configuration instance;<br><br>        private ConfiguracionBuilder(Integer first, Integer second) {<br>            instance = new Configuration();<br>            instance.setFirst(first);<br>            instance.setSecond(second);<br>        }<br><br>        public ConfigurationBuilderThirdTrue thirdTrue(String fifth) {<br>            instance.setFifth(fifth);<br>            return new ConfigurationBuilderThirdTrue(instance);<br>        }<br><br>        public ConfigurationBuilderThirdFalse thirdFalse(String fourth) {<br>            instance.setFourth(fourth);<br>            return new ConfigurationBuilderThirdFalse(instance);<br>        }<br>    }<br><br>    public static class ConfigurationBuilderThirdTrue {<br><br>        private Configuration instance;<br><br>        private ConfigurationBuilderThirdTrue(Configuration instance) {<br>            this.instance = instance;<br>            this.instance.setThird(true);<br>        }<br><br>        public Configuration build() {<br>            return instance;<br>        }<br>    }<br><br>    public static class ConfigurationBuilderThirdFalse {<br><br>        private Configuration instance;<br><br>        private ConfigurationBuilderThirdFalse(Configuration instance) {<br>            this.instance = instance;<br>            this.instance.setThird(false);<br>        }<br><br>        public Configuration build() {<br>            return instance;<br>        }<br>    }<br>}</pre><p>Ahora la creación de objetos se puede hacer así de simple:</p><pre>Configuration config3 = Configuration<br>    .getBuilder(1,0)<br>    .thirdTrue(&quot;otro ejemplo&quot;)<br>    .build();</pre><pre>Configuration config4 = Configuration<br>    .getBuilder(1,0)<br>    .thirdFalse(&quot;ejemplo&quot;)<br>    .build();</pre><p>De esta forma este patrón nos ayuda a orientar la creación de objetos, algo que en base a simplemente setters hubiera sido bastante más complejo.</p><p>Este patrón no entrega aporte respecto a rendimiento, pero sí es de gran ayuda para desarrolladores, debido a que facilita la lectura del código fuente y la construcción manual de objetos. Este patrón además puede ser integrado perfectamente con otros patrones como FactoryMethod, AbstractFactory, Decorator o Chain of Responsability.</p><ul><li><a href="https://medium.com/@pabloulloacastro/programaci%C3%B3n-orientada-a-objetos-solid-c40167ac6ed9">Programación orientada a objetos: Principios SOLID</a></li><li><a href="https://medium.com/@pabloulloacastro/programaci%C3%B3n-orientada-a-objetos-patr%C3%B3n-singleton-423e2755614b">Programación orientada a objetos: Patrón Singleton</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7fb20fe17bd8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Programación orientada a objetos: Patrón Singleton]]></title>
            <link>https://medium.com/@pabloulloacastro/programaci%C3%B3n-orientada-a-objetos-patr%C3%B3n-singleton-423e2755614b?source=rss-2dc038d4277e------2</link>
            <guid isPermaLink="false">https://medium.com/p/423e2755614b</guid>
            <category><![CDATA[diseño-de-patrones]]></category>
            <category><![CDATA[design-patterns]]></category>
            <category><![CDATA[spanish]]></category>
            <category><![CDATA[spanish-medium]]></category>
            <category><![CDATA[español]]></category>
            <dc:creator><![CDATA[Pablo Ulloa Castro]]></dc:creator>
            <pubDate>Mon, 17 Sep 2018 17:38:59 GMT</pubDate>
            <atom:updated>2018-09-27T12:26:44.389Z</atom:updated>
            <content:encoded><![CDATA[<p>Cuándo estamos haciendo software con programación orientada a objetos, el diseño se vuelve algo vital en el proceso de desarrollo (y deberia serlo para cualquier paradigma que estemos utilizando). Un buen diseño no solo debe considerar funcionalidades y la interacción entre los módulos del software, sino que debe de contemplar a su vez aspectos tales como seguridad, rendimiento, mantenibilidad del código y facilidad de desarrollo, tanto para nosotros como para los futuros desarrolladores que se verán enfrentados a nuestro código.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/550/1*YZsyOwXKgS8rf8bhgNZiLg.jpeg" /></figure><p>Bajo esta premisa, uno como desarrollador responsable debiera de no asumir que lo sabe todo y al contrario, consultar a otros desarrolladores con más experiencia acerca de cómo enfrentarían un problema X o pedir consejos o críticas constructivas acerca del diseño que uno está proponiendo. Para nuestra suerte, un grupo de desarrolladores, conocido como <em>el grupo de los cuatro</em>, publicó en 1994 un libro llamado <a href="https://books.google.cl/books/about/Patrones_de_dise%C3%B1o.html?id=gap_AAAACAAJ&amp;redir_esc=y">Patrones de diseño: elementos de software orientado a objetos reutilizables</a>, el cuál es una buenísima base de conocimiento, de la cuál podemos nutrirnos como desarrolladores y aprender como aplicar ciertos patrones que en más de algún momento nos ayudarán en nuestros software.</p><p>En este artículo hablaré sobre el patrón que creo que es más sencillo de comprender y aplicar, pero que a la vez tiene cierta polémica debido a que su abuso termina siendo más perjudicial que beneficioso, por lo que es importante conocerlo bien y saber como aplicarlo y como diseñar variantes de este mismo.</p><h4>¿Qué problema resuelve este patrón?</h4><p>Este patrón intenta resolver el siguiente problema: la instanciación excesiva de objetos de una misma clase, idénticos entre sí, en distintos puntos de nuestro software. Por ejemplo si tenemos una clase de solo métodos y ningún atributo, todas sus instancias son en escencia identicas entre sí desde que son instanciadas.</p><h4>Como resolver el problema:</h4><p>Este problema puede ser resuelto si la clase a la cuál pertenece nuestro objeto, asegura que exista solamente un único objeto de esta clase, y que esta misma clase provea un método estático mediante el cuál podamos acceder a esta instancia única.</p><p>Veamos un ejemplo de esto en Java:</p><pre>public class ClaseSingleton {<br>    private static ClaseSingleton instance = null;</pre><pre>    private ClaseSingleton() {}</pre><pre>    public static ClaseSingleton getInstance() {<br>        if (null == instance)<br>            instance = new ClaseSingleton();<br>        return instance;<br>    }<br>}</pre><h4>Precauciones a considerar:</h4><p>Este patrón tiene ciertas desventajas (no existe ningún patrón perfecto). Una desventaja es que en este patrón, almenos en su forma básica, el objeto singleton opera de forma síncrona, lo cuál puede ser perjudicial si nuestro software requiere de concurrencia de llamados a métodos de este objeto. Otra desventaja evidente es que este objeto corresponde a un recurso compartido dentro de nuestro software, por lo que debemos tener especial cuidado en el manejo de su estado, ya que si un segmento de nuestro software altera su estado, esto puede afectar el funcionamiento de otros segmentos de software que utilicen a este objeto. Estos son dos de los grandes mótivos por los que este patrón debe ser tratado de forma cuidadosa para que no se convierta en un antipatrón.</p><p>Viéndolo de forma genérica, el mayor enemigo de este patrón es el acceso de forma concurrente a este objeto singleton, problema que de hecho no existiría si no se aplicara el patrón. Pero por otro lado este patrón es bastante útil si, por ejemplo, queremos asegurar que la conexión entre capas de software sea realizada por un único objeto, o si este objeto singleton es muy pesado en memoria y tener múltiples instancias de este genera un gran gasto de recursos (¿recuerdan el primer parrafo de este artículo?).</p><p>Es por estas precauciones, que lo recomendado es utilizar este patrón cuándo no exista este problema de concurrencia, ya sea que en el comportamiento y uso de nuestro software, estamos seguros que la concurrencia no será problema, o bien que si sabemos que puede llegar a ocurrir problemas a raíz de que hayan llamados concurrentes a nuestro singleton, tengamos las precauciones necesarias ya implementadas.</p><ul><li><a href="https://medium.com/@pabloulloacastro/programaci%C3%B3n-orientada-a-objetos-solid-c40167ac6ed9">Programación orientada a objetos: Principios SOLID</a></li><li><a href="https://medium.com/@pabloulloacastro/programaci%C3%B3n-orientada-a-objetos-patr%C3%B3n-builder-7fb20fe17bd8">Programación orientada a objetos: Patrón Builder</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=423e2755614b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Programación orientada a objetos: Principios SOLID]]></title>
            <link>https://medium.com/@pabloulloacastro/programaci%C3%B3n-orientada-a-objetos-solid-c40167ac6ed9?source=rss-2dc038d4277e------2</link>
            <guid isPermaLink="false">https://medium.com/p/c40167ac6ed9</guid>
            <category><![CDATA[orientación-a-objetos]]></category>
            <category><![CDATA[spanish-medium]]></category>
            <category><![CDATA[solid]]></category>
            <category><![CDATA[español]]></category>
            <category><![CDATA[object-oriented]]></category>
            <dc:creator><![CDATA[Pablo Ulloa Castro]]></dc:creator>
            <pubDate>Sat, 15 Sep 2018 22:39:51 GMT</pubDate>
            <atom:updated>2018-09-27T12:27:05.383Z</atom:updated>
            <content:encoded><![CDATA[<p>La programación orientada a objetos no debiera ser ninguna novedad, en el sentido de que es parte de lo básico que debieran enseñar en cualquier institución que diga enseñar programación de software a futuros desarrolladores, ya sean técnicos o ingenieros.</p><p>Pero, ¿Que tanto conocemos de orientación a objetos? Hago esta pregunta de forma real, ya que durante mis años de estudiante creí saber lo que era orientación a objetos, hasta que llegué a un curso donde me hablaron de patrones de diseño y principios SOLID, y mi mente explotó. En ese momento sentí “vaya, ahora sí se orientación a objetos”. Claramente no sabia de lo que estaba hablando, claramente creí entender algo de SOLID y creí saber patrones de diseño. Hoy en día me doy cuenta que es un mundo mucho más amplio, dinámico y flexible de lo que creía, pero a la vez veo lo fácil que es caer en antipatrones en los que uno, por pensar estar haciendo las cosas bien, como se dice en buen chileno, la termina cagando más.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/620/1*249RCThomKrXFI5TXvqNtg.jpeg" /></figure><p>Para comprender bien la orientación a objetos, hay que comprender algo esencial: Los objetos. Un objeto, en términos simples, es una representación de un concepto abstracto que representa algo del mundo real. Pero ojo, no hay que ser de mente cerrada y pensar que con esto solo nos referimos a cosas tangibles. Al contrario, cosas intangibles como la física, reglas sociales, procedimientos organizacionales, etc, son cosas de nuestro mundo real que podemos representar cada una de estas como objetos. Si nos vamos por este camino, teóricamente TODO puede ser representado como objetos, y esto en sí ya fue una gran revelación respecto a mi visión previa de lo que era la orientación a objetos.</p><p>Entonces, ahora el desafio es definir cuál es el alcance de hasta donde llega nuestros objetos, ya que por ejemplo, podemos definir el típico ejemplo de la clase de objetos Animal. pero animal es muy amplio, podemos definir reinos de animales, familias, especies, o incluso definir al animal como un conjunto de organos vitales y cada conjunto de organos vitales como una estructura o colonia pluricelular. ¿Donde marco mi límite, hasta donde llego con mi abstracción? La respuesta es bien burda y evidente, pero no por esto necesariamente sencilla: El límite de tu abstracción lo defines tú, según las necesidades y alcances de tu software a desarrollar.</p><p>Es en esta parte, donde los principios SOLID juegan un rol fundamental, para ayudarnos a definir las clases de nuestros objetos y como estas interactuan y se organizan entre sí.</p><h4>¿Qué son los principios SOLID?</h4><p>Los principios SOLID, son 5 principios cuyas iniciales en inglés forman el acrónimo SOLID. Estos son:</p><ul><li>Single responsability principle</li><li>Open-closed principle</li><li>Liskov substitution principle</li><li>Interface segregation principle</li><li>Dependency inversion principle</li></ul><p>Estos principios tienen por objetivo potenciar el ideal de la programación orientada a objetos: hacer código reutilizable, portable y de fácil comprensión y mantenimiento.</p><h4>Single responsability principle</h4><p>El principio de responsabilidad única, como su nombre puede sugerirnos, apunta a que una clase de objetos debe poseer una única responsabilidad (o almenos tender a esto), lo que potencia directamente el aumentar la cohesión de nuestro código.</p><blockquote>Una clase solo debe tener una razón para ser modificada. <br>— Robert C. Martin</blockquote><p>Por ejemplo, bajo este principio es mal visto tener una clase de utilidades generales en nuestro código, en lugar de tener distintas clases de utilidad especializadas bajo algún criterio coherente con las funcionalidades que estas utilidades cubren.</p><h4>Open-closed principle</h4><p>El principio “abierto-cerrado”, se explica de la siguiente forma:</p><blockquote>Las entidades de software deben estar abiertas a su extensión pero cerradas a su modificación. <br>— Betrand Meyer</blockquote><p>Puede sonar raro esto, pero tiene muchisimo sentido, ya que es algo coherente: si tienes una clase A que hace bien su trabajo, pero ahora necesitas que haga algo más, no modifiques esta clase, al contrario, crea una clase B que herede desde A y aquí es donde debes añadir las nuevas funcionalidades. De esta forma, no rompes nada donde ya tenías funcionando A, y ahora adicionalmente puedes utilizar B en donde sea necesario.</p><h4>Liskov substitution principle</h4><p>El principio de sustitución de Liskov (en nombre de su autora), dice lo siguiente:</p><blockquote>Sea ϕ<strong>(x)</strong> una propiedad comprobable acerca de los objetos <strong>x</strong> de tipo T. Entonces ϕ<strong>(y)</strong> debe ser verdad para los objetos <strong>y</strong> del tipo <strong>S</strong> donde <strong>S</strong><em>,</em> es un subtipo de <strong>T</strong>. <br>— Barbara Liskov</blockquote><p>En términos más simples y familiares, aquí estamos hablando del polimorfismo, es decir, cuando el comportamiento esperado al operar un objeto x de clase T, es el mismo comportamiento a si usaramos un objeto y de clase S, considerando que la clase S herede desde T.</p><h4>Interface segregation principle</h4><p>El principio de segregación de interfaces se relaciona también con un concepto de herencia, particularmente sobre la implementación de métodos a partir de clases abstractas e interfaces. Se puede definir simplemente de la siguiente manera:</p><blockquote>Los clientes no deben ser forzados a depender de métodos que no utilizan. <br>— Robert C. Martin</blockquote><p>Poniendo esta frase en contexto, los clientes son las clases que implementan a nuestras interfaces y clases abstractas. El asunto aquí es, si tenemos por ejemplo una interfaz para firmar métodos de un mecanismo de comunicación encriptada podríamos tener por ejemplo:</p><pre>interface Comunicador {<br>    encriptar(mensaje): String<br>    enviar(mensaje, destino): Boolean<br>    desencriptar(mensaje): String<br>    recibir(): Boolean<br>}</pre><p>Esta interfaz sirve para que una clase la implemente y pueda enviar y recibir mensajes encriptados, pero, ¿Y que pasa si queremos tener una clase que implemente solamente los métodos encriptar y desencriptar, para ser utilizado en un contexto diferente al de un mecanismo de comunicación, y adicionalmente una clase que envíe y reciba mensajes sin encriptar?. Estas clases no pueden implementar a esta interfaz, puesto que se verían en la obligación de implementar métodos adicionales a los que realmente utilizarian, por lo que un mejor enfoque sería descomponer esta interfaz en dos interfaces segregadas y especializadas (recuerden el principio de responsabilidad única)</p><pre>interface Comunicador {<br>    enviar(mensaje, destino): Boolean<br>    recibir(): Boolean<br>}</pre><pre>interface Encriptador {<br>    encriptar(mensaje): String<br>    desencriptar(mensaje): String<br>}</pre><h4>Dependency inversion principle</h4><p>El principio de inversión de dependencias es quizás el más complejo de explicar, personalmente aún me cuesta trabajo llevarlo a palabras sencillas, pero aquí haré mi mejor intento. Primero veamos lo que dice un autor reconocido acerca de este principio</p><blockquote>A. Los módulos de alto nivel no deben depender de módulos de bajo nivel. Ambos deben depender de abstracciones<br>B. Las abstracciones no deben depender de detalles. Los detalles deben depender de abstracciones. <br>— Robert C. Martin</blockquote><p>Suena confuso, lo sé, y creanme que lo sigue siendo hasta que ya con práctica le tomas el ritmo. Para comprender estas frases, explicaré primero la segunda: en esta frase, veamos los conceptos de abstraccion y detalle como interfaz y clase que implementa a dicha interfaz. Esta explicación simple abarca la frase B. En cambio la frase A se puede explicar mejor con un ejemplo: si tenemos un módulo de alto nivel A, que debe interactuar con un módulo B de bajo nivel, esta interacción la realizamos mediante una interfaz <em>IB</em>, la cuál firma los métodos que deben ser implementados por el módulo B. Pero A es agnóstico de si en este módulo B se está implementando una clase B1, B2 o B3. De esta forma forzamos que al diseñar la interacción entre módulos, en lugar de considerar una interacción descendiente en que los módulos de alto nivel dependen de los de menor nivel, el enfoque se centra en como interactúan ambos módulos, siendo esta interacción la abstracción de la cual ambos dependen.</p><p>Una vez comprendidos los conceptos SOLID, es bueno prácticarlos y reforzarlos, puesto que estos son base para una programación orientada a objetos más eficiente y mantenible en el tiempo. El siguiente paso a ver serán patrones de diseño: cuando y cómo aplicarlos.</p><ul><li><a href="https://medium.com/@pabloulloacastro/programaci%C3%B3n-orientada-a-objetos-patr%C3%B3n-singleton-423e2755614b">Programación orientada a objetos: Patrón Singleton</a></li><li><a href="https://medium.com/@pabloulloacastro/programaci%C3%B3n-orientada-a-objetos-patr%C3%B3n-builder-7fb20fe17bd8">Programación orientada a objetos: Patrón Builder</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c40167ac6ed9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Javascript con sabor a ES6: Arrow functions]]></title>
            <link>https://medium.com/@pabloulloacastro/javascript-con-sabor-a-es6-arrow-functions-6700414a5c1e?source=rss-2dc038d4277e------2</link>
            <guid isPermaLink="false">https://medium.com/p/6700414a5c1e</guid>
            <category><![CDATA[es6]]></category>
            <category><![CDATA[arrow-functions]]></category>
            <category><![CDATA[funciones]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[español]]></category>
            <dc:creator><![CDATA[Pablo Ulloa Castro]]></dc:creator>
            <pubDate>Thu, 13 Sep 2018 01:24:44 GMT</pubDate>
            <atom:updated>2018-12-31T13:35:20.029Z</atom:updated>
            <content:encoded><![CDATA[<p>Continuando la serie de “Javascript con sabor a ES6”, hoy hablaremos sobre las llamadas “Arrow functions”, las cuáles incluso utilicé en la <a href="https://medium.com/@pabloulloacastro/javascript-con-sabor-a-es6-arrays-1500063ab92a">historia anterior</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/541/1*0Sz2mYCDGuRSkPM0w2_nBw.jpeg" /></figure><p>Las llamadas “funciones flecha” o “arrow functions” son funciones anónimas, las cuales podemos registrar en una variable o utilizar directamente sin registrar. Su sintáxis es la siguiente:</p><pre>variable = argumentos =&gt; procedimiento // se registra en variable<br>argumentos =&gt; procedimiento // no registramos en variable</pre><p>Esta última forma, en la cuál no registramos en variable, es la forma en que las utilicé en la historia Javascript con sabor a ES6: Arrays.</p><p>Quizás se pregunten ¿Y que es una función anónima?, pues bien, una función anónima es una función que “no ocupa espacio de memoria” (en cierto sentido). Esto es algo más bien técnico, por lo que intentaré explicarlo de forma simple: En Javascript, cuando se define una función, por ejemplo function saludar(nombre){ console.log(&quot;hola&quot;+nombre);} , esta función es alojada en un espacio de memoria, y está ahí esperando a ser utilizada, por lo que si nunca es llamada es un desperdicio de memoria. Las funciones anónimas por otro lado, al ser registradas en una variable, son asociadas en forma de puntero de memoria y no directamente en la memoria (confuso, sí).</p><p>Pero en fín, esto es algo que muchos debaten de qué tan efectivo sea este ahorro en rendimiento. Lo que si no se puede negar, es que hay casos en que necesitamos realizar operaciones puntuales, como por ejemplo al entregar una función a un método .map o .reduce de un arreglo.</p><h4>Arrow function con un solo argumento</h4><p>Creo que ya me he dado muchas vueltas teóricas, así que mejor pasemos a lo práctico. Veamos un ejemplo de como sería transformar objetos usando el método .map de los arreglos, analizando tres posibles formas de abordar este problema. Para este caso, supongamos que tenemos el siguiente arreglo:</p><pre>const equipo = [<br>    {nombre: &#39;pikachu&#39;, saludo: &#39;pika!&#39;, hp: 15}, <br>    {nombre: &#39;charmander&#39;, saludo: &#39;char charmander!&#39;, hp: 25},<br>    {nombre: &#39;squirtle&#39;, saludo: &#39;escuero!&#39;, hp: 1}<br>];</pre><p>De este listado de pokemon, queremos imprimir por console log su nombre y saludo. Para esto desarrollaremos una función, la cual entregaremos mediante un .map, y luego pasaremos con .forEach una función que imprimirá por console.log cualquier entrada.</p><pre>function saludar(pokemon) {<br>    return pokemon.nombre + &quot;: &quot; + pokemon.saludo<br>}</pre><pre>function log(texto) {<br>    console.log(texto)<br>}</pre><pre>equipo<br>    .map(saludar)<br>    .forEach(log)</pre><p>Asumiento que no volveremos a utilizar en ningún otro lugar de nuestro programa a la función saludar(pokemon), y considerando lo poco eficiente que es encapsular el console.log, un enfoque más eficiente es definiendo una función anónima directamente en el .map:</p><pre>equipo<br>    .map(function(pokemon) { return pokemon.nombre + &quot;: &quot; + pokemon.saludo })<br>    .forEach(function(texto) { console.log(texto)});</pre><p>Esta solución en teoría es más eficiente en términos de rendimiento, pero aparentemente es a la vez más desordenado el código. Ahora con arrow functions:</p><pre>equipo<br>    .map(pokemon =&gt; pokemon.nombre + &quot;: &quot; + pokemon.saludo)<br>    .forEach(texto =&gt; console.log(texto));</pre><p>Si vamos más allá, podriamos incluso realizar todo esto solamente utilizando el .forEach, pero ampliando el procedimiento:</p><pre>equipo<br>    .forEach(pokemon =&gt; {<br>        const {nombre, saludo} = pokemon<br>        console.log(nombre + &quot;: &quot; + saludo)<br>    })</pre><p>Es importante destacar que en el segmento de procedimiento, nada nos obliga a retornar directamente, ya que podemos tratarlo como un contexto en sí mismo e incluso definir variables dentro de este.</p><h4>Arrow function con dos o más argumentos</h4><p>Ahora veamos como es que podemos definir una arrow function que toma más de un argumento, tomando de ejemplo el método .reduce, para obtener el total de puntos de vida restantes del equipo. Este procedimiento lo veremos de forma similar al caso anterior:</p><pre>function obtenerHp(pokemon) {<br>    return pokemon.hp<br>}</pre><pre>function sumar(valorA, valorB) {<br>    return valorA + valorB<br>}</pre><pre>equipo<br>    .map(obtenerHp)<br>    .reduce(sumar)</pre><pre>equipo<br>    .map(function(pokemon) { return pokemon.hp })<br>    .reduce(function(a, b) { return a + b })</pre><pre>equipo<br>    .map(pokemon =&gt; pokemon.hp)<br>    .reduce((a,b) =&gt; a + b)</pre><h4>Arrow functions con argumentos predefinidos</h4><p>Finalmente, una última gran ventaja que encuentro poseen las arrow functions, y que es de gran ayuda en ciertos editores como VSCode: inferencia de tipo de datos y valores por defecto.</p><p>Para dar valores por defecto en Javascript, se requiere de hacer sobrecarga de una función, o verificar si los argumentos recibidos están definidos o no. Supongamos que queremos hacer una función que multiplique dos números entre sí, pero donde los argumentos puedan ser omitidos y tomar valores por defecto:</p><pre>function multiplica(a, b) {<br>    if (typeof(a) === &#39;undefined&#39;) a = 0<br>    if (typeof(b) === &#39;undefined&#39;) b = 10<br>    return a*b<br>}</pre><pre>multiplica() // retorna 0<br>multiplica(5) // retorna 50<br>multiplica(5,3) // retorna 15</pre><p>Con arrow functions, se puede lograr lo mismo de la siguiente forma:</p><pre>const multiplica = (a = 0, b = 10) =&gt; a*b</pre><pre>multiplica() // retorna 0<br>multiplica(3) // retorna 30<br>multiplica(4,7) // retorna 28</pre><p>En este ejemplo, registramos la función en la constante multiplica, por lo que para llamarla basta con hacer una invocación a la constante como si fuera una función.</p><p>Adicionalmente, al definir valores por defecto los editores más inteligentes, como VSCode o WebStorm, son capaces de inferir el tipo de dato que recibe las funciones, por lo que pueden entregarnos pistas y advertencias en caso de que estemos ejecutando una función que reciba, por ejemplo un string, y queramos entregarle como argumento un número o un arreglo.</p><p>Esta es la segunda entrega de varias más que se vienen acerca de Javascript y su uso con ES6, espero sea de utilidad. Todo comentario, crítica y consulta será bien recibido.</p><p>Para quienes quieran ver otros artículos de la temática de Javascript con sabor a ES6:</p><ul><li><a href="https://medium.com/@pabloulloacastro/javascript-con-sabor-a-es6-arrays-1500063ab92a">Javascript con sabor a ES6: Arrays</a></li><li><a href="https://medium.com/@pabloulloacastro/javascript-con-sabor-a-es6-spread-operator-rest-parameters-y-object-destructuring-1fcd860d1dfc">Javascript con sabor a ES6: Spread Operator, Rest Parameters y Object Destructuring</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6700414a5c1e" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>