https://carrion.dev/es/tags/kotlin/Recent content in kotlin on Carrion.devHugo -- gohugo.ioesignacio@carrion.dev (Ignacio Carrión)ignacio@carrion.dev (Ignacio Carrión)©{year}, All Rights ReservedFri, 07 Nov 2025 08:00:00 +0100https://carrion.dev/es/posts/kotlin-coroutines-dispatchers-jobs/Fri, 07 Nov 2025 08:00:00 +0100ignacio@carrion.dev (Ignacio Carrión)Fri, 07 Nov 2025 08:00:00 +0100https://carrion.dev/es/posts/kotlin-coroutines-dispatchers-jobs/Dominando Kotlin Coroutines: Dispatchers, Jobs y Concurrencia Estructurada Kotlin Coroutines ofrecen una forma ligera y estructurada de escribir código asíncrono y concurrente. Esta guía se centra en tres pilares que usarás a diario: Dispatchers (dónde corren las coroutines), Jobs (qué corre y cómo se supervisa), y la concurrencia estructurada (las reglas que mantienen tu código asíncrono bajo control). Encontrarás modelos mentales, snippets ejecutables, gotchas y patrones listos para producción. TL;DR Dispatcher: decide el hilo o pool donde ejecuta una coroutine (Dispatchers.Ignacio Carriónfeatured imagekotlincoroutinesconcurrencyasyncstructured-concurrencyhttps://carrion.dev/es/posts/kotlin-inline-functions-value-classes/Fri, 24 Oct 2025 08:00:00 +0100ignacio@carrion.dev (Ignacio Carrión)Fri, 24 Oct 2025 08:00:00 +0100https://carrion.dev/es/posts/kotlin-inline-functions-value-classes/Abstracciones de Costo Cero en Kotlin: Funciones Inline y Value Classes Kotlin ofrece dos herramientas muy poderosas para escribir código más seguro y rápido con sobrecarga nula o casi nula en tiempo de ejecución: las funciones inline y las Value Classes. Usadas correctamente, ayudan a evitar asignaciones, mejorar la seguridad de tipos y mantener APIs expresivas. En este artículo veremos qué son, cómo funcionan por dentro, casos de uso prácticos, compromisos y cuándo no usarlas.Ignacio Carriónfeatured imagekotlinfunciones-inlinevalue-classesrendimientogenericoshttps://carrion.dev/es/posts/kotlin-mutex-concurrency-guide/Fri, 03 Oct 2025 08:00:00 +0100ignacio@carrion.dev (Ignacio Carrión)Fri, 03 Oct 2025 08:00:00 +0100https://carrion.dev/es/posts/kotlin-mutex-concurrency-guide/Kotlin Mutex: Concurrencia Segura para Coroutines Al construir aplicaciones concurrentes con coroutines de Kotlin, proteger el estado mutable compartido es esencial. Aunque las herramientas tradicionales de sincronización de Java como bloques synchronized y ReentrantLock funcionan, bloquean hilos y no se integran bien con el modelo de suspensión de coroutines. Aquí es donde entra Mutex — una primitiva de sincronización compatible con coroutines que proporciona exclusión mutua sin bloquear hilos. Esta guía explora cuándo usar Mutex, mejores prácticas y cómo se compara con otros mecanismos de control de concurrencia.Ignacio Carriónfeatured imagekotlincoroutinesconcurrencymutexthread-safetyhttps://carrion.dev/es/posts/migrating-retrofit-okhttp-to-ktor-kmp/Fri, 12 Sep 2025 08:00:00 +0100ignacio@carrion.dev (Ignacio Carrión)Fri, 12 Sep 2025 08:00:00 +0100https://carrion.dev/es/posts/migrating-retrofit-okhttp-to-ktor-kmp/De Retrofit/OkHttp a Ktor en Kotlin Multiplatform: una primera migración práctica Si quieres comenzar a migrar una app Android existente a Kotlin Multiplatform (KMP), la capa de red es un excelente primer paso. Ktor Client funciona en múltiples plataformas y te permite mantener una sola pila HTTP para Android, iOS, Desktop y más. Esta guía muestra cómo migrar de Retrofit/OkHttp a Ktor con motores CIO u OkHttp, manteniendo el impacto limitado a la capa remota cuando tu arquitectura está bien diseñada.Ignacio Carriónfeatured imagekotlinmultiplatformkmpktorretrofitokhttpandroidnetworkingmigrationhttps://carrion.dev/es/posts/kotlin-data-structures-guide/Fri, 05 Sep 2025 08:00:00 +0100ignacio@carrion.dev (Ignacio Carrión)Fri, 05 Sep 2025 08:00:00 +0100https://carrion.dev/es/posts/kotlin-data-structures-guide/Estructuras de Datos en Kotlin: Qué usar y cuándo Elegir bien la estructura de datos es una de las decisiones de rendimiento más influyentes. Kotlin ofrece APIs expresivas y seguras en tipos sobre las colecciones del JVM, además de opciones específicas como ArrayDeque y colecciones inmutables vía kotlinx.collections.immutable. Esta guía se centra en la elección práctica: qué usar, cuándo usarlo y qué esperar en términos de complejidad temporal. TL;DR: Recomendaciones rápidas ¿Necesitas una secuencia ordenada, indexable, redimensionable y con acceso aleatorio rápido?Ignacio Carriónfeatured imagekotlincoleccionesestructuras-de-datosalgoritmoscomplejidadhttps://carrion.dev/es/posts/kotlin-24-rich-errors/Fri, 29 Aug 2025 08:00:00 +0100ignacio@carrion.dev (Ignacio Carrión)Fri, 29 Aug 2025 08:00:00 +0100https://carrion.dev/es/posts/kotlin-24-rich-errors/Kotlin 2.4 Rich Errors: Qué son y cómo prepararte Kotlin 2.4 introduce “Rich errors” (errores enriquecidos): una forma más expresiva y estructurada de representar y propagar fallos. El objetivo es claro: hacer que los flujos de error sean visibles y componibles en toda tu base de código y en múltiples plataformas, sin perder la ergonomía de Kotlin ni su gran historia de interoperabilidad. Este artículo explica los problemas que Rich errors resuelven, cómo se relacionan con las excepciones y Result actuales, qué implican en cuanto a modelo mental e interop, y cómo preparar tu base de código para adoptarlos sin fricciones.Ignacio Carriónfeatured imagekotlinmanejo-de-erroresexcepcionesresultkotlin-2-4https://carrion.dev/es/posts/runcatching-result-pattern/Fri, 20 Jun 2025 08:00:00 +0100ignacio@carrion.dev (Ignacio Carrión)Fri, 20 Jun 2025 08:00:00 +0100https://carrion.dev/es/posts/runcatching-result-pattern/Manejo Elegante de Errores en Kotlin: Usando runCatching y Result El manejo de excepciones es un aspecto crítico para escribir aplicaciones robustas, pero los bloques tradicionales try/catch pueden llevar a código verboso y anidado que es difícil de leer y mantener. Kotlin ofrece un enfoque más elegante con la función runCatching y el tipo Result, que permiten manejar excepciones de manera funcional mientras se mantiene la legibilidad del código y se previenen fallos.Ignacio Carriónfeatured imagekotlinmanejo-de-erroresprogramacion-funcionalpatron-resultmanejo-de-excepcioneshttps://carrion.dev/es/posts/compose-navigation-kmp/Fri, 16 May 2025 08:00:00 +0100ignacio@carrion.dev (Ignacio Carrión)Fri, 16 May 2025 08:00:00 +0100https://carrion.dev/es/posts/compose-navigation-kmp/Implementando Navegación en Proyectos Compose Multiplatform Con la última versión de Compose Multiplatform (1.8.0), el soporte para iOS ha sido declarado estable, marcando un hito significativo para el desarrollo de interfaces de usuario multiplataforma con Kotlin. Uno de los componentes clave para construir aplicaciones robustas es la navegación, y la biblioteca org.jetbrains.androidx.navigation proporciona una solución potente que puede integrarse en proyectos Compose Multiplatform. Este artículo explora cómo implementar la navegación en un entorno Compose Multiplatform, permitiéndote compartir la lógica de navegación entre las plataformas Android e iOS.Ignacio Carriónfeatured imagekotlinmultiplatformkmpcomposenavigationhttps://carrion.dev/es/posts/datastore-in-kmp/Fri, 09 May 2025 08:00:00 +0100ignacio@carrion.dev (Ignacio Carrión)Fri, 09 May 2025 08:00:00 +0100https://carrion.dev/es/posts/datastore-in-kmp/Implementando DataStore en Proyectos Kotlin Multiplatform DataStore es una solución moderna de almacenamiento de datos desarrollada por Google como reemplazo de SharedPreferences. Proporciona una API consistente y segura en cuanto a tipos para almacenar pares clave-valor y objetos tipados con soporte para coroutines y Flow de Kotlin. Con los recientes avances en Kotlin Multiplatform (KMP), ahora podemos integrar DataStore en nuestros proyectos KMP, permitiéndonos compartir código de preferencias y almacenamiento de datos entre plataformas.Ignacio Carriónfeatured imagekotlinmultiplatformkmpdatastorepreferenceshttps://carrion.dev/es/posts/room-in-kmp/Tue, 06 May 2025 08:00:00 +0100ignacio@carrion.dev (Ignacio Carrión)Tue, 06 May 2025 08:00:00 +0100https://carrion.dev/es/posts/room-in-kmp/Implementando Room Database en Proyectos Kotlin Multiplatform La biblioteca de persistencia Room se ha convertido en el estándar para operaciones de base de datos en el desarrollo Android, ofreciendo una capa de abstracción sobre SQLite que permite un acceso robusto a la base de datos mientras aprovecha todo el poder de SQL. Con el lanzamiento de Room 2.7.1, ahora podemos integrar esta potente biblioteca en proyectos Kotlin Multiplatform (KMP), permitiéndonos compartir código de base de datos entre plataformas mientras aprovechamos las optimizaciones específicas de cada plataforma.Ignacio Carriónfeatured imagekotlinmultiplatformkmproomdatabasehttps://carrion.dev/es/posts/coroutine-testing-patterns/Tue, 29 Apr 2025 08:00:00 +0100ignacio@carrion.dev (Ignacio Carrión)Tue, 29 Apr 2025 08:00:00 +0100https://carrion.dev/es/posts/coroutine-testing-patterns/Patrones de Testing para Coroutines: Estrategias Efectivas para Testear Código Asíncrono en Kotlin Testear código asíncrono siempre ha sido un desafío, y las coroutines y flows de Kotlin no son una excepción. Sin embargo, el equipo de Kotlin ha proporcionado potentes utilidades de test que hacen que este proceso sea más manejable y confiable. En este artículo, exploraremos patrones efectivos para testear coroutines y flows, desde tests unitarios básicos hasta escenarios de integración complejos.Ignacio Carriónfeatured imagekotlincoroutinestestingflowshttps://carrion.dev/es/posts/context-parameters-kotlin/Fri, 25 Apr 2025 08:00:00 +0100ignacio@carrion.dev (Ignacio Carrión)Fri, 25 Apr 2025 08:00:00 +0100https://carrion.dev/es/posts/context-parameters-kotlin/Entendiendo los Context parameters en Kotlin 2.2.0 Kotlin 2.2.0 introduce una emocionante nueva característica del lenguaje llamada “Context parameters” que promete hacer tu código más conciso, legible y mantenible. Esta característica aborda el desafío común de pasar información contextual a través de jerarquías de llamadas profundas sin sobrecargar las firmas de las funciones. En este artículo, exploraremos qué son los Context parameters, cómo funcionan y cómo puedes aprovecharlos en tus proyectos Kotlin.Ignacio Carriónfeatured imagekotlinlanguage-featureshttps://carrion.dev/es/posts/expect-actual-kmp/Tue, 22 Apr 2025 08:00:00 +0100ignacio@carrion.dev (Ignacio Carrión)Tue, 22 Apr 2025 08:00:00 +0100https://carrion.dev/es/posts/expect-actual-kmp/Aprovechando expect/actual en Kotlin Multiplatform para Implementaciones Nativas Kotlin Multiplatform (KMP) ha surgido como una poderosa solución para compartir código entre diferentes plataformas, permitiendo al mismo tiempo implementaciones específicas de plataforma cuando sea necesario. En el centro de esta capacidad está el mecanismo expect/actual, que permite a los desarrolladores definir una API común en código compartido y proporcionar implementaciones específicas de plataforma. Este artículo explora cómo utilizar eficazmente expect/actual para crear aplicaciones multiplataforma robustas con implementaciones nativas.Ignacio Carriónfeatured imagekotlinmultiplatformkmphttps://carrion.dev/es/posts/sealed-classes-domain-modeling/Tue, 15 Apr 2025 08:00:00 +0100ignacio@carrion.dev (Ignacio Carrión)Tue, 15 Apr 2025 08:00:00 +0100https://carrion.dev/es/posts/sealed-classes-domain-modeling/Aprovechando las Sealed Classes e Interfaces para un Mejor Modelado de Dominio El modelado de dominio es un aspecto crucial del desarrollo de software, representando los conceptos y reglas de negocio fundamentales en tu aplicación. Kotlin proporciona potentes características de lenguaje que pueden ayudar a crear modelos de dominio más expresivos, con seguridad de tipos y mantenibles. Entre estas características, las sealed classes e interfaces destacan como herramientas particularmente valiosas. Este artículo explora cómo aprovechar estas características de Kotlin para construir mejores modelos de dominio.Ignacio Carriónfeatured imagekotlinarchitecturedomain modelingtype safetyhttps://carrion.dev/es/posts/composition-over-inheritance/Fri, 11 Apr 2025 08:00:00 +0100ignacio@carrion.dev (Ignacio Carrión)Fri, 11 Apr 2025 08:00:00 +0100https://carrion.dev/es/posts/composition-over-inheritance/Composición sobre Herencia: Una Perspectiva de Kotlin En la programación orientada a objetos, existen dos formas principales de reutilizar código y establecer relaciones entre clases: herencia y composición. Aunque ambos enfoques tienen su lugar, el principio de “composición sobre herencia” ha ganado una tracción significativa en el diseño de software moderno. Esta entrada de blog explora ambos enfoques, sus compensaciones, y por qué la composición es a menudo la opción preferida, con ejemplos en Kotlin.Ignacio Carriónfeatured imagekotlinarquitecturapatrones de diseñoprogramación orientada a objetoshttps://carrion.dev/es/posts/building-type-safe-dsls/Tue, 25 Mar 2025 08:00:00 +0100ignacio@carrion.dev (Ignacio Carrión)Tue, 25 Mar 2025 08:00:00 +0100https://carrion.dev/es/posts/building-type-safe-dsls/Construyendo DSLs Tipados con Kotlin: De lo Básico a Patrones Avanzados Los Lenguajes de Dominio Específico (DSLs) en Kotlin te permiten crear APIs expresivas, legibles y tipadas. Este artículo explora cómo construir DSLs efectivos usando las potentes características de Kotlin, centrándose en el control de ámbito con @DslMarker para prevenir errores comunes en DSLs anidados. Al final de este artículo, entenderás: Cómo diseñar APIs de DSL limpias e intuitivas Cuándo y cómo usar @DslMarker para un mejor control de ámbito Mejores prácticas para mantener el tipado seguro en tu DSL Errores comunes y cómo evitarlos Conceptos Básicos de DSL Exploremos los conceptos fundamentales de los DSLs en Kotlin construyendo un simple constructor de HTML:Ignacio Carriónfeatured imagekotlindsltype-safetydesign-patternshttps://carrion.dev/es/posts/advanced-kotlin-generics/Fri, 21 Mar 2025 08:00:00 +0100ignacio@carrion.dev (Ignacio Carrión)Fri, 21 Mar 2025 08:00:00 +0100https://carrion.dev/es/posts/advanced-kotlin-generics/Características Avanzadas de Genéricos y Varianza en Kotlin: Una Guía Completa Entender los genéricos avanzados y la varianza en Kotlin es crucial para escribir código reutilizable y seguro en cuanto a tipos. Este artículo explora estos conceptos en profundidad, proporcionando ejemplos prácticos y aplicaciones del mundo real. Entendiendo la Varianza La varianza en Kotlin determina cómo se relacionan los tipos genéricos con diferentes argumentos de tipo. Entender la varianza es más fácil cuando pensamos en términos de productores y consumidores:Ignacio Carriónfeatured imagekotlingenericsvariancetype-safetyhttps://carrion.dev/es/posts/flow-composition-patterns/Tue, 18 Mar 2025 08:00:00 +0100ignacio@carrion.dev (Ignacio Carrión)Tue, 18 Mar 2025 08:00:00 +0100https://carrion.dev/es/posts/flow-composition-patterns/Patrones de Composición de Flows: Combinando Múltiples Flows de Manera Efectiva Cuando trabajamos con Kotlin Flows en aplicaciones del mundo real, a menudo necesitamos combinar múltiples flujos de datos para crear flujos de trabajo más complejos. Este artículo explora varios patrones de composición de Flows y las mejores prácticas para combinar múltiples Flows de manera efectiva. Entendiendo la Composición de Flows La composición de Flows es el proceso de combinar múltiples Flows para crear un nuevo Flow que representa un flujo de datos más complejo.Ignacio Carriónfeatured imagekotlincoroutinesflowspatternshttps://carrion.dev/es/posts/flow-operators-buffer-conflate/Fri, 14 Mar 2025 08:00:00 +0100ignacio@carrion.dev (Ignacio Carrión)Fri, 14 Mar 2025 08:00:00 +0100https://carrion.dev/es/posts/flow-operators-buffer-conflate/Entendiendo los Operadores de Flujo (Flow): Buffer, Conflate, Debounce y Sample Cuando trabajamos con flujos de Kotlin (Flows), especialmente en escenarios que involucran productores que emiten rápidamente y colectores lentos, es crucial entender cómo gestionar el flujo de datos de manera efectiva. Este post explora cuatro operadores esenciales de Flow que ayudan a manejar estos escenarios: buffer, conflate, debounce y sample. El Problema: Colectores Lentos Antes de profundizar en los operadores, entendamos el problema que resuelven.Ignacio Carriónfeatured imagekotlinflowscoroutineshttps://carrion.dev/es/posts/callback-to-flow-conversion/Tue, 11 Mar 2025 08:00:00 +0100ignacio@carrion.dev (Ignacio Carrión)Tue, 11 Mar 2025 08:00:00 +0100https://carrion.dev/es/posts/callback-to-flow-conversion/Convirtiendo Callbacks a Coroutines y Flows en Kotlin Las APIs basadas en callbacks han sido un patrón común en la programación asíncrona durante muchos años. Sin embargo, con las corrutinas y flows de Kotlin, podemos transformar estos callbacks en código moderno y secuencial que es más fácil de leer y mantener. En este artículo, exploraremos cómo usar suspendCoroutine y callbackFlow para convertir APIs basadas en callbacks a corrutinas y flows.Ignacio Carriónfeatured imagekotlincoroutinesflowscallbackshttps://carrion.dev/es/posts/kotlin-flows-hot-cold/Fri, 07 Mar 2025 08:00:00 +0100ignacio@carrion.dev (Ignacio Carrión)Fri, 07 Mar 2025 08:00:00 +0100https://carrion.dev/es/posts/kotlin-flows-hot-cold/Entendiendo los Hot y Cold Flows en Kotlin Kotlin Flow es una potente característica para manejar flows reactivos de datos. Uno de los conceptos fundamentales para entender cuando trabajamos con flows es la distinción entre hot y cold flows. Este artículo explicará las diferencias y proporcionará ejemplos prácticos de ambos tipos. Cold Flows: El Comportamiento por Defecto Los cold flows son el tipo predeterminado en Kotlin Flow. Comienzan a producir valores solo cuando un collector empieza a recolectar de ellos.Ignacio Carriónfeatured imagekotlincoroutinesflowshttps://carrion.dev/es/posts/koin-compile-safety/Tue, 04 Mar 2025 08:00:00 +0100ignacio@carrion.dev (Ignacio Carrión)Tue, 04 Mar 2025 08:00:00 +0100https://carrion.dev/es/posts/koin-compile-safety/Logrando Seguridad en Tiempo de Compilación con Koin: Una Guía Completa La inyección de dependencias es un patrón fundamental en el desarrollo moderno de Android, pero ¿cómo podemos asegurarnos de que nuestra configuración de DI sea correcta antes de ejecutar la aplicación? En esta publicación, exploraremos dos poderosos enfoques para lograr la seguridad en tiempo de compilación con Koin: usando la función verify() del DSL y aprovechando las Anotaciones de Koin con KSP.Ignacio Carriónfeatured imagekotlinandroidkoinhttps://carrion.dev/es/posts/trusted-time-api/Wed, 19 Feb 2025 08:00:00 +0100ignacio@carrion.dev (Ignacio Carrión)Wed, 19 Feb 2025 08:00:00 +0100https://carrion.dev/es/posts/trusted-time-api/Gestión Confiable del Tiempo con la API TrustedTime en Android La gestión precisa del tiempo es crucial para muchas funcionalidades de las aplicaciones, como la programación de tareas, el registro de transacciones y la seguridad. Sin embargo, depender del reloj del sistema de un dispositivo puede ser problemático, ya que los usuarios pueden modificar la configuración de la hora. Para abordar este problema, Google ha introducido la API TrustedTime, que proporciona una fuente de tiempo confiable y resistente a manipulaciones para las aplicaciones de Android.Ignacio Carriónfeatured imagekotlinandroidgooglehttps://carrion.dev/es/posts/kmp-architecture/Tue, 11 Feb 2025 08:00:00 +0100ignacio@carrion.dev (Ignacio Carrión)Tue, 11 Feb 2025 08:00:00 +0100https://carrion.dev/es/posts/kmp-architecture/Mejores Prácticas de Arquitectura en Kotlin Multiplatform para Aplicaciones Móviles Kotlin Multiplatform (KMP) permite a los desarrolladores compartir la lógica de negocio entre Android y iOS mientras mantienen implementaciones específicas de cada plataforma cuando es necesario. Estructurar un proyecto KMP de manera eficiente es clave para mantener la escalabilidad, testabilidad y aplicar Clean Architecture. En esta guía, exploraremos las mejores prácticas para diseñar una aplicación móvil con Compose Multiplatform y Clean Architecture.Ignacio Carriónfeatured imagekotlincomposecmpmultiplatformcleancodearchitecturehttps://carrion.dev/es/posts/test-doubles/Thu, 06 Feb 2025 08:00:00 +0100ignacio@carrion.dev (Ignacio Carrión)Thu, 06 Feb 2025 08:00:00 +0100https://carrion.dev/es/posts/test-doubles/Mocks, Fakes y Más: Entendiendo los Test Doubles en Kotlin Al escribir tests en Kotlin, especialmente para el desarrollo de Android, a menudo necesitamos reemplazar dependencias reales con test doubles. Sin embargo, no todos los test doubles son iguales: términos como mocks, fakes, stubs, spies y dummies aparecen con frecuencia. En esta publicación, desglosaremos sus diferencias con ejemplos en Kotlin utilizando solo Kotlin puro (sin bibliotecas de terceros). 1. Entendiendo los Test Doubles Los test doubles son objetos que sustituyen dependencias reales en las tests.Ignacio Carriónfeatured imagekotlintestingmocktddhttps://carrion.dev/es/posts/cmp-ui-testing/Mon, 03 Feb 2025 08:00:00 +0100ignacio@carrion.dev (Ignacio Carrión)Mon, 03 Feb 2025 08:00:00 +0100https://carrion.dev/es/posts/cmp-ui-testing/Tests en Compose Multiplatform (CMP) desde Código Común Compose Multiplatform (CMP) permite construir UI para múltiples plataformas utilizando Jetpack Compose. Afortunadamente, CMP también admite escribir y ejecutar tests de UI en el código común, lo que hace que los test sean más eficientes en todas las plataformas. En esta publicación, exploraremos cómo probar aplicaciones CMP utilizando compose.uiTest y ejecutarlas en Android, Desktop e iOS. 1. Configuración de Test de UI Comunes CMP proporciona compose.Ignacio Carriónfeatured imagekotlincomposecmpmultiplatformhttps://carrion.dev/es/posts/immutable-collections/Thu, 30 Jan 2025 08:00:00 +0100ignacio@carrion.dev (Ignacio Carrión)Thu, 30 Jan 2025 08:00:00 +0100https://carrion.dev/es/posts/immutable-collections/Explorando la Librería de Colecciones Inmutables de Kotlin Las colecciones estándar de Kotlin (List, Set, Map) son mutables por defecto, lo que puede provocar modificaciones no deseadas. Para garantizar la inmutabilidad a nivel de API, JetBrains introdujo la librería de Colecciones Inmutables de Kotlin. Esta librería proporciona un conjunto de tipos de colección verdaderamente inmutables que evitan modificaciones accidentales y mejoran la seguridad en entornos concurrentes o de múltiples hilos.Ignacio Carriónfeatured imagekotlincollectionscomposehttps://carrion.dev/es/posts/baseline-profiles/Mon, 27 Jan 2025 08:00:00 +0100ignacio@carrion.dev (Ignacio Carrión)Mon, 27 Jan 2025 08:00:00 +0100https://carrion.dev/es/posts/baseline-profiles/Mejorando el Rendimiento de las Aplicaciones Android con Baseline Profiles Introducción En el mundo móvil actual, los usuarios esperan que las aplicaciones se inicien al instante y funcionen sin problemas. La optimización del rendimiento es crucial, especialmente en lo que respecta al tiempo de inicio y la ejecución en tiempo de ejecución. Los Baseline Profiles de Android ofrecen una forma eficaz de acelerar el inicio de la aplicación y mejorar el rendimiento en tiempo de ejecución al precompilar rutas de código críticas.Ignacio Carriónfeatured imagekotlinarchitecturehttps://carrion.dev/es/posts/gradle-modularization/Thu, 23 Jan 2025 08:00:00 +0100ignacio@carrion.dev (Ignacio Carrión)Thu, 23 Jan 2025 08:00:00 +0100https://carrion.dev/es/posts/gradle-modularization/Modularización en Proyectos Gradle con Kotlin: Una Guía Completa Introducción A medida que los proyectos crecen en complejidad, mantener una base de código monolítica se vuelve un desafío. La modularización es una técnica de diseño de software que divide una aplicación en módulos más pequeños e independientes, haciendo que el proyecto sea más escalable, mantenible y eficiente. En esta guía, exploraremos por qué la modularización es esencial, los diferentes tipos de módulos y las mejores prácticas para configurar un proyecto modular en Gradle usando Kotlin.Ignacio Carriónfeatured imagekotlinarchitecturehttps://carrion.dev/es/posts/tdd-kotlin/Mon, 20 Jan 2025 08:00:00 +0100ignacio@carrion.dev (Ignacio Carrión)Mon, 20 Jan 2025 08:00:00 +0100https://carrion.dev/es/posts/tdd-kotlin/Test-Driven Development (TDD) en Kotlin para Android El Test-Driven Development (TDD) es una práctica de desarrollo de software que enfatiza escribir pruebas antes de implementar la funcionalidad. Sigue un ciclo Rojo-Verde-Refactorización: primero, escribes una prueba que falla (Rojo), luego implementas el código mínimo para que pase (Verde), y finalmente, refactorizas el código manteniendo la prueba en verde (Refactorización). En esta publicación, exploraremos cómo aplicar TDD en Kotlin para el desarrollo de Android usando JUnit, MockK y Coroutines, con un ejemplo del mundo real.Ignacio Carriónfeatured imagekotlinarchitectureTDDtestinghttps://carrion.dev/es/posts/clean-architecture/Sat, 18 Jan 2025 08:00:00 +0100ignacio@carrion.dev (Ignacio Carrión)Sat, 18 Jan 2025 08:00:00 +0100https://carrion.dev/es/posts/clean-architecture/Clean Architecture en Kotlin & Android Introducción Al desarrollar aplicaciones Android, mantener la escalabilidad y la legibilidad es crucial. Sin un enfoque arquitectónico claro, los proyectos pueden volverse difíciles de mantener a medida que crecen. Aquí es donde Clean Architecture, introducida por Uncle Bob (Robert C. Martin), se vuelve invaluable. Esta arquitectura enfatiza la separación de responsabilidades, haciendo que el código sea más modular, testeable y mantenible. Entendiendo Clean Architecture Clean Architecture está estructurada en tres capas principales, cada una con un rol específico:Ignacio Carriónfeatured imagekotlinarchitecturehttps://carrion.dev/es/posts/app-architecture/Wed, 15 Jan 2025 08:00:00 +0100ignacio@carrion.dev (Ignacio Carrión)Wed, 15 Jan 2025 08:00:00 +0100https://carrion.dev/es/posts/app-architecture/Explorando Arquitecturas de Apps en Kotlin: MVC, MVP, MVVM y MVI Introducción En el desarrollo moderno de aplicaciones, elegir la arquitectura adecuada es esencial para crear aplicaciones mantenibles y escalables. Las arquitecturas definen cómo se organiza tu base de código y cómo interactúan los diferentes componentes. En este artículo, exploraremos cuatro arquitecturas populares: Model-View-Controller (MVC), Model-View-Presenter (MVP), Model-View-ViewModel (MVVM) y Model-View-Intent (MVI). Analizaremos su estructura, ventajas, desventajas y ejemplos prácticos en Kotlin.Ignacio Carriónfeatured imagekotlinarchitecturehttps://carrion.dev/es/posts/design-patterns-3/Mon, 13 Jan 2025 08:00:00 +0100ignacio@carrion.dev (Ignacio Carrión)Mon, 13 Jan 2025 08:00:00 +0100https://carrion.dev/es/posts/design-patterns-3/Explorando Más Patrones de Diseño en Kotlin: Parte 3 Part 1 Part 2 Part 3 En esta tercera entrega, cubriremos los patrones Memento, Command, Visitor, Chain of Responsibility y Mediator. Estos patrones abordan desafíos de construcción, comportamiento y estructura, mostrando la sintaxis expresiva y las características modernas de Kotlin. 1. Patrón Memento El Patrón Memento captura y restaura el estado de un objeto sin exponer sus detalles internos.Ignacio Carriónfeatured imagekotlindesign-patternsarchitecturehttps://carrion.dev/es/posts/solid-kotlin/Wed, 08 Jan 2025 08:00:00 +0100ignacio@carrion.dev (Ignacio Carrión)Wed, 08 Jan 2025 08:00:00 +0100https://carrion.dev/es/posts/solid-kotlin/Entendiendo los principios SOLID con ejemplos en Kotlin Los principios SOLID son un conjunto de principios de diseño que hacen que los diseños de software sean más comprensibles, flexibles y mantenibles. Introducidos por Robert C. Martin, estos principios son una piedra angular de la programación orientada a objetos y son especialmente relevantes al construir sistemas complejos. En este blog, exploraremos cada principio con ejemplos escritos en Kotlin, un lenguaje que ofrece una sintaxis moderna y características poderosas.Ignacio Carriónfeatured imagekotlinsolidarchitecturehttps://carrion.dev/es/posts/design-patterns-2/Mon, 06 Jan 2025 08:00:00 +0100ignacio@carrion.dev (Ignacio Carrión)Mon, 06 Jan 2025 08:00:00 +0100https://carrion.dev/es/posts/design-patterns-2/Explorando patrones de diseño en Kotlin: Parte2 Design Patterns Series Part 1 Part 2 Part 3 Después de la gran acogida del primer artículo Patrones de diseño en Kotlin, volvemos con más! En esta segunda parte, revisaremos los patrones de Prototype, Composite, Proxy, Observer, y Strategy. Estos patrones resuelven una variedad de desafios de diseño y demuestran las capacidades expresivas de Kotlin. 1. Patrón Prototype El Patrón Prototype es usado para crear nuevos objeto copiando una objeto existente, asegurando la creación eficaz de objetos.Ignacio Carriónfeatured imagekotlindesign-patternsarchitecturehttps://carrion.dev/es/posts/koin-cmp/Thu, 02 Jan 2025 08:00:00 +0100ignacio@carrion.dev (Ignacio Carrión)Thu, 02 Jan 2025 08:00:00 +0100https://carrion.dev/es/posts/koin-cmp/Usando Koin en Compose Multiplatform La inyección de dependencias es algo imprescindible para crear aplicaciones escalables, y Koin hace que sea muy sencillo, incluso en proyectos con Compose Multiplatform. Con la nueva función composable KoinApplication, puedes inicializar Koin directamente desde el código común, reduciendo la cantidad de código necesario mientras se mantiene la flexibilidad de configurar cada plataforma por separado. Vamos a ver un ejemplo. Project Setup Empieza creando un proyecto de Compose Multiplatform usando el KMP Wizard, seleccionando Android, iOS, Desktop y Web como plataformas.Ignacio Carriónfeatured imagekotlinmultiplatformcmpcomposekoinhttps://carrion.dev/es/posts/design-patterns-1/Mon, 30 Dec 2024 08:00:00 +0100ignacio@carrion.dev (Ignacio Carrión)Mon, 30 Dec 2024 08:00:00 +0100https://carrion.dev/es/posts/design-patterns-1/Explorando patrones de diseño en Kotlin - Parte 1 Serie Patrones de diseño Design Patterns Series Part 1 Part 2 Part 3 Los patrones de diseño son soluciones probadas a problemas comunes en el diseño de software. Con la sintaxis y funcionalidades modernas de Kotlin, implementar estos patrones normalmente resulta más limpio y conciso. En este post, exploraremos los patrones de Singleton, Factory Method, Builder, Adapter and Decorator, profundizando en su propósito, casos de uso y implementaciones en Kotlin.Ignacio Carriónfeatured imagekotlindesign-patternsarchitecturehttps://carrion.dev/es/posts/kotlin-ksp/Fri, 27 Dec 2024 08:00:00 +0100ignacio@carrion.dev (Ignacio Carrión)Fri, 27 Dec 2024 08:00:00 +0100https://carrion.dev/es/posts/kotlin-ksp/Explorando Kotlin Symbol Processing (KSP) con ejemplos prácticos Kotlin Symbol Processing (KSP) es una herramienta muy potente usada para simplificar el procesamiento de anotaciones en Kotlin. Comparado con kapt (Kotlin Annotation Processing Tool), KSP es más rápido, ofrece mejor integración con Kotlin y reduce los tiempos de compilación de forma significativa. En este post, exploraremos los fundamentos de KSP, discutiremos cómo funciona y mostraremos como su uso en librerías populares como Koin y Room.Ignacio Carriónfeatured imagekotlinandroidadvancedhttps://carrion.dev/es/posts/kotlin-infix/Thu, 26 Dec 2024 08:00:00 +0100ignacio@carrion.dev (Ignacio Carrión)Thu, 26 Dec 2024 08:00:00 +0100https://carrion.dev/es/posts/kotlin-infix/Explorando las funciones Infix en Kotlin Kotlin, es un lenguaje de programación moderno con funcionalidades que permiten escribir un código más expresivo y conciso. Una de estas funcionalidades son las infix functions, que permiten escribir código más limpio y legible. En este post, exploraremos que son las funciones infix, como usarlas y algunos ejemplo prácticos. Qué son las funciones Infix? Las funciones infix en Kotlin son un tipo especial de función que pueden ser llamadas sin el uso de paréntesis o el punto.Ignacio Carriónfeatured imagekotlinandroidadvancedhttps://carrion.dev/es/posts/kotlin-delegates/Mon, 23 Dec 2024 08:00:00 +0100ignacio@carrion.dev (Ignacio Carrión)Mon, 23 Dec 2024 08:00:00 +0100https://carrion.dev/es/posts/kotlin-delegates/✨ Entendiendo los Kotlin Delegates: La magia detrás de código más limpio ✨ Los Kotlin delegates son una funcionalidad muy útil que te permite delegar el comportamiento de una propiedad o incluso una implementación de una interfaz a otro objecto. En lugar de escribir lógica repetitiva o manejar el estado directamente, puedes delegar esta responsabilidad a clases especializadas y reusables. Como funcionan los Delegates Delegates en Kotlin funcionan usando la palabra reservada by, que redirecciona el comportamiento de una propiedad o interfaz al objeto delegado.Ignacio Carriónfeatured imagekotlinandroidadvancedhttps://carrion.dev/es/posts/kotlin-contracts/Fri, 20 Dec 2024 08:00:00 +0100ignacio@carrion.dev (Ignacio Carrión)Fri, 20 Dec 2024 08:00:00 +0100https://carrion.dev/es/posts/kotlin-contracts/Kotlin Avanzado - Contracts: Cómo volver al compilador de Kotlin más inteligente Kotlin nunca deja de impresionarme con sus funcionalidades. Una función avanzada pero poco utilizada en el arsenal de Kotlin son los Contracts. Los contratos te permiten guiar al compilador de Kotlin para que tome mejores decisiones acerca de tu código, resultando en mejor seguridad ante nulos, mejor rendimiento o incluso menores errores en tiempo de ejecución. Qué son los contratos de Kotlin?Ignacio Carriónfeatured imagekotlinandroidadvancedhttps://carrion.dev/es/posts/swift-export/Wed, 18 Dec 2024 08:00:00 +0100ignacio@carrion.dev (Ignacio Carrión)Wed, 18 Dec 2024 08:00:00 +0100https://carrion.dev/es/posts/swift-export/Exportar a Swift en KMP Empezando con la versión 2.1.0 podemos empezar a probar a exportar a Swift en Kotlin. Esta funcionalidad te permite exportar los módulos compartidos de Kotlin a Swift sin usar Objective-C. Esto mejorará la experiancia de los desarrolladores de iOS cuando usen módulos de KMP. Actualmente el soporte básico incluye: Exportar múltiples módulos de Gradle a swift. Definir los nombres de los módulos swift. Simplificar la estructura de paquetes.Ignacio Carriónfeatured imagekotlinandroidkmphttps://carrion.dev/es/posts/kotlin-guard-conditions-in-when/Tue, 17 Dec 2024 08:00:00 +0100ignacio@carrion.dev (Ignacio Carrión)Tue, 17 Dec 2024 08:00:00 +0100https://carrion.dev/es/posts/kotlin-guard-conditions-in-when/Condiciones en las expresiones when en Kotlin 2.1.0 Una de las nuevas funcionalidades de Kotlin 2.1.0 es las condiciones en las expresiones when, lo que tendría varias ventajas entre las que se incluye: Reducir anidaciones Evita código repetido Mejorar legibilidad Activar la funcionalidad en Kotlin 2.1.0 Esta funcionalidad se encuentra en preview lo que es necesario activarla explícitamente para poder usarla en Kotlin 2.1.0. En el fichero build.gradle.kts añadiremos el siguiente código dentro del bloque de kotlin {}:Ignacio Carriónfeatured imagekotlinandroidkmphttps://carrion.dev/es/posts/hilt-inject-parameters-runtime/Wed, 24 Feb 2021 07:00:06 +0100ignacio@carrion.dev (Ignacio Carrión)Wed, 24 Feb 2021 07:00:06 +0100https://carrion.dev/es/posts/hilt-inject-parameters-runtime/Inyección de valores en tiempo de ejecución con Dagger-Hilt Desde que apareció Hilt para facilitar la inyección de dependencias en aplicaciones Android, no era posible la inyección de dependencias en tiempo de ejecución sin utilizar librerías ajenas a Dagger o Hilt. Desde la versión 2.31 se incorpora en Dagger la anotación @AssistedInject. Con esta anotación vamos a ser capaces de indicar a Dagger-Hilt que dependencias se tienen que resolver en tiempo de ejecución y retrasar la inyección de esos parámetros hasta tener los valores.Ignaciofeatured imagekotlinandroidjetpackcoroutinesandroidxhttps://carrion.dev/es/posts/welcome-to-my-new-kotlin-and-android-development-blog/Tue, 23 Feb 2021 10:00:06 +0100ignacio@carrion.dev (Ignacio Carrión)Tue, 23 Feb 2021 10:00:06 +0100https://carrion.dev/es/posts/welcome-to-my-new-kotlin-and-android-development-blog/Bienvenido a Carrion.dev Saludos Androide!! Bienvenido a mi nuevo blog de Kotlin y programación Android. Me llamo Ignacio Carrión y soy dessarrollador Android. Me encanta el lenguaje Kotlin por las facilidades que me aporta al programar para Android y las infinitas posibilidades que ofrece en otros ámbitos (backend, web, nativo, multiplataforma). En este blog espero poder publicar cosas interesantes acerca del lenguaje Kotlin y el ecosistema Android al menos cada dos semanas.Ignaciofeatured imagekotlinandroidjetpackcoroutinesandroidx