Upgrade to Pro — share decks privately, control downloads, hide ads and more …

What's new in Kotlin?

What's new in Kotlin?

Presented at Kotlin/Everywhere Beijing 2019.

Svetlana Isakova

August 31, 2019
Tweet

More Decks by Svetlana Isakova

Other Decks in Programming

Transcript

  1. Kotlin evolution Kotlin 1.2 Kotlin 1.0 Kotlin 1.1 Kotlin 1.3

    Coroutines (experimental) Coroutines get stable! Multi-platform projects can target Kotlin/Native (experimental) Multi-platform projects (experimental) Kotlin/Native (experimental) Kotlin gets stable!
  2. Principles of Pragmatic Evolution Language design is cast in stone,

    but this stone is reasonably soft, and with some effort we can reshape it later. Kotlin Design Team * The real sculpture made by José Manuel Castro López
  3. KEEPing the language modern https://github.com/Kotlin/KEEP KEEP = Kotlin Evolution and

    Enhancement Process contains language proposals and the corresponding discussions
  4. Feedback loop with the community • Kotlin the community •

    Kotlin team listens to the community • The community members influence the Kotlin evolution
  5. Experimental features The goal: to let new features be tried

    by early adopters as soon as possible
  6. Experimental Language Features • can be changed in the future

    • you need to explicitly opt in at the call site to use experimental features compileTestKotlin { kotlinOptions { freeCompilerArgs += "-Xinline-classes" } }
  7. Experimental API for Libraries • can be publicly released as

    a part of the library • may break at any moment
  8. @ShinyNewAPI class Foo { ... } Experimental API @Experimental annotation

    class ShinyNewAPI You can mark your new class or function as experimental
  9. Duration API • KEEP: Duration and Time Measurement API •

    status: experimental in Kotlin 1.3.50 • uses inline classes
  10. Inline classes to the rescue inline class Duration(val value: Long)

    fun greetAfterTimeout(duration: Duration) fun greetAfterTimeout_(duration: Long) Under the hood:
  11. Inline classes to the rescue inline class Duration(val value: Long)

    fun greetAfterTimeout(duration: Duration) fun greetAfterTimeout_(duration: Long) Under the hood: No extra object is allocated! ✓
  12. Inline classes: summary • KEEP: inline classes • help to

    improve API and avoid extra allocations • you can go and try it out
  13. Changes in standard library fun String?.isNullOrEmpty(): Boolean { return this

    == null || this.length == 0 } fun String?.isNullOrEmpty(): Boolean { contract { returns(false) implies (this@isNullOrEmpty != null) } return this == null || this.length == 0 }
  14. Changes in standard library fun String?.isNullOrEmpty(): Boolean { contract {

    returns(false) implies (this@isNullOrEmpty != null) } return this == null || this.length == 0 } fun String?.isNullOrEmpty(): Boolean { return this == null || this.length == 0 }
  15. val s: String? = "" if (!s.isNullOrEmpty()) { s.first() }

    We know something about isNullOrEmpty, which the compiler doesn’t
  16. val s: String? = "" if (!s.isNullOrEmpty()) { s.first() }

    Compiler error: Only safe (?.) or non-null asserted (!!.) calls are allowed on a nullable receiver of type String? We know something about isNullOrEmpty, which the compiler doesn’t
  17. val s: String? = "" if (!s.isNullOrEmpty()) { s.first() }

    Compiler error: Only safe (?.) or non-null asserted (!!.) calls are allowed on a nullable receiver of type String? We know something about isNullOrEmpty, which the compiler doesn’t if (s != null && s.isNotEmpty()) { s.first() } ✓
  18. We know something about run, that the compiler doesn’t val

    answer: Int run { answer = 42 } println(answer)
  19. We know something about run, that the compiler doesn’t val

    answer: Int run { answer = 42 } println(answer) Compiler error: Captured values initialization is forbidden due to possible reassignment
  20. fun String?.isNullOrEmpty(): Boolean { contract { returns(false) implies (this@isNullOrEmpty !=

    null) } return this == null || this.length == 0 } Contract: if the function returns false, the receiver is not-null
  21. fun String?.isNullOrEmpty(): Boolean { contract { returns(false) implies (this@isNullOrEmpty !=

    null) } return this == null || this.length == 0 } Contract: if the function returns false, the receiver is not-null val s: String? = "" if (!s.isNullOrEmpty()) { s.first() } ✓
  22. inline fun <R> run(block: () -> R): R { contract

    { callsInPlace(block, InvocationKind.EXACTLY_ONCE) } return block() } Contract: block lambda will be always called once
  23. inline fun <R> run(block: () -> R): R { contract

    { callsInPlace(block, InvocationKind.EXACTLY_ONCE) } return block() } Contract: block lambda will be always called once val answer: Int run { answer = 42 } ✓
  24. Why can’t compiler just implicitly infer such information? Because then

    such implicitly inferred information: - can be implicitly changed - can accidentally break code depending on it
  25. Why can’t compiler just implicitly infer such information? Because then

    such implicitly inferred information: - can be implicitly changed - can accidentally break code depending on it
  26. Contract = explicit statement about function behaviour Why can’t compiler

    just implicitly infer such information? Because then such implicitly inferred information: - can be implicitly changed - can accidentally break code depending on it
  27. Kotlin Contract extra information by developer & compiler uses this

    information for code analysis experimental
  28. Kotlin Contract extra information by developer & compiler uses this

    information for code analysis & checking that the information is correct at compile time or runtime to be supported
  29. • handy functions (run, isEmptyOrNull) are even more useful •

    contract DSL will change • more use-cases in the future • you can define contracts for your own functions Contracts: Summary
  30. channel consumer #1 producer #1 send receive producer #2 producer

    #N consumer #M ... ... Producer-consumer problem
  31. Send & Receive “views” for the same channel interface SendChannel<in

    E> { suspend fun send(element: E) fun close() } interface ReceiveChannel<out E> { suspend fun receive(): E } interface Channel<E> : SendChannel<E>, ReceiveChannel<E>
  32. Send & Receive “views” for the same channel interface SendChannel<in

    E> { suspend fun send(element: E) fun close() } interface ReceiveChannel<out E> { suspend fun receive(): E } interface Channel<E> : SendChannel<E>, ReceiveChannel<E>
  33. Producer-consumer solution: consumers val channel = Channel<Task>() ... async {

    worker(channel) } async { worker(channel) } consumer #1 suspend fun worker(channel: Channel<Task>) { val task = channel.receive() processTask(task) } consumer #2
  34. Producer-consumer solution val channel = Channel<Task>() receive waiting for “send”

    val task = channel.receive() processTask(task) channel.send(task1) channel.send(task2) channel.close()
  35. send(task1) Producer-consumer solution val channel = Channel<Task>() receive waiting for

    “send” val task = channel.receive() processTask(task) channel.send(task1) channel.send(task2) channel.close()
  36. send(task1) Producer-consumer solution val channel = Channel<Task>() receive Rendezvous! waiting

    for “send” val task = channel.receive() processTask(task) channel.send(task1) channel.send(task2) channel.close()
  37. Producer-consumer solution val channel = Channel<Task>() send(task1) receive Rendezvous! val

    task = channel.receive() processTask(task) channel.send(task1) channel.send(task2) channel.close()
  38. Producer-consumer solution val channel = Channel<Task>() val task = channel.receive()

    processTask(task) processing task1 channel.send(task1) channel.send(task2) channel.close()
  39. send(task2) Producer-consumer solution val channel = Channel<Task>() processing task1 val

    task = channel.receive() processTask(task) channel.send(task1) channel.send(task2) channel.close()
  40. send(task2) Producer-consumer solution val channel = Channel<Task>() waiting for “receive”

    val task = channel.receive() processTask(task) processing task1 channel.send(task1) channel.send(task2) channel.close()
  41. send(task2) Producer-consumer solution val channel = Channel<Task>() receive val task

    = channel.receive() processTask(task) val task = channel.receive() processTask(task) processing task1 channel.send(task1) channel.send(task2) channel.close()
  42. send(task2) Producer-consumer solution val channel = Channel<Task>() receive Rendezvous! val

    task = channel.receive() processTask(task) val task = channel.receive() processTask(task) processing task1 channel.send(task1) channel.send(task2) channel.close()
  43. Producer-consumer solution val channel = Channel<Task>() processing task2 val task

    = channel.receive() processTask(task) val task = channel.receive() processTask(task) processing task1 channel.send(task1) channel.send(task2) channel.close()
  44. consumer #1 producer #1 send tasks receive tasks consumer #2

    Producer-consumer solution: many tasks val channel = Channel<Task>()
  45. Producer-consumer solution: many tasks val channel = Channel<Task>() async {

    for (i in 1..N) { channel.send(Task("task$i")) } channel.close() } producer
  46. Producer-consumer solution: many tasks val channel = Channel<Task>() ... async

    { worker(channel) } async { worker(channel) } consumer #1 consumer #2 suspend fun worker(channel: Channel<Task>) { for (task in channel) { processTask(task) } } calls receive while iterating
  47. Flow • suspend-based reactive stream flow { emit(value) } .map

    { transform(it) } .filter { condition(it) } .catch { exception -> log(exception) } .collect { process(it) }
  48. Flows: summary • bring reactive streams to coroutines library •

    currently in an experimental state • will get stable soon
  49. expect fun Char.isUpperCase(): Boolean public actual fun Char.isUpperCase(): Boolean =

    java.lang.Character.isUpperCase(this) Now: fun Char.isUpperCase(): Boolean = java.lang.Character.isUpperCase(this) Before: expect / actual in standard library
  50. expect fun Char.isUpperCase(): Boolean public actual fun Char.isUpperCase(): Boolean =

    java.lang.Character.isUpperCase(this) Now: fun Char.isUpperCase(): Boolean = java.lang.Character.isUpperCase(this) Before: expect / actual in standard library
  51. Sharing common code • Sharing business logic • Keeping UI

    platform-dependent • The shared part might vary
  52. Common code • you define expect declarations in the common

    code and use them • you provide different actual implementations for different platforms
  53. Time measurement example expect fun measureTime(action: () -> Unit): Duration

    Expected platform-specific API: Expected API can be used in the common code: measureTime { // operation }
  54. Platform-specific Implementations expect fun measureTime(action: () -> Unit): Duration actual

    fun measureTime(action: () -> Unit): Duration { // implementation using System.nanoTime() } actual fun measureTime(action: () -> Unit): Duration { // implementation using window.performance.now() } actual fun measureTime(action: () -> Unit): Duration { // implementation using std::chrono::high_resolution_clock } Kotlin/JVM Kotlin/JS Kotlin/Native
  55. Common code • can use the standard library • can

    define expect declarations and use them • can use other multi-platform libraries
  56. Multi-platform libraries • Standard library • Ktor HTTP client •

    kotlinx.serialization • kotlinx.coroutines • … and more
  57. Many apps already in production Going Native: How I used

    Kotlin Native to Port 6 years of Android Game Code to iOS in 6 months Shipping a Mobile Multiplatform Project on iOS & Android Your Multiplatform Kaptain has Arrived: iOS release is powered by Kotlin Multiplatform
  58. Multi-platform projects: summary • a modern approach to multi-platform development

    • you can easily tune what parts you want to be shared • you can go and try it out