1. Null Safety

One of Kotlin's most celebrated features is its built-in null safety. In many programming languages, trying to use a variable that doesn't have a value (is "null") causes your program to crash.

How it works:

var name: String = "John"  // Cannot be null
var nickname: String? = null  // Can be null (notice the ?)

name = null  // Compiler error! This won't even compile
nickname = null  // This is fine

// Safe access
println(nickname?.length)  // Returns null if nickname is null
println(nickname!!.length)  // Throws exception if nickname is null

// Elvis operator
val length = nickname?.length ?: 0  // Use 0 if nickname is null

This means the compiler catches potential null reference errors before your program runs, not when it crashes in production.

2. Type Inference

Kotlin can automatically figure out what type a variable is based on the value you assign to it.

val age = 25  // Kotlin knows this is an Int
val name = "Alice"  // Kotlin knows this is a String
val price = 19.99  // Kotlin knows this is a Double

// You can still specify types explicitly if you want
val count: Int = 100

This makes code cleaner without sacrificing type safety.

3. Data Classes

Creating classes to hold data is incredibly common in programming. In Java, you'd need to write constructors, getters, setters, equals(), hashCode(), and toString() methods manually. Kotlin does this automatically.

// Kotlin
data class Person(val name: String, val age: Int)

// This one line automatically generates:
// - Constructor
// - Getters (and setters for 'var' properties)
// - equals() and hashCode()
// - toString()
// - copy() function

The equivalent Java code would be 30-50 lines long!

4. Extension Functions

You can add new functions to existing classes without modifying their source code or using inheritance.

fun String.addExclamation(): String {
    return this + "!"
}

val greeting = "Hello"
println(greeting.addExclamation())  // Prints: Hello!

This is powerful because you can extend even classes you don't own (like String, which comes from the Java standard library).

5. Smart Casts

When you check the type of a variable, Kotlin automatically casts it for you.

fun processValue(value: Any) {
    if (value is String) {
        // Kotlin automatically knows 'value' is a String here
        println(value.length)  // No need to cast!
    }
}

6. Higher-Order Functions and Lambdas

Kotlin treats functions as first-class citizens, meaning you can pass them as arguments, return them from other functions, and store them in variables.

val numbers = listOf(1, 2, 3, 4, 5)

// Lambda expression to filter even numbers
val evenNumbers = numbers.filter { it % 2 == 0 }

// Lambda expression to double each number
val doubled = numbers.map { it * 2 }

println(evenNumbers)  // [2, 4]
println(doubled)  // [2, 4, 6, 8, 10]

The { } syntax creates a lambda (anonymous function), and it is the implicit parameter name.

7. Immutability by Default

Kotlin encourages immutable data through the val keyword.

val immutable = "Cannot change"  // Like 'final' in Java
var mutable = "Can change"  // Regular variable

immutable = "New value"  // Compiler error!
mutable = "New value"  // This works

Immutable data is easier to reason about and safer in concurrent programming.

8. When Expression (Enhanced Switch)

Kotlin's when is much more powerful than Java's switch.

fun describe(obj: Any): String = when (obj) {
    1 -> "One"
    "Hello" -> "Greeting"
    is Long -> "Long number"
    !is String -> "Not a string"
    in 1..10 -> "Number between 1 and 10"
    else -> "Unknown"
}

9. String Templates

You can embed expressions directly in strings.

val name = "Alice"
val age = 30

println("My name is $name and I am $age years old")
println("Next year I'll be ${age + 1}")

10. Ranges and Progression

Kotlin has built-in support for ranges.

for (i in 1..5) {
    println(i)  // Prints 1, 2, 3, 4, 5
}

for (i in 1 until 5) {
    println(i)  // Prints 1, 2, 3, 4
}

for (i in 5 downTo 1) {
    println(i)  // Prints 5, 4, 3, 2, 1
}

if (age in 18..65) {
    println("Working age")
}

Where Kotlin is Used

Android Development

Google's official recommendation for new Android apps. Over 70% of the top 1000 Android apps use Kotlin.

Server-Side Development

Using frameworks like Ktor, Spring Boot, or Micronaut to build web servers and APIs.

Multiplatform Development

Kotlin Multiplatform allows sharing code between Android, iOS, web, and desktop applications.

Desktop Applications

Using frameworks like TornadoFX or Compose for Desktop.

Data Science

Kotlin is growing in data science with libraries like Kotlin DataFrame and integration with existing Java data science tools.

Comparison with Java

Advantages over Java:

• Significantly less boilerplate code
• Built-in null safety
• More expressive and concise syntax
• Modern language features (coroutines, extension functions)
• Better type inference
• Functional programming support

Considerations:

• Slightly slower compilation times (though improving)
• Smaller community compared to Java (though growing rapidly)
• Learning curve for Java developers (though generally considered easier than Java for beginners)

Kotlin represents a modern approach to programming that combines the best of object-oriented and functional paradigms while maintaining compatibility with the vast Java ecosystem. It prioritizes developer happiness and productivity through thoughtful language design, making it easier to write safe, concise, and maintainable code.

Whether you're building Android apps, server-side applications, or exploring multiplatform development, Kotlin provides the tools and features to make development more enjoyable and efficient.