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.

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.

Jon Gjengset's long live-coding stream explains Rust's Pin and Unpin types: why they exist, how they work, and how they connect to futures and async/await. It also covers moving from pre-pinning code to the new model.

Jonathan Blow's hour-long livestreamed response to a RustConf 2018 closing keynote about entity systems in Rust. He argues that index-based entity systems amount to manual memory management that sidesteps the borrow checker, and he talks about friction for game developers.

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.

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.

A guest lecture Jon Gjengset gave at Two Sigma on using Rust for large, high-performance systems. It covers why Rust suits such projects, the Noria research database, a concurrent data structure used in it, and practical experience.

A 39-minute highlights reel of Bill Gates being deposed by David Boies in the 1998 to 2001 United States v. Microsoft antitrust case.

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.

A short Channel NewsAsia interview clip in which MasterCard's Southeast Asia president voices distrust of cryptocurrencies produced by anonymous computers in anonymous places. It is part of the Perspectives series and runs about four minutes.

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.

Kurzgesagt addresses whether viewers can trust its videos, describing its research process and how it handles older videos with errors or overstated claims.

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.

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.

A demo excerpt from a 2016 Bay Area Rust meetup showing Servo's WebRender drawing CSS on the GPU at very high frame rates. It presents the promise of GPU-based browser rendering.

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.

Patreon CEO Jack Conte explains how Patreon thinks about content policy and why it removed the pages of Lauren Southern, members of Defend Europe and IGD. He also describes the company's trust and safety commitments.

A short clip of Milton Friedman explaining his free-market view of monopoly, namely that monopolies persist mainly through government help. It is excerpted from the Milton Friedman Speaks series.

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.

AdoredTV's history of Intel's monopolistic behavior over three decades, covering its dealings with AMD and its anti-consumer practices.

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.

Kate Gregory argues at CppCon 2015 that C++ should be taught without starting from C: no char* strings, printf or raw arrays at first, with references before pointers.

Andrew Kelley, creator of Zig, introduces the language at the Recurse Center's Localhost series in 2018. He covers its goals of robustness, optimality and clarity, C interop, cross-compilation and explicit allocators.

Chandler Carruth's CppCon 2014 talk on writing fast C++, explaining why data structure choice and memory layout matter more than clever algorithms. It covers why standard containers like unordered_map perform poorly on modern CPUs.