ALLPCB
JetBrains and RustRover
Recently JetBrains released a Rust IDE called RustRover. JetBrains typically does not create a dedicated IDE for languages that are not widely adopted; they usually provide plugins for existing IDEs such as IntelliJ IDEA or PyCharm.
Rust momentum in frontend tooling
At a recent VueConf, it was announced that Vite's underlying tools esbuild and Rollup will be replaced by implementations rewritten in Rust.
The motivation is performance. Vite is the default build tool for Vue 3, used for development and bundling, similar to webpack. The Vue team considered performance insufficient. A competing tool, Turbopack, is several times faster and is written in Rust.
What is Rust
Rust is a systems programming language originally developed at Mozilla and now maintained by the Rust community. It began as a project by a Mozilla engineer in spare time and grew in popularity after release.
Rust was initially designed with the goal of being a better C++. Many design decisions position Rust as an alternative to C++.
For developers familiar with C++, memory management is often the most troublesome area. In C++ programmers manually allocate and free memory and deal with many pointer-related issues that lead to security risks. One of Rust's main strengths is strong memory safety. It introduces concepts such as ownership, borrowing, and lifetimes to prevent memory leaks, null pointer dereferences, and data races. These checks happen at compile time without runtime overhead.
This safety model also contributes to Rust's learning curve. In languages like Java or Python, code with logical bugs can often compile or run without immediate syntax-level blocking. With Rust, code that has potential memory-safety issues will not compile until the issues are resolved. That strictness can be frustrating for newcomers and leads some learners to give up early.
Ownership example
fn main() { let s1 = String::from("hello"); let s2 = s1; println!("{}, world!", s1); }
This will not compile. The compiler will report that the move occurs because s1 has type String, which does not implement the Copy trait, and that the value is borrowed after move.
let s1 = String::from("hello"); | -- move occurs because `s1` has type `String`, which does not implement the `Copy` trait let s2 = s1; | -- value moved here println!("{}, world!", s1); | ^^ value borrowed here after move
To make this work you can clone s1 instead of moving it:
fn main() { let s1 = String::from("hello"); let s2 = s1.clone(); println!("{}, world!", s1); }
Other notable features
Concurrency support
Concurrency is an important factor when evaluating a language. Writing correct concurrent code is difficult in many languages. Java's concurrency and multithreading APIs have been criticized for being error-prone. Rust's concurrency model is designed to be developer-friendly and safe. It supports lightweight threads and async programming, and its model enforces explicit synchronization to avoid data races. That combination makes concurrent development simpler to reason about and produces high-performance concurrent code.
High performance
Rust targets the same domain as C and C++, and performance is a defining characteristic. Being close to the operating system typically yields higher performance at the cost of greater development complexity.
Key contributors to Rust's performance:
- Memory safety: ownership, borrowing, and lifetimes prevent common memory errors with compile-time checks and minimal runtime cost.
- Concurrency model: lightweight threading and async support let developers write efficient concurrent code, with explicit synchronization to avoid races.
- No runtime overhead: Rust avoids a VM, garbage collection, and unnecessary runtime components, producing compact and efficient machine code.
- Advanced optimizations: the Rust compiler performs strong optimizations and can target specific architectures for maximum performance.
Parts of the Rust toolchain itself are written in C and C++, and coupled with these design choices, Rust delivers strong performance.
Cross-platform
The Rust compiler emits an intermediate representation that is not tied to specific hardware or operating systems. This allows Rust code to target multiple platforms. Rust also evolves quickly; at the time of writing, Rust has frequent releases, which some learners cite as a reason the language has a steep maintenance curve.
Typical use cases
Rust is suitable where performance and safety are required. There is a lighthearted community meme about "rustification," referring to tools being rewritten in Rust.
Rustification laws:
- First law: Any tool that can be rewritten in Rust eventually will be.
- Second law: If a tool is rustified, it usually did not need to be rustified.
- Third law: Everyone wants others to rustify their tools while avoiding rustification of their own.
The earlier example of replacing Vite internals with Rust implementations is driven by performance concerns. Microsoft has also used Rust to rewrite parts of Windows components, citing both performance and security benefits.
Embedded
Rust has minimal runtime overhead, good performance, and supports cross-compilation, making it an attractive choice for embedded development.
Blockchain
Blockchain systems prioritize security. Rust's compile-time safety checks can avoid many memory-safety issues, reducing certain classes of vulnerabilities.
Where to learn Rust
Official site: https://www.rust-lang.org/zh-CN/learn. The Rust website contains detailed tutorials and extensive learning materials.
Google's comprehensive Rust guide: https://google.github.io/comprehensive-rust/zh-CN/index.html. This tutorial, prepared by Google's Android team, proposes an accelerated learning path, with a suggested schedule for a short intensive introduction.
Weekly updates: https://this-week-in-rust.org/ lists weekly changes to Rust, language updates, and major news, which illustrates how active the ecosystem is.
Conclusion
Rust job postings are increasingly common across companies of various sizes. Learning Rust is not solely about finding a job, but the growing number of tools and products being implemented in Rust suggests it is a capable language. Its development experience differs from many other languages, so trying it can be instructive even if you decide not to adopt it for production work.
