rust

Without Boats, a Rust language team member, explains the design of Rust's async/await at RustLatam 2019. He covers the history and constraints behind zero-cost, allocation-free async state machines.

Raph Levien presents his new Rust GUI framework, built on data-oriented design and ideas from entity component systems, for the Xi editor. He weighs the approach against alternatives and discusses pros and cons.

Jon Gjengset's Rust NYC talk explaining what `unsafe` in Rust actually means, why it is dangerous, and why it is sometimes necessary. He works through the Rustonomicon to separate fair concerns from overblown ones.

Mark Russinovich's closing keynote at Rust Nation UK on Microsoft's adoption of Rust, covering security gains, integration challenges, performance results and lessons learned.

Lars Bergstrom of Google presents how Rust improves team productivity beyond safety and speed, with data on rewrites, defects and review. It compares Rust teams to those on legacy native languages and Go.

Rik Arends presents Makepad, a Rust UI framework, at RustNL 2023. The talk covers designing modern, GPU-fast UIs with Rust and includes live-coded demos of an IDE and a synthesizer.

Steve Klabnik walks through the history of Rust and how its design evolved toward async/await, including the alternatives tried and dropped. He also discusses the difficulty of adding a major feature to a language.

Bryan Cantrill's QCon SF 2019 talk asking whether operating systems should be rewritten in Rust. He draws on his systems experience to discuss C, memory safety and Rust's fit for system software.

Carol Nichols' Philly ETE 2019 talk on what makes Rust unique. It covers memory safety, how editions let the language evolve without breaking code, and who relies on Rust in production.

Kent Overstreet's Linux Foundation talk about writing a filesystem in Rust. Its Q&A segment, where Rust-for-Linux developers ask about interface semantics, became widely cited.

Catherine West's RustConf 2018 closing keynote on building a game in Rust and organizing a large codebase. It builds up an entity component system and generational indices step by step.

Raph Levien presents Xi editor at RustConf 2016, a high-performance text editor built in Rust. The talk goes into technical details, building polished GUI apps, and running a community-focused open source project.

Leptos creator Greg Johnston examines Rust/WebAssembly frontend frameworks against JavaScript frameworks using the JS framework benchmark. He argues that WASM is no longer too slow for DOM-heavy rendering.

RustConf 2020 closing keynote by Sian Griffin that dives into Pokemon Blue glitches, notably Missingno and arbitrary-code-execution tricks. It uses them to explain how memory unsafety works and how memory-safe languages like Rust prevent such bugs.

Joe Duffy's RustConf 2017 closing keynote on his experience at Microsoft building Midori, an operating system written in a Rust-like safe systems language. He covers the technical and cultural challenges of applying those lessons to Windows.

An excerpt from a Bay Area Rust meetup on Servo's WebRender, which renders CSS display lists on the GPU at very high frame rates. It explains the approach and demos rendering at around 500 FPS.

A 36C3 talk by Bunnie Huang arguing that open source is necessary but not sufficient for trustworthy hardware, because verifying hardware is destructive and so creates a time-of-check/time-of-use gap. It surveys supply chain security and classes of hardware attacks, and presents the Betrusted approach to narrowing that gap.

Bryan Cantrill argues that programming languages and platforms reflect core values, and compares languages through that lens, with Rust as a main example. He draws on his experience with Solaris, DTrace and ZFS.

Joanna Rutkowska's 32C3 talk asks whether trustworthy client systems can be built on x86 hardware, and what realistically can be done about the challenges, such as Intel ME.

Joe Armstrong, creator of Erlang, and Jeremy Ruston, creator of TiddlyWiki, discuss hypertext, Ted Nelson's idea of intertwingled knowledge, and a way to combine TiddlyWiki with Erlang. It is a Code Mesh LDN 2018 talk.

Rusty Russell and Matt Evans examine why Unix utilities like ls and cat grew from a few kilobytes to over a hundred kilobytes. They take apart common tools to see where the growth comes from.

David Weston's BlueHat IL 2023 talk traces the evolution of Windows security and previews Windows 11 and hardware advances. It ends with upcoming changes such as Rust in the kernel and fonts, signed binaries and adminless Windows.

Bryan Cantrill of Oxide Computer Company gives a Stanford EE380 talk on rethinking the server. He argues that hyperscaler-style rack-scale machines with open firmware, RISC-V and Rust should be available to everyone, not just the giants.

Jack Moffitt presents the architecture of Servo, Mozilla's experimental browser engine written in Rust, focusing on parallelism across cores, GPUs and SIMD and the safety properties gained from Rust.

Charlie Marsh of Astral explains how uv, a Rust Python package manager, got so fast. He covers allocators, concurrency, zero-copy tricks and the challenges of Python packaging.

Robert Collins explains why rustup installs were painfully slow on Windows and how changes to rustup and Windows cut install time from 3m30s to 14s. The talk covers NTFS, small files and the cost of antivirus hooks on file close.

Jack Moffitt presents Servo, an experimental browser engine written in Rust and designed to be parallel at every level, using multiple cores, the GPU, fork-join concurrency and SIMD. The talk covers motivations, architecture and plans for the project.

Isaac Freund, author of the River Wayland compositor, talks about writing a Wayland compositor in Zig. He covers why he chose Zig over C and Rust and how Zig can wrap a hairy C library.

Cory Doctorow's DEF CON 31 talk describes how platforms decay in a pattern he calls enshittification. He lays out a plan to stop it through antitrust, interoperability and fixing the law.

Simon Peyton Jones presents linear types for Haskell, showing how practical linearity can fit into a higher-order polymorphic language. The talk covers motivations such as resource handling and relates the ideas to Rust.

Matt Kulukundis explains how Google designed SwissTable, a fast, cache-friendly hash table, step by step from std::unordered_map. The talk covers open addressing, SIMD probing and the tradeoffs of changing a fundamental data structure.

Herb Sutter's CppCon 2015 plenary on writing safe, modern C++ by default using the C++ Core Guidelines. It includes a demo of lifetime-checking static analysis tooling.

Louis Brandy presents the most common and infamous recurring C++ bugs seen in Facebook's huge codebase, including shared_ptr data races and operator[] pitfalls. He explains the surprising complexity behind seemingly simple code.

Part two of Herb Sutter's C++ and Beyond 2012 session on atomic weapons, a deep dive into the C++ memory model, atomics, memory ordering, and hardware behavior. It ends with the modern meaning of volatile.

Andrei Alexandrescu's CppCon 2015 talk argues that std::allocator is badly designed. He proposes building high-performance allocators from small composable, templated pieces.

Rob Pike shows how the Go text/template lexer is built, using state functions, goroutines and channels. The talk was given at a Google Technology User Group in Sydney in 2011.

Jason Turner's CppCon 2016 talk builds a simple Commodore 64 game using C++17, showing how constexpr and const let a modern compiler produce tight 6502 code. He walks through assembly output to show abstractions being optimized away.

Mike Acton of Insomniac Games argues that a program's purpose is transforming data, and shows how common C++ approaches work against that in performance-critical game development. He covers cache behavior, data layout and the limits of compilers.

Eskil Steenberg's two-hour talk on his personal approach to writing C, covering code style, structure, naming, pointers and large-project organization. He warns it contains a fair bit of programming religion.

Rob Pike's Google I/O 2012 talk shows how goroutines and channels solve tricky concurrency problems with simple Go code. It features a playful goroutine demo with gophers passing messages and a search engine example.