Bienvenue dans ce cours dédié à Kotlin, le nouveau langage de programmation destiné principalement aux plateformes de développement Java.
L’objectif de ce cours est de vous initier progressivement à Kotlin, afin que vous puissiez apprécier (ou non… ;)) toutes les possibilités qu’offre ce langage vis-à-vis de Java.
Quoi ? Mais je ne comprends pas ? Pourquoi le compare-t-on à Java ?
Tout simplement car Kotlin et Java sont 100 % interopérables, c’est-à-dire que vous pourrez, sur un même projet, écrire du code source en Java ET en Kotlin… :) Vous pourrez appeler en Java des méthodes créées en Kotlin, et inversement. Plutôt sympa, non ?
Les origines de Kotlin
Remontons à la nuit des temps… enfin presque ! En réalité, c’est en 2010 que l’idée de Kotlin naît dans la tête des ingénieurs de l’entreprise JetBrains (le fameux éditeur de l’IDE IntelliJ, servant de base notamment à Android Studio).
Ces derniers, voyant les limitations de conception que le langage Java causait sur le développement de leurs différents produits, se sont mis à chercher un langage alternatif viable et pérenne, avec cependant une obligation : il devra être 100 % compatible avec le code Java existant.
Eh oui, impossible pour JetBrains de repartir de zéro sur tous leurs projets Java existants, tellement ces derniers sont volumineux (on parle de plusieurs millions de lignes de code !).
Après avoir essayé sans succès d’autres langages compatibles avec la JVM, par exemple Scala (mais son temps de compilation était trop long), les ingénieurs de JetBrains firent le pari fou… de créer leur propre langage ! :D #ChacunSonNiveau
Ainsi, 5 ans après, la première version stable de Kotlin (1.0) sortait, et celle-ci fut rendue disponible de manière open source sur GitHub.
La philosophie de Kotlin
Tout beau projet est motivé par une certaine philosophie, une certaine envie, et Kotlin n’échappe pas à cette règle. En effet, Kotlin se veut concis, sûr, pragmatique et 100 % interopérable avec Java.
Avec Kotlin, vous serez plus productif et plus serein face à certains types d’erreurs récurrentes en Java, comme la célèbre "NullPointerException". Du fait de sa quasi parfaite compatibilité avec Java, Kotlin peut être utilisé dans la création d’application mobile native sur Android, mais également dans la création d’application web (J2EE), par exemple.
Bref, partout où Java est présent, Kotlin peut être utilisé. :magicien:
Mais c’est super ! En revanche, comment cela se passe-t-il sous le capot ?
Bonne question ! Quand vous développez en Java, votre classe (.java) va être compilée par le compilateur Java (présent dans votre IDE) qui la transformera en un fichier (.class) contenant votre code compilé (le fameux bytecode).
Eh bien, avec Kotlin, la même chose se produit, à la différence que le code à compiler sera écrit en Kotlin, et non en Java… ;) Cependant, le code compilé (bytecode) par le compilateur Kotlin (kotlinc) restera exactement le même !
Un langage statiquement typé
Comme Java, Kotlin est un langage de programmation dit "statiquement typé", ou "Statically typed", en anglais.
Euh d’accord… Cela veut dire que l’on peut utiliser le mot clé static , non ? :D
Loupé, c’était un piège ! :) En fait, "statiquement typé" veut dire que le type (Integer, String, Boolean, etc.) de chaque variable d’un programme est connu au moment de la compilation. C’est notamment ce processus qui permet à votre IDE de vous faire part de son mécontentement via une belle erreur rouge, quand vous tentez d’additionner un nombre avec une chaîne de caractères, par exemple…
Mieux vaut être alerté tout de suite par notre IDE, que plus tard par notre application qui plante, non ? :p
Ce type de langage se différencie des langages "dynamiquement typés", dans lesquels vous pouvez définir des variables ou des fonctions qui stockent ou retournent des données de n’importe quel type, qui seront résolues uniquement au moment de l’exécution de votre programme. Ce type de langage a l’avantage d'accélérer le temps de développement d’un programme du fait que le code à produire est plus court. À l’inverse, il demandera plus de mémoire lors de son exécution pour résoudre en temps réel le type de ses variables.
Aaah, j’ai compris ! Mais pourquoi tu nous racontes tout cela ?
Tout simplement car les développeurs de JetBrains, afin d’améliorer la lisibilité de Kotlin, se sont inspirés de ce "typage dynamique" pour l’intégrer à leur langage, bien que ce dernier soit "statiquement typé"... ;)
Pour vous donner un exemple :
val zero = 0
val message = "Hello, world!"
fun sayHello() = "Hello, everyone!"C’est beau, n’est-ce pas ? En fait, tout va se jouer du côté du compilateur Kotlin, qui va "déduire" automatiquement le type de vos variables. On appelle cela "l’inférence de type" (ou "type inference", en anglais). Ne vous en faites pas, nous en parlerons en détail dès le prochain chapitre.
Pour résumer, un langage "statiquement typé" comme Kotlin (ou Java) présente plusieurs avantages majeurs, comme :
Performance : Comme les types sont connus au moment de la compilation, pas besoin de les "déduire" au moment de l’exécution du programme.
Fiabilité : Le compilateur vous indique beaucoup plus d’erreurs au moment de la compilation, minimisant les chances que votre application crashe durant son exécution.
Efficacité : Un langage statiquement typé permet de réaliser beaucoup plus facilement des "refactorings" et permet également la mise en place d’outils performants au sein de l’IDE, comme "l’autocomplétion".
Un langage fonctionnel
Depuis le temps que vous utilisez Java, vous devriez être habitué à la programmation orientée objet. Kotlin est lui aussi un langage orienté objet, avec cependant une petite particularité : c’est aussi un langage dit "fonctionnel".
Je suppose que cela ne veut PAS dire que c’est un langage qui... fonctionne ? :)
Non, en effet ! Voici quelques éléments qui caractérisent un langage de programmation fonctionnel :
First-class function : Derrière cet affreux anglicisme, on retrouve la notion caractérisant le fait que nous pouvons utiliser, dans notre code, des fonctions en tant que valeurs. Nous pourrons par exemple stocker des fonctions dans des variables, passer en paramètres des fonctions, ou encore retourner des fonctions ! Nous le verrons plus en détail dans le chapitre traitant des lambdas… ;)
Immuabilité : L’approche fonctionnelle encourage l’utilisation de variables dites "immuables", c’est-à-dire que leur état ne pourra pas changer après leur création (donc une fois que la variable est créée et instanciée, nous ne pourrons pas modifier son contenu). Cette technique permet d’améliorer la fiabilité et les performances d’un programme, en le rendant notamment résistant aux problèmes liés au multi-threading (comme l’accès et la modification simultanés d’une même variable dans différents threads), par exemple. Nous traiterons ce phénomène dès le prochain chapitre.
Aucun effet de bord : En utilisant uniquement des fonctions dites “pures”, on s’assure que le résultat retourné sera toujours le même. Qu’importe le nombre de fois où la fonction est appelée, celle-ci ne modifiera que ses propres variables locales, et n’aura donc aucun effet indésirable (ou inattendu) sur d’autres variables plus globales de votre application. Nous aborderons cela plus en détail sur le chapitre dédié aux fonctions.
Alors, vous commencez à ressentir la puissance et la flexibilité de ce langage ? :) Eh bien, accrochez-vous fermement à votre clavier, la suite arrive dès le prochain chapitre !
En résumé
Kotlin a été développé par JetBrains dans l’objectif de pallier les limitations qu’imposait Java dans le développement de ses différents produits.
Kotlin est un langage de programmation qui se veut "concis", "sûr", "pragmatique" et "100 % interopérable avec Java".
Kotlin est un langage de programmation "statiquement typé" supportant néanmoins "l’inférence de type" grâce à son compilateur.
Kotlin supporte la "programmation orientée objet" et la "programmation fonctionnelle".
Kotlin est open source, supporte la plupart des IDE et fonctionne sur la majorité des plateformes Java actuelles (où le bytecode JVM est accepté).
Maintenant que vous connaissez l'histoire de Kotlin, découvrons dans le chapitre suivant comment déclarer et initialiser des variables. :)
