Java Terus Membaik dan Tidak Ada yang Sadar

Java itu Rodney Dangerfield-nya dunia bahasa pemrograman: jarang dihargai. Sebut Java ke kebanyakan developer di bawah 30 tahun, dan mereka langsung membayangkan file konfigurasi XML, enterprise beans, dan AbstractSingletonProxyFactoryBean. Reputasi bahasa ini seolah membeku di 2008, ketika Java 6 adalah versi terbaru dan menulis Java berarti tenggelam dalam boilerplate.

Tapi ada yang luar biasa terjadi sejak Java beralih ke ritme rilis enam bulanan di 2017. Bahasa ini berkembang dengan kecepatan yang dulu sulit dibayangkan selama jeda empat tahun antara Java 6, 7, dan 8. Records. Sealed classes. Pattern matching. Virtual threads. String templates. Structured concurrency. Setiap rilis menambahkan fitur yang membuat kode Java lebih ringkas, lebih ekspresif, dan lebih menyenangkan ditulis. Java 26 melanjutkan tren ini, dan jarak antara 'Java yang sebenarnya' dan 'Java yang dibayangkan orang' belum pernah selebar sekarang.

Fitur-Fitur yang Mengubah Segalanya

Kalau kamu belum menulis Java sejak Java 8, kamu melewatkan satu dekade peningkatan. Begini wujud bahasa ini sekarang.

Records (Java 14) adalah data class yang immutable. Yang dulu butuh 50 baris boilerplate — field, constructor, getter, equals, hashCode, toString — sekarang cukup satu baris.

// Java 8: 50 lines of boilerplate
public class Point {
private final int x;
private final int y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
public int getX() { return x; }
public int getY() { return y; }
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof Point)) return false;
Point point = (Point) o;
return x == point.x && y == point.y;
}
@Override
public int hashCode() { return Objects.hash(x, y); }
@Override
public String toString() { return "Point[x=" + x + ", y=" + y + "]"; }
}
// Java 14+: one line
record Point(int x, int y) {}

Pattern matching (Java 16-21, masih terus berkembang) memungkinkan kamu melakukan destructuring objek di switch expression dan pengecekan instanceof. Ini menghilangkan rantai if-else-instanceof bertingkat yang dulu menghantui kode Java.

// Pattern matching with sealed types and records
sealed interface Shape permits Circle, Rectangle, Triangle {}
record Circle(double radius) implements Shape {}
record Rectangle(double width, double height) implements Shape {}
record Triangle(double base, double height) implements Shape {}
// Exhaustive pattern matching — compiler verifies all cases covered
double area(Shape shape) {
return switch (shape) {
case Circle(var r) -> Math.PI * r * r;
case Rectangle(var w, var h) -> w * h;
case Triangle(var b, var h) -> 0.5 * b * h;
};
}

Virtual threads (Java 21) adalah thread ringan yang dikelola JVM, bukan OS. Kamu bisa membuat jutaan thread tanpa kehabisan memori atau handle thread OS. Ini membuat model 'satu thread per request' — model konkurensi paling sederhana — praktis dipakai dalam skala besar.

// Create a million concurrent tasks — try this with OS threads
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
IntStream.range(0, 1_000_000).forEach(i -> {
executor.submit(() -> {
// Each task gets its own virtual thread
// Blocking I/O (HTTP, DB, file) automatically yields
var response = httpClient.send(request, BodyHandlers.ofString());
return response.body();
});
});
}
// All done — executor auto-closes, waits for completion

Virtual threads adalah jawaban Java atas goroutine di Go dan coroutine di Kotlin. Bedanya: kamu tidak perlu sintaks khusus atau memberi 'warna' pada fungsi. Kode blocking biasa tetap jalan — JVM secara transparan menangguhkan dan melanjutkan virtual threads di titik blocking. HTTP client blocking, JDBC driver, dan kode file I/O yang sudah ada ikut diuntungkan tanpa perlu diubah.

Mengapa Tidak Ada yang Sadar

Lintasan perbaikan Java memang sangat mengesankan. Lalu kenapa persepsinya masih terjebak di 2008?

Pertama, inersia enterprise. Banyak organisasi masih menjalankan Java 8 atau 11 karena meng-upgrade codebase besar itu mahal dan berisiko. Saat developer bicara soal 'Java', yang mereka maksud biasanya versi yang dipakai perusahaan mereka, bukan rilis terbaru. Developer Java 8 belum pernah merasakan records, pattern matching, atau virtual threads.

Kedua, lapisan framework. Spring Boot, Jakarta EE, dan framework enterprise lain menambahkan kerumitan sendiri di atas bahasanya. Developer menyalahkan 'Java' atas seremoni anotasi Spring, padahal itu frameworknya, bukan bahasanya. Java modern tanpa framework berat ternyata sangat ramping.

Ketiga, momentum budaya. Budaya tech suka mengelompokkan bahasa ke dalam 'suku'. Java dianggap bahasa 'enterprise', identik dengan korporasi besar, birokrasi, dan over-engineering. Reputasi ini memang pantas didapat — pengembangan Java sekitar 2005 memang layak dikritik. Tapi reputasi biasanya bertahan bertahun-tahun setelah penyebabnya hilang.

Keunggulan JVM

Peningkatan bahasanya penting, tapi keunggulan Java yang paling dalam tetap ada di JVM. Setelah tiga dekade optimasi, HotSpot JVM menjadi salah satu runtime paling canggih yang pernah dibuat.

• JIT compilation. JVM memprofil kode yang sedang berjalan dan mengompilasi method yang sering dipanggil menjadi native code yang dioptimasi. Untuk aplikasi yang berjalan lama (server, pemrosesan data), performa JVM sering menyamai atau melampaui C++ karena JIT bisa mengoptimasi berdasarkan perilaku runtime yang sebenarnya, bukan hanya analisis statis.
• Garbage collection. Implementasi GC modern (ZGC, Shenandoah) memberikan waktu jeda di bawah milidetik meski heap-nya berukuran terabyte. Kritik 'jeda GC membunuh latency' sudah tidak berlaku selama bertahun-tahun — collector ini berjalan secara konkuren bersama aplikasi.
• Observability. JFR (Java Flight Recorder) menyediakan profiling yang aman untuk production dengan overhead hampir nol. Kamu bisa memprofil penggunaan CPU, alokasi memori, lock contention, latency I/O, dan perilaku GC tanpa memperlambat aplikasi.
• Ecosystem maturity. Maven Central punya jutaan paket. Build tool (Gradle, Maven) sudah sangat dipahami. Ekosistem testing (JUnit, Mockito, Testcontainers) sangat bagus. Cerita deployment (container, GraalVM native image) juga sudah jauh lebih matang.

GraalVM dan Native Image

Kelemahan terbesar Java selalu soal waktu startup. JVM butuh ratusan milidetik untuk inisialisasi, memuat class, dan memanaskan JIT compiler. Untuk serverless function dan CLI tool, overhead ini tidak bisa diterima.

GraalVM Native Image mengatasi ini dengan mengompilasi aplikasi Java secara ahead-of-time menjadi executable mandiri. Tidak perlu JVM. Waktu startup turun dari ratusan milidetik menjadi satu digit milidetik. Penggunaan memori ikut turun karena tidak ada interpreter, JIT compiler, dan metadata class yang perlu dimuat.

Trade-off-nya: native image kehilangan optimasi adaptif milik JVM. Aplikasi yang di-JIT makin cepat seiring waktu karena JVM mempelajari hot path. Native image start cepat tapi tidak makin membaik. Untuk proses berumur pendek (CLI tool, serverless), native image menang. Untuk server yang berjalan lama, JIT JVM akhirnya menghasilkan kode yang lebih cepat. Pilih alat yang sesuai dengan karakteristik runtime-mu.

Java Modern vs. Alternatifnya

Bahasa-bahasa yang 'menggantikan' Java — Go, Kotlin, Rust — sangat bagus. Tapi Java modern bersaing lebih efektif daripada yang disadari banyak orang.

Kesederhanaan Go memang menarik, tapi Java sekarang punya virtual threads (setara goroutine) dan sistem tipe yang jauh lebih kaya. Sistem tipe itu penting untuk codebase besar, dan milik Java — terutama dengan sealed types dan pattern matching — menangkap error yang terlewat oleh sistem interface Go.

Kotlin memperbaiki sintaks Java, tapi berjalan di JVM yang sama. Sebagian besar keunggulan Kotlin atas Java 8 (null safety, data class, coroutine) sudah punya padanan parsial atau penuh di Java modern (pola Optional, records, virtual threads). Kotlin tetap lebih ringkas, tapi selisihnya sudah menyempit banyak.

Rust mengisi ceruk yang berbeda — pemrograman sistem tanpa garbage collector. Java tidak perlu bersaing di sana. Tapi untuk aplikasi server-side, pemrosesan data, dan software enterprise, kombinasi performa, keamanan, dan kematangan ekosistem Java sulit dikalahkan.

Ritme Enam Bulanan Adalah Inovasi Sebenarnya

Lebih dari fitur tunggal mana pun, siklus rilis enam bulanan mengubah arah Java. Sebelum 2017, rilis Java adalah acara tiga sampai empat tahunan yang berusaha mengirim semuanya sekaligus. Fitur tertunda karena belum siap, yang menunda seluruh rilis, yang lalu menekan untuk memasukkan semuanya ke rilis berikutnya, yang kemudian juga tertunda. Java 9 butuh lebih dari tiga tahun, sebagian karena kerumitan module system.

Dengan rilis enam bulanan, fitur dikirim ketika sudah siap. Pattern matching dirilis bertahap dari Java 16 sampai 24, dengan tiap rilis menambahkan satu bagian. Virtual threads melewati dua preview release sebelum dirilis final. Pendekatan bertahap ini memungkinkan tim Java mengumpulkan feedback dari dunia nyata dan menyesuaikan desain sebelum mengunci keputusan API yang permanen.

Pelajarannya berlaku di luar Java: rilis kecil yang sering akan menumpuk menjadi perubahan besar. Setiap rilis Java sejak 17 terbilang sederhana. Tapi jika digabung, rilis-rilis itu telah menciptakan ulang bahasanya. Kalau kamu pernah mencoba Java lima tahun lalu dan kapok karena verbosity-nya, coba lagi. Kamu mungkin akan terkejut dengan apa yang kamu temukan.