# Memory Safety

Memory safety is a property of programming languages that prevents certain bugs related to how memory is used, including security vulnerabilities such as out-of-bounds access and use-after-free.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Swift 6.4 Released

DevFeed: [Swift 6.4 Released](<https://devfeed.tech/articles/swift-6-4-released-26971.md>)

Original publisher: [Read original article](<https://swift.org/blog/swift-6.4-released/>)

Author: Holly Borla

Published: 2026-09-15T07:30:00Z

Content type: release

Language: en

Sources: [Swift.org](<https://devfeed.tech/sources/swift-org.md>)

Topics: [Swift](<https://devfeed.tech/topics/swift.md>), [cross-platform](<https://devfeed.tech/topics/cross-platform.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [WebAssembly](<https://devfeed.tech/topics/web-assembly.md>), [browser](<https://devfeed.tech/topics/browser.md>), [Microcontroller](<https://devfeed.tech/topics/microcontroller.md>)

Tags: [cross-platform](<https://devfeed.tech/tags/cross-platform.md>), [errors](<https://devfeed.tech/tags/errors.md>), [libraries](<https://devfeed.tech/tags/libraries.md>), [linux](<https://devfeed.tech/tags/linux.md>), [macos](<https://devfeed.tech/tags/macos.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [programming](<https://devfeed.tech/tags/programming.md>), [swift](<https://devfeed.tech/tags/swift.md>), [webassembly](<https://devfeed.tech/tags/webassembly.md>)

### AI overview

Swift 6.4 is now available with Swift Build as the default in Swift Package Manager, a stable cross-platform Subprocess API, expanded C++20 and Java interoperability, faster WebAssembly support, broader embedded Swift capabilities, and performance improvements that maintain memory safety.

### Source excerpt

Swift 6.4 is now available. Swift aims to be a great choice across the stack, from apps and servers to systems code, embedded devices, and the browser. This release deepens that support, and makes everyday code easier to write. Highlights include: Swift Build is now the default in Swift Package Manager, so your projects build the same way on Linux, macOS, and Windows. Subprocess reaches 1.0, a stable, cross-platform way to run and interact with other programs from Swift, from command-line tools to streaming processes. Interoperability reaches further, with Swift's Span now bridging directly with C++20's std::span, and Swift/Java interop extending its async and callback support. Swift runs faster in the browser, with WebAssembly bridging through JavaScriptKit up to 40 times faster, and the Wasm SDK available directly from Swift.org. Embedded Swift grows more capable, with support for existential types and richer error handling for microcontroller-class targets. Performance improves while maintaining memory safety, with new array types that hold non-copyable elements without copy-on-write overhead, and the new Iterable protocol for iterating without copies. There's so much more. Read on for a detailed guide to the new changes, or see the Swift Evolution dashboard for the full list of proposals in Swift 6.4. Simpler and clearer code Swift 6.4 streamlines your day-to-day programming to make your code simpler and clearer. More natural optional some and any types. When writing an optional some or any type, you no longer have to wrap the type in parentheses. Instead of (some Rocket)?, you can simply write some Rocket? (SE-0521). Source-level control over compiler warnings. When you need to control the behavior of warnings in your project, such as suppressing warnings or promoting them to errors, you can now define the warning behavior directly in your code using the new @diagnose attribute (SE-0522). Clarify which API to use when multiple libraries conflict. When multiple

## Rust-proof your code with our new Testing Handbook chapter

DevFeed: [Rust-proof your code with our new Testing Handbook chapter](<https://devfeed.tech/articles/rust-proof-your-code-with-our-new-testing-handbook-chapter-7658.md>)

Original publisher: [Read original article](<https://blog.trailofbits.com/2026/07/13/rust-proof-your-code-with-our-new-testing-handbook-chapter/>)

Author: "Paweł Płatek"

Published: 2026-07-13T11:00:00Z

Content type: tutorial

Language: en

Sources: [The Trail of Bits Blog](<https://devfeed.tech/sources/the-trail-of-bits-blog.md>), [The Trail of Bits Blog](<https://devfeed.tech/sources/the-trail-of-bits-blog-2.md>)

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [Security](<https://devfeed.tech/topics/security.md>), [mutation-testing](<https://devfeed.tech/topics/mutation-testing.md>), [Tooling](<https://devfeed.tech/topics/tooling.md>), [Test coverage](<https://devfeed.tech/topics/coverage.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [Rust formal verification](<https://devfeed.tech/topics/rust-formal-verification.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Claude Code](<https://devfeed.tech/topics/claude-code.md>), [Claude](<https://devfeed.tech/topics/claude.md>)

Tags: [application-security](<https://devfeed.tech/tags/application-security.md>), [claude-code](<https://devfeed.tech/tags/claude-code.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [measurement](<https://devfeed.tech/tags/measurement.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [mutation-testing](<https://devfeed.tech/tags/mutation-testing.md>), [rust](<https://devfeed.tech/tags/rust.md>), [security](<https://devfeed.tech/tags/security.md>), [testing](<https://devfeed.tech/tags/testing.md>), [testing-handbook](<https://devfeed.tech/tags/testing-handbook.md>), [tooling](<https://devfeed.tech/tags/tooling.md>)

### AI overview

A new Testing Handbook chapter presents techniques for security testing Rust programs and systems. It covers Rust security limitations, dynamic and static analysis, undefined-behavior detection with Miri, property testing, coverage and mutation testing, Clippy, manual code review, memory zeroization, model checking with Kani, and dependency supply-chain vetting. The article also announces rust-review, a Claude Code plugin for automated Rust security reviews.

### Source excerpt

We've added a new chapter to our Testing Handbook: a comprehensive guide to security testing Rust programs. This chapter covers the tools and techniques we use at Trail of Bits to validate the security of Rust programs and systems. fn main() {(|f:&dyn Fn(u128)->Box< dyn Iterator<Item= char>+'static>|f(*[&( 0x7B736D70683F73u128<<64| 0x7A6A6D7C3F7A667D),&(0x7B736Du128 <<64|0x70683F7073737A77)][((std::hint:: black_box(0.0f64)/0.0).to_bits()>>63)as usize]) .for_each(|c|print!("{c}")))(Box::leak(Box::new(|n: u128|Box::new(std::iter::successors(Some(n),|&n|Some(n>>8) ).take_while(|&n|n>0).map(|n|((n as u8)^0x1F)as char))as _)))} What's in the chapter The chapter starts with a security overview of what Rust's guarantees do and don't cover, including underappreciated issues like unwind safety, nondeterminism, and arithmetic errors. This leads into an overview of dynamic analysis, which covers a range of boosters for unit tests, how to use Miri to detect undefined behavior, property testing with proptest, coverage measurement, and mutation testing. The static analysis section then covers Clippy in depth, including a list of our favorite lints. Beyond tooling, the chapter also covers what we've learned from auditing Rust codebases directly. Our gotchas and footguns checklist is a great reference for manual code reviews, and will help you find subtle issues like a & b == c having different operator precedence than in C. The memory zeroization section offers three solutions to the tricky problem of guaranteeing that secrets are erased from memory. Finally, the specialized testing sections cover tools like Kani (a model checker), and the supply chain section covers the full toolchain for vetting dependencies. Still oxidizing We've also released rust-review, a Claude Code plugin for automated Rust security reviews. Co-built with Aptos Labs, it targets over a dozen bug classes, from memory safety and concurrency hazards to FFI pitfalls and async cancellation issues. It's a fast wa

## May in Servo: user scripts, mp4 compat, blackboxing in DevTools, and more!

DevFeed: [May in Servo: user scripts, mp4 compat, blackboxing in DevTools, and more!](<https://devfeed.tech/articles/may-in-servo-user-scripts-mp4-compat-blackboxing-in-devtools-and-more-3545.md>)

Original publisher: [Read original article](<https://servo.org/blog/2026/06/30/may-in-servo/>)

Author: The Servo Project Developers

Published: 2026-06-30T00:00:00Z

Content type: release

Language: en

Sources: [Servo Blog](<https://devfeed.tech/sources/servo-blog.md>)

Topics: [servo](<https://devfeed.tech/topics/servo.md>), [Web platform](<https://devfeed.tech/topics/web-platform.md>), [Document Object Model (DOM)](<https://devfeed.tech/topics/dom.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [API](<https://devfeed.tech/topics/api.md>), [Security](<https://devfeed.tech/topics/security.md>), [Forms](<https://devfeed.tech/topics/forms.md>), [Accessibility](<https://devfeed.tech/topics/accessibility.md>), [Nix](<https://devfeed.tech/topics/nix.md>), [webgpu](<https://devfeed.tech/topics/webgpu.md>)

Tags: [developers](<https://devfeed.tech/tags/developers.md>), [forms](<https://devfeed.tech/tags/forms.md>), [html](<https://devfeed.tech/tags/html.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [release](<https://devfeed.tech/tags/release.md>), [rust](<https://devfeed.tech/tags/rust.md>), [security](<https://devfeed.tech/tags/security.md>), [servo](<https://devfeed.tech/tags/servo.md>), [servo-engine](<https://devfeed.tech/tags/servo-engine.md>), [servo-rendering-engine](<https://devfeed.tech/tags/servo-rendering-engine.md>), [web-browser](<https://devfeed.tech/tags/web-browser.md>), [web-browser-engine](<https://devfeed.tech/tags/web-browser-engine.md>), [web-engine](<https://devfeed.tech/tags/web-engine.md>), [web-platform](<https://devfeed.tech/tags/web-platform.md>), [web-rendering-engine](<https://devfeed.tech/tags/web-rendering-engine.md>), [webgpu](<https://devfeed.tech/tags/webgpu.md>), [windows](<https://devfeed.tech/tags/windows.md>)

### AI overview

Servo 0.3.0 summarizes 391 commits made in May, adding web platform and DOM API support, improving forms and media compatibility, and fixing build issues on Windows, FreeBSD, and Nix environments. The release also includes memory safety fixes through a SpiderMonkey update, experimental Sanitizer improvements, IndexedDB changes, DevTools work, and ongoing WebGPU, accessibility, and performance development.

### Source excerpt

Servo 0.3.0 contains all of the changes we landed in May, which came out to 391 commits (April: 534). For security fixes, see § Security. We've shipped several new web platform features: 'font-kerning: none' (@simonwuelker, #44634) 'font-variant-east-asian' (@simonwuelker, #44989) 'font-variant-ligatures' (@simonwuelker, #44903) 'font-variant-numeric' (@simonwuelker, #44950) 'font-variant-position' (@simonwuelker, #45142) mp4 files without fast start in <video> (@calvaris, #45084) <form enctype="multipart/form-data"> (@yezhizhen, #45028) <form enctype="text/plain"> (@yezhizhen, #45111) <![CDATA[]]> layout (@mrobinson, #44791) Plus a bunch of new DOM APIs: onslotchange property on ShadowRoot (@jdm, #44688) screenLeft and screenTop on Window (@TG199, #45128) new Blob() with {endings: "native"} (@yezhizhen, #44803) new PerformanceMark() (@shubhamg13, #44702) parseHTML() on Document (@kkoyung, #44952) readAsBinaryString() on FileReader (@yezhizhen, #44858, #44921) performance.measure() with mark values 'redirectStart', 'redirectEnd', 'secureConnectionStart', and 'responseEnd' (@shubhamg13, #44673, #44624, #44850, #44739) We've also fixed some build issues on Windows (@mukilan, #45079), FreeBSD (@delan, @mrobinson, @mukilan, #44600), and for anyone building Servo on NixOS or with Nix (@freyacodes, #45051, #45135). This is another big update, so here's an outline: Security - memory safety fixes Work in progress - execCommand(), Sanitizer, IndexedDB, accessibility, workers Embedding API - MSRV, cookies, preferences, diagnostics For users and developers - --host-file, --userscripts, DevTools Debugger More on the web platform - focus, forms, navigation, SubtleCrypto, WebGPU Performance - about:memory, threads, layout, DOM, build times Stability - crashes, hangs, static analysis Security Servo's JS runtime, SpiderMonkey 140.10.0, had several memory safety bugs that have been fixed in Servo 0.3.0 with the update to SpiderMonkey 140.10.1 (@jschwe, #44755). For mor

## Swift at Apple: Migrating the TrueType Hinting Interpreter

DevFeed: [Swift at Apple: Migrating the TrueType Hinting Interpreter](<https://devfeed.tech/articles/swift-at-apple-migrating-the-truetype-hinting-interpreter-2932.md>)

Original publisher: [Read original article](<https://swift.org/blog/migrating-truetype-hinting-to-swift/>)

Author: Scott Perry

Published: 2026-06-12T10:00:00Z

Content type: article

Language: en

Sources: [Swift.org](<https://devfeed.tech/sources/swift-org.md>)

Topics: [Swift](<https://devfeed.tech/topics/swift.md>), [Font](<https://devfeed.tech/topics/font.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [Security](<https://devfeed.tech/topics/security.md>), [Memory safety verification](<https://devfeed.tech/topics/memory-safety-verification.md>), [Web](<https://devfeed.tech/topics/web.md>), [pdf](<https://devfeed.tech/topics/pdf.md>)

Tags: [apple](<https://devfeed.tech/tags/apple.md>), [applications](<https://devfeed.tech/tags/applications.md>), [code](<https://devfeed.tech/tags/code.md>), [fonts](<https://devfeed.tech/tags/fonts.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [performance](<https://devfeed.tech/tags/performance.md>), [security](<https://devfeed.tech/tags/security.md>), [swift](<https://devfeed.tech/tags/swift.md>), [web](<https://devfeed.tech/tags/web.md>)

### AI overview

Apple describes rewriting its TrueType hinting interpreter from C to memory-safe Swift for Fall 2025 releases. The rewrite addresses the security risks of processing untrusted fonts and reportedly improves performance by 13% on average.

### Source excerpt

TrueType is a widely used vector font standard for rendering text in web pages, PDFs, operating systems, and applications. Familiar fonts like Helvetica, Garamond, and Monaco are all built on TrueType outlines. The format specifies a hinting interpreter intended to help outlines rasterize faithfully on low-resolution displays. Modern high-resolution displays enable beautiful typography from outlines alone, but TrueType fonts that need hinting to render legibly remain in use and we continue to support them. Font parsers process data from untrusted sources, making the TrueType hinting interpreter a security-critical attack surface. To make the format more resilient on Apple platforms, we rewrote its hinting interpreter from C to memory-safe Swift for the Fall 2025 releases. In addition to memory safety, we also improved performance: on average, our Swift interpreter runs 13% faster than the C interpreter it replaced. To accompany this post, we've also published the source code of the Swift TrueType hinting interpreter. We hope sharing our experience helps others doing similar work in Swift. TrueType and the hinting engine Apple developed TrueType in the late 1980s and released it with the launch of System 7 in 1991. TrueType was a major breakthrough for the time: it gave font developers enormous control over how glyphs are displayed, with an advanced grid-fitting algorithm and a sophisticated hinting engine built around a special-purpose bytecode interpreter. TrueType did all this on computers that were vastly less powerful than today's, so it had to be extremely well-tuned for performance. Then the internet revolutionized how fonts were used. TrueType became embeddable in PDF files in 1994 and in web pages in 2008, and it remains as relevant as ever. However, these new use cases brought additional risk: TrueType could now be exposed to untrusted fonts from anywhere on the internet. TrueType fonts may contain programs the hinting engine runs through a bytecode interpr

## We beat Google's zero-knowledge proof of quantum cryptanalysis

DevFeed: [We beat Google's zero-knowledge proof of quantum cryptanalysis](<https://devfeed.tech/articles/we-beat-google-s-zero-knowledge-proof-of-quantum-cryptanalysis-7646.md>)

Original publisher: [Read original article](<https://blog.trailofbits.com/2026/04/17/we-beat-googles-zero-knowledge-proof-of-quantum-cryptanalysis/>)

Author: "Keegan Ryan"

Published: 2026-04-17T11:00:00Z

Content type: article

Language: en

Sources: [The Trail of Bits Blog](<https://devfeed.tech/sources/the-trail-of-bits-blog.md>), [The Trail of Bits Blog](<https://devfeed.tech/sources/the-trail-of-bits-blog-2.md>)

Topics: [Zero-knowledge proof](<https://devfeed.tech/topics/zkp.md>), [Cryptography](<https://devfeed.tech/topics/cryptography.md>), [Google](<https://devfeed.tech/topics/google.md>), [Vulnerabilities](<https://devfeed.tech/topics/vulnerabilities.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [Rust](<https://devfeed.tech/topics/rust.md>), [Code](<https://devfeed.tech/topics/code.md>), [Ethereum](<https://devfeed.tech/topics/ethereum.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [cryptography](<https://devfeed.tech/tags/cryptography.md>), [google](<https://devfeed.tech/tags/google.md>), [memory](<https://devfeed.tech/tags/memory.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [quantum](<https://devfeed.tech/tags/quantum.md>), [rust](<https://devfeed.tech/tags/rust.md>), [vulnerabilities](<https://devfeed.tech/tags/vulnerabilities.md>), [zero-knowledge](<https://devfeed.tech/tags/zero-knowledge.md>)

### AI overview

Trail of Bits presents a zero-knowledge proof that improves on Google's reported resource bounds for quantum circuits. The article attributes the result to memory-safety and logic vulnerabilities in Google's Rust prover code, explains the zkVM-based proof setup, and describes the released proof-forging code.

### Source excerpt

Two weeks ago, Google's Quantum AI group published a zero-knowledge proof of a quantum circuit so optimized, they concluded that first-generation quantum computers will break elliptic curve cryptography keys in as little as 9 minutes. Today, Trail of Bits is publishing our own zero-knowledge proof that significantly improves Google's on all metrics. Our result is not due to some quantum breakthrough, but rather the exploitation of multiple subtle memory safety and logic vulnerabilities in Google's Rust prover code. Google has patched their proof, and their scientific claims are unaffected, but this story reflects the unique attack surface that systems introduce when they use zero-knowledge proofs. Google's proof uses a zero-knowledge virtual machine (zkVM) to calculate the cost of a quantum circuit on three key metrics. The total number of operations and Toffoli gate count represent the running time of the circuit, and the number of qubits represents the memory requirements. Google, along with their coauthors from UC Berkeley, the Ethereum Foundation, and Stanford, published proofs for two circuits; one minimizes the number of gates, and the other minimizes qubits. Our proof improves on both. Resource Type Google's Low-Gate Google's Low-Qubit Our Proof Total Operations 17,000,000 17,000,000 8,300,000 Number of Qubits 1,425 1,175 1,164 Toffoli Count 2,100,000 2,700,000 0 Table 1: Resource upper bounds reported in different proofs for circuits computing the correct output across 9,024 randomly sampled inputs Our proof fully verifies when using Google's unpatched verification code. It has the same verification key as their original proofs and is cryptographically indistinguishable from a zero-knowledge proof resulting from actual algorithmic improvements to the quantum circuit. We are releasing the code we developed to forge the proof, and a summary of our proof follows. Circuit SHA-256 hash: 0x7efe1f62bb14a978322ab9ed41d670fc0fe0f211331032615c910df5a540e999 Groth16 pr

## Bringing Rust to the Pixel Baseband

DevFeed: [Bringing Rust to the Pixel Baseband](<https://devfeed.tech/articles/bringing-rust-to-the-pixel-baseband-19818.md>)

Original publisher: [Read original article](<http://security.googleblog.com/2026/04/bringing-rust-to-pixel-baseband.html>)

Author: Edward Fernandez (noreply@blogger.com)

Published: 2026-04-10T15:12:00Z

Content type: article

Language: en

Sources: [Google Online Security](<https://devfeed.tech/sources/google-online-security.md>)

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [Security](<https://devfeed.tech/topics/security.md>), [Parsing](<https://devfeed.tech/topics/parsing.md>), [Google](<https://devfeed.tech/topics/google.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-security](<https://devfeed.tech/tags/android-security.md>), [dns](<https://devfeed.tech/tags/dns.md>), [google](<https://devfeed.tech/tags/google.md>), [internet](<https://devfeed.tech/tags/internet.md>), [library](<https://devfeed.tech/tags/library.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [none](<https://devfeed.tech/tags/none.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [parsing](<https://devfeed.tech/tags/parsing.md>), [pixel](<https://devfeed.tech/tags/pixel.md>), [remote-code-execution](<https://devfeed.tech/tags/remote-code-execution.md>), [rust](<https://devfeed.tech/tags/rust.md>), [security](<https://devfeed.tech/tags/security.md>), [test-coverage](<https://devfeed.tech/tags/test-coverage.md>), [vulnerabilities](<https://devfeed.tech/tags/vulnerabilities.md>)

### AI overview

Google describes integrating a memory-safe Rust DNS parser into Pixel modem firmware. The post explains the security motivation, the modem's remote attack surface, and the evaluation of open-source Rust DNS libraries, identifying hickory-proto as the best candidate based on maintenance, test coverage, and adoption.

### Source excerpt

Posted by Jiacheng Lu, Software Engineer, Google Pixel Team Google is continuously advancing the security of Pixel devices. We have been focusing on hardening the cellular baseband modem against exploitation. Recognizing the risks associated within the complex modem firmware, Pixel 9 shipped with mitigations against a range of memory-safety vulnerabilities. For Pixel 10, Google is advancing its proactive security measures further. Following our previous discussion on "Deploying Rust in Existing Firmware Codebases", this post shares a concrete application: integrating a memory-safe Rust DNS(Domain Name System) parser into the modem firmware. The new Rust-based DNS parser significantly reduces our security risk by mitigating an entire class of vulnerabilities in a risky area, while also laying the foundation for broader adoption of memory-safe code in other areas. Here we share our experience of working on it, and hope it can inspire the use of more memory safe languages in low-level environments. Why Modem Memory Safety Can't Wait In recent years, we have seen increasing interest in the cellular modem from attackers and security researchers. For example, Google's Project Zero gained remote code execution on Pixel modems over the Internet. Pixel modem has tens of Megabytes of executable code. Given the complexity and remote attack surface of the modem, other critical memory safety vulnerabilities may remain in the predominantly memory-unsafe firmware code. Why DNS? The DNS protocol is most commonly known in the context of browsers finding websites. With the evolution of cellular technology, modern cellular communications have migrated to digital data networks; consequently, even basic operations such as call forwarding rely on DNS services. DNS is a complex protocol and requires parsing of untrusted data, which can lead to vulnerabilities, particularly when implemented in a memory-unsafe language (example: CVE-2024-27227). Implementing the DNS parser in Rust offers va

## Using Java's Foreign Function & Memory API to simplify Pi4J native interactions

DevFeed: [Using Java's Foreign Function & Memory API to simplify Pi4J native interactions](<https://devfeed.tech/articles/the-ffm-api-how-openjdk-changed-the-game-for-native-interactions-and-made-pi4j-better-23017.md>)

Original publisher: [Read original article](<https://www.javaadvent.com/2025/12/ffm-api-for-java-on-raspberry-pi.html>)

Author: Frank Delporte

Published: 2025-12-16T03:03:39Z

Content type: article

Language: en

Sources: [Java Advent Calendar](<https://devfeed.tech/sources/java-advent-calendar.md>)

Topics: [Raspberry Pi](<https://devfeed.tech/topics/raspberry-pi.md>), [openjdk](<https://devfeed.tech/topics/openjdk.md>), [Java](<https://devfeed.tech/topics/java.md>), [Library](<https://devfeed.tech/topics/library.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>)

Tags: [2025](<https://devfeed.tech/tags/2025.md>), [code](<https://devfeed.tech/tags/code.md>), [java](<https://devfeed.tech/tags/java.md>), [library](<https://devfeed.tech/tags/library.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [openjdk](<https://devfeed.tech/tags/openjdk.md>), [raspberry-pi](<https://devfeed.tech/tags/raspberry-pi.md>)

### AI overview

The article explains how Java's Foreign Function & Memory API, finalized in Java 22, can simplify Pi4J's interaction with native libraries and memory on Raspberry Pi. It contrasts the API with Pi4J's earlier JNI and Java Native Access approach, focusing on memory safety, easier native-library access, and maintainability.

### Source excerpt

The Pi4J project is a Java library that allows you to control the GPIO pins and electronic components connected to a Raspberry Pi with pure Java code. It removes the complexity of using native libraries and the Java Native Interface (JNI), allowing you to focus on your application logic. In the Java Advent of 2020, I published "Light up [...] The post The FFM API: How OpenJDK Changed the Game for Native Interactions (And Made Pi4J Better!) appeared first on JVM Advent.

## Rust in Android: move fast and fix things

DevFeed: [Rust in Android: move fast and fix things](<https://devfeed.tech/articles/rust-in-android-move-fast-and-fix-things-19806.md>)

Original publisher: [Read original article](<http://security.googleblog.com/2025/11/rust-in-android-move-fast-fix-things.html>)

Author: Edward Fernandez (noreply@blogger.com)

Published: 2025-11-13T16:59:00Z

Content type: article

Language: en

Sources: [Google Online Security](<https://devfeed.tech/sources/google-online-security.md>)

Topics: [Android](<https://devfeed.tech/topics/android.md>), [Rust](<https://devfeed.tech/topics/rust.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [Vulnerabilities](<https://devfeed.tech/topics/vulnerabilities.md>), [C](<https://devfeed.tech/topics/c.md>), [C++](<https://devfeed.tech/topics/c-plus-plus.md>), [Linux](<https://devfeed.tech/topics/linux.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-security](<https://devfeed.tech/tags/android-security.md>), [c](<https://devfeed.tech/tags/c.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [linux](<https://devfeed.tech/tags/linux.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [none](<https://devfeed.tech/tags/none.md>), [programming](<https://devfeed.tech/tags/programming.md>), [rust](<https://devfeed.tech/tags/rust.md>), [security](<https://devfeed.tech/tags/security.md>), [software](<https://devfeed.tech/tags/software.md>), [vulnerabilities](<https://devfeed.tech/tags/vulnerabilities.md>)

### AI overview

Google describes how Rust adoption in Android is associated with fewer memory safety vulnerabilities and faster software delivery. The article reports that memory safety vulnerabilities fell below 20% of total vulnerabilities in 2025, while Rust changes had lower rollback rates and spent less time in code review than comparable changes.

### Source excerpt

Posted by Jeff Vander Stoep, Android Last year, we wrote about why a memory safety strategy that focuses on vulnerability prevention in new code quickly yields durable and compounding gains. This year we look at how this approach isn't just fixing things, but helping us move faster. The 2025 data continues to validate the approach, with memory safety vulnerabilities falling below 20% of total vulnerabilities for the first time. Updated data for 2025. This data covers first-party and third-party (open source) code changes to the Android platform across C, C++, Java, Kotlin, and Rust. This post is published a couple of months before the end of 2025, but Android's industry-standard 90-day patch window means that these results are very likely close to final. We can and will accelerate patching when necessary. We adopted Rust for its security and are seeing a 1000x reduction in memory safety vulnerability density compared to Android's C and C++ code. But the biggest surprise was Rust's impact on software delivery. With Rust changes having a 4x lower rollback rate and spending 25% less time in code review, the safer path is now also the faster one. In this post, we dig into the data behind this shift and also cover: How we're expanding our reach: We're pushing to make secure code the default across our entire software stack. We have updates on Rust adoption in first-party apps, the Linux kernel, and firmware. Our first rust memory safety vulnerability...almost: We'll analyze a near-miss memory safety bug in unsafe Rust: how it happened, how it was mitigated, and steps we're taking to prevent recurrence. It's also a good chance to answer the question "if Rust can have memory safety issues, why bother at all?" Building Better Software, Faster Developing an operating system requires the low-level control and predictability of systems programming languages like C, C++, and Rust. While Java and Kotlin are important for Android platform development, their role is complementary

## exploits.club Weekly Newsletter 89 - iOS GPU Driver Bugs, Kernel Stack UAFs, Hardware Wallet Auth Bypasses, and More

DevFeed: [exploits.club Weekly Newsletter 89 - iOS GPU Driver Bugs, Kernel Stack UAFs, Hardware Wallet Auth Bypasses, and More](<https://devfeed.tech/articles/exploits-club-weekly-newsletter-89-ios-gpu-driver-bugs-kernel-stack-uafs-hardware-wallet-auth-bypasses-and-more-32646.md>)

Original publisher: [Read original article](<https://blog.exploits.club/exploits-club-weekly-newsletter-89-ios-gpu-driver-bugs-kernel-stack-uafs-hardware-wallet-auth-bypasses-and-more/>)

Author: exploits.club

Published: 2025-10-16T15:00:32Z

Content type: article

Language: en

Sources: [exploits.club](<https://devfeed.tech/sources/exploits-club.md>)

Topics: [iOS](<https://devfeed.tech/topics/ios.md>), [Security](<https://devfeed.tech/topics/security.md>), [GPU](<https://devfeed.tech/topics/gpu.md>), [vulnerability](<https://devfeed.tech/topics/vulnerability.md>), [Hacking](<https://devfeed.tech/topics/hacking.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [UEFI](<https://devfeed.tech/topics/uefi.md>)

Tags: [firmware](<https://devfeed.tech/tags/firmware.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [hacking](<https://devfeed.tech/tags/hacking.md>), [ios](<https://devfeed.tech/tags/ios.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [security](<https://devfeed.tech/tags/security.md>), [vulnerability](<https://devfeed.tech/tags/vulnerability.md>)

### AI overview

This weekly newsletter rounds up security research and announcements, including an iOS GPU kernel driver vulnerability whose patched underflow could enable out-of-bounds read/write, though modern allocator hardening may prevent a practical exploit. It also covers x86 memory-safety instructions, Apple security bounty changes, and a Nokia Beacon 1 router teardown involving UART access, command injection, and password generation.

### Source excerpt

Our NBA Finals game 7 prediction didn't go too well earlier this year, but mark these words now: Piastri and Lando are taking each other out at USGP this week. Annnnnnyways 👇 In Case You Missed It... Save the Date for OffensiveCon26 - May 15th and 16th of next

## Trip report: Node.js collaboration summit (2025 Paris)

DevFeed: [Trip report: Node.js collaboration summit (2025 Paris)](<https://devfeed.tech/articles/trip-report-node-js-collaboration-summit-2025-paris-2438.md>)

Original publisher: [Read original article](<https://nodejs.org/en/blog/events/collab-summit-2025-paris>)

Published: 2025-05-22T00:00:00Z

Content type: article

Language: en

Sources: [Node.js Blog](<https://devfeed.tech/sources/node-js-blog.md>)

Topics: [Node.js](<https://devfeed.tech/topics/node-js.md>), [ci](<https://devfeed.tech/topics/ci.md>), [Deadlock](<https://devfeed.tech/topics/deadlock.md>), [JavaScript](<https://devfeed.tech/topics/javascript.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [wasm](<https://devfeed.tech/topics/wasm.md>), [cross-platform](<https://devfeed.tech/topics/cross-platform.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>), [browsers](<https://devfeed.tech/topics/browsers.md>)

Tags: [browsers](<https://devfeed.tech/tags/browsers.md>), [ci](<https://devfeed.tech/tags/ci.md>), [cross-platform](<https://devfeed.tech/tags/cross-platform.md>), [deadlock](<https://devfeed.tech/tags/deadlock.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [node-js](<https://devfeed.tech/tags/node-js.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [wasm](<https://devfeed.tech/tags/wasm.md>)

### AI overview

A trip report on the 2025 Node.js collaboration summit in Paris, covering CI infrastructure reliability, experimental WASM modules, browser coordination, V8 Oilpan integration, memory safety, garbage collection, mentorship, and contributor experience.

### Source excerpt

Node.js® is a free, open-source, cross-platform JavaScript runtime environment that lets developers create servers, web apps, command line tools and scripts.

## Eliminating Array Bounds Checks

DevFeed: [Eliminating Array Bounds Checks](<https://devfeed.tech/articles/eliminating-array-bounds-checks-25610.md>)

Original publisher: [Read original article](<https://www.romainguy.dev/posts/2025/eliminating-array-bounds-checks/>)

Author: Romain Guy

Published: 2025-05-13T00:00:00Z

Content type: tutorial

Language: en

Sources: [Posts on Romain Guy](<https://devfeed.tech/sources/posts-on-romain-guy.md>)

Topics: [Android](<https://devfeed.tech/topics/android.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>), [Exception](<https://devfeed.tech/topics/exception.md>), [toolchain](<https://devfeed.tech/topics/toolchain.md>), [inlining](<https://devfeed.tech/topics/inlining.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [assembly](<https://devfeed.tech/tags/assembly.md>), [code](<https://devfeed.tech/tags/code.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [developer](<https://devfeed.tech/tags/developer.md>), [exception](<https://devfeed.tech/tags/exception.md>), [graphics](<https://devfeed.tech/tags/graphics.md>), [inlining](<https://devfeed.tech/tags/inlining.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [performance](<https://devfeed.tech/tags/performance.md>), [toolchain](<https://devfeed.tech/tags/toolchain.md>)

### AI overview

This tutorial explains how Android Runtime array bounds checks protect memory safety but can add unnecessary instructions. It shows how a simple explicit check can help the compiler eliminate those checks in a fixed-size array, reducing the example from 136 to 60 arm64 instructions.

### Source excerpt

The Android Runtime (ART) offers a nice memory safety feature when accessing the content of an array. The indices you use are automatically checked against the bounds of the array to prevent unsafe memory accesses. To achieve this, ART generates extra machine instructions to throw an ArrayIndexOutOfBoundsException when the index is invalid. Here is a simple Kotlin example: 1fun scaleZ(values: FloatArray, scale: Float) = values[2] * scale After translation to arm64 assembly, we obtain the following result:

## No-Panic Rust: A Nice Technique for Systems Programming

DevFeed: [No-Panic Rust: A Nice Technique for Systems Programming](<https://devfeed.tech/articles/no-panic-rust-a-nice-technique-for-systems-programming-21139.md>)

Original publisher: [Read original article](<https://blog.reverberate.org/2025/02/03/no-panic-rust.html>)

Author: Haberman

Published: 2025-02-03T00:00:00Z

Content type: article

Language: en

Sources: [Josh Haberman](<https://devfeed.tech/sources/josh-haberman.md>)

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [systems](<https://devfeed.tech/topics/systems.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [Programming](<https://devfeed.tech/topics/programming.md>)

Tags: [api](<https://devfeed.tech/tags/api.md>), [code](<https://devfeed.tech/tags/code.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [programming](<https://devfeed.tech/tags/programming.md>), [rust](<https://devfeed.tech/tags/rust.md>), [systems](<https://devfeed.tech/tags/systems.md>)

### AI overview

This article examines "No-Panic Rust," a technique for using Rust in low-level systems programming while avoiding panics as a response to errors. The author argues that the approach could make porting the upb C library to Rust more practical while preserving performance and code-size goals.

### Source excerpt

Can Rust replace C? This is a question that has been on my mind for many years, as I created and now am tech lead for upb, a C library for Protocol Buffers. There is an understandable push to bring memory safety to all parts of the software stack, and this would suggest a port of upb to Rust. While I love the premise of Rust, I have long been skeptical that a port of upb to Rust could preserve the performance and code size characteristics that I and others have fought so hard to optimize. In fact, this blog entry was originally going to be an argument for why Rust cannot match C for upb's use case. But I recently discovered a technique that shifted my thinking a lot. I call it "No-Panic Rust", and while the technique is clearly not new1, I was not able to find any in-depth discussion of how it works or what problems it solves. This article is my attempt to fill that gap. I believe that No-Panic Rust is the key to making Rust a compelling option for low-level systems programming. I now am optimistic about the possibility of porting upb to Rust. What are Panics? Panics are Rust's mechanism for unrecoverable errors. Anytime our program encounters an error, we have three basic options for how to handle it: Handle the error immediately (eg. retry the operation or fall back to plan B). Propagate the error to the caller, who can decide how to handle it. Immediately abort execution. In Rust, we use Result for (2) and panic!() for (3). When we use Result, it is considered a "recoverable error", because the caller can test for the error and decide how to respond. With recoverable errors, the potential for error is reflected in the function signature; a function that returns Result is fallible from the perspective of the caller. Panics on the other hand present the illusion of infallibility from an API perspective, but then proceed to handle errors by simply aborting. There is a lot of standard guidance for when to use panic!() vs Result (for example, here and here), which lar

## Using Compiler Flags to Secure Your Code

DevFeed: [Using Compiler Flags to Secure Your Code](<https://devfeed.tech/articles/using-compiler-flags-to-secure-your-code-13310.md>)

Original publisher: [Read original article](<https://www.chainguard.dev/unchained/using-compiler-flags-to-secure-your-code>)

Published: 2025-01-22T00:00:00Z

Content type: tutorial

Language: en

Sources: [Chainguard: Unchained](<https://devfeed.tech/sources/chainguard-unchained.md>)

Topics: [Compiler](<https://devfeed.tech/topics/compiler.md>), [Code](<https://devfeed.tech/topics/code.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [Security](<https://devfeed.tech/topics/security.md>), [C](<https://devfeed.tech/topics/c.md>), [C++](<https://devfeed.tech/topics/c-plus-plus.md>), [gcc](<https://devfeed.tech/topics/gcc.md>), [Dockerfile](<https://devfeed.tech/topics/dockerfile.md>)

Tags: [c](<https://devfeed.tech/tags/c.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [chainguard-images](<https://devfeed.tech/tags/chainguard-images.md>), [code](<https://devfeed.tech/tags/code.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [compiler-flags](<https://devfeed.tech/tags/compiler-flags.md>), [container](<https://devfeed.tech/tags/container.md>), [gcc](<https://devfeed.tech/tags/gcc.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [open-ssf](<https://devfeed.tech/tags/open-ssf.md>), [security](<https://devfeed.tech/tags/security.md>)

### AI overview

This tutorial examines OpenSSF-recommended compiler flags for C and C++ code, focusing on how hardened standard-library calls and related protections affect memory safety and buffer-overflow behavior. It demonstrates the examples using a Docker-based development environment.

### Source excerpt

Open SSF's recommended compiler flags are a great way to improve memory safety and security. Check out what effect using these flags can have.

## Introducing multi-backends (TRT-LLM, vLLM) support for Text Generation Inference

DevFeed: [Introducing multi-backends (TRT-LLM, vLLM) support for Text Generation Inference](<https://devfeed.tech/articles/introducing-multi-backends-trt-llm-vllm-support-for-text-generation-inference-7501.md>)

Original publisher: [Read original article](<https://huggingface.co/blog/tgi-multi-backend>)

Author: Morgan Funtowicz; Hugo Larcher

Published: 2025-01-16T00:00:00Z

Content type: article

Language: en

Sources: [Hugging Face - Blog](<https://devfeed.tech/sources/hugging-face-blog.md>)

Topics: [tgi](<https://devfeed.tech/topics/tgi.md>), [model-deployment](<https://devfeed.tech/topics/model-deployment.md>), [Rust](<https://devfeed.tech/topics/rust.md>), [vllm](<https://devfeed.tech/topics/vllm.md>), [TensorRT-LLM](<https://devfeed.tech/topics/tensorrt-llm.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [servers](<https://devfeed.tech/topics/servers.md>), [llama.cpp](<https://devfeed.tech/topics/llama-cpp.md>), [sglang](<https://devfeed.tech/topics/sglang.md>), [Python](<https://devfeed.tech/topics/python.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [backend](<https://devfeed.tech/tags/backend.md>), [backends](<https://devfeed.tech/tags/backends.md>), [community](<https://devfeed.tech/tags/community.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [http](<https://devfeed.tech/tags/http.md>), [inference](<https://devfeed.tech/tags/inference.md>), [jetstream](<https://devfeed.tech/tags/jetstream.md>), [llama-cpp](<https://devfeed.tech/tags/llama-cpp.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [neuron](<https://devfeed.tech/tags/neuron.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [performance](<https://devfeed.tech/tags/performance.md>), [production](<https://devfeed.tech/tags/production.md>), [python](<https://devfeed.tech/tags/python.md>), [rust](<https://devfeed.tech/tags/rust.md>), [sglang](<https://devfeed.tech/tags/sglang.md>), [tensorrt-llm](<https://devfeed.tech/tags/tensorrt-llm.md>), [tgi](<https://devfeed.tech/tags/tgi.md>), [vllm](<https://devfeed.tech/tags/vllm.md>)

### AI overview

Hugging Face introduces TGI Backends, a unified frontend architecture for integrating inference solutions such as vLLM, SGLang, llama.cpp, and TensorRT-LLM. The approach lets users switch backends based on model, hardware, and performance requirements while supporting production deployment across diverse accelerators. The article also describes TGI's Rust and Python components, including Rust-based HTTP and scheduling layers designed for memory safety and concurrency.

### Source excerpt

We're on a journey to advance and democratize artificial intelligence through open source and open science.

## Enhanced Compiler Flags for Building Chainguard's Guarded Images

DevFeed: [Enhanced Compiler Flags for Building Chainguard's Guarded Images](<https://devfeed.tech/articles/enhanced-compiler-flags-for-building-chainguard-s-guarded-images-13030.md>)

Original publisher: [Read original article](<https://www.chainguard.dev/unchained/enhanced-compiler-flags-for-building-chainguards-guarded-images>)

Published: 2024-11-19T00:00:00Z

Content type: article

Language: en

Sources: [Chainguard: Unchained](<https://devfeed.tech/sources/chainguard-unchained.md>)

Topics: [chainguard images](<https://devfeed.tech/topics/chainguard-images.md>), [c/c++](<https://devfeed.tech/topics/c-c-plus-plus.md>), [Security](<https://devfeed.tech/topics/security.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [Exploit](<https://devfeed.tech/topics/exploit.md>)

Tags: [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [chainguard-images](<https://devfeed.tech/tags/chainguard-images.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [compiler-flags](<https://devfeed.tech/tags/compiler-flags.md>), [compiler-hardening](<https://devfeed.tech/tags/compiler-hardening.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [openssf](<https://devfeed.tech/tags/openssf.md>), [secure-by-default](<https://devfeed.tech/tags/secure-by-default.md>), [security](<https://devfeed.tech/tags/security.md>), [vulnerabilities](<https://devfeed.tech/tags/vulnerabilities.md>), [vulnerability](<https://devfeed.tech/tags/vulnerability.md>)

### AI overview

Chainguard Images now use enhanced compiler flags for C/C++ projects. The OpenSSF-recommended hardening is implemented through clang configuration files and gcc spec files in Wolfi, helping mitigate memory-safety vulnerabilities such as stack-based buffer overflows and unsafe memory usage.

### Source excerpt

Chainguard Images are now built using enhanced compiler flags for C/C++ projects. See how this strengthens the security posture of Chainguard's build systems.

## Fearless Concurrency Ep.5: Ensuring Memory Safety with Mutexes and RwLocks in Rust

DevFeed: [Fearless Concurrency Ep.5: Ensuring Memory Safety with Mutexes and RwLocks in Rust](<https://devfeed.tech/articles/fearless-concurrency-ep-5-ensuring-memory-safety-with-mutexes-and-rwlocks-in-rust-22269.md>)

Original publisher: [Read original article](<https://www.ardanlabs.com/blog/2024/11/fearless-concurrency-ep5-ensuring-memory-safety-with-mutexes-and-rwlocks-in-rust.html>)

Published: 2024-11-08T00:00:00Z

Content type: tutorial

Language: en

Sources: [William Kennedy](<https://devfeed.tech/sources/william-kennedy.md>)

Topics: [Concurrent Programming](<https://devfeed.tech/topics/concurrent-programming.md>), [Rust](<https://devfeed.tech/topics/rust.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [Programming](<https://devfeed.tech/topics/programming.md>)

Tags: [advanced-concurrency-rust](<https://devfeed.tech/tags/advanced-concurrency-rust.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [concurrency-in-rust](<https://devfeed.tech/tags/concurrency-in-rust.md>), [concurrency-patterns-rust](<https://devfeed.tech/tags/concurrency-patterns-rust.md>), [concurrent-read-write-access-rust](<https://devfeed.tech/tags/concurrent-read-write-access-rust.md>), [data-sharing-in-multithreading](<https://devfeed.tech/tags/data-sharing-in-multithreading.md>), [deadlock-avoidance-rust](<https://devfeed.tech/tags/deadlock-avoidance-rust.md>), [embedding-mutex-in-structs](<https://devfeed.tech/tags/embedding-mutex-in-structs.md>), [fearless-concurrency-rust](<https://devfeed.tech/tags/fearless-concurrency-rust.md>), [interior-mutability-rust](<https://devfeed.tech/tags/interior-mutability-rust.md>), [managing-shared-data-rust](<https://devfeed.tech/tags/managing-shared-data-rust.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [mutex](<https://devfeed.tech/tags/mutex.md>), [mutexes-in-rust](<https://devfeed.tech/tags/mutexes-in-rust.md>), [optimizing-performance-rust-multithreading](<https://devfeed.tech/tags/optimizing-performance-rust-multithreading.md>), [rust](<https://devfeed.tech/tags/rust.md>), [rust-concurrency-best-practices](<https://devfeed.tech/tags/rust-concurrency-best-practices.md>), [rust-concurrency-tools](<https://devfeed.tech/tags/rust-concurrency-tools.md>), [rust-data-synchronization](<https://devfeed.tech/tags/rust-data-synchronization.md>), [rust-interior-mutability-examples](<https://devfeed.tech/tags/rust-interior-mutability-examples.md>), [rust-multithreading-performance](<https://devfeed.tech/tags/rust-multithreading-performance.md>), [rust-mutex-integration](<https://devfeed.tech/tags/rust-mutex-integration.md>), [rust-mutex-vs-rwlock](<https://devfeed.tech/tags/rust-mutex-vs-rwlock.md>), [rust-read-write-locks](<https://devfeed.tech/tags/rust-read-write-locks.md>), [rust-thread-management](<https://devfeed.tech/tags/rust-thread-management.md>), [rust-thread-safety](<https://devfeed.tech/tags/rust-thread-safety.md>), [rust-thread-safety-techniques](<https://devfeed.tech/tags/rust-thread-safety-techniques.md>), [rwlock-in-rust](<https://devfeed.tech/tags/rwlock-in-rust.md>), [rwlock-vs-mutex-rust](<https://devfeed.tech/tags/rwlock-vs-mutex-rust.md>), [sync-trait-in-rust](<https://devfeed.tech/tags/sync-trait-in-rust.md>), [sync-trait-rust](<https://devfeed.tech/tags/sync-trait-rust.md>), [synchronization](<https://devfeed.tech/tags/synchronization.md>), [thread](<https://devfeed.tech/tags/thread.md>), [thread-safe-structs-rust](<https://devfeed.tech/tags/thread-safe-structs-rust.md>)

### AI overview

Episode 5 of a Rust concurrency series explains RwLock for coordinating simultaneous reads and writes, along with interior mutability for embedding mutexes in structs. It advises limiting RwLock use to read-heavy cases, starting with mutexes to learn synchronization fundamentals, and avoiding deadlocks. The examples show how struct-level synchronization can simplify multithreaded code and reduce unnecessary serialization.

### Source excerpt

Introduction: Welcome to Episode 5 of Fearless Concurrency in Rust! In this episode, Herbert Wolverson dives into advanced concurrency tools, focusing on RwLock for managing simultaneous reads and writes and the powerful concept of interior mutability. These tools provide developers with greater control over data sharing in multithreaded environments, enabling them to optimize for both performance and code simplicity in Rust. Read-Write Locks (RwLock): Manage concurrent read and write access efficiently.

## Garbage Collection and Metastability

DevFeed: [Garbage Collection and Metastability](<https://devfeed.tech/articles/garbage-collection-and-metastability-12561.md>)

Original publisher: [Read original article](<http://brooker.co.za/blog/2024/08/14/gc-metastable.html>)

Author: Marc Brooker

Published: 2024-08-14T00:00:00Z

Content type: article

Language: en

Sources: [Marc Brooker's Blog](<https://devfeed.tech/sources/marc-brooker-s-blog.md>), [Marc Brooker's Blog](<https://devfeed.tech/sources/marc-brooker-s-blog-2.md>)

Topics: [systems](<https://devfeed.tech/topics/systems.md>), [Latency](<https://devfeed.tech/topics/latency.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [Go Language](<https://devfeed.tech/topics/go-language.md>), [JavaScript](<https://devfeed.tech/topics/javascript.md>), [Python](<https://devfeed.tech/topics/python.md>), [Rust](<https://devfeed.tech/topics/rust.md>)

Tags: [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [garbage-collection](<https://devfeed.tech/tags/garbage-collection.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [latency](<https://devfeed.tech/tags/latency.md>), [memory](<https://devfeed.tech/tags/memory.md>), [memory-management](<https://devfeed.tech/tags/memory-management.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [production](<https://devfeed.tech/tags/production.md>), [python](<https://devfeed.tech/tags/python.md>), [rust](<https://devfeed.tech/tags/rust.md>), [systems](<https://devfeed.tech/tags/systems.md>)

### AI overview

The article explains how garbage collection can contribute to metastability in large-scale systems. Increased memory pressure can raise GC time and request cost, increasing latency and reducing throughput; this can increase in-flight requests and memory pressure further, creating a self-perpetuating cycle that may collapse systems without limited concurrency. It cites production experience and research showing that some garbage collectors can increase work cost by up to 70% under higher memory pressure.

### Source excerpt

Garbage Collection and Metastability Cleaning up is hard to do. I've written a lot about stability and metastability, but haven't touched on one other common cause of metastability in large-scale systems: garbage collection. GC is great. Garbage collected languages like Javascript, Java, Python, and Go power a big chunk of the internet's infrastructure. Until Rust came along, choosing memory safety typically implied choosing garbage collection. For almost all applications, languages with garbage collection are a reasonable choice. The trade-offs between GC and not-GC have been well trodden, so I'm not going to spend time on any of them except one: metastability. As we've discussed in prior posts, metastability comes about when systems have self-perpetuating cycles which permanently degrade goodput. Here's what the cycle for GC might look like: Increasing memory pressure increases the amount of time it takes for the GC to run, and increases the cost of handling any given request, this increases per-request latency and reduces throughput, this increases the number of requests in flight (and their associated per-request memory), which increases memory pressure. In a system that limits concurrency (whether a closed system or an open system with concurrency-limiting throttling) this isn't likely to happen. In a system without limited concurrency (even if it does limit arrival rate), even a short-lived excursion can send the system into a mode where it spins around this loop until it collapses. But do GCs behave that way? The only controversial step in the loop is higher GC overhead, implying that increasing memory pressure increases per-request latency even in the presence of excess CPU (so it's more than just the effect of memory management consuming more CPU, which would happen without GC). I've seen significant in-production evidence for that, and there seems to be some good evidence from the literature. For example, see Figure 2 from The DaCapo Benchmarks by Blackbur

## Why I am not yet ready to switch to Zig from Rust

DevFeed: [Why I am not yet ready to switch to Zig from Rust](<https://devfeed.tech/articles/why-i-am-not-yet-ready-to-switch-to-zig-from-rust-6111.md>)

Original publisher: [Read original article](<https://turso.tech/blog/why-i-am-not-yet-ready-to-switch-to-zig-from-rust>)

Author: Pekka Enberg

Published: 2024-06-19T00:00:00Z

Content type: opinion

Language: en

Sources: [Turso Blog](<https://devfeed.tech/sources/turso-blog.md>)

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [Zig](<https://devfeed.tech/topics/zig.md>), [C++](<https://devfeed.tech/topics/c-plus-plus.md>), [Programming](<https://devfeed.tech/topics/programming.md>)

Tags: [c](<https://devfeed.tech/tags/c.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [programming](<https://devfeed.tech/tags/programming.md>), [rust](<https://devfeed.tech/tags/rust.md>), [tooling](<https://devfeed.tech/tags/tooling.md>), [zig](<https://devfeed.tech/tags/zig.md>)

### AI overview

The author explains why they are not yet ready to switch from Rust to Zig, reflecting on prior experience with C, C++, Haskell, and Rust. They value Rust's memory safety and borrow checker but previously struggled with its changing tooling and ownership model.

### Source excerpt

Building a better-sqlite3 compatible JavaScript package with Rust

## Ep. 2: Mastering Memory Safety: Rust's Defense Against Use After Free & Use After Move

DevFeed: [Ep. 2: Mastering Memory Safety: Rust's Defense Against Use After Free & Use After Move](<https://devfeed.tech/articles/ep-2-mastering-memory-safety-rust-s-defense-against-use-after-free-use-after-move-22278.md>)

Original publisher: [Read original article](<https://www.ardanlabs.com/blog/2024/22/mastering-memory-safety-ep-2.html>)

Published: 2024-04-22T00:00:00Z

Content type: tutorial

Language: en

Sources: [William Kennedy](<https://devfeed.tech/sources/william-kennedy.md>)

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [C++](<https://devfeed.tech/topics/c-plus-plus.md>), [Go Language](<https://devfeed.tech/topics/go-language.md>)

Tags: [c](<https://devfeed.tech/tags/c.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [go](<https://devfeed.tech/tags/go.md>), [memory](<https://devfeed.tech/tags/memory.md>), [memory-breaches](<https://devfeed.tech/tags/memory-breaches.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [rust](<https://devfeed.tech/tags/rust.md>), [safety-mechanism](<https://devfeed.tech/tags/safety-mechanism.md>), [video](<https://devfeed.tech/tags/video.md>)

### AI overview

A video tutorial examines use-after-free and use-after-move problems, comparing Rust's ownership checks with memory-management approaches in C++ and Go.

### Source excerpt

Introduction: Exploring the critical issues of "use after free" and "use after move," Herbert's insights offer a valuable understanding to Rust developers: Rust's ownership system acts as a powerful safeguard against memory safety issues like "use after free" and "use after move," ensuring code correctness at compile time. By understanding the risks associated with these memory management pitfalls, Rust developers gain deeper insights into crafting more secure and reliable software, leveraging Rust's robust memory handling mechanisms.

## Ep. 1: Defending Against Memory Breaches: Exploring Rust and Go's Safety Mechanisms

DevFeed: [Ep. 1: Defending Against Memory Breaches: Exploring Rust and Go's Safety Mechanisms](<https://devfeed.tech/articles/ep-1-defending-against-memory-breaches-exploring-rust-and-go-s-safety-mechanisms-22277.md>)

Original publisher: [Read original article](<https://www.ardanlabs.com/blog/2024/15/defending-against-memory-breaches-exploring-rust-and-go-safety-mechanisms-ep-1.html>)

Published: 2024-04-15T00:00:00Z

Content type: tutorial

Language: en

Sources: [William Kennedy](<https://devfeed.tech/sources/william-kennedy.md>)

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [Go Language](<https://devfeed.tech/topics/go-language.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Security](<https://devfeed.tech/topics/security.md>)

Tags: [c](<https://devfeed.tech/tags/c.md>), [concurrent](<https://devfeed.tech/tags/concurrent.md>), [concurrent-programming](<https://devfeed.tech/tags/concurrent-programming.md>), [go](<https://devfeed.tech/tags/go.md>), [golang](<https://devfeed.tech/tags/golang.md>), [languages](<https://devfeed.tech/tags/languages.md>), [memory-breaches](<https://devfeed.tech/tags/memory-breaches.md>), [memory-management](<https://devfeed.tech/tags/memory-management.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [rust](<https://devfeed.tech/tags/rust.md>), [safety](<https://devfeed.tech/tags/safety.md>), [safety-mechanism](<https://devfeed.tech/tags/safety-mechanism.md>), [security](<https://devfeed.tech/tags/security.md>), [synchronization](<https://devfeed.tech/tags/synchronization.md>)

### AI overview

This introductory video examines memory safety in programming languages, focusing on Rust and comparing its approach with Go, Java, and C. It discusses buffer overflows, memory leaks, data races, static analysis, checked arithmetic, and the trade-offs between safety and performance.

### Source excerpt

Introduction: Rust's memory safety features are advantageous to Rust developers because they: Ensure robust protection against buffer overflows and underflows, enhancing the reliability and security of software. Empower developers to manage type coercion effectively, promoting code reliability and safety while facilitating safe type conversions. Provide confidence in writing concurrent code by enforcing strict mutability rules and synchronization, thereby preventing data race issues and ensuring code correctness and efficiency. With these memory safety features deeply integrated into Rust's design, developers can build more reliable, secure, and efficient software, spanning various aspects of memory management, type handling, and concurrent programming paradigms.

## Application and AI roundup - September

DevFeed: [Application and AI roundup - September](<https://devfeed.tech/articles/application-and-ai-roundup-september-36687.md>)

Original publisher: [Read original article](<https://shostack.org/blog/appsec-roundup-september/>)

Author: Adam

Published: 2023-10-04T00:00:00Z

Content type: article

Language: en

Sources: [Shostack & Friends Blog](<https://devfeed.tech/sources/shostack-friends-blog.md>)

Topics: [Application Security](<https://devfeed.tech/topics/application-security.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [c/c++](<https://devfeed.tech/topics/c-c-plus-plus.md>), [open-source-security](<https://devfeed.tech/topics/open-source-security.md>), [Zig](<https://devfeed.tech/topics/zig.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [cisa](<https://devfeed.tech/topics/cisa.md>)

Tags: [appsec](<https://devfeed.tech/tags/appsec.md>), [c-c-plus-plus](<https://devfeed.tech/tags/c-c-plus-plus.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [cybersecurity](<https://devfeed.tech/tags/cybersecurity.md>), [development](<https://devfeed.tech/tags/development.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [open-source-software-security](<https://devfeed.tech/tags/open-source-software-security.md>)

### AI overview

A September roundup covering application security developments involving memory safety, C and C++, Zig, hardware memory tagging, secure-by-design AI guidance, cybersecurity policy for medical devices, and open-source software security.

### Source excerpt

September was a big month in appsec for both memory safety and policy

## How we built a secure RDP client

DevFeed: [How we built a secure RDP client](<https://devfeed.tech/articles/how-we-built-a-secure-rdp-client-29826.md>)

Original publisher: [Read original article](<https://goteleport.com/blog/secure-rdp-client/>)

Author: info@goteleport.com (Zac Bergquist)

Published: 2023-09-08T00:00:00Z

Content type: article

Language: en

Sources: [Teleport](<https://devfeed.tech/sources/teleport.md>)

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [client](<https://devfeed.tech/topics/client.md>), [Security](<https://devfeed.tech/topics/security.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [browser](<https://devfeed.tech/topics/browser.md>), [Go](<https://devfeed.tech/topics/go.md>), [Authentication](<https://devfeed.tech/topics/authentication.md>), [Single sign-on (SSO)](<https://devfeed.tech/topics/sso.md>)

Tags: [authentication](<https://devfeed.tech/tags/authentication.md>), [browser](<https://devfeed.tech/tags/browser.md>), [go](<https://devfeed.tech/tags/go.md>), [memory-safe](<https://devfeed.tech/tags/memory-safe.md>), [rdp](<https://devfeed.tech/tags/rdp.md>), [rust](<https://devfeed.tech/tags/rust.md>), [security](<https://devfeed.tech/tags/security.md>), [sso](<https://devfeed.tech/tags/sso.md>)

### AI overview

Teleport describes how it designed a secure RDP client using Rust, with Go also part of its memory-safe programming approach. The design avoids exposing port 3389 publicly, supports strong authentication including SSO and hardware security keys, minimizes the implemented protocol surface, and delivers remote desktop access through a browser sandbox.

### Source excerpt

How Teleport team built a secure RDP client using Rust, Go and a innovative use of the virtual smart card interface.

## My Favorite Bits of OSDI/ATC'23

DevFeed: [My Favorite Bits of OSDI/ATC'23](<https://devfeed.tech/articles/my-favorite-bits-of-osdi-atc-23-12541.md>)

Original publisher: [Read original article](<http://brooker.co.za/blog/2023/07/13/osdi.html>)

Author: Marc Brooker

Published: 2023-07-13T00:00:00Z

Content type: opinion

Language: en

Sources: [Marc Brooker's Blog](<https://devfeed.tech/sources/marc-brooker-s-blog.md>), [Marc Brooker's Blog](<https://devfeed.tech/sources/marc-brooker-s-blog-2.md>)

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [systems](<https://devfeed.tech/topics/systems.md>), [Firecracker](<https://devfeed.tech/topics/firecracker.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [Security](<https://devfeed.tech/topics/security.md>), [distributed-systems](<https://devfeed.tech/topics/distributed-systems.md>), [Serverless](<https://devfeed.tech/topics/serverless.md>)

Tags: [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [firecracker](<https://devfeed.tech/tags/firecracker.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [rust](<https://devfeed.tech/tags/rust.md>), [security](<https://devfeed.tech/tags/security.md>), [serverless](<https://devfeed.tech/tags/serverless.md>), [systems](<https://devfeed.tech/tags/systems.md>)

### AI overview

An opinion piece about OSDI'23 and USENIX ATC'23 discusses the growing use of Rust in systems research, memory safety becoming standard practice, metastability in distributed systems, increased attention to security issues such as timing side-channels, and research on cloning and snapshot safety for serverless workloads.

### Source excerpt

My Favorite Bits of OSDI/ATC'23 Talking to 3D people is cool again. This week brought USENIX ATC'23 and OSDI'23 together in Boston. While I've followed OSDI and ATC papers for years, it's the first time I've been to either of them (I've have been to NSDI a couple times). It was a really good time. In this post I'll cover a couple of my favorite papers1, and trends I noticed. Overall, it was great to meet a bunch of folks in person who I've only interacted with online, and nice to be back to in-person conferences. Thoughts and Trends When we presented the Firecracker paper at NSDI'20, several people said to me that they were worried about the fact we had chosen Rust, because it raised the risk that Firecracker wouldn't be useful once Rust was no longer in vogue. This year at OSDI, pretty much everybody I talked to was building in Rust. Obvious exceptions are folks doing AI/ML work (Python still seems big there), and folks looking to get into the mainline Linux kernel. I couldn't be more happy to see memory safety start to become the default practice in systems. Loads of folks were talking about emergent system properties like metastability. Unfortunately, not a lot of folks seem to be writing papers about it, or getting grants to work on it. I did talk to a couple folks with upcoming papers, and I really hope the hallway interest turns into more publications. Metastable failures in distributed systems and Metastable Failures in the Wild are some of the most important systems work of the last few years, in my opinion. There's a lot more to do here. I got a rough feeling that more papers were paying more attention to security issues than in years past. Subtle issues like timing side-channels especially. Another trend I like to see. Security and systems have always been linked, so this isn't new, but there does seem to be a reduction in completely security-naive work. Some of the Papers I Enjoyed The Most Take Out the Trache by Audrey Cheng et al2. This paper makes an a

## Advancing the use of memory safe programming languages

DevFeed: [Advancing the use of memory safe programming languages](<https://devfeed.tech/articles/advancing-the-use-of-memory-safe-programming-languages-12866.md>)

Original publisher: [Read original article](<https://www.chainguard.dev/unchained/advancing-the-use-of-memory-safe-programming-languages>)

Published: 2023-07-12T00:00:00Z

Content type: article

Language: en

Sources: [Chainguard: Unchained](<https://devfeed.tech/sources/chainguard-unchained.md>)

Topics: [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [Vulnerabilities](<https://devfeed.tech/topics/vulnerabilities.md>), [Rust](<https://devfeed.tech/topics/rust.md>), [Security](<https://devfeed.tech/topics/security.md>), [Linux](<https://devfeed.tech/topics/linux.md>), [Kernel](<https://devfeed.tech/topics/kernel.md>)

Tags: [linux](<https://devfeed.tech/tags/linux.md>), [linux-kernel](<https://devfeed.tech/tags/linux-kernel.md>), [memory-safe](<https://devfeed.tech/tags/memory-safe.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [rust](<https://devfeed.tech/tags/rust.md>), [security](<https://devfeed.tech/tags/security.md>), [software-development](<https://devfeed.tech/tags/software-development.md>), [vulnerabilities](<https://devfeed.tech/tags/vulnerabilities.md>)

### AI overview

The article argues that memory-safe programming languages can eliminate an entire class of software vulnerabilities caused by memory unsafety. It describes growing policy support in the U.S. government and recent progress in adopting Rust for low-level software, including the Linux kernel, TLS, NTP, and DNS.

### Source excerpt

Venture into memory-safe programming languages with Chainguard, boosting your code's defense against vulnerabilities.

[Next page](<https://devfeed.tech/topics/memory-safety.md?cursor=WyIyMDIzLTA3LTEyVDAwOjAwOjAwKzAwOjAwIiwgImE0NTM4MGNkLWNlMmQtNDJlZS05NDc0LThmNjZmNTJjOTQ1NCJd>)