Vous êtes nouveau sur Developpez.com ? Créez votre compte ou connectez-vous afin de pouvoir participer !

Vous devez avoir un compte Developpez.com et être connecté pour pouvoir participer aux discussions.

Vous n'avez pas encore de compte Developpez.com ? Créez-en un en quelques instants, c'est entièrement gratuit !

Si vous disposez déjà d'un compte et qu'il est bien activé, connectez-vous à l'aide du formulaire ci-dessous.

Identifiez-vous
Identifiant
Mot de passe
Mot de passe oublié ?
Créer un compte

L'inscription est gratuite et ne vous prendra que quelques instants !

Je m'inscris !

Kotlin 1.4 est disponible et met l'accent sur la qualité et la performance
Cette version inaugure le Coroutine Debugger pour localiser avec précision les bogues dans vos applications

Le , par Stéphane le calme

305PARTAGES

10  0 
Mise à jour du 18/08/2020 : Kotlin 1.4 est disponible et met l’accent sur la qualité et la performance

Le principal objectif de JetBrains pour cette version était d’améliorer l’expérience de développement globale avec Kotlin, notamment avec l’amélioration des performances et de la stabilité de l’EDI. Il était donc question d’optimiser autant que possible la productivité des utilisateurs de Kotlin et l'éditeur s'est concentré sur l’amélioration des points les plus importants pour les développeurs. Au total, plus de 60 problèmes de performance ont été corrigés, dont beaucoup provoquaient des blocages de l’EDI ou des fuites de mémoire. Au cours de la phase EAP de Kotlin 1.4.0, JetBrains a recueilli de nombreux retours positifs indiquant que l’expérience globale était devenue beaucoup plus agréable !

Lorsque vous travaillez avec un projet et que vous ouvrez un gros fichier Kotlin pour la première fois, son contenu avec mise en évidence de la syntaxe s’affiche maintenant beaucoup plus vite. Dans la plupart des cas, la mise en évidence syntaxique est 1,5 à 4 fois plus rapide.Le temps nécessaire à l’affichage des suggestions de saisie semi-automatique a été considérablement réduit.

Mais Kotlin 1.4 comporte également de nouvelles fonctionnalités. Par exemple, du côté de l'EDI, un nouvel Assistant de projet Kotlin flexible est proposé. Cet assistant fournit un emplacement unique pour créer et configurer des projets Kotlin de différents types, ce qui facilite le démarrage même avec des structures complexes telles que des projets multiplateformes.

Source : JetBrains

Mise à jour du 15/08/2020 : Kotlin 1.4.0 est disponible en version stable

Dans le référentiel Jetbrains dédié à Kotlin, l'éditeur a indiqué il y a quelques heures la disponibilité de la version stable. Elle s'accompagne de nouvelles fonctionnalités, notamment au niveau du compilateur, comme l'introduction de KotlinNothingValueException qui sera généré à la place de NullPointerException sur les exceptions de types Nothing [la classe Nothing représente une valeur inexistante, utilisée notamment par une fonction ne renvoyant qu'une exception (et jamais de valeur)].

Source : JetBrains

JetBrains a annoncé la disponibilité de Kotlin 1.4.0-RC, la Release Candidate de sa prochaine version majeure du langage de programmation.

Prise en charge EDI améliorée de *.gradle.kts

JetBrains a considérablement amélioré la prise en charge EDI des scripts Gradle Kotlin DSL (fichiers *.gradle.kts) dans Kotlin 1.3.70, et l'éditeur a continué sur cette lancée dans Kotlin 1.4.0-RC. Voici ce que cette nouvelle version apporte :

Chargement de la configuration du script explicitement pour de meilleures performances

Auparavant, lorsque vous ajoutiez un nouveau plugin au bloc buildscript ou plugins de votre build.gradle.kts, la nouvelle configuration de script était chargée automatiquement en arrière-plan. Ensuite, après son application, vous pouvez utiliser l'assistance de code pour le plugin nouvellement ajouté.

Pour améliorer les performances, l'éditeur a supprimé ce comportement automatique consistant à appliquer des modifications à la configuration du script lors de la saisie. À partir de Gradle 6.0 et des versions plus récentes, vous devez appliquer explicitement les modifications aux configurations en cliquant sur Charger les modifications Gradle ou en réimportant le projet Gradle.

Dans les versions antérieures de Gradle, vous devez charger manuellement la configuration du script en cliquant sur Charger la configuration dans l'éditeur.

JetBrains a ajouté une autre action dans IntelliJ IDEA 2020.1 avec Gradle 6.0+, Charger les configurations de script, qui charge les modifications des configurations de script sans mettre à jour l'ensemble du projet. Cela prend beaucoup moins de temps que de réimporter l'ensemble du projet.

Meilleurs rapports d'erreurs

Auparavant, vous ne pouviez voir les erreurs du Gradle Daemon (un processus qui s'exécute en arrière-plan et est responsable de toutes les tâches et activités liées à Gradle) que dans des fichiers journaux séparés. Désormais, à partir de Gradle 6.0 ou des versions plus récentes, Gradle Daemon renvoie directement toutes les informations sur les erreurs et les affiche dans la fenêtre de l'outil de création. Cela vous fait gagner du temps et des efforts.


Moins de boilerplate dans la configuration de votre projet

Avec les améliorations apportées au plugin Kotlin Gradle, vous pouvez écrire moins de code dans vos fichiers de construction Gradle : l'un des scénarios les plus courants est désormais activé par défaut.

Faire de la bibliothèque standard une dépendance par défaut

Une écrasante majorité de projets nécessitent la bibliothèque standard Kotlin. À partir de la version 1.4.0-RC, vous n'avez plus besoin de déclarer manuellement une dépendance sur stdlib dans chaque ensemble de sources - elle sera désormais ajoutée par défaut. La version ajoutée automatiquement de la bibliothèque standard sera la même que la version du plugin Kotlin Gradle, car ils ont le même contrôle de version.

Voici à quoi ressemblait une configuration de projet multiplateforme typique avec des cibles Android, iOS et JavaScript avant la version 1.4:

Code Kotlin : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
android() 
ios() 
js() 
  
sourceSets { 
    commonMain { 
        dependencies { 
            implementation("org.jetbrains.kotlin:kotlin-stdlib-common") 
            implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core-common:1.3.6") 
        } 
    } 
  
    androidMain { 
        dependencies { 
            implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8") 
            implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.6") 
        } 
    } 
  
    jsMain { 
        dependencies { 
            implementation("org.jetbrains.kotlin:kotlin-stdlib-js") 
            implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core-js:1.3.6") 
        } 
    } 
  
    iosMain { 
        dependencies { 
            implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core-native:1.3.6") 
        } 
    } 
}
Désormais, vous n'avez plus du tout besoin de déclarer explicitement une dépendance à la bibliothèque standard, et avec la prise en charge de la structure de projet hiérarchique, annoncée dans la version 1.4-M2, vous ne devez spécifier d'autres dépendances qu'une seule fois. Ainsi, votre fichier de construction Gradle deviendra beaucoup plus concis et facile à lire:

Code Kotlin : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
android() 
ios() 
js() 
  
sourceSets { 
    commonMain { 
        dependencies { 
            implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.6") 
        } 
    } 
}

Pour les ensembles de sources de plateforme et les ensembles de sources partagés en backend, la bibliothèque standard correspondante sera ajoutée, tandis qu'une bibliothèque standard commune sera ajoutée au reste. Le plugin Kotlin Gradle sélectionnera la bibliothèque standard JVM appropriée en fonction du paramètre kotlinOptions.jvmTarget.

Si vous déclarez explicitement une dépendance de bibliothèque standard (par exemple, si vous avez besoin d'une version différente), le plugin Kotlin Gradle ne la remplacera pas et n'ajoutera pas une deuxième bibliothèque standard. Et si vous n'avez pas du tout besoin d'une bibliothèque standard, vous pouvez ajouter l'indicateur de désactivation aux propriétés Gradle:

Code Kotlin : Sélectionner tout
kotlin.stdlib.default.dependency=false

Kotlin / Native

Gestion simplifiée des dépendances CocoaPods

Auparavant, une fois que vous intégriez votre projet avec le gestionnaire de dépendances CocoaPods, vous pouviez créer une partie iOS, macOS, watchOS ou tvOS de votre projet uniquement dans Xcode, distincte des autres parties de votre projet multiplateforme. Ces autres pièces pouvaient être générées dans IntelliJ IDEA.

De plus, chaque fois que vous ajoutiez une dépendance à une bibliothèque Objective-C stockée dans CocoaPods (bibliothèque Pod), vous deviez passer d'IntelliJ IDEA à Xcode, lancer la tâche pod install et y exécuter la build Xcode.

Vous pouvez désormais gérer les dépendances de pod directement dans IntelliJ IDEA tout en profitant des avantages qu'il offre pour travailler avec le code, tels que la mise en évidence et la complétion de code. Vous pouvez également créer l'ensemble du projet Kotlin avec Gradle, sans avoir à passer à Xcode. Cela signifie que vous ne devez accéder à Xcode que lorsque vous devez écrire du code Swift / Objective-C ou exécuter votre application sur un simulateur ou un appareil.

Vous pouvez désormais également travailler avec des bibliothèques de pods stockées localement.

Selon vos besoins, vous pouvez ajouter des dépendances entre:
  • Un projet Kotlin et des bibliothèques de pod du référentiel CocoaPods.
  • Un projet Kotlin et des bibliothèques Pod stockées localement.
  • Un Kotlin Pod (projet Kotlin utilisé comme dépendance CocoaPods) et un projet Xcode avec une ou plusieurs cibles.

Terminez la configuration initiale et lorsque vous ajoutez une nouvelle dépendance à CocoaPods, réimportez simplement le projet dans IntelliJ IDEA. La nouvelle dépendance sera ajoutée automatiquement. Aucune étape supplémentaire n'est requise.

Générer des fichiers .dSYM sur les cibles Apple par défaut

Le débogage d'un plantage d'application iOS implique parfois l'analyse des rapports d'incident, et les rapports d'incident nécessitent généralement une symbolisation pour devenir correctement lisibles. Pour symboliser les adresses dans Kotlin, le bundle .dSYM pour le code Kotlin est requis. À partir de la version 1.4-M3, le compilateur Kotlin / Native produit par défaut des .dSYM pour les binaires de version sur les plateformes Darwin. Cela peut être désactivé avec l'indicateur -Xadd-light-debug = disable du compilateur. Sur les autres plateformes, cette option est désactivée par défaut. Pour basculer cette option dans Gradle, utilisez:

Code Kotlin : Sélectionner tout
1
2
3
4
5
6
7
kotlin { 
    targets.withType<org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget> { 
        binaries.all { 
            freeCompilerArgs += "-Xadd-light-debug={enable|disable}" 
        } 
    } 
}

Kotlin 1.4.0-RC est également livré avec de nouvelles fonctionnalités pour déboguer les coroutines et définir des fonctions récursives profondes

Source : JetBrains

Une erreur dans cette actualité ? Signalez-le nous !