Safe Systems Software and the Future of Computing - Closing Keynote
Explore the future of safe systems programming and its impact on operating systems, drawing insights from Microsoft's innovative projects and addressing technical and cultural challenges.
Type System Tips for the Real World - RustConf 2017
Practical insights into Rust's advanced type system features, including zero-sized types, recursive types, and generics, with real-world examples from Diesel.
RPITIT Deep Dive - Exploring Rust Compiler Errors
Dive deep into Return Position Impl Trait in Trait (RPITIT) with Rust compiler expert @compiler-errors. Explore implementation details and challenges in this advanced session.
MIR Formality Walkthrough - Coherence Overlap Check
Explore MIR formality and coherence overlap checks in Rust programming, enhancing your understanding of the language's internal representation and type system.
Getting Something for Nothing - Using Rust's Type System for Safe Hardware Abstractions
Explore safe hardware abstractions in Rust using the Type System and Borrow Checker, focusing on high-performance microcontroller systems and the embedded-hal 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.
How the Chalk-Engine Crate Works in Rust
Explore the inner workings and functionality of the chalk-engine crate in Rust programming, gaining insights into its design and implementation.
Rust Region Inferencer Discussion - Async-Await Working Group
Rust developers discuss region inferencer changes to address limitations, uncovering unexpected issues while exploring multiple unrelated lifetimes in existential types.
Rustc-Chalk Integration Overview: Plans and Implementation
Overview of rustc-chalk integration plans and implementation, covering answer tables, search strategies, inference contexts, and key components like the trait engine and canonicalization.
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.
Rust Lang Team Design Meeting: Dynamic Traits and Coherence - 2020.01.13
Explore Rust's dyn Trait and coherence in this Lang Team Design meeting, covering key concepts, challenges, and potential solutions for dynamic dispatch.
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.
Polonius Working Group: The Role of Subset Relations in Rust
Explore subset relations in Polonius's design and a proposal for equality-only propagation, enhancing understanding of Rust's borrow checker implementation.
Design Meeting: Workflow Checks and Type Aliases in Rust - 2020-07-29
Explore Rust's design decisions on well-formedness checks and type aliases, covering expected behavior, rationale, and future compatibility considerations.
Types of Types in Rust
Explore Rust's type system, including kind bounds, traits, closures, and existential types. Learn advanced concepts for more effective Rust programming.
Rust Typeclasses - Trait-Based Programming
Explore Rust's trait system and its similarities to typeclasses in functional programming languages, presented by researcher Lindsey Kuper.
Rewriting Scientific Computing Tools in Rust - Challenges and Lessons Learned
Exploring Rust's potential in scientific computing by rewriting linear algebra, complex functions, and FFT from Octave. Discusses challenges, benefits, and lessons learned in improving scientific tools.
Subtyping in Rust - Magic and Misconceptions
Explore Rust's subtyping, variance, and advanced data structure concepts with Felix Klock. Gain insights into Rust's unique approach to type systems and memory safety.
Traits and Types in Rust - PDXRust May 2016
Explore Rust's type system, traits, and custom implementations. Learn about basic and built-in types, methods, constructors, and useful traits from the standard library.
Froyo: Overview of Rust-Based Storage Management System
Learn about Froyo, a Rust-based storage management system. Explore its architecture, device mapping, metadata handling, and integration with technologies like RAID and DBus.
The Builder Pattern and Typestate Programming in Rust
Explore the Builder Pattern in Rust, its advantages, and how Rust's type system enhances its implementation. Learn about typestate programming and practical applications.