Menü
Developer

Programmiersprache: Kotlin 1.3 stabilisiert die Koroutinen

Außerdem erweitert Kotlin den Umgang mit Multiplattformprojekten und führt sogenannte Contracts ein.

Von
vorlesen Drucken Kommentare lesen 59 Beiträge
Programmiersprache: Kotlin 1.3 stabilisiert die Koroutinen

JetBrains hat nach sieben Unterversionen des Vorgängers 1.2.x nun Kotlin 1.3 veröffentlicht. Die wesentlichen Neuerungen betreffen vor allem die in Kotlin 1.1 eingeführten Koroutinen, die nun als stabil gelten, und die in Version 1.2 eingeführten Multiplattformprojekte. Außerdem gibt es einige sprachliche Ergänzungen und eine erste Beta von Ktor 1.0.

Koroutinen helfen beim Schreiben von nebenläufigen Programmen. Das auch in anderen Sprachen bekannte Konzept hat Kotlin in Version 1.1 eingeführt. Nachdem sie bisher als experimentell galten, sind sie in Kotlin 1.3 als stabil gekennzeichnet. Passend dazu hat die zugehörige Library kotlinx.coroutines nun die Versionsnummer 1.0.

Koroutinen ermöglichen es, nicht blockierenden asynchronen Code zu schreiben. Vereinfacht ausgedrückt können die Routinen ihren Ablauf unterbrechen, wenn sie beispielsweise auf die Übertragung einer Datei über das Netzwerk warten, ohne dabei den aktiven Thread zu blockieren.

Die Unterstützung beim Erstellen von Cross-Platform-Projekten kam in Version 1.2 zur Programmiersprache. Sie gilt zwar in Version 1.3 nach wie vor als experimentell, hat aber einige Ergänzungen erhalten. So hat das aktuelle Release Bibliotheken für typische Aufgabenfelder an Bord, darunter einen HTTP-Client und eine Serialisierungs-Library. Auch die kotlinx.coroutines-Bibliothek für Koroutinen ist auf Multiplattformprojekte ausgelegt.

Multiplattformprojekte haben eine große Bedeutung für die Programmiersprache, die sich damit von den Wurzeln als reine JVM-Sprache (Java Virtual Machine) hin zu einem breiten Einsatz entwickelt. Entwickler können Code sowohl nach JavaScript als auch als native Binaries kompilieren. Letzteres hilft unter anderem beim Erstellen mobiler Cross-Platform-Projekte, die sowohl auf Android in der JVM als auch auf iOS mit Kotlin/Native laufen.

Kotlin setzt auf eine Kombination aus plattformübergreifendem und für die jeweiligen Zielplattformen spezifischem Code. In ersterem lassen sich über internal expect fun eine Art Wrapper für Funktionen festlegen, die die plattformspezifischen Implementierungen als internal actual fun definieren, um beispielsweise das Ansprechen von GUI-Elementen passend zur jeweiligen Zielplattform umzusetzen.

Kotlin 1.3 führt das Konzept sogenannter Contracts ein, mit denen Funktionen dem Compiler mitteilen können, wie sie sich verhalten. Folgendes Beispiel aus der Kotlin-Dokumentation legt mit contract fest, dass beim erfolgreichen Ausführen der Funktion require die Boolean-Variable condition den Wert true hat. Somit kann der Compiler in der darunter gezeigten foo-Funktion einen Smartcast auf s vornehmen, da durch den Contract festgelegt ist, dass die Bedingung beim erfolgreichen Durchlauf erfüllt ist und ansonsten eine Exception auftreten würde:

fun require(condition: Boolean) {
// This is a syntax form, which tells compiler:
// if this function returns successfully, then passed 'condition' is true
contract { returns() implies condition }
if (!condition) throw IllegalArgumentException(...)
}

fun foo(s: String?) {
require(s is String)
// s is smartcasted to 'String' here, because otherwise
// 'require' would have throw an exception
}

Contracts gelten zwar derzeit allgemein noch als experimentell, haben aber bereits ihren Weg in die Standardbibliothek gefunden und sind dort insofern als stabil gekennzeichnet, als Entwickler sie dafür nicht explizit aktivieren müssen.

Zu den weiteren nennenswerten sprachliche Ergänzungen gehören Inline-Klassen, die als experimentell gelten. Es handelt sich dabei um eingeschränkte Versionen herkömmlicher Klassen, die mit dem Schlüsselwort inline gekennzeichnet sind und genau eine Property aufweisen müssen. Der Compiler nutzt diese Beschränkung für Optimierungen, indem er beispielsweise an passenden Stellen auf den Konstruktor-Aufruf verzichtet und gleich die Property setzen kann.

Neu sind zudem die vier Variablentypen kotlin.UByte, kotlin.UShort, kotlin.UInt, kotlin.ULong für nicht vorzeichenbehaftete (unsigned) Werte mit 8, 16, 32 beziehungsweise 64 Bit. Sie sollen vor allem Low-Level-Funktionen wie Byte-Manipulation ermöglichen. Auch sie gelten derzeit noch als experimentell.

Dass Kotlin 1.3 Anbindungen für die neuen Funktionen an IntelliJ sowohl in der Community Edition als auch der Ultimate-Variante mitbringt, ist nicht verwunderlich, weil die Tools ebenso wie Kotlin von JetBrains stammen. Auch das auf IntelliJ IDEA basierende Android Studio bekommt die volle Tool-Unterstützung. Damit bieten die Entwicklungsumgebungen unter anderem Autovervollständigung und Refactoring für alle Neuerungen in Kotlin 1.3, für das Erstellen von Multiplattformprojekten und auch für Kotlin/Native. Letzteres befindet sich seit der KotlinConf Anfang Oktober offiziell in der Betaphase.

Das Ktor-Framework zum Erstellen asynchroner, verbundener Anwendungen auf Client- und Server-Seite wie Webanwendungen oder HTTP-Services setzt für den nicht blockierenden Ablauf auf Koroutinen. Ktor 1.0 hat nun Betastatus erreicht. Derzeit lassen sich allerdings lediglich JVM-Anwendungen erstellen. JavaScript-Clients und Server beziehungsweise Clients in Kotlin/Native sind in Planung.

Weitere Details zu Kotlin 1.3 lassen sich dem Kotlin-Blog entnehmen. Der aktuelle Kommandozeilen-Compiler ist im GitHub-Repository verfügbar. Bei den Entwicklungsumgebungen hat IntelliJ IDEA 2018.3, das vermutlich innerhalb der nächsten Woche erscheint, Kotlin 1.3 bereits an Bord. In Eclipse lässt sich das aktuelle Release über den Marketplace installieren, und in Android Studio ist es über den Plug-in-Manager verfügbar. Eine Anleitung zum Installieren der aktuellen Kotlin-Version über Maven/Gradle ist in der Kotlin-Dokumentation zu finden. (rme)