Kotlin for Grooviers

A side-by-side comparison between Groovy and Kotlin programming languages.

Transcript

1. Kotlin and Groovy sitting in a tree...
2. KOTLIN!!!
5. 1. Degustar un poco de Kotlin 2. Quizás aprender algo nuevo en Groovy
7. “Fool” Stack Developer Java, Groovy, JS, Clojure, Kotlin, Scala…. Alonso Torres @alotor
8. KALEIDOS http://kaleidos.net/
9. Once upon a time...
11. Smalltalk (1980) • First OOP language • Dynamic typing • Metaprogramming
13. Java (1996) • OOP Language • Static typing • Write once run everywhere
15. Groovy (2003) • A better Java! • Dynamic typing • Functional style • Scripting • DSL capabilities • Metaprogramming
19. Kotlin (2012) • A better Java! • Static typing • Functional style • Scripting • DSL capabilities
20. Groovy (2003) • A better Java! • Dynamic typing • Functional style • Scripting • DSL capabilities • Metaprogramming
22. Why Kotlin?
23. - Slower compilation times - Verbosity - No runtime metaprogramming - Harder reflection + Move runtime errors to compile time + Better tooling support + Faster runtime Static types languages
24. https://rollbar.com/blog/top-10-javascript-errors/
25. Design Goals • Full Java interoperability • Compile as fast as Java • Safer than Java • More concise than Java • Way simpler than Scala
26. Features • Higher-order functions • Properties • Mixins and First-class delegation • Extension functions • Static nullability checking • Automatic casts • Reified generics • Declaration-site variance • Modules and Build infrastructure • Inline-functions • Pattern matching • Type inference • Multiplatform (Android, JS, Native) • Coroutines & suspending functions • Scripting • Infix functions • String templates • Range expressions • Operator overloading • First-class tooling
27. Features • Higher-order functions • Properties • Mixins and First-class delegation • Extension functions • Static nullability checking • Automatic casts • Reified generics • Declaration-site variance • Modules and Build infrastructure • Inline-functions • Pattern matching • Type inference • Multiplatform (Android, JS, Native) • Coroutines & suspending functions • Scripting • Infix functions • String templates • Range expressions • Operator overloading • First-class tooling
29. JAVA
30. GROOVY
31. SCALA
32. KOTLIN
33. Integer factorial(Integer num) { def result = 1 (1..num).forEach { result = result * it } return result } fun factorial(num: Int): Int { var result = 1 (1..num).forEach { result = result * it } return result }
39. • String templates • Multiline strings • Ranges • Closures syntax • Closure implicit parameter (it) • Closure call on last parameter • Null safe navigation • Elvis operator • Builder concept • in, as operators
41. Hello Kotlin
42. println("Hello world") println("Hello world") println('Hello world') Hello world
43. println(""" Hello world """) println(""" Hello world """) Multiline strings
44. def foo = "bar" final def secret = 42 var foo = "bar" val secret = 42 String foo = "bar" Float PI var foo: String = "bar" var PI: Float Variable definition
45. println("The answer is ${secret}") println("The answer is ${secret}") String interpolation
46. def foo = "bar" foo = 10 foo.toUpperCase() var foo = "bar" foo = 10 Compilation error: foo of type String Compilation error: foo of type Integer Type inference
47. var foo = "bar" foo = 10 foo.toUpperCase() Compilation error: Any doesn’t have method def foo = "bar" foo = 10 foo.toUpperCase() Type inference
48. if (x instanceof String) { println(((String)x).toUpperCase()) } else if (x instanceof Integer) { println(((Integer)x) + 2) } if (x is String) { println(x.toUpperCase()) } else if (x is Integer) { println(x + 2) } Smart casting
49. if (tmp is String && tmp.toUpperCase() == "FOOBAR") { ... } Smart casting II
50. Statements & expressions
51. if (x > 0) { println("Greater than zero") } if (x > 0) { println("Greater than zero") } Basic statements for (num in (1 .. 20)) { println("Value: $i") } for (num in (1 .. 20)) { println("Value: $i") }
52. when (value) { 42 -> println("Int") is String -> println("String") in 0..20 -> println("In range") else -> println("Other") } switch (val) { case 42: println "Int"; break case String: println "String"; break case 0..20: println "In range"; break case { "$it".length < 50 }: println "Closure"; break default: println "Other"; break } When statement
53. if (....) { … } else { … } try { … } catch { … } switch (...) { … } for (...) { … } 1 + 1 doStuff() obj.test() Expressions Statements Statements as expressions
54. if (....) { … } else { … } try { … } catch { … } switch (...) { … } for (...) { … } x = 1 + 1 if (doStuff()) { … } println(obj.test()) Expressions Statements Statements as expressions
55. x = if (....) { … } else { … } x = try { … } catch { … } x = when (...) { … } for (...) { … } x = 1 + 1 if (doStuff()) { … } println(obj.test()) Expressions Statements as expressions Statements as expressions
56. val message = if (success) "OK" else "Error" val message = when (success) { true -> "OK" false -> "Error" } val num = try { parseInt(args[0]) } catch (e: Exception) { -1 } Statements as expressions
57. Integer x, y x = (y = 10) var x: Int var y: Int x = (y = 10) Statements as expressions
59. Kotlin is FUN
60. Integer sum(Integer a, Integer b) { return a + b } fun sum (a: Int, b: Int): Int { return a + b } Basic functions definitions
61. Integer sum(Integer a, Integer b) { a + b } fun sum (a: Int, b: Int) = a + b Single expression functions
62. String message (Boolean success) { switch (success) { case true: return "OK" case false: return "Error" } } fun message (success: Boolean) = when (success) { true -> "OK" false -> "Error" } Single expression functions
63. Integer sum(Integer... nums) { nums.sum() } sum(1, 2, 3, 4) fun sum (vararg nums: Int) = nums.sum() sum(1, 2, 3, 4) Variable number of arguments (Varargs)
64. String greet( String message = "Hi", String name = "you") { "$message $name" } greet("Hello") greet("Hello", "GUG") fun greet( message: String = "Hi", name: String = "you" ): String = "$message $name" greet("Hello") greet("Hello", "GUG") Default parameters
65. String greet(Map options) { def msg = options.message ?: "Hi" def name = options.name ?: "you" return "$msg $name" } greet message: "Hello" greet name: "folks", message: "Hey" fun greet( message: String = "Hi", name: String = "you" ): String = "$message $name" greet(message = "Hello") greet(name="folks", message="Hey") Named parameters
66. class Main { static void main(args: String[]) { println("Hello ${args[0]}") } } fun main(args: Array<String>) { println("Hello ${args[0]}") } Function usage and imports
67. package test fun doStuff = println("OK!") val SO_SO_PI = 3.15 import test.doStuff import test.SO_SO_PI fun main() { doStuff() println(SO_SO_PI) } Function usage and imports
68. package test object Helpers { fun doStuff() = println("OK") } import test.Helpers fun main() { Helpers.doStuff() } Function usage and imports
69. package test object Helpers { fun doStuff() = println("OK") } import test.Helpers.doStuff fun main() { doStuff() } Function usage and imports
70. Type system
71. Any Nothing Int String MutableCollection MutableList Collection List
72. def list = [ 1, 2, 3 ] def map = [ "uno": 1, "dos": 2 ] val list = listOf(1, 2, 3) val map = mapOf( "uno" to 1, "dos" to 2 ) list.add(100) map["catorce"] = 14 list.add(100) map["catorce"] = 14 Collections
73. def list = [ 1, 2, 3 ] def map = [ "uno": 1, "dos": 2 ] val list = mutableListOf(1, 2, 3) val map = mutableMapOf( "uno" to 1, "dos" to 2 ) list.add(100) map["catorce"] = 14 list.add(100) map["catorce"] = 14 Mutable collections
74. val arr: Array<Int> = Array(3, { it }) arr[0] = 10 arr[0] = 10 def arr = [ 1, 2, 3 ] as Int[] val arr = arrayOf(1, 2, 3) Arrays
75. list.collect { it * 2 } list.findAllBy { it % 2 == 0 } list.inject(0) { acc, v -> acc + v } list.map { it * 2 } list.filter { it % 2 == 0 } list.reduce { acc, v -> acc + v } Collections higher order functions
77. Any Nothing Int String MutableCollection MutableList Collection List
78. fun fatalError() = throw new RuntimeException("Error") Nothing type : Nothing
79. fun mainLoop(): Nothing { while(true) { doThings() } } fun main(args: Array<String>) { mainLoop() println("End") } Nothing type
80. fun main(args: Array<String>) { val result = processParameters(args) } fun processParameters(args: Array<String>): String = TODO("Process params list") Placeholder for TODO functions
81. The billion dollar mistake
82. .. a null reference can be used to indicate that the data is missing or not known at this time. This led me to suggest that the null value is a member of every type, and a null check is required on every use of that reference variable, and it may be perhaps a billion dollar mistake. - Tony Hoare
83. @Inject MyUserService service User user = service.retrieveUser() user.name.toUpperCase() User user = service?.retrieveUser() user?.name?.toUpperCase() Handling null references
86. -MAX_INT, … -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, ... MAX_INT, null java.lang.Integer -MAX_INT, … -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, ... MAX_I NT, null kotlin.Int? -MAX_INT, … -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, ... MAX_INT kotlin.Int
87. Any Int String ... Nothing Any? Int? String? ... Nothing?
88. val foo: String = null var foo: String? = null foo = "bar" val myList: List<Int>? = null val myMap: Map<String, Int?> = mapOf("test" to null) Compilation error Null types
89. @Inject MyUserService service User user = service.retrieveUser() Only safe (?.) or non-null asserted (!!.) calls are allowed on a nullable receiver of type User? User user = service?.retrieveUser() String result = user.name.toUpperCase() @Inject var service: MyUserService? Null types
90. @Inject MyUserService service User user = service?.retrieveUser() String result = user.name.toUpperCase() @Inject var service: MyUserService? User? user = service?.retrieveUser() String? result = user?.name?.toUpperCase() Null types
91. user?.name?.toUpperCase() // String? user?.name ?: "unknown" // String user?.run { name = "Ada Lovelace" } // User? user!!.name // throws NPE! si user == null Null references navigation
93. Optional<User> user = service.retrieveUser() user.map { it.name?.toUpperCase() } // Optional<String> Optional<User> user = null Is Optional<T> enough?
95. Classes & Objects
97. • Heavily inspired in Scala syntax • Classes are final by default • There is no new keyword • Properties syntax • Delegation for mixins
98. class Animal @TupleConstructor class Cat extends Animal { String name } def felix = new Cat("Felix") def garfield = new Cat(name: "Garfield") open class Animal class Cat(val name: String) : Animal() val felix = Cat("Felix") val garfield = Cat(name = "Garfield") Class and objects definitions
99. @TupleConstructor class Animal { String type } open class Animal( val type: String ) class Cat extends Animal { String name Cat(String name) { super("cat") this.name = name } } class Cat( val name: String ) : Animal("Cat") Class and objects definitions
100. class Cat (val name: String) { String getCatName() { "meoow! ${name}" } } class Cat (val name: String) { val catName get() = "meoow! ${name}" } Properties for classes
101. @Canonical @Immutable(withCopy=true) class Person { String name Integer age } data class Person ( val name: String, val age: Integer ) Immutable data
102. sealed class Expression data class Num(val value: Int) : Expression data class Sum( val left: Expression, val right: Expression ) : Expression Sealed classes
103. class MyData(val num: Int) { operator plus(other: MyData) = MyData(num + other.num) } MyData(10) + MyData(20) // MyData(30) Operator overloading
104. class MyData(val num: Int) { infix fun times(other: Int) = MyData(num * other) } MyData(10) times 3 // MyData(30) Infix methods
105. Closures
106. list.map { it * 2 } list.map { num -> num * 2 } fun transform(list: List<Int>, mapFn: (Int) -> Int) = list.map(mapFn) .filter { it % 2 == 0 } transform(myList) { it * 2 } Using closures in Kotlin
107. class User(val name) val names = listOf("Ada", "Hipatia") names.map(String::toUpperCase) names.map(::User) Method references
108. Boolean hasZeros(Integer... ints) { ints.forEach { if (it == 0) return true } return false } fun hasZeros(vararg ints: Int): Boolean { ints.forEach { if (it == 0) return true } return false } hasZeros(0, 0, 0) hasZeros(0, 0, 0) // false // true Non-local returns
110. inline fun myInlineFn(func: () -> Unit) { println("Before") func() println("Result ${result}") } fun main() { myInlineFn { return } } Function inlining
111. inline fun myInlineFn(func: () -> Unit) { println("Before") func() println("Result ${result}") } fun main() { println("Before") return println("Result ${result}") } Function inlining
112. Boolean hasZeros(Integer... ints) { ints.forEach { if (it == 0) return true } return false } fun hasZeros(vararg ints: Int): Boolean { ints.forEach { if (it == 0) return true } return false } Function inlining
114. inline fun myInlineFn(func: () -> Unit) { println("Before") func() println("Result ${result}") } fun main() { myInlineFn { return } } Only allowed in inline functions Function inlining
116. Extension methods (a.k.a poor’s man metaprogramming)
117. assert 123g instanceof BigInteger assert 42G instanceof BigInteger assert 1.423 instanceof BigDecimal assert 42.0g instanceof BigDecimal assert 9203.10291G instanceof BigDecimal Groovy BigDecimal literals
118. 123.asBig() → Returns BigInteger 123.g → Returns BigInteger
119. Integer.metaClass.asBig = { new BigDecimal(delegate) } Integer.metaClass.getG = { new BigDecimal(delegate) } fun Int.asBig() = BigDecimal(this) val Int.g get() = BigDecimal(this) Extension methods
120. class AsBigExtension { static BigDecimal asBig(Integer num) { new BigDecimal(num) } static BigDecimal getG(Integer num) { new BigDecimal(num) } } use(AsBigExtension) { 10.asBig() } use(AsBigExtension) { 10.g } Groovy extension methods
121. fun transform(myfn: Int.() -> Int): Int { val result = 100 return result.myfn() } transform { println(this) // 100 return this * 2 // 200 } Extension method closures
123. Documentation
128. Ecosystem
133. Tools
138. https://try.kotlinlang.org/
139. Learning
140. http://kotlinlang.org/docs/reference/
141. https://try.kotlinlang.org/
143. I wish you were here
145. • Coroutines • Variance • Multiplatform (JS, Native, …) • Android • First class delegation • Reified generics • Annotation processors • Builders
146. That’s all folks
148. • AST’s & Macros (Compile time metaprogramming) • Dynamic needs (doh!) • Testing (Spock FTW) • Ecosystem (Grails, Gradle, GPars…) • Community Driven (vs company interests)
149. • New and growing strong • Safer than Java (& Groovy) • Multiple platforms (Android, Native…) • Awesome tooling (who knew?) • Attracting people from Java, Scala and Groovy
152. @alotor Any questions?