Getting Started with the Kotlin Ecosystem

// Kotlin emphasizes conciseness, safety, and interoperability
fun main() {
    println("Kotlin: Concise, Safe, Interoperable")
    
    // Null safety by default
    var name: String = "Kotlin"
    // name = null  // This would cause a compile-time error
    
    // Nullable types are explicit
    var nullableName: String? = "Kotlin"
    nullableName = null  // This is allowed
}

# JavaScript environment verification
node --version
npm --version

# Kotlin environment verification
kotlin --version
java --version
gradle --version

// package.json (JavaScript)
{
  "name": "my-project",
  "version": "1.0.0",
  "dependencies": {
    "express": "^4.18.2",
    "axios": "^1.6.0"
  },
  "devDependencies": {
    "jest": "^29.7.0",
    "eslint": "^8.55.0"
  },
  "scripts": {
    "start": "node index.js",
    "test": "jest"
  }
}

// build.gradle.kts (Kotlin)
plugins {
    kotlin("jvm") version "1.9.0"
    application
}

group = "com.example"
version = "1.0.0"

repositories {
    mavenCentral()
}

dependencies {
    implementation("org.jetbrains.kotlin:kotlin-stdlib")
    implementation("com.squareup.okhttp3:okhttp:4.11.0")
    testImplementation("org.jetbrains.kotlin:kotlin-test")
    testImplementation("org.jetbrains.kotlin:kotlin-test-junit")
}

application {
    mainClass.set("MainKt")
}

# JavaScript project initialization
npm init -y
npm install express axios
npm install --save-dev jest eslint

# Kotlin project initialization
gradle init --type kotlin-application
# Dependencies are managed in build.gradle.kts

# JavaScript Project Structure
my-js-project/
├── package.json           # Project configuration
├── node_modules/          # Dependencies
├── src/
│   └── index.js
├── tests/
│   └── index.test.js
└── README.md

# Kotlin Project Structure
my-kotlin-project/
├── build.gradle.kts       # Build configuration
├── src/
│   ├── main/
│   │   └── kotlin/
│   │       └── Main.kt
│   └── test/
│       └── kotlin/
│           └── MainTest.kt
├── gradle/
│   └── wrapper/
├── gradlew               # Gradle wrapper
└── README.md

# macOS
brew install openjdk@17

# Ubuntu/Debian
sudo apt update
sudo apt install openjdk-17-jdk

# Windows
# Download from Oracle or use Chocolatey
choco install openjdk17

# Using SDKMAN! (recommended)
curl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"
sdk install kotlin

# Using Homebrew (macOS)
brew install kotlin

# Manual installation
# Download from https://github.com/JetBrains/kotlin/releases

# Download from https://www.jetbrains.com/idea/download/
# Community Edition is free and sufficient for most development

kotlin --version
java --version
gradle --version

# Create a new Kotlin project
gradle init --type kotlin-application --dsl kotlin --project-name my-kotlin-app

# Navigate to project
cd my-kotlin-app

# Build the project
./gradlew build

# Run the application
./gradlew run

fun main() {
    println("Hello, Kotlin!")
    
    // Demonstrate some Kotlin features
    val numbers = listOf(1, 2, 3, 4, 5)
    val doubled = numbers.map { it * 2 }
    println("Doubled numbers: $doubled")
    
    // Coroutine example
    runBlocking {
        delay(1000)
        println("This runs after 1 second delay")
    }
}

import kotlin.test.*

class CalculatorTest {
    @Test
    fun testAddition() {
        val calculator = Calculator()
        assertEquals(4, calculator.add(2, 2))
    }
    
    @Test
    fun testCoroutine() = runTest {
        val result = async { 
            delay(100)
            "Hello"
        }.await()
        assertEquals("Hello", result)
    }
}

# 1. Create a new Kotlin project
gradle init --type kotlin-application --dsl kotlin --project-name my-first-kotlin-project

# 2. Navigate to the project
cd my-first-kotlin-project

# 3. Build the project
./gradlew build

# 4. Run the application
./gradlew run

// Create a file: src/main/kotlin/CoroutineExample.kt
import kotlinx.coroutines.*

fun main() = runBlocking {
    println("Starting coroutine example...")
    
    // Launch multiple coroutines
    val jobs = List(3) { index ->
        launch {
            delay(1000L * (index + 1))
            println("Coroutine $index completed")
        }
    }
    
    // Wait for all coroutines to complete
    jobs.forEach { it.join() }
    println("All coroutines completed!")
}

// Create a file: src/main/kotlin/NullSafetyExample.kt
data class User(val name: String, val email: String?)

fun processUser(user: User?) {
    // Use safe call operator
    val email = user?.email
    println("Email: ${email ?: "No email provided"}")
    
    // Use let for safe operations
    user?.let { safeUser ->
        println("Processing user: ${safeUser.name}")
    }
}

fun main() {
    val user1 = User("John", "[email protected]")
    val user2 = User("Jane", null)
    val user3: User? = null
    
    processUser(user1)
    processUser(user2)
    processUser(user3)
}