memory errors

Emery Berger's CppCon 2019 talk introducing Mesh, a drop-in malloc replacement that compacts memory in unmodified C and C++ programs. It tackles fragmentation by merging pages without changing pointers.

Herb Sutter's deep C++ and Beyond 2012 talk on atomics and the C++ memory model, covering why programmers chasing top performance need to understand hardware ordering. This is part one of two.

Fedor Pikus's CppCon 2017 talk on C++ atomics, looking at what they let the programmer express and what the hardware actually does. It covers memory ordering and lock-free programming from basic to advanced.

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.

In this TED talk, Nobel laureate Daniel Kahneman distinguishes the experiencing self from the remembering self, using examples such as vacations and colonoscopies. He explains how the two perceive happiness differently and what that means for economics, policy and self-awareness.

Ahmon Dancy of Franz Inc explains low-level programming in Common Lisp, including off-heap data structures used in AllegroGraph to manage memory outside the garbage collector.

Bobby Powers presents Mesh, a drop-in malloc replacement that eliminates memory fragmentation in unmodified C/C++ programs by compacting memory. The talk covers how it works despite C's fixed object addresses, and its benefits for programs like Redis.

Kiran Pamnany's Cambridge Julia Meetup talk on Julia's shared memory parallelism and its new task scheduler. It argues that fork-join and work-stealing models nest poorly and presents depth-first scheduling for composable parallelism.

Artem Dinaburg's DEF CON 19 talk on bit-squatting, where flipped bits in DRAM cause devices to contact domains that differ by one bit from legitimate ones. He shows how registering such domains can hijack traffic without exploiting any software bug.

A DEFCON 21 talk by Robert Stucke on DNS errors caused by single-bit flips, which lead to requests for misspelled domains. It shows real-world data on bitsquatting.

Olivier Giroux's CppCon 2019 talk recounts the roughly ten-year effort to bring std::atomic and the C++ memory model to CUDA GPUs, through ten stories from that work.

R. Stanley Williams of HP Labs gives a keynote on the memristor, covering the physics, crossbar computation, and potential for memory and new computer architectures.

Herb Sutter's CppCon 2016 talk on lifetime safety in C++, aiming for code free of leaks and dangling pointers by default. It covers smart pointers, ownership, reference counting pitfalls and deferred reclamation resembling garbage collection.

David Crane, designer of Pitfall for the Atari 2600, gives a GDC 2011 postmortem on the game's design challenges. He covers how he fit a large world into the console's tiny memory. The session ends with Q&A.

Nicholas Ormrod's CppCon 2016 talk on how Facebook optimizes std::string with its open-source replacement fbstring. It covers storage layout tradeoffs, small string optimization and memory allocation behavior.

Scott Meyers explains how CPU caches work and why they matter for performance, covering cache levels, access speeds, associativity, and effects in multithreaded code. The focus is C++ and cache-aware, data-oriented programming.

Simon Knowles, co-founder and CTO of Graphcore, talks about "intelligence processors", chips designed specifically for machine learning. The talk was given at the RAAIS 2017 summit and covers Graphcore's architecture.

Cliff Click walks through a small performance example on a modern out-of-order CPU. He covers pipelining, ILP, CISC vs RISC, multicore, and why cache misses and the memory subsystem dominate performance.

Artem Dinaburg's DEF CON 19 talk on bit-squatting, where DRAM bit flips cause DNS requests to go to domains one bit off from the intended one. It shows how hardware faults can be exploited for hijacking without any software exploit.

Brian Troutwine's Code Mesh 2015 talk on the Apollo Guidance Computer. It covers the AGC's design, core rope memory, its interrupt and software behavior, and the pioneering engineering effort behind it.

Matt Parker's Royal Institution talk based on his book Humble Pi, covering everyday mathematical mistakes and spurious patterns that went wrong in engineering and software. It mixes stand-up comedy with stories of coincidence and error.

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.

Christopher Domas's Black Hat 2015 talk on a long-unnoticed x86 design flaw that lets an attacker reach System Management Mode, a ring below the OS. It explains how the legacy architecture allows universal privilege escalation and persistent, hard-to-detect malware.

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.

Gor Nishanov's CppCon 2018 talk on using tiny C++ coroutines to hide memory latency, interleaving useful work while prefetches bring cache lines in from main memory.

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

Emery Berger explains why performance is hard to measure and deliver on modern hardware, showing how code layout and alignment can swamp optimization effects. He presents Stabilizer for statistically sound evaluation and Coz, a causal profiler.

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.

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.

A collection of lightning talks from the Surge 2015 conference on scalable systems, hosted by Geir Magnusson. HN mostly points to one segment, a Bryan Cantrill talk touching on madvise semantics.

Microsoft's Tony Chen explains how the Xbox One was designed to resist physical attacks, including secure boot, encrypted memory, a security processor and a hypervisor. The goal was to make any hardware attack cost more than the price of many games.

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.

Optiver's Carl Cook explains how to build high-frequency trading systems in C++, where the critical path runs rarely but must be extremely fast. He covers techniques for low and predictable latency, including avoiding main memory and cache misses.

A 2007 Google Tech Talk in which Cliff Click of Azul Systems presents a lock-free concurrent hash table that scales to 768 CPUs. He explains why it is correct by reasoning in a different way than usual happens-before and memory-order arguments.

Matt Might's Curry On talk on ending errors in code, both software and the human genome. He covers conservative approximation of the halting problem via static analysis and a computational approach to precision medicine.

Raymond Hettinger's PyBay 2019 talk on the mental habits behind effective programming, drawn from coaching, teaching and StackOverflow. He covers problem decomposition, chunking, managing working memory and getting unstuck.

Jonathan Blow's GDC talk explains how the time-rewind mechanic in Braid was designed and implemented, including the technical hurdles such as memory limits and state history. It covers both design and engineering concerns.

Michael Feathers' GOTO Chicago 2018 talk on reducing error checks and conditional logic in code. He offers a framework for handling errors and decisions at the level of code and architecture.

Malte Skarupke's C++Now 2018 talk on hash table performance, explaining why std::unordered_map is slow and memory hungry and presenting faster designs, including his bytell hash map.

Bjarne Stroustrup's keynote at Going Native 2012 covers the ideas behind C++11, including using types to prevent errors and simplifying code with the STL.