What is the stabilization process? Reading the release notes I see a lot of different standard library APIs and even language features (e.g. underscore lifetimes). How does an API become stable?
Stabilization is accomplished by increasing the shear strength and the overall bearing capacity of a soil. Once stabilized, a solid monolith is formed that decreases the permeability, which in turn reduces the shrink/swell potential and harmful effects of freeze/thaw cycles.
Soil stabilization is defined as a chemical, physical, biological, mechanical, or combined technique that maintains or improves the stability of weak soils to achieve engineering goals. The pozzolanic reactions between the stabilizer (binder) and the soil particles improve the quality of the stabilized soft soil.
Stabilization can increase the shear strength of a soil and/or control the shrink-swell properties of a soil, thus improving the load bearing capacity of a sub-grade to support pavements and foundations.
There are three broad types of soil stabilization: biological, physical and chemical.
Stabilization is the way that new features are added to Rust. Unlike many languages, where when stuff is added, it goes in the next release, Rust has a multi-stage process so that we can try out features before they're slated to be included in stable Rust.
Small features, especially new library APIs, can be added by just sending in a pull request. Larger features go through the RFC process, so that there can be some consensus around the design before they're implemented. If an RFC is accepted, an implementation can be sent in via PR. Whenever a new feature is added, it goes behind a "feature gate", that is, a special attribute, #![feature]
, that lets you opt into giving that feature a try.
Every (okay sometimes not every but almost every) night, a nightly build of Rust is made. Nightly builds are used for testing, and so, you can opt into new, unstable features using the #![feature]
attribute. Users then give these features a whirl, report bugs, and comment on how the API or feature is used in the real world.
Every six weeks, a nightly is turned into a "beta" release. Betas are like release candidates, and so they don't allow you to use #![feature]
, and so, don't let you use experimental features. After six weeks, a new nightly becomes beta, and the beta release becomes a new "stable" release. This is what most people mean when they talk about Rust, and what most Rust users use. Stable Rust also doesn't let you use #![feature]
, as those features aren't stable.
Anyway, after a time (that's at least one whole release cycle), if a feature is good, the team discusses if it should be made stable. If they decide yes, then the #![feature]
requirement is removed, and the feature will "ride the trains" to an eventual stable release. If they decide no, it will be deprecated and eventually removed.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With