Belajar Kotlin - Sejarah, Latar Belakang & Mengapa Memilih Kotlin

#Pendahuluan

Episode 1 membuka sejarah di balik Kotlin: bagaimana bahasa yang lahir dari JetBrains bisa menjadi bahasa resmi untuk Android dan pilihan utama backend modern. Kalian juga akan melihat perbandingan jujur dengan Java, Scala, dan Swift, serta keunggulan yang membuat Kotlin layak dipelajari.

Pertanyaan pertama yang sering muncul: kenapa bukan Java? Jawabannya adalah produktivitas. Kotlin menawarkan sintaks yang lebih ringkas, null-safety bawaan, dan interoperabilitas penuh dengan Java — kombinasi yang membuatnya nyaman sekaligus aman dipakai di production.

Di akhir episode ini kalian akan punya alasan kuat untuk melanjutkan series, dan tahu kapan memilih Kotlin dibanding bahasa JVM lain.

#Sejarah dan Latar Belakang

#Lahir dari JetBrains

Kotlin dikembangkan oleh JetBrains, perusahaan di balik IntelliJ IDEA, dan mulai dikerjakan pada tahun 2011. Nama Kotlin diambil dari sebuah pulau di Rusia, mengikuti tradisi penamaan bahasa pemrograman seperti Java dan Groovy. Setelah masa pengembangan yang panjang, Kotlin 1.0 resmi dirilis pada Februari 2016.

Titik balik besar terjadi di tahun 2017, ketika Google mengumumkan Kotlin sebagai bahasa resmi (first-class) untuk Android. Sejak saat itu adopsinya meledak: mayoritas developer Android memakai Kotlin dalam beberapa tahun setelah pengumuman tersebut, dan angka ini terus tumbuh hingga sekarang.

#Evolusi ke Compiler K2

Kotlin 2.0 yang dirilis pada tahun 2024 membawa compiler K2 sebagai default. K2 ditulis ulang dari nol, menghasilkan kecepatan kompilasi yang lebih tinggi, penggunaan memori yang lebih efisien, dan fondasi untuk fitur bahasa baru. Perintah kompilasi tetap sama seperti sebelumnya:

Cek versi compiler Kotlin

kotlinc -version

Jika kalian menjalankan kotlinc -version dan melihat versi 2.x, compiler K2 sudah aktif. Ini penting karena episode 15 akan membahas bagaimana K2 mengubah performa build dan apa artinya bagi project kalian.

#Perbandingan dengan Bahasa Lain

#Kotlin vs Java

Kotlin sering disebut "Java yang lebih modern". Keduanya berjalan di JVM dan interoperabel penuh, tapi sintaks Kotlin jauh lebih ringkas. Perhatikan contoh class data sederhana:

Baris tunggal di atas menghasilkan class dengan getter, setter, equals, hashCode, dan toString — di Java butuh puluhan baris boilerplate. Ini contoh nyata keunggulan conciseness yang akan kalian rasakan di episode 4.

Perbandingan yang lebih jujur terlihat pada kode nyata. Class Java untuk menyimpan data sederhana membutuhkan constructor, getter, setter, equals, hashCode, dan toString yang bisa mencapai puluhan baris:

Java: class data bertele-tele

public class Pengguna {
    private final String nama;
    private final int umur;
 
    public Pengguna(String nama, int umur) {
        this.nama = nama;
        this.umur = umur;
    }
 
    public String getNama() {
        return nama;
    }
 
    public int getUmur() {
        return umur;
    }
 
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Pengguna)) return false;
        Pengguna p = (Pengguna) o;
        return umur == p.umur && nama.equals(p.nama);
    }
 
    @Override
    public int hashCode() {
        return java.util.Objects.hash(nama, umur);
    }
 
    @Override
    public String toString() {
        return "Pengguna{" + "nama='" + nama + '\'' + ", umur=" + umur + '}';
    }
}

Kode Java di atas menghasilkan perilaku yang sama dengan satu baris data class di Kotlin. Ini bukan soal preferensi gaya semata — boilerplate yang lebih sedikit berarti lebih sedikit tempat untuk bug dan review yang lebih cepat, dua hal yang sangat terasa di project besar.

#Kotlin vs Scala

Scala juga berjalan di JVM dengan dukungan gaya fungsional yang kuat, tetapi memiliki kurva belajar yang curam dan kecepatan kompilasi yang sering dikeluhkan. Kotlin memilih jalan tengah: fungsional dan OOP tanpa mengorbankan kesederhanaan. Untuk tim yang baru pindah dari Java, Kotlin jauh lebih mudah diserap dan diadopsi.

#Kotlin vs Swift

Swift adalah bahasa utama pengembangan iOS, dan kalian akan melihat banyak kemiripan dengan Kotlin: keduanya modern, aman terhadap null, dan menyenangkan ditulis. Perbedaannya terletak pada ekosistem: Swift terikat ke platform Apple, sementara Kotlin bebas berjalan di JVM, Android, JavaScript, dan Native melalui Kotlin Multiplatform — topik yang dibahas di episode 12.

#Keunggulan Utama Kotlin

#Conciseness

Kotlin memangkas boilerplate tanpa menghilangkan ekspresivitas. String templates, type inference, dan default arguments membuat kode lebih pendek dan lebih mudah dibaca. Kode yang ringkas berarti lebih sedikit tempat untuk bug bersembunyi dan lebih cepat direview.

#Null-safety

Sistem tipe Kotlin membedakan tipe nullable dan non-nullable sejak compile time. NullPointerException yang terkenal di Java bisa dicegah di level kompilasi — fitur yang akan kalian bedah mendalam di episode 6. Ini salah satu alasan utama tim memigrasi dari Java.

#Interoperabilitas Penuh

Kotlin bisa memanggil library Java dan sebaliknya tanpa adapter. Kalian bisa memigrasi project Java secara bertahap, file demi file, seperti yang akan dibahas di episode 17. Interoperabilitas ini juga berarti seluruh ekosistem library Java terbuka untuk project Kotlin.

#Use Cases Kotlin di Dunia Nyata

Posisi Kotlin sangat luas di dunia nyata:

Android: bahasa resmi utama dengan dukungan penuh Jetpack Compose.
Backend: Ktor, Spring Boot, dan Micronaut semua mendukung Kotlin kelas satu.
Frontend: Kotlin/JS memungkinkan menulis kode yang dikompilasi menjadi JavaScript.
Scripting: file .kts bisa dijalankan langsung dengan perintah kotlin script.kts.
Multiplatform: satu codebase untuk JVM, Android, iOS, dan Native.

Dengan peta ini, keputusan kalian mempelajari Kotlin bukan hanya soal satu platform — ini investasi yang berlaku di banyak area pengembangan perangkat lunak.

#Penutup

Episode 1 menempatkan Kotlin pada konteks yang tepat: lahir dari JetBrains, naik daun sebagai bahasa resmi Android, dan terus berevolusi lewat compiler K2. Kalian juga sudah memahami posisinya dibanding Java, Scala, dan Swift, serta keunggulan inti yang akan kalian rasakan sepanjang series ini.

Inti yang harus dibawa pulang:

Kotlin lahir dari JetBrains dan dirilis stabil pada tahun 2016.
Google menjadikan Kotlin bahasa resmi Android pada tahun 2017.
Compiler K2 default sejak Kotlin 2.0 mempercepat build dan menghemat memori.
Kotlin lebih ringkas dari Java dan lebih mudah dipelajari daripada Scala.
Null-safety dan interoperabilitas penuh adalah dua pembeda utamanya.
Kotlin berlaku untuk Android, backend, frontend, scripting, dan multiplatform.

Di episode 2 selanjutnya kita akan membahas konsep dasar dan arsitektur bahasa Kotlin — struktur program, bagaimana Kotlin dikompilasi menjadi bytecode dan berinteraksi dengan JVM, sistem tipe beserta null-safety, serta model concurrency dengan coroutines. Ini adalah fondasi teknis yang akan dipakai di seluruh episode berikutnya.