currency

Rob Pike's Go talk distinguishing concurrency, the structuring of independent processes, from parallelism, their simultaneous execution. It uses Go channels and goroutines to illustrate.

Rob Pike's 2010 talk at OSCON's Emerging Languages Camp on where Go's concurrency style comes from. It traces the idea from Hoare's CSP through Squeak, Newsqueak and Limbo to Go.

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.

Nathaniel J. Smith's PyCon 2018 talk introducing Trio, a Python concurrency library designed around usability and structured concurrency. He live-codes a problem and analyzes pitfalls in other async libraries.

Andreas Antonopoulos argues that money has a fourth function beyond store of value, medium of exchange and unit of account, which is as a system of control. He covers the history of money and why it does not flow freely.

Jonathan Worthington's YAPC Asia 2015 talk on parallelism, concurrency and asynchrony in Perl 6. It covers the language's concurrency features.

Go runtime contributor Dmitry Vyukov looks inside the Go scheduler, explaining how goroutines and channels are implemented. He covers the main scheduler components and overall operation, then goes into details such as preemption and stacks.

Rich Hickey's long presentation on Clojure and concurrency covers locking and immutability, then goes in depth on refs, transactions and agents. It ends with a multithreaded ant colony simulation demo.

Raymond Hettinger's PyBay 2017 keynote on concurrency in Python. It covers threads, processes, asyncio, locks and the GIL, with live shell-based examples.

A panel with Tony Hoare, Joe Armstrong and Carl Hewitt, hosted by Francesco Cesarini, on the history and future of concurrency. The three creators of CSP, Erlang and the actor model discuss their differing approaches.

Hillel Wayne's Strange Loop talk introducing TLA+ as a specification language for finding concurrency bugs in designs. It covers stalling, race conditions and dropped messages, with PlusCal examples.

Zig creator Andrew Kelley's RedisConf 2020 talk on modeling data flow with asynchronous I/O in Zig. It explains how Zig's async/await avoids function coloring, and Loris Cro demonstrates OkRedis, a zero-allocation Redis client.

A Google Tech Talk by the author of Kilim, a Java library for lightweight actor-style message passing. It argues that message passing can replace shared-memory concurrency and claims performance competitive with or better than Erlang for huge numbers of actors.

CppCon 2014 talk by Jeff Preshing on how Ubisoft Montreal developed games for multicore hardware, before and after C++11 concurrency support. It goes into atomics and lock-free programming in practice.

Joe Grand recounts being hired to hack a Trezor One hardware wallet and recover $2 million of cryptocurrency. He describes three months of experimentation, voltage glitching, failures and high-stakes attempts with only one chance to get it right.

Rob Pike presents Go Proverbs at Gopherfest 2015, a set of pithy aphorisms about Go design such as 'Clear is better than clever' and 'A little copying is better than a little dependency'.

Rob Pike's October 2009 Google Tech Talk introducing Go, a new experimental systems language designed for fast builds, concurrency and garbage collection. It covers the goals, syntax and type system.

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.

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.

Kim Nilsson presents his investigation into how Mt. Gox was hacked and mismanaged, tracing the finances and the missing bitcoins. It was given at the 2017 Breaking Bitcoin meetup.

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.

Ian Miers' Devcon4 talk on failures in on-chain privacy for Bitcoin and Ethereum. It covers attacks on transparent and decoy-based schemes, including how Monero-style privacy can be eroded over repeated transactions.

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.

Jon Moore's Strange Loop 2017 talk argues that rate limiting is the wrong tool for protecting services from noisy clients. He proposes concurrency-based capacity management and quotas instead.

Aditya Siram introduces ATS, a statically typed ML-like language that compiles to C and offers type-safe pointer arithmetic and a full proof language. The Strange Loop talk shows off C interop, concurrency and verification features with non-trivial examples.

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.

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.

Sasa Juric explains what makes Erlang and Elixir suited to server-side systems, focusing on the BEAM concurrency model rather than syntax or ecosystem. He demonstrates processes, supervision, and fault tolerance.

Will Wilson of FoundationDB explains how the team tested their distributed database using deterministic simulation. By running the whole system in a simulator with injected faults and reproducible seeds, they could find rare concurrency and network bugs.

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

Apple security head Ivan Krstic gives a Black Hat 2016 talk on iOS security, covering HomeKit, Auto Unlock and iCloud Keychain. He explains key hierarchies and how data can stay safe even in adversarial clouds.

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.

Moxie Marlinspike's BlackHat 2011 talk examines weaknesses of SSL and the certificate authority system and proposes Convergence, a decentralized notary approach with trust agility.

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.