Aquí hay una entrada de blog de alta calidad escrita para My Core Pick.

Escribe una vez, envía más rápido: Unificando la lógica de iOS y Android con Kotlin Multiplatform

Recuerdo el día en que me di cuenta de que algo estaba fundamentalmente roto en nuestro proceso de desarrollo móvil.

Teníamos un error en nuestro flujo de pago.

El equipo de Android lo arregló el martes.

El equipo de iOS arregló el mismo error exacto el jueves.

Estábamos pagando a dos equipos diferentes para escribir la misma lógica, verificar las mismas reglas y analizar las mismas respuestas JSON.

Se sentía ineficiente porque lo era.

Durante años, la solución de la industria para esto fueron los marcos de trabajo "Cross-Platform" (multiplataforma) como Flutter o React Native.

Pero esos a menudo significaban sacrificar la interfaz de usuario (UI) nativa o lidiar con puentes de rendimiento que ralentizaban las cosas.

Luego llegó Kotlin Multiplatform (KMP).

Prometía algo diferente: compartir la lógica, mantener la UI nativa.

Hoy, voy a explicarte por qué KMP es mi elección principal para la arquitectura móvil moderna, y cómo te permite escribir código una vez y enviar más rápido que nunca.

El problema con "Escribe una vez, ejecuta en todas partes"

Durante mucho tiempo, el santo grial del desarrollo móvil fue una base de código única que se ejecutara en todas partes.

Marcos de trabajo como React Native o Flutter intentan resolver esto renderizando su propia UI.

Básicamente dicen: "Ignora los botones nativos de iOS y Android; usa nuestros botones en su lugar".

Esto funciona muy bien para muchas aplicaciones.

Pero a veces, se siente ligeramente fuera de lugar.

Las animaciones pueden no ser del todo correctas, o sale una nueva función de iOS que el marco de trabajo aún no admite.

Siempre he sido un purista cuando se trata de Experiencia de Usuario (UX).

Quiero que mi aplicación de iOS se sienta 100% como una aplicación de iOS, usando SwiftUI o UIKit.

Quiero que mi aplicación de Android se sienta 100% como una aplicación de Android, usando Jetpack Compose.

Sin embargo, no quiero escribir la lógica de validación de datos dos veces.

No quiero escribir la capa de red dos veces.

Aquí es donde Kotlin Multiplatform cambia el juego.

No intenta ser una solución de "Escribe una vez, ejecuta en todas partes".

Es una solución de "Escribe la lógica una vez, ejecuta en todas partes".

Cómo funciona realmente KMP (Bajo el capó)

Si eres nuevo en KMP, la arquitectura puede parecer un poco mágica.

Pero en realidad se basa en conceptos de programación muy estándar.

En un proyecto KMP, tienes un Módulo Compartido.

Este módulo contiene código Kotlin puro.

Aquí es donde pones tu "lógica de negocio".

¿Qué es la lógica de negocio?

Cuando digo lógica de negocio, me refiero al cerebro de tu aplicación.

Esto incluye hacer llamadas a la API a tu backend.

Incluye almacenar datos en caché en una base de datos local.

Implica validar la entrada del usuario (como comprobar si una dirección de correo electrónico es válida).

Incluye analizar datos JSON en objetos que tu aplicación pueda usar.

La magia del compilador

Cuando compilas tu proyecto, KMP hace algo brillante.

Para la aplicación de Android, compila el código Kotlin en Bytecode de Java, tal como es normal.

Pero para la aplicación de iOS, compila ese mismo código Kotlin en un framework de Apple (usando LLVM).

Para Xcode, tu código Kotlin compartido simplemente parece un framework de Objective-C o Swift.

Lo importas y llamas a las funciones.

El desarrollador de iOS ni siquiera necesita saber cómo escribir Kotlin para usarlo.

Simplemente ven una función llamada fetchUser() y la llaman.

El arma secreta: Expect y Actual

Una de las características más poderosas de KMP es el mecanismo expect y actual.

A veces, necesitas acceder a APIs específicas de la plataforma en tu código compartido.

Por ejemplo, tal vez necesites generar un UUID.

Android maneja esto de manera diferente a iOS.

En tu código compartido, puedes definir una función expect.

Se ve así: expect fun randomUUID(): String

Esto es básicamente decir: "Espero que haya una función que devuelva una cadena, pero aún no sé cómo funciona".

Luego, dentro del conjunto de fuentes (source set) de Android, escribes la implementación actual usando bibliotecas de Java.

Dentro del conjunto de fuentes de iOS, escribes la implementación actual usando las bibliotecas Foundation de Apple.

Esto te permite compartir lógica de alto nivel mientras sigues aprovechando las capacidades nativas siempre que lo necesites.

Elimina la limitación de "caja negra" que a menudo tienen otros marcos multiplataforma.

Mi elección principal: La pila tecnológica de KMP

Si decides saltar a KMP, necesitas las bibliotecas adecuadas.

No puedes usar simplemente Retrofit o Room, porque esas son bibliotecas Java específicas de Android.

Necesitas bibliotecas compatibles con multiplataforma.

Aquí está la pila de "My Core Pick" para una aplicación KMP robusta.

Redes (Networking): Ktor

Ktor es un marco asíncrono para crear microservicios y aplicaciones web, pero crea clientes HTTP increíbles.

Está construido por JetBrains (los creadores de Kotlin) y es totalmente multiplataforma.

Maneja encabezados, autenticación y serialización sin problemas en iOS y Android.

Base de datos: SQLDelight

Esta es mi herramienta de base de datos favorita, y punto.

SQLDelight genera APIs de Kotlin con seguridad de tipos a partir de tus declaraciones SQL.

Verifica tu esquema durante la compilación.

Si cometes un error tipográfico en tu consulta SQL, el código no compilará.

Se ejecuta en SQLite tanto en Android como en iOS, haciendo que tu capa de datos sea absolutamente sólida.

Inyección de dependencias: Koin

La inyección de dependencias puede ser complicada en un entorno multiplataforma.

Koin es un marco de inyección ligero que funciona muy bien con KMP.

Utiliza un DSL (Lenguaje Específico de Dominio) específico que es fácil de leer.

Te permite inyectar tu base de datos y clientes de red directamente en tus ViewModels compartidos.

Concurrencia: Kotlin Coroutines

Lidiar con hilos en iOS y Android solía ser una pesadilla de callbacks y delegados.

Kotlin Coroutines te permite escribir código asíncrono que parece código síncrono.

Puedes ejecutar operaciones complejas en segundo plano en un hilo secundario y devolver el resultado al hilo principal sin bloquear la UI.

Crucialmente, esto interopera con el patrón async/await de Swift, haciéndolo natural para que los desarrolladores de iOS lo consuman.

Los beneficios del mundo real para tu equipo

¿Por qué deberías abogar realmente por esto en tu empresa?

Se reduce a tres cosas: Velocidad, Consistencia y Cordura.

1. La velocidad de iteración

Cuando agregas una nueva función, escribes la lógica una vez.

Escribes las pruebas unitarias una vez.

Solo tienes que construir la UI dos veces.

Esto crea una reducción significativa en el tiempo de desarrollo, generalmente alrededor del 30-40% una vez que el equipo está al día.

2. La consistencia es el rey

Mencioné la corrección de errores antes.

Con KMP, si corriges un error lógico en el módulo compartido, lo corriges para ambas plataformas al instante.

Garantizas que la aplicación de iOS y la aplicación de Android se comporten exactamente de la misma manera.

Calcularán precios de la misma manera.

Ordenarán listas de la misma manera.

Esto reduce masivamente la carga cognitiva en tu equipo de QA.

3. La cordura del desarrollador

Los desarrolladores de Android ya aman Kotlin.

Es un lenguaje moderno, expresivo y seguro.

Los desarrolladores de iOS, ciertamente, suelen dudar en dejar Swift.

Pero debido a que KMP deja la UI a SwiftUI, los desarrolladores de iOS no sienten que están perdiendo el control.

Todavía pueden construir interfaces hermosas y nativas.

Simplemente ya no tienen que escribir el aburrido código repetitivo (boilerplate) para analizar JSON.

Empezando: Una estrategia para la adopción

Entonces, ¿cómo empiezas?

No reescribas toda tu aplicación mañana.

Esa es una receta para el desastre.

KMP está diseñado para ser adoptado incrementalmente.

Empieza con un módulo pequeño y aislado.

Tal vez sea tu lógica de análisis.

Tal vez sea una función simple como un "Feed de noticias".

Paso 1: La configuración

Usa el Kotlin Multiplatform Wizard proporcionado por JetBrains.

Genera la estructura de carpetas y la configuración de Gradle para ti.

Ahorra horas de dolores de cabeza de configuración.

Paso 2: Mover los modelos

Empieza moviendo tus Modelos de Datos (tus clases básicas) al módulo compartido.

Esto asegura que ambas aplicaciones hablen el mismo idioma.

Paso 3: Mover las redes

Una vez que tus modelos estén compartidos, mueve las llamadas a la API.

Reemplaza Retrofit (Android) y Alamofire (iOS) con Ktor en el módulo compartido.

Pasa los datos de vuelta a las capas de UI nativas.

Pensamientos finales

El panorama del desarrollo móvil está cambiando.

Nos estamos alejando del enfoque en silos donde iOS y Android son mundos completamente diferentes.

También estamos superando el "compromiso" de las herramientas multiplataforma basadas en la web.

Kotlin Multiplatform da en el clavo.

Respeta las diferencias de plataforma donde importa (la UI).

Unifica las similitudes donde cuenta (la Lógica).

Si quieres enviar más rápido, reducir errores y mantener tu apariencia y sensación nativa, KMP es el camino a seguir.

Es definitivamente una Elección Principal en mi kit de herramientas de desarrollador.

Pruébalo en tu próxima función, y te prometo que no querrás volver a escribir el mismo código dos veces.