Boxes, Heaps, and Stacks in Rust - September 2022
Explore memory management in Rust through boxes, heaps, and stacks. Learn how Rust's compiler guides programmers in handling pointers and memory allocation efficiently.
Rust Before Main - What Happens Before Your Code Runs
Explore the intricate process that occurs before a Rust program's main function executes, gaining deeper insights into the language's inner workings and program initialization.
What If We Pretended Unsafe Code Was Nice, and Then It Was? - RustConf 2022
Explore Rust's Strict Provenance APIs for safer and more efficient unsafe code. Learn how pretending unsafe code is nice can lead to better documentation, libraries, and tools.
Benchmarking and Optimization of Rust Libraries
Explore benchmarking and optimization strategies for Rust libraries, focusing on consistent evaluation and performance enhancement techniques for the growing ecosystem.
Representing Types in Rustc - Type System Internals
Explore rustc's type representation, covering Ty type, generics, substitution, and type folding. Gain insights into Rust's internal type system implementation.
Polonius and Rustc Code Walkthrough
Explore rustc and Polonius codebases, understanding their connection and key components like IntroFax, compute regions, and liveness computation in this comprehensive walkthrough.
Miri and Constant Evaluation in Rust
Explore miri, Rust's MIR interpreter, and its role in compile-time evaluation. Learn about its architecture, memory representation, and capabilities for interpreting safe and unsafe Rust code.
Async-Await Implementation Strategies for Rust - 2019.02.26 Meeting
Rust developers discuss implementation strategies for async-await, covering issues like explicit lifetimes, existential types, and generator artifacts to improve the language's asynchronous programming capabilities.
Entity Component Systems: A Programming Paradigm Comparison with OO - Rust Auckland
Explore Entity Component Systems (ECS) as an alternative to Object-Oriented programming, comparing data storage and logic organization models in game development.
Pin in Rust - Understanding Memory Management
Explore Rust's Pin feature with @withoutboats, delving into its implementation, use cases, and impact on asynchronous programming and memory management.
Rust Lang Team Triage Meeting - Grammar Working Group Focus - 2019.09.12
Rust Lang Team meeting discussing Grammar Working Group integration, unwind and Ref type issues. Includes goals, history, and plans for better collaboration.
Rust Shared State Code Review - Analyzing Initial Audit Results
Explore initial findings from Aaron Turon's shared state audit, categorizing state elements to determine necessary steps for improving confidence in Rust's codebase.
Polonius and Initialization: Move Tracking in Rust's Borrow Checker
Explores Rust's borrow checker, focusing on move tracking and initialization in Polonius. Covers key concepts like dynamic drop, move paths, and data flow analysis for improved memory safety.
Rust Lang Team Design Meeting: &T and Dereferenceable Optimizations - 2020.02.10
Explore Rust's &T and dereferenceable optimizations, discussing synchronization, parameters, function scope, and interactions with Arc drops. Delve into generics, unsafe cells, and ergonomic considerations.
The Rust That Could Have Been - Abandoned Pre-1.0 Language Features
Explore abandoned pre-1.0 Rust features like typestate and garbage collection, understanding why they were discarded and how current Rust emerged as the optimal version.
Rust 1.0 Progress Update and New Features - August 2014
Explore Rust 1.0's progress, drop semantics, borrow checking, and Cargo package manager in this comprehensive meetup featuring talks by Rust core team members.
Introduction to Structs, Traits, and Zero-Cost Abstractions in Rust
Explore structs, traits, and zero-cost abstractions in Rust. Learn to build efficient abstractions using generics and traits, enhancing code quality without compromising performance.
Caches and You: Optimizing Rust Data Structures for CPU Performance - Rust Cologne
Explore CPU caching, memory allocation, and data structures in Rust to optimize code performance. Learn efficient programming techniques for better cache utilization.
All You Need to Know About the Rust FFI - Lecture 2
Explore Rust's Foreign Function Interface (FFI) for seamless integration with other languages. Learn about ownership, borrowing, memory management, and handling complex data types across language boundaries.
Rust Memory Management - Introduction and Overview
Introducción rápida a la gestión de memoria única de Rust, enfocándose en conceptos clave como propiedad, préstamo y seguridad de hilos para programadores de sistemas.
Geeking Out with WebAssembly and Kubernetes Using ContainerD Shims
Explore WebAssembly integration with Kubernetes using ContainerD shims, covering features, risks, and practical demonstrations for cloud-native development.