herb sutter

Herb Sutter revisits basic C++ questions in light of C++11 and C++14: how to declare and initialize variables, pass values to functions, write loops, and use smart pointers. It covers auto, rvalue references, range-for, uniform initialization, lambdas, unique_ptr and shared_ptr.

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.

Herb Sutter's CppCon 2022 talk on whether C++ can become ten times simpler and safer. He introduces his experimental Cpp2 syntax and the cppfront transpiler, explaining the limits on incremental improvement.

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.

Herb Sutter's CppCon 2019 talk on the split in the C++ community over exceptions and RTTI. He proposes making exceptions cheaper and more usable, including a zero-overhead, Result-like design.

At CppCon 2017 Herb Sutter presents his work on evolving C++ through compile-time code generation, including metaclasses and reflection. The aim is to make the language both more powerful and simpler by letting programmers express intent directly.

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.

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.

Cathode Ray Dude's hour-long retrospective on the ABIT BP6, the dual-Celeron motherboard. He covers early multiprocessing, its legend, a build, running NT 4, benchmarks and the pros and cons of early SMP.

WIRED's 5 Levels format with Jacob Collier explaining harmony to a child, a teen, a college student, a professional and Herbie Hancock.

Motherboard's 2014 visit to a secretive Bitcoin mining operation in a repurposed factory in Liaoning, China, one of six sites producing about 4,050 bitcoins a month. It shows the machines and the workers' living conditions.

A Motherboard documentary in which a reporter lives on nothing but Soylent for 30 days after founder Rob Rhinehart's own experiment. It looks at the effects on health, Silicon Valley and the future of food.

The preface to Herb Gross's MIT OpenCourseWare 'Calculus Revisited: Single Variable Calculus', an older black-and-white lecture series. It introduces his approach to teaching calculus from the basics.

Herbert Wolverson's Roguelike Celebration 2020 talk surveying procedural map generation techniques, including integration of hand-crafted prefabs and vaults.

Der8auer tours Hetzner's test lab and shows a custom AM5 server motherboard with the CPU socket rotated 90 degrees, built for rack airflow in their AX52 servers.

Veritasium's long documentary on the history of Monsanto's herbicides, including glyphosate, and how patented seeds prevent farmers from replanting. It covers agricultural chemistry, litigation and corporate 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.

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.

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.

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.

Jonathan Blow's first talk on designing a new programming language for games, which became Jai. He explains the problems with C++ and why Go, Rust and D do not fit game development.

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.

Chandler Carruth argues in a CppCon 2019 talk that C++ has no truly zero-cost abstractions. Using examples like unique_ptr, ABI constraints and compile-time costs, he shows that abstractions cost runtime, compile time or human effort.

Juan Pedro Bolivar Puente explains immutable and persistent data structures in C++ and how they support value semantics. He presents the Immer library, rrb-trees, and a prototype text editor that opens a huge file instantly.

Zig creator Andrew Kelley justifies why Zig exists and tours its distinctive features, including C interoperability and comptime, along with what people had built and what 1.0 would bring. It was given at Philly ETE 2019.

Casey Muratori argues against smart pointers and RAII, advocating grouped-element thinking, zero-is-initialization and stubs as better ways to structure memory and handle errors.

Rob Pike's dotGo 2015 talk argues that Go only seems simple, and that its simplicity hides real complexity that is part of the design. He explains the thinking behind Go's restraint in features.

Titus Winters' CppCon 2017 talk argues for C++ and Google's Abseil to be maintained as a live at head language, relying on testing and automated tooling rather than never changing or promising no compatibility. It covers Hyrum's law and the limits of semantic versioning.

Andrei Alexandrescu's CppCon 2019 talk revisits sorting, showing how branchless tricks, hybrid strategies and a cost metric can speed up std::sort-style algorithms on modern hardware.

Matt Godbolt's CppCon 2017 talk shows what modern compilers do with your C++ code, using Compiler Explorer to inspect generated assembly. It covers surprising optimizations and how the tool works.

Bisqwit builds a Doom or Duke Nukem 3D style software-rendered 3D engine in C from scratch, supporting non-Euclidean geometry. It covers vector rotation and portal rendering with sped-up, tool-assisted coding.

Liz Rice live-codes a minimal container runtime in a few lines of Go at GOTO Amsterdam 2018. She explains namespaces, control groups and what a host knows about its containers.

Greg Law's 15-minute CppCon 2015 lightning talk shows what GDB can do beyond basic use, including its text user interface and reverse debugging.

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.