The alternative is to keep a relatively small standard library, and a good package manager, to make it easier for people to iterate on API design in third party packages. Major version changes in a single library can have much less impact accross the ecosystem than standard library packages. Eventually you may get a de facto standard, and sometimes they are then later incorporated into the standard library.
This model isn't without its downsides; it can sometimes mean fragmentation when standardization would help, sometimes these de facto standard libraries can become important enough that they run into the same ecosystem fragmentation issues on major releases. But it allows for more flexibility.
The latter model is what the Rust project decided on for everything outside of the most fundamental time types. Dates and times and timezones are notoriously hard to model in code, and easy to create API designs that are full of footguns, so this is a place where that extra freedom to iterate was more important than standardizing on an API early on.
That iteration has led to a number of different libraries, including time, chrono, and now jiff, allowing for exploring the space of API design to really get it right rather than being stuck with what was available early on.
Of course, Go can always backtrack and expose the primitives, and Rust can always add a higher-level API, but as user of the languages, I'd rather have the latter problem than the former. It doesn't help that Go's zoned-time API isn't very good either.
Temporal does improve some things (it has more strict zoning / less defaults, and improves serialization through RFC 9557), but some of the divergences are not necessarily improvements and rather divergences of opinion (e.g. java.time wilfully made non-ISO calendars second-class, Temporal makes them first class more like Joda, and it's one of the things Colebourne — the lead author of Joda and java.time — strongly disagrees with[1], but the Temporal authors have pretty compelling reasons for it[2]).
[1] https://blog.joda.org/2009/11/why-jsr-310-isn-joda-time_4941... https://github.com/tc39/proposal-temporal/issues/5 https://github.com/tc39/proposal-temporal/issues/1454
[2] https://tc39.es/proposal-temporal/docs/calendar-review#why-a...
For a systems programming language, Rust is relatively easy to write applications in -- but I suspect standard library choices (and other choices) will be driven by the systems side for the foreseeable future.
Not at all. We just want to avoid having the standard library be "where code goes to die", as Python folks have put it.
We're working on adding more popular APIs from the ecosystem to the standard library. See https://github.com/rust-lang/std-replacement-data/ for a data set tracking what crates have been obsoleted by additions to the standard library; we hope to increase that over time.
> disparate documentation
I've never experienced this while using a Rust library. They all use rustdoc hosted on docs.rs (or locally with $ cargo doc). They all look identical and there's a single global search bar that searches all your dependencies.
> conflicting dependencies
Since you can install two different versions of the same library, this is only an issue if two of your dependencies both expose a transitive dependency with different versions in their external APIs. (E.g. libA returns a Foo 1.0 and libB expects an argument of Foo 2.0) Only library I've ever run into this with is raw-window-handle.
> supply chain risks
> enormous .cargo
These I agree with. Although honestly the supply chain risk is not as big with these foundational libraries as it would first appear, since they are almost all maintained by the same 5 rust compiler developers. Really the only difference is that they're not in the rust-lang github organization and not shipped precompiled with the standard library
Documentation certainly has nothing to do with it.
Other factors you mentioned are more convincing.