Kotlin/Native — ano ito, compiler sa native code at mga tampok

Ano ang Kotlin/Native?

Kotlin/Native — ay isang teknolohiya ng compilation ng Kotlin code sa native machine code, na binuo ng kumpanyang JetBrains. Ang pangunahing pagkakaiba sa Kotlin/JVM ay ang kawalan ng pangangailangan para sa isang virtual machine — ang tapos na executable file ay naglalaman lamang ng machine code at minimal runtime. Ito ay nagpapahintulot sa pagpapatakbo ng mga Kotlin application sa mga device at system kung saan hindi suportado ang JVM, kabilang ang iPhone, Apple Watch, at mga embedded system.

Ang kasaysayan ng Kotlin/Native ay nagsimula sa isang proyekto ng experimental compiler na noong 2017 ay isinama sa pangunahing branch ng Kotlin. Noong 2019 sa KotlinConf ay inihayag ang suporta para sa iOS bilang target na platform, na naging turning point para sa mobile development. Mula sa bersyong Kotlin 1.9.20, ang Kotlin/Native compiler ay nakamit ang stability at kasama sa Kotlin Multiplatform bilang default.

Ang pangunahing katangian ng Kotlin/Native ay ang paggamit ng shared intermediate representation na IR, na ini-compile sa machine code para sa bawat platform nang hiwalay. Ito ay nagsisiguro ng isang pinag-isang compilation frontend para sa lahat ng backend ng Kotlin: JVM, JS at Native.

Paano gumagana ang Kotlin/Native compiler

Compilation Ang Kotlin/Native ay dumadaan sa ilang yugto ng transformasyon. Ang source code sa Kotlin ay unang ginagawang internal na representasyon, pagkatapos ay ini-optimize at ipinapasa sa LLVM backend para sa pagbuo ng machine code. Ang huling yugto ay ang pag-link sa mga runtime library at paglikha ng executable file o dynamic na library.

Ang arkitektura ay may kasamang tatlong pangunahing bahagi: frontend (pag-parse at type checking), IR generator (pagbuo ng intermediate na representasyon), at LLVM backend (pagbuo ng machine code). Ang scheme na ito ay katulad ng approach na ginagamit sa Clang compilers para sa C++ at Rust.

// Kotlin/Native compilation sa pamamagitan ng command line
kotlinc-native hello.kt -o hello -opt

// Pagbuo para sa iOS arm64 sa pamamagitan ng Kotlin Multiplatform
./gradlew :shared:linkDebugFrameworkIosArm64

Para sa pamamahala ng memorya, gumagamit ang Kotlin/Native ng sarili nitong Memory Manager, batay sa reference counting na may cyclic detector. Mula sa Kotlin 1.7.20, ang bagong memory manager ay gumagana bilang default at hindi nangangailangan ng @ThreadLocal o @SharedImmutable na annotations. Ang garbage collector ay gumagana nang hindi humihinto sa mga thread, na kritikal para sa iOS, kung saan maaaring sapilitang isara ng system ang application sa matagal na pag-block ng pangunahing thread.

Mga yugto ng compilation ng Kotlin/Native

Ang proseso ng compilation ay nahahati sa limang yugto: pag-parse (pagsusuri ng source code), semantic analysis (type checking at name resolution), pagbuo ng IR (pagbuo ng intermediate na representasyon), optimization (pagpapasimple at pag-alis ng dead code), at code generation sa pamamagitan ng LLVM. Ang bawat yugto ay maaaring isagawa nang parallel para sa iba't ibang module, na nagpapabilis sa pagbuo ng malalaking proyekto.

Mga suportadong platform ng Kotlin/Native

Kotlin/Native ay sumusuporta sa 13 target na platform, nahahati sa mga kategorya. Para sa mobile development, available ang iOS (arm64), Android (arm32, arm64, x86_64), at watchOS. Kasama sa mga desktop platform ang macOS (x64, arm64), Windows (mingw x64), at Linux (x64, arm64, arm32). Para sa server at embedded development, available ang WebAssembly at Kotlin/Native sa LLVM nang walang operating system (standalone). Ang bawat platform ay nangangailangan ng hiwalay na framework o library sa output.

Mga platform para sa mobile development

Para sa iOS, ang Kotlin/Native ay bumubuo ng universal framework (.framework) na maaaring ikonekta sa Xcode project. Para sa Android NDK, nilikha ang native .so library na maaaring tawagan sa pamamagitan ng JNI. Ang platform na watchOS ay sinusuportahan mula sa Kotlin 1.6.0, at tvOS mula sa bersyong 1.7.0. Ang bawat arkitektura ay nangangailangan ng hiwalay na build, ngunit ang Kotlin Multiplatform ay nag-automate ng prosesong ito sa pamamagitan ng Gradle plugin.

Desktop at server platform

Ang macOS at Linux ay ginagamit para sa pag-develop ng native desktop application sa Kotlin gamit ang Compose Multiplatform framework. Ang Windows (MinGW) platform ay sinusuportahan mula sa Kotlin 1.3.70 at nagbibigay-daan sa paglikha ng Windows application nang walang pag-install ng JVM. Para sa server development, ang Kotlin/Native ay maaaring gamitin sa mga kapaligiran kung saan hindi available ang JVM, halimbawa, sa Docker containers na may minimal na image batay sa scratch o Alpine.

Kotlin/Native para sa iOS development

iOS ay ang pangunahing target na platform ng Kotlin/Native sa konteksto ng KMM. Ang compiler ay lumilikha ng iOS framework na naglalaman ng lahat ng shared code, na pagkatapos ay ikinokonekta sa Xcode project. Sinusuportahan ng framework ang parehong static at dynamic na pag-link. Ang Kotlin/Native ay bumubuo ng Objective-C wrappers para sa Kotlin classes at functions, na tinitiyak ang direktang integrasyon sa Swift at Objective-C code.

Ang integrasyon sa iOS ay nangangailangan ng configuration ng Xcode para ikonekta ang nabuong framework. Ina-automate ng Kotlin Multiplatform ang prosesong ito gamit ang embedAndSignAppleFrameworkForXcode task na pinapatakbo mula sa Xcode Build Phases. Para sa debugging, sinusuportahan ng Kotlin/Native ang mga breakpoint sa code ng shared module kapag pinapatakbo ang application sa iOS simulator.

// Kotlin code na na-compile sa iOS framework
package com.itsectr.shared

class GreetingProvider {
    fun createGreeting(): String {
        return "Hello from Kotlin/Native!"
    }

    fun formatVersion(major: Int, minor: Int): String {
        return "v$major.$minor"
    }
}

Objective-C at Swift Interop

Ang Interop sa iOS code ay gumagana sa parehong direksyon. Ang Kotlin/Native ay bumubuo ng Objective-C headers para sa Kotlin classes na awtomatikong nagiging available mula sa Swift. Ang feedback ay ibinibigay ng @ObjCName annotation para sa pag-export ng Kotlin functions sa ilalim ng tinukoy na Objective-C name. Ang Kotlin collections ay awtomatikong nagko-convert sa NSArray at NSDictionary, at ang Kotlin coroutines ay binalot sa Combine publishers sa pamamagitan ng SKIE library. Para sa pagtatrabaho sa iOS frameworks mula sa Kotlin, ginagamit ang cinterop — tool para sa pagbuo ng Kotlin bindings sa Objective-C headers.

Mga halimbawa ng code: configuration at compilation

Para magsimula sa Kotlin/Native, kinakailangan ang configuration ng build.gradle.kts na may specipikasyon ng Kotlin Multiplatform plugin at target na platform. Tingnan natin ang minimal na configuration para sa isang KMM project na may suporta sa iOS at Android.

plugins {
    kotlin("multiplatform") version "2.0.21"
}

kotlin {
    iosArm64()
    iosSimulatorArm64()

    sourceSets {
        commonMain.dependencies {
            implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.9.0")
        }
        iosMain.dependencies {
            implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.9.0")
        }
    }
}

Pagkatapos i-configure ang build, maaaring magdagdag ng platform-dependent code. Ang Kotlin/Native ay nagbibigay ng access sa iOS functions sa pamamagitan ng Kotlin wrappers. Halimbawa, ang pagkuha ng UUID ng device sa iOS ay nangangailangan ng pagtawag sa NSUUID mula sa Foundation.

import platform.Foundation.NSUUID

fun getDeviceId(): String {
    return NSUUID().UUIDString()
}

fun currentTimestampMillis(): Long {
    return (platform.Foundation.NSDate().timeIntervalSince1970 * 1000).toLong()
}

Pagbuo ng iOS framework

Para sa pagbuo ng iOS framework, ginagamit ang Gradle task na linkDebugFrameworkIosArm64 o linkReleaseFrameworkIosArm64 para sa produksyon. Pagkatapos ng build, ang framework ay matatagpuan sa build/bin/iosArm64/debugFramework/. Ang pagkonekta sa Xcode project ay ginagawa sa pamamagitan ng Pods Podfile o pagdaragdag ng framework sa section na General → Frameworks, Libraries and Embedded Content.

// Pagbuo ng release framework para sa iOS arm64
./gradlew :shared:linkReleaseFrameworkIosArm64

// Pagbuo ng universal framework x86_64 + arm64
./gradlew :shared:linkReleaseFrameworkIosX64 \
    :shared:linkReleaseFrameworkIosArm64

// Gumawa ng XCFramework para sa App Store
./gradlew :shared:assembleReleaseXCFramework

Kotlin/Native vs Kotlin/JVM: paghahambing

Ang Kotlin/Native at Kotlin/JVM ay nagkakaiba sa arkitektura, performance, at larangan ng aplikasyon. Ang Kotlin/JVM ay nagko-compile ng code sa bytecode na pinapatakbo sa JVM, na nagbibigay ng access sa malawak na ecosystem ng Java libraries, ngunit nangangailangan ng naka-install na virtual machine. Ang Kotlin/Native ay bumubuo ng executable file nang walang external dependencies, ngunit may mas limitadong library ecosystem.

Ang performance ng oras ng pagsisimula ng Kotlin/Native ay mas mataas dahil hindi kailangang mag-load ng JVM. Ayon sa mga benchmark ng JetBrains, ang Hello World application sa Kotlin/Native ay nagsisimula sa loob ng 0.003 segundo, habang ang Kotlin/JVM ay nangangailangan ng 0.5–1 segundo para mag-load ng virtual machine. Gayunpaman, ang laki ng executable file ng Kotlin/Native ay maaaring 2–3 beses na mas malaki dahil sa kasamang runtime.

Ang pagpili sa pagitan ng Kotlin/Native at Kotlin/JVM ay depende sa target na platform. Kung ang proyekto ay nakatuon sa iOS o nangangailangan ng minimal na paggamit ng resources, ang Kotlin/Native ay ang tanging pagpipilian. Para sa Android development, ang Kotlin/JVM ay nananatiling standard, kahit na ang Kotlin/Native ay ginagamit para sa NDK components kung saan kinakailangan ang native performance. Sa multi-platform projects, pinagsasama ng Kotlin Multiplatform ang parehong approach: ang shared code ay ini-compile sa pamamagitan ng Kotlin/Native para sa iOS at sa pamamagitan ng Kotlin/JVM para sa Android.