Programmiersprache Kotlin 1.6.20 kompiliert parallel und inkrementell

Fünf Monate nach Kotlin 1.6 ist nun Version 1.6.20 der Programmiersprache erschienen. Das Release bringt mit Context Receivers und Definitely Non-Nullable Types zwei sprachliche Neuerungen als Vorschau auf Kotlin 1.7. Außerdem erweitert es die Toolchain um paralleles Kompilieren von Modulen für die JVM und einen inkrementellen Compiler für JavaScript. Multiplattformprojekte haben neuerdings eine hierarchische Struktur, um Code zwischen ähnlichen Plattformen zu teilen.

Mehr als ein Empfänger

Kotlin bietet für Funktionstypen optional einen zusätzlichen Empfänger (Receiver). Die Syntax A.(B) -> C definiert eine Funktion mit einem Empfänger A, einem Parameter B und dem Rückgabewert C. Bisher kennt die Sprache jedoch nur jeweils einen Empfänger.

Das Issue "Multiple Receivers on Extension Functions/Properties" lag in der jüngsten Umfrage zu den meist gewünschten Features für die Sprache auf Platz 3. Kotlin 1.6.20 bringt nun den Prototyp von Context Receivers mit, die einen eigenen Weg für mehrere Receiver umsetzen. Der zugehörige Vorschlag ist der Nachfolger des ursprünglichen Issue.

Folgendes Beispiel aus dem Kotlin-Blog zeigt eine Umsetzung, um einen Logger in eine Funktion zu injizieren:

interface LoggingContext {
    // This context provides a reference to a logger 
    val log: Logger 
}

context(LoggingContext)
fun startBusinessOperation() {
    // You can access the log property since LoggingContext 
    // is an implicit receiver
    log.info("Operation has started")
}

fun test(loggingContext: LoggingContext) {
    with(loggingContext) {
        // You need to have LoggingContext in a scope as an 
        // implicit receiver to call startBusinessOperation()
        startBusinessOperation()
    }
}

Weitere Anwendungsbeispiele wie die Arbeit mit mathematischen Abstraktionen und das Berechnen auflösungsunabhängiger Pixel in Android finden sich in dem Vorschlag zu Context Receivers.

Die Umsetzung ist in Kotlin 1.6.20 als Prototyp gekennzeichnet. Um sie zu nutzen, müssen Entwicklerinnen und Entwickler die Compiler-Option -Xcontext-receivers setzen. Die damit erstellten Binaries lassen sich nicht in Produktionscode verwenden.

Definitiv keine Null

Eine weitere sprachliche Ergänzung ist einen Schritt weiter in der Entwicklung und nicht mehr als Prototyp, sondern als Beta gekennzeichnet. Die "Definitely Non-Nullable Types" sollen das Zusammenspiel mit Java beim Erweitern von generischen Klassen und Interfaces verbessern. Die Syntax T & Any legt fest, dass der generische Typparameter auf keinen Fall Null sein kann.

Die Syntax entspricht der für die Kombination zweier Typen als Intersection Types. Diese lassen sich beiden zusammengeführten Typen zuordnen. Der Wert muss also sowohl der Definition des Typparameters T als auch Any entsprechen. Letzteres ist die Mutter aller Non-Nullable Types in Kotlin – im Gegensatz zu Object in Java gilt das nicht nur für Klassen, sondern auch für die allgemeinen Typen, die in Java als primitive Datentypen umgesetzt sind, wie int, boolean und char. Die Pendants in Kotlin haben Any als Elternklasse und sind entsprechend großgeschrieben; Int, Boolean und Char.

Um die Umsetzung von Definitely Non-Nullable Types zu nutzen ist zwar keine spezielle Compiler-Option erforderlich, aber die Sprachversion muss in der Konfiguration auf 1.7 stehen (languageVersion = "1.7").

Paralleles und inkrementelles Kompilieren

Für den Compiler bringt das aktuelle Release ebenfalls zwei Neuerungen mit. Die erste betrifft die Umsetzung für den Zwischencode (IR) zur Java Virtual Machine (JVM) mit einem experimentellen Modus, um alle Dateien innerhalb eines Moduls parallel zu kompilieren. Die Compiler-Option -Xbackend-threads legt fest, wie viele Threads der Compiler nutzen soll.

Bei der Umsetzung gilt es das Zusammenspiel mit der potenziell parallelen Build-Ausführung durch Gradle zu berücksichtigen. Das parallele Kompilieren lohnt sich vor allem für umfangreiche Module. Bei Projekten, die aus zahlreichen kleineren Modulen bestehen, die Gradle bereits parallelisiert, kann die zusätzliche Parallelisierung den Build-Prozess sogar verlangsamen.

Die zweite Neuerung betrifft den Compiler für Kotlin/JS zum Erstellen von JavaScript, der neuerdings einen inkrementellen Modus bietet. Der Compiler cached dabei den erstellten Code ebenfalls auf Modulebene. Er bezieht sich jedoch nur auf Development Binaries, um beim Entwickeln schneller zu kompilieren, nicht auf das Erstellen von Produktionscode. Zum Aktivieren des inkrementellen Kompilierens dient der Eintrag kotlin.incremental.js.ir=true in gradle.properties.

Geteilter Sourcecode

In Kotlin 1.6.20 ist für Multiplattformprojekte die seit Kotlin 1.4 optional verfügbare hierarchische Struktur standardmäßig aktiviert. Damit bietet die Sprache eine zusätzliche Ebene zwischen plattformübergreifenden und plattformspezifischen Codefragmenten. Letztere gelten spezifisch für eine Architektur und erstere für alle Plattformen. Die hierarchische Struktur erlaubt zusätzlich Sourcecode für mehrere ähnliche native Zielplattformen. So lässt sich beispielsweise gemeinsamer Code für iOS auf unterschiedlichen Prozessorarchitekturen in der Zwischenebene vereinheitlichen.

Für Kotlin/Native zum Ausführen von Code ohne die JVM bringt das Release zudem einige Performanceverbesserungen mit. Der Blogbeitrag spricht von Benchmarks auf interne Projekte mit einer im Schnitt um 15 Prozent verbesserten Ausführungsgeschwindigkeit, einer um ein Fünftel verringerten Größe der Binaries und einer um 26 Prozent verbesserten Kompilierzeit.

Eine Sprache und eine Insel

JetBrains hat die Programmiersprache Kotlin vor gut zehn Jahren ins Rennen geschickt. In den Anfängen war Kotlin auf die Java Virtual Machine (JVM) begrenzt. Besonders auf Android hat sie einen Siegeszug angetreten, seit Google sie 2017 offiziell als Alternative zu Java auch in Android Studio aufgenommen und zwei Jahre später zur ersten Wahl für das mobile Betriebssystem erklärt hat. Inzwischen ist die Programmiersprache aber auf diverse Plattformen ausgelegt: Kotlin/Native ermöglicht die Ausführung ohne virtuelle Maschine, vor allem um Plattformen wie iOS abzudecken, die von Haus aus keine JVM an Bord haben.

Mit Kotlin/JS ist zudem eine Anbindung an JavaScript verfügbar, und seit Kotlin 1.2 lassen sich Multiplattformprojekte erstellen, die mit einer Codebasis JVM und JavaScript abdecken.

Seit der ersten Kotlin-Version sind zahlreiche Feature-Releases mit der Versionierung 1.x erschienen, denen inkrementelle Releases mit der Versionsnummer 1.x.y0 (1.5.20, 1.5.30, ...) gefolgt sind. Bugfix-Releases erscheinen nach Bedarf mit der Versionierung 1.x.yz (1.5.31, 1.5.32, ...), und in den letzten Versionen war das jeweilige 1.x.10-Release ebenfalls für Bugfixes vorgesehen. Im Oktober 2020 hat JetBrains die Roadmap angepasst und wie für Java Feature-Releases im Halbjahrestakt angekündigt. Version 1.7 ist somit im Mai zu erwarten.

Den Namen, der hierzulande gerne Trolle in Foren anzieht, verdankt die Sprache einer Insel vor St. Petersburg. Das dortige JetBrains-Team hat Kotlin anfänglich maßgeblich entwickelt. Im März hat JetBrains als Reaktion auf den Ukraine-Krieg alle Aktivitäten in Russland eingestellt und damit auch die russischen Entwicklungsabteilungen geschlossen. Laut Aussage des Unternehmens sind zahlreiche bis dahin in Moskau, St. Petersburg und Nowosibirsk Beschäftigte in andere Länder umgezogen.

Weitere Details zu Kotlin 1.6.20 lassen sich dem Kotlin-Blog entnehmen. IntelliJ IDEA sollte automatisch ein Update zur aktuellen Version vorschlagen. Dasselbe gilt für das auf IntelliJ IDEA basierende Android Studio. Der separate Compiler für die Kommandozeile findet sich auf GitHub.

Siehe auch:

• Kotlin bei heise Download

(rme)