Articoli approfonditi sulla tecnologia che plasma il futuro.

Jiff vs Chrono: quale libreria datetime Rust scegliere

Jiff vs chrono per la gestione di date e orari in Rust: casi limite DST, ergonomia delle API e quando conviene l'una o l'altra, da chi ci è passato con entrambe.

Due orologi stilizzati sovrapposti, uno meccanico e uno organico, che evocano le transizioni tra fusi orari.
I bug sulle date raramente fanno crashare qualcosa: ti restituiscono silenziosamente l'ora sbagliata.

Ogni pochi anni, qualche sfortunato ingegnere scopre che 2026-11-01 01:30 a New York capita due volte, e che il suo scheduler ha appena lanciato il job di fatturazione un'ora prima. I bug legati a date e orari non fanno crashare il programma: corrompono silenziosamente i dati. Ecco perché l'arrivo di Jiff 1.0, una nuova libreria datetime per Rust di Andrew Gallant (quello di ripgrep), conta più di un ennesimo rilascio di crate. Solleva una domanda concreta: Jiff vs chrono, quale dovrebbe usare il tuo prossimo progetto Rust?

Breve storia del dolore datetime in Rust

Rust ci è già passato, e la storia è istruttiva. Chrono risale all'epoca pre-1.0 del linguaggio, quando fu estratta dalla libreria standard insieme a time nell'ambito della grande operazione di 'right-size std'. Per quasi un decennio è stata la risposta predefinita. Funzionava, più o meno. Ma la sua API si è stratificata: NaiveDateTime, DateTime<Utc>, DateTime<Local>, DateTime<FixedOffset>, un trait TimeZone che la maggior parte delle persone usa solo tramite due implementazioni. Il sistema di tipi permetteva di fare un sacco di cose prive di senso semantico, come sommare un datetime naive a uno con fuso orario e ottenere un risultato sicuro di sé ma sbagliato.

Conta anche la questione della manutenzione. Chrono ha attraversato un periodo di abbandono di fatto, e anche i suoi manutentori più recenti hanno descritto l'esperienza come una lotta contro una stabilità delle API che gli utenti trattavano come sacra. Un ex manutentore lo ha detto senza giri di parole: ogni piccolo passo verso il miglioramento incontrava resistenza, perché il principale punto di forza di chrono era diventato la sua stabilità, non il suo design. È una trappola in cui può cadere qualsiasi libreria longeva: la base installata diventa il prodotto. Il crate time ha provato un approccio diverso con un nucleo più pulito, ma per anni ha rimandato la gestione completa dei fusi orari. Nel frattempo l'ecosistema continuava a produrre applicazioni in cui 'che ore sono a Berlino a marzo prossimo' è una domanda portante.

Questa è la vecchia idea su cui Jiff si appoggia, che la nomini o no: la filosofia della 'pit of success' che Rico Mariani descrisse per il design delle API già a metà degli anni 2000. Fai in modo che la strada facile sia anche quella corretta. La tesi di Gallant è che la difficoltà con le date deriva da una modellazione del dominio povera, e che le librerie che scaricano l'ambiguità sull'utente (« ecco un datetime naive, buona fortuna ») stanno esternalizzando il loro problema più difficile. È lo stesso istinto alla base del modello di ownership di Rust: la macchina deve assorbire la complessità perché l'essere umano non debba farlo.

Come Jiff modella il tempo: la cipolla

Il punto centrale del design di Jiff è quello che Gallant chiama la cipolla dei datetime. Gli strati, dall'interno verso l'esterno:

  • civil::Date: una data gregoriana, senza luogo associato. Il tuo compleanno è uno di questi.
  • civil::Time: un orario da orologio a parete con precisione al nanosecondo, senza luogo.
  • civil::DateTime: data più ora, ancora senza luogo. È ciò che chrono chiama naive.
  • Timestamp: un istante non ambiguo, nanosecondi dall'epoca Unix.
  • TimeZone: le regole che mappano istanti e tempo civile in una regione.
  • ZonedDateTime: tutto insieme: istante, tempo civile e fuso orario.

Il vantaggio è che i nomi dei tipi corrispondono al modello mentale che hai già. Un Timestamp è ciò che ottieni da un database o da una system call. Un civil::DateTime è ciò che un essere umano scrive su un invito in calendario. Convertire tra i due è impossibile senza un fuso orario, e Jiff rende quella conversione un'operazione esplicita, fallibile e annotata con la zona. Confronta con chrono, dove la distinzione equivalente esiste ma è più facile da confondere: NaiveDateTime::and_utc() applica felicemente una zona a un orario da parete senza chiedersi se quell'orario sia mai esistito.

L'ergonomia è volutamente gentile. Puoi costruire un datetime con zona partendo da entrambe le direzioni (tempo civile più zona, oppure timestamp più zona), e l'API ti viene incontro in entrambi i casi:

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(())
}

Ora legale: dove Jiff si guadagna il posto

Ecco lo scenario che separa gli adulti dai bambini nel design delle librerie datetime. Il 1° novembre 2026, a New York gli orologi tornano indietro alle 2 di notte. L'ora dell'1 capita due volte. Quindi, quando un utente scrive 'l'1:30 del 1° novembre', cosa fai? La risposta di chrono, storicamente, è LocalResult: un enum che può essere Single, Ambiguous o None, e che una quantità sorprendente di codice di produzione scarta, scompatta o gestisce male con pattern matching. L'ambiguità viene esposta, ma anche l'onere di gestirla, ogni singola volta.

La risposta di Jiff è scegliere un default sensato e rendere le alternative a una chiamata di metodo di distanza. La strategia predefinita 'compatible' risolve il fold sulla occorrenza precedente, come fa la maggior parte dei software di calendario e ogni grande sistema operativo. Ma se ci tieni, l'albero decisionale completo è lì a disposizione:

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(())
}

Anche i gap seguono lo stesso trattamento: quando gli orologi saltano avanti e le 2:30 non esistono mai, Jiff spinge in avanti per impostazione predefinita, e anche qui puoi sovrascrivere. La scelta di design è dichiaratamente opinionata e, credo, corretta. La maggior parte del codice che gestisce orari ambigui non ha una policy: ha un bug che aspetta novembre. Usare come default il comportamento che gli utenti si aspettano già dal telefono, mantenendo visibili e tipizzate le vie di fuga, è esattamente ciò che 'pit of success' significa in pratica. È una filosofia simile a quella dietro i buoni default nell'aritmetica delle date scritta a mano: le regole si possono imparare, ma non dovresti doverle riderivare in ogni punto di chiamata.

Una linea temporale astratta a nastro che mostra un fold, dove torna indietro su se stessa, e un gap, dove si interrompe.
Fold e gap: i due punti in cui il tempo civile smette di corrispondere in modo pulito agli istanti.

Span, durate e il problema del 'un mese'

Se chiedi a chrono una durata di 'un mese', resterai deluso: la sua Duration è un numero fisso di secondi, perché un mese non è un numero fisso di nulla. È una scelta difendibile, ma significa che l'aritmetica di calendario ('aggiungi tre mesi al 31 gennaio') diventa un problema tuo. Il tipo Span di Jiff prende l'altra strada: contiene unità miste dagli anni fino ai nanosecondi, e l'aritmetica si risolve in modo consapevole del calendario. Aggiungere un mese al 31 gennaio dà il 28 (o 29) febbraio, non il 3 marzo. Aggiungere un giorno a un datetime con zona la sera prima di una transizione DST aggiunge un giorno di calendario, che può durare 23 o 25 ore, ed è esattamente ciò che un essere umano intende quando dice 'stessa ora domani'.

Questa distinzione tra tempo trascorso e tempo di calendario è il concetto più confuso in assoluto nella programmazione con le date, ed è confuso ovunque. Il vecchio java.util.Date di Java li mescolava; il package java.time di Java 8 (modellato su Joda-Time) ha separato Duration da Period e ne ha tratto beneficio. La proposta Temporal di JavaScript fa la stessa separazione. Jiff si inserisce comodamente in questa linea: le buone idee nel design dei datetime convergono da vent'anni, e Jiff è essenzialmente l'espressione in Rust di quel consenso, proprio come le funzionalità del linguaggio Rust a lungo in gestazione arrivano alla fine come la versione distillata di un decennio di dibattito.

C'è anche un formato di durata 'friendly': stringhe come 2h 30m o P1DT2H si parsano e si stampano in modo naturale, insieme alla formattazione in stile strptime/strftime e all'integrazione opzionale con ICU4X per l'output sensibile alla localizzazione. Sembrano requisiti minimi, ma chiunque abbia scritto una stringa di formato chrono su misura per una pipeline di log sa quanto attrito eliminano.

Jiff vs Chrono: quando vince l'uno o l'altro

Basta con il giro turistico. Ecco il confronto onesto, con un punto di vista dichiarato.

Dove chrono vince ancora

L'inerzia è una funzionalità. Chrono è nell'albero delle dipendenze di una quota enorme dell'ecosistema Rust, compare in innumerevoli API pubbliche ed è mantenuto da mani affidabili. Se la tua codebase parla già chrono con disinvoltura, i tuoi timestamp sono istanti solo in UTC (pensa a pipeline di metriche, envelope di log, RPC interne) e il tuo team conosce i suoi spigoli taglienti, la migrazione ti porta ben poco. Anche la posizione di chrono, con std opzionale e compatibile con no_std, conta ancora negli angoli embedded. E se fai qualcosa di esotico, come meccanica orbitale su scala di megayear o scale temporali alternative come TAI o UT1, nessuna delle due librerie è davvero la risposta: ne userai una per il parsing delle stringhe mantenendo una rappresentazione tua, e la semplicità di chrono ai margini va bene per questo.

C'è anche un contro-argomento legittimo, che ho visto da parte di chi lavora sul campo: alcuni preferiscono davvero l'esplicitezza di chrono. LocalResult::Ambiguous ti costringe a pensare. Se il tuo dominio è uno in cui sbagliare una supposizione su un fold DST ha conseguenze legali o finanziarie (buste paga, regolamento dell'energia, trading), forse vuoi una libreria che si rifiuti di indovinare, sempre. Jiff lo supporta tramite unambiguous(), ma chrono rende quella la strada di minor resistenza. Ci sta.

Dove vince Jiff

Quasi ovunque il resto. Ogni applicazione che tocca il tempo civile (pianificazione, calendari, date mostrate agli utenti, qualsiasi cosa attraversi i fusi orari) ottiene un affare decisamente migliore con Jiff. I nomi dei tipi insegnano il dominio. L'ambiguità DST riceve un default sensato con vie di fuga tipizzate, invece di un enum che gestirai male alle 2 di notte. Span fa l'aritmetica di calendario correttamente già di serie. Il parsing e la formattazione coprono i formati amichevoli che le persone scrivono davvero. E l'impegno del 1.0 conta: Gallant ha dichiarato l'intenzione di mantenere l'API stabile a tempo indeterminato proprio perché Jiff possa comparire nelle API pubbliche di altre librerie, la stessa proprietà che ha reso permanenti gli errori di chrono. La lista di adozione sostiene già questa ambizione: uv, Cargo, Starship, fd, Nushell, Jujutsu e uutils lo usano, e l'LLRT di AWS ha costruito la sua implementazione di Temporal sopra di esso.

La domanda sulle prestazioni, visto che qualcuno la fa sempre: entrambe le librerie sono abbastanza veloci che la gestione delle date non sarà mai il tuo collo di bottiglia. Jiff incorpora una copia compattata del database tz IANA (con una posizione documentata e ponderata sull'uso di tzdata rearguard) oppure può usare il database dei fusi di sistema. Questo è un dominio in cui la correttezza batte i microbenchmark con un margine tale che scegliere in base alla velocità sarebbe malpractice. Una risposta sbagliata in 50 nanosecondi resta sbagliata.

Una libreria datetime che ti obbliga a gestire l'ambiguità ovunque non è più onesta: esternalizza il suo problema più difficile alla persona meno attrezzata per risolverlo, cioè tu, in un call site, di fretta.

La lezione più grande per il design delle API

Togli le date e Jiff diventa un caso di studio su un argomento più ampio: le librerie dovrebbero incapsulare la complessità del dominio invece di riesportarla fedelmente. Il database dei fusi orari IANA è, come giustamente notano i critici, un artefatto orientato al programmatore: basato sulle località, storicamente esaustivo, pieno di identificatori che nessun utente digiterebbe mai. Una libreria pigra lo espone così com'è e lo chiama flessibilità. Una buona lo assorbe: strategie di disambiguazione predefinite, parsing amichevole, nomi di tipi che corrispondono a concetti umani. La stessa tensione compare in altri domini: il divario tra una specifica e un'implementazione utilizzabile è dove vivono la maggior parte dei bug, e la gestione delle date ne è l'habitat naturale.

È anche una storia di pazienza dell'ecosistema. Rust ha aspettato un decennio la sua libreria datetime 'definitiva', come ha aspettato anni che l'async si assestasse o che il never type si stabilizzasse. L'attesa è il prezzo da pagare per avere il modello giusto invece di bloccare la prima bozza funzionante. Chrono non è stato un fallimento: è stata la bozza di cui l'ecosistema aveva bisogno all'epoca. Ma le bozze si rivedono.

La raccomandazione

Nuovo progetto Rust? Usa Jiff. Non stare a pensarci troppo. L'API è migliore, la gestione DST è più sicura di default, l'impegno di stabilità del 1.0 è esplicito e lo slancio dell'ecosistema (Cargo e uv non adottano crate alla leggera) significa che te lo troverai di fronte sempre più spesso comunque. Usa ZonedDateTime per tutto ciò che è rivolto all'utente, Timestamp per lo storage e i formati di trasmissione, e i tipi civil quando la località non si applica davvero.

Codebase chrono esistente che funziona? Resta dove sei, a meno che tu non stia toccando funzionalità molto legate al tempo civile in cui le trappole di chrono ti stanno attivamente costando. Le due librerie interoperano bene tramite timestamp e stringhe ISO, quindi l'adozione parziale (Jiff per il modulo di pianificazione, chrono nel resto) è una strategia legittima e non un compromesso.

La conclusione più profonda, qualunque sia la tua scelta: la gestione delle date è difficile perché il dominio è irriducibilmente strano (secondi intercalari, fold, gap, mesi di lunghezza variabile, zone politiche che cambiano per decreto). Il meglio che una libreria possa fare è scegliere i default giusti, dare nomi onesti alle cose e tenere vicine le vie di fuga. Jiff fa tutte e tre le cose. Vent'anni di evoluzione delle librerie datetime, da Joda-Time passando per java.time fino a Temporal, hanno convergito sullo stesso modello per un motivo. È bello vedere Rust ottenere finalmente la sua versione.