IV

TODO

Things I've read or listened to (or want to) and plan to take notes on.

Jon Gjengset

  1. impl Rust: One Billion Row Challenge

  2. Decrusting the serde crate

  3. A lot more

Graydon Hoare

  1. The Rust I Wanted Had No Future

  2. Abstract machines and the compilers that love/hate them

  3. Rust is mostly safety

  4. TODO add more — lots of interesting stuff here

kernel.org

  1. #link-new-tab("What is RCU? — \"Read, Copy, Update\"", "https://docs.kernel.org/RCU/whatisRCU.html")

  2. Sequence counters and sequential locks

  3. TODO also add more here

Cliffle (Cliff L. Biffle)

  1. Learn Rust the Dangerous Way

  2. How to think about async/await in Rust (combine into bigger note about Rust futures & async)

  3. Mutex without lock, Queue without push: cancel safety in lilos

  4. Composing concurrency in drivers

  5. On Hubris And Humility

  6. Why Rust mutexes look like they do

  7. The First-Mover Allocator Pattern

  8. Making really tiny WebAssembly graphics demos

  9. The Typestate Pattern in Rust

  10. Attacks on my Server: The Data

Rustonomicon

  1. Atomics

  2. Implementing Vec

  3. Implementing Arc and Mutex

  4. Uninitialized Memory

Adrian Sampson

  1. Flattening ASTs (and Other Compiler Data Structures)

  2. Bril: An Intermediate Language for Teaching Compilers

  3. Manual Test-Case Reduction

  4. FPGAs Have the Wrong Abstraction

  5. Is JavaScript Statically or Dynamically Scoped?

Verdagon (Evan Ovadia)

  1. Borrow checking, RC, GC, and the Eleven (!) Other Memory Safety Approaches

  2. Higher RAII, and the Seven Arcane Uses of Linear Types

  3. The Impossible Optimization, and the Metaprogramming To Achieve It

  4. Group Borrowing: Zero-Cost Memory Safety with Fewer Restrictions

  5. Exploring Seamless Rust Interop for Newer Languages, Part 1

  6. Vale’s First Prototype for Immutable Region Borrowing

  7. Hash Codes, Non-Determinism, and Other Eldritch Horrors

Faster than a Lime

  1. Introducing facet: Reflection for Rust

  2. The virtue of unsynn

  3. strace feels like magic — let’s fix that (with Rust)

Oxide

  1. Futurelock

  2. Helios: post, video

  3. Dealing with cancel safety in async Rust

  4. Holistic Boot

  5. Propolis

  6. TODO add other Oxide & Friends

Blargh (Thomas Habets)

  1. io_uring, kTLS and Rust for zero syscall HTTPS server

Hillel Wayne

  1. 10 Most(ly dead) Influential Programming Languages

  2. Planner programming blows my mind

Mond

  1. Type Inference in Rust and C++

Sunshowers (Rain)

  1. Debugging a rustc segfault on illumos

  2. Rain’s Rust CLI recommendations

  3. Lifetime variance in Rust (combine with Rustonomicon: Subtyping and Variance)

  4. The social consequences of type systems

  5. Example: implementing Borrow for complex keys

Ginger Bill

  1. On the Aesthetics of the Syntax of Declarations === Sebastian Bensusan

  2. We need visual programming. No, not like that.

Fernando Borretti

  1. Introducing Austral: A Systems Language with Linear Types and Capabilities

Chris Siebenmann

  1. I don’t think error handling is a solved problem in language design

Polybdenum

  1. Why You Need Subtyping

Ulrich Drepper

  1. What Every Programmer Should Know About Memory (long)

Yorick Peterse

  1. The inevitability of the borrow checker

Celes

  1. The Language That Never Was

Ryan Brewer

  1. Par Part 1: Sequent Calculus

  2. Par Part 2: Linear Logic

Phantie

  1. Inventing a Better Compression Algorithm for a Specific Problem

Mike Davis

  1. Sparse arrays in Rust and creating custom DSTs.

Conviva

  1. The Concurrency Trap: How An Atomic Counter Stalled A Pipeline

Other Topics

  • DTrace

  • eBPF

  • Async architectures (cooperative multitasking, work stealing, etc.) & Tokio specifically

  • LLVM

  • OS

  • VMs

  • PL topics (lexers, parsers, ..)

  • Hashing

  • Maybe also do some basic topics?