Jiff: Datetime library for Rust

Original Article ↗ Hacker News Discussion ↗

Library goals and motivation

  • Jiff is a new Rust datetime library aiming for a more ergonomic, “pit of success” API than existing crates like chrono.
  • Design docs emphasize correct handling of DST, IANA time zones, calendar arithmetic, roundable durations, and lossless round-trips for zoned datetimes.
  • Some see Rust + Chrono as already the best datetime experience they’ve had; others find Chrono correct but rigid and awkward.

API design, traits, and syntax

  • The ToSpan syntax 5.days().hours(8).minutes(1) split opinion; alternatives suggested:
    • Builder-style Span::new().days(5).hours(8).minutes(1)
    • Arithmetic 5.days() + 8.hours() + 1.minutes()
    • Named arguments or struct-default-based patterns, which Rust currently lacks.
  • Discussion of extension traits vs inherent methods: str.parse() uses the standard FromStr trait, with type inferred or specified via turbofish; some prefer Type::parse(str) for explicitness.

Span arithmetic and negative durations

  • Jiff does not overload + for Span + Span; instead uses methods like checked_add, especially when months/years require a reference datetime.
  • Allowing + only for component-wise addition is seen as too subtly different from reference-based addition.
  • Spans can be negative, matching ISO 8601-2 and other libraries. Critics argue physical “durations” should be non-negative; proponents say signed spans model concepts like “1 year ago” and simplify APIs.

Time zones, DST, and Olson/Temporal conventions

  • Several comments highlight how messy real-world time is (DST, scheduling around midnight/weekends, “tomorrow” semantics).
  • Jiff supports IANA zones and the [Olson/Name] suffix pattern used in Temporal and Java’s time APIs to enable lossless round-trips.
  • Some users compare favorably to Python’s pandas and JS’s upcoming Temporal API; others still struggle with timezone conversion ergonomics in Rust.

Leap seconds and TAI vs Unix time

  • Multiple commenters criticize Unix-time-based libraries for ignoring leap seconds and want TAI-first representations.
  • Jiff deliberately omits leap-second-aware core semantics (though TAI-like support via tzif data is possible), arguing:
    • General-purpose apps rarely need full leap-second correctness.
    • Supporting it adds complexity and can introduce more errors than it removes.
  • Scientific and astronomy use cases (e.g., asteroid tracking, precise linking of observations) do need leap-second accuracy; the suggested approach is to use specialized libraries (e.g., TAI/astronomy crates) and interop rather than burden the general-purpose library.

Rust language features and ecosystem

  • Significant side discussion on:
    • Named and optional arguments, struct default fields, and how they might reduce builder boilerplate; proposals exist but are controversial and stalled.
    • Whether Rust should add a datetime type to std; many argue the standard library is intentionally minimal and critical crates should stay outside std to allow evolution.
  • Logging: Jiff uses the log crate as the lowest common denominator; tracing interops but would be heavier.

Error handling and panics

  • Debate over the pervasive use of unwrap()/expect() in Rust:
    • Some view it as culturally overused and worry about panics from deep in dependency trees, especially for long-running or kernel-like code.
    • Others argue panics (fail-fast) are appropriate for invariant violations and can improve reliability by surfacing bugs early; Result + ? is available when recoverability is desired.
  • There is mention of tools like no_panic to enforce non-panicking code and official Rust docs discussing when to panic vs return errors.

Licensing and ecosystem fit

  • Jiff is dual-licensed MIT and Unlicense:
    • Unlicense is seen by its users as an ideological statement against copyright and a “do whatever you want” signal.
    • Others point out Unlicense has legal issues in some jurisdictions, and MIT is added as a pragmatic fallback for corporate/legal comfort.
  • Some commenters argue for copyleft (GPL/LGPL/MPL) to prevent corporate capture; others prefer permissive licenses to avoid forcing downstream code to open-source.

Implementation details and unsafe

  • One code snippet uses from_utf8_unchecked for ASCII-only decimal formatting.
    • A commenter questions whether the micro-optimization justifies added unsafe complexity and potential invariant risk.
    • A micro-benchmark reportedly shows ~15% speedup in that hot path; there is disagreement about the right balance between performance and clarity/safety.

Naming and pronunciation

  • The name “Jiff” and its pronunciation (explicitly defined as like “gif” with a soft g, “gem”) generated lighthearted debate.
  • Some dislike the name as “pretentious” or confusing; others treat the GIF/GIF joke as harmless bikeshedding.

Overall reception

  • Many are enthusiastic, especially given the author’s track record and the depth of the design and comparison docs.
  • Skepticism centers on:
    • Leap-second correctness.
    • Some API choices (method-chained spans, lack of Span + Span).
    • Broader Rust ecosystem issues (no named args, tiny stdlib).
  • Several commenters plan to adopt Jiff in place of Chrono/time; others are content with existing solutions and view Jiff as another strong option rather than an obvious replacement.