Decoding Kotlin - Your guide to solving the mysterious in Kotlin - JNation2025

Kotlin Mysteries
found from
years working
with Kotlin
By 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

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
…

Reflection 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$ca
llEngineCrossInline$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";
}
Decompile
d
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$callEngineCrossInline$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";
}
Decompile
d
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";
}
?
Decompile
d
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 first 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 @field
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
configuration 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?
I am an inquisitive
cat

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.

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-vali
dation.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 - JNation2025

More Related Content

Similar to Decoding Kotlin - Your guide to solving the mysterious in Kotlin - JNation2025 (20)

More from João Esperancinha (15)

Recently uploaded (20)

Decoding Kotlin - Your guide to solving the mysterious in Kotlin - JNation2025