As the Rust language continues to evolve, it’s natural to need plans for where the language will go next. So the Rust language design team (Rust Lang Team) recently published a roadmap for updates to the Rust language in 2024 on the official blog, providing A look at the future of Rust. It is important to note that it is still early in 2024, so the Rust roadmap may change over time on this basis.
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 technology company, and Rust 2024 will be the fourth version of the programming language roadmap, following Rust 2015, Rust 2018, and Rust 2021. According to the current plan, the three-year cycle will be maintained and there should be no change in the versioning.
From the Rust team’s perspective, the 2024 roadmap focuses on three main things: a lower learning curve, giving the Rust library a better connectivity ecosystem, and further developing and growing the Rust language.
Lowering the Learning Barrier
The high barrier to learning the Rust language is a recurring criticism. In the 2021 Rust Survey survey released in February, 83% of the nearly 10,000 respondents found it very challenging to adopt Rust in a production environment. In surveys over the years, the problem of a steep learning curve has persisted and is one of the main reasons why many people don’t use Rust.
Developers need to understand not only the general logic, but also the specific implementation down to the smallest detail. In the official Rust blog, they cite the ownership system and the concept of a borrow checker as examples – “Even if you’ve learned how Rust’s borrow checker works, there are still a lot of little details you need to figure out 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 the unexpected complexity of Rust. the Rust team wants developers to use Rust in a way that is “not just possible, but also uncomplicated and a pleasure to use,” especially for embedded development and asynchronous programs.
To achieve this vision, the team had four specific goals.
- More accurate analysis: enable the compiler to better identify if the code is correct by improving borrow checkers, type inference, etc. Identify and eliminate “boilerplate” patterns, such as copying and pasting the same set of
- Developers should be able to express the intent of their code more easily and directly. This could be in the form of syntactic sugar (e.g.
let-else) on the one hand, and could mean extending the type system on the other.
- Improve asynchronous support: extend async-await support beyond the current
MVPto include features such as async fns, async drop, etc. in traits.
dyn Traitmore useful. Broaden the set of features available for
dynto make working with
dynmore similar to working with generics.
Libraries and Core Language
Rust combines powerful extensibility mechanisms such as ownership and borrowing, low-level system control, and more, making it a great language for writing libraries. And thanks to Cargo, developers can use a library in their programs with just a few lines of code. That said, there are many things that library authors can’t do, or can’t easily do – for example, they can’t control the error messages you see, or deploy an “unstable” feature. For Rust 2024, the Lang Team wants to build features that will allow library authors to better serve their users, either by helping manage the lifecycle of a feature or by expanding the library’s functionality.
The Lang Team also wants to enable more exploratory changes in the ecology and to enable stable migration of code from the ecology to the standard library; in addition to this, they will enhance Rust’s interoperability, allowing library authors to write code that is portable across many environments, or specific to a particular environment, as they wish.
To further develop the language more effectively, the Lang Team wants developers to be able to easily identify what work the team is actively working on and how far along it is. They want each tracking issue to clearly identify what steps are needed to move that particular feature to completion, and to ensure that those steps are clear enough to potential contributors.
As 2023 approaches, the Lang Team will revisit these issues and will review how much progress has been made and whether any of this needs to be adjusted.
For a programming language, the most important thing that developers would like to see is that version updates should introduce as few disruptive changes as possible. Such changes may affect compatibility between programs on the one hand, and defeat the goal of lowering the learning curve that was set up in the first place. More details on the roadmap can be found on the Rust official blog.