Skip to main content

Kotlin: Un lenguaje pragmático y moderno

⏱ Dedicación recomendada: 0 minutos
Esto considera el contenido visible y relevante, e ignora texto colapsado o marcado como opcional.

El gato se llama Kotlin

Kotlin es un lenguaje moderno que se destaca por su pragmatismo, claridad y su fuerte enfoque en la seguridad. En los últimos años ha ganado gran popularidad gracias a su capacidad para combinar de forma efectiva los paradigmas de programación orientada a objetos y programación funcional, todo dentro de una sintaxis concisa y expresiva.

En este curso exploraremos Kotlin como una herramienta para el diseño e implementación de bibliotecas de software reutilizables. Su interoperabilidad con Java, el modelo de seguridad frente a valores nulos, el soporte para funciones de extensión, corrutinas y otras características modernas lo convierten en una excelente opción para construir componentes modulares, mantenibles y multiplataforma.

Esta primera lección ofrece una introducción al lenguaje y su filosofía. Veremos cómo se escribe en Kotlin, en qué se diferencia de otros lenguajes, y qué ventajas ofrece a quienes buscan escribir código expresivo, seguro y pragmático desde el comienzo.

A través de ejemplos simples y comparaciones prácticas, comenzaremos a establecer las bases sobre las que se apoyará el resto del curso.

🔍 ¿Qué aprenderás en este módulo?​

En este módulo introductorio conocerás los fundamentos esenciales de Kotlin y cómo aplicarlos para crear software reutilizable y expresivo. A lo largo de estas lecciones:

  • Descubrirás qué es Kotlin, cuál es su filosofía y por qué es una excelente opción para construir bibliotecas modernas.
  • Aprenderás a declarar funciones y variables, y distinguir entre valores mutables e inmutables.
  • Comprenderás la diferencia entre expresiones y declaraciones, y cómo aprovecharlas para escribir código más claro y conciso.
  • Explorarás las estructuras de control como condicionales, ciclos y rangos, y su sintaxis idiomática en Kotlin.
  • Verás cómo funciona el punto de entrada de un programa Kotlin y cómo ejecutar tu primer proyecto con Gradle.

Este módulo sienta las bases sobre las que se construirá el resto del curso, donde nos enfocaremos en técnicas para diseñar bibliotecas reutilizables, seguras y fáciles de mantener.

🎯 Objetivos de aprendizaje​

Al finalizar este módulo, serás capaz de:

  • Explicar qué es Kotlin, cuál es su filosofía y cómo facilita el desarrollo de bibliotecas reutilizables y multiplataforma.
  • Declarar funciones y variables, comprendiendo las diferencias entre val, var y los tipos básicos.
  • Usar expresiones condicionales para modelar decisiones de forma concisa y expresiva.
  • Aplicar ciclos y rangos para recorrer estructuras repetitivas con claridad.
  • Identificar la estructura general de un programa en Kotlin y su punto de entrada.
  • Emplear interpolación de cadenas para construir mensajes dinámicos de manera eficiente.

Estos objetivos sientan una base sólida para abordar conceptos más avanzados, como tipos algebraicos, estructuras de control más expresivas y diseño orientado a la composición.

😺 ¿Qué es Kotlin?​

Kotlin es un lenguaje de programación moderno y multiplataforma desarrollado por JetBrains, que combina características de la programación orientada a objetos y la programación funcional. Se destaca por su sintaxis concisa, su enfoque en la seguridad y su capacidad para compilar en múltiples plataformas:

  • JavaScript (JS) y WebAssembly (WASM) para ejecución en navegadores.
  • Java Virtual Machine (JVM) para aplicaciones de servidor y Android.
  • LLVM para aplicaciones nativas en escritorio, iOS y sistemas embebidos.

En este curso nos enfocaremos en Kotlin sobre la JVM, la plataforma más consolidada y ampliamente utilizada del ecosistema. Aun así, los conceptos y técnicas que aprenderás son altamente transferibles a las demás plataformas soportadas por Kotlin, y aplicables en muchos otros lenguajes modernos.

🚀 A Taste of Kotlin​

A continuación, te mostramos un ejemplo sencillo en Kotlin para que te familiarices con su sintaxis y estilo expresivo:

data class Person(
    val name: String,
    val age: Int? = null
)

fun main() {
    val persons = listOf(
        Person("Harrier Du Bois"),
        Person("Kim Kitsuragi", age = 43)
    )
    val youngest = persons.minByOrNull { it.age ?: Int.MAX_VALUE }
    println("The youngest is: $youngest")
}
// Output: The youngest is: Person(name=Kim Kitsuragi, age=43)
¿Qué acabamos de hacer?
  • [1–4] Se declara una data class llamada Person con dos propiedades: name de tipo String y age de tipo Int? (opcional).
  • [3] La propiedad age tiene como valor por defecto null.
  • [7–10] Se crea una lista inmutable con listOf, que contiene dos personas.
  • [9] En el segundo objeto se utiliza una asignación nombrada (age = 43).
  • [11] Se usa minByOrNull con el operador Elvis (?:) para ignorar los null y encontrar la persona más joven.
  • [12] Se imprime el resultado usando interpolación de cadenas.

📜 Filosofía de Kotlin​

Kotlin fue diseñado con el objetivo de hacer la programación más sencilla, segura y expresiva, sin renunciar a la flexibilidad ni a la potencia. En lugar de introducir ideas experimentales o radicales, adopta prácticas consolidadas de otros lenguajes modernos, integrándolas de forma coherente y pragmática.

Algunos de sus principios fundamentales son:

  • Pragmatismo: Está orientado a resolver problemas reales de forma efectiva, priorizando la practicidad sobre las restricciones del lenguaje.
  • Concisión y legibilidad: Su sintaxis minimiza la verbosidad sin sacrificar claridad.
  • Seguridad: Previene errores comunes en tiempo de compilación, como las referencias nulas, fomentando un código más robusto.
  • Claridad intencional: Promueve un estilo donde la intención del código es explícita y fácilmente comprensible para otras personas.

⚖️ Beneficios y limitaciones de Kotlin en el desarrollo de bibliotecas de software​

Beneficios

  • Interoperabilidad con Java → Kotlin se integra sin fricciones con Java, lo que permite reutilizar bibliotecas existentes y adoptar Kotlin de forma gradual.
  • Sintaxis concisa y expresiva → Reduce la repetición de código, mejora la legibilidad y facilita el mantenimiento de bibliotecas.
  • Seguridad frente a nulls → El sistema de tipos de Kotlin previene errores comunes como los NullPointerException, fortaleciendo la robustez de las APIs.
  • Funciones de extensión → Permiten ampliar funcionalidades sin modificar las clases originales, lo que resulta útil para extender bibliotecas de terceros.
  • Compatibilidad multiplataforma → Posibilita crear bibliotecas que funcionan en JVM, JS y Native, fomentando la reutilización de código.
  • Corrutinas integradas → Facilitan la programación asíncrona de manera eficiente y con una sintaxis clara.
  • Facilidad para crear DSLs → Kotlin ofrece herramientas para construir APIs más expresivas e idiomáticas, mejorando la experiencia de uso.

Limitaciones

  • Falta de algunas abstracciones avanzadas → Kotlin aún no ofrece soporte completo para conceptos como los Higher-Kinded Types (HKT) o mecanismos como los implicits en Scala.
    Esta limitación es intencional: en lugar de incorporar abstracciones complejas o experimentales, Kotlin prioriza aquellas que han demostrado ser útiles y comprensibles en contextos reales.
    No obstante, ya se están explorando propuestas como los context parameters, que podrían habilitar nuevos patrones de diseño funcional reutilizable sin sacrificar la claridad del lenguaje.
  • Ausencia de pattern matching exhaustivo → Kotlin no cuenta con un sistema de pattern matching tan expresivo como el de lenguajes funcionales como Scala, Rust o Haskell.
    Aunque se pueden utilizar when y jerarquías selladas para lograr cierto control exhaustivo, no existe una sintaxis declarativa para hacer match de estructuras anidadas ni extraer múltiples valores simultáneamente.

A lo largo del curso, aprenderás a sacar el máximo provecho de Kotlin en el diseño de bibliotecas, aprovechando sus fortalezas y encontrando soluciones pragmáticas cuando el lenguaje no ofrece una abstracción directamente.

🧮 Expresiones vs. Declaraciones​

Es importante distinguir entre expresiones y declaraciones, ya que cumplen roles distintos dentro de un programa. En Kotlin, esta diferencia es clara y ayuda a escribir código más seguro y predecible. Otros lenguajes como Scala o Rust también permiten que muchas construcciones sean expresiones, lo que otorga mayor flexibilidad, aunque puede dificultar el seguimiento del flujo de datos si no se usa con cuidado.

Expresiones

Las expresiones son fragmentos de código que producen un valor y pueden combinarse con otras expresiones. En Kotlin, una expresión puede ser tan simple como una constante, o tan compleja como una función anónima. Ejemplos comunes son operaciones aritméticas, operadores lógicos y llamadas a funciones.

Declaraciones

Las declaraciones son instrucciones que realizan una acción, y en general no se utilizan por su valor. No pueden combinarse con otras expresiones. Ejemplos incluyen la definición de variables, la ejecución de bucles o la declaración de funciones.

Una diferencia clave frente a lenguajes como Java, C o JavaScript es que en esos lenguajes las asignaciones son expresiones, lo que permite errores como if (x = 5) cuando en realidad se quería comparar (==) en lugar de asignar (=). En cambio, en Kotlin las asignaciones son declaraciones, lo que impide ese tipo de ambigüedades y ayuda a detectar errores en tiempo de compilación.

A continuación, una tabla con ejemplos representativos:

Ejemplo¿Expresión o declaración?¿Devuelve valor?
val x = 5DeclaraciónNo
5ExpresiónSí (5)
if (a > b) a else bExpresiónSí (valor de a o b)
fun greet() { println() }DeclaraciónNo
En resumen
  • Las expresiones devuelven un valor y se pueden usar dentro de otras expresiones.
  • Las declaraciones ejecutan acciones y no se pueden componer con otras.

Esta distinción clara en Kotlin contribuye a una programación más segura, expresiva y menos propensa a errores sutiles.

🧵 Interpolación de cadenas​

La interpolación de cadenas (también conocida como string templates) es una característica de Kotlin que permite insertar valores de variables o resultados de expresiones directamente dentro de una cadena (String) usando el símbolo $. Para variables simples, basta con escribir $variable, mientras que para expresiones más complejas se utilizan llaves: ${expresión}.

⚔️ Ejemplo​

En el siguiente ejemplo mostramos el estado de un personaje según sus puntos de vida (hp):

val name = "Leif"
val hp = 24

println("Unit: $name | Status: ${if (hp <= 0) "defeated" else "active"}")

Esto imprimirá:

Unit: Leif | Status: active

Gracias a la interpolación de cadenas, podemos construir mensajes dinámicos de forma clara, concisa y expresiva, sin necesidad de concatenar manualmente con operadores como +.

Además, las expresiones interpoladas se evalúan en el momento en que se forma la cadena final, lo que aporta claridad y eficiencia en tiempo de ejecución.

Sin prefijos especiales

A diferencia de otros lenguajes como Scala (s"Hola, $nombre") o Python (f"Hola, {nombre}"), en Kotlin no necesitas usar prefijos como s o f para habilitar la interpolación.

En Kotlin, todas las cadenas soportan interpolación de forma nativa, sin configuraciones adicionales. Esto simplifica su uso, reduce errores y mejora la legibilidad del código.

¿Qué es un StringBuilder?

Cuando interpolamos cadenas en Kotlin, el compilador genera código que utiliza un StringBuilder, una clase optimizada para construir texto de forma eficiente y sin crear objetos intermedios innecesarios.

Un StringBuilder permite modificar una cadena en memoria (agregando, insertando o eliminando texto) sin crear un nuevo objeto String cada vez. Esto es importante porque en Kotlin (y en Java), las cadenas (String) son inmutables: cada concatenación con + crea una nueva instancia.

Por ejemplo, esta interpolación:

val name = "Leif"
val status = "active"
val message = "Unit: $name | Status: $status"

Se traduce internamente en algo similar a:

val sb = StringBuilder()
sb.append("Unit: ")
sb.append(name)
sb.append(" | Status: ")
sb.append(status)
val message = sb.toString()

Gracias a esto, la interpolación en Kotlin es más legible que la concatenación manual y más eficiente que usar + repetidamente.

🚀 Crear tu primer proyecto Kotlin con Gradle​

Antes de comenzar a escribir código Kotlin, necesitamos configurar un entorno de desarrollo funcional.
En esta sección aprenderás cómo crear un proyecto Kotlin básico desde la terminal utilizando Gradle, el sistema de construcción que usaremos durante el curso.

Te proporcionamos instrucciones específicas para Windows, Linux y macOS, adaptadas a los comandos y alias comunes en cada sistema operativo:

"intro-kt" | ForEach-Object {
    New-Item -Path $_ -ItemType Directory -Force
    Set-Location $_
} && gradle init --use-defaults --type kotlin-application
¿Qué acabamos de hacer?

Este bloque de PowerShell automatiza la creación de un proyecto Kotlin utilizando Gradle:

  1. "intro-kt" | ForEach-Object { ... }: Usa un pipeline para crear y entrar a un directorio llamado intro-kt. Aunque aquí se usa un solo nombre, este patrón permite trabajar con múltiples nombres si fuera necesario.
  2. New-Item -Path $_ -ItemType Directory -Force: Crea el directorio. -Force evita errores si el directorio ya existe.
  3. Set-Location $_: Cambia al nuevo directorio.
  4. && gradle init --use-defaults --type kotlin-application: Inicializa un proyecto Gradle como aplicación Kotlin, con configuración por defecto.

Por ahora, crearemos una aplicación de consola para probar nuestro código. Más adelante aprenderemos a utilizar Gradle para construir bibliotecas de software reutilizables.

Una vez creado el proyecto, puedes abrirlo con IntelliJ IDEA, Fleet u otro editor. Aún no necesitas comprender a fondo la estructura del proyecto, pero es útil tener en cuenta sus directorios principales:

  • El código fuente está en app/src/main/kotlin.
  • Las pruebas se ubican en app/src/test/kotlin.

Si estás usando IntelliJ IDEA y tienes disponible la herramienta idea en tu terminal, puedes abrir el proyecto con el siguiente comando:

idea .
¿Qué acabamos de hacer?

Este comando abre el proyecto actual en IntelliJ IDEA, siempre que tengas habilitado el Command Line Launcher (idea). Puedes activarlo desde el menú Tools > Create Command-line Launcher.

🧠 Ejercicio de cierre: Un "Hello, World" con sentido​

Ya creaste tu primer proyecto en Kotlin. Ahora es momento de darle voz propia. Tu tarea consiste en explorar la estructura del proyecto, encontrar el punto de entrada del programa, y modificarlo para que imprima un mensaje auténtico y significativo para ti.

No se trata de un simple "Hello, World", sino de una frase que te represente: una letra de canción que te acompaña, una cita de tu cómic favorito, una línea que solo quienes jugaron ese juego entenderán, o incluso algo que hayas escrito tú.

🛠️ Para ejecutar el programa, usa:​

./gradlew :app:run

Si todo está bien configurado, tu mensaje aparecerá en la consola ✨

Recuerda

No necesitas crear clases adicionales ni preocuparte por la estructura ideal, ¡solo diviértete explorando el lenguaje!

Solución

Una solución posible —con un toque literario— podría ser:

app/src/main/kotlin/org/example/App.kt
val greeting: String
    get() = "Ladies and Gentlemen, I give you Rose Red's killer..."

📖 Referencias​

🔥 Recomendadas​

  • 🌐 Basic types en la documentación oficial de Kotlin: Introduce los tipos básicos del lenguaje (enteros, flotantes, booleanos, caracteres y cadenas), junto con la inferencia de tipos, inicialización de variables y operadores compuestos.
  • 📚 "Kotlin basics" (pp. 17–43) en Kotlin in Action por Dmitry Jemerov y Svetlana Isakova.
  • 📚 "Kotlin: What and why" (pp. 3–16) en Kotlin in Action por Dmitry Jemerov y Svetlana Isakova.

🔹 Adicionales​