Wedson Almeida Filho, a maintainer of the Rust for Linux project, recently announced his resignation, citing "nontechnical nonsense" as the reason for his departure.
This decision follows a pattern of hostility from some Linux kernel developers toward the integration of the Rust programming language into the Linux kernel.
Filho’s resignation was announced via Linux Kernel mailing list. In the email, Filho expressed his gratitude toward the Rust for Linux team but stated that he no longer had the energy to deal with the negativity surrounding the project.
He concluded his message by saying that while he believes memory-safe languages like Rust are the future of kernel development, he fears that if Linux doesn't embrace this, another kernel will eventually supersede it.
Here's the actual mail from Wedson:
Hey folks,
This is as short a series as one can be: just removing myself as maintainer of
the Rust for Linux project.I am retiring from the project. After almost 4 years, I find myself lacking the
energy and enthusiasm I once had to respond to some of the nontechnical
nonsense, so it's best to leave it up to those who still have it in them.To the Rust for Linux team: thank you, you are great. It was a pleasure working
with you all; the times we spent discussing technical issues, finding ways to
address soundness holes, etc. were something I always enjoyed and looked
forward to. I count myself lucky to have collaborated with such a talended and
friendly group.I wish all the success to the project.
I truly believe the future of kernels is with memory-safe languages. I am no
visionary but if Linux doesn't internalize this, I'm afraid some other kernel
will do to it what it did to Unix.Lastly, I'll leave a small, 3min 30s, sample for context here:
https://youtu.be/WiPp9YEBV0Q?t=1529 -- and to reiterate, no one is trying force
anyone else to learn Rust nor prevent refactorings of C code.Thanks,
-Wedson
As you may noticed, the email also included a link to a YouTube video of a talk Filho gave at the 2024 Linux Kernel Summit, during which he received significant pushback from some audience members regarding the use of Rust in the kernel.
Critics in the audience argued that the integration of Rust would place an undue burden on C developers, who would be forced to learn a new language and maintain compatibility with Rust bindings.
Additionally, some developers expressed concerns about the stability of Rust bindings and the potential for breakage when changes are made to the C code.
Filho and other proponents of Rust in the kernel, however, maintain that these concerns are overblown and that Rust can coexist with C without compromising the stability of the kernel. They argue that the benefits of Rust, particularly its memory safety features, outweigh the challenges of integration.
The debate over Rust's inclusion in the Linux kernel highlights a broader tension in the open-source community between maintaining a stable codebase and embracing innovation.
While some developers value the familiarity and reliability of C, others see the adoption of newer, safer languages like Rust as essential to the long-term health and security of the Linux kernel.
The outcome of this debate will likely have significant implications for the future of Linux and the broader open-source ecosystem.
Linux Community's Reaction
A lot of heated arguments are going among the Linux Community to whether or not to include Rust in the Linux kernel. As I witnessed in this Reddit discussion, here are the arguments for and against using Rust in the Linux Kernel.
Arguments for including Rust in the Linux kernel
1. Increased memory safety:
Rust's memory safety features can help to prevent a large class of bugs and security vulnerabilities that plague C and C++ code. This is particularly important in a codebase as large and complex as the Linux kernel, where even highly skilled programmers can make mistakes.
Also, Data from Google suggests that using Rust instead of C and C++ in existing codebases can reduce the number of high-severity vulnerabilities.
2. Attracting new developers:
Including Rust in the kernel could help to attract new developers who are more familiar with modern languages and may be put off by the perceived difficulty and complexity of working with C. This was one of the main reasons why Linus Torvalds, the creator of Linux, approved the inclusion of Rust in the kernel.
Arguments against including Rust in the Linux kernel
1. Resistance to change from kernel developers:
Many long-time kernel developers are resistant to learning a new language, especially if they do not see a clear need for it. They argue that they would rather spend time learning more about kernel topics than learning a new way of doing the job they already know how to do.
This resistance has manifested in hostile and unprofessional behaviour towards those advocating for Rust in the kernel, such as the treatment of Wedson Almeida Filho.
2. The difficulty of maintaining compatibility between C and Rust code
Ensuring that changes to C code do not break Rust code, and vice versa, is a significant challenge. This is particularly problematic in the absence of comprehensive automated testing within the kernel.
3. Concerns about the maturity of Rust:
Some kernel developers are concerned that Rust is not yet mature enough to be used in a project as critical as the Linux kernel. They worry that the language and its tooling are still evolving too rapidly, and that relying on them could lead to instability and unforeseen problems.
Why the Resistance to Rust in the Linux Kernel?
It's clear from the above Reddit discussion thread and Wedson Almeida Filho's resignation email that there's resistance to incorporating Rust in the Linux Kernel.
This resistance doesn't necessarily stem from hatred of the language itself, but from a confluence of factors, many mirroring broader issues within software development. Here's a nuanced look at the reasons behind this pushback:
1. Technical Concerns
1.1. Maintenance Burden and API Stability:
A recurring concern revolves around the practicalities of maintaining compatibility between C and Rust. Kernel developers, many of whom are long-time C experts, express worries about the added responsibility of ensuring their C code changes don't inadvertently break Rust components. This is particularly relevant given the limited automated testing within the kernel.
1.2. Complexity and the 'Unsafe' Conundrum:
Some developers argue that bridging the gap between Rust's strict safety rules and the inherent complexities of kernel-level programming might necessitate excessive use of the 'unsafe' keyword in Rust. This is seen as potentially undermining the very safety benefits that Rust aims to bring.
2. Human Factors
2.1. Resistance to Change and Learning Curve:
Many long-time kernel maintainers express reluctance to invest time and effort in learning a new language, especially if they've been successfully using C for years. This resistance is exacerbated by the perception that the onus of adapting to Rust falls on them, rather than the other way around.
2.2. Communication Breakdown and Perceived Hostility:
The way some criticisms have been directed towards Rust advocates, as seen in the video linked in Filho's resignation, has created an environment of hostility and discouraged open dialogue. This has further alienated potential Rust proponents within the kernel community.
3. Deeper Philosophical and Cultural Clashes
3.1. Clashing Development Philosophies:
There seems to be a fundamental disconnect in development philosophies between some kernel developers and Rust advocates. The kernel community, valuing stability, proven methodologies, and deep understanding of a complex codebase, might perceive Rust's stringent rules and emphasis on memory safety as an added constraint rather than a benefit.
3.2. Perceived 'Elitism' and Generational Divide:
Some comments in the attached Reddit discussion hint at a perception of Rust proponents as being 'elitist' or dismissive of C developers' expertise. This, coupled with a potential generational divide between long-time C developers and those more familiar with newer languages, further complicates the integration of Rust into a community with well-established norms and hierarchies.
Please note that not all Linux kernel developers are against Rust. Many see its potential benefits and support its inclusion. But, the points raised above highlight the complex interplay of technical, social, and philosophical factors contributing to the resistance Rust faces within the Linux Kernel team.
Future of Rust in the Linux kernel
The future of Rust in the Linux kernel depends on how effectively these concerns are addressed. Open communication, clear demonstration of Rust's benefits in real-world kernel scenarios, and a collaborative approach that respects the expertise of both C and Rust developers will be important for its successful integration.
While this debate is still going on and there isn't any response from Linus Torvalds, we can't come to any conclusion yet. We will keep you updated. Stay tuned for future updates.
Similar Read:
