The document discusses mixing Scala and Kotlin code. It provides reasons why a company using Scala may want to adopt Kotlin, such as it being easier for mobile developers who prefer Kotlin. It also notes reasons to continue using Scala, like existing Scala code and its powerful features. The document outlines some challenges in mixing the languages, like differences in collections and functions, but provides solutions like converting between the types. It recommends it is easier to call Kotlin from Scala than the other way around.

1. Mixing
Scala and Kotlin
March 2021
Alexey Soshin
Solutions Architect

2. Agenda
● What is Depop
● Why?!
● Collections
● Nullability
● Functions
● Coroutines

3. Depop
Building the most diverse, progressive
Home of Fashion.
● Fashion marketplace app for the next generation
to buy, sell and discover unique fashion.
● Community of like minded creatives, young
entrepreneurs and sustainable enthusiasts who
are transforming the fashion industry.
● Globally, over 26 million users on the platform in
147 countries, and 90% of our active users are
under the age of 26, or Gen Z.
● As an app based platform, Depop combines the
familiarity of social media with the mechanics of
a resale marketplace.
● Our Mission is to Empower our community to
create a new sustainable and equitable fashion
system.

4. Motivation

5. Scala was there first
● Scala first appeared around 2004
● Kotlin - 2011, out of Beta in 2016

6. The Dinosaur in the Room

7. Scala engineers are rare

8. Scala is F[_] hard

9. Mobile Developers ❤️ Kotlin
● Kotlin is the main language
on Android
● Conceptually closer to Swift
than Scala
● Great for Backend For
Frontend approach, where
Mobile engineers control the
API layer

10. Map[String, String] or
Map<String, String>?

11. def doSomething(properties: Map[String, List[String]])
fun doSomething(properties: Map<String, List<String>>)
Type mismatch:
inferred type is kotlin.collections.Map<String, kotlin.collections.List<String>>
but scala.collection.immutable.Map<String!,
scala.collection.immutable.List<String!>!>! was expected
🤔
😱
Collections

12. Collections
def doSomething(m: Map[String, List[String]])
doSomething(mapOf("hello" to listOf("world")))
import scala.collection.JavaConverters._
def doSomething(m: java.util.Map[String,
java.util.List[String]])

13. Collections
def doSomething(m: java.util.Map[String,
java.util.List[String]]) = {
val a: mutable.Map[String, util.List[String]] =
m.asScala
val b: collection.Map[String, List[String]] =
a.mapValues(l => l.asScala.toList)
doSomething(b.toMap)
}
def doSomething(m: Map[String, List[String]])

14. Scala Option vs Kotlin
nullability

15. def doSomething(value: Option[String] = None)
fun doSomething(value: String?)
🤔
Nullability
Type mismatch:
Required: Option<String!>!
Found: String?

16. inline fun <reified T> none() = Option.empty<T>()
inline fun <reified T> some(t: T) = Option.apply(t)
if (value == null) none() else some(value)
private fun Any?.asOption() = if (this == null) none() else some(this)
Nullability

17. When a Function is not
a Function

18. def executeBlock(block: () => Unit) = {
println("I'm going to execute it!")
block()
}
fun executeBlock(block: () -> Unit) {
println("I'm going to execute it!")
block()
}
Functions
=?

19. MainKt.executeBlock(() => println("Hello from Scala"))
Error: type mismatch;
found : Unit (in scala)
required: Unit (in kotlin)
MainKt.executeBlock(() => println("hello"))
Functions

20. def executeBlock(block: () => Unit) = {
println("I'm going to execute it!")
block()
}
≠
fun executeBlock(block: () -> Unit) {
println("I'm going to execute it!")
block()
}
kotlin.jvm.functions.Function0 scala.Function0
Functions

21. def executeBlock(block: () => Int): Int = {
println("I'm going to execute it!")
block()
1
}
=?
fun executeBlock(block: () -> Int): Int {
println("I'm going to execute it!")
block()
return 1
}
kotlin.jvm.functions.Function0 scala.Function0
≠
Functions

22. MainKt.executeBlock(() => 1)
ScalaObject.executeBlock {
println("Hello from Kotlin")
1
}
👍
👍
Functions

23. Coroutines

24. class AsyncKotlinClass : CoroutineScope {
override val coroutineContext = Dispatchers.Default
fun getCatAsync(name: String) = async {
Cat(name)
}
suspend fun getCat(name: String): Cat {
delay(100)
return Cat(name)
}
}
Coroutines

25. val asyncKotlinClass = new AsyncKotlinClass()
val res = asyncKotlinClass.getCatAsync("Fluffy")
val cat = res.await()
Error: not enough arguments for method await:
(x$1: kotlin.coroutines.Continuation[_ >: Cat])Object.
Unspecified value parameter x$1.
val cat = res.await()
Coroutines

26. val asyncKotlinClass = new AsyncKotlinClass()
val cat = asyncKotlinClass.getCat("Fluffy")
Error: not enough arguments for method getCat:
(x$1: String, x$2: kotlin.coroutines.Continuation[_ >: Cat])Object.
Unspecified value parameter x$2.
val cat = asyncKotlinClass.getCat("Fluffy")
😱
Coroutines

27. Coroutines

28. import kotlinx.coroutines.future.*
fun getCatAsync(name: String) =
async {
Cat(name)
}.asCompletableFuture()
import
scala.compat.java8.FutureConverters._
val asyncKotlinClass = new
AsyncKotlinClass()
val res =
asyncKotlinClass.getCatAsync("Fluffy")
val cat = toScala(res)
Coroutines

29. Summary
● Reasons to adopt Kotlin in a Scala company:
○ Easier to adopt
○ Mobile Developers love it
● Reasons to keep using Scala
○ Very powerful language
○ Lots of code already written in it
● If you need to mix Scala and Kotlin
○ Easier to call Kotlin from Scala than Scala from
Kotlin

30. We’re Hiring!
Our Blog: https://engineering.depop.com
Tech careers:
https://boards.greenhouse.io/depop
Stay connected:
https://alexey-soshin.medium.com/
https://twitter.com/alexey_soshin
https://www.udemy.com/user/alexey-soshin/

31. THANK YOU