Microsoft engineers look forward to Rust 2023: Rewrite compiler, solve management problems

Nick Cameron is a principal engineer responsible for Rust development at Microsoft and was previously a member of the Rust core development team. He published an article 3 months ago: “Ten Challenges Facing Rust”, saying that this is a problem that Rust should solve in 2023.

Last week, he published another article: “Rust in 2023”, expressing his outlook on Rust and the Rust community in 2023, such as the priority work to be done, and the direction that Rust should start to improve.

two important events

Nick Cameron believes that the most important thing at present is to solve the governance and leadership issues of the Rust community. The reason is that these problems block many potential jobs, and the longer they go on, the more “governance debt” the project accumulates. Even more embarrassingly, after more than a year of infighting within the Rust core team, there is still no suggestion of a new leadership team.

As for Rust’s governance, Nick Cameron believes that it is necessary to update the RFC process and re-examine the organizational structure of teams and working groups. These efforts are currently stalled due to the lack of a leadership team to complete the current changes.

In addition, he thinks Rust needs to be rewritten to look at the strategy of “stable rather than stagnant”. Avoiding stagnation is very important, Rust can’t stop innovation, but it can’t let it develop indefinitely. Because the complexity and size of the language comes at a price, which is at odds with Rust’s mission of enabling people to write reliable and performant software (he sees the need to make programming languages ​​simpler, smaller, and easier to use). Just maintaining backward compatibility doesn’t mean stability is achieved.

Nick stated that he was a bit concerned about the number of new features Rust is discussing or designing, and that there is currently no strategy for the direction of Rust.

Nick believes that Rust’s current architecture has been difficult to support functions such as incremental compilation and parallel compilation. Starting over can use more technologies, and the team can use this opportunity to carefully optimize compilation time and simplify future development difficulties. Combined with Rust 2.0, they can reduce technical debt due to backwards compatibility and improve the language for faster compilation.

Other areas worth working on

Cargo (and crates.io) are very important tools and are on the critical path for a lot of important things (supply chain security, general security, integration with other languages, integration with other build systems, build times…), but It’s currently woefully under-resourced, making progress almost impossible (to be clear, the current team is not to blame, they’re doing a fine job in the harsh conditions, simply due to the fact that it’s hard work).

Nick came up with a solution to this problem: provide funding to anyone on the Cargo and crates.io teams who would take it over, focus on mentoring potential new team members (if those people don’t exist), then convince some big companies to support Rust, let They find someone each to spend 1/4 of their working time on Cargo), then work with those members to quickly scale the team (even if they only have partial knowledge of the codebase), and start encouraging contributions and new features again.

At present, the work related to asynchronous programming is progressing smoothly, and Nick said that he hopes that things will start to improve in 2023 and achieve tangible results. On that note, he’s a little frustrated with his slow progress, sadly most of the asynchronous working groups are busy with other things. Things are changing though, and he believes 2023 will be an exciting year for async. It should remain a high priority for Rust.

The Unsafe Code Guidelines Working Group and others have done a lot to define Rust’s memory model and provide tools and guidelines for unsafe programming. Nick thinks it’s important for Rust to push this further. Because safety is Rust’s main selling point, the more we do to make unsafe programming safer and easier, the better.

The text and pictures in this article are from the OSC open source community