0 views collected around this technical thread.
This article explores how Rust’s innovative ownership, borrowing, and type‑driven error handling move memory safety and concurrency checks from runtime to compile time, contrasting its zero‑cost abstractions with C++ and Go, and demonstrating practical code examples that prevent common bugs.
This article explains how Rust's memory safety, concurrency guarantees, explicit error handling, and modern tooling make it a safer and more maintainable alternative to C for developing Linux kernel modules.
The author, a seasoned TypeScript developer, explains why they chose Rust over C/C++, outlines effective learning resources, and compares Rust’s compiler, type system, and memory management to JavaScript/TypeScript, highlighting the language’s performance, safety, and practical benefits for low‑level development.
While Python dominates data analysis and machine learning with its ease of use, Rust offers memory safety and near‑C performance; this article examines their respective strengths, the challenges of rewriting the Python interpreter in Rust, and how combining both can boost library speed and reliability.
The C++ Alliance and engineer Sean Baxter have proposed a “Safe C++” extension, to be submitted to ISO, that introduces memory‑safety checks and a Safe Standard Library with secure data structures, responding to industry and government calls for safer code and echoing DARPA’s Rust‑translation efforts.
An overview of the Safe C++ extension proposal, developed by the C++ Alliance and Sean Baxter, which aims to add memory‑safety features to C++, includes example code, discusses its significance for software security, and references industry and governmental interest in safer programming languages.
The lead maintainer of the Rust for Linux project resigned, citing fatigue from non‑technical disputes, reigniting heated community debates over Rust’s suitability for kernel development, including concerns about API stability, missing C feature support, cultural collaboration issues, and whether to rewrite the kernel in Rust or continue retrofitting.
Rust, a modern systems programming language, offers memory safety without a garbage collector, a powerful ownership model, zero‑cost abstractions, robust error handling, and safe concurrency primitives, making it ideal for high‑performance, reliable software development, as demonstrated through detailed examples and explanations.
Huawei engineer Petr Tesarik submitted a Linux kernel patch that adds SandBox Mode (SBM), an API confining kernel code to predefined memory regions, using hardware paging and CPU privilege levels to isolate components, detect out‑of‑bounds accesses, recover from violations, terminate the sandbox and return error codes such as -EFAULT, enabling continued execution.
Google reports that its ongoing migration of Android's native components from C++ to Rust has reduced memory‑related security bugs, with Rust now powering about 21% of new native code in Android 13 and being used to rewrite critical security modules such as the protected virtual machine firmware.
Creator of C++ Bjarne Stroustrup counters the NSA’s recommendation to replace C/C++ with memory‑safe languages, arguing that modern C++ has evolved with robust safety features, static analysis, and guidelines that can ensure type and resource safety without abandoning the language.
Rust, a compiled, memory‑safe language that enforces ownership and borrowing at compile time, eliminates garbage‑collection overhead, enabling high‑performance front‑end tools like swc and Rome and efficient WebAssembly modules, though its strict rules present a steep learning curve for newcomers.
A memory‑safety vulnerability (CVE‑2022‑38478) affecting Firefox 103, Firefox ESR 102.1 and 91.12 can leak sensitive data and enable arbitrary code execution, and users should upgrade to Firefox 104 or the latest ESR releases to mitigate the issue.
The author, a veteran C/C++ developer, reflects on two months of using Rust, highlighting how Rust's compile‑time safety checks address common memory problems of C languages, the challenges of reproducing runtime bugs, and the trade‑off between longer compile times and more reliable software.
This article introduces the Rust programming language, explains its design principles such as memory safety, ownership, and zero‑cost abstractions, compares it with C++ and JavaScript, and provides practical advice, code examples, and insights on when and how to start learning Rust.
The article, the second in the “From C++ to Rust” series, explains how Rust replaces C++’s return‑value and exception error handling with the Result type, the ? operator, and the thiserror/anyhow crates, and introduces Rust’s lifetime system, borrow checker, elision rules, variance, and common misconceptions for developers transitioning from C++.
Memory Tagging Extension (MTE), introduced in ARM v8.5, tags memory with 4‑bit keys and checks them in hardware via synchronous or asynchronous modes, providing low‑overhead detection of use‑after‑free, overflow and underflow bugs in Android (since 12) and Linux kernels, complementing tools like ASan and KASAN despite a 16‑byte granularity limitation.
The article compares C++ and Rust for developers switching languages, explaining how Rust enforces move semantics instead of copy defaults, uses the safe Option enum with exhaustive pattern matching instead of nullable pointers, and favors lazy, chainable iterators over index‑based loops for performance and safety.
This article explains Rust's ownership model, detailing how values are owned by variables, released when out of scope, and transferred or accessed through cloning, moving, immutable borrowing, and mutable borrowing, with code examples illustrating each rule and the compiler errors they prevent.
This article explains why the PingCAP team selected Rust over Go, C++, and Java for the TiKV storage layer, introduces Rust's core concepts such as ownership, borrowing, lifetimes, and thread safety, and shares practical tips, tooling, and lessons learned from real‑world Rust development.