Variables (val, var) and null safety in Android Kotlin - Build, Publish & Deploy

Build & Publish - Variables (val, var) and null safety

Performance Impact

Using val (immutable variables) helps the compiler optimize your code, leading to better performance and safer memory usage. var (mutable variables) allow changes but can increase complexity and potential bugs.

Null safety in Kotlin prevents null pointer exceptions, which can crash your app and degrade user experience. Proper null handling improves app stability and reduces unexpected crashes.

Overall, these features help maintain smooth UI rendering at 60fps by avoiding runtime errors and unnecessary object mutations.

Optimization Tips

• Prefer val over var to enable compiler optimizations and reduce bugs.
• Use Kotlin's null safety features like nullable types (String?) and safe calls (?.) to avoid crashes.
• Initialize variables as late as possible to save memory and improve startup time.
• Use the Elvis operator (?:) to provide default values and avoid null checks cluttering your code.

App Size and Startup Time

Using val and var does not significantly affect app bundle size. Kotlin's null safety features are part of the language and runtime, so they add minimal overhead.

Proper null safety reduces runtime crashes, which can indirectly improve perceived startup time by avoiding app restarts or freezes.

iOS vs Android Differences

On Android, Kotlin is the preferred language with built-in null safety and variable immutability features.

iOS apps use Swift, which has similar concepts: let for constants and var for variables, plus optional types for null safety.

Both platforms emphasize immutability and null safety to improve app stability and performance, but the syntax and runtime differ.

Store Review Guidelines

• Ensure your app does not crash due to null pointer exceptions; this is critical for passing both Google Play and Apple App Store reviews.
• Follow platform best practices for memory management by using immutable variables where possible.
• Provide a smooth user experience with stable and responsive UI, which is often checked during app review.

Self-Check Question

Your app takes 5 seconds to load this screen. What's likely wrong?

Answer: You might be using many mutable variables (var) causing unnecessary recomputations or holding onto null values without proper checks, leading to crashes or delays. Also, missing null safety checks can cause runtime exceptions that slow down loading.

Key Result

Using Kotlin's val and var with null safety improves app stability and performance by preventing crashes and enabling compiler optimizations, ensuring smooth UI and faster load times.

Practice

1. Which keyword should you use in Kotlin for a variable whose value will never change after assignment?

easy

A. let

B. var

C. val

D. const

Solution

1. Step 1: Understand Kotlin variable keywords

   val is used for read-only variables, meaning their value cannot change once assigned.

2. Step 2: Compare with other keywords

   var allows changing the value; const is not a Kotlin keyword for variables; let is from other languages like Swift or JavaScript.

3. Final Answer:

   val -> Option C

4. Quick Check:

   Immutable variable = val [OK]

Hint: Use val for fixed values, var for changeable ones [OK]

Common Mistakes:

• Confusing val and var
• Using const which is not Kotlin variable keyword
• Thinking let is Kotlin keyword

2. Which of the following is the correct way to declare a nullable String variable in Kotlin?

easy

A. var name: String? = null

B. var name: String?

C. var name: String = null

D. var name: String = "null"

Solution

1. Step 1: Understand nullable type syntax

   In Kotlin, adding ? after the type means the variable can hold null.

2. Step 2: Check initialization

   Nullable variables should be initialized with null if no value is assigned yet.

3. Final Answer:

   var name: String? = null -> Option A

4. Quick Check:

   Nullable variable syntax = var name: String? = null [OK]

Hint: Use ? after type and assign null to allow null values [OK]

Common Mistakes:

• Assigning null to non-nullable type
• Forgetting ? for nullable types
• Using string "null" instead of null

3. What will be the output of this Kotlin code?

var count: Int? = 5
count = null
println(count)

medium

A. null

B. 0

C. 5

D. Compilation error

Solution

1. Step 1: Analyze variable declaration

   count is declared as nullable Int (Int?) and initially set to 5.

2. Step 2: Assign null and print

   Then count is assigned null, which is allowed for nullable types, so printing it outputs null.

3. Final Answer:

   null -> Option A

4. Quick Check:

   Nullable variable assigned null prints null [OK]

Hint: Nullable variables can hold null and print it directly [OK]

Common Mistakes:

• Expecting 5 after reassignment
• Thinking null prints 0
• Assuming compilation error for null assignment

4. Identify the error in this Kotlin code snippet:

val message: String = null
println(message)

medium

A. No error, code runs fine

B. val cannot be used with String type

C. println cannot print val variables

D. Cannot assign null to non-nullable type String

Solution

1. Step 1: Check variable type and assignment

   message is declared as non-nullable String but assigned null, which is not allowed.

2. Step 2: Understand Kotlin null safety rules

   Non-nullable types cannot hold null; to allow null, type must be String?.

3. Final Answer:

   Cannot assign null to non-nullable type String -> Option D

4. Quick Check:

   Non-nullable String cannot be null [OK]

Hint: Non-nullable types cannot hold null values [OK]

Common Mistakes:

• Thinking val disallows null but var allows
• Assuming println can't print val
• Ignoring Kotlin's null safety rules

5. You want to create a variable that can change its value but sometimes hold no value at all. Which declaration is correct in Kotlin?

hard

A. val data: Int = null

B. var data: Int? = null

C. val data: Int? = 0

D. var data: Int = null

Solution

1. Step 1: Understand mutability and nullability

   The variable must be changeable, so var is needed, and it must allow null, so type must be nullable with ?.

2. Step 2: Check each option

   val data: Int = null uses val (immutable) and assigns null to non-nullable type (error). var data: Int? = null uses var and nullable type with null initial value (correct). val data: Int? = 0 uses val (immutable) but nullable type with 0 initial value (not changeable). var data: Int = null uses var but non-nullable type assigned null (error).

3. Final Answer:

   var data: Int? = null -> Option B

4. Quick Check:

   Mutable and nullable = var with ? [OK]

Hint: Use var for changeable and ? for nullable types [OK]

Common Mistakes:

• Using val when variable should change
• Assigning null to non-nullable type
• Confusing val and var usage