<?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 Facundo Rodríguez Arceri on Medium]]></title>
        <description><![CDATA[Stories by Facundo Rodríguez Arceri on Medium]]></description>
        <link>https://medium.com/@facundomr?source=rss-fa74850821ac------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*9V1SKZYn_wgKpcLbTe0jGw.png</url>
            <title>Stories by Facundo Rodríguez Arceri on Medium</title>
            <link>https://medium.com/@facundomr?source=rss-fa74850821ac------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 19:43:52 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@facundomr/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[Recursos para aprender Kotlin]]></title>
            <link>https://medium.com/@facundomr/recursos-para-aprender-kotlin-e539d00b5aed?source=rss-fa74850821ac------2</link>
            <guid isPermaLink="false">https://medium.com/p/e539d00b5aed</guid>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[education]]></category>
            <category><![CDATA[kotlin-multiplatform]]></category>
            <dc:creator><![CDATA[Facundo Rodríguez Arceri]]></dc:creator>
            <pubDate>Sun, 14 Nov 2021 15:26:48 GMT</pubDate>
            <atom:updated>2021-11-15T11:35:56.991Z</atom:updated>
            <content:encoded><![CDATA[<p>Una de mis responsabilidades como parte del equipo docente de la <a href="https://ingenieria.unlam.edu.ar/index.php?seccion=3&amp;idArticulo=367">Tecnicatura en Desarrollo de Aplicaciones Móviles</a> de la UNLAM es la de ayudar a definir un plan de estudios para aquellas materias específicas donde los alumnos ponen manos a la obra por primera vez para desarrollar sus aplicaciones.</p><p>A la hora de elegir qué enseñar nos encontramos con el desafío de seleccionar un lenguaje de programación. En nuestro caso, por diversos motivos, hemos elegido Kotlin. Entre ellos, podemos destacar que:</p><ul><li>Es un lenguaje expresivo, moderno y distinto a lo que regularmente se ve en las Universidades.</li><li>Es un lenguaje de propósito general, que puede usarse para mucho más que sólo hacer aplicaciones móviles.</li><li>Dentro del mundo mobile, puede usarse para desarrollar para Android en forma nativa, como en Kotlin Multiplatform Mobile.</li></ul><p>De más está decir que este no es el único caso de aplicación de Kotlin en el mundo académico: en el sitio oficial de JetBrains hay un apartado de <strong><em>Kotlin in Education</em></strong> en el que se dan recursos para docentes, e incluso se incluye un listado de Unviersidades que han optado por enseñar el lenguaje:</p><p><a href="https://kotlinlang.org/education/">Kotlin Programming Language</a></p><p>Además, el sitio oficial de Android cuenta con una <a href="https://developer.android.com/teach">sección con recursos para enseñar Android</a>, entre los cuales se encuentra material para enseñar Kotlin.</p><h3>Bibliografía actual de las materias</h3><p>A pedido de varias personas que siempre me consultan sobre cómo empezar con el lenguaje y cómo lo enseñamos en la Universidad, dejo a continuación un listado de enlaces a distintos recursos que forman parte de la bibliografía que utilizamos en las materias de la Universidad. El crédito de esta recopilación no es sólo mío sino del equipo docente completo que está compuesto, entre otros grandes profesionales, por <a href="https://www.linkedin.com/in/sebastian-pardo">Sebastián Pardo</a> y <a href="https://www.linkedin.com/in/fabio-negri-a806105b">Fabio Negri</a>.</p><h3>Para empezar desde cero</h3><ul><li><strong>Artículo</strong>: Sintaxis básica del lenguaje: <a href="https://kotlinlang.org/docs/reference/basic-syntax.html">https://kotlinlang.org/docs/reference/basic-syntax.html</a></li><li><strong>Artículo</strong>: Resumen del lenguaje según el equipo de Android: <a href="https://developer.android.com/kotlin?hl=es">https://developer.android.com/kotlin</a></li><li><strong>Tutorial práctico</strong>: Introduction to Kotlin Pathway: <a href="https://developer.android.com/courses/pathways/android-basics-kotlin-one">https://developer.android.com/courses/pathways/android-basics-kotlin-one</a></li><li><strong>Para practicar</strong>: Kotlin Koans (ejercicios que pueden resolverse online, muy recomendado): <a href="https://play.kotlinlang.org/koans/overview">https://play.kotlinlang.org/koans/overview</a></li></ul><h3>Temas de nivel más intermedio/avanzado</h3><ul><li><strong>Artículo: </strong>Coroutines guide: <a href="https://kotlinlang.org/docs/coroutines-guide.html">https://kotlinlang.org/docs/coroutines-guide.html</a></li><li><strong>Artículo</strong>: Corrutinas en español: <a href="https://devexperto.com/corrutinas/">https://devexperto.com/corrutinas/</a></li><li><strong>Tutorial práctico</strong>: Coroutines <a href="https://play.kotlinlang.org/hands-on/Introduction%20to%20Coroutines%20and%20Channels/01_Introduction">https://play.kotlinlang.org/hands-on/Introduction%20to%20Coroutines%20and%20Channels/01_Introduction</a></li><li><strong>Artículo con ejemplos prácticos</strong>: Sealed classes: <a href="https://medium.com/droid-latam/sealed-classes-en-kotlin-por-qu%C3%A9-y-para-qu%C3%A9-67bb9e1f2e5e">https://medium.com/droid-latam/sealed-classes-en-kotlin-por-qu%C3%A9-y-para-qu%C3%A9-67bb9e1f2e5e</a></li><li><strong>Artículo</strong>: Serialization: <a href="https://kotlinlang.org/docs/serialization.html">https://kotlinlang.org/docs/serialization.html</a></li></ul><h3>Kotlin Multiplatform Mobile</h3><ul><li><strong>Charla en video: </strong>Los primeros 30 minutos son interesantes para entender de qué va Kotlin Multiplatform Mobile y por qué es distinta a otras tecnologías: <a href="https://www.youtube.com/watch?v=_oujlTE0LiY">https://www.youtube.com/watch?v=_oujlTE0LiY</a></li><li><strong>Artículos y tutoriales basicos:</strong> Documentación oficial: <a href="https://kotlinlang.org/docs/kmm-getting-started.html">https://kotlinlang.org/docs/kmm-getting-started.html</a> (hilo conductor de nuestro taller de KMM, pasamos por todas las subsecciones del mismo).</li><li><strong>Tutorial</strong>: SQLDelight: <a href="https://www.valueof.io/blog/installing-sqldelight-in-kotlin-multiplatform-project">https://www.valueof.io/blog/installing-sqldelight-in-kotlin-multiplatform-project</a></li><li><strong>Documentación</strong> sobre Testing: <a href="https://kotlinlang.org/api/latest/kotlin.test/">https://kotlinlang.org/api/latest/kotlin.test/</a></li><li><strong>Video tutoriales</strong>: Kotlin by Jetbrains playlist en YouTube: <a href="https://www.youtube.com/watch?v=GcqFhoUuNNI&amp;list=PLlFc5cFwUnmy_oVc9YQzjasSNoAk4hk_C&amp;index=3">https://www.youtube.com/watch?v=GcqFhoUuNNI&amp;list=PLlFc5cFwUnmy_oVc9YQzjasSNoAk4hk_C&amp;index=3</a></li></ul><p>Intentaré mantener actualizado este listado a medida que se agreguen nuevos recursos a las materias de la Universidad.</p><p><em>Happy coding! 😄</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e539d00b5aed" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[¿Cómo colaborar con DroidLATAM?]]></title>
            <link>https://medium.com/droid-latam/c%C3%B3mo-colaborar-con-droidlatam-7609a72ba8a7?source=rss-fa74850821ac------2</link>
            <guid isPermaLink="false">https://medium.com/p/7609a72ba8a7</guid>
            <dc:creator><![CDATA[Facundo Rodríguez Arceri]]></dc:creator>
            <pubDate>Wed, 12 Aug 2020 22:06:03 GMT</pubDate>
            <atom:updated>2020-08-13T03:27:49.753Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*WuL7Awb7HphMpX_Z" /><figcaption>Photo by <a href="https://unsplash.com/@nickmorrison?utm_source=medium&amp;utm_medium=referral">Nick Morrison</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Enterate de cómo podes hacer para sumar un artículo a la publicación de <a href="https://medium.com/droid-latam">DroidLATAM</a>.</p><p>Nuestro principal objetivo es ayudar a los desarrolladores de habla hispana a encontrar contenido de calidad y en su idioma de una manera fácil y cómoda.</p><p>Si te interesa ser autor de la publicación y poder sumar tus artículos a ella, estas son algunas cosas a tener en cuenta:</p><ul><li>El tema del artículo debe estar relacionado con Android pero puede no estar específicamente limitado a desarrollo nativo. Esto incluye lenguajes de programación como Kotlin, librerías como Firebase, etc.</li><li>Aceptamos artículos de cualquier nivel: desde introductorios hasta avanzados.</li><li>No hay recompensas por escribir artículos, todo lo que hace esta comunidad es sin fines de lucro y aporta a subir la vara de los profesionales de la región.</li><li>Si vas a usar código de ejemplo, usa <em>Github gists</em> o aplicale un buen formato, para mejorar la legibilidad.</li><li>Utiliza una imagen de calidad para empezar tu artículo.</li><li>Podes incluír links útiles o de referencia al final de tu artículo, no importa si están en inglés.</li><li>Utiliza un corrector de ortografía para chequear que el artículo esté bien antes de enviarlo.</li></ul><p><a href="https://forms.gle/3F7jc7rvxhYokTPN9">Envía tu artículo usando este formulario</a></p><p>¡Muchas gracias!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7609a72ba8a7" width="1" height="1" alt=""><hr><p><a href="https://medium.com/droid-latam/c%C3%B3mo-colaborar-con-droidlatam-7609a72ba8a7">¿Cómo colaborar con DroidLATAM?</a> was originally published in <a href="https://medium.com/droid-latam">Droid LATAM</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Sealed classes en Kotlin: ¿Por qué y para qué?]]></title>
            <link>https://medium.com/droid-latam/sealed-classes-en-kotlin-por-qu%C3%A9-y-para-qu%C3%A9-67bb9e1f2e5e?source=rss-fa74850821ac------2</link>
            <guid isPermaLink="false">https://medium.com/p/67bb9e1f2e5e</guid>
            <category><![CDATA[sealed-classes]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[kotlin]]></category>
            <dc:creator><![CDATA[Facundo Rodríguez Arceri]]></dc:creator>
            <pubDate>Mon, 10 Aug 2020 02:32:29 GMT</pubDate>
            <atom:updated>2021-10-01T17:23:09.408Z</atom:updated>
            <content:encoded><![CDATA[<p>Este artículo es un resumen en forma escrita de mi charla en el canal <a href="https://twitter.com/TGIKotlin"><em>Thank’s God It’s Kotlin</em></a>, para aquellos que prefieren tener una referencia escrita en lugar de verla en video. De todas formas, si te interesa el video, te lo dejo por acá:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FLmMD3fjo3N4&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DLmMD3fjo3N4&amp;image=http%3A%2F%2Fi.ytimg.com%2Fvi%2FLmMD3fjo3N4%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/e20c6caa5d4565dd6bfd87350c8a0d0f/href">https://medium.com/media/e20c6caa5d4565dd6bfd87350c8a0d0f/href</a></iframe><h3>¿Por qué existen las sealed classes?</h3><p>Hay veces en las que necesitamos representar una jerarquía limitada y cerrada de casos posibles para ciertos tipos de datos. Por lo general cuando se nos presenta esta situación, y ya tenemos experiencia con otros lenguajes de programación pensamos inmediatamente en los <strong>enumerados. </strong>Veamos qué podemos hacer con ellos modelando el sistema solar.</p><h4>Usando <em>enum</em> para modelar los planetas</h4><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/523cbc6744d9dd10944bcf7413589b77/href">https://medium.com/media/523cbc6744d9dd10944bcf7413589b77/href</a></iframe><p>En ese ejemplo incluímos solo tres planetas (para no hacer demasiado largo el código de ejemplo) pero básicamente vemos las dos principales características de los enumerados: los subtipos posibles del tipo Planet son limitados: no pueden ser otros que los definidos dentro de este. Además, hemos definido un atributo id para cada Planeta, y una función orbit que todos estos deben implementar.</p><p>Las limitaciones también están a la vista: no pueden representarse subjerarquías dentro de Planet, cada tipo es concreto, motivo por el cual todas las instancias de este tipo tienen exactamente los mismos atributos y funciones, limitando la flexibilidad de esta herramienta.<br>Otra limitación que hay que tener clara es que cuando uno escribe <strong>enums</strong> lo que hace (tanto en Java como en Kotlin) es generar una única instancia de cada valor definido, por lo tanto no pueden existir dos objetos distintos que representen a, por ejemplo, Mercury.</p><p>Existe otro tipo de clase en Kotlin que puede ayudarnos a romper con estas limitaciones: las clases abstractas.</p><h4>Usando abstract class para modelar los planetas</h4><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/426fec33e39153c60835daec6c6b1dc0/href">https://medium.com/media/426fec33e39153c60835daec6c6b1dc0/href</a></iframe><p>Vemos como ahora podemos crear subtipos dentro de Planet, en este caso BasicPlanet y PlanetWithSatellites, y a su vez crear a demanda las instancias que querramos, como se ve en la implementación de la función main<em>.</em></p><p>De esta forma podemos representar subjerarquías, y que cada una de ellas agregue los atributos y funciones que sean necesarios para diferenciarse entre ellas. En el ejemplo, PlanetWithSatellites tiene un listado con los nombres de los satélites de los planetas que representa.</p><p>La principal limitación de las clases abstractas es que dejan de tener un conjunto limitado de valores, puesto que otros desarrolladores podría crear una clase que herede de Planet en cualquier otra parte del proyecto, por lo cual perdemos el control sobre los subtipos posibles. Las <strong>sealed classes</strong> vienen a cubrir este hueco que hay entre los enumerados y las clases abstractas. Veamos cómo:</p><h4>Usando sealed class para modelar los planetas</h4><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/63808e400f55b3c942589b5481bbc84e/href">https://medium.com/media/63808e400f55b3c942589b5481bbc84e/href</a></iframe><p>El ejemplo es casi idéntico al de la clase abstracta, pero con una particularidad: para poder heredar de Planet<em> </em>se deberá escribir esa clase dentro del mismo módulo y paquete donde la <strong><em>sealed class</em></strong> está definida (o como clases anidadas, como se ve en el código), caso contrario el compilador dará un error. De esta forma recuperamos la ventaja que tenían los enumerados: los subtipos posibles están limitados. Anteriormente, las subclases de una <strong><em>sealed class</em> </strong>debían estar todas dentro del mismo archivo que la clase padre, pero esto cambió desde <a href="https://kotlinlang.org/docs/whatsnew15.html#package-wide-sealed-class-hierarchies">Kotlin 1.5.0</a>.</p><p>Cabe destacar también que, por definición, las <strong>sealed classes</strong> funcionan como clases abstractas y que los subtipos de estas pueden ser clases de cualquier tipo: <strong>class</strong>, <strong>abstract class, data class, object, open class y… ¡sealed class!. </strong>Por lo tanto las posibilidades son infinitas y es posible adaptar el uso de estas clases a nuestra necesidad puntual.</p><h3>Sobre el uso de if y when como expresiones</h3><p>Existe una similitud más entre los <strong><em>enums</em> </strong>y las<strong> <em>sealed classes</em></strong>, y es que estos tipos de datos son <strong>exhaustivos</strong> cuando usamos <strong><em>when</em> </strong>o <strong><em>if</em></strong> como expresiones, es decir, cuando queremos obtener un resultado a partir de la ejecución de un condicional sobre un dato que es de estos tipos. Esto nos obliga a cubrir todos los casos posibles, caso contrario el compilador no sabrá de qué tipo será la variable resultante. En la siguiente captura podemos ver esto.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2SPkDGlO80EE2EqdGUzHUw.png" /></figure><p>Y el código resultante al agregar las ramas de ejecución faltantes es el siguiente.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e4b37ba0b144e5bdc6320c6a8369e1c8/href">https://medium.com/media/e4b37ba0b144e5bdc6320c6a8369e1c8/href</a></iframe><p>Por supuesto que también podríamos haber agregado un <strong><em>else</em></strong> y listo, pero esto no es recomendable, ya que en caso de agregar nuevos subtipos a la <strong><em>sealed class</em></strong> no se producirá un error de compilación en la aplicación. El uso exhaustivo con <strong><em>enums</em></strong> y <strong><em>sealed classes</em></strong> es una ventaja y podemos aprovecharnos de ello para forzar errores de compilación en lugares del código donde habría que tomar consideraciones adicionales al agregar nuevos tipos. El problema es que este uso exhaustivo funciona sólo al usar <strong><em>if </em></strong><em>I</em><strong><em> when </em></strong>como expresiones. Podemos forzar a que estas operaciones sean exhaustivas siempre agregando una <strong><em>extension</em></strong> <strong><em>property. </em></strong>Para ello dejo en la sección de Links de interés el enlace al artículo <strong><em>“Sealed with a class”</em></strong>, donde se explica en detalle cómo lograr esto.</p><h3>¿Te gustaría ver algunos ejemplos de uso?</h3><p>Dejo a continuación el enlace a un repositorio de ejemplo que desarrollé donde muestro el uso de <strong><em>sealed classes</em></strong> en tres situaciones disintas:</p><ul><li>Para modelar jerarquías cerradas (Planet)</li><li>Para modelar estados posibles de una vista (PlanetsViewModel.State)</li><li>Para modelar distintas combinaciones de parámetros que pueden utilizarse para acceder a una Activity (PlanetDetailParams).</li></ul><p><a href="https://github.com/facundomr/planets-sealed-classes">facundomr/planets-sealed-classes</a></p><h3>Links de interés</h3><ul><li><a href="https://kotlinlang.org/docs/reference/sealed-classes.html">Documentación oficial de Kotlin: Sealed classes</a></li><li><a href="https://medium.com/androiddevelopers/sealed-with-a-class-a906f28ab7b5">Kotlin vocabulary — Sealed with a class</a></li><li><a href="https://devexperto.com/sealed-classes-kotlin/">Sealed classes en Kotlin: los enums con superpoderes</a></li><li><a href="https://proandroiddev.com/til-when-is-when-exhaustive-31d69f630a8b">TIL: when is “when” exhaustive?</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=67bb9e1f2e5e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/droid-latam/sealed-classes-en-kotlin-por-qu%C3%A9-y-para-qu%C3%A9-67bb9e1f2e5e">Sealed classes en Kotlin: ¿Por qué y para qué?</a> was originally published in <a href="https://medium.com/droid-latam">Droid LATAM</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Pensá antes de usar BuildConfig.DEBUG]]></title>
            <link>https://medium.com/droid-latam/pens%C3%A1-antes-de-usar-buildconfig-debug-62b592422b64?source=rss-fa74850821ac------2</link>
            <guid isPermaLink="false">https://medium.com/p/62b592422b64</guid>
            <category><![CDATA[androiddev]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[android-app-development]]></category>
            <dc:creator><![CDATA[Facundo Rodríguez Arceri]]></dc:creator>
            <pubDate>Fri, 28 Feb 2020 20:08:36 GMT</pubDate>
            <atom:updated>2020-02-29T18:25:56.993Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*MRCHE5Pb9NnpoBdH" /><figcaption>Photo by <a href="https://unsplash.com/@hackcapital?utm_source=medium&amp;utm_medium=referral">Hack Capital</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>La semana pasada me encontraba trabajando en una funcionalidad que se encargaba de sincronizar información entre el dispositivo y el backend. Este mecanismo de sincronización es disparado bajo ciertas condiciones y lo que necesitábamos era tener una forma de saltearnos esas condiciones y forzar el proceso de sincronización al habilitar cierta preferencia disponible sólo cuando estamos en modo debug. Dejando de lado los detalles, el código resultante era algo como lo siguiente:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f396ed2e06c4580e49df1bf2cfbf9d69/href">https://medium.com/media/f396ed2e06c4580e49df1bf2cfbf9d69/href</a></iframe><p>Bastante simple. Utilicé como condición la constanteBuildConfig.DEBUG<a href="https://developer.android.com/studio/build/gradle-tips.html#share-custom-fields-and-resource-values-with-your-app-code">que genera Android Studio</a>.</p><h3>El problema</h3><p>Todo parecía estar bien para mí hasta que recibí un comentario en el pull request correspondiente:</p><blockquote><strong>No quisiera incluir funcionalidad de Debug junto con nuestro código productivo dentro del APK/Bundle.</strong></blockquote><p>Estoy de acuerdo con esto, y hay varias razones para ello:</p><ul><li>⛔ Definitivamente no es una buena práctica.</li><li>🔒 Puede resultar en problemas de seguridad: ¿Qué pasa si alguien decompila el artefacto generado y encuentra que estás haciendo trucos para saltearte validaciones? ¿Qué pasaría si logran replicar ese comportamiento? <strong>Edit:</strong> Si usas Proguard/R8 esto <strong>no</strong> debería ser una preocupación, ya que las optimizaciones que realiza el compilador hará que sea imposible ver la condición utilizada. De todas formas recordá que estas herramientas no vienen habilitadas al crear un nuevo proyecto y deberías ocuparte de ello.</li><li>🐞 ¿Y si hubiera un bug en la generación de la clase BuildConfig? Tal vez ni siquiera lo consideraste, pero tengo que contarte que hace algunos años había <a href="https://issuetracker.google.com/issues/36943404">un bug no resuelto que causaba que </a><a href="https://issuetracker.google.com/issues/36943404">BuildConfig.DEBUG retornara siempre <em>true</em>, incluso en el .apk generado</a>.</li></ul><h3>Hay mejores alternativas a esto…</h3><p>… pero la correcta depende de lo que estés intentando hacer.</p><p>Publiqué un tweet con una encuesta y gracias a las respuestas pude aprender bastante sobre la forma en la que los desarrolladores utilizamos esta constante, y cuándo y por qué estamos haciendo las cosas de forma probablemente errónea.</p><h3>Facundo Rodríguez Arceri on Twitter</h3><p>Hey #androiddev 👋 Are you using BuildConfig.DEBUG in your code to execute some development/debug code variation in your project? Tell me how/why 👇 RT for greater reach</p><h3>Incluir funcionalidad sólo disponible en debug</h3><p>Este es mi escenario, pero recibí algunas respuestas de otros desarrolladores que tienen un problema similar, por ejemplo agregar Interceptors a los requests HTTP de la aplicación para poder hacer logging. Deberíamos evitar hacer esto y mi recomendación es utilizar el poder de los flavors para poder separar la lógica de debug de la lógica productiva, incluyendo la misma clase en los flavors de release y debug. En mi caso particular, el resultado está incluido en los siguientes fragmentos de código.</p><p>La funciónsyncData original debería ser tan simple como:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b183f3b513d3aa26be1244e308f9a557/href">https://medium.com/media/b183f3b513d3aa26be1244e308f9a557/href</a></iframe><p>✨ <strong>Magia</strong>. No hay ningún condicional que dependa del ambiente. Ahora estamos delegando la condición a un objeto llamado SyncCoordinator, veamos cómo deberíamos implementarlo:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ac7f9fab40c0bbfead0fd150b8b44ce4/href">https://medium.com/media/ac7f9fab40c0bbfead0fd150b8b44ce4/href</a></iframe><p>Nótese que estos objetos tienen el mismo nombre y que están, obviamente, en dos archivos diferentes. La clave es la ruta del archivo: el primero está bajo el directoriosrc/release y el segundo ensrc/debug. El sistema de build va a utilizar sólo una de estas implementaciones dependiendo de cuál sea el build variant activo. Cuidado: no es posible tener una clase base y luego intentar sobre-escribirla en cada flavor. Podes encontrar más información sobre esto en <a href="https://stackoverflow.com/questions/31733937/why-wont-gradle-override-java-classes-in-different-android-flavors">esta pregunta de StackOverflow</a>.</p><p>También habrás notado que esta forma de separar las cosas nos permite, también, escribir los tests en forma separada para cada flavor, y así poder mantener los tests dedebug de forma independiente a los de release, lo cual es mucho más limpio en el código. Las clases que contengan estos tests deberían estar en los siguientes directorios: MyProject/src/<strong>testDebug</strong>/java/com/facundomr/example/util/SyncCoordinatorTest.kt y MyProject/src/<strong>testRelease</strong>/java/com/facundomr/example/util/SyncCoordinatorTest.kt .</p><p>Ahora que resolvimos esto podemos avanzar y evaluar otras situaciones posibles:</p><h3>Cambiar un valor/constante dependiendo del flavor</h3><p>Si sólo querés definir un valor distinto entonces no tenés que escribir ningún código extra. Podés definir el mismo buildConfigField en cada flavor y eso es suficiente. Para más información sobre esto seguí la <a href="https://developer.android.com/studio/build/gradle-tips#share-custom-fields-and-resource-values-with-your-app-code">documentación oficial</a>.</p><h3>Incluir librerías que sólo se necesitan cuando estás en modo debug</h3><p>Si estás haciendo esto, probablemente no sólo estás incluyendo funcionalidad de debug en tu .apk productivo sino que <strong>probablemente estés incrementando significativamente el tamaño y la cantidad de métodos (<em>method count</em>) de tu aplicación</strong>. Para evitar esto te recomiendo leer el siguiente artículo sobre <a href="https://medium.com/@orhanobut/no-op-versions-for-dev-tools-b0a865934398">No-op versions for dev tools</a>.</p><h3>Evitar que se ejecute cierto código en producción</h3><p>La diferencia es sutil: no es lo mismo incluir funcionalidad de debug que evitar que en producción se ejecute algún código en particular: en este caso probablemente no debas tener ninguna preocupación sobre posibles problemas de seguridad si alguien llegara a descubrir que, por ejemplo, estás deshabilitando los logs basándote en una condición tan simple como depender deBuildConfig.DEBUG. De todas formas hay una manera mucho mejor y más elegante de hacer esto: usar <strong>Proguard</strong> para eliminar esas líneas al momento de exportar tu artefacto. Te recomiendo este <a href="https://medium.com/@trionkidnapper/stripping-log-statements-using-proguard-73dedc68ee97">artículo de Craig Russell</a>.</p><h3>¡Cuidado cuando escribís tu app en módulos!</h3><p>Si estás estructurando tu app en distintos módulos (por ejemplo:app y ui, y estás dependiendo de la constante en el módulo uipara hacer algo particular, entonces tené cuidado: BuildConfig.DEBUG en app no es lo mismo queBuildConfig.DEBUG en el móduloui: <strong>podrías estar ejecutando código de debug incluso en el .apk generado</strong>. Hay una forma más segura de hacer un chequeo global sobre si la app se está ejecutando en modo debug o no: se llama ApplicationInfo.FLAG_DEBUGGABLE. <a href="https://hackernoon.com/checking-debug-build-the-right-way-d12da1098120">Podés leer el siguiente artículo para aprender más sobre cómo utilizarla</a>.</p><h3>Conclusión: ¿Debería siempre evitar el uso de BuildConfig.DEBUG?</h3><p><strong>Definitivamente no.</strong> No estoy diciendo eso. Puede haber situaciones en la no te preocupe nada de lo que menciono en este artículo y está perfectamente bien usar la constante, por ejemplo: deshabilitar Crashlytics en debug. Cuando hagas esto de esa forma:</p><ul><li>De todas formas vas a incluir la librería en producción.</li><li>No estás incluyendo funcionalidad de debug.</li><li>No es peligroso que alguien descubra que estás deshabilitando los reportes de error cuando probás tu propia app.</li></ul><p>Mi única conclusión es: <strong>deberíamos estar considerando todas estas opciones antes de escribir código que utiliza la constante </strong><strong>BuildConfig.DEBUG.</strong> Quizás hay una forma mejor, más segura y elegante de lograr lo mismo, y siempre está bueno aprender cosas nuevas.</p><p>Happy coding! 😊</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=62b592422b64" width="1" height="1" alt=""><hr><p><a href="https://medium.com/droid-latam/pens%C3%A1-antes-de-usar-buildconfig-debug-62b592422b64">Pensá antes de usar BuildConfig.DEBUG</a> was originally published in <a href="https://medium.com/droid-latam">Droid LATAM</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Think before using BuildConfig.DEBUG]]></title>
            <link>https://proandroiddev.com/think-before-using-buildconfig-debug-f2e279da7bad?source=rss-fa74850821ac------2</link>
            <guid isPermaLink="false">https://medium.com/p/f2e279da7bad</guid>
            <category><![CDATA[androiddev]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[debugging]]></category>
            <category><![CDATA[gradle]]></category>
            <category><![CDATA[android-app-development]]></category>
            <dc:creator><![CDATA[Facundo Rodríguez Arceri]]></dc:creator>
            <pubDate>Thu, 27 Feb 2020 13:41:29 GMT</pubDate>
            <atom:updated>2020-02-29T18:25:28.750Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*MRCHE5Pb9NnpoBdH" /><figcaption>Photo by <a href="https://unsplash.com/@hackcapital?utm_source=medium&amp;utm_medium=referral">Hack Capital</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Last week I was working on a feature that syncs data between phone and backend. That sync mechanism is triggered under certain conditions and we needed a way to bypass those conditions and force the sync when enabling some preference in debug mode. Leaving aside the details, the resulting code was something like the following:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f396ed2e06c4580e49df1bf2cfbf9d69/href">https://medium.com/media/f396ed2e06c4580e49df1bf2cfbf9d69/href</a></iframe><p>Pretty simple. I relied on the BuildConfig.DEBUGconstant <a href="https://developer.android.com/studio/build/gradle-tips.html#share-custom-fields-and-resource-values-with-your-app-code">generated by Android Studio</a>.</p><h3>The problem</h3><p>Everything seemed fine to me until I received a comment in the pull request:</p><blockquote><strong>I would not want to ship Debug functionality in our Production APK/Bundle code.</strong></blockquote><p>I agree that we shouldn’t ship debug functionality in the published artifact, and there are many reasons for that:</p><ul><li>⛔ It’s definitely not a good practice.</li><li>🔒 It can introduce security issues: what if someone decompiles the generated artifact and found that you are doing some tricks to avoid a validation? What if someone manages to replicate that behavior? <strong>Edit:</strong> If you are using Proguard/R8 this <strong>isn’t</strong> a real problem for you, because the compiler optimizations will hide the real condition. Anyway: remember that this tools aren’t enabled by default and you need to take are about it.</li><li>🐞 And what if there is a bug in the generation of the BuildConfig class? Maybe you didn’t even consider it, but let me tell you that some years ago there was an unresolved <a href="https://issuetracker.google.com/issues/36943404">bug that caused </a><a href="https://issuetracker.google.com/issues/36943404">BuildConfig.DEBUG was always true, even in the generated .apk file</a>.</li></ul><h3>There are better alternatives…</h3><p>… but the correct one depends on what you are trying to do.</p><p>I published a tweet with a poll and thanks to the responses I learned a lot about the way developers are using this constant, and when and why we are doing things in a, probably, wrong way.</p><h3>Facundo Rodríguez Arceri on Twitter</h3><p>Hey #androiddev 👋 Are you using BuildConfig.DEBUG in your code to execute some development/debug code variation in your project? Tell me how/why 👇 RT for greater reach</p><h3>Including debug functionality</h3><p>This is my own scenario, but I received some responses from developers facing a similar one, for example adding Interceptors to the HTTP requests in the app in order to log requests and responses. We should avoid this and my recommendation is to use the power of flavors in order to separate debugging logic from the production logic, including the same classes in the release and the debug flavor. In my case, the result is included in the following snippets:</p><p>The original syncData function should be as simple as:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b183f3b513d3aa26be1244e308f9a557/href">https://medium.com/media/b183f3b513d3aa26be1244e308f9a557/href</a></iframe><p>✨ <strong>Magic</strong>. No conditionals. Now we are delegating the condition to a function included in an object called SyncCoordinator, let’s see how to implement it:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ac7f9fab40c0bbfead0fd150b8b44ce4/href">https://medium.com/media/ac7f9fab40c0bbfead0fd150b8b44ce4/href</a></iframe><p>Note that these objects have the same name and they are, obviously, in two different files. The file path is the key: the first one is under the src/release directory and the second one is in src/debug. Build system will include just one of these implementations based on the active build variant. Be careful: it’s not possible to have a main class and try to override it in flavors. You can find more information about it in <a href="https://stackoverflow.com/questions/31733937/why-wont-gradle-override-java-classes-in-different-android-flavors">this StackOverflow question</a>.</p><p>You will note also that this approach allow us to write separate unit test classes for each flavor, and maintain debug tests isolated from the release tests, which is so much cleaner. These classes should be included in a path like the following: MyProject/src/<strong>testDebug</strong>/java/com/facundomr/example/util/SyncCoordinatorTest.kt and MyProject/src/<strong>testRelease</strong>/java/com/facundomr/example/util/SyncCoordinatorTest.kt .</p><p>Now, let’s move forward and evaluate other situations:</p><h3>Changing a value/constant depending on the flavor</h3><p>If you just want to get a different value in a constant, then you don’t need to write any extra code. Defining the same buildConfigField in every flavor should be enough. Follow the <a href="https://developer.android.com/studio/build/gradle-tips#share-custom-fields-and-resource-values-with-your-app-code">official documentation</a> for more information about this capability.</p><h3>Including libraries needed only when in debug mode</h3><p>If you are doing this, then you are not just including debug functionality: <strong>you are probably increasing significantly the size and method count of the released artifact</strong>. In order to avoid this you should read this article about <a href="https://medium.com/@orhanobut/no-op-versions-for-dev-tools-b0a865934398">No-op versions for dev tools</a>.</p><h3>Avoiding code execution in production</h3><p>The difference can be subtle: it’s not the same to include debug features as to avoid some code execution in production: because maybe you should’t be scared of security issues if someone discovers that you are, for example, disabling logs based on a condition as simple as relying on BuildConfig.DEBUG. But there are better and more elegant way to do this: use <strong>Proguard</strong> to remove that lines when exporting your artifact. I recommend this <a href="https://medium.com/@trionkidnapper/stripping-log-statements-using-proguard-73dedc68ee97">article from Craig Russell about Stripping log statements using Proguard</a>.</p><h3>Warning: very careful when you write modules in your app</h3><p>If you are writing an app and the code is structured in modules (for example: app and ui, and you are depending on the constant in the uimodule to do some debug logic, then be careful: BuildConfig.DEBUG in app is not the same as BuildConfig.DEBUG in the ui module: <strong>you can be executing debug code even in the released artifact</strong>. There is a safer way to check globally if a build is in debug mode or not: it’s called ApplicationInfo.FLAG_DEBUGGABLE. <a href="https://hackernoon.com/checking-debug-build-the-right-way-d12da1098120">You can read this article to learn about it</a>.</p><h3>Conclusion: Should we always avoid using BuildConfig.DEBUG?</h3><p><strong>Definitely not.</strong> I’m not trying to say that. There can be situations in which you shouldn’t be concerned about it and it’s perfectly fine to rely on the constant, for example disabling Crashlytics on debug. When you use an if statement for this:</p><ul><li>You still need to include the library in production.</li><li>You are not shipping a debug feature.</li><li>It’s not dangerous if someone discovers that you are disabling crash reports when debugging the app.</li></ul><p>My only conclusion is: <strong>we should consider all these options before writing code that depends on the </strong><strong>BuildConfig.DEBUG constant.</strong> Maybe there is a better, safer and more elegant way to achieve the same goal, and it’s always nice to learn new things.</p><p>Happy coding! 😊</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f2e279da7bad" width="1" height="1" alt=""><hr><p><a href="https://proandroiddev.com/think-before-using-buildconfig-debug-f2e279da7bad">Think before using BuildConfig.DEBUG</a> was originally published in <a href="https://proandroiddev.com/">ProAndroidDev</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to be a good speaker]]></title>
            <link>https://medium.com/@facundomr/how-to-be-a-good-speaker-c51a64820a5c?source=rss-fa74850821ac------2</link>
            <guid isPermaLink="false">https://medium.com/p/c51a64820a5c</guid>
            <dc:creator><![CDATA[Facundo Rodríguez Arceri]]></dc:creator>
            <pubDate>Fri, 17 Jan 2020 21:04:56 GMT</pubDate>
            <atom:updated>2020-01-17T21:04:56.673Z</atom:updated>
            <content:encoded><![CDATA[<p>Here I leave some tips on how to be a better speaker, based on my personal experience as a speaker and event organizer.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*e9zZYfiA5BWl_VXJ" /><figcaption>Photo by <a href="https://unsplash.com/@productschool?utm_source=medium&amp;utm_medium=referral">Product School</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Get ready</h3><ul><li>If you are traveling to an event, let the organisers know in advance the following information:</li></ul><p>— Your phone number, in case something comes up regarding the trip.</p><p>— Flight/Bus number, in order to allow them to keep track of your trip and help them if they are going to pick up you in the airport/terminal.</p><ul><li>Ask the organizers if the atmosphere will be dark or bright: if lights are dim, then a light theme for your slides will be an error: the contrast will not allow people to observe you correctly. Instead, a dark theme will fit perfectly. And vice versa: if the room is full illuminated, a dark theme can be a problem and you will prefer to use a light one.</li><li>Check the venue setup in advance:</li></ul><p>— What kind of port has the projector/videowall? Will you need adapters?</p><p>— The venue has its own clickers, or can you use yours?</p><h3>Delight your audience</h3><ul><li>Don’t talk fast enough to make it hard for the audience to follow and understand you, and don’t do it so slowly enough to make it seem like you do it on purpose.</li><li>Use an appropiate vocabulary. Be professional, don’t use bad words, you can make jokes as long as they don’t offend others, be careful with the words you use.</li><li>Practice your body language: Do not gesture too much or stand still on the stage.</li><li>Engage with the audience: you can make open questions to them, try to get some interaction during the talk.</li><li>Set expectations: Make it clear from the beginning if questions can be asked during the talk or only at the end. Ask people to not take pictures to the slides: the organisation team and you are going to publish them later.</li></ul><h3>Be professional</h3><ul><li>Arrive early to the event. Don’t arrive 15 minutes before your talk: it is good manners. There are some things that you can do if you come early. People are going to the event in order to know you. You can be available for the organisers if they need to make a last minute change in the agenda. You can help other speakers with their setup.</li><li>Don’t leave just after your talk: set aside time to talk with people after your exposition. Consider it part of your work as a speaker.</li><li>Practice your presentation. Slides should be correct, no errors. There doesn’t have to be problems with slides, animations or something like that. This is especially important if you are going to show code or, worst, do some live coding.</li><li>Respect your schedule. If you have 45 minutes assigned, you can’t extend for 1h30m. You are reconfiguring the event schedule, making things hard for organisers and you are disrespecting the following speakers.</li><li>Don’t lie: If you don’t know the answer to a question, the best thing you can do is commit to looking for the answer later.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c51a64820a5c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Six reasons to convince your team to start using Kotlin for Android]]></title>
            <link>https://medium.com/@facundomr/six-reasons-to-convince-your-team-to-start-using-kotlin-for-android-4e47c2e36546?source=rss-fa74850821ac------2</link>
            <guid isPermaLink="false">https://medium.com/p/4e47c2e36546</guid>
            <category><![CDATA[android]]></category>
            <category><![CDATA[androiddev]]></category>
            <category><![CDATA[kotlin]]></category>
            <dc:creator><![CDATA[Facundo Rodríguez Arceri]]></dc:creator>
            <pubDate>Thu, 05 Dec 2019 14:30:16 GMT</pubDate>
            <atom:updated>2019-12-07T12:20:19.536Z</atom:updated>
            <content:encoded><![CDATA[<p>Although it has been a long time since Kotlin is officially supported to develop applications for Android, I still find people who tell me that in their work they refuse to adopt a new language. In fact, <a href="https://android-developers.googleblog.com/2019/12/androids-commitment-to-kotlin.html?linkId=78379874">just early 60% of the top 1,000 Android apps contain Kotlin code</a>. In this post I want to give six good arguments to try to convince your boss, technical leader and other developers that starting with Kotlin is the right choice.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*90_MxRZD3GakfnQRxQ6o7g.jpeg" /></figure><h4>1. Increase team productivity</h4><p>Kotlin has features that allow you to write more <strong>concise</strong> code: you can do the same as in Java but in fewer lines. That means there is less code to read, understand and maintain, reducing maintenance costs and the risks of defects, <a href="http://petersommerhoff.com/dev/kotlin/kotlin-concise-code/">some examples of this can be found her</a>e. Also it has <strong>security</strong> as one of its main features: the @Nullable and @NonNull types allow us to avoid misuse of our functions and have to do nullchecks all the time, practicing defensive programming. <a href="https://kotlinlang.org/docs/reference/null-safety.html">Learn more</a>.</p><h4>2. It’s booming: take advantage of this to make your team happy.</h4><p>It is the <strong>fourth most loved language </strong>on GitHub,<a href="https://insights.stackoverflow.com/survey/2019"> 72.6% of developers who use it say so</a>. It also won the <a href="https://medium.com/%20/%20/blog.jetbrains.com/kotlin/2019/07/kotlin-wins-breakout-project-of-the-year-award-at-oscon-19/">Breakout Project of the Year at OSCON ’19</a>. Google itself, in collaboration with JetBrains, drove the Kotlin/Everywhere conference cycle this year. In addition, learning and working with new and trending technologies helps maintain a <strong>high level of motivation in the team</strong>.</p><h4>3. You don’t need to migrate anything</h4><p>The most common strategy that I have seen so far in the companies where I worked and with the colleagues with whom I spoke to adopt Kotlin is to do it little by little and following a very simple rule: <strong>Every new source code file of the project must be written in Kotlin, mandatorily</strong>. If you work on modifications of code written in Java you can choose whether you want to migrate it or not, but to begin with it is good to focus on everything new is in Kotlin. <a href="https://medium.com/google-developer-experts/on-strategies-to-apply-kotlin-to-existing-java-code-6317974717ec">Other strategies can be found in this post</a>.</p><h4>4. It is not that hard to learn</h4><p>It has the same conventions as Java, and there is an infinite amount of material online. You can learn:</p><ul><li><a href="https://developer.android.com/kotlin/learn">With the official Android guide</a>.</li><li><a href="https://kotlinlang.org/docs/tutorials/koans.html">Exercising online</a>.</li><li><a href="https://antonioleiva.com/kotlin-android-developers/">Reading a book</a>.</li><li><a href="https://www.youtube.com/watch?v=Cv1jQtV_AGw&amp;list=PLEPZdzLLJH964FjaGyzyNChnQgAObu0LN">Watching YouTube videos</a>.</li><li><a href="https://www.udacity.com/course/kotlin-for-android-developers--ud888">Taking a course</a>.</li></ul><h4>5. You will have absolutely no compatibility issues</h4><p>One of the main advantages of Kotlin is its <strong>interoperability</strong>, that is, all the code you keep in Java can still be invoked from Kotlin, and vice versa: everything new that you write in Kotlin can be used from Java without any inconvenience. No version problems, no weird tricks. For more information <a href="https://www.youtube.com/watch?v=LZFzRXCO95o">check this AndroidDevSummit talk</a>.</p><h4>6. Future growth perspective</h4><p>Kotlin went from being a language with official support to being the recommended one for Android. <strong>Everyday more and more people start on the platform without going through Java, directly through Kotlin</strong>. In the future it may be difficult to get trained developers to maintain your app if it is completely written in Java. In addition, Google announced that while maintaining support for Java (and C ++), it will have a <a href="https://medium.com/@imstudio/android-what-does-kotlin-first-mean-java-or-kotlin-78bcd06f7ab0">Kotlin-first approach</a> when developing new libraries and components. An example of this is the new UI Toolkit that is being developed, which basically depends on Kotlin to work: <a href="https://link.medium.com/sE4J6WENa2">Jetpack Compose</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4e47c2e36546" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Jetpack Compose III: Flujo de datos y eventos]]></title>
            <link>https://medium.com/@facundomr/jetpack-compose-iii-flujo-de-datos-y-eventos-e62d5f8bce6f?source=rss-fa74850821ac------2</link>
            <guid isPermaLink="false">https://medium.com/p/e62d5f8bce6f</guid>
            <category><![CDATA[jetpack-compose]]></category>
            <category><![CDATA[jetpack]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[compose]]></category>
            <dc:creator><![CDATA[Facundo Rodríguez Arceri]]></dc:creator>
            <pubDate>Mon, 04 Nov 2019 17:42:49 GMT</pubDate>
            <atom:updated>2019-11-04T17:42:49.252Z</atom:updated>
            <content:encoded><![CDATA[<p>En esta tercera parte de la serie de artículos sobre Jetpack Compose veremos cómo estructurar/diseñar nuestras funciones @Composable para simplificar la arquitectura y seguir ciertas reglas que nos harán la vida más fácil a la hora de mantener el código de nuestra interfaz gráfica.</p><p>Si recién estás empezando por este artículo entonces te recomiendo que le pegues un vistazo a los anteriores, empezando por el primero:</p><p><a href="https://medium.com/@facundomr/jetpack-compose-i-motivaci%C3%B3n-50e085543923">Jetpack Compose I: Motivación</a></p><h3>Single source of truth / Fuente única de verdad</h3><p>Es un principio de desarrollo de software, el cual tiene como objetivo que el estado de la aplicación, o los datos de nuestro modelo sean modificados siempre desde un único lugar y, en caso de que algún otro componente dependa de este estado, lo haga a través de referencias al mismo pero sin modificarlo. De esta forma podemos asegurarnos que no habrá problemas como <em>race-conditions</em> y demás, ya que no existirá más de un componente modificando los datos de la aplicación, evitando la redundancia de los datos (por estar almacenados en varios lugares) y minimizando la posibilidad de llegar a estados inconsistentes.</p><p>La forma en la que Jetpack Compose propone respetar este principio es teniendo un flujo de datos que cumpla con <strong>dos reglas</strong>:</p><ul><li>Los <strong>datos</strong> tienen un flujo <strong>top-down</strong>.</li><li>Los <strong>eventos</strong> tienen un flujo <strong>bottom-up</strong>.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/455/1*NIMhmmmWd5LA9KeP425Ohw.png" /></figure><h3>Flujo de datos: top-down</h3><p>Lo que esta regla quiere decir es que <strong>las funciones @Composable deben recibir como parámetro aquellos objetos de los que dependen para poder dibujarse correctamente.</strong></p><p>Como estas funciones serán invocadas por otros @Composable que las contengan, decimos que los datos vienen de arriba hacia abajo.</p><p>Se debe <strong>evitar a toda costa el uso de variables globales</strong> para acceder al estado que una @Composable necesita: si se requieren datos adicionales, entonces estos deberían ser parámetro de entrada de la función.</p><p>Ejemplo: la siguiente función @Composable de nuestro ejemplo habitual recibe como parámetro el objeto Player que va a representar, ya que necesita acceder a su nombre y número. Nótese que no se reciben datos adicionales, como ser la posición del jugador en el listado, ya que no será necesario. Tampoco se accede a ningún otro valor por fuera de los que se reciben como parámetro.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/45ceda216d38765ee273abc2eb990abc/href">https://medium.com/media/45ceda216d38765ee273abc2eb990abc/href</a></iframe><h3>Flujo de eventos: bottom-up</h3><p>Esta regla se respeta haciendo que las modificaciones o acciones que se realizan sobre un @Composable no dependan de esta misma función, sino de aquella que la invocó. De esta forma se consiguen dos cosas:</p><ul><li>En caso de tener que modificar el dato del que depende la función, no será esta quien lo haga. Al delegarlo, podemos mantener el principio de single source of truth.</li><li>Se favorece a la reutilización del Composable: Si se necesita usar el mismo elemento gráfico en otra parte de la aplicación pero manejando la acción de otra manera, entonces se podrá hacer fácilmente ya que la acción está definida por quien llama al @Composable y no por él mismo.</li></ul><p>¿Cómo se implementa esto? De la misma forma que la regla anterior: con parámetros. Se agregarán lambdas que deben manejar los cambios de evento que se esperan sobre el @Composable.</p><p>Si volvemos al ejemplo del listado de jugadores, y necesitamos implementar un click listener sobre cada fila, debemos hacer lo siguiente:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/5f255fc367b9ce608a1ff34228498aa7/href">https://medium.com/media/5f255fc367b9ce608a1ff34228498aa7/href</a></iframe><p>Y ahora cuando la PlayerList invoque a PlayerRow, hará lo siguiente:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3634a4b25f1f94e8c6fa4be52fc96ca7/href">https://medium.com/media/3634a4b25f1f94e8c6fa4be52fc96ca7/href</a></iframe><h3>Conclusión</h3><p>Siempre que aparecen nuevas herramientas para desarrollar partes de nuestras apps nacen los mismos interrogantes: ¿cómo debo estructurar mi código? ¿existe alguna arquitectura recomendada?. En este caso, el equipo de Compose se encargó, desde el primer momento, en brindarnos estas dos reglas para simplificar el diseño y beneficiar la reutilización de nuestras @Composable.</p><h3>Otros links de interés</h3><ul><li>Tutorial oficial de Jetpack Compose: <a href="https://developer.android.com/jetpack/compose/tutorial">https://developer.android.com/jetpack/compose/tutorial</a></li><li>Codelab oficial: <a href="https://codelabs.developers.google.com/codelabs/jetpack-compose-basics">https://codelabs.developers.google.com/codelabs/jetpack-compose-basics</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e62d5f8bce6f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Jetpack Compose II: Funciones @Composable]]></title>
            <link>https://medium.com/@facundomr/jetpack-compose-ii-funciones-composable-8d4d1d40ed44?source=rss-fa74850821ac------2</link>
            <guid isPermaLink="false">https://medium.com/p/8d4d1d40ed44</guid>
            <category><![CDATA[jetpack]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[jetpack-compose]]></category>
            <category><![CDATA[androiddev]]></category>
            <category><![CDATA[kotlin]]></category>
            <dc:creator><![CDATA[Facundo Rodríguez Arceri]]></dc:creator>
            <pubDate>Thu, 11 Jul 2019 16:12:21 GMT</pubDate>
            <atom:updated>2019-11-04T17:51:13.979Z</atom:updated>
            <content:encoded><![CDATA[<p>En el artículo anterior hicimos un repaso sobre los motivos y objetivos detrás del desarrollo de <strong>Jetpack Compose</strong> que Google y Jetpack encaran en conjunto. Si no lo leíste te recomiendo que le pegues una mirada por acá:</p><p><a href="https://medium.com/@facundomr/jetpack-compose-i-motivaci%C3%B3n-50e085543923">Jetpack Compose I: Motivación</a></p><p>Ahora nos toca entrar en un terreno más interesante: configurar un entorno, empezar a hacer las primeras pruebas con el framework y entender <strong>cómo funcionan el mismo</strong>.</p><p>Antes de empezar recuerda que Jetpack Compose se encuentra en franco desarrollo y aún no hay ni siquiera liberada una versión alpha, es por esto que intentaré no profundizar demasiado en cómo se usan los componentes disponibles hasta el momento ni hacer un catálogo de los mismos, ya que es muy probable que estos cambien y por el momento no sería útil documentarlos en detalle.</p><h3>Instalación del entorno</h3><p><strong>Actualizado en Octubre de 2019</strong>: Durante el Android Dev Summit 2019 se liberó la <a href="https://developer.android.com/studio/preview">Preview de Android Studio 4.0</a>. Y el equipo de Compose publicó los <a href="https://mvnrepository.com/artifact/androidx.compose">artefactos Maven</a>, así que ahora es muy sencillo configurar un entorno.</p><p>Con Android Studio 4.0 creemos un proyecto nuevo y utilicemos “Empty Compose Activity” como template y… ¡listo! Este proyecto recién creado ya trae incluídas las librerías de Compose y el plugin del compilador de Kotlin.</p><p><strong>Nota importante</strong>: Las versiones están marcadas como <em>-dev02</em>, por lo tanto tengamos en cuenta siempre que esto ni siquiera es una versión <em>alpha</em>, es de esperarse que haya muchos más cambios en la API.</p><h3>Nuestra primer Activity con Jetpack Compose</h3><p>Este artículo está dirigido a desarrolladores que ya tienen experiencia en Android, por lo cual se asumen ciertos conocimientos. Si no es tu caso, te recomiendo que <a href="https://developer.android.com/guide/components/activities.html">comiences por aquí</a>.</p><p>Una vez creado y configurado el proyecto, modificaremos el archivo <em>MainActivity.kt</em> con el siguiente contenido básico y sencillo:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1a22c58b78c4a6c9f623e2f14bcf5b40/href">https://medium.com/media/1a22c58b78c4a6c9f623e2f14bcf5b40/href</a></iframe><ul><li>¡Listo! Ya tenemos nuestra primer app de ejemplo, que imprime un saludo en pantalla.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*E26spurlz3Wy_D5b9LZjIA.jpeg" /></figure><h3>Analizando la sintaxis</h3><p>Lo primero que vamos a notar es que en lugar de llamar a <em>setContentView(int resId)</em> se llama a la extension function que agregaron a <em>Activity</em>: <strong><em>setContent</em></strong>, la que recibe como parámetro un lambda del tipo <strong>@Composable</strong>.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e79cd34042576075949fa81cbbdcab74/href">https://medium.com/media/e79cd34042576075949fa81cbbdcab74/href</a></iframe><p>No usaremos para nada el <em>CompositionContext</em> que retorna esta función, pero debemos saber que básicamente lo que hará es poner un <em>FrameLayout</em> en la <em>Activity</em> y utilizar la lambda recibida para dibujar los elementos.</p><h3>Nuestra función @Composable</h3><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/456fbdab56acc17901f3a4ab2c7f488f/href">https://medium.com/media/456fbdab56acc17901f3a4ab2c7f488f/href</a></iframe><p>No parece haber mucho de especial en esto, simplemente es una función con tipo de retorno <strong><em>Unit</em></strong>, marcada con la anotación <em>@Composable</em>, la cual en su interior llama a la función <strong><em>Text()</em></strong> pasando un <em>String</em> como parámetro.</p><p>¿Qué hace la anotación <strong><em>@Composable</em></strong>? Básicamente genera el código repetitivo (boilerplate) que Compose necesita para generar el árbol del layout, guardar en <em>caché</em> las vistas para detectar específicamente cuáles son las que cambiaron dentro de dicho árbol y guardar aquellas variables que sirvan para almacenar el estado de la vista. Hablaremos sobre cómo manejar el estado de las vistas en otro artículo, por ahora nos enfocaremos en ver qué podemos hacer con las funciones <em>@Composable</em>.</p><p>¿Y qué es la función “<strong><em>Text()</em></strong>”? Es una de las tantas funciones para dibujar widgets en pantalla que Jetpack Compose trae. Nótese que sólo estamos pasando el <em>String</em> que queremos que se escriba, pero en realidad la función puede recibir otros parámetros para personalizar cómo se visualizará:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/29816053fa8e12e288dce4f677c285c9/href">https://medium.com/media/29816053fa8e12e288dce4f677c285c9/href</a></iframe><h3>Text() != TextView()</h3><p>Quizás no lo hayas notado, pero hay algo raro acá… Jetpack Compose rompe con la convención de código de Kotlin al hacer que una función empiece con letra mayúscula (<em>Text</em>). Esto podría generar confusión y creer que estamos creando un objeto que se transforma en un <em>View</em> que se renderiza en la pantalla, pero realmente no es así… la función <em>Text()</em>, al igual que todas <strong>las funciones @Composable que dibujan widgets, retornan <em>Unit</em></strong> (el equivalente a <em>void</em> en Java).</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/437b6148ac82d2c32746640eacafe9d3/href">https://medium.com/media/437b6148ac82d2c32746640eacafe9d3/href</a></iframe><p>Pero entonces, si la función <em>Text()</em> no crea un <em>TextView</em>, <strong>¿qué hay en la pantalla? </strong>🤔</p><p>Para comprender la diferencia, cambiemos un momento nuestra <em>Activity</em> por el siguiente código:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/5dc7b6e1afb996cd9732bdf26a6067fd/href">https://medium.com/media/5dc7b6e1afb996cd9732bdf26a6067fd/href</a></iframe><p>Y pongamos este contenido en el archivo <strong><em>activity_my_compose_journey.xml</em></strong>:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6b108e22583c5583c5fa4f355cd74455/href">https://medium.com/media/6b108e22583c5583c5fa4f355cd74455/href</a></iframe><p>De esta forma, usaremos el <a href="https://developer.android.com/studio/debug/layout-inspector"><strong><em>Layout Inspector </em></strong>para ver la diferencia entre ambos layouts</a>.</p><p>Esto es lo que se ve en el caso de la <em>Activity</em> usando el layout en el <em>xml</em>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6dAmbqz1MUm0VB2BXypLsw.png" /></figure><p>Y esto es lo que e ve cuando usamos setContent con <strong>Jetpack Compose</strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fR56BmiIpkgony66wlH6_Q.png" /></figure><p>La diferencia está marcada en las screenshots: mientras que cuando usamos layouts de forma convencional se crea un <em>TextView</em> y se agrega al árbol, en la versión que utiliza Jetpack Compose se<strong> inserta un <em>FrameLayout</em> que contiene un <em>AndroidComposeView</em> y no se pueden diferenciar los <em>Views</em> que este contiene</strong>. Si hacemos la prueba agregando más funciones <em>@Composable</em> que usen <em>Text</em> veremos que sólo se diferencia el mismo <em>AndroidComposeView.</em> Esto tiene total sentido si recordamos lo que decíamos en el artículo anterior: <strong>Jetpack Compose no depende del SDK de Android</strong>, por lo tanto no dibuja <em>Views</em>, ¿qué hace?: directamente invoca a <strong><em>drawRect()</em></strong><em> </em>sobre el canvas: dibuja el contenido, pero no tiene absolutamente ninguna dependencia con los <em>Views</em> de Android. Internamente, Compose utiliza un objeto llamado <strong><em>Composer</em></strong> que sabe renderizar la función <em>Text</em> en Android, y lo más interesante de todo es que a futuro se podrán crear distintas implementaciones de <em>Composers</em> para utilizar Jetpack Compose en cualquier plataforma en la que se pueda ejecutar código Kotlin… 🤔 <strong>hay un gran potencial para Kotlin/Native y Kotlin/Multiplatform en este punto. </strong>Si no estás al tanto de este proyecto, te recomiendo que revises <a href="https://kotlinlang.org/docs/reference/native-overview.html">la documentación oficial</a>, o que mires la charla de <a href="https://www.youtube.com/watch?v=Q6DUwVMUCEM">Yury Camacho en el Kotlin/Everywhere Buenos Aires</a>.</p><h3>¿Qué se puede hacer en una función @Composable?</h3><p>Bueno… ¡lo que quieras! Son simplemente funciones de Kotlin, por lo tanto podemos hacer cosas como…</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/255dc9525c0a79c5a6d8e3d05baefa68/href">https://medium.com/media/255dc9525c0a79c5a6d8e3d05baefa68/href</a></iframe><p>O bien hacerlas recibir parámetros necesarios para la UI:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ed7c520b27a4820883149a280bd8b009/href">https://medium.com/media/ed7c520b27a4820883149a280bd8b009/href</a></iframe><p>O también…</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/454eb40c0894cea4bb55067cd19de287/href">https://medium.com/media/454eb40c0894cea4bb55067cd19de287/href</a></iframe><p>Y por último el concepto más importante: la idea detrás de todo esto es la nueva forma en la que debemos pensar:<strong> nuestra UI debe utilizar funciones @Composable que a su vez estén compuestas por otras funciones @Composable</strong>, como se ve en el siguiente ejemplo:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3a27e82c54d96067156a623246c5bbaa/href">https://medium.com/media/3a27e82c54d96067156a623246c5bbaa/href</a></iframe><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*vNY1KK-Yf7DlB5ye7O8d5Q.jpeg" /></figure><p>Esta ha sido nuestra primera aproximación práctica a<strong> Jetpack Compose</strong>. Lo que hemos visto representa la estructura básica de una UI y hemos analizado el código y mencionado algunos detalles de implementación. En el siguiente artículo aprenderemos sobre el flujo recomendado de datos y eventos para nuestras aplicaciones e iremos entendiendo mejor el potencial de esta tecnología.</p><p><a href="https://medium.com/@facundomr/jetpack-compose-iii-flujo-de-datos-y-eventos-e62d5f8bce6f">Jetpack Compose III: Flujo de datos y eventos</a></p><h3>Otros links de interés</h3><ul><li>Compose From First Principles: <a href="http://intelligiblebabble.com/compose-from-first-principles/">http://intelligiblebabble.com/compose-from-first-principles</a></li><li>Android Developers Backstage Podcast: <a href="http://androidbackstage.blogspot.com/2019/06/episode-115-jetpack-compose.html">http://androidbackstage.blogspot.com/2019/06/episode-115-jetpack-compose.html</a></li><li>Karumi blog: <a href="https://blog.karumi.com/android-jetpack-compose-review/">https://blog.karumi.com/android-jetpack-compose-review</a></li><li>Jetpack Compose Quick Setup: <a href="https://android.jlelse.eu/jetpack-compose-quick-setup-d9b40a2e539b">https://android.jlelse.eu/jetpack-compose-quick-setup-d9b40a2e539b</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8d4d1d40ed44" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Jetpack Compose I: Motivación]]></title>
            <link>https://medium.com/droid-latam/jetpack-compose-i-motivaci%C3%B3n-50e085543923?source=rss-fa74850821ac------2</link>
            <guid isPermaLink="false">https://medium.com/p/50e085543923</guid>
            <category><![CDATA[android]]></category>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[androiddev]]></category>
            <category><![CDATA[jetpack-compose]]></category>
            <category><![CDATA[android-app-development]]></category>
            <dc:creator><![CDATA[Facundo Rodríguez Arceri]]></dc:creator>
            <pubDate>Fri, 28 Jun 2019 18:11:48 GMT</pubDate>
            <atom:updated>2019-07-11T18:24:13.374Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*89SZry2V8KHWErHbYtJplw.png" /></figure><p>En el Google I/O 2019 se presentó <strong>Jetpack Compose</strong>. En verdad no hubo una presentación formal ya que no se puede presentar un framework que aún no está disponible, pero sí se habló de la necesidad de tener una nueva forma de implementar los layouts de Android. Para empezar esta serie de artículos sobre Jetpack Compose es necesario primero entender la motivación detrás de esto y los conceptos básicos.</p><h3>¿Qué es?</h3><p>Jetpack Compose es un conjunto de herramientas (librería + plugin del compilador de Kotlin) en desarrollo por parte de <strong>Jetbrains</strong> y <strong>Google</strong>, el cual se incorporará a <strong>Jetpack</strong> dentro de un tiempo. El desarrollo está en una etapa inicial y aún no hay disponible una primera versión alpha: se estima que el primer release estable tarde unos dos años en ser liberado. Esta librería nos permitirá escribir <strong>layouts en forma reactiva y declarativa</strong> aprovechando los beneficios de Kotlin: código conciso, seguro e interoperable con Java.</p><h3>¿Qué significa “Declarative UI”?</h3><p>La programación declarativa es un paradigma de programación y su contraparte es la programación imperativa. Pero, ¿qué significa esto?</p><p>Por <strong>programación imperativa</strong> nos referimos al proceso de escribir un algoritmo en el que se ejecutan <strong>paso a paso</strong> una serie de instrucciones que terminarán cambiando el estado del programa. Esta es la forma en la que venimos haciendo layouts hasta ahora en Android. Por ejemplo:</p><ol><li>Obtenemos una referencia al objeto del layout, por ejemplo un TextView.</li><li>Guardamos dicha referencia en una variable de nuestra Activity.</li><li>Le cambiamos los atributos necesarios cuando lo necesitemos: por ejemplo llamamos al método setText(), setBackgroundColor(), etc.</li></ol><p>De esta forma, cuando aplicamos el paradigma imperativo, somos responsables de escribir cada instrucción que el sistema debe ejecutar para lograr que la pantalla quede en el estado deseado.</p><p>En el <strong>paradigma declarativo</strong>, en cambio, no se expresa exactamente lo que se debe ejecutar sino que se establecen una serie de condiciones que se deben cumplir y es el programa el que deberá hacer lo necesario para que dichas condiciones sean satisfechas siempre. Ya no será nuestra responsabilidad como programadores saber <strong>cómo</strong> se hacen las cosas sino definir <strong>qué</strong> debe hacerse.</p><h3>¿En qué se basa?</h3><p>Las interfaces gráficas declarativas son una tendencia que se viene viendo en otras tecnologías, como <strong>React/React Native, Vue.js, Flutter, Litho y otros</strong>. Si tenés experiencia con alguna de estas entonces ya sabrás qué esperar. Si nunca probaste ninguno de estos frameworks, entonces no te preocupes, lo iremos aprendiendo paso a paso en los próximos artículos.</p><h3>¿Por qué se decidió desarrollar Jetpack Compose?</h3><p>Las razones son variadas:</p><ul><li><strong>No es conveniente depender de clases que estén en el SDK</strong>: Es necesario sacar las clases de interfaz gráfica del SDK e incluir una librería para poder desarrollar, de una única forma, layouts que se vean y funcionen de igual manera en todas las versiones de Android, exactamente lo mismo que se hizo con la SupportLibrary (ahora AndroidX).</li><li><strong>Problemas de retrocompatibilidad</strong>: Las APIs de los Views existentes no se pueden refactorizar tan fácilmente para simplificar su uso y la forma en la cual están implementadas esas APIs se basa en decisiones que se han tomado hace 10 años, lo cual es muy difícil de cambiar.</li><li><strong>Reutilizar vistas es complejo</strong>: Las formas actuales de crear componentes visuales reutilizables son complejas: escribir un CustomView o un Fragment para usar en varias pantallas de nuestras aplicaciones no es tarea trivial y requiere crear y modificar varios archivos para lograr definir, por ejemplo, un nuevo tipo de botón.</li><li><strong>Generalmente no existe una única fuente de información para nuestra vista</strong>: Hoy por hoy un View puede modificarse desde cualquier parte del programa que tenga acceso a una referencia de dicho objeto. Es necesario cambiar el flujo de los datos y los eventos para simplificar esto y que siempre exista un único lugar donde se defina cómo serán los Views y qué variables definen los datos que estos mostrarán en pantalla.</li><li><strong>Demasiado código para cosas sencillas</strong>: ¿Te gustaría escribir menos código para lograr una interfaz gráfica funcional? Pensemos por un minuto en todas las cosas que hay que hacer, por ejemplo, para tener funcionando un listado de elementos:</li></ul><ol><li>Incluir un RecyclerView en el layout.</li><li>Obtener dicho RecyclerView en la Activity.</li><li>Especificar un LayoutManager.</li><li>Implementar un Adapter junto con su respectivo ViewHolder.</li><li>etc…</li></ol><p>¿Y si pudiéramos resolver todo esto en un par de funciones?</p><h3>¿Por qué debería importarme?</h3><ul><li>Pasaron <strong>diez años</strong> desde que se publicó el primer SDK de Android y casi todo ha cambiado desde entonces: ahora tenemos Android Studio, Gradle, Runtime permissions, Kotlin, Architecture Components, RxJava, etc. Todas cosas que ahora son el estándar pero ni siquiera existían en las primeras versiones del SDK de Android. Lo único que nunca cambió fue la forma de desarrollar layouts. Ya es hora de dar un siguiente paso.</li><li>Muchos desarrolladores que <strong>trabajan con algunas de las tecnologías en las que se inspira Jetpack Compose suelen</strong> <strong>extrañarlas</strong> cuando vuelven a trabajar con el SDK nativo de Android. Es razonable que, al menos, tengan la opción de utilizar Compose para trabajar de la misma forma.</li><li>Apenas unas semanas después del Google I/O en el que se anunció Jetpack Compose, Apple realizó su evento anual para desarrolladores (WWDC) y anunció su análogo para iOS: <strong>Swift UI</strong>. Esta es una muestra empírica de que esta tendencia está generando un <strong>interés real</strong>.</li><li>Los elementos de UI que escribamos con Jetpack Compose serán <strong>compatibles con los layouts existentes</strong>. Esto siempre es un buen motivo para no buscar excusas y aprender algo nuevo.</li><li>En mi opinión, es muy probable que este termine siendo el <strong>nuevo estándar de-facto</strong> para escribir los layouts de nuestras aplicaciones por las ventajas ya mencionadas que traerá y porque ayudará a modernizar la forma de desarrollar.</li></ul><h3>¿Cómo puedo aprender Jetpack Compose?</h3><p>El equipo de Android decidió que todo el desarrollo sea <strong>Open Source</strong> para poder recibir feedback temprano de la comunidad. Sin embargo, aún no hay tutoriales oficiales ni codelabs publicados para este tema. La idea de los siguientes artículos de esta serie es que puedas ver qué hay hasta el momento y ponerlo en práctica para que puedas sacar tus propias conclusiones y ver si esta forma de desarrollar layouts te gusta más o menos que la actual.</p><p>Aquí el link a la segunda parte de esta mini-serie:</p><p><a href="https://medium.com/@facundomr/jetpack-compose-ii-funciones-composable-8d4d1d40ed44">Jetpack Compose II: Funciones @Composable</a></p><h3>Otros links de interés</h3><ul><li>Flutter Docs: Introduction to declarative UI: <a href="https://flutter.dev/docs/get-started/flutter-for/declarative">https://flutter.dev/docs/get-started/flutter-for/declarative</a></li><li>Content on Declarative UI: <a href="http://intelligiblebabble.com/content-on-declarative-ui/">http://intelligiblebabble.com/content-on-declarative-ui/</a></li><li>Declarative UI Patterns (Google I/O’19)</li></ul><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FVsStyq4Lzxo%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DVsStyq4Lzxo&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FVsStyq4Lzxo%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/f89fe78e3b84fdda9b66f07c289407a4/href">https://medium.com/media/f89fe78e3b84fdda9b66f07c289407a4/href</a></iframe><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=50e085543923" width="1" height="1" alt=""><hr><p><a href="https://medium.com/droid-latam/jetpack-compose-i-motivaci%C3%B3n-50e085543923">Jetpack Compose I: Motivación</a> was originally published in <a href="https://medium.com/droid-latam">Droid LATAM</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>