Tagged articles
memory safety
91 articles · Page 1 of 1

21CTONov 17, 2026 · Fundamentals
A developer reflects on six years of Rust, explaining how its sum types, pattern matching, static dispatch, type-driven development, macros, ownership model, and arena pattern transformed their approach to software design and performance.
Rustarena patternmacros
0 likes · 19 min read


21CTONov 11, 2026 · Information Security
Microsoft's FORGE Lab used AI-driven vulnerability scanning to uncover multiple memory safety defects in Rust's standard library, including an 11-year-old flaw in process::exit that can cause applications to access freed memory, challenging Rust's safety guarantees even in fully safe code.
HyenasMicrosoft FORGE LabRust
0 likes · 9 min read


AntTechOct 29, 2026 · Information Security
Ant Group's research institute introduces KaPilot and KVerus, two LLM-powered agent systems that automate formal verification of Rust code at scale — KaPilot verifies memory safety of Unsafe Rust via Kani model checking, while KVerus proves functional correctness using Verus deductive verification — demonstrated on the Asterinas OS kernel and Rust standard library with 29/29 verification challenges solved and 274 APIs verified.
AI-assisted verificationAsterinas OSKani
0 likes · 14 min read

A concise vector reallocation example demonstrates how C++ permits use-after-free bugs that Rust catches at compile time via borrow checking, then explores ownership, move semantics, and thread-safety differences between the two languages.
C++Rustborrow checker
0 likes · 9 min read

The article details how an enterprise uses govulncheck's symbol-level reachability analysis and a custom AST scanner to identify high-risk CVEs and Go 1.27.1-incompatible unsafe memory patterns in transitive dependencies, preventing a production segmentation fault from a legacy library's hardcoded alignment assumptions.
Go 1.27.1Reachability AnalysisSoftware Composition Analysis
0 likes · 11 min read


21CTOOct 9, 2026 · Industry Insights
Python 3.16 will introduce an optional Rust backend for the zlib module, marking the first Rust code in CPython, with a roadmap to make Rust mandatory by Python 3.18 in 2029, while addressing performance gains, dependency concerns, and success criteria for the Rust for CPython initiative.
CPythonPEP 826PyO3
0 likes · 6 min read


21CTOSep 15, 2026 · Backend Development
CPython maintainers have abandoned plans to make Rust a required dependency, instead pursuing an optional Rust API for internal extensions, with integration targeting Python 3.16 in 2027, addressing platform compatibility, build system differences, and memory safety challenges while adopting Rust's Cargo-inspired tooling like uv.
CPythonCargoPython 3.16
0 likes · 7 min read


21CTOSep 11, 2026 · Industry Insights
Microsoft has officially designated Rust as a Tier-1 programming language alongside C++, C#, and TypeScript, providing full toolchain support and MSVC integration, enabling Rust's use in core services like Microsoft 365 and Azure, and aiming to eliminate memory vulnerabilities in Windows.
AzureInteroperabilityMSVC
0 likes · 8 min read

The article examines curl's long‑standing C implementation, its memory‑safety vulnerabilities, a four‑year effort to replace the libcurl backend with Rust's Hyper that reached 95% completion, and the decision to drop it because maintenance costs, a fragile C‑Rust glue layer, scarce expertise, and mismatched user demand outweighed the benefits.
HyperRustcurl
0 likes · 9 min read

The article contrasts Bun's 11‑day AI‑driven rewrite of 500 k lines of Zig to Rust with Roc's 487‑day manual rewrite of a 300 k‑line Rust compiler to Zig, analyzing the engineering motivations, performance benchmarks, memory‑safety bug counts, and ecosystem trade‑offs that led each team to choose its language.
CompilerRocRust
0 likes · 19 min read


21CTOJul 9, 2026 · Frontend Development
In just 11 days, Bun migrated 1,448 Zig files and over 780,000 lines of code to Rust, achieving 100% test pass, cutting memory usage dramatically, reducing binary size by 20%, improving performance by up to 5%, and demonstrating an AI‑driven, fully automated rewrite that sparked intense community debate.
AI-driven migrationBunRust
0 likes · 12 min read


TonyBaiJul 9, 2026 · Artificial Intelligence
The article details a full‑scale, AI‑driven rewrite of the Bun runtime from Zig to Rust, performed by a single engineer with 64 parallel Claude agents over 11 days, producing over a million lines of Rust code, cutting memory usage, binary size, and improving performance while documenting costs, bugs, and safety reviews.
AI code generationBunClaude
0 likes · 20 min read


21CTOJul 7, 2026 · Fundamentals
The author recounts a multi‑year journey from first discovering Zig, switching to Rust due to stability and ecosystem concerns, and ultimately returning to Zig because of its simplicity, evolving tooling, and a firm stance on LLM usage, while weighing memory‑safety trade‑offs and future prospects.
LLM policyRustZig
0 likes · 11 min read

The Calif security team disclosed the first macOS kernel memory‑corruption vulnerability on Apple’s M5 chip, demonstrating that the flagship Memory Integrity Enforcement (MIE) protection—five years and $5 billion in development—was bypassed in just five days with AI‑assisted assistance.
AI-assisted exploitApple M5Kernel LPE
0 likes · 6 min read

Cloudflare replaced Nginx with its home‑grown Rust‑based proxy Pingora, citing architectural limits of Nginx's worker model, superior performance, lower CPU/memory usage, better connection reuse, richer feature support, and stronger memory safety, all backed by extensive production metrics.
CloudflareHTTP ProxyNginx
0 likes · 14 min read

The article analyzes why Rust is rapidly gaining traction in the AI era, highlighting its dramatic performance gains, built‑in memory safety, AI‑driven code translation, industry‑wide adoption, and the accompanying risks such as steep learning curves and ecosystem gaps.
AIRustindustry trends
0 likes · 13 min read


UbuntuMar 25, 2026 · Information Security
Ubuntu 26.04 will ship sudo‑rs, a Rust‑rewritten replacement for the classic sudo tool, aiming to eliminate decades‑long memory‑safety bugs, simplify maintenance, and provide safer defaults while keeping the familiar command‑line interface for users and administrators alike.
LinuxRustUbuntu 26.04
0 likes · 18 min read

The article examines Go’s claim of eradicating undefined behavior, showing that while the language defines many formerly UB cases such as integer overflow and out‑of‑bounds access, it still harbors UB in concurrent data races, interface type confusion, and certain unspecified behaviors.
ConcurrencyData RaceGo
0 likes · 18 min read

A six‑line C++ lambda caused a $2.3 million loss due to a dangling reference, and after months of debugging the team rewrote the order‑matching engine in Rust, cutting latency by 19 % and eliminating the hidden ‘safety tax’ of memory‑unsafe code.
C++Rustmemory safety
0 likes · 7 min read

The article explains CVE‑2025‑68260, the first Rust‑based vulnerability in the Linux kernel, detailing the race condition in the rust_binder driver, why the bug proves Rust’s safety promises, and how its limited impact contrasts with countless C‑related kernel CVEs.
CVEConcurrencyLinux kernel
0 likes · 7 min read


21CTOJan 7, 2026 · Fundamentals
Steve Klabnik, a veteran of Rust and Ruby on Rails, explores a new system programming language called Rue that aims for memory safety without garbage collection, leveraging Anthropic’s Claude AI for rapid development and discussing its design trade‑offs, progress, and future prospects.
ClaudeLLMRust
0 likes · 8 min read


21CTODec 13, 2025 · Fundamentals
At recent Linux kernel maintainer meetings, developers announced that Rust has shed its experimental label and become a permanent, core component of the Linux kernel, highlighting its growing maturity, production use, and the remaining challenges for full integration.
Linux kernelSystems Programmingmemory safety
0 likes · 4 min read


21CTODec 11, 2025 · Backend Development
PythonC lets developers write type‑annotated Python that is compiled into efficient C code, offering features beyond Cython such as compile‑time code generation, independent executable creation, and advanced memory‑safety mechanisms.
C compilationPythonCcode generation
0 likes · 9 min read


21CTODec 4, 2025 · Information Security
Ferrocene, an open‑source Rust compiler toolchain, has achieved IEC 61508 SIL 2 certification for its core library, highlighting Rust’s growing role in memory‑safe, safety‑critical embedded devices and outlining the implications of SIL levels, certification bodies, and real‑world industrial use cases.
FerroceneIEC 61508Rust
0 likes · 5 min read


21CTOSep 29, 2025 · Fundamentals
Apple is quietly rewriting core parts of iOS using a new, Rust‑inspired system language—offering better memory safety and performance—while keeping the change hidden from most developers and outlining a phased migration strategy for critical subsystems.
AppleRustiOS
0 likes · 7 min read

In an interview, Vivo’s BlueOS team explains why they built their operating system with Rust, detailing the language’s safety and performance benefits, the challenges of adoption, the measurable gains in reliability and maintenance, and the learning curve developers faced.
BlueOSRustSystem Programming
0 likes · 11 min read

This article explains Rust’s core borrowing rules—allowing any number of immutable references, permitting only one mutable reference, and forbidding their coexistence—detailing the concept of lifetimes, providing code examples for each rule, and highlighting the safety benefits for concurrent programming.
borrowinglifetimesmemory safety
0 likes · 6 min read

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.
RustZero-Cost Abstractionserror handling
0 likes · 10 min read


21CTOMay 3, 2025 · Information Security
A Dutch consultancy’s experiment shows that Rust’s memory‑safety guarantees and rigorous testing can prevent critical DNS‑related vulnerabilities in billions of devices, delivering faster development and more reliable code compared to unsafe C implementations.
C languageSystems Programmingmemory safety
0 likes · 10 min read


21CTOFeb 22, 2025 · R&D Management
The Linux kernel community is wrestling with the integration of Rust, as senior developers argue for its memory‑safety benefits while some maintainers fear added maintenance burden, revealing a broader policy clash over language diversity in core OS development.
Rustkernel-developmentmemory safety
0 likes · 9 min read


21CTOFeb 10, 2025 · Backend Development
The Linux kernel community is embroiled in a heated debate as Linus Torvalds rejects Rust‑based device driver patches, citing concerns over process, social‑media backlash, and the added complexity of mixing Rust with the traditionally C‑centric kernel code.
Linus TorvaldsRustdevice drivers
0 likes · 6 min read


21CTOJan 6, 2025 · Information Security
Researchers from Inria and Microsoft have devised a method to automatically translate a subset of C code, called Mini‑C, into memory‑safe Rust, using the KaRaMeL compiler framework, demonstrating comparable performance on cryptographic libraries while reducing vulnerability risks.
C++KaRaMeLRust
0 likes · 6 min read


21CTODec 16, 2024 · Backend Development
After building sizable projects in Go, Zig, and Rust, the author compares their performance, safety, ecosystem, and developer experience, ultimately concluding that Rust’s ownership model and compile‑time guarantees make it the superior choice for backend engineers despite Go’s speed and Zig’s simplicity.
BackendLanguage comparisonZig
0 likes · 8 min read


21CTODec 12, 2024 · Information Security
Google's research shows that adding boundary checks to its C++ codebase can automatically fix thousands of CVE‑related memory bugs, cut production crash rates by 30%, and improve performance with only a 0.3% overhead, sparking a broad community discussion on safe legacy code.
C++CompilerLLVM
0 likes · 9 min read

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.
CompilerRustSystems Programming
0 likes · 8 min read


21CTONov 17, 2024 · Fundamentals
Herb Sutter, ISO C++ chair and former Microsoft veteran, announced at CppCon that the upcoming C++26 standard will introduce four major features—enhanced std::execution, stronger type and memory safety, powerful reflection and code generation, and contracts—aimed at boosting concurrency, safety, and compile‑time programming.
C++C++26Contracts
0 likes · 5 min read

US agencies CISA and FBI have issued a hard‑line directive urging software vendors to abandon non‑memory‑safe languages like C/C++ for critical infrastructure, mandating a clear migration roadmap by Jan 1 2026, while industry leaders debate the practicality and costs of such a shift.
C languageC++government policy
0 likes · 11 min read


21CTONov 5, 2024 · Fundamentals
The article examines the Safe C++ proposal—a collaborative effort by Sean Baxter and Christian Mazakas to add Rust‑inspired ownership and borrowing checks to C++ through a safe standard library—while discussing its 18‑month development timeline, toolchain extensions, community reactions, and broader implications for memory‑safe programming.
C++RustSafe C++
0 likes · 11 min read


21CTONov 1, 2024 · Information Security
The U.S. CISA and FBI have issued a stern warning to software vendors, demanding the elimination of unsafe coding practices—especially the use of memory‑unsafe languages like C/C++—by January 1 2026, or risk being labeled negligent and jeopardizing national security.
CISAmemory safetyopen-source
0 likes · 8 min read

This article explores the challenges of memory safety in Android, explains the design and core mechanisms of ARM's Memory Tagging Extension (MTE), and details its hardware, compiler, kernel, and user‑space implementations, deployment options, and advantages over other memory‑protection techniques.
ARM ArchitectureAndroid SecurityMTE
0 likes · 23 min read


21CTOOct 16, 2024 · Information Security
Amid rising memory‑safety concerns highlighted by Chrome’s vulnerabilities and high‑profile attacks, the C++ community proposes a Safe C++ Extension to add memory‑safety features, while experts compare it to Rust and discuss challenges, adoption pressures, and DARPA’s AI‑driven code‑conversion efforts.
C++Rustinformation security
0 likes · 6 min read

This article explores Rust’s origins, its superior memory safety and concurrency, demonstrates how replacing JavaScript‑based Vite with Rust‑based Rsbuild can cut build times from minutes to seconds, and delves into Rust’s ownership, borrowing, lifetimes, error handling, and its growing role in frontend tooling and frameworks.
Build ToolsRustmemory safety
0 likes · 26 min read

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.
PythonRustdata science
0 likes · 6 min read

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.
C++Safe C++Standard Proposal
0 likes · 5 min read

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.
C++ISO standardSafe C++
0 likes · 5 min read


21CTOSep 21, 2024 · Fundamentals
The C++ community has unveiled a groundbreaking “Safe C++ Extensions” proposal that borrows Rust’s borrow‑checking and initialization analysis to add memory‑safety features, sparking debate over its impact on C++’s identity while addressing industry demand for safer code.
C++language designmemory safety
0 likes · 3 min read


21CTOSep 9, 2024 · Information Security
Google has rebuilt the protected virtual‑machine firmware of its Android virtualization framework in Rust, highlighting the language’s safety benefits, productivity gains, and the broader push from both industry and the U.S. government to eliminate memory‑safety bugs in critical software.
AndroidGoogleembedded systems
0 likes · 5 min read


21CTOAug 22, 2024 · Fundamentals
This article traces Rust’s origin from Graydon Hoare’s personal frustration with buggy elevators to its rise as a memory‑safe, high‑performance language adopted by major tech companies, highlighting its design principles, community culture, and impact on modern software development.
Concurrencymemory safety
0 likes · 16 min read

The article examines DARPA's TRACTOR project, which aims to use large‑language‑model AI to automatically translate legacy C and C++ code into safe Rust, discusses the memory‑safety motivations, technical challenges, community reactions, and the broader push by US agencies to abandon unsafe languages.
AIC++DARPA
0 likes · 11 min read


21CTOJul 24, 2024 · Information Security
The article examines the recent Windows BSOD crisis caused by a faulty CrowdStrike update, argues that memory‑unsafe languages like C/C++ contributed to the failure, and explains how Microsoft and the industry are turning to the memory‑safe Rust language for system, firmware, and cloud components to improve reliability and security.
AzureSystem Programmingmemory safety
0 likes · 8 min read


21CTOJun 25, 2024 · Backend Development
Google’s Android engineering director revealed that migrating services from Go or C++ to Rust doubled productivity, slashed memory consumption, lowered defect rates, and boosted developer confidence, highlighting a broader industry move toward memory‑safe languages.
C++memory safetysoftware migration
0 likes · 4 min read


21CTOJun 4, 2024 · Information Security
The article offers a comprehensive analysis of memory‑safety concerns, weighing the economic, technical, and practical factors that influence whether developers should replace C/C++ with safer languages like Rust, and explains why the decision is far more complex than a straightforward security upgrade.
C++ vs RustSystem Programminglanguage adoption
0 likes · 52 min read

This article explains Go's pointer model, why the language forbids generating pointers from non‑pointer values, how garbage collection and memory compaction cause object addresses to change at runtime, and provides best practices and code examples for safely using pointers in Go programs.
Gogarbage collectionmemory safety
0 likes · 5 min read

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.
RustSystems Programmingmemory safety
0 likes · 8 min read

The April TIOBE Index shows Python gaining market share while C and C++ lose ground due to memory‑safety concerns, PHP slipping to historic lows, and a broader shift in developer preferences driven by AI, web frameworks, and security considerations.
C++C++Programming Language Popularity
0 likes · 7 min read


21CTOApr 8, 2024 · Fundamentals
This article explains how Rust’s built‑in language features—such as immutable defaults, ownership, borrowing, lifetimes, and compile‑time checks—provide memory safety that C, C++, and many managed languages lack, while also discussing the trade‑offs and ecosystem support.
Programming LanguageSystems Programmingmemory safety
0 likes · 10 min read


21CTOMar 23, 2024 · Information Security
Amid a US government report urging developers to abandon C and C++ for memory‑safe languages, C++ creator Bjarne Stroustrup argues that modern C++ already incorporates strong safety guarantees, cites ongoing standards work, and warns that abandoning the language overlooks its evolving security features.
Bjarne StroustrupC++memory safety
0 likes · 6 min read

The White House Office of the National Cyber Director released a 19‑page report urging developers to adopt memory‑safe programming languages, citing the security risks of C and C++ and calling for both software and hardware improvements to reduce attack surfaces and improve software measurability.
C++NSAONCD
0 likes · 12 min read


21CTOFeb 29, 2024 · Information Security
The White House’s ONCD report urges developers to replace C and C++ with memory‑safe languages like Rust, Go, and Java, citing alarming vulnerability statistics and a strategic shift that moves software‑security responsibility from individuals to large organizations and the federal government.
C++Rustgovernment policy
0 likes · 8 min read

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.
Linux kernelhardware isolationmemory safety
0 likes · 2 min read

This article explains the concept of memory safety, details Rust’s unique ownership and borrowing mechanisms that enforce safety at compile time, compares them with the inherent risks of manual memory management in C and C++, and highlights why Rust is increasingly favored for secure system development.
C++ ComparisonRustmemory safety
0 likes · 10 min read


ITPUBDec 11, 2023 · Backend Development
This article compares Go and Rust across performance, concurrency, memory safety, development speed, and developer experience, highlighting each language's strengths and weaknesses to help developers decide which language best fits their specific project requirements in 2024.
ConcurrencyGoLanguage comparison
0 likes · 12 min read

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.
AndroidRustU-Boot
0 likes · 4 min read


21CTOJun 27, 2023 · Fundamentals
The article explores how Rust's memory‑safety and efficiency are driving major companies like Microsoft, Google, and Amazon to rewrite operating‑system components and cloud services, while also tracing Rust’s quirky origins, rapid rise in popularity, and the challenges it still faces.
AndroidLinux kernelRust
0 likes · 10 min read


21CTOMay 12, 2023 · Fundamentals
Microsoft has begun replacing parts of the Windows 11 kernel with Rust, adding around 36,000 lines of memory‑safe code that have passed boot tests, with the Win32k.sys driver now available in Insider builds, promising no performance loss and even speed gains over C++.
RustWin32k.sysWindows 11
0 likes · 3 min read


21CTOFeb 7, 2023 · Information Security
At the end of 2022 the NSA warned that C and C++ are unsafe and urged a shift to languages like Rust or Go, but Bjarne Stroustrup counters that modern C++ offers robust static analysis, type and resource safety, and that the agency’s view overlooks these advances.
C++memory safetyprogramming languages
0 likes · 6 min read

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.
C++Programming Language Safetymemory safety
0 likes · 5 min read


21CTOJan 14, 2023 · Information Security
Google's Chrome security team announced that Chromium will soon support third‑party Rust libraries, aiming to simplify development, reduce memory‑safety bugs, and enhance overall browser security by integrating safer Rust code into Chrome binaries.
ChromeChromiumRust
0 likes · 6 min read


21CTODec 30, 2022 · Frontend Development
This article explores how Rust’s safety, performance, and WebAssembly integration make it a compelling option for modern frontend development, highlighting industry insights, real‑world use cases, and the language’s growing popularity among developers.
Frontend DevelopmentRustWebAssembly
0 likes · 5 min read


21CTODec 7, 2022 · Mobile Development
Google’s shift to Rust for Android development has dramatically cut memory‑safety bugs, dropping from 223 incidents in 2019 to 85 in 2022, and reducing the share of such vulnerabilities from 76% to 35%, highlighting Rust’s growing role in mobile security.
AndroidRustmemory safety
0 likes · 3 min read


21CTOOct 13, 2022 · Fundamentals
This article explores Rust's rise in systems programming, detailing its strengths such as safe concurrency, modern language design, and strong compiler feedback, while also highlighting challenges like a steep learning curve, complex async model, and low‑level memory management concerns.
ConcurrencyRustSystems Programming
0 likes · 10 min read

This article examines Rust's rapid rise, its safety‑focused design versus C/C++'s speed emphasis, real‑world adoption by major tech firms, and the ongoing debate about whether Rust can eventually supplant C and C++ for system‑level development.
ConcurrencySystems Programmingc++
0 likes · 9 min read


21CTOSep 22, 2022 · Fundamentals
Microsoft Azure CTO Mark Russinovich argues that C and C++ should be retired for new projects in favor of Rust, highlighting memory‑safety benefits, industry adoption challenges, and responses from language creators, while examining the broader impact on system software development.
C++Rustmemory safety
0 likes · 7 min read


21CTOSep 20, 2022 · Fundamentals
Microsoft engineer Nick Cameron outlines the ten biggest governance, ecosystem, and technical challenges Rust must overcome in the coming years, offering insight into community dynamics, crate management, async support, language usability, memory safety, compiler complexity, and macro design.
CompilerProgramming LanguageRust
0 likes · 11 min read

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.
Programming LanguageRustWasm
0 likes · 21 min read

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.
CVE-2022-38478Firefoxmemory safety
0 likes · 3 min read


21CTOAug 24, 2022 · Fundamentals
An interview with Rust creator Graydon Hoare explores the language's origins, its emphasis on speed, memory safety and concurrency, its adoption by major tech firms, and his perspective on the current state and future challenges of system programming security.
ConcurrencyRustSystem Programming
0 likes · 6 min read

This article explains the core algorithms behind AddressSanitizer, covering its shadow memory mapping, instrumentation module, runtime library, poisoned redzones, false‑negative scenarios, configurable flags, and emerging hardware‑assisted designs for memory‑error detection.
C++Runtime Instrumentationaddresssanitizer
0 likes · 15 min read

This article introduces Google’s Sanitizers suite for detecting C/C++ memory errors, reviews essential memory concepts and C++ standards, compares compiler support, and explains why these tools are crucial for improving security and productivity in large‑scale C++ projects such as NetEase Cloud IM.
C++Compiler SupportSanitizers
0 likes · 9 min read


21CTOJun 28, 2022 · Fundamentals
Linus Torvalds hints at integrating Rust into the upcoming Linux 5.20 kernel, outlining the language's safety benefits, development timeline, and the broader impact on kernel architecture while emphasizing that a full rewrite is not planned.
LinuxRustkernel-development
0 likes · 5 min read

This article introduces Rust to front‑end developers, covering its origins, safety‑focused design, key language features such as ownership and borrowing, core data types, structs, enums, and practical code examples to help readers grasp why Rust is worth learning.
Programming LanguageRustdata types
0 likes · 6 min read

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.
Compile-time ChecksRustc++
0 likes · 9 min read

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.
GenericsProgramming LanguageRust
0 likes · 27 min read

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++.
C++Result TypeRust
0 likes · 19 min read

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.
ARMAndroidMTE
0 likes · 10 min read

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.
C++Rustiterator
0 likes · 15 min read


21CTOMar 24, 2021 · Fundamentals
The article examines how Rust is entering the Linux ecosystem, detailing discussions between Linus Torvalds and Greg Kroah‑Hartman, the motivations for using Rust in kernel development, and the potential impact on safety and driver programming.
Linux kernelRustSystems Programming
0 likes · 6 min read

A PLDI'20 study of open‑source Rust projects shows that while Rust’s safe code effectively prevents most memory errors, many bugs still stem from unsafe blocks, and even safe code can suffer thread‑safety issues, highlighting the need for better tooling and developer awareness.
RustUnsafememory safety
0 likes · 14 min read

This article examines Rust’s performance advantages over C++ and Go through benchmark tests on prime number calculations, binary size, runtime speed, memory and CPU usage, and explains Rust’s ownership, borrowing, lifetimes, and concurrency model that provide memory safety without sacrificing efficiency.
ConcurrencyRustmemory safety
0 likes · 26 min read


ITPUBDec 6, 2017 · Information Security
MesaLock Linux is an open‑source Linux distribution that rewrites user‑space applications in memory‑safe languages like Rust and Go, applying three security principles to reduce attack surface, offering container‑ready images, BSD licensing, and community‑driven development.
GoLinuxRust
0 likes · 6 min read

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.
RustSystems ProgrammingTiKV
0 likes · 19 min read
