Decoding Kotlin - Your Guide to Solving the Mysterious in Kotlin - Devoxx PL 2025

Kotlin Mysteries
found from years
working with
Kotlin
João Esperancinha 2024/04/24
https://jnation.pt/sessions/

Topics for today
Null safety
1. Working with the Spring Framework
2. Reflection to force nulls
Inline and cross-inline
1. The Java overview
Tail recursive => Tail Call Optimization
(TCO)
1. What is it
2. Why?
3. How it makes us work recursively and
not use mutable
Data classes
1. Why things work and why things don't
work
2. How to fix the ones that don't
3. How to work with use-site targets.
What does a `delegate` do? and other
use-site targets.
1. What is a delegate
2. How can a use-site target affect it
Kotlin & Java evolution
1. A main tale

About me
João Esperancinha
● Java
● Kotlin
● Groovy
● Scala
● Software Engineer 10+ years
● JESPROTECH owner for 2 years
Kong Champion/Java Professional/Spring Professional

What do I mean
with
Decompiling
Kotlin to ByteCode to Java
When we convert the
bytecode to Java, we get a
snapshot of how things would
work in the JVM. For a real
picture we would need to read
the bytecode directly, which
can be very difﬁcult
Let’s DEMO this!

Null-safety
Kotlin promises a
guarantee of null-safety.
Although we can use
nullable members in our
classes, we really shouldn’t
whenever possible.
When is whenever
possible?

@Table(name = "CAR_PARTS")
@Entity
data class CarPart(
@Id
val id: Long,
val name: String,
val productionDate: Instant,
val expiryDate: Instant,
val barCode: Long,
val cost: BigDecimal
)
CREATE SEQUENCE car_parts_id_sequence
START WITH 1
INCREMENT BY 1
NO MINVALUE
NO MAXVALUE
CACHE 1;
CREATE TABLE CAR_PARTS (
id BIGINT NOT NULL DEFAULT
nextval('car_parts_id_sequence'::regclass),
name VARCHAR(100),
production_date timestamp,
expiry_date timestamp,
bar_code BIGINT,
cost float
);
CRUD Entity Example

CRUD Entity Example
INSERT INTO CAR_PARTS
(name, production_date, expiry_date, bar_code, cost)
VALUES ('screw', current_date, current_date, 12345, 1.2);
INSERT INTO CAR_PARTS
(name, production_date, expiry_date, bar_code, cost)
VALUES (null, current_date, current_date, 12345, 1.2);
@Test
fun `should mysteriously get a list with a
car part with a name null`() {
carPartDao.findAll()
.filter { it.name == null }
.shouldHaveSize(1)
}
Is this possible?
Yes!
● Migrate data and database
model
● Use nullables
…

Reﬂection Example
val carPartDto = CarPartDto(
id = 123L,
name = "name",
productionDate = Instant.now(),
expiryDate = Instant.now(),
cost = BigDecimal.TEN,
barCode = 1234L
)
println(carPartDto)
val field: Field = CarPartDto::class.java
.getDeclaredField("name")
field.isAccessible = true
field.set(carPartDto, null)
println(carPartDto)
assert(carPartDto.name == null)
println(carPartDto.name == null)
data class CarPartDto(
val id: Long,
val name: String,
val productionDate:
Instant,
val barCode: Long,
)
Is this possible?
Yes!

Inline and
crossinline.
Inline and crossinline can be used in
combination with each other. Inline
provides bytecode copies of the
code per each call point and they
can even help avoid type erasure.
Crossinline improves readability
and some safety, but nothing really
functional.
Why does this
matter?

Inlining code with inline
fun main() {
callEngineCrossInline {
println("Place key in ignition")
println("Turn key or press push button ignition")
println("Clutch to the floor")
println("Set the first gear")
}.run { println(this) }
}
inline fun callEngineCrossInline(startManually: () -> Unit) {
run loop@{
println("This is the start of the loop.")
introduction {
println("Get computer in the backseat")
return@introduction
}
println("This is the end of the loop.")
}
println("Engine started!")
}
fun introduction(intro: () -> Unit) {
println(LocalDateTime.now())
intro()
return
}
public final class IsolatedCarPartsExampleKt {
public static final void main() {
int $i$f$callEngineCrossInline = false;
int var1 = false;
String var2 = "This is the start of the loop.";
System.out.println(var2);
introduction((Function0)IsolatedCarPartsExampleKt$cal
lEngineCrossInline$1$1.INSTANCE);
var2 = "This is the end of the loop.";
String var4 = "Engine started!";
Unit var3 = Unit.INSTANCE;
int var5 = false;
}
public static final void introduction(@NotNull
Function0 intro) {
Intrinsics.checkNotNullParameter(intro,
"intro");
LocalDateTime var1 = LocalDateTime.now();
intro.invoke();
} public final void invoke() {
String var1 = "Get computer in the
backseat";
}
Decompiled
code

Crossinline as just a marker for inlined code
fun main() {
callEngineCrossInline {
println("Place key in ignition")
println("Turn key or press push button ignition")
println("Clutch to the floor")
println("Set the first gear")
}.run { println(this) }
}
inline fun callEngineCrossInline(crossinline startManually: ()
-> Unit) {
run loop@{
println("This is the start of the loop.")
introduction {
println("Get computer in the backseat")
startManually()
return@introduction
}
println("This is the end of the loop.")
}
println("Engine started!")
}
fun introduction(intro: () -> Unit) {
println(LocalDateTime.now())
intro()
return
}
public final class IsolatedCarPartsExampleKt {
public static final void main() {
int $i$f$callEngineCrossInline = false;
int var1 = false;
String var2 = "This is the start of the loop.";
introduction((Function0)(new
IsolatedCarPartsExampleKt$main$$inlined$callEngineCro
ssInline$1()));
var2 = "This is the end of the loop.";
String var4 = "Engine started!";
Unit var3 = Unit.INSTANCE;
int var5 = false;
}
public static final void introduction(@NotNull
Function0 intro) {
Intrinsics.checkNotNullParameter(intro,
"intro");
LocalDateTime var1 = LocalDateTime.now();
intro.invoke();
}
public final void invoke() {
String var1 = "Get computer in the
backseat";
int var2 = false;
String var3 = "Place key in ignition";
var3 = "Turn key or press push button
ignition";
var3 = "Clutch to the floor";
var3 = "Set the first gear";
}
Decompiled
code

Crossinline for safety
object SpecialShopNonLocalReturn {
inline fun goToStore(chooseItems: () -> Unit) {
println("Walks in")
chooseItems()
}
@JvmStatic
fun main(args: Array<String> = emptyArray()) {
goToStore {
println("Make purchase")
return@main
}
println("Never walks out")
}
}
object SpecialShopLocalReturn {
inline fun goToStore(crossinline block: () -> Unit) {
println("Walks in")
block()
}
@JvmStatic
fun main(args: Array<String> = emptyArray()) {
goToStore {
println("Make purchase")
return@goToStore
}
println("Walks out")
}
}
@JvmStatic
public static final void main(@NotNull String[] args) {
Intrinsics.checkNotNullParameter(args, "args");
SpecialShopNonLocalReturn this_$iv = INSTANCE;
int $i$f$goToStore = false;
String var3 = "Walks in";
int var4 = false;
String var5 = "Make purchase";
}
@JvmStatic
public static final void main(@NotNull String[] args) {
Intrinsics.checkNotNullParameter(args, "args");
SpecialShopLocalReturn this_$iv = INSTANCE;
int $i$f$goToStore = false;
String var3 = "Walks in";
int var4 = false;
String var5 = "Make purchase";
String var6 = "Walks out";
}
?
Decompiled
code

Tail Call
Optimization
Since the late 50’s TCO was
already a theory intentend to be
applied to Tail Recursivity. It
allows tail recursive functions to
be transformed into iterative
functions in the compiled code
for better performance.
What is the catch?

Tail Call Optimization
sealed interface Part {
val totalWeight: Double
}
sealed interface ComplexPart : Part{
val parts: List<Part>
}
data class CarPart(val name: String, val weight:
Double) : Part {
override val totalWeight: Double
get() = weight
}
data class ComplexCarPart(
val name: String,
val weight: Double,
override val parts: List<Part>
) :
ComplexPart {
get() = weight
}
data class Car(
val name: String,
override val parts: List<Part>
) : ComplexPart {
get() = parts.sumOf { it.totalWeight }
}
tailrec fun totalWeight(parts: List<Part>, acc: Double = 0.0):
Double {
if (parts.isEmpty()) {
return acc
}
val part = parts.first()
val remainingParts = parts.drop(1)
val currentWeight = acc + part.totalWeight
return when (part) {
is ComplexPart -> totalWeight(remainingParts +
part.parts, currentWeight)
else -> totalWeight(remainingParts, currentWeight)
}
}
Why use this?
All variables
are immutable
Tail recursive

tailrec fun totalWeight(parts: List<Part>, acc: Double = 0.0):
Double {
return acc
}
val part = parts.first()
val remainingParts = parts.drop(1)
val currentWeight = acc + part.totalWeight
return when (part) {
is ComplexPart -> totalWeight(remainingParts +
part.parts, currentWeight)
else -> totalWeight(remainingParts, currentWeight)
}
}
public static final double totalWeight(@NotNull List parts, double acc) {
while(true) {
Intrinsics.checkNotNullParameter(parts, "parts");
return acc;
}
Part part = (Part)CollectionsKt.first(parts);
List remainingParts = CollectionsKt.drop((Iterable)parts, 1);
double currentWeight = acc + part.getTotalWeight();
if (part instanceof ComplexPart) {
List var10000 = CollectionsKt.plus((Collection)remainingParts,
(Iterable)((ComplexPart)part).getParts());
acc = currentWeight;
parts = var10000;
} else {
acc = currentWeight;
parts = remainingParts;
}
}
}
Variables are
mutable and
algorithm is
iterative

Why use Tail Call Optimization(TCO) and why use
tailrec?
1. tailrec allow us to use tail recursive code and transform it in the
background to iterative code
2. tail recursive functions and enabling TCO on them prevents endless
recursive calls due to failed check of the terminating condition
3. By using tail recursive functions and applying tailrec we enable the
possible use of TCO and with it guarantee the use of a single stackframe
preventing StackOverflow exceptions

Data classes and
Frameworks
Kotlin provides use-site targets
that allow us to specify where
particular annotations have to
be applied. Sometimes we need
them and sometimes we don’t
Why?

Working with Data classes
@Entity
data class CarPart(
@Id
val id: Long,
@Column
@field:NotNull
@field:Size(min=3, max=20)
val name: String,
val barCode: Long,
@field:Min(value = 5)
)
@Entity
data class CarPart(
@Id
val id: Long,
@Column
@NotNull
@Size(min=3, max=20)
val name: String,
val barCode: Long,
@Min(value = 5)
)
Doesn’t work Works!
Why
use-site
targets?

https://kotlinlang.org/docs/annotations.html#annotation-use-site-targets
If you don't specify a use-site target, the target is chosen
according to the @Target annotation of the annotation
being used. If there are multiple applicable targets, the ﬁrst
applicable target from the following list is used:
● param
● property
● field
● https://github.com/Kotlin/KEEP/issues/402
Kotlin 2.2.0 as experimental

@Target({ElementType.METHOD,
ElementType.FIELD,
ElementType.ANNOTATION_TYPE,
ElementType.CONSTRUCTOR,
ElementType.PARAMETER,
ElementType.TYPE_USE})
@Retention(RetentionPolicy.RUNTIME)
@Repeatable(List.class)
@Documented
@Constraint(
validatedBy = {}
)
public @interface Size {
PARAMETER
is
selected

public final class CarPart {
@Id
private final long id;
@Column
@NotNull
private final String name;
@NotNull
private final Instant productionDate;
@NotNull
private final Instant expiryDate;
private final long barCode;
@NotNull
private final BigDecimal cost;
public final long getId() {
return this.id;
}
@NotNull
public final String getName() {
return this.name;
}
@NotNull
public final Instant getProductionDate() {
return this.productionDate;
}
@NotNull
public final Instant getExpiryDate() {
return this.expiryDate;
}
public final long getBarCode() {
return this.barCode;
}
@NotNull
public final BigDecimal getCost() {
return this.cost;
}
public CarPart(long id, @jakarta.validation.constraints.NotNull @Size(min =
3,max = 20) @NotNull String name, @NotNull Instant productionDate, @NotNull
Instant expiryDate, long barCode, @Min(5L) @NotNull BigDecimal cost) {
Intrinsics.checkNotNullParameter(name, "name");
Intrinsics.checkNotNullParameter(productionDate, "productionDate");
Intrinsics.checkNotNullParameter(expiryDate, "expiryDate");
Intrinsics.checkNotNullParameter(cost, "cost");
Not where we want
them to be,
but where they are
expected

@Entity
data class CarPart(
@Id
val id: Long,
@Column
@field:NotNull
@field:Size(min=3, max=20)
val name: String,
val barCode: Long,
@field:Min(value = 5)
)
public final class CarPart {
@Id
private final long id;
@Column
@NotNull
@Size(
min = 3,
max = 20
)
@org.jetbrains.annotations.NotNull
private final String name;
private final Instant productionDate;
private final Instant expiryDate;
private final long barCode;
@Min(5L)
private final BigDecimal cost;
Since @ﬁeld forces
the target, these
annotations get
applied where they
should

Delegates and other
use-site targets
Delegation is a great part
of the Kotlin language
and it is quite different
than what we are used to
seeing in Java
But how can we use it?

Working with Delegates
interface Horn {
fun beep()
}
class CarHorn : Horn {
override fun beep() {
println("beep!")
}
}
class WagonHorn : Horn {
override fun beep() {
println("bwooooooo!")
}
}
annotation class DelegateToWagonHorn
annotation class DelegateToCarHorn
class HornPack {
@delegate:DelegateToWagonHorn
val wagonHorn: Horn by SoundDelegate(WagonHorn())
@delegate:DelegateToCarHorn
val carHorn: Horn by SoundDelegate(CarHorn())
}
class SoundDelegate(private val initialHorn: Horn) {
operator fun getValue(thisRef: Any?, property: KProperty<*>): Horn {
return initialHorn
}
}
Where is this being applied to?
Horn or SoundDelegate?

public final class HornPack {
// $FF: synthetic field
static final KProperty[] $$delegatedProperties = new KProperty[]{Reflection.property1(new
PropertyReference1Impl(HornPack.class, "wagonHorn", "getWagonHorn()Lorg/jesperancinha/talks/carparts/Horn;",
0)), Reflection.property1(new PropertyReference1Impl(HornPack.class, "carHorn",
"getCarHorn()Lorg/jesperancinha/talks/carparts/Horn;", 0))};
@DelegateToWagonHorn
@NotNull
private final SoundDelegate wagonHorn$delegate = new SoundDelegate((Horn)(new WagonHorn()));
@DelegateToCarHorn
@NotNull
private final SoundDelegate carHorn$delegate = new SoundDelegate((Horn)(new CarHorn()));
@NotNull
public final Horn getWagonHorn() {
return this.wagonHorn$delegate.getValue(this, $$delegatedProperties[0]);
}
@NotNull
public final Horn getCarHorn() {
return this.carHorn$delegate.getValue(this, $$delegatedProperties[1]);
}
}
SoundDelegate
Not Horn!

class SanitizedName(var name: String?) {
operator fun getValue(thisRef: Any?,
property: KProperty<*>): String? = name
operator fun setValue(thisRef: Any?,
property: KProperty<*>, v: String?) {
name = v?.trim()
}
}
class PartNameDto {
@get:NotBlank
@get:Size(max = 12)
var name: String? by SanitizedName(null)
override fun toString(): String {
return name ?: "N/A"
}
}
class ImpossiblePartNameDto {
@delegate:NotBlank
@delegate:Size(max = 12)
var name: String? by SanitizedName(null)
override fun toString(): String {
return name ?: "N/A"
}
}
public final class PartNameDto {
static final KProperty[] $$delegatedProperties = new KProperty[]{Reflection.mutableProperty1(new
MutablePropertyReference1Impl(PartNameDto.class, "name", "getName()Ljava/lang/String;", 0))};
@Nullable
private final SanitizedName name$delegate = new SanitizedName((String)null);
@NotBlank
@Size(
max = 12
)
@Nullable
return this.name$delegate.getValue(this, $$delegatedProperties[0]);
}
…
public final class ImpossiblePartNameDto {
static final KProperty[] $$delegatedProperties = new KProperty[]{Reflection.mutableProperty1(new
MutablePropertyReference1Impl(ImpossiblePartNameDto.class, "name", "getName()Ljava/lang/String;",
0))};
@NotBlank
@Size(
max = 12
)
@Nullable
private final SanitizedName name$delegate = new SanitizedName((String)null);
@Nullable
return this.name$delegate.getValue(this, $$delegatedProperties[0]);
}
jakarta.validation.UnexpectedTypeException:
HV000030: No validator could be found for
constraint 'jakarta.validation.constraints.Size'
validating type 'SanitizedName'. Check
conﬁguration for 'name$delegate'...

@Service
data class DelegationService(
val id: UUID = UUID.randomUUID()
) {
@delegate:LocalDateTimeValidatorConstraint
@get: Past
val currentDate: LocalDateTime by LocalDateTimeDelegate()
}
public class DelegationService {
// $FF: synthetic field
static final KProperty[] $$delegatedProperties = new KProperty[]{Reflection.property1(new
PropertyReference1Impl(DelegationService.class, "currentDate",
"getCurrentDate()Ljava/time/LocalDateTime;", 0))};
@LocalDateTimeValidatorConstraint
@NotNull
private final LocalDateTimeDelegate currentDate$delegate;
@NotNull
private final UUID id;
@Past
@NotNull
public LocalDateTime getCurrentDate() {
return this.currentDate$delegate.getValue(this, $$delegatedProperties[0]);
}
@Target(AnnotationTarget.FIELD, AnnotationTarget.FUNCTION)
@Retention(AnnotationRetention.RUNTIME)
@Constraint(validatedBy = [LocalDateTimeValidator::class])
@MustBeDocumented
annotation class LocalDateTimeValidatorConstraint(
val message: String = "Invalid value",
val groups: Array<KClass<*>> = [],
val payload: Array<KClass<*>> = []
)
class LocalDateTimeValidator : ConstraintValidator<LocalDateTimeValidatorConstraint, LocalDateTimeDelegate> {
override fun initialize(constraintAnnotation: LocalDateTimeValidatorConstraint) {
}
override fun isValid(value: LocalDateTimeDelegate, context: ConstraintValidatorContext): Boolean {
val country = Locale.getDefault().country.trim()
logger.info("Current country is {}", country)
return when (country) {
"", "NL", "US", "PT", "ES", "UK", "FR"-> true
else -> false
}
}
companion object {
val logger: Logger = getLogger<LocalDateTimeValidator>()
}
}

Unnamed classes Unnamed classes in
Kotlin were a focal point
in Java vs Kotlin
discussions
They have arrived in
Java

Main.java
void main() {
System.out.println("Hello, world!");
}
Unnamed Classes
Main.kt
fun main(args: Array<String>) {
runApplication<CarPartsDataStructureApplication>(*args)
}
JEP 445: Unnamed
Classes and Instance
Main Methods
Friendly competition
drives innovation, but
also a lot of synergy

What’s next?
● Better understanding of the Kotlin Language.
● Better understanding of the Spring Framework, Quarkus, Ktor and where, when
and how to use them.
● Search the Kotlin documentation before searching for the seemingly
unexplainable.
● Nothing is perfect and Kotlin also falls into that category and recognizing that,
allow us to be better.
● Check if Kotlin or Java are the right languages for you and your team

Questions and answers
Q: Is the use of tailrec only intended to make sure we use readable code as for
example with recursive functions and then use it iteratively when compiled to the
bytecode?
A: A quick answer is yes. The nuanced answer is that, while tailrec enables the
compiler to apply the optimization only if the function is tail recursive, it is
only with the application of TCO, that we can make sure to avoid StackOverflow
exceptions, because with TCO we use only one StackFrame. It is TCO that does this
and not exactly the application of tailrec.

Questions?
I am an inquisitive cat

Resources
● Null Safety: https://kotlinlang.org/docs/null-safety.html
● Inline: https://kotlinlang.org/docs/inline-functions.html
● Tail Call Optimization: https://kotlinlang.org/docs/functions.html#tail-recursive-functions
● Annotation use-site targets:
https://kotlinlang.org/docs/annotations.html#annotation-use-site-targets
● Spring Validation via AOP :
https://docs.spring.io/spring-framework/reference/web/webmvc/mvc-controller/ann-validation.html
● https://github.com/Kotlin/KEEP/issues/402
● https://openjdk.org/jeps/445

Source code and slides
● https://github.com/jesperancinha/kotlin-mysteries

About me
● Homepage - https://joaofilipesabinoesperancinha.nl
● LinkedIn - https://www.linkedin.com/in/joaoesperancinha/
● YouTube - JESPROTECH - https://www.youtube.com/@jesprotech
● Bluesky - https://bsky.app/profile/jesperancinha.bsky.social
● Mastodon - https://masto.ai/@jesperancinha
● GitHub - https://github.com/jesperancinha
● Hackernoon - https://hackernoon.com/u/jesperancinha
● DevTO - https://dev.to/jofisaes
● Medium - https://medium.com/@jofisaes

Decoding Kotlin - Your Guide to Solving the Mysterious in Kotlin - Devoxx PL 2025

More Related Content

Similar to Decoding Kotlin - Your Guide to Solving the Mysterious in Kotlin - Devoxx PL 2025 (20)

More from João Esperancinha (15)

Recently uploaded (20)

Decoding Kotlin - Your Guide to Solving the Mysterious in Kotlin - Devoxx PL 2025