Présentation du langage Kotlin

1. Environnement de développement intégré

Afin de commencer à développer en Kotlin, il est conseillé d’installer et de configurer un environnement de développement intégré (EDI). Comme pour tout autre langage de programmation, ce type d’environnement n’est pas obligatoire mais il est fortement recommandé pour faciliter et améliorer votre expérience de développement.

IntelliJ IDEA, l’EDI très connu dans le monde Java, supporte Kotlin par défaut sans que cela nécessite l’installation d’un plugin supplémentaire. Ceci est valable pour ses deux versions : Ultimate (payante) et Community Edition (gratuite).

La version d’IntelliJ IDEA appelée Android Studio, destinée aux développeurs Android, fournit exactement le même support du langage Kotlin.

L’EDI Eclipse nécessite quant à elle l’installation du plugin Kotlin Plugin For Eclipse. Cependant, ce plugin n’offre pas un support complet et à jour de toutes les fonctionnalités du langage. Il est recommandé d’utiliser IntelliJ IDEA ou Android Studio pour vos développements en Kotlin.

L’éditeur de texte très célèbre Visual Studio Code dispose aussi d’un plugin dédié pour Kotlin. Comme pour le plugin Eclipse, il n’offre qu’un support limité du langage.

2. Compilateur Kotlin

Des outils de production tels que Maven ou Gradle sont utilisés afin de gérer le build des applications Kotlin, comme c’est le cas en Java. Il n’est donc pas nécessaire d’installer et d’appeler directement le compilateur Kotlin.

Pour chaque version de Kotlin, il est cependant possible de télécharger le compilateur associé disponible dans le dépôt GitHub du projet Kotlin.

La configuration des outils Maven et Gradle permettant de supporter Kotlin sera traitée dans les deux sections suivantes.

3. Maven

Maven, créé en 2004, est un outil de production très utilisé dans le monde Java. Il permet de gérer tout le cycle de vie de la production : génération de code, compilation, test, génération de JAR/WAR, déploiement et publication de la documentation. La majorité des EDI fournissent un support complet de cet outil, soit directement comme pour IntelliJ IDEA, soit à travers un plugin comme pour Eclipse.

On peut ajouter Kotlin à un projet Maven en utilisant le plugin kotlin-maven-plugin. Ce plugin va gérer la compilation de tout code Kotlin dans les répertoires src/main/kotlin et src/test/kotlin. Le nom/emplacement des répertoires par défaut peut être modifié par simple configuration du plugin....

1. Programme minimal

Comme la majorité des langages de programmation, tous les programmes Kotlin commencent à la fonction main. Un programme Kotlin minimale doit donc contenir cette fonction. Cette dernière doit accepter comme paramètre un tableau de chaînes de caractères. Ce tableau contiendra tous les arguments passés à l’application lors de son démarrage.

Contrairement à Java, la fonction main ne doit pas être enveloppée dans une classe statique. Ceci est un programme Kotlin valide :

fun main(args: Array<String>) { 
  println("Hello Kotlin!") 
} 

Une fois démarré, ce programme affichera la chaîne de caractères Hello Kotlin! puis il s’arrêtera puisqu’il s’agit de la dernière instruction spécifiée dans la fonction main.

Quand l’application Kotlin est compilée en bytecode Java, la fonction main est transformée en une fonction statique d’une classe générée automatiquement par le compilateur. Le nom de cette classe correspond au nom du fichier source Kotlin en plus d’un suffixe kt. Par exemple, si le fichier source porte le nom Main.kt, alors la classe statique générée par le compilateur aura le nom MainKt.

Il est également possible de définir la fonction main dans un objet (et non pas dans une classe) :

object MyApp { 
   @JvmStatic fun main(args: Array<String>) { 
     println("Hello Kotlin!") 
   } 
}  

Ce dernier programme aura exactement le même résultat que le précédent. La seule différence réside dans le fait que le nom de classe principale est celui de l’objet défini, en l’occurrence MyApp dans l’exemple.

Il faut noter qu’il n’est pas possible en Kotlin de définir la fonction main dans une classe comme en Java, du fait que Kotlin n’a pas de notion de « méthode statique ». L’annotation @JvmStatic permet de simuler ce comportement lorsque l’application écrite en Kotlin est compilée pour être exécutée par la plate-forme JVM.

On peut aussi noter qu’il n’y a pas besoin de points-virgules à la fin de chaque instruction. En Kotlin, le caractère « ; » est complètement optionnel et il n’est pas recommandé.

2. Les commentaires

Les commentaires ont la même syntaxe que Java et les autres langages dérivés du C. Les deux caractères « // » permettent de définir un commentaire sur une seule ligne, tandis que « /* */ » permet de définir un commentaire qui s’étend sur plusieurs lignes :

// This is a single line comment 
  
/* This 
is a multiline 
comment 
*/ 

3. Les variables

En Kotlin, il existe une distinction très claire entre deux catégories de variables :

L’usage de ces deux mots-clés permet de rendre le code très lisible et de choisir plus judicieusement la catégorie de la variable lors de sa déclaration.

Pour toute variable, on doit définir en plus de la catégorie un nom et un type. Si la variable est immuable val, on doit aussi lui affecter une valeur (qu’on ne peut plus changer).

La syntaxe de déclaration de variables en Kotlin est la suivante :

val/var nomDeLaVariable : TypeDeLaVarialbe = valeurInitiale 

Par exemple :

var counter : Int = 0 

L’initialisation des variables modifiables est optionnelle. On peut déclarer une variable var sans valeur initiale :

var age : Int 

En revanche, l’initialisation est obligatoire pour les variables immuables (val) :

val name : String = "Dupont" 

Pour modifier la valeur d’une...

1. Introduction

Aujourd’hui, les applications ont besoin d’exécuter plusieurs tâches simultanément. Elles doivent souvent gérer plusieurs requêtes et plusieurs utilisateurs concurrents. Ces applications doivent dès lors utiliser ce que l’on appelle un « thread ». Ce dernier est une unité d’exécution pouvant être planifiée et lancée indépendamment par le système d’exploitation. Une application peut créer et démarrer plusieurs threads à la fois. Cela rend possible l’exécution de plusieurs tâches simultanément par l’application.

Les threads sont gérés directement par le système d’exploitation, la machine virtuelle Java agit comme un intermédiaire entre l’application et le système d’exploitation. La JVM permet de masquer la complexité de la gestion des threads en fournissant un contrat simple et pratique à utiliser à travers les interfaces et classes du JDK. Les threads créés par une application ont un coût non négligeable qui peut impacter à la fois l’application et la machine hôte. En effet, pour chaque thread créé, le système d’exploitation alloue une zone mémoire dédiée où la JVM initialise une pile d’exécution pour stocker les variables locales et les métadonnées du thread. En plus, le système d’exploitation doit planifier et distribuer les ressources CPU entre tous les threads de toutes les applications lancées sur la machine hôte. Par conséquent, un nombre excessif de threads peut ralentir l’application. Il peut même monopoliser les ressources du système.

Kotlin propose une solution pour ce problème de coût des threads. Elle consiste à définir une unité d’exécution plus légère que les threads classiques. Cette unité ne nécessite pas de ressources mémoire et CPU dédiées. Plusieurs de ces unités peuvent partager le même thread système classique et ainsi partager les ressources entre elles. Ce type d’unité léger est appelée « coroutine ». Les threads virtuels introduits en Java 21 permettent aussi de répondre au même besoin.

Les coroutines sont gérées directement par Kotlin. La librairie des coroutines se charge de créer les threads, de les gérer et de distribuer l’exécution des différentes coroutines aux différents threads système. L’application peut alors créer des coroutines d’une façon illimitée pour lancer des tâches en parallèle sans avoir besoin de gérer la complexité et le coût de création et de gestion des threads.

2. Fonctionnement des coroutines

implementation("org.jetbrains.kotlinx:kotlinx-
coroutines-core:1.8.0") 

<dependency> 
    <groupId>org.jetbrains.kotlinx</groupId> 
    <artifactId>kotlinx-coroutines-core</artifactId> 
    <version>1.8.0</version> 
</dependency> 

1. Introduction

En tant que langage de la JVM, Kotlin est compatible avec toutes les librairies Java existantes. La librairie JUnit est la référence pour l’écriture des tests dans l’écosystème du langage Java. Elle peut aussi être utilisée pour écrire des tests en Kotlin. Cependant, toutes les capacités offertes par le langage Kotlin ne pourraient pas être pleinement exploitées en utilisant JUnit.

Kotest est une librairie de test alternative à JUnit. Elle est écrite entièrement en Kotlin. Elle permet d’écrire les tests d’une façon déclarative en se basant sur la puissance du langage Kotlin.

Kotest ne fournit pas de moteur d’exécution des tests. Elle se base sur le moteur de JUnit quand l’application cible la JVM.

tasks.withType<Test>().configureEach { 
    useJUnitPlatform() 
} 

testImplementation("io.kotest:kotest-runner-junit5:5.8.0") 

testImplementation("io.kotest:kotest-assertions-core:5.8.0") 

<plugin> 
   <groupId>org.apache.maven.plugins</groupId> 
   <artifactId>maven-surefire-plugin</artifactId> 
   <version>2.22.2</version> 
</plugin> 

<dependency> 
   <groupId>io.kotest</groupId> 
   <artifactId>kotest-runner-junit5-jvm</artifactId> 
   <version>5.8.0</version> 
   <scope>test</scope> 
</dependency> 

<dependency> 
   <groupId>io.kotest</groupId> 
   <artifactId>kotest-assertions-core-jvm</artifactId> 
   <version>5.8.0</version> 
   <scope>test</scope> 
</dependency> 

c. Configuration d’IntelliJ

Pour pouvoir lancer les tests directement depuis l’environnement de développement IntelliJ, il est nécessaire d’installer le plugin Kotest. Ce dernier est disponible depuis la « Marketplace » des plugins d’IntelliJ :

Après l’installation du plugin, le redémarrage de l’EDI est nécessaire.

2. Écrire des tests avec Kotest

Le framework Kotest permet d’écrire les tests unitaires en suivant plusieurs styles différents. Cependant, pour faciliter la lecture du code, il est recommandé de suivre un seul style d’écriture pour tous les tests de la même application. La majorité des styles sont inspirés par les frameworks de tests des autres langages comme JUnit pour Java, ScalaTest pour le langage Scala et Karma pour le langage JavaScript. Offrir ces différents styles avait pour but de faciliter l’adoption de Kotlin et de Kotest par les développeurs accoutumés à d’autres langages. Le framework Kotest propose aussi ses propres styles qui ont pour but de faciliter l’écriture et la lecture des tests.