Why immutability by default matters in Kotlin - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Kotlin code with immutable and mutable variables?

Consider the following Kotlin code snippet. What will be printed?

Kotlin

val x = 10
var y = 20
y = 30
println("x = $x, y = $y")

A x = 30, y = 30

B x = 10, y = 20

C Compilation error due to val reassignment

D x = 10, y = 30

💡 Hint

Remember that val means immutable and var means mutable.

val x = 10 creates an immutable variable, so x cannot change. var y = 20 creates a mutable variable, so y can be reassigned to 30. The print statement shows the current values.

🧠 Conceptual

intermediate

Why is immutability by default beneficial in Kotlin?

Which of the following is the best reason why Kotlin uses immutability by default with val?

A It makes the program run faster by avoiding all variable changes.

B It prevents accidental changes to data, making code safer and easier to understand.

C It forces all variables to be constants and never change.

D It allows variables to be changed only inside functions.

💡 Hint

Think about how bugs happen when data changes unexpectedly.

Immutability prevents accidental changes, which reduces bugs and makes reasoning about code easier. It does not force all variables to be constants, only those declared with val. Mutable variables can still be declared with var.

🔧 Debug

advanced

What error does this Kotlin code produce?

Examine this Kotlin code snippet. What error will it cause?

Kotlin

val list = mutableListOf(1, 2, 3)
list = mutableListOf(4, 5, 6)

A Val cannot be reassigned error

B No error, code runs fine

C Type mismatch error

D Null pointer exception

💡 Hint

Look at the val keyword and what it means for reassignment.

val means the variable reference cannot be changed. Trying to assign a new list to list causes a compilation error: 'Val cannot be reassigned'. The contents of the list can be changed, but the reference cannot.

❓ Predict Output

advanced

What is the output when modifying a mutable list declared with val?

What will this Kotlin code print?

Kotlin

val numbers = mutableListOf(1, 2, 3)
numbers.add(4)
println(numbers)

A [1, 2, 3]

B Compilation error due to val reassignment

C [1, 2, 3, 4]

D Runtime error: UnsupportedOperationException

💡 Hint

Think about what val protects: the reference or the object?

val means the reference numbers cannot point to a different list, but the list itself can be changed because it is mutable. So adding 4 works and prints the updated list.

🧠 Conceptual

expert

Why does Kotlin prefer immutability by default in concurrent programming?

In concurrent programming, why is immutability by default important in Kotlin?

A Because immutable data cannot be changed by multiple threads, preventing race conditions.

B Because mutable data is faster to access in multiple threads.

C Because Kotlin disallows mutable variables in concurrent code.

D Because immutability automatically synchronizes threads.

💡 Hint

Think about what causes bugs when many threads change the same data.

Immutable data cannot be changed after creation, so multiple threads can safely read it without causing conflicts or race conditions. Mutable data requires careful synchronization to avoid bugs.