Kotlin

Kotlin Dataframe : une abstraction pour travailler avec des données structurées

Soumis par fredericmazue le

Kotlin Dataframe est une abstraction permettant de travailler avec des données structurées, la structure étant un tableau à 2 dimensions avec des colonnes étiquetées.

Ainsi la bibliothèque Kotlin Dataframe peut traiter des sources de données aussi diverses que fichiers CVS, JSON, Excel ou Apache Arrow. L'abstraction n'est bien sûr pas dans la table elle-même, mais dans un ensemble d'opérations définies sur celle-ci. La bibliothèque Kotlin Dataframe est un langage DSL (langage spécifique au domaine) basé sur Kotlin définissant de telles opérations. 

Kotlin Dataframe a été conçus de manière hiérarchique et permet l'imbrication de colonnes et de cellules, c'est pourquoi la bibliothèque permet de traiter des fichiers JSON.

Kotlin Dataframe est générique car les colonnes peuvent stocker des objets de n'importe quel type, pas seulement des nombres ou des chaînes. Kotlin Dataframe est également poluymorphique. Ainsi, si toutes les colonnes de la trame de données sont présentées dans une autre trame de données, la première pourrait être une superclasse pour la seconde. Ainsi, on peut définir une fonction sur une interface avec un ensemble de colonnes puis l'exécuter de manière sûre sur n'importe quel dataframe qui contient cet ensemble de colonnes.

Kotlin Dataframe vient de sortir en préversion.

Kotlin Dataframe est un logiciel libre sous licence Apache 2.0, disponible sur GitHub. 

Kotlin 1.7

Soumis par fredericmazue le

JetBrains a annoncé la sortie 1.7 de Kotlin, son langage maison. Pour mémoire une des nouveautés majeures annoncées pour Kotlin 1.7 est l'évolution de l'inférence du générateur de type. Cette fonctionnalité aide le compilateur à déduire les arguments de type d'un appel en utilisant les informations de type sur les autres appels à l'intérieur de son argument lambda. Avec Kotlin 1.7 l'inférence de générateur de type est automatiquement activée si une inférence de type standard ne peut pas obtenir suffisamment d'informations sur un type sans spécifier l'option -Xenable-builder-inference du compilateur, qui a été introduite avec Kotlin 1.6. Cela signifie que vous pouvez désormais écrire vos propres générateurs qui utilisent l'inférence de générateur de type sans appliquer d'annotations ou d'options supplémentaires.

On remarquera encore l'arrivée de la version alpha du nouveau compilateur Kotlin K2. Ce nouveau compilateur vise à accélérer le développement de nouvelles fonctionnalités de langage, à unifier toutes les plates-formes prises en charge par Kotlin, à apporter des améliorations de performances et à fournir une API pour les extensions de compilateur.

Il est important de souligner qu'avec la version alpha du nouveau compilateur K2, l'éditeur JetBrains s'est principalement concentré sur l'amélioration des performances, et cela ne fonctionne que pour les projets JVM. Le compilateur K2 ne prend pour le moment pas en charge Kotlin/JS, Kotlin/Native ou d'autres projets multi plates-formes, et aucun des plugins de compilateur, y compris kapt, ne fonctionne avec lui. Cette restriction faite, JetBrains annonce des 'résultats remarquables', ce qui, selon les benchmark de l'éditeur signifie des performances plus que doublées.

On remarque enfin que les types définitivement non nullables ont été promus en stable dans Kotlin 1.7. Ces types offrent une meilleure interopérabilité lors de l'extension des classes et des interfaces Java génériques. Vous pouvez marquer un paramètre de type générique comme définitivement non nullable avec la nouvelle syntaxe T & Any. La forme syntaxique provient de la notation des types d'intersection et est maintenant limitée à un paramètre de type avec des bornes supérieures nullables sur le côté gauche de & et un non -nullable Any sur le côté droit :

fun <T> elvisLike(x: T, y: T & Any): T & Any = x ?: y
fun main() {
    // OK
    elvisLike<String>("", "").length
    // Error: 'null' cannot be a value of a non-null type
    elvisLike<String>("", null).length

    // OK
    elvisLike<String?>(null, "").length
    // Error: 'null' cannot be a value of a non-null type
    elvisLike<String?>(null, null).length
}

[video:https://www.youtube.com/watch?v=54WEfLKtCGk autoplay:0]

 

Kotlin 1.7 bêta

Soumis par fredericmazue le

JetBrains vient de publier Kotlin 1.7 bêta. La principale nouveauté mise en avant par JetBrains pour Kotlin 1.7 est l'évolution de l'inférence du générateur de type. Cette fonctionnalité aide le compilateur à déduire les arguments de type d'un appel en utilisant les informations de type sur les autres appels à l'intérieur de son argument lambda.

Avec Kotlin 1.7 l'inférence de générateur de type est automatiquement activée si une inférence de type standard ne peut pas obtenir suffisamment d'informations sur un type sans spécifier l'option -Xenable-builder-inference du compilateur, qui a été introduite avec Kotlin 1.6. Cela signifie que vous pouvez désormais écrire vos propres générateurs qui utilisent l'inférence de générateur de type sans appliquer d'annotations ou d'options supplémentaires.

A remarquer aussi, le retour des fonctions de collections min() et max(). Avec Kotlin 1.4 ces fonctions avaient été renommées minOrNull() et maxOrNull(). Kotlin 1.7.0 réintroduit les noms de fonction d'origine, mais avec un type de retour non nullable. Ces nouvelles fonctions min() et max() renvoient maintenant strictement l'élément de collection ou lèvent une exception.

fun main() {
    val numbers = listOf<Int>()
    println(numbers.maxOrNull()) // "null"
    println(numbers.max()) // "Exception in… Collection is empty."
}

A remarquer encore la possibilié d'essayer la version alpha du nouveau gestionnaire de mémoire Kotlin/Native dans Kotlin 1.7.0 bêta. Cette version apporte des améliorations de performances au nouveau gestionnaire de mémoire qui amélioreront l'expérience des développeurs.

Le nouveau gestionnaire de mémoire élimine les différences entre les plateformes JVM et Native. Il offre une expérience de développement cohérente dans les projets multi plates-formes. Par exemple, vous aurez beaucoup plus de facilité à créer de nouvelles applications mobiles multi plates-formes qui fonctionnent à la fois sur Android et iOS, assure JetBrains.

Le nouveau gestionnaire de mémoire Kotlin/Native lève les restrictions sur le partage d'objets entre les threads. Il fournit également des primitives de programmation simultanée sans fuite qui sont sûres et ne nécessitent aucune gestion ou annotation spéciale. Le nouveau gestionnaire de mémoire deviendra celui par défaut dans les futures versions.

Ktor 2.0

Soumis par fredericmazue le

Ktor est un framework Kotlin pour la construction de serveurs et de clients asynchrones dans des systèmes connectés. Il est créé par l’équipe de Kotlin chez JetBrains et, en tant que tel, il tire pleinement parti des possibilités de ce langage. Ktor vient de sortir en version 2.0, et, fort logiquement, il est compatible avec Kotlin 1.6.20, qui vient également de sortir.

Ktor 2.0 introduit de nombreuses nouvelles fonctionnalités, avec des changements de rupture. Cela nous a permis d'effectuer des travaux de maintenance et de nous débarrasser des décisions héritées, explique l'équipe de développement

Dans cette version 2.0, l'API d'extensibilité a été grandement simplifiée, ce qui facilite considérablement la création de plugins.

Par exemple ce code en 1.x :

companion object Feature : ApplicationFeature<ApplicationCallPipeline, CustomHeader.Configuration, CustomHeader> {
  override val key = AttributeKey<CustomHeader>("CustomPlugin")
  override fun install(pipeline: ApplicationCallPipeline, configure: Configuration.() -> Unit): CustomHeader {

    val configuration = Configuration().apply(configure)
    val feature = CustomHeader(configuration)
      pipeline.intercept(ApplicationCallPipeline.Call) {
         feature.intercept(this)
    }
  
    return feature
  }
}

devient en 2.0 :

val myCustomPlugin = createApplicationPlugin("CustomPlugin") {
  onCall {
  }
  onCallReceive {
  }
  onCallRespond {
  }
}

Côté serveur, Kotlin/Native est désormais pris en charge en plus de GraalVM (qui était déjà pris en charge à partir de la version 1.6), ce qui signifie que vous avez deux options en ce qui concerne les applications serveur autonomes. 

En raison des changements de rupture mentionnés plus haut, la migration vers Ktor 2.0 n'est pas immédiate. Notamment en raison de nouvelles conventions de nommage en ce qui concerne les modules et les packages.

JetBrains fournit une documentation de mappage pour aider les utilisateurs à migrer.

 

Kotlin 1.6.20

Soumis par fredericmazue le

JetBrains a publié Kotlin 1.6.20. Cette version apporte 2 nouveautés notables au langage et de nombreuses améliorations de performances.

La première nouveauté de Kotlin 1.6.20 au niveau du langage est le 'Prototype de récepteurs de contexte'. Avec Kotlin 1.6.20, vous n'êtes plus limité à un seul récepteur. Si vous avez besoin de plus, vous pouvez rendre les fonctions, les propriétés et les classes dépendantes du contexte (ou contextual ) en ajoutant des récepteurs de contexte à leur déclaration. Par exemple :

interface LoggingContext {
    val log: Logger // This context provides a reference to a 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()
    }
}

Une déclaration contextuelle exige que tous les récepteurs de contexte déclarés soient présents dans la portée d'un appelant en tant que récepteurs implicites et apporte les récepteurs de contexte déclarés dans sa portée de corps en tant que récepteurs implicites. Pour activer les récepteurs de contexte dans votre projet, utilisez l'option -Xcontext-receivers du compilateur. 

Les 'Types définitivement non nullables' sont l'autre nouvauté majeure du langage. Pour fournir une meilleure interopérabilité lors de l'extension des classes et des interfaces Java génériques, Kotlin 1.6.20 vous permet de marquer un paramètre de type générique comme définitivement non nullable avec la nouvelle syntaxe T & Any. Par exemple :

fun <T> elvisLike(x: T, y: T & Any): T & Any = x ?: y

fun main() {
    // OK
    elvisLike<String>("", "").length
    // Error: 'null' cannot be a value of a non-null type
    elvisLike<String>("", null).length
 
   // OK
    elvisLike<String?>(null, "").length
    // Error: 'null' cannot be a value of a non-null type
    elvisLike<String?>(null, null).length
}

Remarque : il faut positionner la version linguistique sur 1.7 pour activer cette fonctuonnalité

Kotlin 1.6.20, c'est aussi de nombreuses améliorations de performances. Tout d'abord, JetBrains a travaillé à améliorer le temps de compilation du nouveau backend JVM IR.  Ainsi a été ajouté le mode backend expérimental JVM IR pour compiler tous les fichiers d'un module en parallèle. La compilation parallèle peut réduire le temps total de compilation jusqu'à 15%, selon JetBrains. L'éditeur précise que cette parallélisation n'est utile que lorsque la construction du projet n'est pas suffisamment parallélisée par un outil de construction tel que Gradle. En revanche, si un projet se compose de nombreux petits modules et a déjà une construction parallélisée, l'ajout d'une autre couche de parallélisation peut nuire aux performances.

Arrive aussi un nouveau mode de compilation incrémentale. Dans ce mode, le compilateur met en cache les résultats des compilations précédentes au niveau du module. Il utilise ensuite les résultats de compilation mis en cache pour les fichiers source inchangés lors des compilations suivantes, ce qui les rend les opérations plus rapides, en particulier dans le cas de petites modifications.

Enfin, Jetbrains travaille à améliorer les performances de Kotlin/Native. Ainsi, Kotlin 1.6.20 M1 apporte des mises à jour de performances qui affectent le LLVM IR généré. Selon les benchmarks de JetBrains, les gains moyens de performances sont les suivants :

  • 15% de réduction du temps d'exécution
  • Réduction de 20 % de la taille du code des binaires de version et de débogage
  • Réduction de 26 % du temps de compilation des binaires de publication

Toujours selon JetBrains, ces améliorations permettent également de réduire de 10% le temps de compilation d'un binaire de débogage sur un grand projet.

Enfin nous remarquons la prise en charge des exécutables Android autonomes. Auparavant, les exécutables Android Native dans Kotlin/Native n'étaient pas réellement des exécutables mais des bibliothèques partagées que vous pouviez utiliser comme NativeActivity. Il existe désormais une option permettant de générer des exécutables standard pour les cibles Android natives.

Pour cela, dans la partie build.gradle(.kts) de votre projet, configurez le bloc exécutable de votre cible androidNative. Ajoutez l'option binaire suivante :

kotlin {
    androidNativeX64("android") {
        binaries {
            executable {
                binaryOptions["androidProgramType"] = "standalone"
            }
        }
    }
}

Cette fonctionnalité deviendra la valeur par défaut dans Kotlin 1.7.0.

De meilleures performances avec Kotlin 1.6.20 M1

Soumis par fredericmazue le

JetBrains a publié la première préversion de Kotlin 1.6.20. Cette version apporte entre autres de nombreuses améliorations de performances.

Tout d'abord, JetBrains a travaillé à améliorer le temps de compilation du nouveau backend JVM IR.  Ainsi a été ajouté le mode backend expérimental JVM IR pour compiler tous les fichiers d'un module en parallèle. La compilation parallèle peut réduire le temps total de compilation jusqu'à 15%, selon JetBrains. L'éditeur précise que cette parallélisation n'est utile que lorsque la construction du projet n'est pas suffisamment parallélisée par un outil de construction tel que Gradle. En revanche, si un projet se compose de nombreux petits modules et a déjà une construction parallélisée, l'ajout d'une autre couche de parallélisation peut nuire aux performances.

Arrive aussi un nouveau mode de compilation incrémentale. Dans ce mode, le compilateur met en cache les résultats des compilations précédentes au niveau du module. Il utilise ensuite les résultats de compilation mis en cache pour les fichiers source inchangés lors des compilations suivantes, ce qui les rend les opérations plus rapides, en particulier dans le cas de petites modifications.

Enfin, Jetbrains travaille à améliorer les performances de Kotlin/Native. Ainsi, Kotlin 1.6.20 M1 apporte des mises à jour de performances qui affectent le LLVM IR généré. Selon les benchmarks de JetBrains, les gains moyens de performances sont les suivants :

  • 15% de réduction du temps d'exécution
  • Réduction de 20 % de la taille du code des binaires de version et de débogage
  • Réduction de 26 % du temps de compilation des binaires de publication

Toujours selon JetBrains, ces améliorations permettent également de réduire de 10% le temps de compilation d'un binaire de débogage sur un grand projet.

JetBrains publie kotlinx.coroutines 1.6.0

Soumis par fredericmazue le

Suite à la sortie de Kotlin 1.6, JetBrains a publié kotlinx.coroutines en version 1.6.0. Les principales fonctionnalités apportées sont une nouvelle API et un support multi plates-formes pour kotlinx-coroutines-test, la prise en charge du nouveau gestionnaire de mémoire Kotlin/Native, une nouvelle API dispatcher views qui permet de limiter le parallélisme sans créer de pools de threads supplémentaires et fournit un moyen unifié de créer des répartiteurs pour un parallélisme indépendant et l'introduction de CopyableThreadContextElemenr qui donne aux coroutines un accès en écriture thread-safe aux variables ThreadLocal.

kotlinx-coroutines 1.6.0 est sur GitHub.

[video:https://www.youtube.com/watch?v=9R1IdMwSVps autoplay:0]

Compose Multiplatform 1.0 : un framework d'interface utilisateur bureau et web pour Kotlin

Soumis par fredericmazue le

JetBrains, éditeur du célèbre EDI Intellij IDEA et concepteur du langage Kotlin, a publié Compose Multiplatform en version 1.0. Il s'agit d'un framework pour créer des interfaces utilisateur avec le langage Kotlin, ciblant les applications de bureau et les application web, sur Windows, Linux et macOS.

Compose for Desktop propose une approche déclarative et réactive de la création d’interfaces utilisateurs de bureau avec Kotlin, sans que XML ou un langage de template soit nécessaire. Compose for Desktop cible la JVM et prend en charge le rendu d’interface utilisateur avec accélération matérielle sur toutes les principales plateformes de bureau (macOS, Windows et Linux) en exploitant la bibliothèque graphique native Skia.

Compose for Web permet de créer des interfaces utilisateur réactives pour le web en Kotlin, en utilisant les concepts et les API de Jetpack Compose pour exprimer l'état, le comportement et la logique des applications. Compose for Web offre plusieurs façons de déclarer des interfaces utilisateur dans le code Kotlin, ce qui, selon JetBrains, permet d'avoir un contrôle total sur la mise en page de votre site web avec une API DOM déclarative.

Compose Multiplatform est un logiciel libre sous licence Apache 2.0, disponible sur GitHub.

Kotlin 1.6

Soumis par fredericmazue le

JetBrains a publié la version 1.6 de son langage Kotin. Parmi les nouveautés de cette riche version, mentionnons tout d'abord le fait que l'amélioration de l'inférence des types récursifs génériques, apparue avec Kotlin 1.5.30 est maintenant activée par défaut.

Cette amélioration permet d'inférer les arguments des types gécursifs génériques en se basant uniquement sur les limites supérieures des paramètres de type correspondants. 

// Before 1.5.30
val containerA = PostgreSQLContainer<Nothing>(DockerImageName.parse("postgres:13-alpine")).apply {
  withDatabaseName("db")
  withUsername("user")
  withPassword("password")
  withInitScript("sql/schema.sql")
}

// With compiler option in 1.5.30 or by default starting with 1.6.0
val containerB = PostgreSQLContainer(DockerImageName.parse("postgres:13-alpine"))
  .withDatabaseName("db")
  .withUsername("user")
  .withPassword("password")
  .withInitScript("sql/schema.sql")

A remarquer aussi du nouveau autour des déclarations when. Une déclaration when est exhaustive lorsqu'elle contient des branches pour tous les types ou valeurs possibles de son sujet, et, pour certains types, une branche else supplémentaire. Une déclaration exhaustive, comme le terme le suggère, couvre tous les cas possibles, rendant votre code plus sûr.

JetBrains interdira bientôt les déclarations when non exhaustives pour rendre le comportement cohérent avec les expressions when. Pour assurer une migration en douceur, Kotlin 1.6.0 signale des avertissements concernant les déclarations when non exhaustives avec un sujet enum, sealed ou boolean. Ces avertissements deviendront des erreurs dans les versions futures.

sealed class Contact {
    data class PhoneCall(val number: String) : Contact()
    data class TextMessage(val number: String) : Contact()
}

fun Contact.messageCost(): Int =
    when(this) { // Error: 'when' expression must be exhaustive
        is Contact.PhoneCall -> 42
    }

fun sendMessage(contact: Contact, message: String) {
    // Starting with 1.6.0

    // Warning: Non exhaustive 'when' statements on Boolean will be
    // prohibited in 1.7, add 'false' branch or 'else' branch instead
    when(message.isEmpty()) {
        true -> return
    }

    // Warning: Non exhaustive 'when' statements on sealed class/interface will be
    // prohibited in 1.7, add 'is TextMessage' branch or 'else' branch instead
    when(contact) {
        is Contact.PhoneCall -> TODO()
    }
}

A partir de Kotlin 1.6.0, JetBrains en charge le développement de trois versions précédentes de l'API au lieu de deux, ainsi que la version stable actuelle. Donc JetBrains prend actuellement en charge les versions 1.3, 1.4, 1.5 et 1.6.

Kotlin/Natif

Il y a aussi beaucoup de nouveau du côté de Kotlin/Natif :

  • Un nouveau gestionnaire de mémoire en préversion
  • Prise en charge de Xcode 13
  • Compilation de cibles Windows sur n'importe quel hôte
  • Mises à jour de LLVM et de l'éditeur de liens
  • Amélioration des performances
  • Plugin de compilateur unifié ABI avec backends JVM et JS IR
  • Messages d'erreur détaillés pour les échecs de liaison klib
  • API de gestion des exceptions non gérée retravaillée   

Site : kotlinlang.org

Kotlin a sa mascotte ! Trouvez lui un nom !

Soumis par fredericmazue le

Si Kotlin, le langage de programmation conçu par JetBrains, éditeur du célèbre environnement de développent intégré IntelliJ IDEA, existe depuis dix ans, il n'avait toujours pas de mascotte, jusqu'à la fin de la semaine dernière.

Ce vide est comblé, ce qui semble très important au yeux de JetBrains. L'éditeur indique que chacun peut utiliser cette mascotte n'importe où. Dans votre blog, vos avatars, vos diapositives, vos vidéos, etc. Plus d'informations ici.

Mais cette mascotte n'a pas de nom ! JetBrains invite toutes les personnes intéressées à proposer des idées de noms. Un premier tri sera fait pour regrouper les noms qui auront été les plus mentionnés. Puis le nom définitif sera élu parmi ceux-ci.

Les propositions de noms pour la mascotte de Kotlin peuvent être faites ici.