Level up in Kotlin

Transcript

1. Level up in Kotlin
2. I am Pamela Hill Android Engineer - Luno You can find me here: • Twitter: @pamelaahill • Blog: www.pamelaahill.com Hello! ! 2
3. ! 3
4. ! 4 . Conciseness Readability Maintainability Performance Focus Compatibility
5. ! 5 Coroutines What’s New DSLs
6. DSLs 1 ! 6
7. General-purpose language A general-purpose language solves any problem that can be solved by a computer A general-purpose language is imperative, specifying the operations to solve the problem What is a DSL? Domain-specific language A domain-specific language focusses on solving problems in a specific domain A domain-specific language is declarative, describing the required result ! 7
8. External DSL Unrestricted in terms of how it expresses itself Requires string concatenation and parsing What is an internal DSL? Internal DSL Restricted by the syntax of a general purpose language No concatenation or parsing necessary ! 8
9. Why DSLs? ! 9 Readability Conciseness . Maintainability
10. Why is Kotlin great for constructing DSLs? • Optional semicolon - removes syntactic noise • Dropping . and ( ) by infixing functions
 str should startsWith("Space") is more readable than assertTrue(str.startsWith(“Space")) • Extension functions - makes existing code more fluent • No ( ) required for last lambda argument - removes syntactic noise • Lambdas with receivers • Invoke convention ! 10
11. Lambdas with Receivers Lambdas that are executed within the context of a target ! 11
12. ! 12 val printDelimitedMission: Mission.(String) -> Unit = { delimiter -> println("$delimiter $this $delimiter") } Mission().printDelimitedMission("*")
13. Commander Eileen M. Collins • First female pilot, commander of a Space Shuttle • On mission STS-63, she piloted the ship, which rendezvoused with Discovery and Mir ! 13
14. ! 14 EileenCollins mission { board on SpaceShuttle launch at 9.00 rendesvouz with Discovery rendesvouz with Mir land at 14.00 }
15. ! 15 class Astronaut { infix fun mission(block: Mission.() -> Unit) { val mission = Mission() mission.block() } }
16. ! 16 class Mission { var shuttle: Shuttle? = null var rendezvousShuttles: MutableList<Shuttle> = LinkedList() var board = this var launch = LaunchTime() var rendesvouz = this var land = LandTime() infix fun on(ship: Shuttle) { shuttle = ship } infix fun with(destination: Shuttle) { rendezvousShuttles.add(destination) } }
17. DSLs - key takeaways • DSLs are focussed on describing only solutions to problems for a specific domain • DSLs are concise, readable, and maintainable • Language features like lambdas with receivers support the creation of readable DSLs ! 17
18. Coroutines 2 ! 18
19. Coroutines • Like lightweight threads • Run on a shared pool of threads, one thread can run many coroutines ! 19
20. Suspendable computation Function that can suspend its computation at some point and resume later on, without blocking the thread ! 20
21. Why coroutines? ! 21 Performance Readability Compatibility
22. Coroutine Scope Coroutine Launches Coroutine Builder Originates from Suspending Function Runs Dispatcher Specifies Controls thread Coroutine Context Contains
23. Coroutine scope • Tracks coroutines • When cancelled, all coroutines in the scope are also cancelled ! 23
24. Coroutine builder Provides a way to start the coroutine ! 24
25. Suspending function • Suspend and resume without blocking the thread • Marked with suspend keyword in function signature ! 25
26. Coroutine context Useful key-value map ! 26
27. Coroutine dispatcher Ensures the executions and continuation of the coroutines are dispatched on the right threads ! 27
28. ! 28 launch
29. ! 29 suspend fun launchSpaceShuttle(){...}
 suspend fun flyToDestination(){...}
 suspend fun dockOnSpaceStation(){...}
30. ! 30 suspend fun launchSpaceShuttle(){...} suspend fun flyToDestination(){...} suspend fun dockOnSpaceStation(){...} val job = launch { delay(1000) println("10,9,8 ... Ignition!") launchSpaceShuttle() flyToDestination() dockOnSpaceStation() println("Mission complete") } println("What were we doing again?")
31. ! 31 async
32. ! 32 suspend fun checkFlightPath(): FlightPath {...}
 suspend fun checkCrewHealth(): CrewHealth {...}
 fun reportToMissionControl(flightPath: FlightPath, crewHealth: CrewHealth){...}

33. ! 33 suspend fun checkFlightPath(): FlightPath {...}
 suspend fun checkCrewHealth(): CrewHealth {...}
 fun reportToMissionControl(flightPath: FlightPath, crewHealth: CrewHealth){...} val job = launch {
 val flightPath = async {checkFlightPath()}
 val crewHealth = async {checkCrewHealth()}
 reportToMissionControl(flightPath.await(), crewHealth.await()) }

34. Flow Cold, asynchronous data stream that sequentially emits values ! 34
35. ! 35 suspend fun flyHalfway(){...} suspend fun flyToDestination(){...} launch { flow { emit(Point(0.0, 0.0)) flyHalfway() emit(Point(50.0, 50.0)) flyToDestination() emit(Point(100.0, 100.0)) }.collect { point -> updateUI(point) } }
36. Channels Communication between coroutines ! 36
37. ! 37 val channel = Channel<Point>() launch { channel.send(Point(0.0, 0.0)) flyHalfway() channel.send(Point(50.0, 50.0)) flyToDestination() channel.send(Point(100.0, 100.0)) channel.close() } launch { for (point in channel) { updateUI(point) } }
38. ! 38 val channel = Channel<Point>() launch { channel.send(Point(0.0, 0.0)) flyHalfway() channel.send(Point(50.0, 50.0)) flyToDestination() channel.send(Point(100.0, 100.0)) channel.close() } launch { for (point in channel) { updateUI(point) } }
39. viewModelScope • Start coroutines in the ViewModel • Use this scope to ensure that coroutines are only cancelled once ViewModel is cleared ! 39
40. Coroutines - key takeaways • Coroutines are like lightweight threads • Suspendable computations are functions that suspend at some point, and resume at a later point - without blocking the thread • launch, async are examples of coroutine builders • Flows are cold, asynchronous data streams that sequentially emit values • Channels can be used to communicate between coroutines ! 40
41. What’s New 3 ! 41
42. Inline Classes • Improve API by wrapping single type • Avoid unnecessary heap allocation ! 42
43. ! 43 inline class LaunchCode(private val launchCode: String)
44. Contracts • Share extra information with compiler about a section of code ! 44
45. ! 45 val planet: String? = "" if (planet != null && !planet.isEmpty()){ planet.first() }
46. ! 46 val planet: String? = "" if (!planet.isNullOrEmpty()) { planet.first() }
47. ! 47 public inline fun CharSequence?.isNullOrEmpty(): Boolean { contract { returns(false) implies (this@isNullOrEmpty != null) } return this == null || this.length == 0 }
48. Immutable Collections • Read-only vs immutable • Immutable vs persistent ! 48
49. ! 49 List MutableList ImmutableList PersistentList
50. Why Immutable Collections? ! 50 Memory- efficient Thread-safe Defensive programming
51. What’s new - key takeaways • Inline classes improve the API, without the heap allocations of wrapper classes • Contracts give the compiler extra information about a code - use with caution • Immutable collections prevent the underlying data from being modified ! 51
52. What’s next? ! 52 Research www.pamelaahill.com KotlinConf Creating Full-stack Web Apps
 with Kotlin DSLs
53. Questions? ! 53 Let’s chat
54. Thank you! ! 54 Keep in touch Pamela Hill Android Engineer, Luno @pamelaahill