¡Kotlin 1.1 Beta ya llegó!

¡Estamos de enhorabuena! Hoy, Kotlin 1.1 ha llegado a la beta, y eso significa:

• Llegó la hora de probarlo
• Todavía hay tiempo para que nos proporcionéis feedback (¡y nos vendría genial!)
• Ya falta muy poco para la versión final

Hemos observado mucho interés en Kotlin en el último año, y nos gustaría agradecer a todos nuestros usuarios, contribuyentes y seguidores. ¡Y en especial a los que han adoptado la nuevas características de las EAP por su bravura y por su feedback!

Un vistazo a lo que viene en Kotlin 1.1

Las novedades más suculentas de Kotlin 1.1 son:

• Soporte completo de JavaScript
• Corrutinas en la JVM, Android y JavaScript

Os proporcionaremos más detalles sobre dichos puntos más abajo. Pero éstas no son las únicas noticias emocionantes de la 1.1. Hay muchas más mejoras y características en el lenguaje en esta versión (y vamos a dar más detalles en la página de What’s new.

• Alias de tipo (type aliases)<code class="highlighter-rouge">typealias Action<T> = (T) -> Unit
• Referencias ligadas a llamables (bound callable references)<code class="highlighter-rouge">expr::foo
• Inferencia de tipos para los getters: <code class="highlighter-rouge">val myString get() = "hi"
• Plugins de compilación para:
• Hacer las clases <code class="highlighter-rouge">open por defecto
• Generar constructores sin argumentos por defecto
• Lambdas de extensión en conversiones SAM (Single Abstract Method)
• Herencia de clases <code class="highlighter-rouge">data
• Subclases de clases <code class="highlighter-rouge">sealed en el mismo archivo
• Destructuración de lambdas: <code class="highlighter-rouge">map.forEach { (k, v) -> ...}
• Barra baja para parámetros sin usar
• Control de ámbito para DSLs de construcción: <code class="highlighter-rouge">@DslMarker
• Convención de operador <code class="highlighter-rouge">provideDelegate
• Propiedades locales delegadas
• Métodos del JDK 8 en las colecciones de Kotlin:<code class="highlighter-rouge">list.parallelStream()
• Propiedades inline
• <code class="highlighter-rouge">enumValues()/<code class="highlighter-rouge">enumValueOf() para acceso genérico a enums
• Barra baja en literales numéricos<code class="highlighter-rouge">1_000_000

Deprecado

Hemos deprecado el desafortunado nombre <code class="highlighter-rouge">mod que usábamos para el operador <code class="highlighter-rouge">%, y lo hemos reemplazado con <code class="highlighter-rouge">rem, que es correcto semánticamente y está alineado con librerías existentes como <code class="highlighter-rouge">java.math.BigInteger.

Las advertencias de deprecado y las herramientas os ayudarán durante el proceso de migración.

JavaScript

Es sencillo: ahora todas las características de Kotlin compilan a JavaScript. Esto no significa que hayamos hecho un port del JDK entero al navegador: el lenguaje y su librería estándar no están acoplados al JDK, pero podéis usar las cadenas de Kotlin, las colecciones, secuencias, arrays y otras APIs del núcleo tanto en JS como en la JVM y Android.

Expondremos muchas de las librerías JS populares a través de cabeceras tipadas (convertidas desde DefinitelyTyped). Soportamos todos los sistemas de módulos populares de JavaScript así como webpack y otras herramientas importantes.

Deducaremos mucho esfuerzo en la 1.2 de Kotlin y posteriores a hacer las herramientas de JavaScript útiles y placenteras. Nuestro objetivo es hacer que Kotlin se pueda usar completamente en un entorno full-stack.

Corrutinas

En serio, es difícil remarcar lo suficiente las corrutinas. El futuro ha llegado, y estamos adheridos a él: Necesitamos APIs asíncronas no bloqueantes que soporten la carga de trabajo que tienen que procesar. Nos hemos hecho camino a través del infierno de llamadas anidadas (callback hell) y lo hemos consquistado. Pero nos merecemos algo mejor. Lo único que queremos es escribir cñodigo que se siga como una ***secuencia ***lógica natural y dejar que sea el lenguaje el que se encargue de averiguar cómo asincronizarlo por nosotros. Y de eso tratan las corrutinas: async/await, generate/yield, IO no bloqueante, Rx y mucho más. Todo bajo el mismo paradigma de funciones suspendibles (suspending functions). Como una función (o lambda) que representa un cómputo que se puede suspender (sin bloquear ningún hilo) y retomar a posteriori.

future { val original = asyncLoadImage("...original...") // creates a Future val overlay = asyncLoadImage("...overlay...") // creates a Future ... // suspend while awaiting the loading of the images // then run applyOverlay(...) when they are both loaded return applyOverlay(original.await(), overlay.await()) }

El principal beneficio de las corrutinas es su flexibilidad:

• La parte del lenguaje es mínima
• Todo se puede escribir como una librería
• Las librerías tienen control total de todos los aspectos de la suspensión y retomado de los cómputos: hilos, excepciones y otros aspectos del cómputo son completamente personalizables.

Hemos escrito un conjunto de librerías para casos de uso comunes: kotlinx.coroutines

Leed más sobre corrutinas aquí.

Nota importante. Con todos los beneficios que esto trae, las corrutinas de Kotlin son un diseño bastante nuevo que necesita un testeo muy intensivo antes de estar seguros de que está 100% correcto y completo. Es por eso que en esta versión lo vamos a habilitar con un flag experimental. No esperamos que cambien las reglas del lenguaje, pero es posible que haya que hacer algún ajuste en relación a las APIs en Kotlin 1.2.

• Línea de comandos: <code class="highlighter-rouge">-Xcoroutines=enabled
• Gradle: <code class="highlighter-rouge">kotlin.coroutines=enable en <code class="highlighter-rouge">gradle.properties o <code class="highlighter-rouge">local.properties
• Maven: <code class="highlighter-rouge"><configuration> <args> <arg>-Xcoroutines=enable</arg> </args> </configuration>
• IDE: Usad un quick-fix (Alt+Enter) o modificad las opciones en (***Project Structure -> Modules -> Your Module -> Compiler -> Coroutines (experimental)***)

Librería estándar, herramientas y frameworks

La librería estándar de Kotlin se ha extendido con numerosas utilidades y extensiones incluyendo algunas específicas del JDK 7 y 8.

Nuestra colaboración con Gradle ha llevado a gradle-script-kotlin lo que implica que ahora se puede escribir scripts de gradle con seguridad tipada usando Kotlin como scripting.

Ahora soportamos el JSR 223, que se utiliza el framework Spring junto a DSLs con tipado seguro y otras cosas.

Cómo probarlo:

Como en otras versiones preeliminares, no damos ningún tipo de garantía para Kotlin 1.1-Beta. Lo que es más, cuando lleguemos a la RC final, todos los binarios producidos por las versiones
preeliminares serán rechazados por el compilador: lo que implica que habrá que recompilar todo lo que se haya compilado para la 1.1-M0x y Beta (todo el código de la 1.0.x es perfectamente válido sin recompilación).

En Maven/Gradle: Añadid http://dl.bintray.com/kotlin/kotlin-eap-1.1 como repositorio para el build script y en vuestros proyectos usad <code class="highlighter-rouge">1.1.0-beta-17 como versión para el compilador y la librería estándar.

En intelliJ IDEA: Id a <code class="highlighter-rouge">Tools → <code class="highlighter-rouge">Kotlin → <code class="highlighter-rouge">Configure Kotlin Plugin Updates, y seleccionad <code class="highlighter-rouge">“Early Access Preview 1.1” en el desplegable de <code class="highlighter-rouge">Update channel, y pulsad Check para actualizaciones.

El compilador cli se puede descargar de la página de releases de Github

En try.kotlinlang.org. Usad el desplegable de la esquina inferior derecha para cambiar la versión del compilador a la 1.1-Beta.

¡A Kotlinear!