Kotlin

JUnit 6.0.0 : Java 17 minimum, support de Kotlin suspend

Soumis par francoistonic le
Image

Un des outils phares des développeurs Java est JUnit. L'environnement de tests revient en version 6.0.0. Il faut installer Java 17 minimum et Kotlin 2.2 pour les tests de codes Kotlin. Une des nouveautés les plus importantes est le support de suspend (Kotlin). La v6 introduit aussi Java Flight Recorder, FastCSV et le retrait des derniers éléments de la version 4. 

Le support de suspend permet aux développeurs Kotlin une meilleure expérience JUnit - Kotlin. Cette fonctionnalité permet de suspendre un appel API durant les tests. Cela doit apporter un comportement des coroutines comme sur le code de production. 

Les modules JUnit supportent les annotations nullable JSpecify. Elles indiquent explicitement les paramètres d'une méthode, un retour de types ou un champs peuvent être null. Le support de FastCSV doit éviter toute dépendance CSV et améliorer le retour d'erreurs sur les données CSV. 

En résumé, JUNIT 6.0.0 c'est :

- Java 17 et Kotlin 2.2 minimum

- une version unique pour Platform, Jupiter et Vintage

- support de JSpecify

- intégration de JFR dans junit-platform-launcher

- support de la librairie FastCSV pour CsvSource et CsvFileSource

- nouveau mode --fail-fast pour la ConsoleLauncher

- annulation d'une exécution de tests avec CancellationToken

- retrait des fonctionnalités et API anciennes

Note de version complète : https://docs.junit.org/6.0.0/release-notes/

Kotlin 2.2.20 : nouvelle bêta

Soumis par francoistonic le

Kotlin 2.2.20 est en développement. Fin juillet, la bêta 2 était disponible. Les principales évolutions de cette bêta sont :

- export Swift par défaut sur Kotlin Multiplatform ainsi qu'une nouvelle approche pour la déclaration des dépendances communes (pour stabiliser et simplifier la gestion des dépendances)

- taille réduire des binaires sur iOS

- Kotlin-Wasm : meilleure interopérabilité

- bêta 2 disponible sur Android Studio et IntelliJ IDEA

- support expérimentation d'invokedynamic 

Tous les détails : https://kotlinlang.org/docs/whatsnew-eap.html?_cl=MTsxOzE7akIwbnppZW1hcU1CeGlpb1BOZ3V5QldTY3BZbTJscElKMWt5QkJnVzZkWlpIcHZqbllLTzZYdHdhNkJ0TjVlazs=#kotlin-native

Kotlin 2.2.0 : focus sur le compilateur, le langage, Gradle

Soumis par francoistonic le

Kotlin 2.2.0 est disponible depuis le 23 juin. Une version particulièrement riche : nouveautés du langage, le compilateur, l'interopérabilité avec la JVM / Native, Wasm et JavaScript, la librairie standard, Gradle et la documation. La 2.2.0 est disponible sur les dernières version d'IntelliJ IDEA et Android Studio. 

1 Langage

Kollin 2.2.0 propose plusieurs fonctionnalités expérimentales, par exemple, les paramètres de contexte : permet aux fonctions et propriétés de déclarer des dépendances disponibles dans un contexte précis, ou encore des annotations cibles "use-site"

2 Compliateur

Introduction, en expérimentation, d'une gestion unifiée des avertissements de compilation avec l'option -Xwarning-level. 

3 Interopérabilité

Kotlin met à jour les ponts avec la JVM. Le compilateur supporte le bytecode Java 24. Avec cette version, on voit apparaitre les annotations en lecture et écriture dans les metadonnées Kotlin. Ces annotations seront intégrées au niveau de la librairie Kotlin Metadata KVM. Autre expérimentation, l'introduction de @JVMExposeBoxed pour consommer plus facilement des classes inline value de Java. Côté Kotlin/Native, LLVM 19 est supporté. Et on peut tester l'encodage Latin-1 des strings dns le runtime. Le langage promet aussi une amélioration du tracking de la mémoire sur macOS. Côté Kotlin/Wasm, le langage propose que l'infrastructure build pour Wasm soit séparée de celle de JavaScript. Jusqu'à présent, on devait utiliser la même infrastructure pour cibler JS et Wasm. 

4 Divers

Gradle est à jour avec la version 8.14. Autre fonction expérimentale, la possibilité de vérifier la compatibilité binaire directement depuis le plugin Gradle. Autre nouveauté, l'apparition de la couleur dans les données de sorties sur la console durant le build Gradle pour améliorer la compréhension des rapports. Kotlin 2.2.0 introduit aussi un nouvel outil pour le build d'API. Il supporte Kotlin/JVM uniquement. 

Kotlin stabilise l'encodage et le décodage Base64.  

5 Casse compatibilité et dépréciations

Attention, Kotlin 2.2.0 introduit de nombreuses casses de codes et des dépréciations : 

- le support du build Ant est déprécié

- JSR-223 ne sera pas migré sur K2

- dépréciation de kotlin-android-extensions

La liste est longue. Avant de migrer vers Kotlin 2.2.0 vérifiez attentivement vos codes. 

Note de version : https://kotlinlang.org/docs/whatsnew22.html#optimizenonskippinggroups-feature-flag-enabled-by-default

Kotlin 2.0

Soumis par fredericmazue le

Jetbrains a annoncé la disponibilité de la nouvelle version de son langage maison : Kotlin 2.0. Les développeurs apprécieront que les plugins Kotlin qui prennent en charge Kotlin 2.0.0 sont regroupés dans les dernières versions d'IntelliJ IDEA et Android Studio. Vous n'avez pas besoin de mettre à jour le plugin Kotlin dans votre IDE. Tout ce que vous avez à faire est de changer la version de Kotlin en Kotlin 2.0.0 dans vos scripts de build.

Kotlin 2.0 se fait essentiellement remarquer par son nouveau compilateur K2, désormais stable et utilisé par défaut. Jetbrains souligne que ce nouveau compilateur est stable pour toutes les plates-formes cibles : JVM, Native, Wasm et JS. JetBrains souligne encore que  le nouveau compilateur apporte des améliorations majeures en termes de performances, accélère le développement de nouvelles fonctionnalités de langage, unifie toutes les plates-formes prises en charge par Kotlin et fournit une meilleure architecture pour les projets multiplateformes.

JetBrains a assuré la qualité du nouveau compilateur en compilant avec succès 10 millions de lignes de code provenant de projets utilisateur et internes sélectionnés. 18 000 développeurs et 80 000 projets ont été impliqués dans le processus de stabilisation, essayant le nouveau compilateur K2 dans leurs projets et signalant tous les problèmes rencontrés.

Pour rendre le processus de migration vers le nouveau compilateur aussi fluide que possible, JetBrains a publié un guide de migration du compilateur K2 . Ce guide explique les nombreux avantages du compilateur, met en évidence les modifications que vous pourriez rencontrer et décrit comment revenir à la version précédente si nécessaire.

Améliorations de Kotlin Multiplateforme

Les nouveautés apportées par ce nouveau comilateur K2 sont très nombreuses. Nous renvoyons le lecteur à la note de version. Nous remarquons ici que JetBrains a apporté des améliorations au compilateur K2 lié à Kotlin Multiplatform dans les domaines suivants :

  • Séparation des sources communes et de la plateforme lors de la compilation
  • Différents niveaux de visibilité des déclarations attendues et réelles

Différents niveaux de visibilité des déclarations attendues et réelles

Avant Kotlin 2.0.0, si vous utilisiez des déclarations attendues et réelles dans votre projet Kotlin Multiplatform, elles devaient avoir le même niveau de visibilité. Kotlin 2.0.0 prend désormais également en charge différents niveaux de visibilité, mais uniquement si la déclaration réelle est plus permissive que la déclaration attendue.

Séparation des sources communes et de la plateforme lors de la compilation

Auparavant, la conception du compilateur Kotlin l’empêchait de séparer les ensembles de sources communes et de plate-forme au moment de la compilation. En conséquence, le code commun pouvait accéder au code de la plate-forme, ce qui entraînait des comportements différents entre les plates-formes. De plus, certains paramètres du compilateur et dépendances du code commun étaient utilisés pour s'infiltrer dans le code de la plate-forme. Avec le compilater K2, ceci n'est plus possible.

Plugin de compilateur expérimental Kotlin Power-assert

On remarque enfin que Kotlin 2.0.0 introduit un plugin expérimental de compilateur Power-assert. Ce plugin améliore l'expérience d'écriture de tests en incluant des informations contextuelles dans les messages d'échec, rendant le débogage plus facile et plus efficace.

Les développeurs doivent souvent utiliser des bibliothèques d'assertions complexes pour écrire des tests efficaces. Le plugin Power-assert simplifie ce processus en générant automatiquement des messages d'échec qui incluent des valeurs intermédiaires de l'expression d'assertion. Cela aide les développeurs à comprendre rapidement pourquoi un test a échoué.

Lorsqu'une assertion échoue lors d'un test, le message d'erreur amélioré affiche les valeurs de toutes les variables et sous-expressions de l'assertion, indiquant clairement quelle partie de la condition a provoqué l'échec. Ceci est particulièrement utile pour les assertions complexes où plusieurs conditions sont vérifiées.

L'activation de ce plugin expérimental se fait dand le fichier build.gradle(.kts) :

plugins {
    kotlin("multiplatform") version "2.0.0"
    kotlin("plugin.power-assert") version "2.0.0"
}

powerAssert {
    functions = listOf("kotlin.assert", "kotlin.test.assertTrue")
}

IntelliJ IDEA supporte le mode Kotlin k2

Soumis par fredericmazue le
IDE

A partir de la v.2024.1, IntelliJ IDEA est livré avec un mode K2 en option. Dans ce mode, l'EDI utilise le compilateur K2 pour une analyse du code Kotlin plus rapide et plus robuste.
L'EDI dispose donc désormais de deux modes :

  • Mode classique (activé par défaut) – l'IDE utilise le compilateur Kotlin standard (K1) pour analyser le code Kotlin.
  • Mode K2 (maintenant en Alpha) – l'EDI utilise le nouveau compilateur K2 comme moteur d'analyse de code.

Qu'est-ce que le mode K2 ?

JetBrains a réécrit le compilateur Kotlin à partir de zéro pour améliorer les performances et améliorer l'architecture interne, facilitant ainsi le développement ultérieur du langage Kotlin. De plus, comme le compilateur Kotlin est utilisé comme moteur d'analyse de code dans l'IDE, le compilateur K2 est optimisé pour répondre aux exigences de l'IDE.

Le mode K2 offre :

  • Compatibilité avec les futures fonctionnalités de Kotlin 
  • Stabilité de l'analyse du code :
  • Meilleures performances de l'IDE 

Pour essayer le mode K2 il faut aller dans Paramètres | Langages et frameworks | Kotlin, puis cocher la case Activer le plugin Kotlin basé sur K2 pour activer le nouveau mode .

Après avoir activé le mode K2, vous devrez redémarrer l'IDE.

Kotlin 1.9.20

Soumis par fredericmazue le

JetBrains a annoncé la disponibilité d'une nouvelle mouture de son langage maison : Kotlin 1.9.20. Cette version, riche, se distingue principalement à nos yeux par la stabilité de Kotlin Multiplatforn et l'arrivée du nouveau compilateur K2 en version bêta, ainsi que d'un nouvel allocateur mémoire plus efficace.

Statibilité de Kotlin Multiplatform

La version 1.9.20 marque une étape importante dans l'évolution de Kotlin, souligne JetBrains. Kotlin Multiplatform est devenu stable. Cette promotion signifie que la technologie peut être utilisée en toute sécurité dans vos projets et prête pour la production. Cela signifie également que le développement ultérieur de Kotlin Multiplatform se poursuivra conformément aux règles strictes de compatibilité ascendante de JetBrains.

Il est à noter que certaines fonctionnalités avancées de Kotlin Multiplatform sont encore en évolution. Lorsque vous utilisez celles-ci, vous recevez un avertissement décrivant l'état de stabilité actuel de la fonctionnalité avec laquelle vous travaillez. 

Compilateur Kotlin K2 bêta

L'équipe Kotlin de JetBrains continue de stabiliser le nouveau compilateur K2, qui doit à terme apporter des améliorations majeures des performances, accélérer le développement de nouvelles fonctionnalités de langage, unifier toutes les plates-formes prises en charge par Kotlin et fournir une meilleure architecture pour les projets multi plates-formes. À l'heure actuelle, K2 est en version bêta pour toutes les cibles. L'équipe JetBrains a dit avoir assuré la qualité du nouveau compilateur en compilant avec succès des dizaines de projets utilisateurs et internes. Ce stade bêta signifie que vous pouvez désormais essayer K2 dans n'importe quel projet Kotlin.

Un nouvel allocateur mémoire

Kotlin 1.9.20 est livré avec un nouvel allocateur mémoire qui est activé par défaut. Il est conçu pour remplacer l'allocateur par défaut précédent, mimaloc afin de rendre le garbage collection plus efficace et d'améliorer les performances d'exécution du gestionnaire de mémoire Kotlin/Native .

Le nouvel allocateur personnalisé divise la mémoire système en pages, permettant un balayage indépendant dans un ordre consécutif. Chaque allocation devient un bloc de mémoire dans une page et la page garde une trace de la taille des blocs. Différents types de pages sont optimisés pour différentes tailles d'allocation. La disposition consécutive des blocs de mémoire garantit une itération efficace sur tous les blocs alloués.

Lorsqu'un thread alloue de la mémoire, il recherche une page appropriée en fonction de la taille d'allocation. Les threads conservent un ensemble de pages pour différentes catégories de taille.

Le nouvel allocateur permet simultanément plusieurs espaces d'allocation indépendants, ce qui permettra à l'équipe Kotlin d'expérimenter différentes mises en page pour améliorer encore davantage les performances.

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

Kotlin 1.9

Soumis par fredericmazue le

JetBrains a annoncé la disponibilié du langage Kotlin en version 1.9. Cette version continue de stabiliser le compilateur K2 et la version 1.9.0 introduit de nouvelles avancées. Le compilateur K2 pour la JVM est maintenant en version bêta.

À partir de la version 1.9.0 jusqu'à la sortie de Kotlin 2.0, vous pouvez facilement tester le compilateur K2 avec la propriété Gradle kotlin.experimental.tryK2=true. Vous pouvez également exécuter la commande suivante :

./gradlew assemble -Pkotlin.experimental.tryK2=true

Cette propriété Gradle définit automatiquement la version du langage sur 2.0 et met à jour le rapport de génération avec le nombre de tâches Kotlin compilées à l'aide du compilateur K2 par rapport au compilateur actuel :

##### 'kotlin.experimental.tryK2' results (Kotlin/Native not checked) #####
:lib:compileKotlin: 2.0 language version
:app:compileKotlin: 2.0 language version
##### 100% (2/2) tasks have been compiled with Kotlin 2.0 #####

Les nouveautés de Kotlin 1.9 sont récapitulées dans la vidéo ci-dessous

[video:https://www.youtube.com/watch?v=fvwTZc-dxsM autoplay:0]

Kotlin 1.8

Soumis par fredericmazue le

JetBrains a publié, sans tambour ni trompette, une nouvelle mouture de son langage maison : Kotlin 1.8.

Cette nouvelle version voit des enrichissements de sa bibliothèque standard. Par exemple arrivent deux nouvelles fonctions d'extension pour java.nio.file.Path, copyToRecursively() et deleteRecursively(), qui permettent d'effectuer des tâches récursives sur des répertoires :

  • la copie d'un répertoire et son contenu vers une autre destination.
  • la suppression un répertoire et son contenu.

Ces nouvelles fonctions sont au stade expérimental pour le moment.

On remarque encore une amélioration de l'interopérabilité avec Objective-C et Swift grâce à l'arrivée de nouvelles annotations. En ce qui concerne Kotlin Native arrive le support pour l'EDI Xcode 14

Kotlin 1.8 apporte encore la compatibilité avec Gradle 3.7.

Meta abandonne Java au profit de Kotlin pour le développement sur Android

Soumis par fredericmazue le

Dans un intéressant billet intitulé "De zéro à 10 millions de lignes de Kotlin", l'entreprise Meta, ex Facebook, explique désormais utiliser Kotlin au lieu de Java pour développer sur Android, et décrit la migration de son code existant.

Pour justifier son choix, Meta remarque que Kotlin est généralement considéré comme un meilleur langage que Java et dit avoir comparé la dernière version de Kotlin avec Java 11, qui est la dernière version pouvant être utilisée pour le développement Android.

Meta voit quelques avantages majeurs à Kotlin :

  • Nullability : les exceptions de pointeur Null sont un problème courant chez Meta, comme partout ailleurs. Nous sommes très bons pour les corriger avant de publier nos applications, mais traiter ces problèmes prend encore du temps. Nous utilisons des outils internes pour détecter plus tôt les problèmes de sécurité nuls, et nous annotons rigoureusement notre code dans le cadre de notre travail pour détecter ces problèmes dans Java plus tôt . Mais même avec cela, la gestion de nullabilité intégrée de Kotlin est plus robuste et plus facile à utiliser.
  • Programmation fonctionnelle : la prise en charge par Kotlin des fonctions en ligne et des expressions lambda nous permet d'utiliser un style de programmation fonctionnel sans compromettre la vitesse d'exécution. Bien que Java 8 ajoute la prise en charge des lambdas et soit disponible pour Android, cela se fait au prix d'objets plus anonymes, ce qui affecte négativement les performances sur les appareils Android bas de gamme. Le Redex maison de Meta minimise ces problèmes, mais ils existent toujours, faisant de Kotlin une meilleure alternative.
  • Code plus court : la conception moderne de Kotlin rend son code plus court. Kotlin permet de supprimer des types explicites (comme le fait Java 11), et avec la bibliothèque standard, qui est basée sur le style fonctionnel mentionné ci-dessus, il raccourcit de nombreuses boucles répétitives en instructions plus simples. Ce code plus court est également plus explicite, ce qui peut le rendre plus facile à suivre.
  • Langage spécifique au domaine (DSL) / Constructeurs de type sécurisé : Les différentes fonctionnalités de Kotlin se rejoignent et nous permettent de définir un DSL. Fondamentalement, un moyen de déplacer des définitions telles que les XML Android à implémenter directement dans le code Kotlin. Mais cet outil doit être utilisé avec précaution car la mise en œuvre de DSL dans Kotlin peut être utile ou se transformer en ingénierie excessive.

Meta énumère aussi quelques inconvénients au passage à Kotlin. Notamment le fait qu'il existe moins d'outils de développement pour Kotlin que pour Java et le fait que les temps de construction des applications sont potentiellement beaucoup plus longs.

Le reste du billet détaille comment le code a été migré de Java à Kotlin, avec des résultats satisfaisants. Meta apprécie une taille du code réduite pour des vitesses d'exécution sensiblement identiques. Les temps de construction des applications ont effectivement augmenté avec le passage à Kotlin, mais Meta traite ce problème avec certaines des fonctionnalités de son outil de construction de projets maison Buck.

Kotlin 1.7.20

Soumis par fredericmazue le

JetBrains a publié la version 1.7.20 de son langage maison Kotlin. Dans cette version nous remarquons particulièrement l'arrivée d'un nouvel opérateur ainsi qu'une nouvelle fonctionnalité expérimentale, les classes inline génériques.

L'opérateur ..<

Kotline 1.7.20 introduit le nouvel opérateur ..<. Cet opérateur permet d'exprimer une plage de valeurs. Il agit comme la fonction until et vous aide à définir la plage ouverte.

Voici un exemple d'utilisation de l'opérateur v dans une expression ..< :

when (value) {
    in 0.0..<0.25 -> // first quarter
    in 0.25..<0.5 -> // second quarter
    in 0.5..<0.75 -> // third quarter
    in 0.75..1.0 ->  // last quarter  <- note closed range here
}

Pour utiliser l'opérateur ..<, activez l' option -language-version 1.8 du compilateur.

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

Les classes inline génériques

Les classes en ligne génériques sont à l'heure actuelle une fonctionnalité expérimentale qui peut être supprimée ou modifiée à tout moment.

Kotlin 1.7.20 permet au type sous-jacent des classes en ligne JVM d'être un paramètre de type. Le compilateur le mappe sur Any? ou, généralement, sur la limite supérieure du paramètre de type.

Considérez l'exemple suivant :

@JvmInline
value class UserId<T>(val value: T)

fun compute(s: UserId<String>) {} // compiler generates fun compute-<hashcode>(s: Any?)

La fonction accepte la classe inline comme paramètre. Le paramètre est mappé à la limite supérieure, pas à l'argument de type.

Pour activer cette fonctionnalité, utilisez l' option -language-version 1.8 du compilateur.

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

A remarquer aussi

Kotlin 1.7.20 impose des restrictions majeures sur l'utilisation de l'inférence de type de générateur qui pourraient affecter votre code. Ces restrictions s'appliquent au code contenant des fonctions lambda de générateur, où il est impossible de dériver le paramètre sans analyser le lambda lui-même. Le paramètre est utilisé comme argument. Désormais, le compilateur affichera toujours une erreur pour un tel code et vous demandera de spécifier explicitement le type.

Enfin, Kotlin 1.7.20 est livré avec le nouveau gestionnaire de mémoire Kotlin/Native activé par défaut.

Toutes les nouveautés de Kotlin 1.7.20 sont récapitulées dans la vidéo ci-dessous.

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