Our colleagues on the Chrome browser team have done a similar analysis, which you can find here. While this means our specific conclusions may not be accurate for other codebases, we hope the methodology can help others to make a more informed decision about introducing Rust into their large codebase.
We analyzed code and interfaces in the Android platform specifically, not codebases in general. Therefore, our goal is not to consider all language features, but rather to analyze how Android uses C++ and ensure that interop is convenient for the vast majority of our use cases. After all, we’re introducing Rust because many features and characteristics of C++ make it difficult to write safe and correct code. Simply enumerating the features of each language results in an unsurprising conclusion: many concepts are not easily translatable, nor do we necessarily want them to be. While both Rust and C++ support using the C ABI, it is not sufficient for idiomatic usage of either language. Interoperability with C++ is more challenging and is the focus of this post. For Rust interoperability with C, the C application binary interface (ABI) is already sufficient. Rust support will likewise focus on the FFI boundary as this is consistent with how AOSP projects are developed, how code is shared, and how dependencies are managed. We also present a follow-up analysis with some insights into how the original analysis has held up as Android projects have adopted Rust.Įxisting language interoperability in Android focuses on well defined foreign-function interface (FFI) boundaries, which is where code written in one programming language calls into code written in a different language. This post will cover the analysis we did more than a year ago while we evaluated Rust for use in Android. Adding a new language has costs we needed to demonstrate that Rust would be able to scale across the codebase and meet its potential in order to justify those costs. This means interoperability is the most practical way forward.īefore introducing Rust into the Android Open Source Project (AOSP), we needed to demonstrate that Rust interoperability with C and C++ is sufficient for practical, convenient, and safe use within Android.
As we discussed previously, we have too much C++ to consider ignoring it, rewriting all of it is infeasible, and rewriting older code would likely be counterproductive as the bugs in that code have largely been fixed. To accomplish this, we need to provide the majority of functionality platform developers use. If Rust is to meet its goals of improving security, stability, and quality Android-wide, we need to be able to use Rust anywhere in the codebase that native code is required.
One of the main challenges of evaluating Rust for use within the Android platform was ensuring we could provide sufficient interoperability with our existing codebase. Posted by Joel Galenson and Matthew Maurer, Android Team
0 kommentar(er)
