Below are a few of, what I thought were, the interesting tidbits from Hadi Hariri’s GDD Europe ’17 talk entitled “What can Kotlin do for me?”
Misc
use val by default instead of var
“work towards having read only variables”
easily create a list of numbers within a rang
val numbers = 1..100
asSequence() to create a Sequence from an Iterable See Doc
Functions
“what we are trying to do is keep functions as simple as possible…“
Characteristics of Kotlin functions
- functions don’t have to exist within a class
- they can exist outside of a class as “top-level” functions
- these top-level functions can then be called from wherever you would like
Function Syntax
fun sum(x: Int, y: Int) = x + y
- skip declaration of return type
- omit curly braces
fun sum(x: Int, y: Int) : Int { return x + y }
- can also be declared like this
Overloaded methods vs Kotlin functions
Java requires overloaded methods to provide methods with the same functionality but different arguments
This can lead to a great deal of duplicated, boilerplate code
Functions in Kotlin reduce this by supporting the following features
- default arguments
- named arguments
Because of this, a single function can be called multiple ways, with different numbers of arguments. For example:
// define a log function with default arg values
fun log(tag:String = "tag", msg:String = "")
// can then call the function in multiple ways
log()
log("a tag", "a message")
log(msg="a message", tag="a tag")
Data classes
Data classes provides getters/setters, copy, equals/hashCode functions for you
- reduces boilerplate
- no maintenance required as class changes
Why does this matter? Some might argue that this is all generated by the IDE in java anyways. Hadi makes a great point here.
Sure, the IDE might generate the equals() method for you, but it won’t update it every time the class’s data changes. It won’t ensure that you didn’t manually adjust the generated implementation and introduce an error.
With Kotlin data classes, this code is generated behind the scenes for you so there isn’t a question about whether it’s up to date or correct (assuming you trust the tooling, which I do at this point)
When using the copy function, you can choose to override the copied value for certain properties
val modelCopy = model.copy(value = "a new value")
Destructuring of variables
Data classes support destructuring declarations, when can help make your code more understandable
For example, you can write a function that returns a `Pair` or `Triple`then use destructuring to make the returned values more comprehensible
val returnedPair = returnsPair() println(returnedPair.second) // destructuring allows us to supply meaningful names to the values val (_, email) = returnsPair() println(email)
Typealiases
Typealiases allow a developer to provide a new name for an existing type
typealias CustomerName = String- can improve readability
- can enable you to use an alias throughout your code, then change the alias definition to refactor the code in a single place
Extension functions
Allow us to extend a class’s functionality, without inheriting from that class
- can extend any type in Kotlin or Java
- adds expressivity
The Kotlin standard library is largely build from extension functions on generic types. For example:
public inline fun <T> T.apply(block: T.() -> Unit): T { block(); return this }
In an Android “context”, we could imagine creating extension functions that perform tasks like getting resources in a backwards compatible way with a cleaner api than using ContextCompat. For example:
ContextCompat.getColor(context, R.color.primary) // an extension function version of the same code context.getColorCompat(R.color.primary)
What does all of this buy you?
- expressivity
- concise code
- less boilerplate
- modern features
“You can do everything in Java, and when I say Java I mean you can do everything in assembly“
Kotlin doesn’t necessarily come with any single, amazing feature that requires necessitates developers learning it right away. Rather, the experience of using Kotlin on a daily basis is greater than the sum of its parts. All of the small niceties add up to make the language feel easy to use, expressive, convenient, and safe.
Hadi makes the comparison that Assembly provides the same functionality as modern languages, but not many people would choose Assembly for their daily development language. Newer languages emerged that made developers’ jobs easier and more enjoyable.
That’s certainly how I feel about Kotlin. It’s not that Kotlin suddenly enables me to write well architected code, or think up brilliant design patterns, but instead it gets out of my way and lets me express the patterns and functionality that I want to, in a much easier way.
I love to meet/talk/discuss and help where I can. If you want to chat or ask a question you can follow me on Twitter, YouTube, Instagram and Facebook.