Partie 1 : Introduction à Kotlin

Chapitre 1 : Qu’est-ce que Kotlin et pourquoi en ai-je besoin ?

1.1 Un aperçu de Kotlin
1.2 Principales caractéristiques de Kotlin
1.2.1 Cas d'utilisation de Kotlin : Android, serveurs, environnements d'exécution Java, et plus encore
1.2.2 Les performances, la fiabilité et la maintenabilité de Kotlin sont toutes bonnes grâce au typage statique.
Azim
1.2.3 La combinaison de la programmation fonctionnelle et de la programmation orientée objet rend Kotlin sûr et
Soyez flexible
1.2.4 Les coroutines vous permettent d'écrire du code concurrent et asynchrone de manière naturelle et structurée.
il y a
1.2.5 Kotlin peut être utilisé à toutes fins.
Kotlin est un logiciel libre, et vous
est ouvert aux contributions
1.3 Domaines d'utilisation fréquente de Kotlin
1.3.1 Support du backend : Programmation serveur Kotlin
1.3.2 Développement mobile : Android privilégie Kotlin
1.3.3 Multiplateforme : Partagez la logique métier entre iOS, JVM, JS et d'autres plateformes.
Réduisez au minimum la duplication et l'ambiguïté du code
1.4 La philosophie de Kotlin
1.4.1 Kotlin est un langage pratique
1.4.2 Kotlin est concis
1.4.3 Kotlin est sûr
1.4.4 Kotlin est interopérable
1.5 Utilisation des outils Kotlin
1.5.1 Configuration et exécution du code Kotlin
1.5.2 Compilation du code Kotlin
addition

Chapitre 2 : Les bases de Kotlin

2.1 Éléments de base : Fonctions et variables
2.1.1 Écrire votre premier programme Kotlin : Bonjour, monde !
2.1.2 Déclaration d'une fonction avec paramètres et valeurs de retour
2.1.3 Définition plus concise des fonctions à l'aide de corps d'expression
2.1.4 Déclarer des variables pour stocker les données
2.1.5 Marquage des variables comme étant en lecture seule ou réassignables
2.1.6 Formatage simplifié des chaînes de caractères : modèles de chaînes
2.2 Comportement et encapsulation des données : classes et propriétés
2.2.1 Association des classes aux données et leur accessibilité : propriétés
2.2.2 Calcul des valeurs des propriétés sans les stocker : Accesseurs personnalisés
2.2.3 Structure du code source Kotlin : répertoires et packages
2.3 Expressions de sélection et traitement : inum et when
2.3.1 Définitions des classes et constantes d'énumération
2.3.2 Gestion des classes énumérées avec when
2.3.3 Capture de la cible de l'expression when dans une variable
2.3.4 Utilisation d'objets arbitraires dans les conditions de branchement when
2.3.5 Utilisation sans arguments
2.3.6 Conversion intelligente : combinaison de la vérification de type et de la conversion de type
2.3.7 Refactorisation : Remplacer « if » par « when »
2.3.8 Utilisation des blocs dans les branches if et when
2.4 Itération cible : boucles while et for
2.4.1 Répéter du code tant qu'une condition est vraie : la boucle while
2.4.2 Itération sur les nombres : intervalles et permutations
2.4.3 Itération sur la carte
2.4.4 Inspection des éléments d'une collection ou d'une plage dans
2.5 Gestion des exceptions en Kotlin
2.5.1 Gestion des exceptions et récupération des erreurs à l'aide de try, catch et finally
2.5.2 Utilisation de try comme expression
addition

Chapitre 3 Définition et appel de fonctions

3.1 Création de collections en Kotlin
3.2 Faciliter l'appel des fonctions
3.2.1 Arguments nommés
3.2.2 Valeurs des paramètres par défaut
3.2.3 Élimination des classes utilitaires statiques : fonctions et propriétés de niveau supérieur
3.3 Ajout de méthodes à d'autres classes : fonctions d'extension et propriétés d'extension
3.3.1 Fonctions d'importation et d'extension
3.3.2 Appel de fonctions d'extension depuis Java
3.3.3 Définition des fonctions utilitaires comme fonctions d'extension
3.3.4 Les fonctions d'extension ne peuvent pas être surchargées
3.3.5 Propriétés de l'extension
3.4 Gestion des collections : arguments de longueur variable, appels de fonctions infixes et prise en charge des bibliothèques
3.4.1 Extensions de l'API Java Collection
3.4.2 Fonctions variadiques : définition de fonctions pouvant avoir un nombre variable d’arguments
3.4.3 Gestion des paires (tuples) : appels infixes et déclarations de déstructuration
3.5 Gestion des chaînes de caractères et des expressions régulières
3.5.1 Division des cordes
3.5.2 Expressions régulières et chaînes de caractères entre triples guillemets
3.5.3 Chaînes multilignes entre triples guillemets
3.6 Nettoyage du code : fonctions locales et extensions
addition

Chapitre 4 Classes, objets et interfaces

4.1 Définition de la hiérarchie des classes
4.1.1 Interfaces Kotlin
4.1.2 Modificateurs open, final et abstract : final par défaut
4.1.3 Modificateur de visibilité : public par défaut
4.1.4 Classes internes et imbriquées : Classes imbriquées par défaut
4.1.5 Classes scellées : définition d’une hiérarchie de classes avec des extensions restreintes
4.2 Déclaration d'une classe avec des constructeurs ou des propriétés non évidents
4.2.1 Initialisation de la classe : constructeur principal et bloc d’initialisation
4.2.2 Constructeurs secondaires : Initialisation de la superclasse d’une manière différente
4.2.3 Implémentation des propriétés déclarées dans une interface
4.2.4 Accès aux champs gérés par des accesseurs et des mutateurs
4.2.5 Modification de la visibilité d'un accesseur
4.3 Méthodes générées par le compilateur : classes de données et délégation de classes
4.3.1 Méthodes que chaque classe doit définir
4.3.2 Classes de données : Générer automatiquement les méthodes que chaque classe doit définir.
4.4 Mot-clé object : Déclarez une classe et créez une instance simultanément.
4.4.1 Déclaration d'objet : Créer facilement des singletons
4.4.2 Objets compagnons : emplacement des méthodes de fabrique et des membres statiques
4.4.3 Utilisation d'objets compagnons comme objets ordinaires
4.4.4 Expressions d'objets : Écriture d'alternatives aux classes internes anonymes
4.5 Ajout de la sécurité typographique sans frais supplémentaires : classes en ligne
addition

Chapitre 5 : Programmation avec Lambda

5.1 Expressions lambda et références de membres
5.1.1 Introduction aux lambdas : traiter les blocs de code comme des valeurs
5.1.2 Lambdas et collections
5.1.3 Grammaire des expressions lambda
5.1.4 Accéder aux variables dans la portée actuelle
5.1.5 Référence du membre
5.1.6 Références appelables associées aux valeurs
5.2 Utilisation des interfaces fonctionnelles de Java : méthode abstraite unique
5.2.1 Passage de lambdas comme paramètres aux méthodes Java
5.2.2 Conversion SAM : Conversion explicite des lambdas en interfaces fonctionnelles
5.3 Définition d'une interface SAM en Kotlin : interface amusante
5.4 Expressions lambda pour spécifier les objets récepteurs : with, apply, also
5.4.1 avec fonction
5.4.2 Fonction d'application
5.4.3 Exécution d'opérations supplémentaires sur les objets : également
addition

Chapitre 6 Collections et séquences

6.1 API fonctionnelle pour les collections
6.1.1 Suppression et transformation d'éléments : filtrage et mappage
6.1.2 Cumul des valeurs de collection : réduction et repliement
6.1.3 Application des prédicats aux collections : all, any, none, count, find
6.1.4 Partitionnement d'une liste en paires de listes : partition
6.1.5 Conversion d'une liste en une carte de plusieurs groupes : groupBy
6.1.6 Conversion d'une collection en map : associate, associateWith, associateBy
6.1.7 Modification des éléments d'une collection mutable : replaceAll, fill
6.1.8 Gestion des cas particuliers dans les collections : ifEmpty
6.1.9 Fractionnement d'une collection : par blocs et par fenêtres
6.1.10 Fusion de collections : zip
6.1.11 Manipulation des éléments de collections imbriquées : flatMap et flatten
6.2 Opérations de collecte paresseuses : séquences
6.2.1 Exécution des opérations séquentielles : opérations intermédiaires et finales
6.2.2 Création d'une séquence
addition

Chapitre 7 : Valeurs pouvant être nulles

7.1 Éviter l'exception NullPointerException et gérer l'absence de valeurs : la possibilité de valeurs nulles
7.2 Spécifier une variable pouvant être nulle comme un type pouvant être nul
7.3 Un examen plus approfondi de la signification des types
7.4 Combinaison de la vérification des valeurs nulles et des appels de méthode avec l'opérateur d'appel sécurisé : ?.
7.5 Attribuer une valeur par défaut à la valeur nulle avec l'opérateur Elvis : ?:
7.6 Conversion de types en toute sécurité sans lever d'exceptions : comme ?
7.7 Ce n'est pas votre affirmation : !!
7.8 fonction let
7.9 Types non nuls qui ne sont pas initialisés directement : propriétés d’initialisation paresseuse
7.10 Extensions de type sans opérateurs d'appel sécurisés : Extensions aux types nullables
7.11 Nullité des paramètres de type
7.12 Possibilité nulle et Java
7.12.1 Type de plateforme
7.12.2 Héritage
addition

Chapitre 8 Types de base, collections et tableaux

8.1 Types primitifs et de base
8.1.1 Représentation des entiers, des nombres à virgule flottante, des caractères et des valeurs booléennes sous forme de types primitifs
8.1.2 Utilisation de toute la plage de bits pour représenter les nombres positifs : types de nombres non signés
8.1.3 Types primitifs pouvant être nuls : Int?, Boolean?, etc.
8.1.4 Conversion de nombres
8.1.5 Any et Any ? : Les racines de la hiérarchie des types de Kotlin
8.1.6 Type d'unité : Vide de Kotlin
8.1.7 Type Nothing : Cette fonction ne renvoie jamais de valeur.
8.2 Collections et tableaux
8.2.1 Collections de valeurs pouvant être nulles et collections pouvant être nulles
8.2.2 Collections en lecture seule et modifiables
8.2.3 Les collections Kotlin et les collections Java sont étroitement liées.
8.2.4 Les collections déclarées en Java apparaissent comme des types de plateforme en Kotlin.
8.2.5 Création de tableaux d'objets ou de tableaux de types primitifs pour optimiser les performances et l'interopérabilité
addition

Partie 2 : Utiliser Kotlin à la manière de Kotlin

Chapitre 9 Surcharge de l'opérateur et autres conventions

9.1 Surcharge des opérateurs arithmétiques pour faciliter les opérations sur des classes arbitraires
9.1.1 Plus, multiplication, division, etc. : Surcharge des opérations arithmétiques binaires
9.1.2 Application d'une opération puis affectation directe du résultat : surcharge de l'opérateur d'affectation composée
Ding
9.1.3 Opérateurs à un seul opérande : surcharge d’opérateur unaire
9.2 Vérifiez facilement les relations entre les objets en surchargeant les opérateurs de comparaison.
9.2.1 Opérateur d'égalité : égale
9.2.2 Opérateurs d'ordre : compareTo (〈, 〉, 〈=, 〉=)
9.3 Conventions pour la rédaction des descriptions de collections et de gammes
9.3.1 Accès aux éléments par index : get et set
9.3.2 Vérification de l'appartenance d'un objet à une collection : la convention « in »
9.3.3 Création de plages à partir d'objets : les conventions rangeTo et rangeUntil
9.3.4 Boucle sur votre propre type : la convention d’itération
9.4 Fourniture de déclarations de déstructuration à l'aide de fonctions de composants
9.4.1 Déstructuration des déclarations et des boucles
9.4.2 _ Ignorer les valeurs de déstructuration utilisant des caractères
9.5 Réutilisation de la logique d'accès aux propriétés : propriétés déléguées
9.5.1 Syntaxe de base et fonctionnement interne des propriétés déléguées
9.5.2 Utilisation des propriétés déléguées : Initialisation paresseuse avec lazy()
9.5.3 Implémentation des propriétés déléguées
9.5.4 Les propriétés déléguées sont converties en propriétés cachées avec des accesseurs personnalisés.
9.5.5 Accès dynamique aux attributs par délégation à une carte
9.5.6 Comment les frameworks du monde réel utilisent les propriétés déléguées
addition

Chapitre 10 Fonctions d'ordre supérieur : Utilisation des lambdas comme paramètres et valeurs de retour

10.1 Définition de fonctions qui prennent d'autres fonctions comme arguments ou qui renvoient d'autres fonctions : Fonctions d'ordre supérieur
10.1.1 Le type de fonction spécifie les types de paramètres et le type de retour de la lambda.
10.1.2 Appel d'une fonction passée en argument
10.1.3 Utilisation des types de fonctions Kotlin en Java
10.1.4 Vous pouvez spécifier des valeurs par défaut pour les paramètres de type fonction, et celles-ci peuvent être nulles.
il y a
10.1.5 Retourner une fonction depuis une autre fonction
10.1.6 Utilisation de Lambda pour réduire la duplication et accroître la réutilisabilité du code
10.2 Éliminer la surcharge des lambdas en utilisant des fonctions en ligne
10.2.1 Fonctionnement de l'intégration en ligne
10.2.2 Restrictions relatives aux fonctions en ligne
10.2.3 Opération de collecte en ligne
10.2.4 Déterminer quand déclarer une fonction en ligne
10.2.5 Utilisation des lambdas intégrées pour la gestion des ressources avec withLock, use et useLines
10.3 Retour des lambdas : Contrôle du flux dans les fonctions d’ordre supérieur
10.3.1 Instruction de retour dans une lambda : Retour de la fonction englobant la lambda
10.3.2 Retour depuis Lambdas : Retour avec étiquettes
10.3.3 Fonctions anonymes : retour local par défaut
addition

Chapitre 11 Génériques

11.1 Création de types acceptant des arguments de type : paramètres de type générique
11.1.1 Fonctions et propriétés qui fonctionnent avec des types génériques
11.1.2 Déclarer une classe générique en utilisant la syntaxe des crochets
11.1.3 Limitation des types utilisables par les classes ou fonctions génériques : restrictions relatives aux types des paramètres
environ
11.1.4 Exclusion des arguments de type nullables en marquant explicitement les paramètres de type comme non nullables
11.2 Comportement des génériques d'exécution : paramètres de type effacés et réifiés
11.2.1 Limitations lors de la recherche d'informations de type pour les classes génériques à l'exécution : vérification de type et
Fonderie
11.2.2 Une fonction qui utilise un paramètre de type instancié renvoie l'argument de type au moment de l'exécution.
peut être mentionné
11.2.3 Remplacement des références de classe par des paramètres de type instancié dans java.lang.Class
Éviter les paramètres
11.2.4 Définition des accesseurs avec des paramètres de type réifiés
11.2.5 Contraintes sur les paramètres de type matérialisé
11.3 La variance décrit la relation de sous-type entre un générique et ses arguments de type.
11.3.1 La variance nous permet de déterminer s’il est sûr de passer des arguments à une fonction.
11.3.2 Classes, types et sous-types
11.3.3 La covariance préserve les relations de sous-type
11.3.4 La contravariance inverse les relations de sous-typage
11.3.5 Spécification de la variance au point où un type est mentionné à l'aide de la variance au point d'utilisation
11.3.6 Projection en étoile : Utilisation de * pour indiquer qu’il n’existe aucune information concernant un argument de type générique
11.3.7 Alias ​​de type
addition

Chapitre 12 Annotations et réflexions

12.1 Déclaration et application des annotations
12.1.1 Annoter les déclarations
12.1.2 Spécification des déclarations exactes auxquelles une annotation peut faire référence : Cibles d’annotation
12.1.3 Contrôle de la sérialisation JSON à l'aide d'annotations
12.1.4 Déclaration d'annotation
12.1.5 Métaannotations : Contrôle du traitement des annotations
12.1.6 Utilisation des classes comme paramètres d'annotation
12.1.7 Réception d'une classe générique en tant que paramètre d'annotation
12.2 Réflexion : Observation des objets Kotlin à l’exécution
12.2.1 API de réflexion Kotlin : KClass, KCallable, KFunction, KProperty
12.2.2 Implémentation de la sérialisation d'objets à l'aide de la réflexion
Contrôle de la sérialisation à l'aide des annotations 12,2,3
12.2.4 Analyse JSON et désérialisation d'objets
12.2.5 Étape finale de désérialisation : Création d’objets à l’aide de CallBy() et de la réflexion
addition

Chapitre 13 : Création d’un DSL

13.1 De l'API au DSL : Création de structures de code personnalisées expressives
13.1.1 Langages spécifiques à un domaine
13.1.2 Le DSL interne s'intègre parfaitement au reste du programme.
13.1.3 Structure DSL
13.1.4 Création de code HTML avec un DSL interne
13.2 Création d'une API structurée : Utilisation des lambdas pour spécifier les objets reçus dans le DSL
13.2.1 Types de fonctions lambda et d'extension pour la spécification des objets récepteurs
13.2.2 Utilisation d'une fonction lambda spécifiant un objet récepteur dans un générateur HTML
13.2.3 Générateurs Kotlin : activer l’abstraction et la réutilisation
13.3 Utilisation de la convention d'invocation pour imbriquer les blocs de manière plus flexible
13.3.1 Utilisation de la convention d'invocation pour imbriquer les blocs de manière plus flexible
13.3.2 Conventions d'appel DSL : Déclaration des dépendances Gradle
13.4 Kotlin DSL en pratique
13.4.1 Enchaînement des appels intermédiaires : Fonction « devrait » du framework de test
13.4.2 Définition des fonctions d'extension pour les types primitifs : gestion des dates
13.4.3 Fonctions d'extension de membre : un DSL interne pour SQL
addition

Partie 3 : Programmation concurrente avec les coroutines et Flow

Chapitre 14 Coroutines

14.1 Concurrence et parallélisme
14.2 Gestion de la concurrence en Kotlin : suspension des fonctions et des coroutines
14.3 Comparaison des threads et des coroutines
14.4 Fonctions pouvant mettre en pause : Fonctions de suspension
14.4.1 Le code utilisant la fonction suspend apparaît séquentiel.
14.5 Comparaison des coroutines avec d'autres approches
14.5.1 Appel de la fonction Suspend
14.6 Découverte du monde des coroutines : générateur de coroutines
14.6.1 Du code classique au monde des coroutines : la fonction runBlocking
14.6.2 Création d'une coroutine « lancer et oublier » : la fonction de lancement
14.6.3 Opérations en attente : Générateurs asynchrones
14.7 Choisir où exécuter le code : le répartiteur
14.7.1 Sélection d'un répartiteur
14.7.2 Transmission d'un répartiteur à un constructeur de coroutines
14.7.3 Modification du répartiteur dans une coroutine à l'aide de withContext
14.7.4 Les coroutines et les dispatchers ne sont pas une solution magique aux problèmes de sécurité des threads.
Non
14.8 Les coroutines contiennent des informations supplémentaires dans leur contexte de coroutine.
addition

Chapitre 15 Concurrence structurée

15.1 La portée des coroutines établit une structure entre les coroutines.
15.1.1 Création d'une portée de coroutine : la fonction coroutineScope
15.1.2 Association d'une portée de coroutine à un composant : CoroutineScope
15.1.3 Risques liés à GlobalScope
15.1.4 Contextes de coroutines et concurrence structurée
15.2 Annulation
15.2.1 Déclencheur d'annulation
15.2.2 Annulation automatique de l'appel après dépassement du délai imparti
15.2.3 L'annulation se propage à toutes les coroutines enfants.
15.2.4 Une coroutine annulée lève une CancellationException à un point particulier.
15.2.5 L'annulation est coopérative
15.2.6 Vérification de l'annulation d'une coroutine
15.2.7 Donner une chance aux autres coroutines : la fonction Yield
15.2.8 Tenez compte des annulations lors de l'acquisition de ressources
15.2.9 Le framework peut annuler pour vous.
addition

Chapitre 16 Flux

16.1 Les modèles de flux représentent un flux de valeurs continues.
16.1.1 Flow vous permet de traiter les éléments dès leur émission.
16.1.2 Différents types de flux Kotlin
16.2 Flux froid
16.2.1 Création d'un flux froid à l'aide de la fonction de création de flux
16.2.2 Le flux froid n’effectue aucun travail tant qu’il n’est pas collecté.
16.2.3 Annuler la collecte de flux
16.2.4 Mise en œuvre interne du flux froid
16.2.5 Flux simultanés utilisant des flux de canal
16.3 Flux chaud
16.3.1 Un flux partagé diffuse des valeurs aux abonnés.
16.3.2 Suivi de l'état du système : Flux d'état
16.3.3 Comparaison du flux d'état et du flux partagé
16.3.4 Flux chaud, flux froid, flux partagé, flux avec état : quand utiliser quel flux ?
addition

Chapitre 17 Opérateurs de flux

17.1 Manipulation du flux avec les opérateurs de flux
17.2 Des opérateurs intermédiaires sont appliqués au flux amont et renvoient le flux aval.
17.2.1 Émission de valeurs aléatoires pour chaque élément en amont : la fonction de transformation
17.2.2 Les opérateurs de prise et les opérateurs associés peuvent annuler le flux
17.2.3 Activation de chaque étape du flux : onStart, onEach, onCompletion, onEmpty
17.2.4 Mise en mémoire tampon des éléments pour les opérateurs et collecteurs en aval : l’opérateur de mémoire tampon
17.2.5 Opérateur qui ignore les valeurs intermédiaires : opérateur de fusion
17.2.6 Opérateur de filtrage des valeurs sur une période de temps : opérateur de rebond
17.2.7 Modification du contexte de coroutine dans lequel un flux est exécuté : l’opérateur flowOn
17.3 Création d'opérateurs intermédiaires personnalisés
17.4 L'opérateur final exécute le flux en amont et calcule la valeur.
17.4.1 Le framework fournit des opérateurs personnalisés.
addition

Chapitre 18 Gestion des erreurs et tests

18.1 Gestion des erreurs levées à l'intérieur des coroutines
18.2 Propagation des erreurs dans les coroutines Kotlin
18.2.1 Une coroutine qui annule tous les enfants si un enfant échoue.
18.2.2 La concurrence structurée n'affecte que les exceptions qui étendent la portée de la coroutine.
18.2.3 Les superviseurs veillent à ce que les parents et les frères et sœurs ne soient pas annulés.
18.3 CoroutineExceptionHandler : un dernier recours pour la gestion des exceptions
18.3.1 Différences entre l'application de CoroutineExceptionHandler à launch et async
18.4 Gestion des exceptions dans Flow
18.4.1 Gestion des exceptions en amont avec l'opérateur Catch
18.4.2 Nouvelle tentative de traitement de la collection de flux lorsque le prédicat est vrai : l’opérateur de nouvelle tentative
18.5 Coroutines et tests de flux
18.5.1 Écriture rapide de tests à l'aide de coroutines : temps virtuel et répartiteur de tests
18.5.2 Essai de débit avec turbine
addition

Annexe A Création d'un projet Kotlin
Annexe B : Documentation du code Kotlin
Annexe C : Écosystème Kotlin

◈ Ce que ce livre aborde ◈

◆ Guide des membres de l'équipe Kotlin
◆ Langage spécifique au domaine (DSL)
◆ Coroutines et flux Kotlin

◈ Public cible de ce livre ◈

Ce livre s'adresse principalement aux développeurs ayant une certaine expérience de Java.
Kotlin s'appuie sur de nombreux concepts et techniques présents en Java, et ce livre tire parti des connaissances existantes des lecteurs pour les aider à apprendre rapidement Kotlin.

Les lecteurs ayant déjà une expérience d'autres langages de programmation, tels que C# ou JavaScript, auront besoin d'autres ressources pour comprendre les subtilités de l'interaction de Kotlin avec la JVM, mais ils peuvent tout de même utiliser ce livre pour apprendre Kotlin.
Ce livre couvre l'intégralité du langage Kotlin et ne se concentre sur aucun domaine problématique spécifique.
Cela sera donc utile aux développeurs de serveurs, aux développeurs Android, ou à tout développeur créant des projets fonctionnant sur la JVM.

◈ Note de l'auteur ◈

L'idée du langage Kotlin a vu le jour chez JetBrains en 2010.
À l'époque, JetBrains était une entreprise réputée et relativement prospère qui fournissait des outils de développement pour divers langages tels que Java, C#, JavaScript, Python, Ruby et PHP.
Le produit phare de JetBrains, l'environnement de développement intégré Java IntelliJ IDEA, inclut également des plugins pour faciliter le développement en Scala et Groovy.

Notre expérience en matière de développement d'outils pour une gamme aussi diversifiée de langages nous a permis d'acquérir une perspective et une compréhension uniques de l'ensemble du paysage des langages de programmation.
Et tous les environnements de développement intégrés (IDE) qui utilisent IntelliJ comme plateforme, y compris IntelliJ IDEA lui-même, ont été développés en Java.
Nous envions tellement nos collègues de l'équipe .Net qui développaient en C#, un langage moderne, puissant et en constante évolution, mais nous ne trouvions aucun langage capable de remplacer Java.
Quelles étaient nos exigences pour un langage destiné à remplacer Java ?

La première et la plus évidente des exigences était le typage statique.
Il n'existe pas d'autre moyen de développer une base de code de plusieurs millions de lignes sans devenir fou, si ce n'est le typage statique.
Deuxièmement, nous avions besoin d'un langage entièrement compatible avec le code Java existant.
Notre base de code existante est un atout incroyablement précieux pour JetBrains, et nous ne pouvions pas nous permettre de la perdre ou de voir sa valeur diminuée en raison d'un manque d'interopérabilité.
Troisièmement, nous ne voulions pas faire de compromis sur la disponibilité des outils.
Pour JetBrains, la valeur la plus importante est la productivité du développement, et atteindre une productivité élevée nécessite d'excellents outils.
Enfin, il nous fallait un langage facile à apprendre et dont le code permette de comprendre aisément le fonctionnement.

Au moment où nous avons constaté ce besoin non satisfait au sein de notre entreprise, nous avons réalisé que certaines entreprises se trouvaient dans une situation similaire.
Par conséquent, nous pouvions nous attendre à ce que si nous parvenions à créer une solution répondant aux besoins de JetBrains, nous trouvions davantage d'utilisateurs en dehors de JetBrains.
C’est dans cette optique que nous avons décidé de lancer un projet visant à créer un nouveau langage : Kotlin.

La période de développement du langage a été plus longue que prévu initialement, et Kotlin 1.0 a été publié plus de cinq ans après le premier commit sur le dépôt.
Depuis, Kotlin a trouvé une base d'utilisateurs qui le désire, et son propre écosystème s'est magnifiquement développé, et cette progression se poursuit encore aujourd'hui.

Kotlin est basé à Saint-Pétersbourg, en Russie.
C'est le nom d'une île près de Saint-Pétersbourg.
Le choix du nom de l'île s'inscrit dans les traditions des langues javanaise et ceylanaise.

À l'approche de la sortie officielle de Kotlin, j'ai pensé qu'il serait utile d'avoir un livre écrit par des personnes ayant participé à la conception du langage et capables d'expliquer avec assurance pourquoi ses fonctionnalités sont telles qu'elles sont.
Ce livre s'inscrit dans cette démarche, et j'espère que les lecteurs apprendront et comprendront mieux le langage Kotlin grâce à lui.
Bonne chance et j'espère que vous prendrez toujours plaisir à développer.

◈ Note du traducteur ◈

En 2017, lors de la traduction de la première édition de ce livre, Kotlin commençait à être utilisé sérieusement sur Android, et les concepts de programmation fonctionnelle s'intégraient lentement dans le monde des langages de programmation grand public grâce à Scala, Hadoop et d'autres.
La « Note du traducteur » de la première édition devait donc expliquer en détail le contenu concerné.
Cependant, avec le temps, Kotlin s'est solidement implanté dans la programmation Android, le nombre de développeurs et d'entreprises utilisant Kotlin dans la programmation serveur a considérablement augmenté, et le concept de programmation fonctionnelle s'est également solidement établi dans une certaine mesure. Je pense donc qu'il n'est plus nécessaire d'expliquer les caractéristiques ou les avantages du langage Kotlin et ceux de la programmation fonctionnelle.
Tout développeur qui prendra ce livre en main sera prêt à tomber amoureux du langage rien qu'en entendant le nom Kotlin.

Kotlin ne se contente plus d'être un meilleur remplaçant de Java sur la JVM, mais s'impose désormais comme un langage de programmation autonome, doté de son propre framework de programmation concurrente et d'une prise en charge multiplateforme.
Grâce à ce livre, vous pourrez apprendre la philosophie et la grammaire de base du langage Kotlin, le traitement des collections à l'aide de techniques de programmation fonctionnelle de base, les méthodes de développement DSL internes et d'API riches utilisant les fonctionnalités de support DSL du langage Kotlin, ainsi que la programmation concurrente/parallèle à l'aide des coroutines Kotlin et de Flow.
Vous apprendrez également à utiliser Java et Kotlin ensemble dans vos projets sur la JVM.
Les développeurs qui auront acquis de solides bases en Kotlin grâce à ce livre seront capables d'utiliser Kotlin dans divers domaines, tels que le développement d'applications multiplateformes via Compose Multiplatform ou le développement de serveurs à architecture propre intégrant des bibliothèques Java telles que Spring.
Par exemple, Mobility42, où travaille le traducteur, a développé sa propre bibliothèque multiplateforme Kotlin et l'utilise pour développer diverses applications telles que des serveurs (modélisation de bases de données à l'aide de sa propre bibliothèque serveur basée sur Spring et d'un DSL interne), des applications web (JavaScript + sa propre bibliothèque de composants développée) et Compose Desktop.

J’espère sincèrement que grâce à ce livre, Kotlin deviendra un outil que vous pourrez utiliser confortablement au travail, comme une massue bien conçue qui tient parfaitement dans la main.
Et j'espère que le gain de productivité que vous obtiendrez grâce à Kotlin vous permettra de profiter de soirées plus tranquilles.