Welcome
Who we are
We design payments technology that powers the growth of millions of businesses around the world. Engineering the next frontiers in payments technology
- Leader in payment and secured transactions
- Over 50 billion transactions/year
- 7000+ engineers in over 40 countries
- A huge & diverse tech-stack
Prerequisites
- Basic knowledge of object-oriented language like Java
- Prepare your development environment and install stuff before the session (see Tooling section)
Useful links
',10)]))}const p=i(l,[["render",s],["__file","index.html.vue"]]),c=JSON.parse(`{"path":"/","title":"Welcome","lang":"en-US","frontmatter":{"home":true,"heroImage":"./kotlin_logo.png","tagline":"A beginner's guide to a modern programming language","actions":[{"text":"Get started →","link":"/en/presentation/","type":"primary"}],"features":[{"title":"Language features","details":"null safety, extensions, lambdas, Java interoperability and more"},{"title":"Backend development","details":"With Ktor, spring and NodeJS"},{"title":"Frontend development","details":"Compose multiplatform, Kotlin/JS, Kotlin/WASM and JVM frameworks"},{"title":"Cross-platform development","details":"With KMP and Compose multiplatform"},{"title":"Advanced Kotlin","details":"Coroutines, delegates, Function literal with receiver, DSLs and more"},{"title":"Practical exercises and solutions","details":"All chapters have a set of exercises"}],"footer":"Worldline, 2023"},"headers":[{"level":2,"title":"Who we are","slug":"who-we-are","link":"#who-we-are","children":[]},{"level":2,"title":"Prerequisites","slug":"prerequisites","link":"#prerequisites","children":[]},{"level":2,"title":"Useful links","slug":"useful-links","link":"#useful-links","children":[]}],"git":{"updatedTime":1729869737000,"contributors":[{"name":"yostane","email":"1958676+yostane@users.noreply.github.com","commits":1}]},"filePathRelative":"index.md"}`);export{p as comp,c as data}; diff --git a/assets/index.html-2LK4oqoY.js b/assets/index.html-2LK4oqoY.js new file mode 100644 index 0000000..fa29d96 --- /dev/null +++ b/assets/index.html-2LK4oqoY.js @@ -0,0 +1,13 @@ +import{_ as e,c as a,a as s,o as t}from"./app-Djq7wF8p.js";const i={};function l(c,n){return t(),a("div",null,n[0]||(n[0]=[s(`📚 Advanced and other Kotlin features
Delegated properties
Kotlin allows to delegate the getter and setter of a property to another object, which is called a delegate. It is a class that defines the getValue and setValue methods.
Kotlin provides standard delegates such lazy properties and observable properties.
▶️ this code illustrates delegate properties.
Concurrency and Coroutines
Kotlin provides a high level concurrency model called Coroutines. The developer can delegated the management of threads to the compiler and runtime and using higher level constructs than threads to express asynchronous operations.
Coroutines in Kotlin revolve around these concepts:
- A coroutine is an instance of suspendable computation.
- Kotlin has many methods for creating a coroutine such as
launch.
- Kotlin has many methods for creating a coroutine such as
- A coroutine must exist within a coroutine scope.
- For example
runBlockingcreates a coroutine scope whithin which coroutines can be launched.
- For example
- A coroutine can run suspend functions which can suspend the coroutine but do not block the thread.
- For example: the
delaysuspend the coroutine but does not block the thread on which it is running. - Suspend functions are operations that may take time such http requests and file system calls.
- For example: the
- The
suspendqualifier defines a suspend function. It runs within a coroutine and can call other suspend functions. Flowallows to generate a list of asynchronous values.DeferredandChanneltransfer a single value and a stream of values, respectively, between coroutines.
▶️ this code show how to create a coroutine and suspend function and how to use them.
▶️ this code illustrated flows.
▶️ this code illustrates channels and deferred.
Function literal with receiver and Type-safe builders
As seen previously, function extension add behavior to existing classes. Inside the definition of the function extension, we can reference the extension receiver (or this) implicitly.
fun String.countCharacters() = length // or this.length
+println("hello".countCharacters()) // prints 5
+We can define this extension with a function literal (or lambda) in instead of a named function (declared with fun).
var extFn: String.() -> Int
+extFn = { length } // extFn is a function literal
+println("hello".extFn()) // prints 5
+println(extFn("hello")) // prints 5
+extFn is a function literal (lambda) that has access to the receiver (this). That's why it's called a function literal with receiver.
extFn("hello") or extFn("hello") call the extension as expected from extension functions.
The type of a function literal with receiver is funName: ReceiverType.(arg1Type, arg2Type, etc.) -> ReturnType and is called with funName(receiverValue, arg1Value, etc.) or receiverValue.funName(arg1Value, etc.). However, this is not the interesting aspect.
The important part is extFn = { length } which can be put as a function argument in a higher order function. The developer that calls the higher order function must define extFn, which in turn has access to the receiver. This allows for a nice style of programming. ▶️ this code shows an example.
Type-safe builders combine well-named builder functions and functions literals with receiver to create type-safe, statically typed builders in Kotlin.
Builder pattern
The builder pattern is a way to construct complex objects.
// StirngBuilder uses the builder pattern
+val text = StringBuilder("Temp")
+ .append(1)
+ .append(true)
+ .append("friend")
+ .toString()
+This code shows a basic type-safe builder.
Kotlin docs provides an example of an advanced type-safe builder that builds an HTML page.
🧪 Exercises
Exercise 1
- open the java-integration-exercise projects in the materials folder.
- Have a look at the Java class we provided you in the
src/main/java/com/worldline/learning/kotlin/java2kotlinpackage. (yes, that's the Pokemon class) - Convert that Java class in Kotlin using IntelliJ's awesome copy-pasta tool! (just copy paste the java code in a kotlin file, one is provided at
src/main/kotlin/com/worldline/learning/kotlin/java2kotlin) - Have a look at the generated Kotlin code, and note the major differences you spot!
📚 Fonctionnalités du langage Kotlin
Kotlin est un langage qui support les paradigmes orienté objet et fonctionnel. Ce chapitre couvre les caractéristiques basiques et intermédiaires. Le chapitre suivant couvrira les fonctionnalités avancées.
Caractéristiques de base
Constructions de base (variables, flux de contrôle)
- Kotlin est typé statiquement et prend en charge le typage implicite.
- Typage statique : les types ne peuvent pas changer à l'exécution (c'est l'inverse du typage dynamique).
- Typage implicite : le compilateur peut inférer le type tant que c'est possible.
varcrée des variables ré-assignables.valcrée des variables qu'on ne peut plus ré-assigner.- Les points-virgules sont facultatifs.
- Kotlin prend en charge la déclaration de haut niveau des variables et des fonctions (elles peuvent être déclarées en dehors des classes).
- L'interpolation de chaîne de caractères est disponible avec cette syntaxe
\${expression}. ifetwhensont des expressions (elles peuvent renvoyer une valeur).whenest équivalent à l'instructionswitchdes autres langages- L'opérateur ternaire n'est pas disponible. L'expression
ifle remplace.
- for-each est le seul type de boucle for disponible.
- La programmation orientée objet est prise en charge comme en Java avec quelques fonctionnalités supplémentaires telles que les extensions.
- Le compilateur prend en charge la Null Safety. Il permet d'écrire du code sans erreur de pointeur nulle vérifié à la compilation.
- La programmation fonctionnelle est prise en charge (fonctions d'ordre supérieur et fonctions en tant qu'éléments de 1ère classe, etc.).
Utiliser val par défaut
Utiliser var uniquement si vous réassignez une variable ou argument.
▶️ this code highlights the above features.
Les fonctions
Dans cette section, les termes 'argument' et 'paramètre' sont utilisés de manière interchangeable.
Les fonctions de Kotlin ont les caractéristiques suivantes :
- Déclaration :
fun functionName(arg1 : type1 = defaultvalue1, ...) : retunrType. - Appeler une fonction en passant la valeur dans l'ordre de déclaration.
- Utilisez des étiquettes d'argument pour plus de clarté, cependant, cela permet également un classement arbitraire des arguments.
- Les arguments optionnels ont une valeur par défaut et peuvent être omis lors de l'appel.
- Les fonctions sont des éléments de première classe ou citoyens : elles peuvent être affectées à une variable, passées en tant que paramètre de fonction ou renvoyées par une fonction.
- 💡 Une fonction qui prend une fonction comme argument ou en renvoie une est une fonction d'ordre supérieur.
- Un type de fonction peut être exprimé comme suit :
(typeOfParam1, typeOfParam2, etc) -> returnType(Le type de retour vide estUnit). - Les fonctions anonymes utilisent la syntaxe suivante
{ argName1, argName2, etc. -> // code }- Aussi appelées fonctions lambda ou fonctions littérales
- Le dernier argument de la fonction peut être mis après la fermeture après la parenthèse fermante
compute(9, 5) { x, y -> x * y }
▶️ Ce code illustre les fonctions en Kotlin.
La prochaine section abordera le null safety.
Null safety
null safety est une fonctionnalité du compilateur qui élimine la fameuse Null pointer exception ou npe. En effet, le compilateur signale des erreurs et des avertissements lorsque nous manipulons des types nullables (également appelées types optionnels) dès qu'il y a un risque de npe à l'exécution. Ainsi, afin de mettre Voici une liste des fonctionnalités de sécurité null fournies par Kotlin :
- Tous les types ne sont pas nullables par défaut ; nous ne pouvons pas affecter
nullà une variable ou à un argument.- Par exemple, ce code échoue
var s: String = null.
- Par exemple, ce code échoue
- Un type peut être rendu nullable en le suffixant avec un ?. Par exemple :
var s : chaîne ? = nul. - Kotlin interdit d'appeler une méthode ou une propriété de type non nullable, sauf si l'on fait l'une de ces possibilités :
- Utilisez le chaînage optionnel avec le suffixe ?.
- Fournissez une valeur par défaut avec l'opérateur elvis ?:.
- Smart-cast le nullable dans un non-nullable.
- Utilisez l'opérateur !! qui élimine les vérifications du compilateur. Cela ne devrait jamais être utilisé.
Ne jamais déballer avec !!
Car cela équivaut à désactiver la null safety. Utilisez les autres possibilités à la place.
▶️ ce code illustrate la null safety et les types optionnels.
La classe \`Optional\` de Java ne fournit aucun protection à la compilation
Ce code lance une npe en Java: Optional<String> s = null; s.isPresent();. Le compilateur Java (au moins à la version version 17) ne propose pas d'équivalent à ce que propose Kotlin comme le smart casting.
Énumérations
Les énumérations permettent de travailler avec un groupe de valeurs de façon cadrée. Contrairement aux énumérations Java, les énumérations Kotlin sont des classes. Les enum class de Kotlin fournissent ces fonctionnalités :
- Les expressions when prennent en charge les énumérations.
- Une
enum classpeut définir des méthodes et implémenter des interfaces mais elle ne peut pas dériver d'une classe. - Il existe des méthodes pour lister les constantes d'une
enum class. - Chaque constante d'une énumération a des propriétés pour obtenir son nom et sa position (en commençant par 0).
▶️ ce code illustres les enum en Kotlin de façon succincte. Veuillez consulter la documentation officielle pour aller plus loin.
Exercices
Exercice 1
Veuillez cliquer sur le lien pour consulter l'énoncé
Déplier pour consulter la solution
Exercise 2
Veuillez cliquer sur le lien pour consulter l'énoncé
Déplier pour consulter la solution
Fonctionnalités intermédiaires
Programmation orientée objet
Kotlin permet d'écrire du code Orienté Object concis grâce aux caractéristiques suivantes :
- Concepts disponibles : classes, héritage, interfaces et classes abstraites.
- Prise en charge possée des propriétés : les getters et les setters sont automatiquement implémentés.
- On peut les personnaliser les accesseurs en définissant les fonctions
get()etset(value)à côté de la déclaration de la propriété.
- On peut les personnaliser les accesseurs en définissant les fonctions
- Les arguments du constructeur sont définis à côté du nom de la classe
class ClassName(arg1, atg2, ) - Préfixer les arguments d'un constructeur avec
valouvaren fait une propriété (valla rend non ré-assignable). - Le nom du constructeur est
initet ne nécessite pas de paramètres. - Le compilateur vérifie que toutes les propriétés non nullables sont initialisées à la fin du constructeur.
- ⚠️ Le compilateur ne vérifie pas l'initialisation des propriétés
lateinit. Ainsi, y accéder avant alors qu'elles ne sont pas initialisés provoque une exception.
- ⚠️ Le compilateur ne vérifie pas l'initialisation des propriétés
- Une classe doit être préfixée avec
openpour permettre l'héritage. - Kotlin utilise le niveau d'accès
publicpar défaut. - L'opérateur d'égalité
==appelle implicitement la méthodeequals()(contrairement à Java qui utilise l'égalité de référence). - Un objet compagnon contient des méthodes et des propriétés statiques.
- Les extensions ajoutent des fonctions et des propriétés aux classes existantes.
- 💡 Ils remplacent l'héritage dans de nombreuses situations.
- Par exemple, nous pouvons ajouter des fonctions à la classe String au lieu de créer une nouvelle classe
StringUtils.
- Les classes et interfaces scellées ne peuvent pas être étendues ou implémentées par des tiers.
Ne définir les accesseurs que si vous avez un comportement personnalisé
Kotlin prend en charge les propriétés de façon plus poussée que Java et permet d'ajouter des accesseurs ultérieurement sans refactoriser le code qui appelle ces propriétés. Ainsi, par défaut, il suffit de définir le nom des propriétés sans accesseurs et on peut les utiliser directement.
▶️ ce code illustre la POO en Kotlin.
Data class
Ce sont des classes qui implémentent des méthodes communes:
equals(),hashCode(),copy()ettoString()componentN()qui est une syntaxe alternative pour récupérer les propriétés.
Cependant, les data class ont des restrictions:
- Le constructeur principal doit avoir au moins un paramètre.
- Tous les paramètres du constructeur principal doivent être marqués comme
valouvar. - Une Data class ne peut pas être abstraite, ouverte à l'héritage, scellée ou interne (💡 mais des extensions sont possibles).
▶️ ce code illustrate les data class.
Programmation fonctionnelle
Concepts généraux
La programmation fonctionnelle s'articule autour de ces concepts : fonctions pures, récursivité, transparence référentielle, variables immuables, fonctions en tant que citoyens de première classe et fonctions d'ordre supérieur.
Expliquons brièvement ces concepts :
- Les variables immuables signifient qu'on ne peut pas changer la valeur d'une variable ou ses propriétés une fois qu'elle a été créée. Si nous voulons le faire, nous devons créer une nouvelle instance avec la nouvelle valeur.
- Les fonctions pures sont des fonctions qui n'ont pas d'effets secondaires et renverront donc toujours la même sortie étant donné la même entrée.
- Les fonctions sont des citoyennes de première classe : elles peuvent être affectées à une variable ou utilisées dans des fonctions d'ordre supérieur (passées en tant qu'un argument de fonction ou retournées dans un fonction).
- Transparence référentielle : signifie qu'une expression peut être remplacée par son résultat sans modifier le comportement du programme.
💡 Les langages fonctionnels purs fournissent ces fonctionnalités de manière native et les appliquent (au moment de la construction).
Kotlin et programmation fonctionnelle
Kotlin n'est pas un langage fonctionnel pur mais il prend en charge certaines fonctionnalités. En effet, Kotlin ne sait pas dire si une fonction est pures ou non, mais il fournit des collections immuables via la bibliothèque kotlinx.collections.immutable pour nous aider à manipuler des données immuables.
\`listOf\` génère des listes en lecture seule, mais qui sont mutables
Une liste en lecture seule ne peut pas ajouter ou supprimer des éléments, mais elle peut modifier les données sous-jacentes.
@Test
+fun givenReadOnlyList_whenCastToMutableList_checkNewElementsAdded(){
+ val list: List<String> = listOf("This", "Is", "Totally", "Immutable")
+ (list as MutableList<String>)[2] = "Not"
+ assertEquals(listOf("This", "Is", "Not", "Immutable"), list)
+}
+La librairie Arrow-kt permet d'aller encore plus loin en développement fonctionnel.
Programmation déclarative
La programmation déclarative est un style célèbre dans la programmation fonctionnelle. Il consiste à écrire du code sous la forme d'un enchaînement d'appels de fonction dans ce style val result = f(x).g(y). .... Les fonctions d'ordre supérieur remplacent de nombreuses situations où nous utiliserions des boucles. Cela favorise le code lisible qui est facile à déboguer et à maintenir.
▶️ ce code montre comment manipuler une liste avec la programmation déclarative.
Kotlin and Java interoperability
- Kotlin is designed with Java interoperability in mind.
- Kotlin code may require some annotations to be called from Java.
- It is possible to mix Java and Kotlin in the same project.
- JetBrain's IntelliJ and Android Studio can convert to Kotlin when pasting java code.
- Kotlin generates Java records by annotating a data class with
@JvmRecordand targeting JVM 16, among other requirement listed here. - It is much more easier and natural to call Java from Kotlin.
- For example: Java accessors are converted to Kotlin properties.
▶️ this code shows how to convert a Kotlin List to a Java ArrayList.
The official documentation provides exhaustive documentation on Kotlin and JVM integration
Exercices
Exercice 3
Solution(s)
Exercice 4
Solutions(s)
Exercice 5
Solution(s)
Exercice 6
solution(s)
Exercice 7
Solution(s)
Plus d'exercices et de lecture
`,77)]))}const s=e(i,[["render",c],["__file","index.html.vue"]]),t=JSON.parse(`{"path":"/fr/kotlin-features/","title":"📚 Fonctionnalités du langage Kotlin","lang":"fr-FR","frontmatter":{},"headers":[{"level":2,"title":"Caractéristiques de base","slug":"caracteristiques-de-base","link":"#caracteristiques-de-base","children":[{"level":3,"title":"Constructions de base (variables, flux de contrôle)","slug":"constructions-de-base-variables-flux-de-controle","link":"#constructions-de-base-variables-flux-de-controle","children":[]},{"level":3,"title":"Les fonctions","slug":"les-fonctions","link":"#les-fonctions","children":[]},{"level":3,"title":"Null safety","slug":"null-safety","link":"#null-safety","children":[]},{"level":3,"title":"Énumérations","slug":"enumerations","link":"#enumerations","children":[]},{"level":3,"title":"Exercices","slug":"exercices","link":"#exercices","children":[]}]},{"level":2,"title":"Fonctionnalités intermédiaires","slug":"fonctionnalites-intermediaires","link":"#fonctionnalites-intermediaires","children":[{"level":3,"title":"Programmation orientée objet","slug":"programmation-orientee-objet","link":"#programmation-orientee-objet","children":[]},{"level":3,"title":"Data class","slug":"data-class","link":"#data-class","children":[]},{"level":3,"title":"Programmation fonctionnelle","slug":"programmation-fonctionnelle","link":"#programmation-fonctionnelle","children":[]},{"level":3,"title":"Kotlin and Java interoperability","slug":"kotlin-and-java-interoperability","link":"#kotlin-and-java-interoperability","children":[]},{"level":3,"title":"Exercices","slug":"exercices-1","link":"#exercices-1","children":[]}]},{"level":2,"title":"Plus d'exercices et de lecture","slug":"plus-d-exercices-et-de-lecture","link":"#plus-d-exercices-et-de-lecture","children":[]}],"git":{"updatedTime":1729869737000,"contributors":[{"name":"yostane","email":"1958676+yostane@users.noreply.github.com","commits":1}]},"filePathRelative":"fr/kotlin-features/README.md"}`);export{s as comp,t as data}; diff --git a/assets/index.html-B08ZAEqY.js b/assets/index.html-B08ZAEqY.js new file mode 100644 index 0000000..878b91d --- /dev/null +++ b/assets/index.html-B08ZAEqY.js @@ -0,0 +1,272 @@ +import{_ as c,c as r,a as o,b as e,d as t,r as l,o as u,e as n,f as s}from"./app-Djq7wF8p.js";const d={};function k(m,a){const p=l("CodeGroupItem"),i=l("CodeGroup");return u(),r("div",null,[a[2]||(a[2]=o(`📚 Backend development
Many frameworks officially support Kotlin: Spring, Quarkus, Ktor, among others listed here.
In addition to that, Kotlin is theoretically compatible with any framework that targets the JVM or JS. For example, this tutorial shows how to use node.js with Kotlin. However, frameworks that do not officially support Kotlin may require some tweaking to use it.
Ktor
Ktor is a cross-platform Kotlin library for building both HTTP clients and servers. This makes Ktor a useful library to learn for both front-end developers for its HTTP client capabilities and backend-development for its HTTP server capabilities. In the following, we'll create a REST API with Ktor server.
🧪 develop an API with Ktor
- Create a project on start.ktor.io with the following plugins: Content Negotiation, kotlinx.serialization, and Routing.
- Click on "Generate project".
- Download the archive, unzip it, and open the project with IntelliJ.
- Create a
modelspackage and add to it aCustomerdata class with these immutable propertiesid: String, firstName: String, lastName: String, email: String. - Annotate the class with
@Serializable. - Create a new package named
routesand add to it a fileCustomerRoutes.ktthat will contain the code for the/customerendpoint. - The code below provides the implementation of some endpoints. Please implement the remaining ones.
- To enable the route call
customerRouting()in the routing configuration file located inplugins/Routing.kt. - For simplicity, use a global in-memory list of customers
val store = mutableListOf<Customer>(). - Run the server by running the main method.
- Test the api on the IDE by using an http file or using any other client.
CustomerRoutes.kt
val store = mutableListOf<Customer>()
+
+fun Route.customerRouting() {
+ route("/customer") {
+ get {
+ call.respond(store)
+ }
+ get("{id?}") {
+ val id = call.parameters["id"] ?: return@get call.respondText(
+ "Missing id",
+ status = HttpStatusCode.BadRequest
+ )
+ val customer =
+ store.find { it.id == id } ?: return@get call.respondText(
+ "No customer with id $id",
+ status = HttpStatusCode.NotFound
+ )
+ call.respond(customer)
+ }
+ post {
+ val customer = call.receive<Customer>()
+ store.add(customer)
+ call.respondText("Customer stored correctly", status = HttpStatusCode.Created)
+ }
+ delete("{id?}") {
+
+ }
+ }
+}
+plugins/Routing.kt
fun Application.configureRouting() {
+ routing {
+ customerRouting()
+ }
+}
+return@label
You can specify which level you want to return with an explicit label using return@lambda.
lambdaA {
+ lambdaB {
+ lambdaC {
+ val randomInt = Random.nextInt(0, 100)
+ if (randomInt > 50) return@lambdaC else return@lambdaB
+ }
+ printf("In lambdaB")
+ }
+}
+CustomerTest.http
POST http://127.0.0.1:8080/customer
+Content-Type: application/json
+
+{
+ "id": "100",
+ "firstName": "Jane",
+ "lastName": "Smith",
+ "email": "jane.smith@company.com"
+}
+
+
+###
+POST http://127.0.0.1:8080/customer
+Content-Type: application/json
+
+{
+ "id": "200",
+ "firstName": "John",
+ "lastName": "Smith",
+ "email": "john.smith@company.com"
+}
+
+###
+POST http://127.0.0.1:8080/customer
+Content-Type: application/json
+
+{
+ "id": "300",
+ "firstName": "Mary",
+ "lastName": "Smith",
+ "email": "mary.smith@company.com"
+}
+
+
+###
+GET http://127.0.0.1:8080/customer
+Accept: application/json
+
+###
+GET http://127.0.0.1:8080/customer/200
+Accept: application/json
+
+###
+GET http://127.0.0.1:8080/customer/500
+Accept: application/json
+
+###
+DELETE http://127.0.0.1:8080/customer/100
+
+###
+DELETE http://127.0.0.1:8080/customer/500
+Spring framework
Spring is a famous framework for developing server-side applications: APIs, server generated web pages, microservices, etc. It relies on the the Java ecosystem to build and run, thus making it compatible with Kotlin. Even better, Spring officially supports Kotlin. It even allows in start a new project with Kotlin and Gradle-Kotlin. In the next section, we'll use this starter to recreate our above REST API with Spring.
🧪 Spring boot part 1 - develop the same API with Spring Boot
- Create a project on start.spring.io (also called Spring initializr) with the following dependencies: Spring Web and Spring Boot DevTools.
- Choose Kotlin as the language and Kotlin-Grade as the project manager.
- Add these dependencies: Spring Web, Spring Boot DevTools, h2 database and Spring Data JPA.
- Click on "Generate". Download the archive, unzip it, and open the project with IntelliJ (preferably) or VSCode.
- For VSCode, install a Kotlin extension and Spring Boot Extension Pack ( ⚠️ Spring extension do not seem to support kotlin).
- Create
Customerdata class in themodelpackage without the@Serializableannotation. - Create a
controllerpackage that contains aCustomerControllerclass which provides a CRUD using a global list. You can find a skeleton below.- 💡 In Spring, Rest controllers serve the purpose of Ktor routes, where a controller defines a REST resource.
- Define the same endpoints as in the previous PW.
- Start the REST API server by running
.\\gradlew bootRunor from your IDE. - Please test the endpoints with a REST client. You can find http files here in JetBrains format or VSCode's REST Client extension
CustomerController.kt
val store = mutableListOf<Customer>()
+
+@RestController
+@RequestMapping("/customer")
+class CustomerController {
+ @GetMapping
+ fun getAll() = store
+
+ @GetMapping("{id}")
+ fun getById(@PathVariable id: String) { /* TODO: implement */ }
+
+ @PostMapping
+ fun addOne(@RequestBody customer: Customer) { /* TODO: implement */ }
+
+ @DeleteMapping("{id}")
+ fun deleteOne(@PathVariable id: String) { /* TODO: implement */ }
+}
+Models or model package ? plural or not ?
Both are ok as long as you follow the same convention in the project.
🧪 Spring boot part 2 - adding a database
Let's go a little bit further by storing data in a database and writing some tests.
We'll use the H2 in-memory database for the sake of simplicity, since it does not require a server to run. Classes will mapped to database tables with JPA annotations. The database API we'll be using is called JPARepository. It is a lightweight API that provides common CRUD features by just defining an interface.
On the testing side, we'll see two different syntaxes. The default one that is more familiar with Java style and the DSL one which is more readable and more familiar with Kotlin developers.
- Create a new Spring project using Spring initializr with Kotlin and the following dependencies: Spring Data JPA, H2 Database, Spring Boot DevTools, Spring Web
- Open the project and add this class in the
modelpackage@Entity class Product(@Id @GeneratedValue var id: Long? = null, var name: String, var price: Int). This single defines the class as well as the minimal JPA annotations (@Entity,@Idand@GeneratedValue) to generate the corresponding table. - In the
repositorypackage, declare theProductRepositoryinterface as followsinterface ProductRepository: JpaRepository<Product, Long>. This is enough for Spring to generate an implementation with common features as we'll see later. - Next, create a
ProductServiceclass which will contain the business logic. In terms of architecture, the controller calls a service which in turn rely on other services or repositories.
ProductService.kt
@Service
+class ProductService(@Autowired val productRepository: ProductRepository) {
+ fun getAll() = productRepository.findAll()
+
+ // use findByIdOrNull instad of findById because the latter returns an optional<Product> instead of Product?
+ fun getById(id: Long) = productRepository.findByIdOrNull(id)
+}
+- In the controller package, create a
ProductControllerclass that is mapped to/productand injects the with@Autowired. Reply to@Getas follows.
ProductController.kt
@RestController
+@RequestMapping("/product")
+class ProductController(@Autowired val productService: ProductService) {
+ @GetMapping fun getAll() = productService.getAll()
+
+ @GetMapping("{id}")
+ fun getById(@PathVariable id: Long) =
+ productService.getById(id) ?: throw ResponseStatusException(HttpStatus.NOT_FOUND)
+}
+Kotlin makes getById(@PathVariable id: Long) more concise
The Elvis operator ?: allows to simplify the code. Here is a longer version as reference.
@GetMapping("{id}")
+fun getById(@PathVariable id: Long): Product {
+ val product = productService.getById(id)
+ if (product != null){
+ return product
+ }
+ throw ResponseStatusException(HttpStatus.NOT_FOUND)
+}
+In addition to that, Spring provides @ControllerAdvice to change the exception message. You can see an example here.
- Let's run the project. Before running the project, we need to add a plugin that allows Kotlin classes to generate a default constructor
id("org.jetbrains.kotlin.plugin.jpa") version "1.8.10". The plugins should look as follows:
plugins {
+ id("org.jetbrains.kotlin.plugin.jpa") version "1.8.10"
+ id("org.springframework.boot") version "3.0.4"
+ id("io.spring.dependency-management") version "1.1.0"
+ kotlin("jvm") version "1.8.10"
+ kotlin("plugin.spring") version "1.8.10"
+}
+- As an exercise, implement these endpoints: POST a single product, DELETE by id (
/product/{id}) and GET by id (/product/{id}).- Hint:
ProductControlleralready provides the necessary methods.
- Hint:
- Call the different endpoints with a REST client.
🧪 Spring boot part 2 - adding tests
Spring frameworks helps perform different types of tests by providing different classes out of the box:
- Unit testing of services, repositories and the REST API. This is done through mock utilities such as
MockMVC. - Integration testing of the REST API using
TestRestTemplate. In this situation, a full server is run and tested.
Most, if not all classes provided by Spring provide an elegant syntax for Java developers. Some of them go further by taking advantage of Kotlin specific features. In the following, we're going to focus on parts that provide Kotlin DSLs, namely unit testing the REST API with MockMVC.
- Create a test class
ProductControllerUnitTestswith this initial content.MockMvcallows to unit test the REST API. The@AutoConfigureMockMvcannotation allows spring to configure it automatically
@SpringBootTest
+@AutoConfigureMockMvc
+class ProductControllerTests(
+ @Autowired val mockMvc: MockMvc,
+ @Autowired val productRepository: ProductRepository) {
+
+ @BeforeEach
+ fun reset(){
+ productRepository.deleteAll()
+ }
+}
+- Add these two tests. The first one uses a classic approach while the second take advantage of Kotlin DSL capabilities. In addition to that, we name using a more readable string literal
- As an exercise, unit tests for the other endpoints.
The request builder of JpaRepository
Spring repositories implement requests based on the name of their methods. For example, to get all products sorted by name, we can add this method to the interface.
interface ProductRepository: JpaRepository<Product, Long> {
+ fun findAllByOrderByNameAsc(): List<Product>;
+}
+The official documentation provides more detailed explanations and examples.
node.js
Thanks to Kotlin/JS, we can write apps that target node.js using Kotlin. We can even import npm libraries as long as you declare the JS API surface that you'll be using in Kotlin. This is called external declaration (You can think of it as an equivalent of TypeScript's type definitions) that declares the symbols that we want to access in Kotlin thanks to @JsModule and @JsNonModule annotations.
Defining such external declarations can be a hassle and there seems to be no official automatic generator (dukat has been removed in kotlin 1.8.20). In that case, we have two options, either we write the external declaration ourselves or import it as a dependency if available. Fortunately for express developers, chrisnkrueger/kotlin-express provides declarations for the express library.
There are two gradle plugins that allow to create node.js projects: the kotlin("js") one and the kotlin("multiplatform") one. The difference between the two plugins is that the former only supports JS or WASM while the latter supports more platforms but requires to configure source sets. Thus, the former may seem easier to setup but the latter is better in the long run because it allows us to get more familiar with Kotlin Multiplatform (KMP).
🧪 Getting started with Kotlin/JS and Express
At the time of writing, I didn't find an official wizard or starter project. So we'll create one from scratch using gradle init.
- Create a new Gradle project using IntelliJ or by running
gradle initin a empty folder (see below for the replies to thegradle initcommand).
gradle init
gradle init
+Starting a Gradle Daemon, 1 incompatible and 1 stopped Daemons could not be reused, use --status for details
+
+Select type of project to generate:
+ 1: basic
+ 2: application
+ 3: library
+ 4: Gradle plugin
+Enter selection (default: basic) [1..4] 1
+
+Select build script DSL:
+ 1: Kotlin
+ 2: Groovy
+Enter selection (default: Kotlin) [1..2] 1
+
+Project name (default: starter): rest-api-kotlin-nodejs
+
+Generate build using new APIs and behavior (some features may change in the next minor release)? (default: no) [yes, no] yes
+
+
+> Task :init
+To learn more about Gradle by exploring our Samples at https://docs.gradle.org/8.3/samples
+
+BUILD SUCCESSFUL in 24s
+2 actionable tasks: 2 executed
+- In build.gradle.kts, add and configure the
kotlin("multiplatform")plugin. Also add theexpressanddev.chriskrueger:kotlin-expressdependencies.
build.gradle.kts
plugins {
+ kotlin("multiplatform") version "1.9.20-Beta"
+}
+
+repositories {
+ mavenCentral()
+}
+
+group = "tech.worldline.demo"
+version = "1.0-SNAPSHOT"
+
+kotlin {
+ js {
+ nodejs {
+ }
+ binaries.executable()
+ useCommonJs()
+ }
+
+ sourceSets {
+ val jsMain by getting {
+ dependencies {
+ implementation(npm("express", "> 4.0.0 < 5.0.0"))
+ implementation("dev.chriskrueger:kotlin-express:1.2.0")
+ }
+ }
+ }
+}
+Some notes on the build file
- express dependency is retrieved from npm
useCommonJs()is required to be able to use chrisnkrueger/kotlin-express in our code.
- create a main.kt file in src/jsMain/kotlin with the following content:
main.kt
data class Message(val id: Int, val message: String)
+
+val messages = mutableListOf(Message(0, "I love Kotlin/JS"))
+
+fun main() {
+ val app = express.Express()
+
+ // REST API that provides a **GET /hello** endpoint
+ app.get("/hello") { _, res ->
+ res.send(messages)
+ }
+
+ // Create a server that listens to port 3000
+ app.listen(3000) {
+ console.log("server start at port 3000")
+ }
+}
+- Run the task
jsRunfrom IntelliJ of from the command line./gradlew --console=plain jsRun. The server should start running. - Open the hello endpoint on http://localhost:3000/hello
Execution failed for task ':kotlinStoreYarnLock'
If you get this error:
Execution failed for task ':kotlinStoreYarnLock'.
+> yarn.lock was changed. Run the \`kotlinUpgradeYarnLock\` task to actualize yarn.lock file
+Run ./gradlew kotlinUpgradeYarnLock so that yarn.lock is updated
🧪 Adding a post endpoint and an external Kotlin/JS definition
Let's add a post endpoint which reads the body as a json. In order to read the body as json, we must add this possibility to express by importing the npm library body-parser and by calling app.use(bodyParser.json()). Once this setup is complete, req.body will contain the content of the body. However, there is no available external definition for bodyParser as of the time of writing. Thus, we must create or own external definition.
- First, add the body-parser dependncy in the build file
implementation(npm("body-parser", "> 1.0.0 < 2.0.0")) - Next, we would write:
app.use(bodyparser.json())to activate the library. Let's guess what a minimal definition ofbodyparsercan be.
BodyParser.kt
// external means that this class is defined in JS
+external class BodyParser {
+ // we tell Kotlin that we want to use the json() function.
+ fun json(): Any
+ // It is not required to define all the functions of the module
+}
+
+// @JsModule is used to import the module from the NPM registry
+@JsModule("body-parser")
+external val bodyParser: BodyParser
+- Finally, we just need to add the BodyParser.kt file into the project and use it in our server.
main.kt
app.use(bodyParser.json())
+app.post("/hello") { req, res ->
+ // Kotlin does not keep the original field name when parsing JSON from JS (you can see it the in get response)
+ if (req.body as? Message == null) {
+ println("failed to get the body from Kotlin")
+ }
+ // Thus, we need to use js() to get the the field by its expected name
+ // js() calls JS from Kotlin
+ println("req.body from JS \${js("req.body.id")} - \${js("req.body.message")}")
+ val id = js("req.body.id") as? Int
+ val message = js("req.body.message") as? String
+ if (message != null && id != null) {
+ messages.add(Message(id, message))
+ res.status(201).end()
+ } else {
+ res.status(400).send(js("{cause : 'error'}") as Any)
+ }
+}
+🧪 Adding more endpoints
- Add PUT and DELETE endpoints
🎯 Solutions
- ktor Rest API
- Spring boot Rest API
- The starter and final node.js projects are available here
Other frameworks
Micronaut and Quarkus
Micronaut and Quarkus are two other frameworks that support Kotlin. Bootstrap websites are available here and here.
📖 Further readings
These official tutorials go even further:
- This tutorial from kotlinlang shows how to create a RESTful web service with a database using Spring Boot.
- This one from spring.io show how to build a web application with Spring Boot and Kotlin.
- Rest ÄPIs with Spring
- Quarkus and kotlin
References
- JS in Kotlin/JS
- mockmvc kotlin dsl
- spring-boot-kotlin tutorial
- Working with Kotlin and JPA
- Spring Data JPA How to use Kotlin nulls instead of Optional
📚 Développement frontend
Kotlin supporte une large sélection de frameworks frontaux sur toutes les plateformes : mobile, desktop et web. Vous trouverez ci-dessous un aperçu des possibilités que vous pouvez faire directement à partir d'IntelliJ :
- Côté bureau
- Grâce au support de la JVM, Kotlin supporte JavaFX. 💡 Il existe même un équivalent en Kotlin appelé tornadofx.
- Compose Multiplatform apporte l'API Jetpack Compose sur le bureau, le web et le mobile.
- Sur le web
- Ktor peut utiliser des moteurs de modèles tels que FreeMarker pour créer des pages de serveur.
- Avec KotlinJS, les développeurs peuvent créer des applications React, nodsjs ou vanilla JS en utilisant Kotlin.
- Kotlin WASM se compile en Web Assembly. Il peut compléter KotlinJS pour les tâches à forte intensité de calcul.
- Compose Multiplatform apporte deux options sur le web: Compose web et Compose for Web Canvas.
- Sur les mobiles
- Les développeurs Android utilisent Jetpack Compose ou l'ancienne méthode de layout XML.
- Compose Multiplatform supporte Android de façon stable et iOS de façon expérimentale.
Comme nous pouvons le voir, Kotlin propose plusieurs options. L'option la plus séduisante en terme de partage de code est Compose Multiplatform. Ceci est possible notamment grâce à KMP
KMP
- KMP (Kotlin Multiplatform) permet de partager une base de code unique sur plusieurs cibles.
- KMP s'appuie sur Kotlin native et d'autres fonctionnalités de Kotlin pour aider les développeurs à créer des projets destinés à plusieurs plates-formes en utilisant une base de code Kotlin commune.
- De nombreuses combinaisons de cibles et de cas d'utilisation sont possibles :
- Full-Stack web apps : Un projet qui contient un backend et une application web tout en partageant une logique commune.
- Bibliothèques multiplateformes
- KMM est une ancienne dénomination qui est dépréciée.
Dans la suite de ce chapitre, nous explorerons les différentes possibilités individuellement et on fera un projet KMP dans le chapitre suivant.
Kotlin/JS et Kotlin/WASM
- Kotlin/JS peut également cibler le web et même utiliser des frameworks web (tels que react) dans Kolitn.
- Kotlin WASM est une autre possibilité de cibler le web, mais il génère WASM au lieu de code JS pur.
- Il peut être utilisé par exemple pour développer des bibliothèques à forte intensité de calcul.
- Nous pourrons peut-être faire encore plus à l'avenir grâce à l'évolution de toutes ces technologies (Kotlin, WASM et Kotlin/WASM). - Par exemple, [WASI] (https://wasi.dev/) permet à WASM de communiquer avec le système d'exploitation. - Cela signifie que je pourrais voir des projets Kotlin/WASM à l'avenir qui peuvent cibler à la fois le navigateur et le système d'exploitation.
- Continuons à observer 😄.
🧪 Application web Kotlin/WASM
- Les assistants de création de projet Kotlin/WASM et Kotlin/JS sur IntelliJ fonctionnent de manière similaire:
- L'IDE génère un fichier Kotlin qui sera compilé par la suite en WASM et/ou JS. Kotlin/JS ne génère que du JS tandis que Kotin/WASM génère à la fois du JS et du WASM.
- Dans les deux cas, le point d'entrée du code généré est un fichier JS appelé nom_du_module.js.
- L'IDE génère également dans le dossier des ressources un fichier index.html dont le but est de charger le JS généré (le fichier nom_du_module.js).
- La tâche
wasmBrowserDevelopmentRunoujsWasmBrowserDevelopmentRunlancera un serveur local qui hébergera à la fois les fichiers index.html et les fichiers JS et WASM générés.
- Créons une application Kotlin/WASM. Tout d'abord, activez l'assistant Kotlin/WASM en activant kotlin.wasm.wizard dans le registre d'IntelliJ (ouvrez le registre en appuyant deux fois sur shift et en tapant "registry" dans la boîte de recherche). Alternativement, clonez ce projet.
- Vérifiez qu'on est sur la dernière version de Kotlin dans build.gradle.kts (l'assistant peut le configurer à une version antérieure).
- Ouvrez src/wasmMain/kotlin/sample.kt et cliquez sur le bouton lancer qui apparaît à côté de la fonction
main. - Si la compilation échoue parce que l'IDE a utilisé la mauvaise tâche gradle, veuillez la changer en
wasmBrowserDevelopmentRunet essayez de l'exécuter à nouveau.
- Le serveur de développement devrait démarrer et vous pouvez ouvrir votre application web sur http://localhost:8080/
- ⚠️ Il se peut que vous deviez activer certains drapeaux sur votre navigateur pour que l'application fonctionne. Si vous voyez une page blanche, veuillez lire les journaux du navigateur pour vérifier les instructions.
- Le fichier wasm généré est disponible dans build/js/packages/nom_du_projet/kotlin
- WASM étant un format binaire, nous devons d'abord le convertir au format texte.
- Nous pouvons soit installer [WABT (The WebAssembly Binary Toolkit ou wabbit)] (https://github.com/WebAssembly/wabt) et utiliser l'outil wasm2wattool
wasm2wat --enable-all -v .\\kotlin-wasm-demo-wasm.wasm -o wasm.wat, - ou utiliser un convertisseur en ligne comme celui-ci
- ❗ Cependant, je n'ai pas réussi à le faire fonctionner
- Nous pouvons soit installer [WABT (The WebAssembly Binary Toolkit ou wabbit)] (https://github.com/WebAssembly/wabt) et utiliser l'outil wasm2wattool
🧪 Application web KotlinJS
L'assistant Kotlin/JS crée une application très similaire à celle de Kotlin/WASM. Dans un prochain PW, nous créerons une application complète avec Ktor et Kotlin/JS.
Compose
Compose multiplatform est une famille de frameworks d'interface utilisateur déclaratifs pour Android (Jetpack Compose), le bureau (Compose Desktop) et le web (Compose Web). Il dispose d'un support expérimental pour iOS et Web Canvas.
Compose multiplatform vs Jetpack Compose
Bien que très similaire, Compose multiplatform est différent de Jetpack Compose car ce dernier n'est compatible qu'avec Android. Google fournit un JetPack compose tutorial pour le développement Android.
Compose Web vs Compose for Web Canvas
- La surface de l'API de Compose Web est différente des autres cibles de Compose car elle travaille directement avec le DOM.
- Compose for Web Canvas a la même surface d'API que celle du Desktop, Android et iOS car il dessine sur un Canvas et ne manipule pas le DOM.
Cela signifie que le premier a un meilleur support web et que le second a plus de code réutilisable.
🧪 Compose Web
- Créez un nouveau projet IntelliJ -> Compose Multiplaform.
- Choisissez "Single platform" -> "Web" et remplissez les autres champs.
- Choisissez Finish
- IntelliJ peut prendre un certain temps pour préparer le projet et peut demander d'installer des plugins supplémentaires.
- Lancez le serveur de développement de l'application web à l'aide de la commande
./gradlew jsBrowserRun --continuous. - Modifiez
Main.ktcomme suit et lancez l'application. - Ouvrez cette adresse :
localhost:8080.
fun main() {
+ renderComposable(rootElementId = "root") {
+ Div({ style { padding(25.px) } }) {
+ var expanded by remember { mutableStateOf(false) }
+ Button(
+ attrs = {
+ onClick { expanded = !expanded }
+ }
+ ) { Text("Cliquez sur moi") }
+ Div({ style { display(if (expanded) DisplayStyle.Block else DisplayStyle.None) } }) {
+ Text("Cliquez sur moi !")
+ }
+ }
+ }
+}
+🧪 Compose desktop + Android app
- Créez un nouveau projet sur IntelliJ -> Compose Multiplatform.
- Choisissez "multiple platforms" et remplissez les autres champs. Choisissez ensuite Finish.
- IntelliJ commence à préparer le projet et peut demander l'installation de plugins.
- Une fois le projet prêt, lancez l'application Android en utilisant le bouton vert run.
- Lancez l'application desktop en exécutant la fonction principale du projet desktop (qui devrait se trouver dans
Main.kt). - Modifiez
App.ktdans le projet principal comme suit et lancez l'application.
@Composable
+fun App() {
+ val platformName = getPlatformName()
+ Card {
+ var expanded by remember { mutableStateOf(false) }
+ Column(Modifier.clickable { expanded = !expanded }) {
+ Texte(
+ text="Cliquez sur moi !",
+ style = MaterialTheme.typography.h2
+ )
+ AnimatedVisibility(expanded){
+ Texte(
+ text = "Bonjour, \${platformName} 🎊",
+ style = MaterialTheme.typography.h1
+ )
+ }
+ }
+ }
+}
+Pour aller plus loin
',35)]))}const v=s(c,[["render",d],["__file","index.html.vue"]]),f=JSON.parse('{"path":"/fr/front-development/","title":"📚 Développement frontend","lang":"fr-FR","frontmatter":{},"headers":[{"level":2,"title":"KMP","slug":"kmp","link":"#kmp","children":[]},{"level":2,"title":"Kotlin/JS et Kotlin/WASM","slug":"kotlin-js-et-kotlin-wasm","link":"#kotlin-js-et-kotlin-wasm","children":[{"level":3,"title":"🧪 Application web Kotlin/WASM","slug":"🧪-application-web-kotlin-wasm","link":"#🧪-application-web-kotlin-wasm","children":[]},{"level":3,"title":"🧪 Application web KotlinJS","slug":"🧪-application-web-kotlinjs","link":"#🧪-application-web-kotlinjs","children":[]}]},{"level":2,"title":"Compose","slug":"compose","link":"#compose","children":[{"level":3,"title":"🧪 Compose Web","slug":"🧪-compose-web","link":"#🧪-compose-web","children":[]},{"level":3,"title":"🧪 Compose desktop + Android app","slug":"🧪-compose-desktop-android-app","link":"#🧪-compose-desktop-android-app","children":[]}]},{"level":2,"title":"Pour aller plus loin","slug":"pour-aller-plus-loin","link":"#pour-aller-plus-loin","children":[]}],"git":{"updatedTime":1729869737000,"contributors":[{"name":"yostane","email":"1958676+yostane@users.noreply.github.com","commits":1}]},"filePathRelative":"fr/front-development/README.md"}');export{v as comp,f as data}; diff --git a/assets/index.html-BZTbG60u.js b/assets/index.html-BZTbG60u.js new file mode 100644 index 0000000..3439f10 --- /dev/null +++ b/assets/index.html-BZTbG60u.js @@ -0,0 +1 @@ +import{_ as t}from"./kmp_codelab-CiTPMWjt.js";import{_ as n,c as r,a as i,o as a}from"./app-Djq7wF8p.js";const o={};function l(s,e){return a(),r("div",null,e[0]||(e[0]=[i('🛠 Construisons une app multiplateforme !
En combinant KMP, KMM et Compose, il est possible de développer des applications mobiles et de bureau multiplateformes en utilisant uniquement Kotlin.
Prérequis
- Connaissance de base du développement en Kotlin (notamment la nullabilité, les fonctions en ligne et les fonctions lambda)
- IDE Android Studio avec la version stable la plus récente, version Giraffe ou supérieure
- Une bonne connectivité
Conseil
Pour plus d'informations sur votre environnement de développement (DEV) et les installations, veuillez consulter la documentation liée à JetBrains ici.
____ 🚀 Demarrer la session pratique ici 🚀___
🚀 Présentation de Kotlin
Kotlin est un langage de programmation moderne développé par JetBrains.
Certaines fonctionnalités
- Kotlin est capable de compiler vers différentes cibles : la JVM, JS, Android, iOS, Les OS de bureau, etc.
- Pris en charge officiellement par de grands frameworks back-end, tels que Spring et Quarkus,
- Langage préféré pour le développement Android,
- Kotlin Native compile en code natif,
- Kotlin peut être considéré comme un langage fullstack
- Interopérable avec Java.
- Fournit des fonctionnalités modernes telles que la null safety à la compilation.
- Prend en charge la programmation orientée objet et la programmation fonctionnelle.
- Processus d'évolution open source: Kotlin KEEP.
Histoire
- 15 février 2016 : sortie de Kotlin 1.0.
- 4 janvier 2017 : Spring a introduit le support de Kotlin dans Spring 5.
- Lors de Google I/O 2017, Google a annoncé une prise en charge officielle de Kotlin sur Android.
- Le 7 mai 2019, Google a annoncé que Kotlin était le langage préféré des développeurs d'applications Android.
- Juin 2022 : Kotlin 1.7 est sorti avec la version du nouveau compilateur K2.
Quelques chiffres et faits
- En 2022, Kotlin est utilisé par 7,8 % des experts de l'industrie.
- Selon StackOverflow, Kotlin était le 4ème langage le plus apprécié en 2020 avec 62,9 % des votes.
- Kotlin est désormais répertorié parmi les 20 meilleurs langages de programmation par Redmonk.
- Kotlin fait partie des 3 principaux langages vers lesquels la plupart des entreprises prévoient de migrer leurs applications en 2022.
- Kotlin est utilisé par des entreprises mondiales telles que Google, Netflix, Amazon, Trello, etc.
- Plusieurs entreprises dont Google, Pinterest et Uber ont migré leurs applications de Java vers Kotlin.
Veuillez trouver plus de statiques ici :
Pourquoi passer de Java à Kotlin
Voici quelques arguments qui motivent le passage de Java (version 17 LTS au moment de la rédaction) à Kotlin.
- Kotlin prend en charge plus de cibles que Java.
- Kotlin protège des références null à la compilation (les
OptionalJava sont ne sont pas de protections à la compilation). - Les chaînes de caractères Kotlin prennent en charge l'interpolation.
- Les fonctionnalités de programmation fonctionnelle de Kotlin sont meilleures. Il permet même de définir des constructeurs et des DSL (Domain Specific Language) dont le typage est sécurisé (type-safe).
- Kotlin peut être mélangé avec du code Java, facilitant ainsi le processus de migration.
Vous pouvez lire plus d'arguments dans ces articles :
- Java Vs Kotlin : Lequel vaut-il mieux apprendre en 2022 ?
- [8 raisons pour lesquelles vous devriez passer à Kotlin depuis Java] (https://www.geeksforgeeks.org/8-reasons-why-you-should-switch-to-kotlin-from-java)
Sources et plus de lecture
- Kotlin sur Wikipedia
- Présentation de la prise en charge de Kotlin dans Spring Framework 5.0
- 8 statistiques et faits à connaître sur Kotlin en 2022
- Pourquoi devriez-vous apprendre Kotlin en 2022 ?
📅 Workshops
(2023) Android makers : Kotlin Beyond Android
Link
Workshop link: awl.li/am23-kt
Agenda
',7)),l("ul",null,[l("li",null,[o(t,{to:"/en/backend-development/#ktor"},{default:i(()=>e[0]||(e[0]=[n("Backend development: Rest API with Ktor")])),_:1})]),l("li",null,[e[2]||(e[2]=n("Optional: ")),o(t,{to:"/en/backend-development/#ktor"},{default:i(()=>e[1]||(e[1]=[n("Backend development: Rest API with node.js and Kotlin/JS")])),_:1})]),l("li",null,[o(t,{to:"/en/front-development/#kotlin-js-and-kotlin-wasm"},{default:i(()=>e[3]||(e[3]=[n("Front-end development: Kotlin/WASM and Kotlin/JS webapp")])),_:1})]),l("li",null,[o(t,{to:"/en/front-development/#compose"},{default:i(()=>e[4]||(e[4]=[n("Front-end development: cross-platform Hello world App with Compose multiplatform")])),_:1})]),e[6]||(e[6]=l("li",null,[l("a",{href:"https://worldline.github.io/learning-kotlin-multiplatform/",target:"_blank",rel:"noopener noreferrer"},"Front-end development: Cross-platform Quiz App with Compose multiplatform")],-1)),l("li",null,[o(t,{to:"/en/other-technologies/#pw-add-a-ktor-server-app"},{default:i(()=>e[5]||(e[5]=[n("Full-stack development: Quiz App with Compose multiplatform and Ktor server")])),_:1})])]),e[42]||(e[42]=r('(2023) JNation : Let's discover the possibilities of Kotlin
Link
Workshop link: awl.li/jnation23-kt
Agenda
',5)),l("ul",null,[l("li",null,[o(t,{to:"/en/presentation/#prerequisites"},{default:i(()=>e[7]||(e[7]=[n("Prerequisutes")])),_:1})]),l("li",null,[e[10]||(e[10]=n("Selection of Kotlin's languages features: ")),o(t,{to:"/en/kotlin-features/#null-safety"},{default:i(()=>e[8]||(e[8]=[n("null safety")])),_:1}),e[11]||(e[11]=n(" and ")),o(t,{to:"/en/kotlin-features/#functions"},{default:i(()=>e[9]||(e[9]=[n("functions")])),_:1})]),l("li",null,[o(t,{to:"/en/backend-development/#ktor"},{default:i(()=>e[12]||(e[12]=[n("Backend development: Rest API with Ktor")])),_:1})]),l("li",null,[e[14]||(e[14]=n("Optional: ")),o(t,{to:"/en/backend-development/#ktor"},{default:i(()=>e[13]||(e[13]=[n("Backend development: Rest API with node.js and Kotlin/JS")])),_:1})]),l("li",null,[o(t,{to:"/en/front-development/#kotlin-js-and-kotlin-wasm"},{default:i(()=>e[15]||(e[15]=[n("Front-end development: Kotlin/WASM and Kotlin/JS webapp")])),_:1})]),l("li",null,[o(t,{to:"/en/front-development/#compose"},{default:i(()=>e[16]||(e[16]=[n("Front-end development: cross-platform Hello world App with Compose multiplatform")])),_:1})]),e[18]||(e[18]=l("li",null,[l("a",{href:"https://worldline.github.io/learning-kotlin-multiplatform/",target:"_blank",rel:"noopener noreferrer"},"Front-end development: Cross-platform Quiz App with Compose multiplatform")],-1)),l("li",null,[o(t,{to:"/en/other-technologies/#pw-add-a-ktor-server-app"},{default:i(()=>e[17]||(e[17]=[n("Full-stack development: Quiz App with Compose multiplatform and Ktor server")])),_:1})])]),e[43]||(e[43]=r('(2023) Mobile DevOps summit
- Title: From Android to Multiplatform: leveraging the full potential of Kotlin
- Link: awl.li/mds23-kt
Agenda
',4)),l("ul",null,[l("li",null,[o(t,{to:"/en/other-technologies/#pw-add-a-ktor-server-app"},{default:i(()=>e[19]||(e[19]=[n("Initiate a cross-platform app")])),_:1})]),l("li",null,[e[23]||(e[23]=n("Live examples of other Kotlin possibilities: ")),l("ul",null,[l("li",null,[o(t,{to:"/en/backend-development/#ktor"},{default:i(()=>e[20]||(e[20]=[n("Backend development: Rest API with Ktor")])),_:1})]),l("li",null,[o(t,{to:"/en/backend-development/#ktor"},{default:i(()=>e[21]||(e[21]=[n("Backend development: Rest API with node.js and Kotlin/JS")])),_:1})]),l("li",null,[o(t,{to:"/en/front-development/#kotlin-js-and-kotlin-wasm"},{default:i(()=>e[22]||(e[22]=[n("Front-end development: Kotlin/WASM and Kotlin/JS webapp")])),_:1})])])])]),e[44]||(e[44]=l("h2",{id:"_2024-mixit",tabindex:"-1"},[l("a",{class:"header-anchor",href:"#_2024-mixit"},[l("span",null,"(2024) MiXit")])],-1)),e[45]||(e[45]=l("ul",null,[l("li",null,[n("Titre : "),l("strong",null,"Développement front et back en Kotlin. Une visite guidée de KMP")])],-1)),e[46]||(e[46]=l("p",null,"",-1)),e[47]||(e[47]=l("h3",{id:"agenda-3",tabindex:"-1"},[l("a",{class:"header-anchor",href:"#agenda-3"},[l("span",null,"Agenda")])],-1)),l("ul",null,[l("li",null,[o(t,{to:"/en/presentation/#prerequisites"},{default:i(()=>e[24]||(e[24]=[n("Prérequis")])),_:1})]),l("li",null,[e[27]||(e[27]=n("Fonctionnalités notables: ")),o(t,{to:"/en/kotlin-features/#null-safety"},{default:i(()=>e[25]||(e[25]=[n("null safety")])),_:1}),e[28]||(e[28]=n(" et ")),o(t,{to:"/en/kotlin-features/#functions"},{default:i(()=>e[26]||(e[26]=[n("les fonctions")])),_:1})]),l("li",null,[e[32]||(e[32]=l("strong",null,"Développement backend",-1)),l("ul",null,[e[31]||(e[31]=l("li",null,[l("a",{href:"https://speakerdeck.com/yostane/kotlin-pour-le-developpement-backend",target:"_blank",rel:"noopener noreferrer"},"Présentation d'introduction à Kotlin pour le développement backend")],-1)),l("li",null,[o(t,{to:"/en/backend-development/#spring-framework"},{default:i(()=>e[29]||(e[29]=[n("API Rest avec Spring boot")])),_:1})]),l("li",null,[o(t,{to:"/en/backend-development/#ktor"},{default:i(()=>e[30]||(e[30]=[n("API Rest avec Ktor")])),_:1})])])]),l("li",null,[e[34]||(e[34]=l("strong",null,"Développement frontend",-1)),l("ul",null,[l("li",null,[o(t,{to:"/en/front-development/#compose"},{default:i(()=>e[33]||(e[33]=[n('Application "Hello World" avec Compose Multiplatform')])),_:1})])])]),l("li",null,[e[36]||(e[36]=l("strong",null,"Développement fullstack",-1)),l("ul",null,[l("li",null,[o(t,{to:"/en/other-technologies/#pw-add-a-ktor-server-app"},{default:i(()=>e[35]||(e[35]=[n("Application de quiz avec Ktor + Compose Multiplatform")])),_:1})])])]),l("li",null,[e[40]||(e[40]=l("strong",null,"Autres fonctionnalités",-1)),l("ul",null,[l("li",null,[o(t,{to:"/en/front-development/#kotlin-js-and-kotlin-wasm"},{default:i(()=>e[37]||(e[37]=[n("Kotlin/WASM")])),_:1})]),l("li",null,[o(t,{to:"/en/backend-development/#node.js"},{default:i(()=>e[38]||(e[38]=[n("Développement node.js en Kotlin")])),_:1})]),l("li",null,[o(t,{to:"/en/kotlin-features-advanced/#concurrency-and-coroutines"},{default:i(()=>e[39]||(e[39]=[n("Coroutines")])),_:1})])])])])])}const b=d(m,[["render",f],["__file","index.html.vue"]]),A=JSON.parse(`{"path":"/en/workshops/","title":"📅 Workshops","lang":"en-US","frontmatter":{},"headers":[{"level":2,"title":"(2023) Android makers : Kotlin Beyond Android","slug":"_2023-android-makers-kotlin-beyond-android","link":"#_2023-android-makers-kotlin-beyond-android","children":[{"level":3,"title":"Link","slug":"link","link":"#link","children":[]},{"level":3,"title":"Agenda","slug":"agenda","link":"#agenda","children":[]}]},{"level":2,"title":"(2023) JNation : Let's discover the possibilities of Kotlin","slug":"_2023-jnation-let-s-discover-the-possibilities-of-kotlin","link":"#_2023-jnation-let-s-discover-the-possibilities-of-kotlin","children":[{"level":3,"title":"Link","slug":"link-1","link":"#link-1","children":[]},{"level":3,"title":"Agenda","slug":"agenda-1","link":"#agenda-1","children":[]}]},{"level":2,"title":"(2023) Mobile DevOps summit","slug":"_2023-mobile-devops-summit","link":"#_2023-mobile-devops-summit","children":[{"level":3,"title":"Agenda","slug":"agenda-2","link":"#agenda-2","children":[]}]},{"level":2,"title":"(2024) MiXit","slug":"_2024-mixit","link":"#_2024-mixit","children":[{"level":3,"title":"Agenda","slug":"agenda-3","link":"#agenda-3","children":[]}]}],"git":{"updatedTime":1729869737000,"contributors":[{"name":"yostane","email":"1958676+yostane@users.noreply.github.com","commits":1}]},"filePathRelative":"en/workshops/README.md"}`);export{b as comp,A as data}; diff --git a/assets/index.html-COrAJfz9.js b/assets/index.html-COrAJfz9.js new file mode 100644 index 0000000..dc544f2 --- /dev/null +++ b/assets/index.html-COrAJfz9.js @@ -0,0 +1,7 @@ +import{_ as I,c as g,a,o as c}from"./app-Djq7wF8p.js";const i={};function e(n,l){return c(),g("div",null,l[0]||(l[0]=[a(`📚 Kotlin language features
Kotlin is an object oriented language with functional features. This chapter covers important and relevant features of the language slit into basic and intermediate. Another chapter covers advanced features.
Basic features
Basic constructs (variables, control flow)
- Kotlin is statically typed and supports implicit typing.
- Static typing: types cannot change on runtime (it is the opposite of dynamic typing).
- Implicit typing: the compiler can infer the type whenever possible.
varcreates mutable variables.valcreates immutable variables or constants.- Semi-colons are optional.
- Kotlin supports top level declaration of variables and functions (They can be declared outside of classes).
- String interpolation is available with this syntax
\${expression}. if, andwhenstatements are expressions (they can return a value).whenis equivalent to theswitchstatement of other languages- The ternary operator is not available but the
ifstatement replaces-it.
- for-each is the only type of for loop available.
- Object oriented programming is supported as in Java with some additional features such as extensions.
- The compiler supports Null Safety. It allows to write code free from null pointer errors with a compile time guarantee.
- Functional programming is supported (Higher-order functions and functions as 1st class items, etc.).
Use val by default
Replace by var only if needed.
▶️ this code highlights the above features.
Functions
In the this section, the terms 'argument' and 'parameter' are used interchangeably.
Functions in Kotlin have the following features:
- Declaration:
fun functionName(arg1: type1 = defaultvalue1, ...) : retunrType. - Call a function by passing the value in the declaration order.
- Use argument labels for more clarity, however, it also allows for arbitrary ordering of arguments.
- Optional arguments have a default value and can be omitted during the call.
- Functions are first class items or citizen: they can be assigned to a variable, passed as a function parameter, or returned from a function.
- 💡 A function that takes a function as an argument or returns one is a higher order function.
- A function type can be expressed as follows:
(typeOfParam1, typeOfParam2, etc) -> returnType(The empty return type isUnit). - Anonymous functions use the following syntax
{ argName1, argName2, etc. -> // code }- Also called or lambda functions or literal functions
- The last function argument can be put after the closing after the closing parenthesis
compute(9, 5) { x, y -> x * y }
▶️ this code highlights the above features.
The next section talk about null safety.
Null safety
In a nutshell, null safety is a compiler feature that eliminates the infamous Null pointer exception or npe. The Kotlin compiler reports errors and warnings when we manipulate nullable (also called optional) values. Here is a list of null safety features provided by Kotlin:
- All types are non-nullable by default; we cannot assign
nullto a variable or an argument.- For example, this code fails
var s: String = null.
- For example, this code fails
- A type can be made nullable by suffixing it with a ?. For example:
var s: String? = null. - Kotlin forbids calling a method or a property of a non-nullable type, unless we do one of these possibilities:
- Use optional chaining with the ? suffix.
- Provide a default value with the elvis ?: operator.
- Smart-cast the nullable into a non-nullable.
- Use the !! operator that eliminates compiler checks. This should never be used.
Never unwrap with !!
Use other safe techniques instead.
▶️ this code illustrates null safety and how to use optional types.
Java \`Optional\` does not provide compile time null checks
Optional wrap null values on runtime. The Java compiler (as of version 17) does not provide unwrapping features such as smart casting. It is still possible to have a npe like this: Optional<String> s = null; s.isPresent();
Enumerations
Enumerations allow to work with a group of values in a type-safe fashion. Unlike Java enums, Kotlin enums are classes. Kotlin enum classes provide these features:
whenstatements support enumerations.- Enum constants can declare their own anonymous classes with their corresponding methods, as well as with overriding base methods.
- An enum class can implement an interface but it cannot derive from a class
- There are methods for listing the defined enum constants and getting an enum constant by its name.
- Every enum constant has properties for obtaining its name and position (starting with 0).
▶️ this code illustrated the features above. For further reading please consult the official documentation.
🧪 Exercises
Exercise 1
Please click on this link to view the exercise
Please open to see the solution(s)
Exercise 2
Please click on this link to view the exercise
Please open to see the solution(s)
Intermediate features
Object oriented programming
Kotlin allows to write concise OOP code and has the following features:
- Available common features: classes, inheritance, interfaces, and abstract classes.
- Native support of properties: do not define getters and setters unless needed.
- Just add
get()andset(value)functions next to the property declaration.
- Just add
- Constructor arguments are defined next to the class name
class ClassName(arg1, atg2, ) - Prefixing a constructor arguments with
valorvarmakes it a property (valmakes it read-only). - The constructor name is
initand does not require parameters. - The compiler checks that all non-nullable properties are initialized by the end of the constructor.
- ⚠️ The compiler does not check the initialization of
lateinitproperties. Thus, accessing them before while uninitialized causes an exception.
- ⚠️ The compiler does not check the initialization of
- Prefix classes with
opento allow inheritance. - Kotlin enables the
publicaccess level by default. - The equality operator
==callsequals()(as opposed to Java which uses reference equality). - A companion object contains static methods and properties.
- Extensions add function and properties to existing classes.
- 💡 They replace inheritance in many situations.
- For example, we can add functions to the String class instead of creating a new
StringUtilsclass.
- Sealed classes and interfaces cannot be extended or implemented by third parties.
Do not define accessors unless needed
As opposed to Java, Kotlin supports properties and allows to add accessors later without refactoring the code that calls these properties. Thus, by default, just define the name of properties without accessors and use them directly.
▶️ this code illustrates some features.
Data class
Data classes are final (cannot be inherited from) classes that provide standard functionality:
equals()andhashCode()toString()of the form"class(field=value, ...)"componentN()that correspond to the properties in their order of declaration.copy()
However, they have the following constraints:
- The primary constructor needs to have at least one parameter.
- All primary constructor parameters need to be marked as val or var.
- They cannot be abstract, open, sealed, or inner (💡 but extensions are possible).
▶️ this code illustrates some features.
Functional programming
General concepts
Functional programming revolves around these concepts: pure functions, recursion, referential transparency, immutable variables, functions as first-class citizens, and higher-order functions.
Let's briefly explain these concepts:
- Immutable variables means that we cannot change the value of a variable or its properties once it has been created. If we want to do so, we must create a new instance with the new value.
- Pure functions are functions that do not have side effects and will thus return always the same output given the same input.
- Functions are first class citizens: they can be assigned to a variable or used in higher-order functions (passed as a function parameter to another function or returned from a function).
- Referential transparency: means that an expression can be replaced by its result without changing the behavior of the program. Transparency refers to the fact that the implementation of the expression is irrelevant.
💡 Pure functional languages provide these features natively and enforces them (at build time).
Kotlin and functional programming
Kotlin is not a pure functional languages but it supports some features. For example, Kotlin does not have compile time verification of pure functions, but it provides immutable collections through the kotlinx.collections.immutable library.
listOf generates read-only lists, which are not immutable
A read-only list cannot add or remove elements, but it can change the underlying data.
@Test
+fun givenReadOnlyList_whenCastToMutableList_checkNewElementsAdded(){
+ val list: List<String> = listOf("This", "Is", "Totally", "Immutable")
+ (list as MutableList<String>)[2] = "Not"
+ assertEquals(listOf("This", "Is", "Not", "Immutable"), list)
+}
+The Arrow-kt library add more functional programming features.
Declarative programming
Declarative programming is a famous style within functional programming. It consists of writing code as a chaining of function calls in this style val result = f(x).g(y). .... Higher order functions replace many situation where we would use loops. This favors readable code which is easy to debug an maintain.
▶️ this code show an example of list manipulation using declarative programming.
Kotlin and Java interoperability
- Kotlin is designed with Java interoperability in mind.
- Kotlin code may require some annotations to be called from Java.
- It is possible to mix Java and Kotlin in the same project.
- JetBrain's IntelliJ and Android Studio can convert to Kotlin when pasting java code.
- Kotlin generates Java records by annotating a data class with
@JvmRecordand targeting JVM 16, among other requirement listed here. - It is much more easier and natural to call Java from Kotlin.
- For example: Java accessors are converted to Kotlin properties.
▶️ this code shows how to convert a Kotlin List to a Java ArrayList.
The official documentation provides exhaustive documentation on Kotlin and JVM integration
🧪 Exercises
Exercise 3
Please click on this link to view the exercise
Please open to see the solution(s)
Exercise 4
Please click on this link to view the exercise
Please open to see the solution(s)
Exercise 5
Please click on this link to view the exercise
Please open to see the solution(s)
Exercise 6
Please click on this link to view the exercise
Please open to see the solution(s)
Exercise 7
Please click on this link to view the exercise
Please open to see the solution(s)
📖 Further reading
`,77)]))}const s=I(i,[["render",e],["__file","index.html.vue"]]),t=JSON.parse('{"path":"/en/kotlin-features/","title":"📚 Kotlin language features","lang":"en-US","frontmatter":{},"headers":[{"level":2,"title":"Basic features","slug":"basic-features","link":"#basic-features","children":[{"level":3,"title":"Basic constructs (variables, control flow)","slug":"basic-constructs-variables-control-flow","link":"#basic-constructs-variables-control-flow","children":[]},{"level":3,"title":"Functions","slug":"functions","link":"#functions","children":[]},{"level":3,"title":"Null safety","slug":"null-safety","link":"#null-safety","children":[]},{"level":3,"title":"Enumerations","slug":"enumerations","link":"#enumerations","children":[]},{"level":3,"title":"🧪 Exercises","slug":"🧪-exercises","link":"#🧪-exercises","children":[]}]},{"level":2,"title":"Intermediate features","slug":"intermediate-features","link":"#intermediate-features","children":[{"level":3,"title":"Object oriented programming","slug":"object-oriented-programming","link":"#object-oriented-programming","children":[]},{"level":3,"title":"Data class","slug":"data-class","link":"#data-class","children":[]},{"level":3,"title":"Functional programming","slug":"functional-programming","link":"#functional-programming","children":[]},{"level":3,"title":"Kotlin and Java interoperability","slug":"kotlin-and-java-interoperability","link":"#kotlin-and-java-interoperability","children":[]},{"level":3,"title":"🧪 Exercises","slug":"🧪-exercises-1","link":"#🧪-exercises-1","children":[]}]},{"level":2,"title":"📖 Further reading","slug":"📖-further-reading","link":"#📖-further-reading","children":[]}],"git":{"updatedTime":1729869737000,"contributors":[{"name":"yostane","email":"1958676+yostane@users.noreply.github.com","commits":1}]},"filePathRelative":"en/kotlin-features/README.md"}');export{s as comp,t as data}; diff --git a/assets/index.html-CcuJhM9n.js b/assets/index.html-CcuJhM9n.js new file mode 100644 index 0000000..7da026c --- /dev/null +++ b/assets/index.html-CcuJhM9n.js @@ -0,0 +1 @@ +import{_ as t}from"./kmp_codelab-CiTPMWjt.js";import{_ as a,c as o,a as r,o as i}from"./app-Djq7wF8p.js";const n={};function l(s,e){return i(),o("div",null,e[0]||(e[0]=[r('🛠 Let's make a cross-plaform app !
By combining KMP and Compose, it is possible to fully develop cross-platform mobile, web and desktop apps using only Kotlin.
Prerequisites
- Basic knowledge of kotlin development (nullability,inline & lambda functions mainly)
- Android Studio IDE with latest stable version Giraffe version or above
- A good connectivity
Tips
For more information about your DEV environment and installs please have a look to jetbrain related docs
_____ 🚀 Start the practical work here 🚀_____
Prerequisites
- Connaissance de base en language de programmation orienté object comme Java
- Préparez votre environnement de développement et installez des éléments avant la session (voir la section Outillage)
Liens utiles
',5)]))}const m=t(l,[["render",a],["__file","index.html.vue"]]),p=JSON.parse(`{"path":"/fr/","title":"","lang":"fr-FR","frontmatter":{"home":true,"heroImage":"./kotlin_logo.png","tagline":"A beginner's guide to a modern programming language","actions":[{"text":"Débuter →","link":"/fr/presentation/","type":"primary"}],"features":[{"title":"Bien commencer avec Kotlin","details":"lorem"},{"title":"Syntaxe de base","details":"lorem"},{"title":"Exemples","details":"lorem"}],"footer":"Worldline, 2021"},"headers":[{"level":2,"title":"Prerequisites","slug":"prerequisites","link":"#prerequisites","children":[]},{"level":2,"title":"Liens utiles","slug":"liens-utiles","link":"#liens-utiles","children":[]}],"git":{"updatedTime":1729869737000,"contributors":[{"name":"yostane","email":"1958676+yostane@users.noreply.github.com","commits":1}]},"filePathRelative":"fr/index.md"}`);export{m as comp,p as data}; diff --git a/assets/index.html-D-c6bFFq.js b/assets/index.html-D-c6bFFq.js new file mode 100644 index 0000000..d375f50 --- /dev/null +++ b/assets/index.html-D-c6bFFq.js @@ -0,0 +1 @@ +import{_ as t}from"./kotlin-used-for-Bdlavnqs.js";import{_ as i,c as o,a as n,o as r}from"./app-Djq7wF8p.js";const a="/learning-kotlin/assets/kotlin-decision-tree-4i7nEr1Z.svg",l={};function s(h,e){return r(),o("div",null,e[0]||(e[0]=[n('🚀 Presentation of Kotlin
Kotlin is a modern programming language developed by JetBrains.
Some features
- Kotlin compiles to many targets: the JVM, JS, WASM, Android, iOS, Desktop, native code, etc.
- Many server frameworks officially support Kotlin such as Spring and Quarkus.
- It is the first-class language for writing Android.
- Kotlin can compile to native with Kotlin native or with GraalVM.
- KMP allows to share code between different platforms.
- Kotlin can be considered as both fullstack and corss-platform language.
- Inter-operable with Java.
- Provides modern features such as compile-time null safety and data classes.
- Supports Object oriented programming and functional programming.
- Kotlin KEEP is its open source evolution process.
History
- February 15, 2016: Kotlin 1.0 was released.
- January 04, 2017: Spring introduced Kotlin support in Spring 5.
- At Google I/O 2017, Google announced first-class support for Kotlin on Android.
- On 7 May 2019, Google announced that Kotlin the preferred language for Android app developers.
- June 2022: Kotlin 1.7 was released with the version of the new K2 compiler.
Some numbers and facts
- As of 2022, Kotlin is used by 7.8% of the industry experts.
- According to StackOverflow, Kotlin was the 4th most beloved language in 2020 with 62.9% votes.
- Kotlin is now listed among the top 20 programming languages by Redmonk.
- Kotlin is among the top 3 languages that most businesses are planning to migrate their apps to in 2022.
- Kotlin is used by global companies like Google, NetFlix, Amazon, Trello, and more.
- Pinterest and Uber are among the companies that migrated their apps to Kotlin from Java.
Please find more statics here:
Why switch from Java to Kotlin
Here are some arguments that motivate switching from Java (version 17 LTS at the time of writing) to Kotlin.
- Kotlin supports more targets than Java.
- Kotlin has compile time null-safety (Java Optionals are runtime wrappers for nullable values and null annotations have less features).
- Kotlin strings support interpolation.
- Casting in Kotlin is smart.
- Kotlin functional programming features are better. It even allows to define Type-Safe builders and DSLs.
- Kotlin can be mixed with Java code, thus helping the migration process.
You can read more arguments in these articles:
- Java Vs Kotlin: Which One Is Better To Learn In 2022?
- 8 Reasons Why You Should Switch To Kotlin From Java
A decision tree to help you decide if you should use Kotlin
Prerequisites
- Recommended: IntelliJ IDEA (Both community or ultimate are OK),
- or GitPod by opening https://gitpod.io/#https://github.com/worldline/learning-kotlin to create a workspace and then browser to the material folder,
- or VSCode (with Kotlin and Java plugins) + JDK 17 (install via scoop.sh on windows or SDK man on Unix) + gradle
📖 Further reading
- Kotlin on Wikipedia
- Introducing Kotlin support in Spring Framework 5.0
- 8 stats and facts you should know about Kotlin in 2022
- Why should you learn Kotlin in 2022?
- Kotlin is awesome
- Awesome Kotlin
📚 Fonctionnalités avancées de Kotlin
Propriétés déléguées
Kotlin permet de déléguer le getter et le setter d'une propriété à un autre objet, appelé délégué. C'est une classe qui définit les méthodes getValue et setValue.
Kotlin fournit des délégués standard tels que des propriétés paresseuses et des propriétés observables.
▶️ this code illustrates delegate properties.
Concurrence et coroutines
Kotlin fournit un modèle de concurrence de haut niveau appelé Coroutines. Le développeur peut déléguer la gestion des threads au compilateur et à l'exécution et utiliser des constructions de niveau supérieur aux threads pour exprimer des opérations asynchrones.
Les coroutines de Kotlin tournent autour de ces concepts :
- Une coroutine est une instance de calcul suspendable.
- Kotlin a de nombreuses méthodes pour créer une coroutine telle que
launch.
- Kotlin a de nombreuses méthodes pour créer une coroutine telle que
- Une coroutine doit exister dans une portée de coroutine.
- Par exemple,
runBlockingcrée une portée de coroutine dans laquelle les coroutines peuvent être lancées.
- Par exemple,
- Une coroutine peut exécuter des fonctions de suspension qui peuvent suspendre la coroutine mais ne bloquent pas le thread.
- Par exemple : le
delaysuspend la coroutine mais ne bloque pas le thread sur lequel elle s'exécute. - Les fonctions de suspension sont des opérations qui peuvent prendre du temps telles que les requêtes http et les appels au système de fichiers.
- Par exemple : le
- Le qualificateur
suspenddéfinit une fonction de suspension. Il s'exécute dans une coroutine et peut appeler d'autres fonctions de suspension. Flowpermet de générer une liste de valeurs asynchrones.DeferredetChanneltransfèrent respectivement une valeur unique et un flux de valeurs entre coroutines.
▶️ this code show how to create a coroutine and suspend function and how to use them.
▶️ this code illustrated flows.
▶️ this code illustrates channels and deferred.
Littéral de fonction avec récepteur et constructeurs de type sécurisé
Comme vu précédemment, les extensions de fonctions ajoute du comportement à des classes existantes sans utiliser l'héritage. À l'intérieur de la définition de l'extension de fonction, nous pouvons référencer implicitement le récepteur d'extension (this).
fun String.countCharacters() = length // or this.length
+println("hello".countCharacters()) // prints 5
+Nous pouvons définir cette extension avec une fonction littérale (ou lambda) au lieu d'une fonction classique (déclarée avec fun).
var extFn: String.() -> Int
+extFn = { length } // extFn is a function literal
+println("hello".extFn()) // prints 5
+println(extFn("hello")) // prints 5
+extFn est une fonction littérale (lambda) qui a accès au récepteur (this). C'est pourquoi on l'appelle une fonction littérale avec récepteur.
extFn("hello") ou extFn("hello") appelle l'extension comme prévu par les fonctions d'extension.
Le type d'une fonction littérale avec récepteur est funName: ReceiverType.(arg1Type, arg2Type, etc.) -> ReturnType et est appelé avec funName(receiverValue, arg1Value, etc.) ou receiverValue.funName(arg1Value, etc.) .). Cependant, ce n'est pas l'aspect le plus intéressant.
La partie importante est extFn = { length } qui peut être placée comme argument de fonction dans une fonction d'ordre supérieur. Le développeur qui appelle la fonction d'ordre supérieur doit définir extFn, qui à son tour a accès au récepteur. Cela permet un style de programmation assez intéressant.
▶️ ce code montre un example.
Les Type-safe builders combinent les monteurs bien nommées et les fonctions littérales avec récepteur pour créer des monteur avec un typage statique et sécurisé. La syntaxe particulière possible avec technique permet de définir une sorte de sous-langage aussi appelé DSL (domain specific language).
Le pattern monteur (Builder)
Est une technique permettant de construire des objects avec une syntaxe élégante.
// StirngBuilder uses the builder pattern
+val text = StringBuilder("Temp")
+ .append(1)
+ .append(true)
+ .append("friend")
+ .toString()
+Ce code montre un type-safe builder basique.
Kotlin docs fournit un exemple plus avancé d'un monteur de documents HTML.
Exercises
Exercise 1
- open the java-integration-exercise projects in the materials folder.
- Have a look at the Java class we provided you in the
src/main/java/com/worldline/learning/kotlin/java2kotlinpackage. (yes, that's the Pokemon class) - Convert that Java class in Kotlin using IntelliJ's awesome copy-pasta tool! (just copy paste the java code in a kotlin file, one is provided at
src/main/kotlin/com/worldline/learning/kotlin/java2kotlin) - Have a look at the generated Kotlin code, and note the major differences you spot!
📚 Développement du backend
De nombreux frameworks supportent officiellement Kotlin comme Spring, Quarkus et Ktor, parmi d'autres listés ici.
En outre, Kotlin est théoriquement compatible avec tout framework qui cible la JVM ou JS. Cependant, les frameworks qui ne supportent pas officiellement Kotlin peuvent nécessiter quelques ajustements pour l'utiliser.
Ktor
Ktor est une bibliothèque Kotlin multiplateforme permettant de développer des clients et des serveurs HTTP. Cela fait de Ktor une bibliothèque utile à la fois aux développeurs frontend, pour la partie client HTTP, ainsi qu'aux développeurs backend, pour la partie serveur HTTP. Dans ce qui suit, nous allons créer une API REST avec le serveur Ktor.
TP : développer une API avec Ktor
- Créez un projet sur start.ktor.io avec les plugins suivants : Content Negotiation, kotlinx.serialization, et Routing.
- Cliquez sur "Generate project".
- Téléchargez l'archive, décompressez-la et ouvrez le projet avec votre IDE préféré.
- Créez un package
modelset ajoutez-y une classe de donnéesCustomeravec ces propriétés immuablesid : String, firstName : String, lastName : Chaîne, email : Chaîne. - Annotez la classe avec
@Serializable. - Créez un nouveau package nommé
routeset ajoutez-y un fichierCustomerRoutes.ktqui contiendra le code pour l'endpoint/customer. - Le code ci-dessous fournit l'implémentation de certains endpoints. Veuillez implémenter les autres.
- Pour activer la route, appelez
customerRouting()dans le fichier de configuration du routage situé dansplugins/Routing.kt. - Pour plus de simplicité, utilisez une liste globale de clients en mémoire
val store = mutableListOf<Customer>(). - Lancer le serveur en exécutant la méthode main.
- Tester l'API sur l'IDE en utilisant un fichier http ou en utilisant n'importe quel autre client.
CustomerRoutes.kt
val store = mutableListOf<Customer>()
+
+fun Route.customerRouting() {
+ route("/customer") {
+ get {
+ call.respond(store)
+ }
+ get("{id?}") {
+ val id = call.parameters["id"] ? : return@get call.respondText(
+ "Missing id",
+ status = HttpStatusCode.BadRequest
+ )
+ val customer =
+ store.find { it.id == id } ? : return@get call.respondText(
+ "Pas de client avec l'id $id",
+ status = HttpStatusCode.NotFound
+ )
+ call.respond(customer)
+ }
+ post {
+ val customer = call.receive<Customer>()
+ store.add(customer)
+ call.respondText("Customer stored correctly", status = HttpStatusCode.Created)
+ }
+ delete("{id?}") {
+ // TODO
+ }
+ }
+}
+
+plugins/Routing.kt
fun Application.configureRouting() {
+ routing {
+ customerRouting()
+ }
+}
+return@label
Vous pouvez spécifier le niveau que vous voulez retourner avec un label explicite en utilisant return@lambda.
lambdaA {
+ lambdaB {
+ lambdaC {
+ val randomInt = Random.nextInt(0, 100)
+ if (randomInt > 50) return@lambdaC else return@lambdaB
+ }
+ printf("In lambdaB")
+ }
+}
+CustomerTest.http
POST http://127.0.0.1:8080/customer
+Content-Type : application/json
+
+{
+ "id" : "100",
+ "firstName" : "Jane",
+ "lastName" : "Smith",
+ "email" : "jane.smith@company.com"
+}
+
+
+###
+POST http://127.0.0.1:8080/customer
+Content-Type : application/json
+
+{
+ "id" : "200",
+ "firstName" : "John",
+ "lastName" : "Smith",
+ "email" : "john.smith@company.com"
+}
+
+###
+POST http://127.0.0.1:8080/customer
+Content-Type : application/json
+
+{
+ "id" : "300",
+ "firstName" : "Mary",
+ "lastName" : "Smith",
+ "email" : "mary.smith@company.com"
+}
+
+
+###
+GET http://127.0.0.1:8080/customer
+Accept : application/json
+
+###
+GET http://127.0.0.1:8080/customer/200
+Accepte : application/json
+
+###
+GET http://127.0.0.1:8080/customer/500
+Accepte : application/json
+
+###
+DELETE http://127.0.0.1:8080/customer/100
+
+###
+DELETE http://127.0.0.1:8080/customer/500
+Cette page contient des étapes détaillées
node.js
Grâce à Kotlin/JS, nous pouvons écrire des applications qui ciblent node.js en utilisant Kotlin.
On peut même importer des librairies npm à condition de déclarer les API JS que l'on va utiliser en Kotlin. C'est ce qu'on appelle une déclaration externe (vous pouvez la considérer comme un équivalent des définitions de type de TypeScript) qui déclare les symboles auxquels nous voulons accéder en Kotlin grâce aux annotations @JsModule et @JsNonModule. Définir de telles déclarations externes peut s'avérer fastidieux et il ne semble pas y avoir de générateur automatique officiel et stable (dukat a été supprimé dans kotlin 1.8.20). Dans ce cas, nous avons deux options, soit écrire la déclaration externe nous-même, soit l'importer en tant que dépendance si elle est disponible.
Heureusement pour nous, le prochain TP utilise la librairie Express pour laquelle nous pouvons trouver une déclaration de type externe.
TP : API Rest avec Kotlin/JS et Express
- Dans IntelliJ, créer un nouveau projet node.js
- Une fois le projet chargé, éditer build.gradle.ts comme suit :
- Mettre la dernière version de Kotlin dans la ligne contenant
kotlin("js"). - Ajoutez ces deux dépendances:
- La première est la bibliothèque Express,
- et la seconde est la définition externe fournie par chrisnkrueger/kotlin-express.
- ajouter une ligne
useCommonJs()à l'intérieur du blocjs. Ceci est nécessaire pour pouvoir utiliser chrisnkrueger/ kotlin-express dans notre code.
- Mettre la dernière version de Kotlin dans la ligne contenant
implementation(npm("express", "> 4.0.0 < 5.0.0"));
+implementation("dev.chriskrueger:kotlin-express:1.2.0");
+- Modifiez main.kt comme suit. Cela crée un serveur API REST qui écoute le port 3000 et fournit une route GET /hello.
data class Message(val id : Int, val message : String)
+
+fun main() {
+ val messages = listOf(Message(0, "I love Kotlin/JS"))
+ val app = express.Express()
+ app.get("/hello") { req, res ->
+ res.send(messages)
+ }
+
+ app.listen(3000) {
+ console.log("server start at port 3000")
+ }
+}
+- Exécutez la tâche
nodeRundepuis votre IDE ou depuis la ligne de commande (si vous avez installé Gradle).- Si vous rencontrez une erreur avec Yarn lock, exécutez la tâche
kotlinUpgradeYarnLockpuis réessayez.
- Si vous rencontrez une erreur avec Yarn lock, exécutez la tâche
- Ajouter des routes en POST, PUT et DELETE
- En ce qui concerne le corps du POST, Express positionne
req.bodyàundefinedà moins que nous ne spécifions un body parser.- Pour un corps en JSON, nous devons appeler
app.use(bodyParser.json()). - bodyParser est une bibliothèque npm et malheureusement, chrisnkrueger/kotlin-express ne fournit pas de définition externe pour bodyParser au moment de l'écriture de ces lignes (chrisnkrueger/kotlin-express en version 1.2.0).
- Pouvez-vous essayer de la définir vous-même en lisant le code de la bibliothèque ?
- Vous pouvez trouver une solution ici
- Pour un corps en JSON, nous devons appeler
Spring framework
Spring est un framework célèbre pour le développement d'applications côté serveur : API REST, pages web générées par le serveur, microservices, etc. Il s'appuie sur l'écosystème Java pour la compilation et l'exécution, ce qui le rend compatible avec Kotlin. Mieux encore, Spring supporte officiellement Kotlin. On peut même démarrer un nouveau projet avec Kotlin et Gradle-Kotlin. Dans la prochaine section, nous utiliserons ce projet pour recréer notre API REST plus haut avec Spring.
TP : Spring boot part 1 - développer la même API avec Spring Boot
- Créez un projet sur start.spring.io (aussi appelé Spring initializr) avec les dépendances suivantes : Spring Web et Spring Boot DevTools.
- Choisissez Kotlin comme langage et Kotlin-Grade comme gestionnaire de projet.
- Ajoutez les dépendances suivantes : Spring Web et Spring Boot DevTools.
- Cliquez sur Generate. Téléchargez l'archive, décompressez-la et ouvrez le projet avec IntelliJ (de préférence) ou VSCode.
- Pour VSCode, installez une extension Kotlin et Spring Boot Extension Pack ( ⚠️ l'extension Spring ne semble pas supporter kotlin).
- Vérifiez que la partie plugins
build.gradle.ktsutilise la dernière version de Kotlin. Voici à quoi cela devrait ressembler avec Kotlin 1.8.10 :
plugins {
+ id("org.springframework.boot") version "3.0.4"
+ id("io.spring.dependency-management") version "1.1.0"
+ kotlin("jvm") version "1.8.10"
+ kotlin("plugin.spring") version "1.8.10"
+}
+- Créez la
data class Customerdans le packagemodel(sans l'annotation@Serializable). - Créez un paquetage
controllerqui contient une classeCustomerControllerqui fournit un CRUD en utilisant une liste globale.- Vous pouvez trouver un squelette ci-dessous.
- 💡 Dans Spring, les contrôleurs Rest servent de routes Ktor, où un contrôleur définit une ressource REST.
- Définissez les mêmes routes que dans le TP précédent.
- Démarrez le serveur de l'API REST en exécutant :
- Sur Powershell :
.\\gradlew.bat bootRun - Tout shell Unix :
.\\gradlew bootRun - Ou bien, vérifiez si votre IDE fournit déjà des configurations d'exécution pour les projets Spring Boot.
- Sur Powershell :
- Veuillez tester les routes avec un client REST. Vous pouvez trouver des fichiers http ici au format JetBrains ou au format de l'extension REST Client de VSCode
CustomerController.kt
val store = mutableListOf<Customer>()
+
+@RestController
+@RequestMapping("/customer")
+class CustomerController {
+ @GetMapping
+ fun getAll() = store
+
+ @GetMapping("{id}")
+ fun getById(@PathVariable id : String) { /* TODO : implement */ }
+
+ @PostMapping
+ fun addOne(@RequestBody customer : Customer) { /* TODO : implement */ }
+
+ @DeleteMapping("{id}")
+ fun deleteOne(@PathVariable id : String) { /* TODO : implement */ }
+}
+TP : Spring boot partie 2 - ajouter une base de données
Allons un peu plus loin en stockant des données dans une base de données et en écrivant quelques tests.
Nous utiliserons la base de données en mémoire H2 pour des raisons de simplicité, puisqu'elle ne nécessite pas de serveur pour fonctionner. Les classes seront mappées aux tables de la base de données avec des annotations JPA. L'API de base de données que nous utiliserons s'appelle JPARepository. C'est une API légère qui fournit des fonctionnalités CRUD communes à partir d'une simple une interface.
- Créez un nouveau projet Spring en utilisant Spring initializr avec Kotlin et les dépendances suivantes : Spring Data JPA, H2 Database, Spring Boot DevTools, Spring Web.
- Ouvrez le projet et ajoutez cette classe dans le package
model@Entity class Product(@Id @GeneratedValue var id : Long ? = null, var name : String, var price : Int). Ceci définit la classe ainsi que les annotations JPA minimales (@Entity,@Idet@GeneratedValue) pour générer la table correspondante. - Dans le package
repository, déclarez l'interfaceProductRepositorycomme suitinterface ProductRepository : JpaRepository<Produit, Long>. C'est suffisant pour que Spring génère une implémentation avec des caractéristiques communes comme nous le verrons plus tard. - Ensuite, créez une classe
ProductServicequi contiendra la logique métier. En termes d'architecture, le contrôleur appelle un service qui, à son tour, s'appuie sur d'autres services ou référentiels.
ProductService.kt
@Service
+class ProductService(@Autowired val productRepository: ProductRepository) {
+ fun getAll() = productRepository.findAll()
+
+ // use findByIdOrNull instad of findById because the latter returns an optional<Product> instead of Product?
+ fun getById(id: Long) = productRepository.findByIdOrNull(id)
+}
+- Dans le package controller, créez une classe
ProductControllerqui est mappée à/productet injectée avec@Autowired. Répondez à@Getcomme suit.
ProductController.kt
@RestController
+@RequestMapping("/product")
+class ProductController(@Autowired val productService : ProductService) {
+ @GetMapping fun getAll() = productService.getAll()
+
+ @GetMapping("{id}")
+ fun getById(@PathVariable id : Long) =
+ productService.getById(id) ? : throw ResponseStatusException(HttpStatus.NOT_FOUND)
+}
+Kotlin rend getById(@PathVariable id : Long) plus concis
L'opérateur Elvis ?: permet de simplifier le code. Voici une version plus longue en guise de référence.
@GetMapping("{id}")
+fun getById(@PathVariable id : Long) : Produit {
+ val product = productService.getById(id)
+ if (product != null){
+ return product
+ }
+ throw ResponseStatusException(HttpStatus.NOT_FOUND)
+}
+En outre, Spring fournit @ControllerAdvice pour modifier le message d'exception. Vous pouvez voir un [exemple ici] (https://spring.io/guides/tutorials/rest/).
- Exécutons le projet. Avant de lancer le projet, nous devons ajouter un plugin qui permet aux classes Kotlin de générer un constructeur par défaut
id("org.jetbrains.kotlin.plugin.jpa") version "1.8.10". Les plugins devraient ressembler à ce qui suit :
plugins {
+ id("org.jetbrains.kotlin.plugin.jpa") version "1.8.10"
+ id("org.springframework.boot") version "3.0.4"
+ id("io.spring.dependency-management") version "1.1.0"
+ kotlin("jvm") version "1.8.10"
+ kotlin("plugin.spring") version "1.8.10"
+}
+
+- En guise d'exercice, implémentez ces routes : POST d'un seul produit, DELETE par id (
/produit/{id}) et GET par id (/produit/{id}).- Indice :
ProductControllerfournit déjà les méthodes nécessaires.
- Indice :
- Appelez les différents points de terminaison avec un client REST.
- Tester votre API Rest avec un client HTTP
TP : Spring boot partie 3 - ajouter des tests
Les frameworks Spring permettent d'effectuer différents types de tests en fournissant différentes classes dès le départ :
- Tests unitaires/de composants des services et de l'API REST. Cela se fait par le biais d'utilitaires de bouchonnage tels que
MockMVC. - Tests d'intégration de l'API REST en utilisant
TestRestTemplate. Dans ce cas, un serveur complet est exécuté et testé.
La plupart des classes fournies par Spring, si ce n'est toutes, offrent une syntaxe élégante pour les développeurs Java. Certaines d'entre elles vont plus loin en tirant parti des caractéristiques spécifiques de Kotlin. Dans ce qui suit, nous allons nous concentrer sur les parties qui fournissent des DSLs Kotlin, à savoir le test unitaire de l'API REST avec MockMVC.
- Créer une classe de test
ProductControllerUnitTestsavec le contenu initial ci-dessous.MockMvcpermet de tester unitairement l'API REST. L'annotation@AutoConfigureMockMvcpermet à Spring de la configurer automatiquement.
@SpringBootTest
+@AutoConfigureMockMvc
+classe ProductControllerTests(
+ @Autowired val mockMvc : MockMvc,
+ @Autowired val productRepository : ProductRepository) {
+
+ @BeforeEach
+ fun reset(){
+ productRepository.deleteAll()
+ }
+}
+- Ajoutez les deux tests ci-dessous. Le premier utilise une approche classique tandis que le second tire parti des capacités du DSL de Kotlin. De plus, nous utilisons une chaîne littérale plus lisible.
- En guise d'exercice, écrire des tests pour les autres points d'accès.
Le constructeur de requêtes de JpaRepository
Les repository Spring implémentent des requêtes basées sur le nom de leurs méthodes. Par exemple, pour obtenir tous les produits triés par nom, nous pouvons ajouter cette méthode à l'interface.
interface ProductRepository : JpaRepository<Produit, Long> {
+ fun findAllByOrderByNameAsc() : List<Produit> ;
+}
+La [documentation officielle] (https://docs.spring.io/spring-data/jpa/docs/current/reference/html/#repositories.query-methods.query-creation) fournit des explications et des exemples plus détaillés.
Projets terminés
Aller plus loin
Ces tutoriels officiels vont encore plus loin :
- Ce tutoriel de kotlinlang montre comment créer un service web RESTful avec une base de données en utilisant Spring Boot.
- Ce tutoriel de spring.io montre comment construire une application web avec Spring Boot et Kotlin.
- Rest APIs with Spring
- Quarkus et Kotlin
Lien et références
- JS et Kotlin/JS
- mockmvc kotlin dsl
- spring-boot-kotlin tutorial
- Kotlin et JPA
- Spring Data JPA Comment utiliser les nulls Kotlin au lieu de Optional
Welcome
Who we are
We design payments technology that powers the growth of millions of businesses around the world. Engineering the next frontiers in payments technology
- Leader in payment and secured transactions
- Over 50 billion transactions/year
- 7000+ engineers in over 40 countries
- A huge & diverse tech-stack
Prerequisites
- Basic knowledge of object-oriented language like Java
- Prepare your development environment and install stuff before the session (see Tooling section)
Useful links
',10)]))}const p=n(l,[["render",s],["__file","index.html.vue"]]),c=JSON.parse(`{"path":"/en/","title":"Welcome","lang":"en-US","frontmatter":{"home":true,"heroImage":"./kotlin_logo.png","tagline":"A beginner's guide to a modern programming language","actions":[{"text":"Get started →","link":"/en/presentation/","type":"primary"}],"features":[{"title":"Language features","details":"null safety, extensions, lambdas, Java interoperability and more"},{"title":"Backend development","details":"With Ktor, spring and node.js"},{"title":"Frontend development","details":"Compose multiplatform, Kotlin/JS, Kotlin/WASM and JVM frameworks"},{"title":"Cross-platform development","details":"With KMP and Compose multiplatform"},{"title":"Advanced Kotlin","details":"Coroutines, delegates, Function literal with receiver, DSLs and more"},{"title":"Practical exercises and solutions","details":"All chapters have a set of exercises"}],"footer":"Worldline, 2023"},"headers":[{"level":2,"title":"Who we are","slug":"who-we-are","link":"#who-we-are","children":[]},{"level":2,"title":"Prerequisites","slug":"prerequisites","link":"#prerequisites","children":[]},{"level":2,"title":"Useful links","slug":"useful-links","link":"#useful-links","children":[]}],"git":{"updatedTime":1729869737000,"contributors":[{"name":"yostane","email":"1958676+yostane@users.noreply.github.com","commits":1}]},"filePathRelative":"en/index.md"}`);export{p as comp,c as data}; diff --git a/assets/index.html-jwVfesBb.js b/assets/index.html-jwVfesBb.js new file mode 100644 index 0000000..7f5e3c6 --- /dev/null +++ b/assets/index.html-jwVfesBb.js @@ -0,0 +1 @@ +import{_ as s}from"./Kotlin-Beyond-Android-CYulNy7n.js";import{_ as d,c as a,a as i,e,b as o,d as r,f as n,r as p,o as u}from"./app-Djq7wF8p.js";const f="/learning-kotlin/assets/Androidmakers2023Kotlinshortlink-7XGfMd7N.svg",m={};function k(v,l){const t=p("RouteLink");return u(),a("div",null,[l[42]||(l[42]=i('📅 Workshops
Android makers 2023: Kotlin Beyond Android
Liens
Lien du workshop: awl.li/am23-kt
Agenda
',7)),e("ul",null,[e("li",null,[o(t,{to:"/fr/backend-development/#ktor"},{default:r(()=>l[0]||(l[0]=[n("Backend development: Rest API with Ktor")])),_:1})]),e("li",null,[l[2]||(l[2]=n("Optional: ")),o(t,{to:"/fr/backend-development/#ktor"},{default:r(()=>l[1]||(l[1]=[n("Backend development: Rest API with node.js and Kotlin/JS")])),_:1})]),e("li",null,[o(t,{to:"/fr/front-development/#kotlin-js-and-kotlin-wasm"},{default:r(()=>l[3]||(l[3]=[n("Front-end development: Kotlin/WASM and Kotlin/JS webapp")])),_:1})]),e("li",null,[o(t,{to:"/fr/front-development/#compose"},{default:r(()=>l[4]||(l[4]=[n("Front-end development: cross-platform Hello world App with Compose multiplatform")])),_:1})]),l[6]||(l[6]=e("li",null,[e("a",{href:"https://worldline.github.io/learning-kotlin-multiplatform/",target:"_blank",rel:"noopener noreferrer"},"Front-end development: Cross-platform Quiz App with Compose multiplatform")],-1)),e("li",null,[o(t,{to:"/fr/other-technologies/#pw-add-a-ktor-server-app"},{default:r(()=>l[5]||(l[5]=[n("Full-stack development: Quiz App with Compose multiplatform and Ktor server")])),_:1})])]),l[43]||(l[43]=i('Mobile DevOps summit 2023
- Titre: From Android to Multiplatform: leveraging the full potential of Kotlin
- Lien: awl.li/mds23-kt
Agenda
',4)),e("ul",null,[e("li",null,[o(t,{to:"/fr/other-technologies/#pw-add-a-ktor-server-app"},{default:r(()=>l[7]||(l[7]=[n("Développement d'une application multi-plateformes")])),_:1})]),e("li",null,[l[11]||(l[11]=n("Démonstration des autres possibilités: ")),e("ul",null,[e("li",null,[o(t,{to:"/fr/backend-development/#ktor"},{default:r(()=>l[8]||(l[8]=[n("API Rest avec Ktor")])),_:1})]),e("li",null,[o(t,{to:"/fr/backend-development/#ktor"},{default:r(()=>l[9]||(l[9]=[n("API Rest avec node.js et Kotlin/JS")])),_:1})]),e("li",null,[o(t,{to:"/fr/front-development/#kotlin-js-and-kotlin-wasm"},{default:r(()=>l[10]||(l[10]=[n("Webapp Kotlin/WASM et Kotlin/JS")])),_:1})])])])]),l[44]||(l[44]=i('Devoxx Morocco 2023
- Titre: Let's discover the amazing possibilities of Kotlin
- Lien: awl.li/mds23-kt
Agenda
',4)),e("ul",null,[e("li",null,[o(t,{to:"/fr/presentation/#prerequisites"},{default:r(()=>l[12]||(l[12]=[n("Prérequis")])),_:1})]),e("li",null,[l[15]||(l[15]=n("Caractéristiques notables de Kotlin: ")),o(t,{to:"/fr/kotlin-features/#null-safety"},{default:r(()=>l[13]||(l[13]=[n("le null safety")])),_:1}),l[16]||(l[16]=n(" et ")),o(t,{to:"/fr/kotlin-features/#functions"},{default:r(()=>l[14]||(l[14]=[n("les fonctions")])),_:1})]),e("li",null,[o(t,{to:"/fr/backend-development/#spring-framework"},{default:r(()=>l[17]||(l[17]=[n("API Rest avec Spring boot")])),_:1})]),e("li",null,[o(t,{to:"/fr/backend-development/#ktor"},{default:r(()=>l[18]||(l[18]=[n("API Rest avec Ktor")])),_:1})]),e("li",null,[o(t,{to:"/fr/front-development/#compose"},{default:r(()=>l[19]||(l[19]=[n(`Développement d'une application multi-plateformes type "Hello World" avec Compose Multiplatform`)])),_:1})]),e("li",null,[o(t,{to:"/fr/other-technologies/#pw-add-a-ktor-server-app"},{default:r(()=>l[20]||(l[20]=[n("Dévelopment sullstack d'une application de Quiz avec with Compose multiplatform en front et Ktor server en backend")])),_:1})]),e("li",null,[l[24]||(l[24]=n("Autres fonctionnalités et possibilités: ")),e("ul",null,[e("li",null,[o(t,{to:"/fr/front-development/#kotlin-js-and-kotlin-wasm"},{default:r(()=>l[21]||(l[21]=[n("Kotlin/WASM")])),_:1})]),e("li",null,[o(t,{to:"/fr/backend-development/#nodejs"},{default:r(()=>l[22]||(l[22]=[n("Serveur node.js avec Kotlin/JS")])),_:1})]),e("li",null,[o(t,{to:"/fr/kotlin-features-advanced/#concurrency-and-coroutines"},{default:r(()=>l[23]||(l[23]=[n("Coroutines")])),_:1})])])])]),l[45]||(l[45]=e("h2",{id:"_2024-mixit",tabindex:"-1"},[e("a",{class:"header-anchor",href:"#_2024-mixit"},[e("span",null,"(2024) MiXit")])],-1)),l[46]||(l[46]=e("ul",null,[e("li",null,[n("Titre : "),e("strong",null,"Développement front et back en Kotlin. Une visite guidée de KMP")])],-1)),l[47]||(l[47]=e("p",null,"",-1)),l[48]||(l[48]=e("h3",{id:"agenda-3",tabindex:"-1"},[e("a",{class:"header-anchor",href:"#agenda-3"},[e("span",null,"Agenda")])],-1)),e("ul",null,[e("li",null,[o(t,{to:"/fr/presentation/#prerequisites"},{default:r(()=>l[25]||(l[25]=[n("Prérequis")])),_:1})]),e("li",null,[l[28]||(l[28]=n("Fonctionnalités notables: ")),o(t,{to:"/fr/kotlin-features/#null-safety"},{default:r(()=>l[26]||(l[26]=[n("null safety")])),_:1}),l[29]||(l[29]=n(" et ")),o(t,{to:"/fr/kotlin-features/#functions"},{default:r(()=>l[27]||(l[27]=[n("les fonctions")])),_:1})]),e("li",null,[l[33]||(l[33]=e("strong",null,"Développement backend",-1)),e("ul",null,[l[32]||(l[32]=e("li",null,[e("a",{href:"https://speakerdeck.com/yostane/kotlin-pour-le-developpement-backend",target:"_blank",rel:"noopener noreferrer"},"Présentation d'introduction à Kotlin pour le développement backend")],-1)),e("li",null,[o(t,{to:"/fr/backend-development/#spring-framework"},{default:r(()=>l[30]||(l[30]=[n("API Rest avec Spring boot")])),_:1})]),e("li",null,[o(t,{to:"/fr/backend-development/#ktor"},{default:r(()=>l[31]||(l[31]=[n("API Rest avec Ktor")])),_:1})])])]),e("li",null,[l[35]||(l[35]=e("strong",null,"Développement frontend",-1)),e("ul",null,[e("li",null,[o(t,{to:"/fr/front-development/#compose"},{default:r(()=>l[34]||(l[34]=[n('Application "Hello World" avec Compose Multiplatform')])),_:1})])])]),e("li",null,[l[37]||(l[37]=e("strong",null,"Développement fullstack",-1)),e("ul",null,[e("li",null,[o(t,{to:"/fr/other-technologies/#pw-add-a-ktor-server-app"},{default:r(()=>l[36]||(l[36]=[n("Application de quiz avec Ktor + Compose Multiplatform")])),_:1})])])]),e("li",null,[l[41]||(l[41]=e("strong",null,"Autres fonctionnalités",-1)),e("ul",null,[e("li",null,[o(t,{to:"/fr/front-development/#kotlin-js-and-kotlin-wasm"},{default:r(()=>l[38]||(l[38]=[n("Kotlin/WASM")])),_:1})]),e("li",null,[o(t,{to:"/fr/backend-development/#nodejs"},{default:r(()=>l[39]||(l[39]=[n("Développement node.js en Kotlin")])),_:1})]),e("li",null,[o(t,{to:"/fr/kotlin-features-advanced/#concurrency-and-coroutines"},{default:r(()=>l[40]||(l[40]=[n("Coroutines")])),_:1})])])])])])}const x=d(m,[["render",k],["__file","index.html.vue"]]),A=JSON.parse('{"path":"/fr/workshops/","title":"📅 Workshops","lang":"fr-FR","frontmatter":{},"headers":[{"level":2,"title":"Android makers 2023: Kotlin Beyond Android","slug":"android-makers-2023-kotlin-beyond-android","link":"#android-makers-2023-kotlin-beyond-android","children":[{"level":3,"title":"Liens","slug":"liens","link":"#liens","children":[]},{"level":3,"title":"Agenda","slug":"agenda","link":"#agenda","children":[]}]},{"level":2,"title":"Mobile DevOps summit 2023","slug":"mobile-devops-summit-2023","link":"#mobile-devops-summit-2023","children":[{"level":3,"title":"Agenda","slug":"agenda-1","link":"#agenda-1","children":[]}]},{"level":2,"title":"Devoxx Morocco 2023","slug":"devoxx-morocco-2023","link":"#devoxx-morocco-2023","children":[{"level":3,"title":"Agenda","slug":"agenda-2","link":"#agenda-2","children":[]}]},{"level":2,"title":"(2024) MiXit","slug":"_2024-mixit","link":"#_2024-mixit","children":[{"level":3,"title":"Agenda","slug":"agenda-3","link":"#agenda-3","children":[]}]}],"git":{"updatedTime":1729869737000,"contributors":[{"name":"yostane","email":"1958676+yostane@users.noreply.github.com","commits":1}]},"filePathRelative":"fr/workshops/README.md"}');export{x as comp,A as data}; diff --git a/assets/index.html-zXMBiwyM.js b/assets/index.html-zXMBiwyM.js new file mode 100644 index 0000000..0bb2b5f --- /dev/null +++ b/assets/index.html-zXMBiwyM.js @@ -0,0 +1,24 @@ +import{_ as n}from"./kotlin-wasm-webapp-R4_9ho9v.js";import{_ as t,c as a,a as o,o as s}from"./app-Djq7wF8p.js";const l="/learning-kotlin/assets/launch-android-app-BS4WBFFP.png",i="/learning-kotlin/assets/hello-compose-demo-B4DIIuDy.gif",r={};function p(c,e){return s(),a("div",null,e[0]||(e[0]=[o('📚 Frontend development
Kotlin supports a wide selection of frontend frameworks across all platforms: mobile, desktop and web.
Please find below a glimpse of the possibilities that you can do right from IntelliJ:
- On the Desktop side
- Thanks to JVM support, Kotlin supports JavaFX (There was a Kotlin counterpart called tornadofx which is not maintained anymore).
- Compose Multiplatform brings Jetpack Compose to the desktop, the web and mobile.
- On the Web
- Ktor can use templates engines such as FreeMarker to create server pages.
- With KotlinJS, developers can create React, nodsjs, or vanilla JS Apps using Kotlin.
- Kotlin WASM compiles into Web Assembly. It can complement KotlinJS for computation intensive tasks.
- On Mobiles
- Android developers use the Jetpack Compose UI Framework or the legacy xml layouts. It is experimental on iOS.
Kotlin supports cross platform frontend development thanks to Kotlin MultiPlatform (KMP)
Kotlin Multiplatform (KMP)
"The Kotlin Multiplatform technology is designed to simplify the development of cross-platform projects. It reduces time spent writing and maintaining the same code for different platforms while retaining the flexibility and benefits of native programming." ₁
KMP relies on Kotlin native and other Kotlin features to help developers create projects that target multiple platforms using a common Kotlin code-base.
Many combinations of targets and use cases are possible:
- Full-Stack web apps: A project that contains a backend and a web app while sharing common logic.
- Multiplatform libraries
Kotlin/JS and Kotlin/WASM
- Kotlin/JS can also target the web and even use web frameworks (such as react) in Kolitn.
- Kotlin WASM is another possibility to target the web but this will generate WASM instead of pure JS code.
- It can be used for example to develop computation intensive libraries.
- Maybe we can do even more in the future with as all these technologies (Kotlin, WASM and Kotlin/WASM) evolve. - For example, WASI allows WASM to communicate with the operating system. - This means that me may see Kotlin/WASM project projects in the future that can target both the browser and the OS.
- Let's keep watching 😄.
🧪 Kotlin/WASM web app
- Let's create a Kotlin/WASM app. By cloning
git clone git@github.com:Kotlin/kotlin-wasm-examples.gitand opening the browser-example folder in your IDE.- To get up to date information on how to start a Kotlin/WASM project, please refer to the official documentation for kotlin/wasm.
- Open the project and run the
wasmJsBrowserRuntask. - The development server should start and you can open your WASM powered webapp on http://localhost:8080/
- ⚠️ You may need to activate some flags on your browser for the app to work. If you see a blank page, please read the browser logs to check for the instructions.
- Please check the contents of src/wasmJsMain/kotlin/Simple.kt to understand how the page is coded.
- Next, let's check the generated wasm file which is available in build/js/packages/project_name/kotlin
- WASM being a binary format, we need to convert it first to text format.
- We can either install WABT (The WebAssembly Binary Toolkit or wabbit) and use the wasm2wattool
wasm2wat --enable-all -v .\\kotlin-wasm-demo-wasm.wasm -o wasm.wat, - or use an online converter such as this one
- ❗ However, I couldn't get it to work (yet).
Kotlin/JS and Kotlin/WASM common points
Both Kotlin/WASM and Kotlin/JS IntelliJ work somewhat similarly.
- Both rely on the KMP plugin
- Kotlin/WASM is enabled by adding a
wasmjssection in thebuild.gradle.ktsfile, while Kotlin/JS is enabled by adding ajssection. - The Kotlin code will compile to WASM and / or JS. Kotlin/JS generates only JS while Kotin/WASM generates both JS and WASM.
- In both cases, the entry point of the generated code is a JS file called module_name.js.
- The index.html in the resources folder loads the generated JS explained above (the one named module_name.js).
- The task
wasmBrowserDevelopmentRunorjsWasmBrowserDevelopmentRunrun a local server that hosts both the index.html files and the generated JS and WASM files.
Compose multiplatform
"Compose Multiplatform simplifies and accelerates UI development for Desktop and Web applications, and allows extensive UI code sharing between Android, iOS, Desktop and Web. It's a modern toolkit for building native UI. Quickly bring your app to life with less code, powerful tools, and intuitive Kotlin APIs."
Button(
+ onClick = {
+ logger.info("Pressed!")
+ }
+) {
+ Text("Hello $platform")
+}
+It is based on Android Jetpack Compose declarative UI approach ( which is similar also to iOS SwiftUI ) 1
Compose multiplatform vs Jetpack Compose
While very similar, Compose multiplatform is different from Jetpack Compose as the latter is only compatible with Android. Google provides a JetPack compose tutorial for Android development.
Compose HTML is not cross-platform
Compose HTML is UI a library targeting Kotlin/JS which is not compatible with Compose Multiplatform (it is a different API). For cross-platform UI development with Compose Multiplatform, compose Web is the choice.
🧪 Create a Compose multiplatform app
We'll create a multiplatform app using the official template. At the time of writing, this template does not include a compose web target.
- Please check that your environment is correctly setup as explained here.
- On Windows and Linux, we don't need to install iOS/macOS related tools but and we won't be able to run iOS/macOS targets.
- If we don't want to install Android Studio, we need at least to install the Android SDK either through the official installer or from the "Languages and Framework -> Android SDK" menu in the settings.
- Open the official template and either download a zip or use the "use this template" options on GitHub.
- Open the downloaded projet. You'll note that it contains these modules:
- a shared module (or subproject) that contains common code as well as
- and another module for earch targeted platform: androidApp, iOSApp and desktopApp (When web will be included in the template, we should also see a webApp project). These contain the source code of the apps itself (such as the main activity in Android, the
@main Appin iOS and the main function in desktopJVM) and well as platform specific resources that cannot be placed in the shared module. Some examples of such files are the AndroidManifest.xml for android and the info.plist in iOS.
- In order to run the desktopApp, open a terminal on the project root folder and launch this command:
./gradlew desktopApp:run. - In order to run the Android App, the simplest way is to launch it from IntelliJ
. It is also possible define a gradle task that installs the app on the device and issues a command to the device to launch it.
- In order to run the iOS App, the simplest way is to run it on the simulator using IntelliJ. In order to run it on a real device, the TramID needs to be defined as explained here
🧪 Playing with the Compose multiplatform API
Compose multiplatform is a component based declarative UI framework. Each component is called a Composable and is defined as a function annotated with @Composable.
In compose multiplatform, the main component (the component at the root of the App) is usually found in shared/src/commonMain/Kotlin/App.kt.
- Take a look at shared/src/commonMain/Kotlin/App.kt, run the app and try to understand how compose works.
- Let's create a new composable called
RandomNumberList.
@Composable
+fun RandomNumberList(){
+ // Generate a list of random numbers
+ val myRandomValues = List(5) { Random.nextInt(0, 30) }
+ // LazyColumn is a vertically scrolling list that renders items on demand
+ LazyColumn {
+ items(myRandomValues.size){
+ Text(text = "$it")
+ }
+ }
+}
+- Place this composable below
AnimatedVisibilityandButtonand run the app.
/*
+Button(onClick ...
+AnimatedVisibility(showImage) { ...
+*/
+RandomNumberList()
+- Exercise: Make the "Hello, .." button switch between showing the list and and the image.
🎯 Solutions
📖 Further reading
',44)]))}const u=t(r,[["render",p],["__file","index.html.vue"]]),h=JSON.parse('{"path":"/en/front-development/","title":"📚 Frontend development","lang":"en-US","frontmatter":{},"headers":[{"level":2,"title":"Kotlin Multiplatform (KMP)","slug":"kotlin-multiplatform-kmp","link":"#kotlin-multiplatform-kmp","children":[]},{"level":2,"title":"Kotlin/JS and Kotlin/WASM","slug":"kotlin-js-and-kotlin-wasm","link":"#kotlin-js-and-kotlin-wasm","children":[{"level":3,"title":"🧪 Kotlin/WASM web app","slug":"🧪-kotlin-wasm-web-app","link":"#🧪-kotlin-wasm-web-app","children":[]},{"level":3,"title":"Kotlin/JS and Kotlin/WASM common points","slug":"kotlin-js-and-kotlin-wasm-common-points","link":"#kotlin-js-and-kotlin-wasm-common-points","children":[]}]},{"level":2,"title":"Compose multiplatform","slug":"compose-multiplatform","link":"#compose-multiplatform","children":[{"level":3,"title":"🧪 Create a Compose multiplatform app","slug":"🧪-create-a-compose-multiplatform-app","link":"#🧪-create-a-compose-multiplatform-app","children":[]},{"level":3,"title":"🧪 Playing with the Compose multiplatform API","slug":"🧪-playing-with-the-compose-multiplatform-api","link":"#🧪-playing-with-the-compose-multiplatform-api","children":[]}]},{"level":2,"title":"🎯 Solutions","slug":"🎯-solutions","link":"#🎯-solutions","children":[]},{"level":2,"title":"📖 Further reading","slug":"📖-further-reading","link":"#📖-further-reading","children":[]}],"git":{"updatedTime":1729869737000,"contributors":[{"name":"yostane","email":"1958676+yostane@users.noreply.github.com","commits":1}]},"filePathRelative":"en/front-development/README.md"}');export{u as comp,h as data}; diff --git a/assets/kmp_codelab-CiTPMWjt.js b/assets/kmp_codelab-CiTPMWjt.js new file mode 100644 index 0000000..69a29a4 --- /dev/null +++ b/assets/kmp_codelab-CiTPMWjt.js @@ -0,0 +1 @@ +const s="/learning-kotlin/assets/kmp_codelab-J5AI0da_.png";export{s as _}; diff --git a/assets/kmp_codelab-J5AI0da_.png b/assets/kmp_codelab-J5AI0da_.png new file mode 100644 index 0000000..9ebc2b8 Binary files /dev/null and b/assets/kmp_codelab-J5AI0da_.png differ diff --git a/assets/kotlin-decision-tree-4i7nEr1Z.svg b/assets/kotlin-decision-tree-4i7nEr1Z.svg new file mode 100644 index 0000000..d3375a7 --- /dev/null +++ b/assets/kotlin-decision-tree-4i7nEr1Z.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/assets/kotlin-used-for-Bdlavnqs.js b/assets/kotlin-used-for-Bdlavnqs.js new file mode 100644 index 0000000..c91b22f --- /dev/null +++ b/assets/kotlin-used-for-Bdlavnqs.js @@ -0,0 +1 @@ +const s="/learning-kotlin/assets/kotlin-used-for-FU2DHhYT.png";export{s as _}; diff --git a/assets/kotlin-used-for-FU2DHhYT.png b/assets/kotlin-used-for-FU2DHhYT.png new file mode 100644 index 0000000..d023253 Binary files /dev/null and b/assets/kotlin-used-for-FU2DHhYT.png differ diff --git a/assets/kotlin-wasm-flag-BKaaN9Pq.png b/assets/kotlin-wasm-flag-BKaaN9Pq.png new file mode 100644 index 0000000..c51b253 Binary files /dev/null and b/assets/kotlin-wasm-flag-BKaaN9Pq.png differ diff --git a/assets/kotlin-wasm-webapp-R4_9ho9v.js b/assets/kotlin-wasm-webapp-R4_9ho9v.js new file mode 100644 index 0000000..d4ed5a8 --- /dev/null +++ b/assets/kotlin-wasm-webapp-R4_9ho9v.js @@ -0,0 +1 @@ +const s="/learning-kotlin/assets/kotlin-wasm-webapp-ViYyGRus.png";export{s as _}; diff --git a/assets/kotlin-wasm-webapp-ViYyGRus.png b/assets/kotlin-wasm-webapp-ViYyGRus.png new file mode 100644 index 0000000..0910b9d Binary files /dev/null and b/assets/kotlin-wasm-webapp-ViYyGRus.png differ diff --git a/assets/launch-android-app-BS4WBFFP.png b/assets/launch-android-app-BS4WBFFP.png new file mode 100644 index 0000000..0deef90 Binary files /dev/null and b/assets/launch-android-app-BS4WBFFP.png differ diff --git a/assets/logo_worldline-dinT9MYm.js b/assets/logo_worldline-dinT9MYm.js new file mode 100644 index 0000000..bba4f9b --- /dev/null +++ b/assets/logo_worldline-dinT9MYm.js @@ -0,0 +1 @@ +const o="/learning-kotlin/assets/logo_worldline-t5KadDQv.png";export{o as _}; diff --git a/assets/logo_worldline-t5KadDQv.png b/assets/logo_worldline-t5KadDQv.png new file mode 100644 index 0000000..6981642 Binary files /dev/null and b/assets/logo_worldline-t5KadDQv.png differ diff --git a/assets/setupDevtools-7MC2TMWH-TJgRKbnT.js b/assets/setupDevtools-7MC2TMWH-TJgRKbnT.js new file mode 100644 index 0000000..72faf8e --- /dev/null +++ b/assets/setupDevtools-7MC2TMWH-TJgRKbnT.js @@ -0,0 +1 @@ +import{s as T,w as E}from"./app-Djq7wF8p.js";var l="org.vuejs.vuepress",v="VuePress",I=v,r=l,N=v,i="client-data",a="Client Data",g=(p,n)=>{T({app:p,id:l,label:v,packageName:"@vuepress/client",homepage:"https://vuepress.vuejs.org",logo:"https://vuepress.vuejs.org/images/hero.png",componentStateTypes:[I]},t=>{const c=Object.entries(n),u=Object.keys(n),d=Object.values(n);t.on.inspectComponent(e=>{e.instanceData.state.push(...c.map(([s,o])=>({type:I,editable:!1,key:s,value:o.value})))}),t.addInspector({id:r,label:N,icon:"article"}),t.on.getInspectorTree(e=>{e.inspectorId===r&&(e.rootNodes=[{id:i,label:a,children:u.map(s=>({id:s,label:s}))}])}),t.on.getInspectorState(e=>{e.inspectorId===r&&(e.nodeId===i&&(e.state={[a]:c.map(([s,o])=>({key:s,value:o.value}))}),u.includes(e.nodeId)&&(e.state={[a]:[{key:e.nodeId,value:n[e.nodeId].value}]}))}),E(d,()=>{t.notifyComponentUpdate(),t.sendInspectorState(r)})})};export{g as setupDevtools}; diff --git a/assets/style-CIQ0kvik.css b/assets/style-CIQ0kvik.css new file mode 100644 index 0000000..05f22f0 --- /dev/null +++ b/assets/style-CIQ0kvik.css @@ -0,0 +1 @@ +.vp-back-to-top-button{position:fixed!important;inset-inline-end:1rem;bottom:4rem;z-index:100;width:48px;height:48px;padding:12px;border-width:0;border-radius:50%;background:var(--back-to-top-c-bg);color:var(--back-to-top-c-accent-bg);box-shadow:2px 2px 10px 4px var(--back-to-top-c-shadow);cursor:pointer}@media (max-width: 959px){.vp-back-to-top-button{transform:scale(.8);transform-origin:100% 100%}}@media print{.vp-back-to-top-button{display:none}}.vp-back-to-top-button:hover{color:var(--back-to-top-c-accent-hover)}.vp-back-to-top-button .back-to-top-icon{overflow:hidden;width:24px;height:24px;margin:0 auto;background:var(--back-to-top-c-icon);-webkit-mask-image:var(--back-to-top-icon);mask-image:var(--back-to-top-icon);-webkit-mask-position:50%;mask-position:50%;-webkit-mask-size:cover;mask-size:cover}.vp-scroll-progress{position:absolute;right:-2px;bottom:-2px;width:52px;height:52px}.vp-scroll-progress svg{width:100%;height:100%}.vp-scroll-progress circle{opacity:.9;transform:rotate(-90deg);transform-origin:50% 50%}.back-to-top-enter-active,.back-to-top-leave-active{transition:opacity .3s}.back-to-top-enter-from,.back-to-top-leave-to{opacity:0}:root{--back-to-top-z-index: 5;--back-to-top-icon: url("data:image/svg+xml,%3csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%2048%2048'%3e%3cpath%20fill='none'%20stroke='currentColor'%20stroke-linecap='round'%20stroke-linejoin='round'%20stroke-width='4'%20d='M24.008%2014.1V42M12%2026l12-12l12%2012M12%206h24'%20/%3e%3c/svg%3e");--back-to-top-c-bg: var(--vp-c-bg);--back-to-top-c-accent-bg: var(--vp-c-accent-bg);--back-to-top-c-accent-hover: var(--vp-c-accent-hover);--back-to-top-c-shadow: var(--vp-c-shadow);--back-to-top-c-icon: currentcolor}.vp-copy-code-button{position:absolute;top:.5em;right:.5em;z-index:5;width:2.5rem;height:2.5rem;padding:0;border-width:0;border-radius:.5rem;background:#0000;outline:none;opacity:0;cursor:pointer;transition:opacity .4s}@media print{.vp-copy-code-button{display:none}}.vp-copy-code-button:before{content:"";display:inline-block;width:1.25rem;height:1.25rem;padding:.625rem;background:currentcolor;color:var(--copy-code-c-text);font-size:1.25rem;-webkit-mask-image:var(--code-copy-icon);mask-image:var(--code-copy-icon);-webkit-mask-position:50%;mask-position:50%;-webkit-mask-size:1em;mask-size:1em;-webkit-mask-repeat:no-repeat;mask-repeat:no-repeat}.vp-copy-code-button:focus,.vp-copy-code-button.copied{opacity:1}.vp-copy-code-button:hover,.vp-copy-code-button.copied{background:var(--copy-code-c-hover)}.vp-copy-code-button.copied:before{-webkit-mask-image:var(--code-copied-icon);mask-image:var(--code-copied-icon)}.vp-copy-code-button.copied:after{content:attr(data-copied);position:absolute;top:0;right:calc(100% + .25rem);display:block;height:1.25rem;padding:.625rem;border-radius:.5rem;background:var(--copy-code-c-hover);color:var(--copy-code-c-text);font-weight:500;line-height:1.25rem;white-space:nowrap}.no-copy-code .vp-copy-code-button{display:none}body:not(.no-copy-code) div[class*=language-]:hover:before{display:none}body:not(.no-copy-code) div[class*=language-]:hover .vp-copy-code-button{opacity:1}:root{--code-copy-icon: url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='%23808080' stroke-width='2'%3e%3cpath stroke-linecap='round' stroke-linejoin='round' d='M9 5H7a2 2 0 0 0-2 2v12a2 2 0 0 0 2 2h10a2 2 0 0 0 2-2V7a2 2 0 0 0-2-2h-2M9 5a2 2 0 0 0 2 2h2a2 2 0 0 0 2-2M9 5a2 2 0 0 1 2-2h2a2 2 0 0 1 2 2' /%3e%3c/svg%3e");--code-copied-icon: url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='%23808080' stroke-width='2'%3e%3cpath stroke-linecap='round' stroke-linejoin='round' d='M9 5H7a2 2 0 0 0-2 2v12a2 2 0 0 0 2 2h10a2 2 0 0 0 2-2V7a2 2 0 0 0-2-2h-2M9 5a2 2 0 0 0 2 2h2a2 2 0 0 0 2-2M9 5a2 2 0 0 1 2-2h2a2 2 0 0 1 2 2m-6 9 2 2 4-4' /%3e%3c/svg%3e");--copy-code-c-text: var(--code-c-line-number);--copy-code-c-hover: var(--code-c-highlight-bg)}.hint-container{position:relative;border-color:var(--hint-c-accent);background:var(--hint-c-soft);transition:background var(--vp-t-color),color var(--vp-t-color)}@media print{.hint-container{page-break-inside:avoid}}.hint-container>.hint-container-title{color:var(--hint-c-title)}.hint-container :not(pre)>code{background:var(--hint-c-soft)}.hint-container .hint-container-title{position:relative;margin-block:.75em;font-weight:600;line-height:1.25}.hint-container.important,.hint-container.info,.hint-container.note,.hint-container.tip,.hint-container.warning,.hint-container.caution{margin-block:.75rem;padding:.25em 1em;border-radius:.5em;color:inherit;font-size:var(--hint-font-size)}@media print{.hint-container.important,.hint-container.info,.hint-container.note,.hint-container.tip,.hint-container.warning,.hint-container.caution{border-inline-start-width:.25em;border-inline-start-style:solid}}.hint-container.important .hint-container-title,.hint-container.info .hint-container-title,.hint-container.note .hint-container-title,.hint-container.tip .hint-container-title,.hint-container.warning .hint-container-title,.hint-container.caution .hint-container-title{padding-inline-start:1.75em}@media print{.hint-container.important .hint-container-title,.hint-container.info .hint-container-title,.hint-container.note .hint-container-title,.hint-container.tip .hint-container-title,.hint-container.warning .hint-container-title,.hint-container.caution .hint-container-title{padding-inline-start:0}}.hint-container.important .hint-container-title:before,.hint-container.info .hint-container-title:before,.hint-container.note .hint-container-title:before,.hint-container.tip .hint-container-title:before,.hint-container.warning .hint-container-title:before,.hint-container.caution .hint-container-title:before{content:" ";position:absolute;inset-inline-start:0;top:calc(50% - .6125em);width:1.25em;height:1.25em;font-size:1.25em}@media print{.hint-container.important .hint-container-title:before,.hint-container.info .hint-container-title:before,.hint-container.note .hint-container-title:before,.hint-container.tip .hint-container-title:before,.hint-container.warning .hint-container-title:before,.hint-container.caution .hint-container-title:before{display:none}}.hint-container.important p,.hint-container.info p,.hint-container.note p,.hint-container.tip p,.hint-container.warning p,.hint-container.caution p{line-height:1.5}.hint-container.important a,.hint-container.info a,.hint-container.note a,.hint-container.tip a,.hint-container.warning a,.hint-container.caution a{color:var(--vp-c-accent)}.hint-container.important{--hint-c-accent: var(--important-c-accent);--hint-c-title: var(--important-c-text);--hint-c-soft: var(--important-c-soft)}.hint-container.important>.hint-container-title:before{background-color:currentColor;-webkit-mask-image:url("data:image/svg+xml;utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 1024 1024'%3E%3Cpath d='M512 981.333a84.992 84.992 0 0 1-84.907-84.906h169.814A84.992 84.992 0 0 1 512 981.333zm384-128H128v-42.666l85.333-85.334v-256A298.325 298.325 0 0 1 448 177.92V128a64 64 0 0 1 128 0v49.92a298.325 298.325 0 0 1 234.667 291.413v256L896 810.667v42.666zm-426.667-256v85.334h85.334v-85.334h-85.334zm0-256V512h85.334V341.333h-85.334z'/%3E%3C/svg%3E");mask-image:url("data:image/svg+xml;utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 1024 1024'%3E%3Cpath d='M512 981.333a84.992 84.992 0 0 1-84.907-84.906h169.814A84.992 84.992 0 0 1 512 981.333zm384-128H128v-42.666l85.333-85.334v-256A298.325 298.325 0 0 1 448 177.92V128a64 64 0 0 1 128 0v49.92a298.325 298.325 0 0 1 234.667 291.413v256L896 810.667v42.666zm-426.667-256v85.334h85.334v-85.334h-85.334zm0-256V512h85.334V341.333h-85.334z'/%3E%3C/svg%3E");-webkit-mask-position:50%;mask-position:50%;-webkit-mask-size:1em;mask-size:1em;-webkit-mask-repeat:no-repeat;mask-repeat:no-repeat}.hint-container.info{--hint-c-accent: var(--info-c-accent);--hint-c-title: var(--info-c-text);--hint-c-soft: var(--info-c-soft)}.hint-container.info>.hint-container-title:before{background-color:currentColor;-webkit-mask-image:url("data:image/svg+xml;utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'%3E%3Cpath d='M12 22C6.477 22 2 17.523 2 12S6.477 2 12 2s10 4.477 10 10-4.477 10-10 10zm-1-11v6h2v-6h-2zm0-4v2h2V7h-2z'/%3E%3C/svg%3E");mask-image:url("data:image/svg+xml;utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'%3E%3Cpath d='M12 22C6.477 22 2 17.523 2 12S6.477 2 12 2s10 4.477 10 10-4.477 10-10 10zm-1-11v6h2v-6h-2zm0-4v2h2V7h-2z'/%3E%3C/svg%3E");-webkit-mask-position:50%;mask-position:50%;-webkit-mask-size:1em;mask-size:1em;-webkit-mask-repeat:no-repeat;mask-repeat:no-repeat}.hint-container.note{--hint-c-accent: var(--note-c-accent);--hint-c-title: var(--note-c-text);--hint-c-soft: var(--note-c-soft)}.hint-container.note>.hint-container-title:before{background-color:currentColor;-webkit-mask-image:url("data:image/svg+xml;utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'%3E%3Cpath d='M12 22C6.477 22 2 17.523 2 12S6.477 2 12 2s10 4.477 10 10-4.477 10-10 10zm-1-11v6h2v-6h-2zm0-4v2h2V7h-2z'/%3E%3C/svg%3E");mask-image:url("data:image/svg+xml;utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'%3E%3Cpath d='M12 22C6.477 22 2 17.523 2 12S6.477 2 12 2s10 4.477 10 10-4.477 10-10 10zm-1-11v6h2v-6h-2zm0-4v2h2V7h-2z'/%3E%3C/svg%3E");-webkit-mask-position:50%;mask-position:50%;-webkit-mask-size:1em;mask-size:1em;-webkit-mask-repeat:no-repeat;mask-repeat:no-repeat}.hint-container.tip{--hint-c-accent: var(--tip-c-accent);--hint-c-title: var(--tip-c-text);--hint-c-soft: var(--tip-c-soft)}.hint-container.tip>.hint-container-title:before{background-color:currentColor;-webkit-mask-image:url("data:image/svg+xml;utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'%3E%3Cpath d='M7.941 18c-.297-1.273-1.637-2.314-2.187-3a8 8 0 1 1 12.49.002c-.55.685-1.888 1.726-2.185 2.998H7.94zM16 20v1a2 2 0 0 1-2 2h-4a2 2 0 0 1-2-2v-1h8zm-3-9.995V6l-4.5 6.005H11v4l4.5-6H13z'/%3E%3C/svg%3E");mask-image:url("data:image/svg+xml;utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'%3E%3Cpath d='M7.941 18c-.297-1.273-1.637-2.314-2.187-3a8 8 0 1 1 12.49.002c-.55.685-1.888 1.726-2.185 2.998H7.94zM16 20v1a2 2 0 0 1-2 2h-4a2 2 0 0 1-2-2v-1h8zm-3-9.995V6l-4.5 6.005H11v4l4.5-6H13z'/%3E%3C/svg%3E");-webkit-mask-position:50%;mask-position:50%;-webkit-mask-size:1em;mask-size:1em;-webkit-mask-repeat:no-repeat;mask-repeat:no-repeat}.hint-container.warning{--hint-c-accent: var(--warning-c-accent);--hint-c-title: var(--warning-c-text);--hint-c-soft: var(--warning-c-soft)}.hint-container.warning>.hint-container-title:before{background-color:currentColor;-webkit-mask-image:url("data:image/svg+xml;utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 1024 1024'%3E%3Cpath d='M576.286 752.57v-95.425q0-7.031-4.771-11.802t-11.3-4.772h-96.43q-6.528 0-11.3 4.772t-4.77 11.802v95.424q0 7.031 4.77 11.803t11.3 4.77h96.43q6.528 0 11.3-4.77t4.77-11.803zm-1.005-187.836 9.04-230.524q0-6.027-5.022-9.543-6.529-5.524-12.053-5.524H456.754q-5.524 0-12.053 5.524-5.022 3.516-5.022 10.547l8.538 229.52q0 5.023 5.022 8.287t12.053 3.265h92.913q7.032 0 11.803-3.265t5.273-8.287zM568.25 95.65l385.714 707.142q17.578 31.641-1.004 63.282-8.538 14.564-23.354 23.102t-31.892 8.538H126.286q-17.076 0-31.892-8.538T71.04 866.074q-18.582-31.641-1.004-63.282L455.75 95.65q8.538-15.57 23.605-24.61T512 62t32.645 9.04 23.605 24.61z'/%3E%3C/svg%3E");mask-image:url("data:image/svg+xml;utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 1024 1024'%3E%3Cpath d='M576.286 752.57v-95.425q0-7.031-4.771-11.802t-11.3-4.772h-96.43q-6.528 0-11.3 4.772t-4.77 11.802v95.424q0 7.031 4.77 11.803t11.3 4.77h96.43q6.528 0 11.3-4.77t4.77-11.803zm-1.005-187.836 9.04-230.524q0-6.027-5.022-9.543-6.529-5.524-12.053-5.524H456.754q-5.524 0-12.053 5.524-5.022 3.516-5.022 10.547l8.538 229.52q0 5.023 5.022 8.287t12.053 3.265h92.913q7.032 0 11.803-3.265t5.273-8.287zM568.25 95.65l385.714 707.142q17.578 31.641-1.004 63.282-8.538 14.564-23.354 23.102t-31.892 8.538H126.286q-17.076 0-31.892-8.538T71.04 866.074q-18.582-31.641-1.004-63.282L455.75 95.65q8.538-15.57 23.605-24.61T512 62t32.645 9.04 23.605 24.61z'/%3E%3C/svg%3E");-webkit-mask-position:50%;mask-position:50%;-webkit-mask-size:1em;mask-size:1em;-webkit-mask-repeat:no-repeat;mask-repeat:no-repeat}.hint-container.caution{--hint-c-accent: var(--caution-c-accent);--hint-c-title: var(--caution-c-text);--hint-c-soft: var(--caution-c-soft)}.hint-container.caution>.hint-container-title:before{background-color:currentColor;-webkit-mask-image:url("data:image/svg+xml;utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'%3E%3Cpath d='M12 2c5.523 0 10 4.477 10 10v3.764a2 2 0 0 1-1.106 1.789L18 19v1a3 3 0 0 1-2.824 2.995L14.95 23a2.5 2.5 0 0 0 .044-.33L15 22.5V22a2 2 0 0 0-1.85-1.995L13 20h-2a2 2 0 0 0-1.995 1.85L9 22v.5c0 .171.017.339.05.5H9a3 3 0 0 1-3-3v-1l-2.894-1.447A2 2 0 0 1 2 15.763V12C2 6.477 6.477 2 12 2zm-4 9a2 2 0 1 0 0 4 2 2 0 0 0 0-4zm8 0a2 2 0 1 0 0 4 2 2 0 0 0 0-4z'/%3E%3C/svg%3E");mask-image:url("data:image/svg+xml;utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'%3E%3Cpath d='M12 2c5.523 0 10 4.477 10 10v3.764a2 2 0 0 1-1.106 1.789L18 19v1a3 3 0 0 1-2.824 2.995L14.95 23a2.5 2.5 0 0 0 .044-.33L15 22.5V22a2 2 0 0 0-1.85-1.995L13 20h-2a2 2 0 0 0-1.995 1.85L9 22v.5c0 .171.017.339.05.5H9a3 3 0 0 1-3-3v-1l-2.894-1.447A2 2 0 0 1 2 15.763V12C2 6.477 6.477 2 12 2zm-4 9a2 2 0 1 0 0 4 2 2 0 0 0 0-4zm8 0a2 2 0 1 0 0 4 2 2 0 0 0 0-4z'/%3E%3C/svg%3E");-webkit-mask-position:50%;mask-position:50%;-webkit-mask-size:1em;mask-size:1em;-webkit-mask-repeat:no-repeat;mask-repeat:no-repeat}.hint-container.details{position:relative;display:block;margin-block:.75rem;padding:1.25rem 1rem;border-radius:.5rem;background:var(--detail-c-bg);transition:background var(--vp-t-transform),color var(--vp-t-transform)}.hint-container.details h4{margin-top:0}.hint-container.details figure:last-child,.hint-container.details p:last-child{margin-bottom:0;padding-bottom:0}.hint-container.details a{color:var(--vp-c-accent)}.hint-container.details :not(pre)>code{background:var(--detail-c-soft)}.hint-container.details summary{position:relative;margin:-1rem;padding-block:1em;padding-inline:3em 1.5em;list-style:none;font-size:var(--hint-font-size);cursor:pointer}.hint-container.details summary::-webkit-details-marker{display:none}.hint-container.details summary::marker{color:#0000;font-size:0}.hint-container.details summary:before{background-color:currentColor;-webkit-mask-image:url("data:image/svg+xml;utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'%3E%3Cpath d='M7.41 15.41L12 10.83l4.59 4.58L18 14l-6-6-6 6z'/%3E%3C/svg%3E");mask-image:url("data:image/svg+xml;utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'%3E%3Cpath d='M7.41 15.41L12 10.83l4.59 4.58L18 14l-6-6-6 6z'/%3E%3C/svg%3E");-webkit-mask-position:50%;mask-position:50%;-webkit-mask-size:1em;mask-size:1em;-webkit-mask-repeat:no-repeat;mask-repeat:no-repeat;content:" ";position:absolute;inset-inline-start:.8em;top:calc(50% - .5em);width:1em;height:1em;font-size:1.25rem;line-height:normal;transition:color,var(--vp-t-color),transform var(--vp-t-transform);transform:rotate(90deg)}.hint-container.details[open]>summary{margin-bottom:.5em}.hint-container.details[open]>summary:before{transform:rotate(180deg)}:root{--hint-font-size: .9rem;--important-c-accent: var(--vp-c-purple-bg);--important-c-text: var(--vp-c-purple-text);--important-c-soft: var(--vp-c-purple-soft);--info-c-accent: var(--vp-c-blue-bg);--info-c-text: var(--vp-c-blue-text);--info-c-soft: var(--vp-c-blue-soft);--note-c-accent: var(--vp-c-grey-bg);--note-c-text: var(--vp-c-grey-text);--note-c-soft: var(--vp-c-grey-soft);--tip-c-accent: var(--vp-c-green-bg);--tip-c-text: var(--vp-c-green-text);--tip-c-soft: var(--vp-c-green-soft);--warning-c-accent: var(--vp-c-yellow-bg);--warning-c-text: var(--vp-c-yellow-text);--warning-c-soft: var(--vp-c-yellow-soft);--caution-c-accent: var(--vp-c-red-bg);--caution-c-text: var(--vp-c-red-text);--caution-c-soft: var(--vp-c-red-soft);--detail-c-bg: var(--vp-c-control);--detail-c-icon: var(--vp-c-border);--detail-c-soft: var(--vp-c-grey-soft)}:root{--nprogress-c: var(--vp-c-accent);--nprogress-z-index: 1031}#nprogress{pointer-events:none}#nprogress .bar{position:fixed;top:0;left:0;z-index:var(--nprogress-z-index);width:100%;height:2px;background:var(--nprogress-c)}:root{--code-padding-x: 1.25rem;--code-padding-y: 1rem;--code-border-radius: 6px;--code-line-height: 1.6;--code-font-size: 14px;--code-font-family: consolas, monaco, "Andale Mono", "Ubuntu Mono", monospace}div[class*=language-]{position:relative;border-radius:var(--code-border-radius);background-color:var(--code-c-bg)}div[class*=language-]:before{content:attr(data-title);position:absolute;top:.8em;right:1em;z-index:3;color:var(--code-c-text);font-size:.75rem}div[class*=language-] pre{position:relative;z-index:1;overflow-x:auto;margin:0;border-radius:var(--code-border-radius);font-size:var(--code-font-size);font-family:var(--code-font-family);line-height:var(--code-line-height)}div[class*=language-] pre code{display:block;box-sizing:border-box;width:-moz-fit-content;width:fit-content;min-width:100%;padding:var(--code-padding-y) var(--code-padding-x);background-color:#0000!important;color:var(--code-c-text);overflow-wrap:unset;-webkit-font-smoothing:auto;-moz-osx-font-smoothing:auto}:root{--code-c-text: #f8f8f2;--code-c-bg: #2e3440;--code-c-highlight-bg: rgb(51.6454545455, 60.5484848485, 78.3545454545);--code-c-line-number: rgba(248, 248, 242, .67)}.token.comment,.token.prolog,.token.doctype,.token.cdata{color:#636f88}.token.punctuation{color:#81a1c1}.namespace{opacity:.7}.token.property,.token.tag,.token.constant,.token.symbol,.token.deleted{color:#81a1c1}.token.number{color:#b48ead}.token.boolean{color:#81a1c1}.token.selector,.token.attr-name,.token.string,.token.char,.token.builtin,.token.inserted{color:#a3be8c}.token.operator,.token.entity,.token.url,.language-css .token.string,.style .token.string,.token.variable{color:#81a1c1}.token.atrule,.token.attr-value,.token.function,.token.class-name{color:#88c0d0}.token.keyword{color:#81a1c1}.token.regex,.token.important{color:#ebcb8b}.token.important,.token.bold{font-weight:700}.token.italic{font-style:italic}.token.entity{cursor:help}:root{--code-line-number-width: 3rem}div[class*=language-]:not(.line-numbers-mode) .line-numbers{display:none}div[class*=language-].line-numbers-mode:after{content:"";position:absolute;top:0;left:0;width:var(--code-line-number-width);height:100%;border-right:1px solid var(--code-c-highlight-bg, var(--code-c-text));border-radius:var(--code-border-radius) 0 0 var(--code-border-radius);transition:border var(--vp-t-color)}div[class*=language-].line-numbers-mode pre{vertical-align:middle;margin-left:var(--code-line-number-width)}div[class*=language-].line-numbers-mode code{padding-left:1rem}div[class*=language-].line-numbers-mode .line-numbers{counter-reset:line-number;position:absolute;top:0;width:var(--code-line-number-width);padding-top:var(--code-padding-y);color:var(--code-c-line-number, var(--code-c-text));font-size:var(--code-font-size);line-height:var(--code-line-height);text-align:center}div[class*=language-].line-numbers-mode .line-number{position:relative;z-index:3;font-family:var(--code-font-family);-webkit-user-select:none;-moz-user-select:none;user-select:none}div[class*=language-].line-numbers-mode .line-number:before{content:counter(line-number);counter-increment:line-number}div[class*=language-] .line.highlighted{display:inline-block;width:100%;margin:0 calc(-1*var(--code-padding-x));padding:0 var(--code-padding-x);background-color:var(--code-c-highlight-bg)}div[class*=language-].has-collapsed-lines.collapsed{overflow-y:hidden;height:calc(var(--vp-collapsed-lines)*var(--code-line-height)*var(--code-font-size) + var(--code-padding-y) + 28px)}div[class*=language-].has-collapsed-lines .collapsed-lines{--vp-collapsed-lines-bg: var(--code-c-bg);position:absolute;right:0;bottom:0;left:0;z-index:4;display:flex;align-items:center;justify-content:center;height:28px;background:linear-gradient(to bottom,transparent 0%,var(--vp-collapsed-lines-bg) 55%,var(--vp-collapsed-lines-bg) 100%);cursor:pointer;transition:--vp-collapsed-lines-bg var(--vp-t-color)}div[class*=language-].has-collapsed-lines .collapsed-lines:hover{--vp-collapsed-lines-bg: rgb(0 0 0 / 10%) !important}div[class*=language-].has-collapsed-lines[data-highlighter=shiki] .collapsed-lines{--vp-collapsed-lines-bg: var(--code-c-bg, var(--shiki-light-bg))}[data-theme=dark] div[class*=language-].has-collapsed-lines[data-highlighter=shiki] .collapsed-lines{--vp-collapsed-lines-bg: var(--code-c-bg, var(--shiki-dark-bg))}div[class*=language-].has-collapsed-lines .collapsed-lines:before{--icon: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='1em' height='1em' viewBox='0 0 24 24'%3E%3Cpath fill='none' stroke='%23000' stroke-width='2' d='m18 12l-6 6l-6-6m12-6l-6 6l-6-6'/%3E%3C/svg%3E");--vp-collapsed-lines-rotate: 0deg;content:"";display:inline-block;width:24px;height:24px;background-color:var(--code-c-text);-webkit-mask-image:var(--icon);mask-image:var(--icon);-webkit-mask-position:50%;mask-position:50%;-webkit-mask-size:20px;mask-size:20px;-webkit-mask-repeat:no-repeat;mask-repeat:no-repeat;pointer-events:none;animation:code-collapsed-lines 1.2s infinite alternate-reverse ease-in-out}div[class*=language-].has-collapsed-lines:not(.collapsed) code{padding-bottom:max(var(--code-padding-y),28px)}div[class*=language-].has-collapsed-lines:not(.collapsed) .collapsed-lines:hover{--vp-collapsed-lines-bg: transparent !important}div[class*=language-].has-collapsed-lines:not(.collapsed) .collapsed-lines:before{--vp-collapsed-lines-rotate: 180deg}@property --vp-collapsed-lines-bg{inherits:false;initial-value:#fff;syntax:"
📚 Backend development
Many frameworks officially support Kotlin: Spring, Quarkus, Ktor, among others listed here.
In addition to that, Kotlin is theoretically compatible with any framework that targets the JVM or JS. For example, this tutorial shows how to use node.js with Kotlin. However, frameworks that do not officially support Kotlin may require some tweaking to use it.
Ktor
Ktor is a cross-platform Kotlin library for building both HTTP clients and servers. This makes Ktor a useful library to learn for both front-end developers for its HTTP client capabilities and backend-development for its HTTP server capabilities. In the following, we'll create a REST API with Ktor server.
🧪 develop an API with Ktor
- Create a project on start.ktor.io with the following plugins: Content Negotiation, kotlinx.serialization, and Routing.
- Click on "Generate project".
- Download the archive, unzip it, and open the project with IntelliJ.
- Create a
modelspackage and add to it aCustomerdata class with these immutable propertiesid: String, firstName: String, lastName: String, email: String. - Annotate the class with
@Serializable. - Create a new package named
routesand add to it a fileCustomerRoutes.ktthat will contain the code for the/customerendpoint. - The code below provides the implementation of some endpoints. Please implement the remaining ones.
- To enable the route call
customerRouting()in the routing configuration file located inplugins/Routing.kt. - For simplicity, use a global in-memory list of customers
val store = mutableListOf<Customer>(). - Run the server by running the main method.
- Test the api on the IDE by using an http file or using any other client.
CustomerRoutes.kt
val store = mutableListOf<Customer>()
+
+fun Route.customerRouting() {
+ route("/customer") {
+ get {
+ call.respond(store)
+ }
+ get("{id?}") {
+ val id = call.parameters["id"] ?: return@get call.respondText(
+ "Missing id",
+ status = HttpStatusCode.BadRequest
+ )
+ val customer =
+ store.find { it.id == id } ?: return@get call.respondText(
+ "No customer with id $id",
+ status = HttpStatusCode.NotFound
+ )
+ call.respond(customer)
+ }
+ post {
+ val customer = call.receive<Customer>()
+ store.add(customer)
+ call.respondText("Customer stored correctly", status = HttpStatusCode.Created)
+ }
+ delete("{id?}") {
+
+ }
+ }
+}
+plugins/Routing.kt
fun Application.configureRouting() {
+ routing {
+ customerRouting()
+ }
+}
+return@label
You can specify which level you want to return with an explicit label using return@lambda.
lambdaA {
+ lambdaB {
+ lambdaC {
+ val randomInt = Random.nextInt(0, 100)
+ if (randomInt > 50) return@lambdaC else return@lambdaB
+ }
+ printf("In lambdaB")
+ }
+}
+CustomerTest.http
POST http://127.0.0.1:8080/customer
+Content-Type: application/json
+
+{
+ "id": "100",
+ "firstName": "Jane",
+ "lastName": "Smith",
+ "email": "jane.smith@company.com"
+}
+
+
+###
+POST http://127.0.0.1:8080/customer
+Content-Type: application/json
+
+{
+ "id": "200",
+ "firstName": "John",
+ "lastName": "Smith",
+ "email": "john.smith@company.com"
+}
+
+###
+POST http://127.0.0.1:8080/customer
+Content-Type: application/json
+
+{
+ "id": "300",
+ "firstName": "Mary",
+ "lastName": "Smith",
+ "email": "mary.smith@company.com"
+}
+
+
+###
+GET http://127.0.0.1:8080/customer
+Accept: application/json
+
+###
+GET http://127.0.0.1:8080/customer/200
+Accept: application/json
+
+###
+GET http://127.0.0.1:8080/customer/500
+Accept: application/json
+
+###
+DELETE http://127.0.0.1:8080/customer/100
+
+###
+DELETE http://127.0.0.1:8080/customer/500
+Spring framework
Spring is a famous framework for developing server-side applications: APIs, server generated web pages, microservices, etc. It relies on the the Java ecosystem to build and run, thus making it compatible with Kotlin. Even better, Spring officially supports Kotlin. It even allows in start a new project with Kotlin and Gradle-Kotlin. In the next section, we'll use this starter to recreate our above REST API with Spring.
🧪 Spring boot part 1 - develop the same API with Spring Boot
- Create a project on start.spring.io (also called Spring initializr) with the following dependencies: Spring Web and Spring Boot DevTools.
- Choose Kotlin as the language and Kotlin-Grade as the project manager.
- Add these dependencies: Spring Web, Spring Boot DevTools, h2 database and Spring Data JPA.
- Click on "Generate". Download the archive, unzip it, and open the project with IntelliJ (preferably) or VSCode.
- For VSCode, install a Kotlin extension and Spring Boot Extension Pack ( ⚠️ Spring extension do not seem to support kotlin).
- Create
Customerdata class in themodelpackage without the@Serializableannotation. - Create a
controllerpackage that contains aCustomerControllerclass which provides a CRUD using a global list. You can find a skeleton below.- 💡 In Spring, Rest controllers serve the purpose of Ktor routes, where a controller defines a REST resource.
- Define the same endpoints as in the previous PW.
- Start the REST API server by running
.\gradlew bootRunor from your IDE. - Please test the endpoints with a REST client. You can find http files here in JetBrains format or VSCode's REST Client extension
CustomerController.kt
val store = mutableListOf<Customer>()
+
+@RestController
+@RequestMapping("/customer")
+class CustomerController {
+ @GetMapping
+ fun getAll() = store
+
+ @GetMapping("{id}")
+ fun getById(@PathVariable id: String) { /* TODO: implement */ }
+
+ @PostMapping
+ fun addOne(@RequestBody customer: Customer) { /* TODO: implement */ }
+
+ @DeleteMapping("{id}")
+ fun deleteOne(@PathVariable id: String) { /* TODO: implement */ }
+}
+Models or model package ? plural or not ?
Both are ok as long as you follow the same convention in the project.
🧪 Spring boot part 2 - adding a database
Let's go a little bit further by storing data in a database and writing some tests.
We'll use the H2 in-memory database for the sake of simplicity, since it does not require a server to run. Classes will mapped to database tables with JPA annotations. The database API we'll be using is called JPARepository. It is a lightweight API that provides common CRUD features by just defining an interface.
On the testing side, we'll see two different syntaxes. The default one that is more familiar with Java style and the DSL one which is more readable and more familiar with Kotlin developers.
- Create a new Spring project using Spring initializr with Kotlin and the following dependencies: Spring Data JPA, H2 Database, Spring Boot DevTools, Spring Web
- Open the project and add this class in the
modelpackage@Entity class Product(@Id @GeneratedValue var id: Long? = null, var name: String, var price: Int). This single defines the class as well as the minimal JPA annotations (@Entity,@Idand@GeneratedValue) to generate the corresponding table. - In the
repositorypackage, declare theProductRepositoryinterface as followsinterface ProductRepository: JpaRepository<Product, Long>. This is enough for Spring to generate an implementation with common features as we'll see later. - Next, create a
ProductServiceclass which will contain the business logic. In terms of architecture, the controller calls a service which in turn rely on other services or repositories.
ProductService.kt
@Service
+class ProductService(@Autowired val productRepository: ProductRepository) {
+ fun getAll() = productRepository.findAll()
+
+ // use findByIdOrNull instad of findById because the latter returns an optional<Product> instead of Product?
+ fun getById(id: Long) = productRepository.findByIdOrNull(id)
+}
+- In the controller package, create a
ProductControllerclass that is mapped to/productand injects the with@Autowired. Reply to@Getas follows.
ProductController.kt
@RestController
+@RequestMapping("/product")
+class ProductController(@Autowired val productService: ProductService) {
+ @GetMapping fun getAll() = productService.getAll()
+
+ @GetMapping("{id}")
+ fun getById(@PathVariable id: Long) =
+ productService.getById(id) ?: throw ResponseStatusException(HttpStatus.NOT_FOUND)
+}
+Kotlin makes getById(@PathVariable id: Long) more concise
The Elvis operator ?: allows to simplify the code. Here is a longer version as reference.
@GetMapping("{id}")
+fun getById(@PathVariable id: Long): Product {
+ val product = productService.getById(id)
+ if (product != null){
+ return product
+ }
+ throw ResponseStatusException(HttpStatus.NOT_FOUND)
+}
+In addition to that, Spring provides @ControllerAdvice to change the exception message. You can see an example here.
- Let's run the project. Before running the project, we need to add a plugin that allows Kotlin classes to generate a default constructor
id("org.jetbrains.kotlin.plugin.jpa") version "1.8.10". The plugins should look as follows:
plugins {
+ id("org.jetbrains.kotlin.plugin.jpa") version "1.8.10"
+ id("org.springframework.boot") version "3.0.4"
+ id("io.spring.dependency-management") version "1.1.0"
+ kotlin("jvm") version "1.8.10"
+ kotlin("plugin.spring") version "1.8.10"
+}
+- As an exercise, implement these endpoints: POST a single product, DELETE by id (
/product/{id}) and GET by id (/product/{id}).- Hint:
ProductControlleralready provides the necessary methods.
- Hint:
- Call the different endpoints with a REST client.
🧪 Spring boot part 2 - adding tests
Spring frameworks helps perform different types of tests by providing different classes out of the box:
- Unit testing of services, repositories and the REST API. This is done through mock utilities such as
MockMVC. - Integration testing of the REST API using
TestRestTemplate. In this situation, a full server is run and tested.
Most, if not all classes provided by Spring provide an elegant syntax for Java developers. Some of them go further by taking advantage of Kotlin specific features. In the following, we're going to focus on parts that provide Kotlin DSLs, namely unit testing the REST API with MockMVC.
- Create a test class
ProductControllerUnitTestswith this initial content.MockMvcallows to unit test the REST API. The@AutoConfigureMockMvcannotation allows spring to configure it automatically
@SpringBootTest
+@AutoConfigureMockMvc
+class ProductControllerTests(
+ @Autowired val mockMvc: MockMvc,
+ @Autowired val productRepository: ProductRepository) {
+
+ @BeforeEach
+ fun reset(){
+ productRepository.deleteAll()
+ }
+}
+- Add these two tests. The first one uses a classic approach while the second take advantage of Kotlin DSL capabilities. In addition to that, we name using a more readable string literal
- As an exercise, unit tests for the other endpoints.
The request builder of JpaRepository
Spring repositories implement requests based on the name of their methods. For example, to get all products sorted by name, we can add this method to the interface.
interface ProductRepository: JpaRepository<Product, Long> {
+ fun findAllByOrderByNameAsc(): List<Product>;
+}
+The official documentation provides more detailed explanations and examples.
node.js
Thanks to Kotlin/JS, we can write apps that target node.js using Kotlin. We can even import npm libraries as long as you declare the JS API surface that you'll be using in Kotlin. This is called external declaration (You can think of it as an equivalent of TypeScript's type definitions) that declares the symbols that we want to access in Kotlin thanks to @JsModule and @JsNonModule annotations.
Defining such external declarations can be a hassle and there seems to be no official automatic generator (dukat has been removed in kotlin 1.8.20). In that case, we have two options, either we write the external declaration ourselves or import it as a dependency if available. Fortunately for express developers, chrisnkrueger/kotlin-express provides declarations for the express library.
There are two gradle plugins that allow to create node.js projects: the kotlin("js") one and the kotlin("multiplatform") one. The difference between the two plugins is that the former only supports JS or WASM while the latter supports more platforms but requires to configure source sets. Thus, the former may seem easier to setup but the latter is better in the long run because it allows us to get more familiar with Kotlin Multiplatform (KMP).
🧪 Getting started with Kotlin/JS and Express
At the time of writing, I didn't find an official wizard or starter project. So we'll create one from scratch using gradle init.
- Create a new Gradle project using IntelliJ or by running
gradle initin a empty folder (see below for the replies to thegradle initcommand).
gradle init
gradle init
+Starting a Gradle Daemon, 1 incompatible and 1 stopped Daemons could not be reused, use --status for details
+
+Select type of project to generate:
+ 1: basic
+ 2: application
+ 3: library
+ 4: Gradle plugin
+Enter selection (default: basic) [1..4] 1
+
+Select build script DSL:
+ 1: Kotlin
+ 2: Groovy
+Enter selection (default: Kotlin) [1..2] 1
+
+Project name (default: starter): rest-api-kotlin-nodejs
+
+Generate build using new APIs and behavior (some features may change in the next minor release)? (default: no) [yes, no] yes
+
+
+> Task :init
+To learn more about Gradle by exploring our Samples at https://docs.gradle.org/8.3/samples
+
+BUILD SUCCESSFUL in 24s
+2 actionable tasks: 2 executed
+- In build.gradle.kts, add and configure the
kotlin("multiplatform")plugin. Also add theexpressanddev.chriskrueger:kotlin-expressdependencies.
build.gradle.kts
plugins {
+ kotlin("multiplatform") version "1.9.20-Beta"
+}
+
+repositories {
+ mavenCentral()
+}
+
+group = "tech.worldline.demo"
+version = "1.0-SNAPSHOT"
+
+kotlin {
+ js {
+ nodejs {
+ }
+ binaries.executable()
+ useCommonJs()
+ }
+
+ sourceSets {
+ val jsMain by getting {
+ dependencies {
+ implementation(npm("express", "> 4.0.0 < 5.0.0"))
+ implementation("dev.chriskrueger:kotlin-express:1.2.0")
+ }
+ }
+ }
+}
+Some notes on the build file
- express dependency is retrieved from npm
useCommonJs()is required to be able to use chrisnkrueger/kotlin-express in our code.
- create a main.kt file in src/jsMain/kotlin with the following content:
main.kt
data class Message(val id: Int, val message: String)
+
+val messages = mutableListOf(Message(0, "I love Kotlin/JS"))
+
+fun main() {
+ val app = express.Express()
+
+ // REST API that provides a **GET /hello** endpoint
+ app.get("/hello") { _, res ->
+ res.send(messages)
+ }
+
+ // Create a server that listens to port 3000
+ app.listen(3000) {
+ console.log("server start at port 3000")
+ }
+}
+- Run the task
jsRunfrom IntelliJ of from the command line./gradlew --console=plain jsRun. The server should start running. - Open the hello endpoint on http://localhost:3000/hello
Execution failed for task ':kotlinStoreYarnLock'
If you get this error:
Execution failed for task ':kotlinStoreYarnLock'.
+> yarn.lock was changed. Run the `kotlinUpgradeYarnLock` task to actualize yarn.lock file
+Run ./gradlew kotlinUpgradeYarnLock so that yarn.lock is updated
🧪 Adding a post endpoint and an external Kotlin/JS definition
Let's add a post endpoint which reads the body as a json. In order to read the body as json, we must add this possibility to express by importing the npm library body-parser and by calling app.use(bodyParser.json()). Once this setup is complete, req.body will contain the content of the body. However, there is no available external definition for bodyParser as of the time of writing. Thus, we must create or own external definition.
- First, add the body-parser dependncy in the build file
implementation(npm("body-parser", "> 1.0.0 < 2.0.0")) - Next, we would write:
app.use(bodyparser.json())to activate the library. Let's guess what a minimal definition ofbodyparsercan be.
BodyParser.kt
// external means that this class is defined in JS
+external class BodyParser {
+ // we tell Kotlin that we want to use the json() function.
+ fun json(): Any
+ // It is not required to define all the functions of the module
+}
+
+// @JsModule is used to import the module from the NPM registry
+@JsModule("body-parser")
+external val bodyParser: BodyParser
+- Finally, we just need to add the BodyParser.kt file into the project and use it in our server.
main.kt
app.use(bodyParser.json())
+app.post("/hello") { req, res ->
+ // Kotlin does not keep the original field name when parsing JSON from JS (you can see it the in get response)
+ if (req.body as? Message == null) {
+ println("failed to get the body from Kotlin")
+ }
+ // Thus, we need to use js() to get the the field by its expected name
+ // js() calls JS from Kotlin
+ println("req.body from JS ${js("req.body.id")} - ${js("req.body.message")}")
+ val id = js("req.body.id") as? Int
+ val message = js("req.body.message") as? String
+ if (message != null && id != null) {
+ messages.add(Message(id, message))
+ res.status(201).end()
+ } else {
+ res.status(400).send(js("{cause : 'error'}") as Any)
+ }
+}
+🧪 Adding more endpoints
- Add PUT and DELETE endpoints
🎯 Solutions
- ktor Rest API
- Spring boot Rest API
- The starter and final node.js projects are available here
Other frameworks
Micronaut and Quarkus
Micronaut and Quarkus are two other frameworks that support Kotlin. Bootstrap websites are available here and here.
📖 Further readings
These official tutorials go even further:
- This tutorial from kotlinlang shows how to create a RESTful web service with a database using Spring Boot.
- This one from spring.io show how to build a web application with Spring Boot and Kotlin.
- Rest ÄPIs with Spring
- Quarkus and kotlin
References
📚 Frontend development
Kotlin supports a wide selection of frontend frameworks across all platforms: mobile, desktop and web.
Please find below a glimpse of the possibilities that you can do right from IntelliJ:
- On the Desktop side
- Thanks to JVM support, Kotlin supports JavaFX (There was a Kotlin counterpart called tornadofx which is not maintained anymore).
- Compose Multiplatform brings Jetpack Compose to the desktop, the web and mobile.
- On the Web
- Ktor can use templates engines such as FreeMarker to create server pages.
- With KotlinJS, developers can create React, nodsjs, or vanilla JS Apps using Kotlin.
- Kotlin WASM compiles into Web Assembly. It can complement KotlinJS for computation intensive tasks.
- On Mobiles
- Android developers use the Jetpack Compose UI Framework or the legacy xml layouts. It is experimental on iOS.
Kotlin supports cross platform frontend development thanks to Kotlin MultiPlatform (KMP)
Kotlin Multiplatform (KMP)
"The Kotlin Multiplatform technology is designed to simplify the development of cross-platform projects. It reduces time spent writing and maintaining the same code for different platforms while retaining the flexibility and benefits of native programming." ₁
KMP relies on Kotlin native and other Kotlin features to help developers create projects that target multiple platforms using a common Kotlin code-base.
Many combinations of targets and use cases are possible:
- Full-Stack web apps: A project that contains a backend and a web app while sharing common logic.
- Multiplatform libraries
Kotlin/JS and Kotlin/WASM
- Kotlin/JS can also target the web and even use web frameworks (such as react) in Kolitn.
- Kotlin WASM is another possibility to target the web but this will generate WASM instead of pure JS code.
- It can be used for example to develop computation intensive libraries.
- Maybe we can do even more in the future with as all these technologies (Kotlin, WASM and Kotlin/WASM) evolve. - For example, WASI allows WASM to communicate with the operating system. - This means that me may see Kotlin/WASM project projects in the future that can target both the browser and the OS.
- Let's keep watching 😄.
🧪 Kotlin/WASM web app
- Let's create a Kotlin/WASM app. By cloning
git clone git@github.com:Kotlin/kotlin-wasm-examples.gitand opening the browser-example folder in your IDE.- To get up to date information on how to start a Kotlin/WASM project, please refer to the official documentation for kotlin/wasm.
- Open the project and run the
wasmJsBrowserRuntask. - The development server should start and you can open your WASM powered webapp on http://localhost:8080/
- ⚠️ You may need to activate some flags on your browser for the app to work. If you see a blank page, please read the browser logs to check for the instructions.
- Please check the contents of src/wasmJsMain/kotlin/Simple.kt to understand how the page is coded.
- Next, let's check the generated wasm file which is available in build/js/packages/project_name/kotlin
- WASM being a binary format, we need to convert it first to text format.
- We can either install WABT (The WebAssembly Binary Toolkit or wabbit) and use the wasm2wattool
wasm2wat --enable-all -v .\kotlin-wasm-demo-wasm.wasm -o wasm.wat, - or use an online converter such as this one
- ❗ However, I couldn't get it to work (yet).
Kotlin/JS and Kotlin/WASM common points
Both Kotlin/WASM and Kotlin/JS IntelliJ work somewhat similarly.
- Both rely on the KMP plugin
- Kotlin/WASM is enabled by adding a
wasmjssection in thebuild.gradle.ktsfile, while Kotlin/JS is enabled by adding ajssection. - The Kotlin code will compile to WASM and / or JS. Kotlin/JS generates only JS while Kotin/WASM generates both JS and WASM.
- In both cases, the entry point of the generated code is a JS file called module_name.js.
- The index.html in the resources folder loads the generated JS explained above (the one named module_name.js).
- The task
wasmBrowserDevelopmentRunorjsWasmBrowserDevelopmentRunrun a local server that hosts both the index.html files and the generated JS and WASM files.
Compose multiplatform
"Compose Multiplatform simplifies and accelerates UI development for Desktop and Web applications, and allows extensive UI code sharing between Android, iOS, Desktop and Web. It's a modern toolkit for building native UI. Quickly bring your app to life with less code, powerful tools, and intuitive Kotlin APIs."
Button(
+ onClick = {
+ logger.info("Pressed!")
+ }
+) {
+ Text("Hello $platform")
+}
+It is based on Android Jetpack Compose declarative UI approach ( which is similar also to iOS SwiftUI ) 1
Compose multiplatform vs Jetpack Compose
While very similar, Compose multiplatform is different from Jetpack Compose as the latter is only compatible with Android. Google provides a JetPack compose tutorial for Android development.
Compose HTML is not cross-platform
Compose HTML is UI a library targeting Kotlin/JS which is not compatible with Compose Multiplatform (it is a different API). For cross-platform UI development with Compose Multiplatform, compose Web is the choice.
🧪 Create a Compose multiplatform app
We'll create a multiplatform app using the official template. At the time of writing, this template does not include a compose web target.
- Please check that your environment is correctly setup as explained here.
- On Windows and Linux, we don't need to install iOS/macOS related tools but and we won't be able to run iOS/macOS targets.
- If we don't want to install Android Studio, we need at least to install the Android SDK either through the official installer or from the "Languages and Framework -> Android SDK" menu in the settings.
- Open the official template and either download a zip or use the "use this template" options on GitHub.
- Open the downloaded projet. You'll note that it contains these modules:
- a shared module (or subproject) that contains common code as well as
- and another module for earch targeted platform: androidApp, iOSApp and desktopApp (When web will be included in the template, we should also see a webApp project). These contain the source code of the apps itself (such as the main activity in Android, the
@main Appin iOS and the main function in desktopJVM) and well as platform specific resources that cannot be placed in the shared module. Some examples of such files are the AndroidManifest.xml for android and the info.plist in iOS.
- In order to run the desktopApp, open a terminal on the project root folder and launch this command:
./gradlew desktopApp:run. - In order to run the Android App, the simplest way is to launch it from IntelliJ
. It is also possible define a gradle task that installs the app on the device and issues a command to the device to launch it. - In order to run the iOS App, the simplest way is to run it on the simulator using IntelliJ. In order to run it on a real device, the TramID needs to be defined as explained here
🧪 Playing with the Compose multiplatform API
Compose multiplatform is a component based declarative UI framework. Each component is called a Composable and is defined as a function annotated with @Composable.
In compose multiplatform, the main component (the component at the root of the App) is usually found in shared/src/commonMain/Kotlin/App.kt.
- Take a look at shared/src/commonMain/Kotlin/App.kt, run the app and try to understand how compose works.
- Let's create a new composable called
RandomNumberList.
@Composable
+fun RandomNumberList(){
+ // Generate a list of random numbers
+ val myRandomValues = List(5) { Random.nextInt(0, 30) }
+ // LazyColumn is a vertically scrolling list that renders items on demand
+ LazyColumn {
+ items(myRandomValues.size){
+ Text(text = "$it")
+ }
+ }
+}
+- Place this composable below
AnimatedVisibilityandButtonand run the app.
/*
+Button(onClick ...
+AnimatedVisibility(showImage) { ...
+*/
+RandomNumberList()
+- Exercise: Make the "Hello, .." button switch between showing the list and and the image.
🎯 Solutions
📖 Further reading
Learning Kotlin
A beginner's guide to a modern programming language
Language features
null safety, extensions, lambdas, Java interoperability and more
Backend development
With Ktor, spring and node.js
Frontend development
Compose multiplatform, Kotlin/JS, Kotlin/WASM and JVM frameworks
Cross-platform development
With KMP and Compose multiplatform
Advanced Kotlin
Coroutines, delegates, Function literal with receiver, DSLs and more
Practical exercises and solutions
All chapters have a set of exercises
Welcome
Who we are
We design payments technology that powers the growth of millions of businesses around the world. Engineering the next frontiers in payments technology
- Leader in payment and secured transactions
- Over 50 billion transactions/year
- 7000+ engineers in over 40 countries
- A huge & diverse tech-stack
Prerequisites
- Basic knowledge of object-oriented language like Java
- Prepare your development environment and install stuff before the session (see Tooling section)
Useful links
📚 Advanced and other Kotlin features
Delegated properties
Kotlin allows to delegate the getter and setter of a property to another object, which is called a delegate. It is a class that defines the getValue and setValue methods.
Kotlin provides standard delegates such lazy properties and observable properties.
▶️ this code illustrates delegate properties.
Concurrency and Coroutines
Kotlin provides a high level concurrency model called Coroutines. The developer can delegated the management of threads to the compiler and runtime and using higher level constructs than threads to express asynchronous operations.
Coroutines in Kotlin revolve around these concepts:
- A coroutine is an instance of suspendable computation.
- Kotlin has many methods for creating a coroutine such as
launch.
- Kotlin has many methods for creating a coroutine such as
- A coroutine must exist within a coroutine scope.
- For example
runBlockingcreates a coroutine scope whithin which coroutines can be launched.
- For example
- A coroutine can run suspend functions which can suspend the coroutine but do not block the thread.
- For example: the
delaysuspend the coroutine but does not block the thread on which it is running. - Suspend functions are operations that may take time such http requests and file system calls.
- For example: the
- The
suspendqualifier defines a suspend function. It runs within a coroutine and can call other suspend functions. Flowallows to generate a list of asynchronous values.DeferredandChanneltransfer a single value and a stream of values, respectively, between coroutines.
▶️ this code show how to create a coroutine and suspend function and how to use them.
▶️ this code illustrated flows.
▶️ this code illustrates channels and deferred.
Function literal with receiver and Type-safe builders
As seen previously, function extension add behavior to existing classes. Inside the definition of the function extension, we can reference the extension receiver (or this) implicitly.
fun String.countCharacters() = length // or this.length
+println("hello".countCharacters()) // prints 5
+We can define this extension with a function literal (or lambda) in instead of a named function (declared with fun).
var extFn: String.() -> Int
+extFn = { length } // extFn is a function literal
+println("hello".extFn()) // prints 5
+println(extFn("hello")) // prints 5
+extFn is a function literal (lambda) that has access to the receiver (this). That's why it's called a function literal with receiver.
extFn("hello") or extFn("hello") call the extension as expected from extension functions.
The type of a function literal with receiver is funName: ReceiverType.(arg1Type, arg2Type, etc.) -> ReturnType and is called with funName(receiverValue, arg1Value, etc.) or receiverValue.funName(arg1Value, etc.). However, this is not the interesting aspect.
The important part is extFn = { length } which can be put as a function argument in a higher order function. The developer that calls the higher order function must define extFn, which in turn has access to the receiver. This allows for a nice style of programming. ▶️ this code shows an example.
Type-safe builders combine well-named builder functions and functions literals with receiver to create type-safe, statically typed builders in Kotlin.
Builder pattern
The builder pattern is a way to construct complex objects.
// StirngBuilder uses the builder pattern
+val text = StringBuilder("Temp")
+ .append(1)
+ .append(true)
+ .append("friend")
+ .toString()
+This code shows a basic type-safe builder.
Kotlin docs provides an example of an advanced type-safe builder that builds an HTML page.
🧪 Exercises
Exercise 1
- open the java-integration-exercise projects in the materials folder.
- Have a look at the Java class we provided you in the
src/main/java/com/worldline/learning/kotlin/java2kotlinpackage. (yes, that's the Pokemon class) - Convert that Java class in Kotlin using IntelliJ's awesome copy-pasta tool! (just copy paste the java code in a kotlin file, one is provided at
src/main/kotlin/com/worldline/learning/kotlin/java2kotlin) - Have a look at the generated Kotlin code, and note the major differences you spot!
📚 Kotlin language features
Kotlin is an object oriented language with functional features. This chapter covers important and relevant features of the language slit into basic and intermediate. Another chapter covers advanced features.
Basic features
Basic constructs (variables, control flow)
- Kotlin is statically typed and supports implicit typing.
- Static typing: types cannot change on runtime (it is the opposite of dynamic typing).
- Implicit typing: the compiler can infer the type whenever possible.
varcreates mutable variables.valcreates immutable variables or constants.- Semi-colons are optional.
- Kotlin supports top level declaration of variables and functions (They can be declared outside of classes).
- String interpolation is available with this syntax
${expression}. if, andwhenstatements are expressions (they can return a value).whenis equivalent to theswitchstatement of other languages- The ternary operator is not available but the
ifstatement replaces-it.
- for-each is the only type of for loop available.
- Object oriented programming is supported as in Java with some additional features such as extensions.
- The compiler supports Null Safety. It allows to write code free from null pointer errors with a compile time guarantee.
- Functional programming is supported (Higher-order functions and functions as 1st class items, etc.).
Use val by default
Replace by var only if needed.
▶️ this code highlights the above features.
Functions
In the this section, the terms 'argument' and 'parameter' are used interchangeably.
Functions in Kotlin have the following features:
- Declaration:
fun functionName(arg1: type1 = defaultvalue1, ...) : retunrType. - Call a function by passing the value in the declaration order.
- Use argument labels for more clarity, however, it also allows for arbitrary ordering of arguments.
- Optional arguments have a default value and can be omitted during the call.
- Functions are first class items or citizen: they can be assigned to a variable, passed as a function parameter, or returned from a function.
- 💡 A function that takes a function as an argument or returns one is a higher order function.
- A function type can be expressed as follows:
(typeOfParam1, typeOfParam2, etc) -> returnType(The empty return type isUnit). - Anonymous functions use the following syntax
{ argName1, argName2, etc. -> // code }- Also called or lambda functions or literal functions
- The last function argument can be put after the closing after the closing parenthesis
compute(9, 5) { x, y -> x * y }
▶️ this code highlights the above features.
The next section talk about null safety.
Null safety
In a nutshell, null safety is a compiler feature that eliminates the infamous Null pointer exception or npe. The Kotlin compiler reports errors and warnings when we manipulate nullable (also called optional) values. Here is a list of null safety features provided by Kotlin:
- All types are non-nullable by default; we cannot assign
nullto a variable or an argument.- For example, this code fails
var s: String = null.
- For example, this code fails
- A type can be made nullable by suffixing it with a ?. For example:
var s: String? = null. - Kotlin forbids calling a method or a property of a non-nullable type, unless we do one of these possibilities:
- Use optional chaining with the ? suffix.
- Provide a default value with the elvis ?: operator.
- Smart-cast the nullable into a non-nullable.
- Use the !! operator that eliminates compiler checks. This should never be used.
Never unwrap with !!
Use other safe techniques instead.
▶️ this code illustrates null safety and how to use optional types.
Java `Optional` does not provide compile time null checks
Optional wrap null values on runtime. The Java compiler (as of version 17) does not provide unwrapping features such as smart casting. It is still possible to have a npe like this: Optional<String> s = null; s.isPresent();
Enumerations
Enumerations allow to work with a group of values in a type-safe fashion. Unlike Java enums, Kotlin enums are classes. Kotlin enum classes provide these features:
whenstatements support enumerations.- Enum constants can declare their own anonymous classes with their corresponding methods, as well as with overriding base methods.
- An enum class can implement an interface but it cannot derive from a class
- There are methods for listing the defined enum constants and getting an enum constant by its name.
- Every enum constant has properties for obtaining its name and position (starting with 0).
▶️ this code illustrated the features above. For further reading please consult the official documentation.
🧪 Exercises
Exercise 1
Please click on this link to view the exercise
Please open to see the solution(s)
Exercise 2
Please click on this link to view the exercise
Please open to see the solution(s)
Intermediate features
Object oriented programming
Kotlin allows to write concise OOP code and has the following features:
- Available common features: classes, inheritance, interfaces, and abstract classes.
- Native support of properties: do not define getters and setters unless needed.
- Just add
get()andset(value)functions next to the property declaration.
- Just add
- Constructor arguments are defined next to the class name
class ClassName(arg1, atg2, ) - Prefixing a constructor arguments with
valorvarmakes it a property (valmakes it read-only). - The constructor name is
initand does not require parameters. - The compiler checks that all non-nullable properties are initialized by the end of the constructor.
- ⚠️ The compiler does not check the initialization of
lateinitproperties. Thus, accessing them before while uninitialized causes an exception.
- ⚠️ The compiler does not check the initialization of
- Prefix classes with
opento allow inheritance. - Kotlin enables the
publicaccess level by default. - The equality operator
==callsequals()(as opposed to Java which uses reference equality). - A companion object contains static methods and properties.
- Extensions add function and properties to existing classes.
- 💡 They replace inheritance in many situations.
- For example, we can add functions to the String class instead of creating a new
StringUtilsclass.
- Sealed classes and interfaces cannot be extended or implemented by third parties.
Do not define accessors unless needed
As opposed to Java, Kotlin supports properties and allows to add accessors later without refactoring the code that calls these properties. Thus, by default, just define the name of properties without accessors and use them directly.
▶️ this code illustrates some features.
Data class
Data classes are final (cannot be inherited from) classes that provide standard functionality:
equals()andhashCode()toString()of the form"class(field=value, ...)"componentN()that correspond to the properties in their order of declaration.copy()
However, they have the following constraints:
- The primary constructor needs to have at least one parameter.
- All primary constructor parameters need to be marked as val or var.
- They cannot be abstract, open, sealed, or inner (💡 but extensions are possible).
▶️ this code illustrates some features.
Functional programming
General concepts
Functional programming revolves around these concepts: pure functions, recursion, referential transparency, immutable variables, functions as first-class citizens, and higher-order functions.
Let's briefly explain these concepts:
- Immutable variables means that we cannot change the value of a variable or its properties once it has been created. If we want to do so, we must create a new instance with the new value.
- Pure functions are functions that do not have side effects and will thus return always the same output given the same input.
- Functions are first class citizens: they can be assigned to a variable or used in higher-order functions (passed as a function parameter to another function or returned from a function).
- Referential transparency: means that an expression can be replaced by its result without changing the behavior of the program. Transparency refers to the fact that the implementation of the expression is irrelevant.
💡 Pure functional languages provide these features natively and enforces them (at build time).
Kotlin and functional programming
Kotlin is not a pure functional languages but it supports some features. For example, Kotlin does not have compile time verification of pure functions, but it provides immutable collections through the kotlinx.collections.immutable library.
listOf generates read-only lists, which are not immutable
A read-only list cannot add or remove elements, but it can change the underlying data.
@Test
+fun givenReadOnlyList_whenCastToMutableList_checkNewElementsAdded(){
+ val list: List<String> = listOf("This", "Is", "Totally", "Immutable")
+ (list as MutableList<String>)[2] = "Not"
+ assertEquals(listOf("This", "Is", "Not", "Immutable"), list)
+}
+The Arrow-kt library add more functional programming features.
Declarative programming
Declarative programming is a famous style within functional programming. It consists of writing code as a chaining of function calls in this style val result = f(x).g(y). .... Higher order functions replace many situation where we would use loops. This favors readable code which is easy to debug an maintain.
▶️ this code show an example of list manipulation using declarative programming.
Kotlin and Java interoperability
- Kotlin is designed with Java interoperability in mind.
- Kotlin code may require some annotations to be called from Java.
- It is possible to mix Java and Kotlin in the same project.
- JetBrain's IntelliJ and Android Studio can convert to Kotlin when pasting java code.
- Kotlin generates Java records by annotating a data class with
@JvmRecordand targeting JVM 16, among other requirement listed here. - It is much more easier and natural to call Java from Kotlin.
- For example: Java accessors are converted to Kotlin properties.
▶️ this code shows how to convert a Kotlin List to a Java ArrayList.
The official documentation provides exhaustive documentation on Kotlin and JVM integration
🧪 Exercises
Exercise 3
Please click on this link to view the exercise
Please open to see the solution(s)
Exercise 4
Please click on this link to view the exercise
Please open to see the solution(s)
Exercise 5
Please click on this link to view the exercise
Please open to see the solution(s)
Exercise 6
Please click on this link to view the exercise
Please open to see the solution(s)
Exercise 7
Please click on this link to view the exercise
Please open to see the solution(s)
📖 Further reading
🛠 Let's make a cross-plaform app !
By combining KMP and Compose, it is possible to fully develop cross-platform mobile, web and desktop apps using only Kotlin.
Prerequisites
- Basic knowledge of kotlin development (nullability,inline & lambda functions mainly)
- Android Studio IDE with latest stable version Giraffe version or above
- A good connectivity
Tips
For more information about your DEV environment and installs please have a look to jetbrain related docs
_____ 🚀 Start the practical work here 🚀_____
🚀 Presentation of Kotlin
Kotlin is a modern programming language developed by JetBrains.
Some features
- Kotlin compiles to many targets: the JVM, JS, WASM, Android, iOS, Desktop, native code, etc.
- Many server frameworks officially support Kotlin such as Spring and Quarkus.
- It is the first-class language for writing Android.
- Kotlin can compile to native with Kotlin native or with GraalVM.
- KMP allows to share code between different platforms.
- Kotlin can be considered as both fullstack and corss-platform language.
- Inter-operable with Java.
- Provides modern features such as compile-time null safety and data classes.
- Supports Object oriented programming and functional programming.
- Kotlin KEEP is its open source evolution process.
History
- February 15, 2016: Kotlin 1.0 was released.
- January 04, 2017: Spring introduced Kotlin support in Spring 5.
- At Google I/O 2017, Google announced first-class support for Kotlin on Android.
- On 7 May 2019, Google announced that Kotlin the preferred language for Android app developers.
- June 2022: Kotlin 1.7 was released with the version of the new K2 compiler.
Some numbers and facts
- As of 2022, Kotlin is used by 7.8% of the industry experts.
- According to StackOverflow, Kotlin was the 4th most beloved language in 2020 with 62.9% votes.
- Kotlin is now listed among the top 20 programming languages by Redmonk.
- Kotlin is among the top 3 languages that most businesses are planning to migrate their apps to in 2022.
- Kotlin is used by global companies like Google, NetFlix, Amazon, Trello, and more.
- Pinterest and Uber are among the companies that migrated their apps to Kotlin from Java.
Please find more statics here:
Why switch from Java to Kotlin
Here are some arguments that motivate switching from Java (version 17 LTS at the time of writing) to Kotlin.
- Kotlin supports more targets than Java.
- Kotlin has compile time null-safety (Java Optionals are runtime wrappers for nullable values and null annotations have less features).
- Kotlin strings support interpolation.
- Casting in Kotlin is smart.
- Kotlin functional programming features are better. It even allows to define Type-Safe builders and DSLs.
- Kotlin can be mixed with Java code, thus helping the migration process.
You can read more arguments in these articles:
- Java Vs Kotlin: Which One Is Better To Learn In 2022?
- 8 Reasons Why You Should Switch To Kotlin From Java
A decision tree to help you decide if you should use Kotlin
Prerequisites
- Recommended: IntelliJ IDEA (Both community or ultimate are OK),
- or GitPod by opening https://gitpod.io/#https://github.com/worldline/learning-kotlin to create a workspace and then browser to the material folder,
- or VSCode (with Kotlin and Java plugins) + JDK 17 (install via scoop.sh on windows or SDK man on Unix) + gradle
📖 Further reading
📅 Workshops
(2023) Android makers : Kotlin Beyond Android
Link
Workshop link: awl.li/am23-kt
Agenda
- Backend development: Rest API with Ktor
- Optional: Backend development: Rest API with node.js and Kotlin/JS
- Front-end development: Kotlin/WASM and Kotlin/JS webapp
- Front-end development: cross-platform Hello world App with Compose multiplatform
- Front-end development: Cross-platform Quiz App with Compose multiplatform
- Full-stack development: Quiz App with Compose multiplatform and Ktor server
(2023) JNation : Let's discover the possibilities of Kotlin
Link
Workshop link: awl.li/jnation23-kt
Agenda
- Prerequisutes
- Selection of Kotlin's languages features: null safety and functions
- Backend development: Rest API with Ktor
- Optional: Backend development: Rest API with node.js and Kotlin/JS
- Front-end development: Kotlin/WASM and Kotlin/JS webapp
- Front-end development: cross-platform Hello world App with Compose multiplatform
- Front-end development: Cross-platform Quiz App with Compose multiplatform
- Full-stack development: Quiz App with Compose multiplatform and Ktor server
(2023) Mobile DevOps summit
- Title: From Android to Multiplatform: leveraging the full potential of Kotlin
- Link: awl.li/mds23-kt
Agenda
- Initiate a cross-platform app
- Live examples of other Kotlin possibilities:
(2024) MiXit
- Titre : Développement front et back en Kotlin. Une visite guidée de KMP
Agenda
- Prérequis
- Fonctionnalités notables: null safety et les fonctions
- Développement backend
- Développement frontend
- Développement fullstack
- Autres fonctionnalités
📚 Développement du backend
De nombreux frameworks supportent officiellement Kotlin comme Spring, Quarkus et Ktor, parmi d'autres listés ici.
En outre, Kotlin est théoriquement compatible avec tout framework qui cible la JVM ou JS. Cependant, les frameworks qui ne supportent pas officiellement Kotlin peuvent nécessiter quelques ajustements pour l'utiliser.
Ktor
Ktor est une bibliothèque Kotlin multiplateforme permettant de développer des clients et des serveurs HTTP. Cela fait de Ktor une bibliothèque utile à la fois aux développeurs frontend, pour la partie client HTTP, ainsi qu'aux développeurs backend, pour la partie serveur HTTP. Dans ce qui suit, nous allons créer une API REST avec le serveur Ktor.
TP : développer une API avec Ktor
- Créez un projet sur start.ktor.io avec les plugins suivants : Content Negotiation, kotlinx.serialization, et Routing.
- Cliquez sur "Generate project".
- Téléchargez l'archive, décompressez-la et ouvrez le projet avec votre IDE préféré.
- Créez un package
modelset ajoutez-y une classe de donnéesCustomeravec ces propriétés immuablesid : String, firstName : String, lastName : Chaîne, email : Chaîne. - Annotez la classe avec
@Serializable. - Créez un nouveau package nommé
routeset ajoutez-y un fichierCustomerRoutes.ktqui contiendra le code pour l'endpoint/customer. - Le code ci-dessous fournit l'implémentation de certains endpoints. Veuillez implémenter les autres.
- Pour activer la route, appelez
customerRouting()dans le fichier de configuration du routage situé dansplugins/Routing.kt. - Pour plus de simplicité, utilisez une liste globale de clients en mémoire
val store = mutableListOf<Customer>(). - Lancer le serveur en exécutant la méthode main.
- Tester l'API sur l'IDE en utilisant un fichier http ou en utilisant n'importe quel autre client.
CustomerRoutes.kt
val store = mutableListOf<Customer>()
+
+fun Route.customerRouting() {
+ route("/customer") {
+ get {
+ call.respond(store)
+ }
+ get("{id?}") {
+ val id = call.parameters["id"] ? : return@get call.respondText(
+ "Missing id",
+ status = HttpStatusCode.BadRequest
+ )
+ val customer =
+ store.find { it.id == id } ? : return@get call.respondText(
+ "Pas de client avec l'id $id",
+ status = HttpStatusCode.NotFound
+ )
+ call.respond(customer)
+ }
+ post {
+ val customer = call.receive<Customer>()
+ store.add(customer)
+ call.respondText("Customer stored correctly", status = HttpStatusCode.Created)
+ }
+ delete("{id?}") {
+ // TODO
+ }
+ }
+}
+
+plugins/Routing.kt
fun Application.configureRouting() {
+ routing {
+ customerRouting()
+ }
+}
+return@label
Vous pouvez spécifier le niveau que vous voulez retourner avec un label explicite en utilisant return@lambda.
lambdaA {
+ lambdaB {
+ lambdaC {
+ val randomInt = Random.nextInt(0, 100)
+ if (randomInt > 50) return@lambdaC else return@lambdaB
+ }
+ printf("In lambdaB")
+ }
+}
+CustomerTest.http
POST http://127.0.0.1:8080/customer
+Content-Type : application/json
+
+{
+ "id" : "100",
+ "firstName" : "Jane",
+ "lastName" : "Smith",
+ "email" : "jane.smith@company.com"
+}
+
+
+###
+POST http://127.0.0.1:8080/customer
+Content-Type : application/json
+
+{
+ "id" : "200",
+ "firstName" : "John",
+ "lastName" : "Smith",
+ "email" : "john.smith@company.com"
+}
+
+###
+POST http://127.0.0.1:8080/customer
+Content-Type : application/json
+
+{
+ "id" : "300",
+ "firstName" : "Mary",
+ "lastName" : "Smith",
+ "email" : "mary.smith@company.com"
+}
+
+
+###
+GET http://127.0.0.1:8080/customer
+Accept : application/json
+
+###
+GET http://127.0.0.1:8080/customer/200
+Accepte : application/json
+
+###
+GET http://127.0.0.1:8080/customer/500
+Accepte : application/json
+
+###
+DELETE http://127.0.0.1:8080/customer/100
+
+###
+DELETE http://127.0.0.1:8080/customer/500
+Cette page contient des étapes détaillées
node.js
Grâce à Kotlin/JS, nous pouvons écrire des applications qui ciblent node.js en utilisant Kotlin.
On peut même importer des librairies npm à condition de déclarer les API JS que l'on va utiliser en Kotlin. C'est ce qu'on appelle une déclaration externe (vous pouvez la considérer comme un équivalent des définitions de type de TypeScript) qui déclare les symboles auxquels nous voulons accéder en Kotlin grâce aux annotations @JsModule et @JsNonModule. Définir de telles déclarations externes peut s'avérer fastidieux et il ne semble pas y avoir de générateur automatique officiel et stable (dukat a été supprimé dans kotlin 1.8.20). Dans ce cas, nous avons deux options, soit écrire la déclaration externe nous-même, soit l'importer en tant que dépendance si elle est disponible.
Heureusement pour nous, le prochain TP utilise la librairie Express pour laquelle nous pouvons trouver une déclaration de type externe.
TP : API Rest avec Kotlin/JS et Express
- Dans IntelliJ, créer un nouveau projet node.js
- Une fois le projet chargé, éditer build.gradle.ts comme suit :
- Mettre la dernière version de Kotlin dans la ligne contenant
kotlin("js"). - Ajoutez ces deux dépendances:
- La première est la bibliothèque Express,
- et la seconde est la définition externe fournie par chrisnkrueger/kotlin-express.
- ajouter une ligne
useCommonJs()à l'intérieur du blocjs. Ceci est nécessaire pour pouvoir utiliser chrisnkrueger/ kotlin-express dans notre code.
- Mettre la dernière version de Kotlin dans la ligne contenant
implementation(npm("express", "> 4.0.0 < 5.0.0"));
+implementation("dev.chriskrueger:kotlin-express:1.2.0");
+- Modifiez main.kt comme suit. Cela crée un serveur API REST qui écoute le port 3000 et fournit une route GET /hello.
data class Message(val id : Int, val message : String)
+
+fun main() {
+ val messages = listOf(Message(0, "I love Kotlin/JS"))
+ val app = express.Express()
+ app.get("/hello") { req, res ->
+ res.send(messages)
+ }
+
+ app.listen(3000) {
+ console.log("server start at port 3000")
+ }
+}
+- Exécutez la tâche
nodeRundepuis votre IDE ou depuis la ligne de commande (si vous avez installé Gradle).- Si vous rencontrez une erreur avec Yarn lock, exécutez la tâche
kotlinUpgradeYarnLockpuis réessayez.
- Si vous rencontrez une erreur avec Yarn lock, exécutez la tâche
- Ajouter des routes en POST, PUT et DELETE
- En ce qui concerne le corps du POST, Express positionne
req.bodyàundefinedà moins que nous ne spécifions un body parser.- Pour un corps en JSON, nous devons appeler
app.use(bodyParser.json()). - bodyParser est une bibliothèque npm et malheureusement, chrisnkrueger/kotlin-express ne fournit pas de définition externe pour bodyParser au moment de l'écriture de ces lignes (chrisnkrueger/kotlin-express en version 1.2.0).
- Pouvez-vous essayer de la définir vous-même en lisant le code de la bibliothèque ?
- Vous pouvez trouver une solution ici
- Pour un corps en JSON, nous devons appeler
Spring framework
Spring est un framework célèbre pour le développement d'applications côté serveur : API REST, pages web générées par le serveur, microservices, etc. Il s'appuie sur l'écosystème Java pour la compilation et l'exécution, ce qui le rend compatible avec Kotlin. Mieux encore, Spring supporte officiellement Kotlin. On peut même démarrer un nouveau projet avec Kotlin et Gradle-Kotlin. Dans la prochaine section, nous utiliserons ce projet pour recréer notre API REST plus haut avec Spring.
TP : Spring boot part 1 - développer la même API avec Spring Boot
- Créez un projet sur start.spring.io (aussi appelé Spring initializr) avec les dépendances suivantes : Spring Web et Spring Boot DevTools.
- Choisissez Kotlin comme langage et Kotlin-Grade comme gestionnaire de projet.
- Ajoutez les dépendances suivantes : Spring Web et Spring Boot DevTools.
- Cliquez sur Generate. Téléchargez l'archive, décompressez-la et ouvrez le projet avec IntelliJ (de préférence) ou VSCode.
- Pour VSCode, installez une extension Kotlin et Spring Boot Extension Pack ( ⚠️ l'extension Spring ne semble pas supporter kotlin).
- Vérifiez que la partie plugins
build.gradle.ktsutilise la dernière version de Kotlin. Voici à quoi cela devrait ressembler avec Kotlin 1.8.10 :
plugins {
+ id("org.springframework.boot") version "3.0.4"
+ id("io.spring.dependency-management") version "1.1.0"
+ kotlin("jvm") version "1.8.10"
+ kotlin("plugin.spring") version "1.8.10"
+}
+- Créez la
data class Customerdans le packagemodel(sans l'annotation@Serializable). - Créez un paquetage
controllerqui contient une classeCustomerControllerqui fournit un CRUD en utilisant une liste globale.- Vous pouvez trouver un squelette ci-dessous.
- 💡 Dans Spring, les contrôleurs Rest servent de routes Ktor, où un contrôleur définit une ressource REST.
- Définissez les mêmes routes que dans le TP précédent.
- Démarrez le serveur de l'API REST en exécutant :
- Sur Powershell :
.\gradlew.bat bootRun - Tout shell Unix :
.\gradlew bootRun - Ou bien, vérifiez si votre IDE fournit déjà des configurations d'exécution pour les projets Spring Boot.
- Sur Powershell :
- Veuillez tester les routes avec un client REST. Vous pouvez trouver des fichiers http ici au format JetBrains ou au format de l'extension REST Client de VSCode
CustomerController.kt
val store = mutableListOf<Customer>()
+
+@RestController
+@RequestMapping("/customer")
+class CustomerController {
+ @GetMapping
+ fun getAll() = store
+
+ @GetMapping("{id}")
+ fun getById(@PathVariable id : String) { /* TODO : implement */ }
+
+ @PostMapping
+ fun addOne(@RequestBody customer : Customer) { /* TODO : implement */ }
+
+ @DeleteMapping("{id}")
+ fun deleteOne(@PathVariable id : String) { /* TODO : implement */ }
+}
+TP : Spring boot partie 2 - ajouter une base de données
Allons un peu plus loin en stockant des données dans une base de données et en écrivant quelques tests.
Nous utiliserons la base de données en mémoire H2 pour des raisons de simplicité, puisqu'elle ne nécessite pas de serveur pour fonctionner. Les classes seront mappées aux tables de la base de données avec des annotations JPA. L'API de base de données que nous utiliserons s'appelle JPARepository. C'est une API légère qui fournit des fonctionnalités CRUD communes à partir d'une simple une interface.
- Créez un nouveau projet Spring en utilisant Spring initializr avec Kotlin et les dépendances suivantes : Spring Data JPA, H2 Database, Spring Boot DevTools, Spring Web.
- Ouvrez le projet et ajoutez cette classe dans le package
model@Entity class Product(@Id @GeneratedValue var id : Long ? = null, var name : String, var price : Int). Ceci définit la classe ainsi que les annotations JPA minimales (@Entity,@Idet@GeneratedValue) pour générer la table correspondante. - Dans le package
repository, déclarez l'interfaceProductRepositorycomme suitinterface ProductRepository : JpaRepository<Produit, Long>. C'est suffisant pour que Spring génère une implémentation avec des caractéristiques communes comme nous le verrons plus tard. - Ensuite, créez une classe
ProductServicequi contiendra la logique métier. En termes d'architecture, le contrôleur appelle un service qui, à son tour, s'appuie sur d'autres services ou référentiels.
ProductService.kt
@Service
+class ProductService(@Autowired val productRepository: ProductRepository) {
+ fun getAll() = productRepository.findAll()
+
+ // use findByIdOrNull instad of findById because the latter returns an optional<Product> instead of Product?
+ fun getById(id: Long) = productRepository.findByIdOrNull(id)
+}
+- Dans le package controller, créez une classe
ProductControllerqui est mappée à/productet injectée avec@Autowired. Répondez à@Getcomme suit.
ProductController.kt
@RestController
+@RequestMapping("/product")
+class ProductController(@Autowired val productService : ProductService) {
+ @GetMapping fun getAll() = productService.getAll()
+
+ @GetMapping("{id}")
+ fun getById(@PathVariable id : Long) =
+ productService.getById(id) ? : throw ResponseStatusException(HttpStatus.NOT_FOUND)
+}
+Kotlin rend getById(@PathVariable id : Long) plus concis
L'opérateur Elvis ?: permet de simplifier le code. Voici une version plus longue en guise de référence.
@GetMapping("{id}")
+fun getById(@PathVariable id : Long) : Produit {
+ val product = productService.getById(id)
+ if (product != null){
+ return product
+ }
+ throw ResponseStatusException(HttpStatus.NOT_FOUND)
+}
+En outre, Spring fournit @ControllerAdvice pour modifier le message d'exception. Vous pouvez voir un [exemple ici] (https://spring.io/guides/tutorials/rest/).
- Exécutons le projet. Avant de lancer le projet, nous devons ajouter un plugin qui permet aux classes Kotlin de générer un constructeur par défaut
id("org.jetbrains.kotlin.plugin.jpa") version "1.8.10". Les plugins devraient ressembler à ce qui suit :
plugins {
+ id("org.jetbrains.kotlin.plugin.jpa") version "1.8.10"
+ id("org.springframework.boot") version "3.0.4"
+ id("io.spring.dependency-management") version "1.1.0"
+ kotlin("jvm") version "1.8.10"
+ kotlin("plugin.spring") version "1.8.10"
+}
+
+- En guise d'exercice, implémentez ces routes : POST d'un seul produit, DELETE par id (
/produit/{id}) et GET par id (/produit/{id}).- Indice :
ProductControllerfournit déjà les méthodes nécessaires.
- Indice :
- Appelez les différents points de terminaison avec un client REST.
- Tester votre API Rest avec un client HTTP
TP : Spring boot partie 3 - ajouter des tests
Les frameworks Spring permettent d'effectuer différents types de tests en fournissant différentes classes dès le départ :
- Tests unitaires/de composants des services et de l'API REST. Cela se fait par le biais d'utilitaires de bouchonnage tels que
MockMVC. - Tests d'intégration de l'API REST en utilisant
TestRestTemplate. Dans ce cas, un serveur complet est exécuté et testé.
La plupart des classes fournies par Spring, si ce n'est toutes, offrent une syntaxe élégante pour les développeurs Java. Certaines d'entre elles vont plus loin en tirant parti des caractéristiques spécifiques de Kotlin. Dans ce qui suit, nous allons nous concentrer sur les parties qui fournissent des DSLs Kotlin, à savoir le test unitaire de l'API REST avec MockMVC.
- Créer une classe de test
ProductControllerUnitTestsavec le contenu initial ci-dessous.MockMvcpermet de tester unitairement l'API REST. L'annotation@AutoConfigureMockMvcpermet à Spring de la configurer automatiquement.
@SpringBootTest
+@AutoConfigureMockMvc
+classe ProductControllerTests(
+ @Autowired val mockMvc : MockMvc,
+ @Autowired val productRepository : ProductRepository) {
+
+ @BeforeEach
+ fun reset(){
+ productRepository.deleteAll()
+ }
+}
+- Ajoutez les deux tests ci-dessous. Le premier utilise une approche classique tandis que le second tire parti des capacités du DSL de Kotlin. De plus, nous utilisons une chaîne littérale plus lisible.
- En guise d'exercice, écrire des tests pour les autres points d'accès.
Le constructeur de requêtes de JpaRepository
Les repository Spring implémentent des requêtes basées sur le nom de leurs méthodes. Par exemple, pour obtenir tous les produits triés par nom, nous pouvons ajouter cette méthode à l'interface.
interface ProductRepository : JpaRepository<Produit, Long> {
+ fun findAllByOrderByNameAsc() : List<Produit> ;
+}
+La [documentation officielle] (https://docs.spring.io/spring-data/jpa/docs/current/reference/html/#repositories.query-methods.query-creation) fournit des explications et des exemples plus détaillés.
Projets terminés
Aller plus loin
Ces tutoriels officiels vont encore plus loin :
- Ce tutoriel de kotlinlang montre comment créer un service web RESTful avec une base de données en utilisant Spring Boot.
- Ce tutoriel de spring.io montre comment construire une application web avec Spring Boot et Kotlin.
- Rest APIs with Spring
- Quarkus et Kotlin
Lien et références
📚 Développement frontend
Kotlin supporte une large sélection de frameworks frontaux sur toutes les plateformes : mobile, desktop et web. Vous trouverez ci-dessous un aperçu des possibilités que vous pouvez faire directement à partir d'IntelliJ :
- Côté bureau
- Grâce au support de la JVM, Kotlin supporte JavaFX. 💡 Il existe même un équivalent en Kotlin appelé tornadofx.
- Compose Multiplatform apporte l'API Jetpack Compose sur le bureau, le web et le mobile.
- Sur le web
- Ktor peut utiliser des moteurs de modèles tels que FreeMarker pour créer des pages de serveur.
- Avec KotlinJS, les développeurs peuvent créer des applications React, nodsjs ou vanilla JS en utilisant Kotlin.
- Kotlin WASM se compile en Web Assembly. Il peut compléter KotlinJS pour les tâches à forte intensité de calcul.
- Compose Multiplatform apporte deux options sur le web: Compose web et Compose for Web Canvas.
- Sur les mobiles
- Les développeurs Android utilisent Jetpack Compose ou l'ancienne méthode de layout XML.
- Compose Multiplatform supporte Android de façon stable et iOS de façon expérimentale.
Comme nous pouvons le voir, Kotlin propose plusieurs options. L'option la plus séduisante en terme de partage de code est Compose Multiplatform. Ceci est possible notamment grâce à KMP
KMP
- KMP (Kotlin Multiplatform) permet de partager une base de code unique sur plusieurs cibles.
- KMP s'appuie sur Kotlin native et d'autres fonctionnalités de Kotlin pour aider les développeurs à créer des projets destinés à plusieurs plates-formes en utilisant une base de code Kotlin commune.
- De nombreuses combinaisons de cibles et de cas d'utilisation sont possibles :
- Full-Stack web apps : Un projet qui contient un backend et une application web tout en partageant une logique commune.
- Bibliothèques multiplateformes
- KMM est une ancienne dénomination qui est dépréciée.
Dans la suite de ce chapitre, nous explorerons les différentes possibilités individuellement et on fera un projet KMP dans le chapitre suivant.
Kotlin/JS et Kotlin/WASM
- Kotlin/JS peut également cibler le web et même utiliser des frameworks web (tels que react) dans Kolitn.
- Kotlin WASM est une autre possibilité de cibler le web, mais il génère WASM au lieu de code JS pur.
- Il peut être utilisé par exemple pour développer des bibliothèques à forte intensité de calcul.
- Nous pourrons peut-être faire encore plus à l'avenir grâce à l'évolution de toutes ces technologies (Kotlin, WASM et Kotlin/WASM). - Par exemple, [WASI] (https://wasi.dev/) permet à WASM de communiquer avec le système d'exploitation. - Cela signifie que je pourrais voir des projets Kotlin/WASM à l'avenir qui peuvent cibler à la fois le navigateur et le système d'exploitation.
- Continuons à observer 😄.
🧪 Application web Kotlin/WASM
- Les assistants de création de projet Kotlin/WASM et Kotlin/JS sur IntelliJ fonctionnent de manière similaire:
- L'IDE génère un fichier Kotlin qui sera compilé par la suite en WASM et/ou JS. Kotlin/JS ne génère que du JS tandis que Kotin/WASM génère à la fois du JS et du WASM.
- Dans les deux cas, le point d'entrée du code généré est un fichier JS appelé nom_du_module.js.
- L'IDE génère également dans le dossier des ressources un fichier index.html dont le but est de charger le JS généré (le fichier nom_du_module.js).
- La tâche
wasmBrowserDevelopmentRunoujsWasmBrowserDevelopmentRunlancera un serveur local qui hébergera à la fois les fichiers index.html et les fichiers JS et WASM générés.
- Créons une application Kotlin/WASM. Tout d'abord, activez l'assistant Kotlin/WASM en activant kotlin.wasm.wizard dans le registre d'IntelliJ (ouvrez le registre en appuyant deux fois sur shift et en tapant "registry" dans la boîte de recherche). Alternativement, clonez ce projet.
- Vérifiez qu'on est sur la dernière version de Kotlin dans build.gradle.kts (l'assistant peut le configurer à une version antérieure).
- Ouvrez src/wasmMain/kotlin/sample.kt et cliquez sur le bouton lancer qui apparaît à côté de la fonction
main. - Si la compilation échoue parce que l'IDE a utilisé la mauvaise tâche gradle, veuillez la changer en
wasmBrowserDevelopmentRunet essayez de l'exécuter à nouveau.
- Le serveur de développement devrait démarrer et vous pouvez ouvrir votre application web sur http://localhost:8080/
- ⚠️ Il se peut que vous deviez activer certains drapeaux sur votre navigateur pour que l'application fonctionne. Si vous voyez une page blanche, veuillez lire les journaux du navigateur pour vérifier les instructions.
- Le fichier wasm généré est disponible dans build/js/packages/nom_du_projet/kotlin
- WASM étant un format binaire, nous devons d'abord le convertir au format texte.
- Nous pouvons soit installer [WABT (The WebAssembly Binary Toolkit ou wabbit)] (https://github.com/WebAssembly/wabt) et utiliser l'outil wasm2wattool
wasm2wat --enable-all -v .\kotlin-wasm-demo-wasm.wasm -o wasm.wat, - ou utiliser un convertisseur en ligne comme celui-ci
- ❗ Cependant, je n'ai pas réussi à le faire fonctionner
- Nous pouvons soit installer [WABT (The WebAssembly Binary Toolkit ou wabbit)] (https://github.com/WebAssembly/wabt) et utiliser l'outil wasm2wattool
🧪 Application web KotlinJS
L'assistant Kotlin/JS crée une application très similaire à celle de Kotlin/WASM. Dans un prochain PW, nous créerons une application complète avec Ktor et Kotlin/JS.
Compose
Compose multiplatform est une famille de frameworks d'interface utilisateur déclaratifs pour Android (Jetpack Compose), le bureau (Compose Desktop) et le web (Compose Web). Il dispose d'un support expérimental pour iOS et Web Canvas.
Compose multiplatform vs Jetpack Compose
Bien que très similaire, Compose multiplatform est différent de Jetpack Compose car ce dernier n'est compatible qu'avec Android. Google fournit un JetPack compose tutorial pour le développement Android.
Compose Web vs Compose for Web Canvas
- La surface de l'API de Compose Web est différente des autres cibles de Compose car elle travaille directement avec le DOM.
- Compose for Web Canvas a la même surface d'API que celle du Desktop, Android et iOS car il dessine sur un Canvas et ne manipule pas le DOM.
Cela signifie que le premier a un meilleur support web et que le second a plus de code réutilisable.
🧪 Compose Web
- Créez un nouveau projet IntelliJ -> Compose Multiplaform.
- Choisissez "Single platform" -> "Web" et remplissez les autres champs.
- Choisissez Finish
- IntelliJ peut prendre un certain temps pour préparer le projet et peut demander d'installer des plugins supplémentaires.
- Lancez le serveur de développement de l'application web à l'aide de la commande
./gradlew jsBrowserRun --continuous. - Modifiez
Main.ktcomme suit et lancez l'application. - Ouvrez cette adresse :
localhost:8080.
fun main() {
+ renderComposable(rootElementId = "root") {
+ Div({ style { padding(25.px) } }) {
+ var expanded by remember { mutableStateOf(false) }
+ Button(
+ attrs = {
+ onClick { expanded = !expanded }
+ }
+ ) { Text("Cliquez sur moi") }
+ Div({ style { display(if (expanded) DisplayStyle.Block else DisplayStyle.None) } }) {
+ Text("Cliquez sur moi !")
+ }
+ }
+ }
+}
+
🧪 Compose desktop + Android app
- Créez un nouveau projet sur IntelliJ -> Compose Multiplatform.
- Choisissez "multiple platforms" et remplissez les autres champs. Choisissez ensuite Finish.
- IntelliJ commence à préparer le projet et peut demander l'installation de plugins.
- Une fois le projet prêt, lancez l'application Android en utilisant le bouton vert run.
- Lancez l'application desktop en exécutant la fonction principale du projet desktop (qui devrait se trouver dans
Main.kt). - Modifiez
App.ktdans le projet principal comme suit et lancez l'application.
@Composable
+fun App() {
+ val platformName = getPlatformName()
+ Card {
+ var expanded by remember { mutableStateOf(false) }
+ Column(Modifier.clickable { expanded = !expanded }) {
+ Texte(
+ text="Cliquez sur moi !",
+ style = MaterialTheme.typography.h2
+ )
+ AnimatedVisibility(expanded){
+ Texte(
+ text = "Bonjour, ${platformName} 🎊",
+ style = MaterialTheme.typography.h1
+ )
+ }
+ }
+ }
+}
+
Pour aller plus loin
Apprendre Kotlin
A beginner's guide to a modern programming language
Bien commencer avec Kotlin
lorem
Syntaxe de base
lorem
Exemples
lorem
Prerequisites
- Connaissance de base en language de programmation orienté object comme Java
- Préparez votre environnement de développement et installez des éléments avant la session (voir la section Outillage)
Liens utiles
📚 Fonctionnalités avancées de Kotlin
Propriétés déléguées
Kotlin permet de déléguer le getter et le setter d'une propriété à un autre objet, appelé délégué. C'est une classe qui définit les méthodes getValue et setValue.
Kotlin fournit des délégués standard tels que des propriétés paresseuses et des propriétés observables.
▶️ this code illustrates delegate properties.
Concurrence et coroutines
Kotlin fournit un modèle de concurrence de haut niveau appelé Coroutines. Le développeur peut déléguer la gestion des threads au compilateur et à l'exécution et utiliser des constructions de niveau supérieur aux threads pour exprimer des opérations asynchrones.
Les coroutines de Kotlin tournent autour de ces concepts :
- Une coroutine est une instance de calcul suspendable.
- Kotlin a de nombreuses méthodes pour créer une coroutine telle que
launch.
- Kotlin a de nombreuses méthodes pour créer une coroutine telle que
- Une coroutine doit exister dans une portée de coroutine.
- Par exemple,
runBlockingcrée une portée de coroutine dans laquelle les coroutines peuvent être lancées.
- Par exemple,
- Une coroutine peut exécuter des fonctions de suspension qui peuvent suspendre la coroutine mais ne bloquent pas le thread.
- Par exemple : le
delaysuspend la coroutine mais ne bloque pas le thread sur lequel elle s'exécute. - Les fonctions de suspension sont des opérations qui peuvent prendre du temps telles que les requêtes http et les appels au système de fichiers.
- Par exemple : le
- Le qualificateur
suspenddéfinit une fonction de suspension. Il s'exécute dans une coroutine et peut appeler d'autres fonctions de suspension. Flowpermet de générer une liste de valeurs asynchrones.DeferredetChanneltransfèrent respectivement une valeur unique et un flux de valeurs entre coroutines.
▶️ this code show how to create a coroutine and suspend function and how to use them.
▶️ this code illustrated flows.
▶️ this code illustrates channels and deferred.
Littéral de fonction avec récepteur et constructeurs de type sécurisé
Comme vu précédemment, les extensions de fonctions ajoute du comportement à des classes existantes sans utiliser l'héritage. À l'intérieur de la définition de l'extension de fonction, nous pouvons référencer implicitement le récepteur d'extension (this).
fun String.countCharacters() = length // or this.length
+println("hello".countCharacters()) // prints 5
+Nous pouvons définir cette extension avec une fonction littérale (ou lambda) au lieu d'une fonction classique (déclarée avec fun).
var extFn: String.() -> Int
+extFn = { length } // extFn is a function literal
+println("hello".extFn()) // prints 5
+println(extFn("hello")) // prints 5
+extFn est une fonction littérale (lambda) qui a accès au récepteur (this). C'est pourquoi on l'appelle une fonction littérale avec récepteur.
extFn("hello") ou extFn("hello") appelle l'extension comme prévu par les fonctions d'extension.
Le type d'une fonction littérale avec récepteur est funName: ReceiverType.(arg1Type, arg2Type, etc.) -> ReturnType et est appelé avec funName(receiverValue, arg1Value, etc.) ou receiverValue.funName(arg1Value, etc.) .). Cependant, ce n'est pas l'aspect le plus intéressant.
La partie importante est extFn = { length } qui peut être placée comme argument de fonction dans une fonction d'ordre supérieur. Le développeur qui appelle la fonction d'ordre supérieur doit définir extFn, qui à son tour a accès au récepteur. Cela permet un style de programmation assez intéressant.
▶️ ce code montre un example.
Les Type-safe builders combinent les monteurs bien nommées et les fonctions littérales avec récepteur pour créer des monteur avec un typage statique et sécurisé. La syntaxe particulière possible avec technique permet de définir une sorte de sous-langage aussi appelé DSL (domain specific language).
Le pattern monteur (Builder)
Est une technique permettant de construire des objects avec une syntaxe élégante.
// StirngBuilder uses the builder pattern
+val text = StringBuilder("Temp")
+ .append(1)
+ .append(true)
+ .append("friend")
+ .toString()
+Ce code montre un type-safe builder basique.
Kotlin docs fournit un exemple plus avancé d'un monteur de documents HTML.
Exercises
Exercise 1
- open the java-integration-exercise projects in the materials folder.
- Have a look at the Java class we provided you in the
src/main/java/com/worldline/learning/kotlin/java2kotlinpackage. (yes, that's the Pokemon class) - Convert that Java class in Kotlin using IntelliJ's awesome copy-pasta tool! (just copy paste the java code in a kotlin file, one is provided at
src/main/kotlin/com/worldline/learning/kotlin/java2kotlin) - Have a look at the generated Kotlin code, and note the major differences you spot!
📚 Fonctionnalités du langage Kotlin
Kotlin est un langage qui support les paradigmes orienté objet et fonctionnel. Ce chapitre couvre les caractéristiques basiques et intermédiaires. Le chapitre suivant couvrira les fonctionnalités avancées.
Caractéristiques de base
Constructions de base (variables, flux de contrôle)
- Kotlin est typé statiquement et prend en charge le typage implicite.
- Typage statique : les types ne peuvent pas changer à l'exécution (c'est l'inverse du typage dynamique).
- Typage implicite : le compilateur peut inférer le type tant que c'est possible.
varcrée des variables ré-assignables.valcrée des variables qu'on ne peut plus ré-assigner.- Les points-virgules sont facultatifs.
- Kotlin prend en charge la déclaration de haut niveau des variables et des fonctions (elles peuvent être déclarées en dehors des classes).
- L'interpolation de chaîne de caractères est disponible avec cette syntaxe
${expression}. ifetwhensont des expressions (elles peuvent renvoyer une valeur).whenest équivalent à l'instructionswitchdes autres langages- L'opérateur ternaire n'est pas disponible. L'expression
ifle remplace.
- for-each est le seul type de boucle for disponible.
- La programmation orientée objet est prise en charge comme en Java avec quelques fonctionnalités supplémentaires telles que les extensions.
- Le compilateur prend en charge la Null Safety. Il permet d'écrire du code sans erreur de pointeur nulle vérifié à la compilation.
- La programmation fonctionnelle est prise en charge (fonctions d'ordre supérieur et fonctions en tant qu'éléments de 1ère classe, etc.).
Utiliser val par défaut
Utiliser var uniquement si vous réassignez une variable ou argument.
▶️ this code highlights the above features.
Les fonctions
Dans cette section, les termes 'argument' et 'paramètre' sont utilisés de manière interchangeable.
Les fonctions de Kotlin ont les caractéristiques suivantes :
- Déclaration :
fun functionName(arg1 : type1 = defaultvalue1, ...) : retunrType. - Appeler une fonction en passant la valeur dans l'ordre de déclaration.
- Utilisez des étiquettes d'argument pour plus de clarté, cependant, cela permet également un classement arbitraire des arguments.
- Les arguments optionnels ont une valeur par défaut et peuvent être omis lors de l'appel.
- Les fonctions sont des éléments de première classe ou citoyens : elles peuvent être affectées à une variable, passées en tant que paramètre de fonction ou renvoyées par une fonction.
- 💡 Une fonction qui prend une fonction comme argument ou en renvoie une est une fonction d'ordre supérieur.
- Un type de fonction peut être exprimé comme suit :
(typeOfParam1, typeOfParam2, etc) -> returnType(Le type de retour vide estUnit). - Les fonctions anonymes utilisent la syntaxe suivante
{ argName1, argName2, etc. -> // code }- Aussi appelées fonctions lambda ou fonctions littérales
- Le dernier argument de la fonction peut être mis après la fermeture après la parenthèse fermante
compute(9, 5) { x, y -> x * y }
▶️ Ce code illustre les fonctions en Kotlin.
La prochaine section abordera le null safety.
Null safety
null safety est une fonctionnalité du compilateur qui élimine la fameuse Null pointer exception ou npe. En effet, le compilateur signale des erreurs et des avertissements lorsque nous manipulons des types nullables (également appelées types optionnels) dès qu'il y a un risque de npe à l'exécution. Ainsi, afin de mettre Voici une liste des fonctionnalités de sécurité null fournies par Kotlin :
- Tous les types ne sont pas nullables par défaut ; nous ne pouvons pas affecter
nullà une variable ou à un argument.- Par exemple, ce code échoue
var s: String = null.
- Par exemple, ce code échoue
- Un type peut être rendu nullable en le suffixant avec un ?. Par exemple :
var s : chaîne ? = nul. - Kotlin interdit d'appeler une méthode ou une propriété de type non nullable, sauf si l'on fait l'une de ces possibilités :
- Utilisez le chaînage optionnel avec le suffixe ?.
- Fournissez une valeur par défaut avec l'opérateur elvis ?:.
- Smart-cast le nullable dans un non-nullable.
- Utilisez l'opérateur !! qui élimine les vérifications du compilateur. Cela ne devrait jamais être utilisé.
Ne jamais déballer avec !!
Car cela équivaut à désactiver la null safety. Utilisez les autres possibilités à la place.
▶️ ce code illustrate la null safety et les types optionnels.
La classe `Optional` de Java ne fournit aucun protection à la compilation
Ce code lance une npe en Java: Optional<String> s = null; s.isPresent();. Le compilateur Java (au moins à la version version 17) ne propose pas d'équivalent à ce que propose Kotlin comme le smart casting.
Énumérations
Les énumérations permettent de travailler avec un groupe de valeurs de façon cadrée. Contrairement aux énumérations Java, les énumérations Kotlin sont des classes. Les enum class de Kotlin fournissent ces fonctionnalités :
- Les expressions when prennent en charge les énumérations.
- Une
enum classpeut définir des méthodes et implémenter des interfaces mais elle ne peut pas dériver d'une classe. - Il existe des méthodes pour lister les constantes d'une
enum class. - Chaque constante d'une énumération a des propriétés pour obtenir son nom et sa position (en commençant par 0).
▶️ ce code illustres les enum en Kotlin de façon succincte. Veuillez consulter la documentation officielle pour aller plus loin.
Exercices
Exercice 1
Veuillez cliquer sur le lien pour consulter l'énoncé
Déplier pour consulter la solution
Exercise 2
Veuillez cliquer sur le lien pour consulter l'énoncé
Déplier pour consulter la solution
Fonctionnalités intermédiaires
Programmation orientée objet
Kotlin permet d'écrire du code Orienté Object concis grâce aux caractéristiques suivantes :
- Concepts disponibles : classes, héritage, interfaces et classes abstraites.
- Prise en charge possée des propriétés : les getters et les setters sont automatiquement implémentés.
- On peut les personnaliser les accesseurs en définissant les fonctions
get()etset(value)à côté de la déclaration de la propriété.
- On peut les personnaliser les accesseurs en définissant les fonctions
- Les arguments du constructeur sont définis à côté du nom de la classe
class ClassName(arg1, atg2, ) - Préfixer les arguments d'un constructeur avec
valouvaren fait une propriété (valla rend non ré-assignable). - Le nom du constructeur est
initet ne nécessite pas de paramètres. - Le compilateur vérifie que toutes les propriétés non nullables sont initialisées à la fin du constructeur.
- ⚠️ Le compilateur ne vérifie pas l'initialisation des propriétés
lateinit. Ainsi, y accéder avant alors qu'elles ne sont pas initialisés provoque une exception.
- ⚠️ Le compilateur ne vérifie pas l'initialisation des propriétés
- Une classe doit être préfixée avec
openpour permettre l'héritage. - Kotlin utilise le niveau d'accès
publicpar défaut. - L'opérateur d'égalité
==appelle implicitement la méthodeequals()(contrairement à Java qui utilise l'égalité de référence). - Un objet compagnon contient des méthodes et des propriétés statiques.
- Les extensions ajoutent des fonctions et des propriétés aux classes existantes.
- 💡 Ils remplacent l'héritage dans de nombreuses situations.
- Par exemple, nous pouvons ajouter des fonctions à la classe String au lieu de créer une nouvelle classe
StringUtils.
- Les classes et interfaces scellées ne peuvent pas être étendues ou implémentées par des tiers.
Ne définir les accesseurs que si vous avez un comportement personnalisé
Kotlin prend en charge les propriétés de façon plus poussée que Java et permet d'ajouter des accesseurs ultérieurement sans refactoriser le code qui appelle ces propriétés. Ainsi, par défaut, il suffit de définir le nom des propriétés sans accesseurs et on peut les utiliser directement.
▶️ ce code illustre la POO en Kotlin.
Data class
Ce sont des classes qui implémentent des méthodes communes:
equals(),hashCode(),copy()ettoString()componentN()qui est une syntaxe alternative pour récupérer les propriétés.
Cependant, les data class ont des restrictions:
- Le constructeur principal doit avoir au moins un paramètre.
- Tous les paramètres du constructeur principal doivent être marqués comme
valouvar. - Une Data class ne peut pas être abstraite, ouverte à l'héritage, scellée ou interne (💡 mais des extensions sont possibles).
▶️ ce code illustrate les data class.
Programmation fonctionnelle
Concepts généraux
La programmation fonctionnelle s'articule autour de ces concepts : fonctions pures, récursivité, transparence référentielle, variables immuables, fonctions en tant que citoyens de première classe et fonctions d'ordre supérieur.
Expliquons brièvement ces concepts :
- Les variables immuables signifient qu'on ne peut pas changer la valeur d'une variable ou ses propriétés une fois qu'elle a été créée. Si nous voulons le faire, nous devons créer une nouvelle instance avec la nouvelle valeur.
- Les fonctions pures sont des fonctions qui n'ont pas d'effets secondaires et renverront donc toujours la même sortie étant donné la même entrée.
- Les fonctions sont des citoyennes de première classe : elles peuvent être affectées à une variable ou utilisées dans des fonctions d'ordre supérieur (passées en tant qu'un argument de fonction ou retournées dans un fonction).
- Transparence référentielle : signifie qu'une expression peut être remplacée par son résultat sans modifier le comportement du programme.
💡 Les langages fonctionnels purs fournissent ces fonctionnalités de manière native et les appliquent (au moment de la construction).
Kotlin et programmation fonctionnelle
Kotlin n'est pas un langage fonctionnel pur mais il prend en charge certaines fonctionnalités. En effet, Kotlin ne sait pas dire si une fonction est pures ou non, mais il fournit des collections immuables via la bibliothèque kotlinx.collections.immutable pour nous aider à manipuler des données immuables.
`listOf` génère des listes en lecture seule, mais qui sont mutables
Une liste en lecture seule ne peut pas ajouter ou supprimer des éléments, mais elle peut modifier les données sous-jacentes.
@Test
+fun givenReadOnlyList_whenCastToMutableList_checkNewElementsAdded(){
+ val list: List<String> = listOf("This", "Is", "Totally", "Immutable")
+ (list as MutableList<String>)[2] = "Not"
+ assertEquals(listOf("This", "Is", "Not", "Immutable"), list)
+}
+La librairie Arrow-kt permet d'aller encore plus loin en développement fonctionnel.
Programmation déclarative
La programmation déclarative est un style célèbre dans la programmation fonctionnelle. Il consiste à écrire du code sous la forme d'un enchaînement d'appels de fonction dans ce style val result = f(x).g(y). .... Les fonctions d'ordre supérieur remplacent de nombreuses situations où nous utiliserions des boucles. Cela favorise le code lisible qui est facile à déboguer et à maintenir.
▶️ ce code montre comment manipuler une liste avec la programmation déclarative.
Kotlin and Java interoperability
- Kotlin is designed with Java interoperability in mind.
- Kotlin code may require some annotations to be called from Java.
- It is possible to mix Java and Kotlin in the same project.
- JetBrain's IntelliJ and Android Studio can convert to Kotlin when pasting java code.
- Kotlin generates Java records by annotating a data class with
@JvmRecordand targeting JVM 16, among other requirement listed here. - It is much more easier and natural to call Java from Kotlin.
- For example: Java accessors are converted to Kotlin properties.
▶️ this code shows how to convert a Kotlin List to a Java ArrayList.
The official documentation provides exhaustive documentation on Kotlin and JVM integration
Exercices
Exercice 3
Solution(s)
Exercice 4
Solutions(s)
Exercice 5
Solution(s)
Exercice 6
solution(s)
Exercice 7
Solution(s)
Plus d'exercices et de lecture
🛠 Construisons une app multiplateforme !
En combinant KMP, KMM et Compose, il est possible de développer des applications mobiles et de bureau multiplateformes en utilisant uniquement Kotlin.
Prérequis
- Connaissance de base du développement en Kotlin (notamment la nullabilité, les fonctions en ligne et les fonctions lambda)
- IDE Android Studio avec la version stable la plus récente, version Giraffe ou supérieure
- Une bonne connectivité
Conseil
Pour plus d'informations sur votre environnement de développement (DEV) et les installations, veuillez consulter la documentation liée à JetBrains ici.
____ 🚀 Demarrer la session pratique ici 🚀___
🚀 Présentation de Kotlin
Kotlin est un langage de programmation moderne développé par JetBrains.
Certaines fonctionnalités
- Kotlin est capable de compiler vers différentes cibles : la JVM, JS, Android, iOS, Les OS de bureau, etc.
- Pris en charge officiellement par de grands frameworks back-end, tels que Spring et Quarkus,
- Langage préféré pour le développement Android,
- Kotlin Native compile en code natif,
- Kotlin peut être considéré comme un langage fullstack
- Interopérable avec Java.
- Fournit des fonctionnalités modernes telles que la null safety à la compilation.
- Prend en charge la programmation orientée objet et la programmation fonctionnelle.
- Processus d'évolution open source: Kotlin KEEP.
Histoire
- 15 février 2016 : sortie de Kotlin 1.0.
- 4 janvier 2017 : Spring a introduit le support de Kotlin dans Spring 5.
- Lors de Google I/O 2017, Google a annoncé une prise en charge officielle de Kotlin sur Android.
- Le 7 mai 2019, Google a annoncé que Kotlin était le langage préféré des développeurs d'applications Android.
- Juin 2022 : Kotlin 1.7 est sorti avec la version du nouveau compilateur K2.
Quelques chiffres et faits
- En 2022, Kotlin est utilisé par 7,8 % des experts de l'industrie.
- Selon StackOverflow, Kotlin était le 4ème langage le plus apprécié en 2020 avec 62,9 % des votes.
- Kotlin est désormais répertorié parmi les 20 meilleurs langages de programmation par Redmonk.
- Kotlin fait partie des 3 principaux langages vers lesquels la plupart des entreprises prévoient de migrer leurs applications en 2022.
- Kotlin est utilisé par des entreprises mondiales telles que Google, Netflix, Amazon, Trello, etc.
- Plusieurs entreprises dont Google, Pinterest et Uber ont migré leurs applications de Java vers Kotlin.
Veuillez trouver plus de statiques ici :
Pourquoi passer de Java à Kotlin
Voici quelques arguments qui motivent le passage de Java (version 17 LTS au moment de la rédaction) à Kotlin.
- Kotlin prend en charge plus de cibles que Java.
- Kotlin protège des références null à la compilation (les
OptionalJava sont ne sont pas de protections à la compilation). - Les chaînes de caractères Kotlin prennent en charge l'interpolation.
- Les fonctionnalités de programmation fonctionnelle de Kotlin sont meilleures. Il permet même de définir des constructeurs et des DSL (Domain Specific Language) dont le typage est sécurisé (type-safe).
- Kotlin peut être mélangé avec du code Java, facilitant ainsi le processus de migration.
Vous pouvez lire plus d'arguments dans ces articles :
- Java Vs Kotlin : Lequel vaut-il mieux apprendre en 2022 ?
- [8 raisons pour lesquelles vous devriez passer à Kotlin depuis Java] (https://www.geeksforgeeks.org/8-reasons-why-you-should-switch-to-kotlin-from-java)
Sources et plus de lecture
📅 Workshops
Android makers 2023: Kotlin Beyond Android
Liens
Lien du workshop: awl.li/am23-kt
Agenda
- Backend development: Rest API with Ktor
- Optional: Backend development: Rest API with node.js and Kotlin/JS
- Front-end development: Kotlin/WASM and Kotlin/JS webapp
- Front-end development: cross-platform Hello world App with Compose multiplatform
- Front-end development: Cross-platform Quiz App with Compose multiplatform
- Full-stack development: Quiz App with Compose multiplatform and Ktor server
Mobile DevOps summit 2023
- Titre: From Android to Multiplatform: leveraging the full potential of Kotlin
- Lien: awl.li/mds23-kt
Agenda
- Développement d'une application multi-plateformes
- Démonstration des autres possibilités:
Devoxx Morocco 2023
- Titre: Let's discover the amazing possibilities of Kotlin
- Lien: awl.li/mds23-kt
Agenda
- Prérequis
- Caractéristiques notables de Kotlin: le null safety et les fonctions
- API Rest avec Spring boot
- API Rest avec Ktor
- Développement d'une application multi-plateformes type "Hello World" avec Compose Multiplatform
- Dévelopment sullstack d'une application de Quiz avec with Compose multiplatform en front et Ktor server en backend
- Autres fonctionnalités et possibilités:
(2024) MiXit
- Titre : Développement front et back en Kotlin. Une visite guidée de KMP
Agenda
- Prérequis
- Fonctionnalités notables: null safety et les fonctions
- Développement backend
- Développement frontend
- Développement fullstack
- Autres fonctionnalités
Hello
A beginner's guide to a modern programming language
Language features
null safety, extensions, lambdas, Java interoperability and more
Backend development
With Ktor, spring and NodeJS
Frontend development
Compose multiplatform, Kotlin/JS, Kotlin/WASM and JVM frameworks
Cross-platform development
With KMP and Compose multiplatform
Advanced Kotlin
Coroutines, delegates, Function literal with receiver, DSLs and more
Practical exercises and solutions
All chapters have a set of exercises
Welcome
Who we are
We design payments technology that powers the growth of millions of businesses around the world. Engineering the next frontiers in payments technology
- Leader in payment and secured transactions
- Over 50 billion transactions/year
- 7000+ engineers in over 40 countries
- A huge & diverse tech-stack
Prerequisites
- Basic knowledge of object-oriented language like Java
- Prepare your development environment and install stuff before the session (see Tooling section)