Kotlin
A concise multiplatform language developed by JetBrains
Premiers pas avec Kotlin pour les développeurs Java
Article de notre invité Urs Peter, Ingénieur logiciel senior et Formateur Kotlin certifié JetBrains. Pour les lecteurs qui souhaitent une approche plus structurée pour développer leurs compétences en Kotlin, Urs anime également le Kotlin Upskill Program à la Xebia Academy.
Cet article est le premier d’une série intitulée Guide complet pour réussir l’adoption de Kotlin dans un environnement Java, qui explique concrètement comment l’adoption de Kotlin peut être progressivement déployée au sein d’une équipe, en partant de la curiosité d’un développeur pour aboutir à une transformation à l’échelle de l’entreprise.
« Passer à Kotlin ne se fait pas du jour au lendemain.
On élimine les risques, on mesure, on célèbre les victoires,
et seulement alors on double la mise. »
Adopter Kotlin dans un environnement Java existant n’est pas qu’une décision technique. C’est un parcours qui requiert une planification minutieuse, une réflexion stratégique, et surtout, l’obtention de l’approbation et du soutien de vos pairs.
Ayant formé plus de 1 000 développeurs et aidé de nombreuses organisations à réussir leur transition vers Kotlin, j’ai vu ce qui fonctionne et ce qui ne fonctionne pas. Ce guide vous présentera pas à pas des recettes éprouvées pour adopter Kotlin, que j’ai collectées au fil du temps, depuis les premières expérimentations jusqu’à la transformation d’organisations à grande échelle.
Voici le parcours que nous allons suivre dans cette série :
- Tout commence par une étincelle, et c’est vous qui l’allumez !
- L’étape d’expérimentation : commencez petit, avec des tests
- L’étape d’évaluation : au-delà de l’expérimentation avec Kotlin
- Faire passer le message : convaincre vos collègues développeurs
- Convaincre la direction : créez une analyse de rentabilité pour Kotlin
- Facteurs de réussite pour l’adoption de Kotlin à grande échelle
- Kotlin ou pas Kotlin : quel type d’entreprise voulez-vous être ?
Tout commence par une étincelle, et c’est vous qui l’allumez !
Pourquoi faire l’effort de passer à Kotlin ? Pourquoi ne pas simplement continuer d’utiliser Java et passer sa route ?
La réponse dépend de nombreux facteurs. Bien que les données démontrent clairement les avantages de Kotlin dans de multiples domaines, la décision n’est pas purement technique. La subjectivité (« J’aime mon langage parce que je l’aime ») et le scepticisme face à la nouveauté, qui est généralement une bonne chose, jouent un rôle important.
L’évolution des langages de programmation démontre toutefois que nos préférences et nos besoins évoluent avec le temps. Chaque nouvelle génération de langages intègre de nouveaux paradigmes – sécurité (null), syntaxe concise et légère, fonctions de première classe, bibliothèques standard riches, concurrence asynchrone, prise en charge multiplateforme, compatibilité avec l’IA générative, etc. – qui offrent des avantages décisifs aux développeurs et aux organisations.
Sans cette évolution naturelle, nous utiliserions encore tous COBOL ou un autre langage archaïque, incapable de répondre aux exigences actuelles. L’évolution n’est donc pas une option ; elle est inscrite dans l’histoire de notre secteur d’activité.
Mais les avantages techniques à eux seuls ne suffisent pas pour que de tels changements s’enracinent dans une entreprise. Cela nécessite des facilitateurs, des personnes désireuses d’explorer, de défendre et de démontrer la valeur de ces nouveaux paradigmes en pratique. Mon expérience m’a montré que trois types d’ingénieurs deviennent généralement ces catalyseurs pour l’adoption de Kotlin :
- Le développeur Java pragmatique et axé sur la productivité : des développeurs expérimentés qui considèrent Java comme un outil, pas une religion. Ils cherchent toujours de meilleures façons d’effectuer le travail plus rapidement.
- Le passionné des langages modernes qui recherche avant tout la qualité : les ingénieurs qui privilégient un code lisible, concis et maintenable. Ce sont souvent les mêmes personnes qui seraient passées à Scala par le passé.
- Le développeur junior qui posent simplement la question : « Pourquoi devrais-je utiliser Java si je peux utiliser Kotlin ? » N’ayant pas des années d’expérience en Java, Kotlin leur apparaît souvent une évidence.
À quel groupe appartenez-vous ?
Ces utilisateurs précoces initient la première étape vers le changement. Mais par où commencer ? Poursuivez la lecture… ;-)
L’étape d’expérimentation : commencez petit, avec des tests
Vous avez entendu parler de Kotlin et vous souhaitez l’essayer sans vous engager pour le moment.
La première chose dont vous avez besoin, c’est d’un outil de développement qui puisse vous aider à planter vos premières graines Kotlin. Voici quelques possibilités :
- https://play.kotlinlang.org/ est un excellent terrain de jeu en ligne qui permet de saisir et d’exécuter du code Kotlin non seulement sur la JVM, mais aussi pour plusieurs autres plateformes (JS, WASM, etc.).
- Kotlin Notebook est une fonctionnalité puissante pour IntelliJ IDEA qui vous permet d’importer facilement des dépendances, d’exécuter du code, et même de travailler avec des données, de créer des graphiques, etc. Voici un exemple qui montre à quel point il est facile de réaliser un appel REST avec le RestClient de Spring :
- IntelliJ IDEA offre une prise en charge de premier ordre pour Kotlin. Cela n’est pas surprenant, puisque JetBrains est le créateur de Kotlin, et qu’une grande partie d’IntelliJ IDEA est écrite dans ce langage. Alors, commencer à utiliser Kotlin dans IntelliJ IDEA (même dans votre projet Java existant) est un vrai jeu d’enfant :
…Et c’est parti !
- Et ce n’est pas tout ! JetBrains a récemment publié le Kotlin Language Server, qui apporte une expérience de développement Kotlin complète dans d’autres IDE qu’IntelliJ IDEA, comme VS Code. Voyez par vous-même : https://github.com/Kotlin/kotlin-lsp
Maintenant, vous pouvez écrire en Kotlin dans votre environnement de développement préféré. Comment évaluer le langage dans une situation réelle avec un impact minimal tout en obtenant un maximum d’informations ? Dans la suite de tests d’un projet Java existant !
Cette approche sûre et réaliste pour expérimenter avec Kotlin offre plusieurs avantages :
- Faible risque : les tests n’affectent pas le code de production.
- Opportunité d’apprentissage : vous pouvez explorer les fonctionnalités du langage dans un contexte familier.
- Introduction progressive : les membres de l’équipe peuvent se familiariser avec la syntaxe de Kotlin sans pression.
Astuces
- Essayez Kotest + MockK : pour ressentir immédiatement l’expressivité des DSL (Domain-Specific Language) de tests de Kotlin, comme les assertions riches en fonctionnalités (
shouldHaveSize(…), infix (value shouldBe 1), etc. - Utilisez la puissance et la concision de Kotlin Collections plutôt que Java Streams.
- Expérimentez avec les diverses fonctionnalités du langage comme les types nullables, la déstructuration, l’immutabilité (
val,data classes), les constructions d’expressions (when,try-catch,if else), et bien plus encore.
Voici ce que vous obtenez :
Java
@Test
void shouldGetAverageRating() {
when(productRepository.findAll()).thenReturn(products);
Map ratings = productService.averageRatings();
assertAll(
() -> assertThat(ratings).hasSize(4),
() -> assertEquals(ratings, products
.stream()
.collect(Collectors.groupingBy(
Product::getName,
Collectors.flatMapping(
p -> p.getRatings()
.stream()
.mapToDouble(Integer::doubleValue)
.boxed(),
Collectors.averagingDouble(Double::doubleValue)
)))
)
);
verify(productRepository).findAll();
}
Kotlin
@Test
fun `should get average rating`() { //descriptive tests using ``
every { productRepository.findAll() } returns products
val ratings = productService.averageRatings()
assertSoftly(ratings) { //powerful testing DSLs (Kotest)
shouldHaveSize(4)
this shouldBe productRepository.findAll()
.groupBy { it.name } //concise collections
.mapValues { (_, products) -> //destructuring
products.flatMap { it.ratings }.average() }
}
verify { productRepository.findAll() }
}
Suite de la série
L’adoption de Kotlin commence généralement par une personne qui l’essaie et quelques tests qui prouvent son utilité. Ces premiers moments de découverte mènent naturellement à quelque chose de plus conséquent : évaluer Kotlin dans un projet concret.
Le prochain article de cette série décrira cette étape et expliquera comment tester Kotlin dans des environnements de production.
Auteur de l’article original en anglais :
Subscribe to Kotlin Blog updates
