As the Rust language continues to evolve, it's natural to have a plan for where the language will go next. Therefore, the Rust language design team (Lang Team) recently announced the update roadmap of the Rust language in 2024 in the official blog , providing a vision for the future of Rust. It's important to note that 2024 is still very early, so Rust's roadmap is likely to change based on that over time.
Rust 1.0 was released in 2015. Since then, Rust has grown from a niche language to a mainstream programming language used by almost every major tech company. Rust 2024 will also be the fourth edition of the programming language roadmap, following Rust 2015, Rust 2018, and Rust 2021. According to the current plan, the three-year cycle will be retained, and there should be no change in version division.
From the Rust team's point of view, the 2024 roadmap focuses on three main things: a lower learning curve, a better connectivity ecosystem for Rust libraries, and further development and growth of the Rust language.
Lower the learning threshold
The high threshold of learning the Rust language is a problem that has been criticized many times. In the 2021 Rust Survey released in February, 83% of nearly 10,000 respondents found it challenging to adopt Rust in a production environment. The problem of the learning curve being too steep has persisted in surveys over the years, and it's one of the main reasons why many people don't use Rust.
Developers not only need to understand the general logic, but also need to be precise about the specific implementation down to a lot of minutiae. In the official Rust blog, they cite the concept of ownership systems and borrow checkers as examples - "Even if you've learned how Rust's borrow checkers work, there are still many little details that you need to figure out understand, so that Rust programs can compile."
So one of their goals in Rust's 2024 roadmap is to simplify programs so that developers only have to deal with the inherent complexity of their domain and no longer have to deal with Rust's unexpected complexities. The Rust team hopes that developers using Rust should be "not just possible, but uncomplicated and enjoyable to use", especially for embedded development and asynchronous programming.
To achieve this vision, the team has four specific goals:
- More precise analysis: Enables the compiler to better identify if the code is correct with improved borrow checkers, type inference, and more. Identify and eliminate "boilerplate" patterns, such as copy-pasting the same group everywhere
where. - Developers should be able to express the intent of the code more easily and directly. On the one hand it can be in the form of syntactic sugar (eg
let-else), on the other hand it can mean extending the type system. - Improve async support: Extend async-await support beyond the current "MVP" to include features such as async fns, async drop in traits.
- make
dyn Traitmore useful. Broaden the setdynof , making the work of usingdynthe work closer to the work of using generics.
Libraries and Core Languages
Rust combines powerful extensibility mechanisms like ownership and borrowing, low-level system control, etc., making it a great language for writing libraries. And thanks to Cargo, developers can use a library with just a few lines of code in their programs. Still, there are a lot of things that library authors can't do, or can't do easily - eg: they can't control the error messages you see, or deploy a "unstable" feature. For Rust 2024, the Lang Team hopes to build features that will enable library authors to better serve their users, whether by helping to manage the lifecycle of features or by expanding the capabilities of the library.
Lang Team also hopes to be able to explore more changes in the ecosystem, and to be able to steadily migrate code from the ecosystem to the standard library; in addition, they will also enhance the interoperability of Rust, allowing library authors to do whatever they want Write code that is portable across many environments, or specific to one environment.
To further develop the language more efficiently, the Lang Team wants developers to be able to easily identify what work the team is actively working on, and how much progress has been made. They want each tracking issue to clearly identify which steps are required to drive completion of that particular feature, and to ensure that those steps are clear enough to potential contributors.
finally
As 2023 rolls around, the Lang Team will be revisiting these issues, reviewing how much progress has been made and whether these need to be adjusted.
For a programming language, the most important thing developers want to see is that version updates should introduce as few breaking changes as possible. Such changes may affect the compatibility between programs on the one hand, and also violate the original goal of reducing the learning curve on the other hand. More details on the roadmap can be found on the official Rust blog .