Kotlin, primeros pasos

Kotlin es un lenguaje de programación fuertemente tipado que se ejecuta principalmente sobre la JVM (Java Virtual Machine), y digo «principalmente» porque también es posible compilarlo a JavaScript o incluso a código nativo, pero por ahora nos vamos a centrar en la JVM y sus capacidades de interoperabilidad con librerías o cualquier código escrito en Java.

Es un lenguaje creado por JetBrains (sí, sí, los creadores de los conocidos IDE de desarrollo IntelliJ, PyCharm, WebStorm, AppCode…​) hace algún tiempo, pero parece que ha saltado de nuevo a la palestra con el anuncio por parte de Google de considerarlo lenguaje de primer nivel para el desarrollo de Android y, por tanto, darle soporte directo.

Esto es muy buena noticia y va a ayudar a garantizar la vida y evolución del lenguaje, por lo que puede ser un buen momento para echarle a un vistazo al lenguaje, ya que este de verdad tiene cosas muy interesantes, especialmente para los que venimos de Java o ya usamos la JVM.

A nivel de lenguaje nos vamos a encontrar con todo lo que tiene Java y muchas características más que van a facilitarnos mucho la vida a la hora de hacer nuestras aplicaciones. No voy a contarlas todas, ya que la idea de este tutorial no es enseñar Kotlin, y para ello os recomiendo la propia guía de referencia de Kotlin, muy completa, clara y con ejemplos. Pero podemos destacar:

Sólo con esta lista parcial espero haber picado tu curiosidad para, por lo menos, echar un ojo a la guía de referencia de Kotlin.

Además, si queréis hacer pruebas o ver ejemplos, lo podéis hacer directamente desde el navegador en https://try.kotlinlang.org.

El tutorial está escrito usando el siguiente entorno:

Lo mejor de todo es que Kotlin no necesita instalación.

Por supuesto Kotlin tiene un compilador de línea de comandos, pero no va a ser necesaria su instalación ya que normalmente vamos a trabajar con Maven o con Gradle, en concreto en este tutorial usaremos Gradle. En cualquier caso, si tenéis curiosidad podéis encontrar más información en https://kotlinlang.org/docs/tutorials/command-line.html

Así, para preparar la estructura de nuestro primer proyecto, ejecutaremos:

$ mkdir kotlin-tutorial ; cd kotlin-tutorial
$ gradle init
$ mkdir -p src/main/kotlin
$ mkdir -p src/test/kotlin
                

Para que Gradle sea capaz de compilar Kotlin sobreescribimos todo el contenido del fichero build.gradle (veréis que el contenido está totalmente comentado y es sólo un ejemplo que podéis borrar con tranquilidad) con:

plugins {
    id 'org.jetbrains.kotlin.jvm' version '1.1.3'
}

tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all {
    sourceCompatibility = JavaVersion.VERSION_1_8
    targetCompatibility = JavaVersion.VERSION_1_8

    kotlinOptions {
        jvmTarget = '1.8'
    }
}

repositories {
    mavenCentral()
}

dependencies {
    compile 'org.jetbrains.kotlin:kotlin-stdlib-jre8'
}
                

Aquí destacamos:

Ahora vamos a crear nuestro primer código Kotlin y, como no podía ser de otra forma, empezaremos por nuestro querido «Hola, mundo». Para ello creamos el fichero src/main/kotlin/App.kt con el siguiente contenido:

fun main(args: Array<String>) {
    println("Hello, world!")
}
                

Se ve cómo es simplemente el punto de entrada de la aplicación, donde nos entra un array con los argumentos de la línea de comandos y simplemente escribimos un mensaje por consola. Cabe destacar cómo hemos escrito la función sin necesidad de que esta esté dentro de una clase, y no como en Java, donde sí tenemos esa restricción.

Para ver que todo funciona correctamente, ejecutamos en la línea de comandos:

$ gradle build
                

Donde deberíamos ver algo similar a:

Sólo con el punto anterior ya podríamos empezar a hacer aplicaciones con Kotlin, pero ya sabéis que soy muy fan de los tests y que no entiendo el desarrollo sin ellos, así que vamos a modificar un poco el fichero build.gradle para añadir soporte para JUnit 5.

Añadir soporte para JUnit 4 hubiera sido cuestión de añadir una dependencia, mientras que el soporte para JUnit 5 nos va a costar un poquito más (no es culpa de Kotlin, sino del propio soporte de JUnit 5), pero quiero hacer este ejemplo para que veáis cómo podemos usar Kotlin con las últimas versiones de nuestras librerías Java sin ningún problema.

Primero vamos a añadir al principio del fichero las siguientes líneas para dar de alta el plugin de Gradle de JUnit 5 (como vemos, todavía no soporta el nuevo DSL de Gradle para la definición de plugins):

buildscript {
    ext {
        junitPlatformVersion = '1.0.0-M4'
        junitJupiterVersion = '5.0.0-M4'
        junitVintageVersion = '4.12.0-M4'
    }

    repositories {
        mavenCentral()
    }
    dependencies {
        classpath "org.junit.platform:junit-platform-gradle-plugin:${junitPlatformVersion}"
    }
}
                

Ahora aplicamos el plugin, para ello justo después de la sección de plugins { …​ } que tenemos de antes, añadimos la línea:

apply plugin: 'org.junit.platform.gradle.plugin'
                

Y por último, dentro de la sección de dependencias, añadimos las necesarias para poder escribir los tests:

dependencies {
    ...
    testCompile 'org.jetbrains.kotlin:kotlin-test'
    testCompile 'org.jetbrains.kotlin:kotlin-test-junit'

    testCompile "org.junit.jupiter:junit-jupiter-api:${junitJupiterVersion}"
    testRuntime "org.junit.jupiter:junit-jupiter-engine:${junitJupiterVersion}"
    testRuntime "org.junit.vintage:junit-vintage-engine:${junitVintageVersion}"
}
                

Aquí podemos destacar:

Podemos mencionar también cómo en el caso de las dependencias de las líneas 3 y 4 no hemos puesto versión, esto es posible gracias a que el propio plugin de Kotlin las va a proporcionar en función de la versión de Kotlin que estamos usando.

Os pongo el fichero completo para que sea más fácil verlo:

buildscript {
    ext {
        junitPlatformVersion = '1.0.0-M4'
        junitJupiterVersion = '5.0.0-M4'
        junitVintageVersion = '4.12.0-M4'
    }

    repositories {
        mavenCentral()
    }
    dependencies {
        classpath "org.junit.platform:junit-platform-gradle-plugin:${junitPlatformVersion}"
    }
}

plugins {
    id 'org.jetbrains.kotlin.jvm' version '1.1.3'
}

apply plugin: 'org.junit.platform.gradle.plugin'

tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all {
    sourceCompatibility = JavaVersion.VERSION_1_8
    targetCompatibility = JavaVersion.VERSION_1_8

    kotlinOptions {
        jvmTarget = '1.8'
    }
}

repositories {
    mavenCentral()
}

dependencies {
    compile 'org.jetbrains.kotlin:kotlin-stdlib-jre8'

    testCompile 'org.jetbrains.kotlin:kotlin-test'
    testCompile 'org.jetbrains.kotlin:kotlin-test-junit'

    testCompile "org.junit.jupiter:junit-jupiter-api:${junitJupiterVersion}"
    testRuntime "org.junit.jupiter:junit-jupiter-engine:${junitJupiterVersion}"
    testRuntime "org.junit.vintage:junit-vintage-engine:${junitVintageVersion}"
}
                

Ya podemos escribir tests en Kotlin usando JUnit 5. Podemos hacer la prueba creando el fichero src/test/kotlin/AppTest.kt con el contenido:

import org.junit.jupiter.api.Test
import kotlin.test.assertEquals

class AppTest {

    @Test
    fun `addition is correct`() {
        assertEquals(4, 2 + 2)
    }
}
                

Podemos destacar:

Si ahora ejecutamos (el clean no es necesario pero lo ponemos para forzar una compilación completa):

$ gradle clean build
                

deberíamos ver algo similar a:

Si ejecutamos los tests desde el IntelliJ, veremos algo como:

Donde podemos apreciar la ventaja de los nombres.

Si solemos trabajar con Java, o en general con la JVM, empezar con Kotlin es muy sencillo, ya que la barrera de entrada, por lo menos para jugar un poco, es prácticamente inexistente.

Además, ya tenemos cantidad de herramientas que lo soportan, incluyendo los tres grandes IDEs a día de hoy: Eclipse, Netbeans y, por supuesto, IntelliJ y Android Studio.

Otra buena referencia es este site donde podréis encontrar cantidad de información y recursos: Kotlin is awesome!

¿Kotlin va a sustituir a Java? Sólo el tiempo lo dirá, pero lo que está claro es que trae cantidad de cosas útiles, que está evolucionando muy rápido, y que ahora también tiene el apoyo de Google. Todo esto sumado a la facilidad para mezclarlo con nuestro código y librerías existentes lo convierte en una opción más que viable y atractiva. Más vale que Java se ande con ojo y se dé un poco de vidilla si no quiere quedarse en la cuenta.

Eso sí, ¡larga vida a la JVM!

Alejandro Pérez García (@alejandropgarci)
Ingeniero en Informática (especialidad de Ingeniería del Software) y Certified ScrumMaster

Socio fundador de Autentia Real Business Solutions S.L. – «Soporte a Desarrollo»

Socio fundador de ThE Audience Megaphone System, S.L. – TEAMS – «Todo el potencial de tus grupos de influencia a tu alcance»