Artikel mendalam tentang teknologi yang membentuk masa depan.

Jiff vs Chrono: Library Datetime Rust Mana yang Menang

Jiff vs chrono untuk datetime di Rust: kasus DST, ergonomi API, dan kapan masing-masing library layak dipakai menurut pengalaman pribadi.

Dua jam bergaya yang saling tumpang tindih, satu mekanis dan satu organik, menggambarkan transisi zona waktu.
Bug datetime jarang bikin sesuatu crash, mereka diam-diam memberimu jam yang salah.

Setiap beberapa tahun, ada engineer malang yang menemukan bahwa 2026-11-01 01:30 di New York terjadi dua kali, dan scheduler-nya tiba-tiba menjalankan billing job satu jam lebih awal. Bug datetime memang tidak membuat program crash, tetapi diam-diam merusak datamu. Karena itu, rilisnya Jiff 1.0, library datetime baru untuk Rust dari Andrew Gallant (si pembuat ripgrep), penting lebih dari sekadar rilis crate biasa. Ini memaksa kita menjawab pertanyaan serius: Jiff vs chrono, mana yang sebaiknya dipakai di proyek Rust berikutnya?

Sejarah Singkat Derita Datetime di Rust

Rust pernah mengalami ini sebelumnya, dan sejarahnya layak dipelajari. Chrono berasal dari era pra-1.0 bahasa ini, ketika ia dipisahkan dari standard library bersama time sebagai bagian dari pembersihan besar 'right-size std'. Selama hampir satu dekade ia menjadi jawaban default. Ia bekerja, sebagian besar. Tapi API-nya menumpuk lapisan demi lapisan: NaiveDateTime, DateTime<Utc>, DateTime<Local>, DateTime<FixedOffset>, dan trait TimeZone yang kebanyakan orang hanya sentuh lewat dua implementasi. Sistem tipenya membiarkanmu melakukan banyak hal yang tidak masuk akal secara semantik, seperti menambahkan datetime naive ke datetime berzona dan mendapat jawaban yang yakin tapi salah.

Cerita pemeliharaannya juga penting. Chrono sempat mengalami masa terbengkalai, dan bahkan para maintainer-nya kemudian menggambarkan pengalaman itu sebagai mendorong melawan kestabilan API yang oleh pengguna dianggap sakral. Seorang mantan maintainer berkata blak-blakan: setiap langkah kecil menuju perbaikan selalu mendapat perlawanan, karena daya jual utama chrono sudah berubah dari desainnya menjadi stabilitasnya. Itu jebakan yang bisa menimpa library mana pun yang sudah lama hidup, yaitu basis pengguna terpasang akhirnya menjadi produknya. Crate time mencoba pendekatan berbeda dengan inti yang lebih bersih, tapi selama bertahun-tahun menunda penanganan zona waktu secara penuh. Sementara itu, ekosistem terus merilis aplikasi di mana 'jam berapa di Berlin bulan Maret depan' adalah pertanyaan yang krusial.

Ini gagasan lama yang menjadi pijakan Jiff, entah disebut atau tidak: filosofi 'pit of success' yang dijelaskan Rico Mariani untuk desain API sekitar pertengahan 2000-an. Jadikan jalur mudah sebagai jalur yang benar. Pandangan Gallant adalah bahwa kesulitan datetime berasal dari pemodelan domain yang buruk, dan library yang melemparkan ambiguitas ke pengguna, seperti 'ini datetime naive, semoga berhasil', sebenarnya sedang melempar masalah terberatnya ke orang lain. Ini sama dengan naluri di balik model ownership Rust: mesin seharusnya menyerap kompleksitasnya supaya manusia tidak perlu.

Cara Jiff Memodelkan Waktu: Si Bawang

Langkah desain utama Jiff adalah apa yang disebut Gallant sebagai datetime onion (bawang datetime). Lapisannya, dari dalam ke luar:

  • civil::Date — tanggal Gregorian tanpa lokasi. Tanggal lahirmu termasuk di sini.
  • civil::Time — waktu dinding hingga presisi nanodetik, tanpa lokasi.
  • civil::DateTime — tanggal plus waktu, masih tanpa lokasi. Ini yang disebut naive oleh chrono.
  • Timestamp — instant yang tidak ambigu, nanodetik sejak Unix epoch.
  • TimeZone — aturan yang memetakan instant ke waktu sipil di suatu wilayah.
  • ZonedDateTime — semuanya digabung: instant, waktu sipil, dan zona.

Keuntungannya, nama tipe sejalan dengan model mental yang sudah kamu punya. Timestamp adalah yang kamu dapat dari database atau system call. civil::DateTime adalah yang ditulis manusia di undangan kalender. Mengubah keduanya tanpa zona waktu itu mustahil, dan Jiff membuat konversi tersebut sebagai operasi yang eksplisit, bisa gagal, dan beranotasi zona. Bandingkan dengan chrono, di mana perbedaan serupa ada tapi lebih mudah kabur: NaiveDateTime::and_utc() dengan senang hati menempelkan zona ke waktu dinding tanpa bertanya apakah waktu dinding itu pernah ada.

Ergonominya sengaja dibuat ramah. Kamu bisa membangun datetime berzona dari dua arah, yaitu waktu sipil plus zona, atau timestamp plus zona, dan API-nya menyambut keduanya:

use jiff::civil;
fn main() -> anyhow::Result<()> {
// Start from what a human would write on a calendar.
let dt = civil::date(2026, 11, 1).at(17, 30, 0, 0);
let zdt = dt.in_tz("America/New_York")?;
assert_eq!(zdt.offset().seconds(), -(5 * 60 * 60));
// Arithmetic on the civil parts stays civil:
let tomorrow = zdt.date().tomorrow()?;
assert_eq!(tomorrow, civil::date(2026, 11, 2));
Ok(())
}

Daylight Saving Time: Tempat Jiff Membuktikan Nilainya

Ini skenario yang membedakan orang dewasa dari anak-anak dalam desain library datetime. Pada 1 November 2026, jam di New York mundur pukul 2 pagi. Jam 1 terjadi dua kali. Jadi ketika pengguna mengetik '1:30 AM pada 1 November', apa yang harus dilakukan? Jawaban chrono secara historis adalah LocalResult: enum yang bisa berupa Single, Ambiguous, atau None, dan cukup banyak kode produksi yang mengunwrap-nya, membuangnya, atau salah pattern-match. Ambiguitasnya memang terlihat, tapi beban untuk menanganinya juga, setiap kali.

Jawaban Jiff adalah memilih default yang masuk akal dan membuat alternatifnya hanya berjarak satu pemanggilan method. Strategi default 'compatible' menyelesaikan fold ke kejadian yang lebih awal, sesuai dengan yang dilakukan kebanyakan software kalender dan setiap sistem operasi besar. Tapi kalau kamu peduli, seluruh pohon keputusannya ada di sana:

use jiff::{civil::date, tz::TimeZone};
fn main() -> anyhow::Result<()> {
let tz = TimeZone::get("America/New_York")?;
let dt = date(2026, 11, 1).at(1, 30, 0, 0);
let amb = tz.to_ambiguous_zoned_datetime(dt);
let earlier = amb.earlier()?;  // offset -04 (EDT), first 1:30
let later = amb.later()?;      // offset -05 (EST), second 1:30
// Or refuse to guess entirely:
assert!(tz.to_ambiguous_zoned_datetime(dt).unambiguous().is_err());
Ok(())
}

Gap diperlakukan dengan cara serupa: ketika jam maju dan pukul 2:30 pagi tidak pernah terjadi, Jiff secara default menggesernya ke depan, dan lagi-lagi kamu bisa menimpanya. Keputusan desain ini opinionated dan menurut saya benar. Kebanyakan kode yang menangani waktu ambigu tidak punya kebijakan, yang ada hanyalah bug yang menunggu bulan November. Menggunakan perilaku default yang sudah diharapkan pengguna dari ponsel mereka, sambil membuat jalan keluar tetap terlihat dan bertipe, itulah arti 'pit of success' dalam praktik. Filosofinya mirip dengan default yang baik di aritmetika tanggal buatan sendiri: aturannya bisa dipelajari, tapi kamu tidak seharusnya menurunkannya ulang di setiap call site.

Timeline pita abstrak yang menunjukkan fold di mana garisnya berbalik arah dan gap di mana garisnya terputus.
Fold dan gap: dua tempat di mana waktu sipil berhenti memetakan dengan rapi ke instant.

Span, Durasi, dan Masalah 'Satu Bulan'

Minta chrono untuk durasi 'satu bulan' dan kamu akan kecewa, karena Duration-nya adalah jumlah detik yang tetap, sebab sebulan bukan jumlah tetap dari apa pun. Itu desain yang bisa dipertanggungjawabkan, tapi artinya aritmetika kalender ('tambah tiga bulan ke 31 Januari') menjadi masalahmu. Tipe Span milik Jiff mengambil jalur lain: ia menyimpan unit campuran dari tahun sampai nanodetik, dan aritmetikanya diselesaikan dengan cara yang sadar kalender. Menambah satu bulan ke 31 Januari menghasilkan 28 (atau 29) Februari, bukan 3 Maret. Menambah satu hari ke datetime berzona pada malam sebelum transisi DST menambah satu hari kalender, yang bisa berisi 23 atau 25 jam, dan itulah yang dimaksud manusia ketika bilang 'jam yang sama besok'.

Perbedaan antara waktu yang berlalu dan waktu kalender ini adalah konsep paling membingungkan dalam pemrograman datetime, dan ia membingungkan di mana-mana. java.util.Date di Java awalnya mencampurkan keduanya; java.time di Java 8 (yang sendirinya terinspirasi dari Joda-Time) memisahkan Duration dari Period, dan hasilnya lebih baik. Proposal Temporal di JavaScript membuat pemisahan yang sama. Jiff berada nyaman dalam garis keturunan itu: ide-ide bagus dalam desain datetime sudah konvergen selama dua puluh tahun, dan Jiff pada dasarnya adalah ekspresi Rust dari konsensus tersebut, mirip dengan fitur bahasa Rust yang lama dimatangkan yang akhirnya hadir sebagai versi tersuling dari perdebatan selama satu dekade.

Ada juga format durasi 'ramah': string seperti 2h 30m atau P1DT2H bisa di-parse dan dicetak dengan natural, plus format gaya strptime/strftime dan integrasi ICU4X opsional untuk output yang sensitif locale. Ini terdengar seperti kebutuhan dasar, tapi siapa pun yang pernah menulis format string chrono khusus untuk pipeline log tahu betapa banyak gesekan yang bisa dihilangkan.

Jiff vs Chrono: Kapan Masing-masing Menang

Cukup tur-nya. Ini perbandingan jujur, dengan sudut pandang yang saya sertakan.

Di mana chrono masih unggul

Inersia itu juga fitur. Chrono ada di dependency tree sebagian besar ekosistem Rust, muncul di banyak API publik, dan dipelihara oleh tangan yang andal. Kalau codebase-mu sudah fasih dengan chrono, timestamp-mu hanya instant UTC (misalnya pipeline metrik, envelope log, RPC internal), dan tim kamu paham sisi tajamnya, migrasi hanya memberimu sedikit keuntungan. Posisi chrono yang opsional untuk std dan ramah no_std juga masih penting di sudut embedded. Dan kalau kamu mengerjakan hal yang eksotis, seperti mekanika orbit dalam skala megatahun atau skala waktu alternatif seperti TAI atau UT1, tak satu pun library ini benar-benar jawabanmu; kamu akan membungkus salah satunya untuk parsing string dan tetap memakai representasi sendiri, dan kesederhanaan chrono di tepinya sudah cukup untuk itu.

Ada juga argumen balasan yang sah yang pernah saya lihat dari praktisi: sebagian orang benar-benar lebih suka eksplisitnya chrono. LocalResult::Ambiguous memaksamu berpikir. Kalau domainmu adalah yang salah menebak fold DST punya konsekuensi hukum atau finansial, seperti payroll, settlement energi, atau trading, mungkin kamu ingin library menolak menebak, selalu. Jiff mendukung itu lewat unambiguous(), tapi chrono menjadikannya jalur paling mudah. Wajar saja.

Di mana Jiff menang

Hampir di semua tempat lain. Aplikasi apa pun yang menyentuh waktu sipil, seperti penjadwalan, kalender, tanggal yang terlihat pengguna, atau apa pun yang melintasi zona waktu, mendapat kesepakatan yang jauh lebih baik dengan Jiff. Nama tipenya mengajarkan domainnya. Ambiguitas DST mendapat default yang waras dengan jalan keluar yang bertipe, bukan enum yang akan kamu tangani salah jam 2 pagi. Span melakukan aritmetika kalender dengan benar sejak awal. Parsing dan formatting mencakup format ramah yang benar-benar ditulis manusia. Dan komitmen 1.0 itu penting: Gallant sudah menyatakan niat untuk menjaga API tetap stabil tanpa batas waktu, justru agar Jiff bisa muncul di API publik library lain, sifat yang sama yang membuat kesalahan chrono menjadi permanen. Daftar adopsinya sudah mendukung ambisi itu: uv, Cargo, Starship, fd, Nushell, Jujutsu, dan uutils semuanya memakainya, dan LLRT milik AWS membangun implementasi Temporal-nya di atasnya.

Pertanyaan performa, karena selalu ada yang bertanya: keduanya cukup cepat sehingga penanganan datetime tidak pernah menjadi bottleneck-mu. Jiff menyertakan salinan terkompresi dari database zona waktu IANA (dengan sikap yang terdokumentasi dan matang soal penggunaan rearguard tzdata) atau bisa memakai database zona sistem. Ini domain di mana kebenaran jauh lebih penting daripada microbenchmark, sehingga memilih berdasarkan kecepatan adalah malpraktik. Jawaban salah yang dihasilkan dalam 50 nanodetik tetap salah.

Library datetime yang membuatmu menangani ambiguitas di mana-mana bukan lebih jujur. Ia hanya melempar masalah terberatnya ke orang yang paling tidak siap menyelesaikannya: kamu, di call site, sedang terburu-buru.

Pelajaran Lebih Besar untuk Desain API

Lepaskan tanggalnya, dan Jiff adalah studi kasus untuk argumen yang lebih luas: library seharusnya mengenkapsulasi kompleksitas domain, bukan mengekspos ulang secara setia. Database zona waktu IANA, seperti yang dikritik banyak orang dengan adil, adalah artefak yang berorientasi programmer: berbasis lokasi, historisnya sangat lengkap, penuh pengenal yang tidak pernah diketik pengguna. Library yang malas mengekspos semuanya mentah-mentah dan menyebutnya fleksibilitas. Library yang baik menyerapnya: strategi disambiguasi default, parsing yang ramah, nama tipe yang memetakan ke konsep manusia. Ketegangan yang sama terlihat di domain lain. Celah antara spesifikasi dan implementasi yang bisa dipakai adalah tempat sebagian besar bug bersarang, dan penanganan datetime adalah habitat alami celah itu.

Ini juga cerita tentang kesabaran ekosistem. Rust menunggu satu dekade untuk library datetime yang 'definitif', sama seperti ia menunggu bertahun-tahun agar async stabil atau agar never type distabilkan. Penantian itu adalah harga untuk mendapatkan model yang benar, alih-alih mengunci draf pertama yang bisa jalan. Chrono bukan kegagalan; ia adalah draf yang dibutuhkan ekosistem pada masanya. Tapi draf memang direvisi.

Rekomendasinya

Proyek Rust baru? Pakai Jiff. Jangan terlalu dipikirkan. API-nya lebih baik, penanganan DST lebih aman secara default, komitmen stabilitas 1.0 jelas, dan momentum ekosistemnya (Cargo dan uv tidak mengadopsi crate sembarangan) berarti kamu makin sering bertemu dengannya cepat atau lambat. Pakai ZonedDateTime untuk apa pun yang terlihat pengguna, Timestamp untuk penyimpanan dan format wire, dan tipe civil ketika lokasi memang tidak berlaku.

Codebase chrono yang sudah berjalan? Tetap di sana, kecuali kamu menyentuh fitur yang berat waktu sipil di mana footgun chrono benar-benar merugikanmu. Kedua library ini bisa berinteroperasi dengan baik lewat timestamp dan string ISO, jadi adopsi parsial (Jiff untuk modul penjadwalan, chrono di tempat lain) adalah strategi yang sah, bukan kompromi.

Kesimpulan yang lebih dalam, apa pun pilihanmu: penanganan datetime itu sulit karena domainnya memang aneh dan tidak bisa disederhanakan, mulai dari detik kabisat, fold, gap, bulan dengan panjang yang bervariasi, sampai zona politik yang berubah lewat keputusan. Yang terbaik yang bisa dilakukan library adalah memilih default yang tepat, memberi nama dengan jujur, dan menjaga jalan keluar tetap dekat. Jiff melakukan ketiganya. Dua puluh tahun evolusi library datetime, dari Joda-Time lewat java.time hingga Temporal, konvergen pada model yang sama karena suatu alasan. Senang rasanya melihat Rust akhirnya mendapatkan versinya sendiri.