Kotlin: Un lenguaje pragmático y moderno

Encuentra el código de la lección:

Abstract

Kotlin es un lenguaje moderno que destaca por su pragmatismo, claridad y un fuerte enfoque en la seguridad. En los últimos años ha ganado gran popularidad gracias a su capacidad para combinar de forma eficaz 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, su modelo seguro 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 a 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 sentar las bases que guiarán 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 a diferenciar entre valores mutables e inmutables.
Comprenderás la diferencia entre expresiones y declaraciones, y cómo aprovecharla para escribir código más claro y conciso.
Explorarás 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 sentará las bases conceptuales y prácticas para lo que sigue: 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 por qué es una excelente opción para desarrollar bibliotecas reutilizables y multiplataforma.
Declarar funciones y variables, comprendiendo la diferencia entre val val y var var , así como el uso de tipos básicos.
Utilizar expresiones condicionales para modelar decisiones de forma clara, concisa e idiomática.
Aplicar ciclos y rangos para recorrer colecciones y estructuras repetitivas siguiendo las convenciones del lenguaje.
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 expresiva.

Estos objetivos te permitirán construir una base sólida para abordar temas más avanzados como tipos algebraicos, control de flujo funcional y diseño orientado a la composición.

¿Qué es Kotlin?

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

JavaScript (JS) y WebAssembly (WASM) para ejecución en navegadores.
Java Virtual Machine (JVM) para aplicaciones de servidor y desarrollo en 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 del ecosistema. Sin embargo, los conceptos que aprenderás son altamente transferibles a las demás plataformas compatibles 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 expresiva y concisa:

Primer programa: filtrar y mostrar datos

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)

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?

Se define una data class data class llamada Person Person con dos propiedades: name name de tipo String String y age age de tipo Int? Int? (puede ser nulo).
La propiedad age age tiene un valor por defecto ( null null ), lo que permite omitirla al crear una instancia.
Se crea una lista inmutable con listOf listOf , que contiene dos objetos Person Person .
En la segunda instancia se utiliza una asignación nombrada ( age = 43 age = 43 ) para mayor claridad y legibilidad.
Se emplea minByOrNull minByOrNull junto con el operador Elvis ( ?: ?: ) para ignorar los valores nulos y encontrar la persona más joven.
Si todas las edades fueran nulas, se usa Int.MAX_VALUE Int.MAX_VALUE como valor de reemplazo para evitar errores.
Finalmente, se imprime el resultado usando interpolación de cadenas.

Filosofía de Kotlin

Kotlin fue diseñado con el propósito 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 y las integra de forma coherente y pragmática.

Entre sus principios fundamentales se encuentran:

Pragmatismo: resuelve problemas reales de forma efectiva, priorizando la practicidad sobre las restricciones artificiales.
Concisión y legibilidad: su sintaxis reduce la verbosidad sin sacrificar claridad.
Seguridad: previene errores comunes en tiempo de compilación —como las referencias nulas— y fomenta un código más robusto.
Claridad intencional: promueve un estilo en el que la intención del código es explícita y fácil de comprender 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 el ecosistema Java, lo que permite reutilizar bibliotecas existentes y adoptar el lenguaje de forma gradual, incluso en bases de código heredadas.
Sintaxis concisa y expresiva → Reduce la repetición de código, mejora la legibilidad y facilita el mantenimiento. Favorece el diseño de APIs limpias y DSLs orientadas a usabilidad.
Seguridad frente a nulls → Su sistema de tipos previene errores comunes como NullPointerException NullPointerException , reforzando la robustez de las APIs y facilitando contratos más confiables.
Funciones de extensión → Permiten ampliar funcionalidades sin modificar clases originales, fomentando una arquitectura modular y extensible — ideal para bibliotecas reutilizables.
Compatibilidad multiplataforma → Posibilita crear bibliotecas que funcionan en JVM, JS y Native, promoviendo la reutilización de código entre diferentes entornos. Requiere seguir ciertas restricciones de API común.
Corrutinas integradas → Facilitan la programación asíncrona con una sintaxis clara y eficiente, lo que permite exponer APIs no bloqueantes en bibliotecas como clientes HTTP o SDKs.
Facilidad para crear DSLs → Permite construir APIs idiomáticas, expresivas y personalizables, ideales para bibliotecas de configuración, testing o transformación de datos.

Limitaciones

Falta de algunas abstracciones avanzadas → Kotlin aún no ofrece soporte completo para conceptos como los Higher-Kinded Types (HKT) ni mecanismos como los implicits de Scala. Esta omisión es intencional: prioriza la claridad y la utilidad práctica. No obstante, ya se exploran propuestas como los context parameters, que podrían habilitar nuevos patrones funcionales sin comprometer legibilidad.
Ausencia de pattern matching exhaustivo → Kotlin no cuenta con un sistema de pattern matching tan expresivo como Scala, Rust o Haskell. Aunque when when y las jerarquías selladas permiten cierto control, no existe una sintaxis declarativa para hacer match de estructuras anidadas ni extraer múltiples valores simultáneamente.

Kotlin es una excelente opción para diseñar bibliotecas modernas, seguras y expresivas. Su enfoque pragmático lo convierte en una herramienta poderosa para la reutilización de código. Sin embargo, su decisión de no incluir ciertas abstracciones avanzadas puede limitar algunos estilos de diseño altamente genéricos o funcionales.

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 provee una abstracción directamente.

¿Qué distingue una expresión de una declaración?

En Kotlin, es importante distinguir entre expresiones y declaraciones, ya que cumplen funciones diferentes dentro de un programa. Esta distinción —también presente en lenguajes como Rust— favorece un estilo de programación más seguro y predecible.

Expresión

Una expresión produce un valor y puede combinarse con otras. En Kotlin, esto incluye desde constantes hasta funciones anónimas. También lo son operaciones aritméticas, operadores lógicos y llamadas a funciones.

Declaración

Las declaraciones son instrucciones que realizan una acción. En general, no se usan por su valor, y no pueden combinarse con otras expresiones. Ejemplos comunes son la definición de variables, bucles o funciones.

Una diferencia clave con lenguajes como Java, C o JavaScript es que en esos lenguajes las asignaciones son expresiones, lo que puede llevar a errores como if (x = 5) if (x = 5) cuando en realidad se quería comparar ( if (x == 5) if (x == 5) ). En Kotlin, las asignaciones son declaraciones, lo que impide este tipo de ambigüedades y permite que el compilador detecte errores más fácilmente.

A continuación, una tabla con ejemplos representativos:

Ejemplos de expresiones y declaraciones en Kotlin
Ejemplo	¿Expresión o declaración?	¿Devuelve valor?
`val x = 5 val x = 5`	Declaración	No
`5 5`	Expresión	Sí, el valor `5 5`
`if (a > b) a else b if (a > b) a else b`	Expresión	Sí, el valor de `a a` o `b b`
`fun greet() { println() } fun greet() { println() }`	Declaración	No

En resumen

Las expresiones devuelven un valor y pueden ser combinadas con otras expresiones.
Las declaraciones ejecutan acciones y no devuelven un valor, por lo que no pueden ser combinadas con otras expresiones.

Esta diferencia promueve una programación más expresiva, segura 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 o expresiones directamente dentro de un String String usando el símbolo $ $ .

Para insertar una variable, basta con escribir $variable $variable . En el caso de expresiones, se deben usar llaves: ${expresión} ${expresión} .

Ejemplo

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

Interpolación de cadenas en acción

val name = "Leif"
val hp = 24

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

val name = "Leif"
val hp = 24

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

Esto imprimirá:

Salida en consola

Unit: Leif | Status: active

Unit: Leif | Status: active

Gracias a la interpolación de cadenas, podemos construir mensajes dinámicos de forma más clara, concisa y expresiva, evitando la concatenación manual con operadores como + + .

Además, las expresiones interpoladas se evalúan en el momento en que se construye la cadena, lo que aporta claridad y eficiencia sin sobrecostos innecesarios.

Sin prefijos especiales

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

En Kotlin, todas las cadenas admiten interpolación de forma nativa, lo que las hace más simples, legibles y menos propensas a errores.

¿Qué es un `StringBuilder StringBuilder` ?

Cuando interpolamos cadenas en Kotlin, el compilador genera código que usa internamente un StringBuilder StringBuilder , una clase optimizada para construir texto de forma eficiente sin crear múltiples objetos intermedios.

Esto es relevante porque en Kotlin (y en Java), las cadenas ( String String ) son inmutables: cada vez que concatenas con + + , se crea una nueva instancia, lo cual puede degradar el rendimiento en operaciones repetidas o dentro de bucles.

Un StringBuilder StringBuilder , en cambio, permite modificar la cadena en memoria, agregando, insertando o eliminando texto sin copiar constantemente.

Por ejemplo, esta interpolación:

Interpolación de cadenas

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

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

Se traduce internamente a algo similar a esto:

Traducción interna usando StringBuilder

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

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

Gracias a esta conversión, 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.

Gradle es una herramienta de automatización de construcción flexible y ampliamente utilizada en el ecosistema Kotlin y Java. Nos permitirá compilar, probar y empaquetar nuestras aplicaciones y bibliotecas de forma reproducible.

Te proporcionamos instrucciones específicas para Windows, Linux y macOS:

Inicializar Proyecto Kotlin

scripts\windows\Initialize-KotlinApplication.ps1

# Enable advanced parameter binding and metadata support
[CmdletBinding()]
param (
    # Name of the project directory to create and initialize
    [Parameter(Mandatory)]
    [string]
    $ProjectName
)

# Build the full path to the new project directory
$projectPath = Join-Path -Path (Get-Location) -ChildPath $ProjectName

# Create the project directory if it doesn't exist
if (-not (Test-Path -Path $projectPath)) {
    New-Item -Path $projectPath -ItemType Directory | Out-Null
} else {
    Write-Warning "Directory '$ProjectName' already exists. Reusing it."
}

# Change into the project directory
Push-Location -Path $projectPath
try {
    # Run Gradle to initialize a basic Kotlin application project
    & gradle init --use-defaults --type kotlin-application
} finally {
    # Return to the original directory after initialization
    Pop-Location
}

# Enable advanced parameter binding and metadata support
[CmdletBinding()]
param (
    # Name of the project directory to create and initialize
    [Parameter(Mandatory)]
    [string]
    $ProjectName
)

# Build the full path to the new project directory
$projectPath = Join-Path -Path (Get-Location) -ChildPath $ProjectName

# Create the project directory if it doesn't exist
if (-not (Test-Path -Path $projectPath)) {
    New-Item -Path $projectPath -ItemType Directory | Out-Null
} else {
    Write-Warning "Directory '$ProjectName' already exists. Reusing it."
}

# Change into the project directory
Push-Location -Path $projectPath
try {
    # Run Gradle to initialize a basic Kotlin application project
    & gradle init --use-defaults --type kotlin-application
} finally {
    # Return to the original directory after initialization
    Pop-Location
}

Guarda este script como Initialize-KotlinApplication.ps1 Initialize-KotlinApplication.ps1 y ejecútalo en la terminal:

Ejecutar Script

.\scripts\windows\Initialize-KotlinApplication.ps1 -ProjectName "intro-kt"

.\scripts\windows\Initialize-KotlinApplication.ps1 -ProjectName "intro-kt"

Inicializar Proyecto Kotlin

scripts/macos/initialize_kotlin_application.sh

#!/usr/bin/env bash
set -euo pipefail  # Exit on error, unset vars, or failed pipe

# Require exactly one argument (project name)
if [[ $# -ne 1 ]]; then
    echo "Usage: $0 <ProjectName>" >&2
    exit 1
fi

PROJECT_NAME=$1
PROJECT_PATH="${PWD}/${PROJECT_NAME}"

# Create project directory if it doesn't exist
if [[ ! -d $PROJECT_PATH ]]; then
    mkdir -p "$PROJECT_PATH"
else
    echo "Warning: Directory '$PROJECT_NAME' already exists. Reusing it." >&2
fi

# Change into project directory and initialize Kotlin app with Gradle
# This creates a subshell to isolate the directory change
(
    cd "$PROJECT_PATH"
    gradle init --use-defaults --type kotlin-application
)

#!/usr/bin/env bash
set -euo pipefail  # Exit on error, unset vars, or failed pipe

# Require exactly one argument (project name)
if [[ $# -ne 1 ]]; then
    echo "Usage: $0 <ProjectName>" >&2
    exit 1
fi

PROJECT_NAME=$1
PROJECT_PATH="${PWD}/${PROJECT_NAME}"

# Create project directory if it doesn't exist
if [[ ! -d $PROJECT_PATH ]]; then
    mkdir -p "$PROJECT_PATH"
else
    echo "Warning: Directory '$PROJECT_NAME' already exists. Reusing it." >&2
fi

# Change into project directory and initialize Kotlin app with Gradle
# This creates a subshell to isolate the directory change
(
    cd "$PROJECT_PATH"
    gradle init --use-defaults --type kotlin-application
)

Guarda este script como initialize_kotlin_application.sh initialize_kotlin_application.sh y ejecútalo en la terminal:

Ejecutar Script

chmod +x ./scripts/macos/initialize_kotlin_application.sh
./scripts/macos/initialize_kotlin_application.sh "intro-kt"

chmod +x ./scripts/macos/initialize_kotlin_application.sh
./scripts/macos/initialize_kotlin_application.sh "intro-kt"

Inicializar Proyecto Kotlin

scripts/linux/initialize_kotlin_application.sh

#!/usr/bin/env bash
set -euo pipefail  # Exit on error, unset vars, or failed pipe

# Require exactly one argument (project name)
if [[ $# -ne 1 ]]; then
    echo "Usage: $0 <ProjectName>" >&2
    exit 1
fi

PROJECT_NAME=$1
PROJECT_PATH="${PWD}/${PROJECT_NAME}"

# Create project directory if it doesn't exist
if [[ ! -d $PROJECT_PATH ]]; then
    mkdir -p "$PROJECT_PATH"
else
    echo "Warning: Directory '$PROJECT_NAME' already exists. Reusing it." >&2
fi

# Change into project directory and initialize Kotlin app with Gradle
# This creates a subshell to isolate the directory change
(
    cd "$PROJECT_PATH"
    gradle init --use-defaults --type kotlin-application
)

#!/usr/bin/env bash
set -euo pipefail  # Exit on error, unset vars, or failed pipe

# Require exactly one argument (project name)
if [[ $# -ne 1 ]]; then
    echo "Usage: $0 <ProjectName>" >&2
    exit 1
fi

PROJECT_NAME=$1
PROJECT_PATH="${PWD}/${PROJECT_NAME}"

# Create project directory if it doesn't exist
if [[ ! -d $PROJECT_PATH ]]; then
    mkdir -p "$PROJECT_PATH"
else
    echo "Warning: Directory '$PROJECT_NAME' already exists. Reusing it." >&2
fi

# Change into project directory and initialize Kotlin app with Gradle
# This creates a subshell to isolate the directory change
(
    cd "$PROJECT_PATH"
    gradle init --use-defaults --type kotlin-application
)

Guarda este script como initialize_kotlin_application.sh initialize_kotlin_application.sh y ejecútalo en la terminal:

Ejecutar Script

chmod +x ./scripts/linux/initialize_kotlin_application.sh
./scripts/linux/initialize_kotlin_application.sh "intro-kt"

chmod +x ./scripts/linux/initialize_kotlin_application.sh
./scripts/linux/initialize_kotlin_application.sh "intro-kt"

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 app/src/main/kotlin .
Las pruebas se ubican en app/src/test/kotlin app/src/test/kotlin .

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

Abrir proyecto en IntelliJ IDEA

idea intro-kt

idea intro-kt

¿Qué acabamos de hacer?

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

Ejercicio: Un “Hello, World” con sentido

Ya creaste tu primer proyecto en Kotlin. Ahora es momento de darle voz propia.

Tu tarea es 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" "Hello, World" , sino de una frase que te represente. Algunas ideas:

Una línea de tu videojuego favorito
Una cita que te inspira
Un meme que te haga reír
Una frase que hayas escrito tú mismx

Ejecutar el programa

./gradlew :app:run

./gradlew :app:run

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

Recuerda

No necesitas crear clases nuevas ni preocuparte por la estructura ideal. Simplemente disfruta de escribir tu primer programa en Kotlin.

Solución

app/src/main/kotlin/org/example/App.kt

package org.example

class App {
    val greeting: String
        get() = "Ladies and Gentlemen, I give you Rose Red's killer..."
}

fun main() {
    println(App().greeting)
}

package org.example

class App {
    val greeting: String
        get() = "Ladies and Gentlemen, I give you Rose Red's killer..."
}

fun main() {
    println(App().greeting)
}

Conclusiones

En esta lección asentaste una base práctica de Kotlin: lo conociste como lenguaje pragmático, exploraste su sintaxis clara, la diferencia entre expresiones y declaraciones, y viste cómo la interpolación de cadenas mejora la legibilidad. Además, dejaste listo un proyecto con Gradle para ejecutar y evolucionar tus ejercicios.

Con esto ya puedes leer y escribir pequeños programas idiomáticos y tienes el entorno de trabajo funcionando para continuar con temas más profundos.

Puntos clave

Kotlin prioriza claridad y seguridad sin sacrificar productividad.
Expresiones producen valor; declaraciones ejecutan acciones.
La interpolación ( $ $ / ${...} ${...} ) evita concatenaciones verbosas y se traduce eficientemente.
Con Gradle puedes crear y ejecutar un proyecto base reproducible.

¿Qué nos llevamos?

La “caja de herramientas” inicial para seguir construyendo: un entorno que compila, un primer contacto con la filosofía del lenguaje y hábitos que nos acompañarán todo el curso: preferir la intencionalidad sobre la astucia, elegir construcciones expresivas y cuidar la legibilidad de las APIs.

¿Con ganas de más?

Referencias recomendadas

“Kotlin: what and why” (pp. 3–16) en Kotlin in Action por Svetlana Isakova y Dmitry Jemerov
Este capítulo introductorio presenta a Kotlin como un lenguaje moderno, conciso, seguro y pragmático que se integra perfectamente con Java. Explica sus principales características —como la inferencia de tipos, el soporte para programación funcional y orientada a objetos, y la interoperabilidad total con bibliotecas Java— y muestra cómo Kotlin se adapta a distintos contextos: desde el desarrollo de aplicaciones Android hasta servicios del lado del servidor. También se discuten su filosofía (pragmatismo, seguridad, concisión e interoperabilidad), las herramientas disponibles (REPL, plug-ins para IntelliJ y Eclipse, playground online), y mecanismos como el convertidor Java→Kotlin para facilitar su adopción. El libro está principalmente orientado a estudiantes con conocimientos básicos de Java que buscan transicionar a un lenguaje más moderno y expresivo.

Kotlin: Un lenguaje pragmático y moderno

Abstract

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

Objetivos de aprendizaje

¿Qué es Kotlin?

A Taste of Kotlin

¿Qué acabamos de hacer?

Filosofía de Kotlin

Beneficios y limitaciones de Kotlin en el desarrollo de bibliotecas de software

¿Qué distingue una expresión de una declaración?

Expresión

Declaración

En resumen

Interpolación de cadenas

Ejemplo

Sin prefijos especiales

¿Qué es un StringBuilder StringBuilder ?

Crear tu primer proyecto Kotlin con Gradle

¿Qué acabamos de hacer?

Ejercicio: Un “Hello, World” con sentido

Recuerda

Solución

Conclusiones

Puntos clave

¿Qué nos llevamos?

¿Con ganas de más?

Referencias recomendadas

¿Qué es un `StringBuilder StringBuilder` ?