Programming Talks

I watch a lot of talks that I love to share with my friends, fellows and coworkers. As I consider all GitHubbers my friends (oh yeah!), I decided it's time to share the list.

There are talks on programming language specifics as well as a more general section I call "theory". But don't expect to always get theoretical computer science for every talk there; most of them are on the architecture and design of software.

I welcome every contribution to the list; for guidelines look below.

Disclaimer: I did not give any of the talks on the list and am responsible neither for their content nor for their presentation. All links below will direct you to external sites (mostly YouTube, really), be aware of that. If you are one of the people responsible for the talks or the platform presenting it and want it removed, tell me and I'll sort it out with you.

[A] after a talk name denotes a talk that someone thought could be listened to as audio, without needing the video. This may not reflect your experience with the talk, but you can make a pull request to change it.

Names to look out for

To make choosing the right speakers a tad easier, let me give you a quick overview over my favourite speakers in no particular order:

• Scott Meyers (C++): Scott Meyers is one of the most entertaining and knowledgeable speaker when it comes to all things C++. His talks cover a variety of topics, from type inference to API design and cache lines.
• Rich Hickey (Clojure): I am not a Clojure programmer, but I like reasoning about and building programming languages. Even if you don't, Rich Hickeys talks are inspiring and thought-provoking. Whenever he talks about the fundamentals of programming and reasoning, you are sure to learn a ton. Oh, and if you program in Clojure, you have no excuse for not watching this guy speak.
• Reginald Braithwaite (JavaScript): one of my favourite JavaScript speakers. He also has a variety of talks on my list, but is more true to his realm (JavaScript) than most of the other speakers on my list.
• David Nolen (Clojure/Clojurescript): The core maintainer of Clojurescript. His talks mostly focus on immutability and share a bit of their structure. He doesn't get boring, though, and is another very smart person with deep insights in such fields as immutability.
• David Beazley (Python): The person who singlehandedly made me a Pythonista. Need I say more? He has a lot of low-level knowledge about Python and makes poking at the Python interpreter seem more fun than it actually is.
• Joe Armstrong (Erlang): One of the few people I actually had the chance to see live already. He is a funny, witty and smart guy and if you want to learn about Erlang, watch his talks. Most of his talks are also very beginner-friendly.
• Brandon Rhodes (Python): Yet another Pythonista. His talks are enjoyable, enlightening and his way of talking is just enjoyable - you might think that is secondary, but it is really important. His talk on Tolkien is one of the most enjoyable diversions on this list (and a bit off-topic, mind you).
• Aaron Patterson (Ruby): Probably the most entertaining speaker on the list. As a core developer of both Ruby and Rails, he works close to the heart of the Ruby community.
• Philip Wadler (Haskell, Theory, ...): Incredibly knowledgeable gentleman. If you use generics in Java, you owe that to him. If you use Haskell and/or monads, you probably already know him, but in case you do not, try to change that fact. He makes theoretical computer science more approachable than it actually is, and that is a good thing.
• Zach Tellman (Clojure, Theory): Another person in the Clojure landscape with interesting, important insights that do not only apply to Clojure. His talks on theory should inspire you to think more deeply about what you are doing, which is probably the most important thing to take away from anything ever.

Contents

• On Programming Languages
  • Alpaca
  • APL
  • Assembly
  • Bash
  • C
  • Clojure
  • C++
  • Crystal
  • CSS
  • D
  • Elixir
  • Elm
  • Erlang
  • F#
  • Factor
  • Frege
  • Go
  • Hackett
  • Haskell
  • Idris
  • Java & Android
  • JavaScript
  • Julia
  • Lisp
  • Objective C
  • OCaml
  • Prolog
  • PureScript
  • Python
  • Racket
  • Ruby
  • Rust
  • Scala
  • Scheme
  • Smalltalk
  • Swift
  • Unison
  • VimL
  • Wolfram Language
• On theory
  • Compilers/Interpreters
  • Computer Graphics and Vision
  • Creative Technology
  • Databases
  • Data Science
  • Data Structures & Algorithms
  • Debugging
  • DevOps
  • Distributed Systems
  • Entrepreneurship
  • Functional Programming
  • Game Development
  • Hardware
  • Logic Programming
  • Machine Learning
  • Mathematics
  • On Languages
  • On the Industry/Community
  • Operating Systems
  • Performance Engineering
  • Programming Language Design
  • Program Synthesis
  • Research
  • Robotics
  • Security
  • Software Development
  • System Architecture
  • Testing
  • Theoretical Computer Science
  • Type Theory
  • UX/UI
  • Web Development
• Miscellaneous
• Contributing

On Programming Languages

Alpaca

• Alpaca: Static Typing on the BEAM [00:45:34] by Jeremy Pierre (2017)

APL

• Lessons for the Masses from the Trenches of Co-dfns by Aaron Hsu (2019)
• Tacit Techniques with Dyalog version 18.0 Operators by Marshall Lochbaum (2019)
• Patterns and Anti-patterns in APL: Escaping the Beginner's Plateau [00:59:02] by Aaron Hsu (2017)
• 50 Years of APL Datatypes: From Booleans to Hypercomplex Numbers [00:39:21] by Bob Smith (2016)

Assembly

• Enough x86 Assembly to Be Dangerous [00:30:58] by Charles Bailey (2017)
• The Teensy ELF Executable [00:49:03] by Brian Raiter (2014)

Bash

• The Functional Tao of Bash [00:48:12] by Garrett Smith (2015)

C

• Advanced C Coding For Fun! [00:46:53] by Rusty Russell (2014)
• Writing application fault handlers [00:49:03] by Gilad Ben-Yossef (2008)

Clojure

• Expeditious Code via Inference [00:45:36] by Mike Fikes (2019)
• fn and Games with Arcadia [00:53:49] by Ramsey Nasser (2019)
• Rethinking Identity with Clojure [00:41:53] by David Nolen (2019)
• Solving Problems the Clojure Way [01:02:55] by Rafal Dittwald (2019)

• Every Clojure Talk Ever [00:27:36] by Alex Engelberg & Derek Slager (2018)
• Functional Programming in Anger [00:42:05] by David Nolen (2018)
• Java Made (Somewhat) Simple [00:40:45] by Ghadi Shayban (2018) [A]
• REBL [00:33:05] by Stuart Halloway (2018)

• Core.Async in Use [00:34:04] by Timothy Baldridge (2017)
• Symbolic Assembly: Using Clojure to Meta-program Bytecode [00:39:42] by Ramsey Nasser (2017)
• Bare Metal Clojure with clojure.spec [00:36:07] by Michael Reitzenstein (2016)
• Clarifying Rules Engines with Clara Rules [00:37:07] by Mike Rodriguez (2016)
• Clojure at DataStax: The Long Road From Python to Clojure [00:29:28] by Nick Bailey (2016)
• Composing music with clojure.spec [00:46:30] by Wojciech Franke (2016)
• Creating DSLs - A tale of spec tacular success and failure [00:39:46] by Claire Alvis (2016)
• Full stack FP in Datomic, Clojure, and ClojureScript [00:51:30] by Priyatam Mudivarti (2016)
• Live-Coding Mathematics Your First Clojure Proof [00:41:54] by Frederic Peschanski (2016)
• Managing One of the World's Largest Clojure Code Bases [00:41:05] by Donevan Dolby (2016)
• Parallel Programming, Fork Join, and Reducers [00:40:53] by Daniel Higginbotham (2016)
• Proto REPL, a New Clojure Development and Visualization Tool [00:30:10] by Jason Gilman (2016)
• Spec-ulation [01:16:23] by Rich Hickey (2016)
• The Next Five Years of ClojureScript [01:00:57] by David Nolen (2016)
• Using Clojure with C APIs for crypto and more [00:41:07] by lvh (2016)

• Bottom Up vs Top Down Design in Clojure [00:36:41] by Mark Bastian (2015)
• Building a Bicycle for the Mind [00:26:39] by David Nolen (2015)
• Clojure, Made Simple [01:00:43] by Rich Hickey (2015)
• ClojureScript + React.js: How I learned to stop worrying and love the browser [00:52:24] by Norbert Wójtowicz (2015)
• ClojureScript for Skeptics [00:41:08] by Derek Slager (2015)
• Condition Systems in an Exceptional Language [00:33:31] by Chris Houser (2015)
• Data Science in Clojure [00:44:03] by Soren Macbeth (2015)
• Developing ClojureScript With Figwheel [00:45:30] by Bruce Hauman (2015)
• Domain Specific Type Systems [00:40:05] by Nathan Sorenson (2015)
• From REST to CQRS with Clojure, Kafka, & Datomic [00:44:24] by Bobby Calderwood (2015)
• Game Development Development [00:35:09] by Michael Nygard & Ragnar Svensson (2015)
• Genetic Programming in Clojure [00:40:07] by Lee Spector (2015)
• Hoplon and Javelin, WebDev Alternative Reality [00:22:07] by Micha Niskin (2015)
• Om Next [00:39:22] by David Nolen (2015)
• Purely Random [00:38:04] by Gary Fredericks (2015)
• Pattern Matching in Clojure [00:47:02] by Sean Johnson (2015)
• Simplicity in Practice [00:30:47] by Luke VanderHart (2015)
• Solving Problems with Automata [00:38:03] by Mark Engelberg & Alex Engelberg (2015)
• Specter: overcome your fear of nested Clojure data [00:41:50] by Nathan Marz (2015)
• The ReactJS Landscape [00:41:03] by Luke VanderHart (2015)
• The Relevance of ClojureScript [00:36:16] by Jearvon Dharrie (2015)

• Always Be Composing [00:35:11] by Zach Tellman (2014)
• ClojureScript: Lisp's Revenge [00:32:03] by David Nolen (2014)
• Enter the Matrix [00:40:00] by Mike Anderson (2014)
• How Clojure Works: Understanding the Clojure Runtime [00:30:07] by Daniel Solano Gomez (2014)
• Making Games at Runtime with Clojure [00:37:34] by Zach Oakes (He's a very funny guy!) (2014)
• Predictably Fast Clojure [00:34:01] by Zach Tellman (2014)
• Typed Clojure in Practice [00:41:57] by Ambrose Bonnaire Sergeant (2014)
• Variants are Not Unions [00:37:53] by Jeanine Adkisson (2014)

• Clojure core.async [00:44:25] by Rich Hickey (2013)
• Clojure Data Science [00:32:40] by Edmund Jackson (2013)
• Clojure Enemy of the State [01:06:31] by Alex Miller (2013)
• Clojure in 10 Big Ideas [00:30:48] by Stu Halloway (2013)
• Clojure Library Core.async for Asynchronous Programming [00:55:32] by David Nolen (2013)
• Core.Async [00:39:45] by Timothy Baldridge (2013)
• Design, Composition and Performance [00:51:10] by Rich Hickey (2013)
• Expert to Expert - Inside Clojure [00:53:56] by Rich Hickey & Brian Beckman (it's not so much a talk as a conversation; awesome for beginners) (2013)
• Jelly stains. Thoughts on JavaScript, LISP & Play [00:19:12] by David Nolen (2013)
• Machine Learning Live [00:27:38] by Mike Anderson (2013)
• Make Your Own Lisp [00:53:52] by Bodil Stokke (2013)
• Playing Go with Clojure [00:35:53] by Zach Tellman (2013)
• Predicate Dispatch [00:28:58] by David Nolen (2013)
• The Macronomicon [00:42:02] by Michael Fogus (2013)

• Clojure Concurrency [02:32:39] by Rich Hickey (2012)
• Why Is A Monad Like A Writing Desk? [00:30:38] by Carin Meier (2012)
• Clojure for Schemers [01:17:27] by David Nolen (2011)
• Persistent Data Structures and Managed References [00:55:53] by Rich Hickey (2009)

C++

• C++ - The Newest Old Language [00:43:36] by Matt Godbolt (2018)
• Memory Latency Troubles You? Nano-coroutines to the Rescue! (Using Coroutines TS, of Course) [01:04:25] by Gor Nishanov (2018)
• Modern C++ in Embedded Systems [01:30:39] by Michael Caisse (2018)
• -Os matters [00:44:12] by Mark Zeren (2018)

• 10 Core Guidelines You Need to Start Using Now [01:02:32] by Kate Gregory (2017)
• Curiously Recurring C++ Bugs at Facebook [00:52:00] by Louis Brandy (2017)
• Fantastic Algorithms and Where To Find Them [00:46:57] by Nicholas Ormrod (2017)
• Meta: Thoughts on generative C++ [01:47:44] by Herb Sutter (2017)
• Postmodern C++ [01:27:46] by Tony Van Eerd (2017)
• Rethinking Strings [01:26:53] by Mark Zeren (2017)
• Rethinking Exceptions [01:23:17] by Jason Turner (2017)
• The Last Thing D Needs [00:54:55] by Scott Meyers (2017)
• The Nightmare of Move Semantics for Trivial Classes [00:57:15] by Nicolai Josuttis (2017)
• Undefined Behavior in 2017: This talk has two parts.
  • Undefined Behavior in 2017, Part I [00:49:22] by John Regehr (2017)
  • Undefined Behavior in 2017, Part II [00:49:22] by John Regehr (2017)

• A <chrono> Tutorial [01:00:31] by Howard Hinnant (2016)
• Better Code [01:20:00] by Sean Parent (2016)
• C++17, is it great or just OK? [01:11:06] by Michael Wong (2016)
• Design Patterns in Modern C++ [01:07:04] by Dmitri Nesteruk (2016)
• Fastware [01:02:16] by Andrei Alexandrescu (2016)
• Making C++ easier, faster and safer: This talk has two parts.
  • Making C++ easier, faster and safer, Part I [01:18:28] by Chandler Carruth (2016)
  • Making C++ easier, faster and safer, Part II [01:16:00] by Chandler Carruth (2016)
• STL Algorithms - How To Use Them and How to Write Your Own [01:30:36] by Marshall Clow (2016)
• Thinking outside the synchronisation quadrant [01:32:50] by Kevlin Henney (2016)

• Better Code: Data Structures [01:03:59] by Sean Parent (2015)
• Support for Embedded Programming in C++11 and C++14 [01:12:52] by Scott Meyers (2015)
• Tuning C++: Benchmarks, and CPUs, and Compilers! Oh My! [01:29:53] by Chandler Carruth (2015)
• Transducers: from Clojure to C++ [01:00:03] by Juan Pedro Bolívar (2015)
• Writing Good C++14... By Default [01:29:05] by Herb Sutter (2015)

• Back to the Basics! Essentials of Modern C++ Style [01:40:27] by Herb Sutter (2014)
• C++ on Mars: Incorporating C++ into Mars Rover Flight Software [01:26:18] by Mark Maimone (2014)
• C++17: I See A Monad In Your Future [01:20:59] by Bartosz Milewski (2014)
• Efficiency with Algorithms, Performance with Data [01:13:41] by Chandler Carruth (2014)
• Lock-Free Programming (or, Juggling Razor Blades): This talk has two parts. I recommend taking a short break after watching the first part.
  • Lock-Free Programming (or, Juggling Razor Blades), Part I [01:24:00] by Herb Sutter (2014)
  • Lock-Free Programming (or, Juggling Razor Blades), Part II [01:11:19] by Herb Sutter (2014)
• Making C++ Code Beautiful [00:56:23] by James McNellis & Kate Gregory (2014)
• Optimization Tips - Mo' Hustle Mo' Problems [00:58:19] by Andrei Alexandrescu (2014)
• Plain Threads are the GOTO of todays computing [01:27:36] by Hartmut Kaiser (2014)
• Pragmatic Type Erasure: Solving OOP Problems with Elegant Design Pattern [00:43:47] by Zach Laine (2014)
• Type Deduction and Why You Care [01:09:34] by Scott Meyers (2014)

• C++ Seasoning [01:17:12] by Sean Parent (2013)
• Don't Help the Compiler [01:17:00] by Stephan Lavavej (2013)
• Optimizing the Emergent Structures of C++ [01:33:02] by Chandler Carruth (somewhat annoyingly bad quality) (2013)
• Scaling with C++11 [01:18:27] by Edouard Alligand (2013)
• The Effective C++11/14 Sampler [01:15:45] by Scott Meyers (2013)
• Writing Quick Code in C++, Quickly [01:11:37] by Andrei Alexandrescu (2013)

• C++11 Style - A Touch of Class [01:29:48] by Bjarne Stroustrup (2012)
• On Static If, C++11 in 2012, Modern Libraries, and Metaprogramming [00:53:15] by Andrei Alexandrescu, Scott Meyers & Herb Sutter (2012)
• Using C++11 to speed up your Qt 5 programs [00:46:47] by Marc Mutz (2012)

Crystal

• Introducing the Crystal Programming Language [00:29:53] by Will Leinweber (2016)
• Writing CLI applications in Crystal [00:26:20] by Mark Ranallo (2016)

CSS

(yeah, I know, stylesheets are not traditionally programming)

• Stuff About Cascading Style Sheets [00:20:52] by Mark Otto & Connor Sears (2015)
• Your Very Own Component Library [00:20:04] by Alex Sexton (2015)
• CSS Performance Tooling [00:46:28] by Addy Osmani (2014)
• CSS Levels Up [00:31:39] by Angelina Fabbro (2013)
• Your CSS is a Mess [00:51:26] by Jonathan Snook (2013)

D

• High Performance Code Using D [01:03:24] by Walter Bright (2014)
• Refactoring JIT Compilation [00:43:57] by Maxime Chevalier-Boisvert (2014)
• SDC, a D Compiler as a Library [00:48:37] by Amaury Sechet (2014)

Elixir

• The Soul of Erlang and Elixir [00:42:02] by Saša Juric (2019)

• GenStage and Flow [00:53:32] by José Valim (2017)
• Solid Ground [00:31:30] by Saša Juric (2017)
• Transforming Programming [00:46:45] by Dave Thomas (2017)

• Building Multiplayer Games with Phoenix and Phaser [00:34:47] by Keith Salisbury (2016)
• Build Your Own Elixir [00:45:37] by Louis Pilfold (2016)
• Code Generation in Elixir [00:43:54] by Bryan Weber (2016)
• Dialyzer: Optimistic Type Checking for Erlang and Elixir [00:48:57] by Jason Voegele (2016)
• Enhanced Embedded Systems with Nerves [00:56:11] by Justin Schneck (2016)
• Elixir in Elixir [00:46:12] by Jay Hayes (2016)
• Explicit Elixir [00:27:50] by Paul Lamb (2016)
• Learn Elixir: Building a Neural Network from Scratch [00:32:26] by Karmen Blake (2016)
• New Heights [00:48:42] by Chris McCord (2016)
• Real World Elixir Deployment [00:40:35] by Pete Gamache (2016)
• Securing Elixir Applications [00:42:52] by Bram Verburg (2016)
• The Climb: Experiencing the Rise of Elixir from the Inside [00:43:22] by Bruce Tate & Dave Thomas (2016)

• Elixir Should Take Over the World [00:58:30] by Jessica Kerr (not only interesting for Elixir devs! But I wasn't sure where else to put it) (2015)
• Phoenix - Productive. Reliable. Fast. [00:45:19] by Chris McCord (2015)

• elixir Conf 2014 Keynote [00:59:32] by Jose Valim (2014)
• Elixir: The Power of Erlang, the Joy of Ruby [00:49:42] by Dave Thomas (2014)
• Think Different [00:55:47] by Dave Thomas (2014)

Elm

• Demystifying Parsers [00:22:12] by Tereza Sokol (2018)
• If Coco Chanel Reviewed Elm [00:17:30] by Tereza Sokol (2017)
• The life of a file by Evan Czaplicki (2017)
• Controlling Time and Space: understanding the many formulations of FRP [00:40:55] by Evan Czaplicki (2014)

Erlang

• Operable Erlang and Elixir [00:35:29] by Fred Hebert (2019)
• Getting to the BEAM, without going through Erlang [00:24:32] by Kofi Gumbs (2018)

• A Peek Inside Erlang's OTP [00:50:19] by Steve Vinovski (2016)
• Distributed Jamming with Sonic Pi and Erlang [00:54:16] by Sam Aaron & Joe Armstrong (2016)
• Erlang and Deep Learning [00:47:15] by Garrett Smith (2016)
• Pilgrim's Progress to the Promised Land [00:52:24] by Robert Virding (2016)
• Scaling Distributed Erlang [00:47:23] by Zandra Norman (2016)

• Erlang: Evolution [00:37:24] by Robert Virding (2015)
• How To Ship New Code Without Taking Your System Down [00:32:47] by Martin Rehfeld (2015)
• Implementing Languages on the BEAM [01:47:47] by Robert Virding (2015)
• OTP Has Done It [00:36:04] by Nick DeMonner (2015)

• Designing a Real Time Game Engine in Erlang [00:38:32] by Mark Allen (2014)
• Optimizing Native Code for Erlang [00:26:46] by Steve Vinoski (2014)
• Using Logic Programming Tools to Drive Property-based Testing [00:34:45] by Zachary Kessin (2014)
• Why The Cool Kids Don't Use Erlang [00:51:55] by Garrett Smith (2014)
• Writing Quality Code in Erlang [00:40:47] by Garrett Smith (2014)

• 26 years with Erlang or How I got my grey hairs [01:20:00] by Joe Armstrong (2013)
• A Few Improvements to Erlang [00:43:30] by Joe Armstrong (2013)
• Chicago Boss: A Web Framework Built for Comfort (and Speed) [00:45:59] by Evan Miller (2013)
• Over a Century of Programming [01:00:10] by Mike Williams, Joe Armstrong & Robert Virding (2013)
• Erlang in production: I wish I'd known that when I started [00:42:43] by Bernard Duggan (2012)

F#

• F# for Trading [00:50:43] by Phillip Trelford (2014)

Factor

• Factor: an extensible interactive language [01:36:39] by Slava Pestov (2008)

Frege

• Frege, a Haskell for the JVM [01:00:12] by Dierk König (2015)

Go

• SQLite and Go [00:32:02] by David Crawshaw (2018)
• Things in Go I Never Use [00:24:52] by Mat Ryer (2018)

• cgo - Safely Taming the Beast [00:48:20] by Filippo Valsorda (2016)
• Communicating Sequential Goroutines [00:50:15] by Adrian Cockcroft (2016)
• Crypto for Go Developers [00:31:14] by George Tankersley (title of Youtube video wrong) (2016)
• Do not fear first class functions [00:18:54] by Dave Cheney (2016)
• "go test -race" Under the Hood [00:44:13] by Kavya Joshi (2016)
• Idiomatic Go Tricks [00:27:56] by Mat Ryer (2016)
• Inside the Map Implementation [00:26:49] by Keith Randall (2016)
• Packet Capture, Analysis, and Injection with Go [00:37:14] by John Leon (2016)
• Program your next server in Go [01:02:05] by Sameer Ajmani (2016)
• The Design of the Go Assembler [00:23:56] by Rob Pike (2016)
• The Hidden Power of Humble Interfaces [00:23:47] by Aditya Mukerjee (2016)

• 7 common mistakes in Go and when to avoid them [00:27:57] by Steve Francia (2015)
• Communicating Sequential Processes [00:43:21] by Eric Shull (2015)
• Go [00:38:18] by Rob Pike (2015)
• Golang: The good, the bad, & the ugly [00:48:31] by Vincent Batts (2015)
• gRPC: Google's high-performance, open-source RPC framework [00:29:22] by Sameer Ajmani (2015)
• Stupid Gopher Tricks [00:53:10] by Andrew Gerrand (2015)
• The move from C to Go in the toolchain [00:32:52] by Rob Pike (2015)

• High Performance Systems in Go [00:29:39] by Derek Collison (2014)
• Three fallacies of dependencies [00:20:38] by Blake Mizerany (2014)

• Advanced Go Concurrency Patterns [00:34:11] by Sameer Ajmani (2013)
• Go for Pythonistas [00:51:17] by Francesc Campoy Flores (2013)

• Concurrency Is Not Parallelism [00:31:22] by Rob Pike (2012)
• Go Concurrency Patterns [00:51:27] by Rob Pike (2012)
• Practical Go Programming [00:59:20] by Andrew Gerrand (2011)

Hackett

• Hackett: a metaprogrammable Haskell [00:33:39] by Alexis King (2018)

Haskell

• Laws! [00:28:03] by George Wilson (2018)
• Linear Haskell: practical linearity in a higher-order polymorphic language [01:03:33] by Simon Peyton Jones (2018)
• Suggesting Valid Substitutions For Typed Holes [00:41:36] by Matthías Páll Gissurarson (2018)

• Dependent Types in Haskell [00:38:41] by Stephanie Weirich (2017)
• Escape from the ivory tower: the Haskell journey [01:04:15] by Simon Peyton-Jones (2017)
• Point-Free or Die: Tacit Programming in Haskell and Beyond [00:36:12] by Amar Shah (2016)
• What are Types for, or are they only Against? [01:03:37] by Conor McBride (2016)

• Enigmatic Haskell, Haskellish Enigma [00:59:41] by Rishiyur S. Nikhil (2015)
• Framing the Discussion with EDSLs [01:41:41] by Anthony Cowley (There is a repository containing the slides and code here) (2015)
• Next Level MTL [00:44:36] by George Wilson (2015)
• Pure Type Systems [01:17:01] by Cody Roux (2015)
• The Road to Running Haskell at Facebook Scale [00:43:36] by Jon Coens (2015)

• Demystifying Haskell [00:26:11] by Andrew Rademacher (for Beginners) (2014)
• Getting a Quick Fix on Comonads [00:58:33] by Kenneth Foner (for best watching experience, watch it after the optimization talk by dan doel) (2014)
• Haste: Full-Stack Haskell for Non-PhD Candidates [00:40:50] by Erin Swenson-Healey and James Cooper (the sound quality is really bad in the first 5:30 min or so, but it gets better, promise) (2014)
• How Haskell is Changing my Brain [00:48:32] by Alissa Pajer (2014)
• Introduction to Low Level Haskell Optimization [01:09:40] by Dan Doel (2014)
• Safe Zero-Cost Coercions for Haskell [00:26:01] by Richard A. Eisenberg (2014)
• Writing a game in Haskell [00:29:37] by Elise Huard (2014)

• Lenses, Folds, and Traversals [01:54:46] by Edward Kmett (2012)
• The Algebra In Algebraic Data Types [01:04:35] by Chris Taylor (2012)
• Haskell Amuse-Bouche [00:57:13] by Mark Lentczner (the audio quality is scarily bad) (2011)
• Data Parallel Haskell [01:19:56] by Simon Peyton Jones (2010)
• A History of Haskell: being lazy with class [00:56:46] by Simon Peyton Jones (2007)

Idris

• Type-driven Development of Communicating Systems in Idris [00:40:37] by Edwin Brady (2016)
• Coding for Types: The Universe Patern in Idris [00:48:04] by David Christiansen (2015)
• Type-Driven Development in Idris [00:46:35] by Edwin Brady (2015)

• Dependently Typed Functional Programming with Idris by Edwin Brady: This lecture series has four parts (playlist):
  • Part 1: Introduction [mirror] [01:11:18] by Edwin Brady (2013) [A]
  • Part 2: Embedded DSLs [mirror] [01:06:53] by Edwin Brady (2013) [A]
  • Part 3: Effect management [mirror] [00:59:22] by Edwin Brady (2013) [A]
  • Part 4: Implementing Idris [mirror] [01:11:29] by Edwin Brady (2013) [A]

Java & Android

• Java in 2018: Change is the Only Constant [00:27:08] by Mark Reinhold (2018)
• Modules in One Lesson [00:51:17] by Mark Reinhold (2017)
• g ∘ f patterns [00:50:44] by Mario Fusco (2017)
• Parallel and Asynchronous Programming with Streams and CompletableFuture [02:34:29] by Venkat Subramaniam (2017)
• A JVM does that??? [00:51:58] by Cliff Click (2016)
• Optional - The Mother of All Bikesheds [00:58:42] by Stuart Marks (2016)

• 4 JVM Web Frameworks in 40 Minutes [00:58:38] by Joe Kutner (this is actually for a few JVM languages, not only Java) (2015)
• A Few Ok Libraries [01:09:20] by Jake Wharton (2015)
• Fast as C: How to write really terrible Java [00:51:42] by Charles Oliver Nutter (2015)
• New Concurrency Models on the JVM: Fibres, Verticles, Agents and Actors [01:03:01] by Lutz Hühnken (2015)

• Common crypto mistakes in Android [00:48:44] by Isaax Potoczny-Jones (2014)
• Functional Reactive Programming with RxJava [00:49:27] by Ben Christensen (2014)
• Java 8 Lambda Expressions & Streams [01:43:53] by Adib Saikali (2014)
• Java 8 Language Capabilities, What's in it for you? [01:25:28] by Venkat Subramaniam (2014)
• Living in the Matrix with Bytecode Manipulation [00:55:01] by Ashley Puls (2014)
• Ludicrous Speed: Designing For Performance on the JVM [00:39:54] by Cliff Moon (2014)
• Nashorn: implementing a dynamic language runtime on JVM in 2014 [00::44:32] by Attila Szegedi (2014)
• Recursion Schemes [01:50:29] by Tim Williams (2014)

• JVM Bytecode for Dummies (and the Rest of Us Too [00:50:34] by Charles O.o Nutter (2013)
• Java - The Good, Bad and Ugly Parts [00:14:34] by Josh Bloch (2011)
• Effective Java; Still Effective After All These Years [01:13:59] by Joshua Bloch (2009)

JavaScript

(There is a good list of talks about JS to be found here)

• A Cartoon Intro to WebAssembly [00:29:40] by Lin Clark (2017)
• How to effortlessly integrate Three.js into your projects [00:22:00] by Jason Farrell (not as technical as the other *GL talks) (2016)
• Learning Functional Programming with JavaScript [00:29:56] by Anjana Vakil (2016)

• Angular + React = Speed [00:19:27] by Dave Smith (2015)
• Benchmarking JavaScript [00:40:54] by Vyacheslav Egorov (2015)
• ECMAScript 6 & Web Components [00:36:11] by Brian LeRoux (2015)
• Ember 2.0 [00:40:21] by Erik Bryn (2015)
• If you wish to learn ES6/2015 from scratch, you must first invent the universe [00:25:49] by Ashley Williams (2015)
• Immutable Data and React [00:31:10] by Lee Byron (2015)
• Improving Your Workflow With Code Transformation [00:30:18] by Sebastian McKenzie (2015)
• j2me.js - a multi-threaded Java VM in JavaScript [00:44:10] by Andreas Gal (2015)

• 10 Angular JS Patterns [01:01:27] by John Papa (2014)
• Async JavaScript with Reactive Extensions [00:28:39] by Jafar Husain (2014)
• Build Production Ready Javascript Apps With Grunt [00:40:51] by Shai Reznik (2014)
• ES6 and 7, the future of JS [01:07:12] by Brendan Eich (2014)
• Functional programming patterns for the non-mathematician [00:29:58] by Brian Lonsdorf (beware; the pace is somewhat high) (2014)
• Immutability, interactivity & JavaScript [00:26:20] by David Nolen (2014)
• Javascript Combinators [00:54:55] by Reginald Braithwaite (2014)
• Large Scale JavaScript Application Architecture [00:50:40] by Dan Lynch (2014)
• Node.js in 20 Minutes [00:23:08] by Edmond Meinfelder (2014)
• Raw WebGL [00:55:21] by Nick Desaulniers (2014)
• Reactive Game Development For The Discerning Hipster [00:31:06] by Bodil Stokke (2014)
• The Art of the Javascript Metaobject Protocol [00:58:06] by Reginald Braithwaite (2014)
• The Art of the JavaScript Metaobject Protocol: Duck Typing, Compatibility, and the Adaptor Pattern [00:26:29] by Reginald Braithwaite (2014)
• Version 7: The Evolution of JavaScript [01:11:54] by Jafar Husain (2014)
• What the heck is the event loop anyway? [00:26:53] by Philip Roberts (2014)

• Bringing Angular Apps to Life with Animation [00:42:38] by Miško Hevery (2013)
• Classical Inheritance is Obsolete - How to Think in Prototypal OO [00:43:18] by Eric Elliott (2013)
• Constraint programming in the browser [00:28:15] by Adam Solove (2013)
• Creating A Scalable JavaScript Application Architecture [00:41:54] by Nicholas Zakas (2013)
• Design Decisions in AngularJS [00:40:00] by Brad Green & Miško Hevery (2013)
• Dissecting WebGL [01:11:04] by Justin Windle (2013)
  • (you might want to take a look at the slides, you cannot really see them well)
• Is Node.js Better [00:41:43] by Brian Ford (2013)
• Monads and Gonads [00:49:48] by Douglas Crockford (2013)
• Really. JavaScript. [00:46:10] by Douglas Crockford (2013)
• Redemption from Callback Hell [00:50:25] by Michael Jackson & Domenic Denicola (2013)
• Snappy Performance Apps with Ember.js [00:28:39] by Anthony Bull (2013)
• Solving the real callback hell [00:21:54] by Tim Ruffles (2013)

• The first ever presentation on Node.js [00:48:31] by Ryan Dahl (2012)
• Crockford on JavaScript by Douglas Crockford (2011) (it's 10 hours long!)
• Introduction to Node.js [00:58:18] by Ryan Dahl (2010)

Julia

• What's Bad About Julia [00:30:39] by Jeff Bezanson (2019)
• The Unreasonable Effectiveness of Multiple Dispatch [00:35:23] by Stefan Karpinski (2019)

• Julia as a platform for language development [00:28:20] by Jamie Brandon (2018)

• Introduction to Writing High Performance Julia (Workshop) [02:48:30] by Arch D. Robison (2016)
• Julia 1.0 [00:29:46] by Stefan Karpinski (2016)
• Machine Code [00:38:11] by Jameson Nash (2016)
• The Two Cultures of Programming [00:29:40] by Joshua Ballanco (2016)

• Convex Optimization in Julia [00:40:12] by Madeleine Udell (2014)
• Crossing Language Barriers with Julia, SciPy,IPython [01:11:18] by Stephen G. Johnson (2014)
• Python and Julia. Why do we need another language? [00:26:19] by Dwight J. Browne (2014)

Lisp

• The Most Beautiful Program Ever Written [01:31:05] by William Byrd (2017)
• Lisp [00:56:00] by Igor Wiedler (2014)
• Practical Common Lisp [01:12:04] by Peter Seibel (2012)

Objective C

• Object-Oriented Programming in Objective-C [00:31:10] by Graham Lee (2015)
• RACify Non-Reactive Code [00:24:23] by Dave Lee (2014)

OCaml

• Jane and the Compiler [01:03:45] by Yaron Minsky (2018) [A]
• Why OCaml [01::06:39] by Yaron Minsky (2016)
• Caml Trading [01:12:43] by Yaron Minsky (2012)

Prolog

• Production Prolog [00:39:57] by Michael Hendricks (2014)
• A Taste of Prolog [00:33:48] by Aja Hammerly (2012)

PureScript

• PureScript (Maybe This Time We Get JavaScript Right) [00:44:31] by Bodil Stokke (2014)

Python

(There is a good list of talks about Python to be found here)

• A Talk near the Future of Python? [01:01:11] by David Beazley (2019)
• Understanding Python Bytecode [00:29:44] by James Bennett (2018)

• Grok the GIL - Write Fast And Thread Safe Python [00:41:29] by A. Jesse Jiryu Davis (2017)
• The Dictionary Even Mightier [00:47:21] by Brandon Rhodes (2017)
• The Python Visualization Landscape [00:33:30] by Jake VanderPlas (2017)
• What Does It Take To Be An Expert At Python? [01:52:02] by James Powell (2017)

• Builtin Super Heroes [00:42:13] by David Beazley (2016)
• Finding closures with closures [00:31:05] by Thomas Ballinger (2016)
• Flask for Fun and Profit [01:01:23] by Armin Ronacher (2016)
• Machete-mode debugging: Hacking your way out of a tight spot [00:35:13] by Ned Batchelder (2016)
• Python and Johnny Cash [00:43:15] by James Powell (2016)
• Removing Python's GIL: The Gilectomy [00:32:06] by Larry Hastings (2016)
• Statistics for Hackers [00:40:44] by Jake Vanderplas (2016)

• Advanced Data Storage [01:19:39] by Thomas Pfaff (2015)
• Beyond PEP 8 - Best practices for beautiful intelligible code [00:52:05] by Raymond Hettinger (2015)
• Bytes in the Machine: Inside the CPython interpreter [00:34:33] by Allison Kaptur (2015)
• Facts and Myths about Python names and values [00:25:20] by Ned Batchelder (2015)
• How to Be More Effective with Functions [00:29:39] by Brett Slatkin (2015)
• How to build a brain with Python [00:35:22] by Trevor Bekolay (2015)
• Investigating Python Wats [00:24:09] by Amy Hanlon (2015)
• Is Your REST API RESTful? [00:45:31] by Miguel Grinberg (2015)
• Keynote at PyCon Brasil 2015 [00:56:29] by David Beazley (about asyncio) (2015)
• Losing your Loops Fast Numerical Computing with NumPy [00:30:31] by Jake VanderPlas (2015)
• Modules and Packages: Live and Let Die! [03:02:34] by David Beazley (2015)
• My Python's a little Rust-y [00:29:18] by Dan Callahan (2015)
• Oh, Come On Who Needs Bytearrays [00:44:24] by Brandon Rhodes (2015)
• Porting Python to run without an OS [00:32:57] by Josh Triplett (2015)
• PyPy.js: What? How? Why? [00:30:13] by Rian Kelly (2015 version) (2015)
• Python Concurrency From the Ground Up: LIVE! [00:46:50] by David Beazley (2015)
• Serialization formats are not toys [00:29:54] by Tom Eastman (2015)
• Side Effects are a Public API [00:38:26] by Christopher Armstrong (2015)
• Super considered super! [00:46:52] by Raymond Hettinger (2015)
• Terminal whispering [00:28:07] by Thomas Ballinger (2015)
• Type Hints [00:49:26] by Guido van Rossum (2015)

• All Your Ducks In A Row: Data Structures in the Std Lib and Beyond [00:37:40] by Brandon Rhodes (2014)
• Decorators: A Powerful Weapon in your Python Arsenal [00:31:31] by Colton Myers (only about function decorators) (2014)
• Discovering Python [00:47:50] by David Beazley (2014)
• Fast Python, Slow Python [00:36:11] by Alex Gaynor (2014)
• Flask by Example [03:40:29] by Miguel Grinberg (2014)
• Generators: The Final Frontier [03:50:55] by David Beazley (2014)
• Getting Hy on Python: How to implement a Lisp front-end to Python [00:47:09] by Paul Tagliamonte (2014)
• Outlier Detection in Time Series Signals [00:36:30] by Bugra Akyildiz (2014)
• PyPy.js: What? How? Why? [00:25:38] by Ryan Kelly (2014 version) (2014)
• The Cython Compiler for Python [00:48:01] by Dr. Stefan Behnel (2014)
• Up and Down the Python Data and Web Visualization Stack [00:39:18] by Rob Story (2014)

• Does your stuff scale? [00:24:31] by Steven Holmes (2013)
• Introduction to SQLAlchemy [02:48:48] by Mike Bayer (2013)
• Learn Python Through Public Data Hacking [02:38:22] by David Beazley (2013)
• Loop like a native: while, for, iterators, generators [00:29:15] by Ned Batchelder (2013)
• Python 3 Metaprogramming [03:24:00] by David Beazley (2013)
• Super Advanced Python [01:38:56] by Raymond Chandler (2013)
• Transforming Code into Beautiful, Idiomatic Python [00:48:51] by Raymond Hettinger (2013)

• A Python Æsthetic: Beauty and Why I Python [00:46:56] by Brandon Rhodes (2012)
• Inside the Python GIL [01:01:03] by David Beazley (2012)
• pandas: Powerful data analysis tools for Python [00:34:38] by Wes McKinney (2012)
• Python Epiphanies [02:21:44] by Stuart Williams (PDF version/code can be found here) (2012)
• Python Metaprogramming for Mad Scientists and Evil Geniuses [00:37:13] by Walker Hale (2012)
• Stop Writing Classes [00:27:29] by Jack Diederich (2012)
• Understanding the Python GIL [00:46:10] by David Beazley (2012)

• pyREtic: Reversing Obfuscated Python Bytecode Live Python Objects [01:00:24] by Rich Smith (2010)
• Slightly Advanced Python: Some Python Internals [00:59:36] by Alex Martelli (2008)

Racket

• Generic Collections: One Interface to Rule Them All [00:18:26] by Alexis King (2015)
• Generic Syntax Expanders and Extensible Macros [00:16:26] by Jack Firth (2015)
• Racket: A Programming-Language Programming Language [00:51:42] by Robby Findler (2015)
• The Racket Manifesto [00:52:42] by Matthias Felleisen (2015)
• Purely Functional 3D in Typed Racket [00:22:15] by Neil Toronto (2014)

Ruby

• What Killed Smalltalk Could Kill Ruby, Too [01:00:55] by Robert Martin (2009)
• Writing Ruby Like it’s 2018 [00:11:53] by Joe Leo III (2018)

• Composition [00:47:55] by James Dabbs (2016)
• Halve Your Memory Usage With These 12 Weird Tricks [00:45:30] by Nate Berkopec (2016)
• How Are Method Calls Formed? [00:52:16] by Aaron Patterson (2016)
• Metaprogramming? Not good enough! [00:36:09] by Justin Weiss (2016)
• Methods of Memory Management in MRI [00:48:48] by Aaron Patterson (2016)

• Building a binary protocol client in Ruby: A magical journey! [00:30:27] by Trevor Rosen and egypt (James Lee) (2015)
• Fun with the Lambda Calculus [00:48:48] by Corey Haines (2015)
• How to Performance [00:30:03] by Eileen Uchitelle (2015)
• Inside Ruby's VM: The TMI Edition [00:39:10] by Aaron Patterson (2015)
• Nothing is Something [00:35:52] by Sandi Metz (2015)
• Softly, softly typing [00:44:33] by John Cinnamond (2015)

• Refactoring Ruby with Monads [00:30:04] by Tom Stuart (2014)
• Speed up Rails, Speed up Your Code [00:41:04] by Aaron Patterson (2014)

• A Rubyist in Clojure-land [00:37:50] by David Chelimsky (2013)
• Pry - The Good Parts! [00:33:33] by Conrad Irwin (2013)
• REPL driven development with Pry [00:39:26] by Conrad Irwin (2013)
• Ruby, threads, events ... and Flying Robots! [01:12:54] by Jim Weirich (2013)
• That's Not Very Ruby of You [00:36:57] by Ernie Miller (2013)
• You Gotta Try This [00:45:12] by Avdi Grimm (2013)

• Confident Code [00:31:24] by Avdi Grimm (2012)
• Make awesome command line apps with Ruby [00:28:57] by Dave Copeland (2012)
• MiniTest: Write Awesome Tests [00:32:27] by Michael J.I. Jackson (2012)
• Programming With Nothing [00:40:50] by Tom Stuart (2012)
• Y Not - Adventures in Functional Programming [00:53:22] by Jim Weirich (2012)

Rust

• Rust at speed - building a fast concurrent database [00:52:53] by Jon Gjengset (2018)
• Using Rust For Game Development [00:42:29] by Catherine West (2018)

• Building Rocket [00:33:15] by Sergio Benitez (2017)
• How I Convinced the World's Largest Package Manager to Use Rust, and So Can You! [00:37:33] by Ashley Williams (2017)
• Shipping a Solid Rust Crate [00:22:08] by Michael Gattozzi (2017)

• Back to the Futures [00:29:53] by Alex Crichton (2016)
• In Rust We Trust [00:45:01] by Alex Burkhardt (2016)
• RFC: In Order to Form a More Perfect `union` [00:28:21] by Josh Triplet (2016)
• Rusty Runtimes [00:35:30] by Aditya Siram (2016)
• Rust: Safe and Scalable Systems Programming [01:00:09] by Alex Crichton (2016)
• The History of Rust [00:58:41] by Steve Klabnik (2016)
• The /r/playrust Classifier [00:30:34] by Suchin Gururangan & Colin O'Brien (2016)
• Using Generics Effectively [00:23:42] by Without Boats (2016)

• What Rust can teach us about Ruby [00:34:07] by Steve Klabnik (2015)
• Cap'n Proto and Rust: Type Systems for Sharing [00:40:47] by David Renshaw (2014)
• Concurrency in Rust [00:31:24] by Alex Crichton (2014)

Scala

• Move Over Free Monads: Make Way for Free Applicatives! [00:45:29] by John de Goes (2016)
• The Dialectics of Type-Level Programming [00:41:04] by Aaron Levin (2016)

• Lawful Asynchronous Programming [01:04:31] by Daniel Spiewak (2015)
• Minimizing the Slippery Surface of Failure [00:59:26] by Jon Pretty (2015)
• Principles for Modular, Functional, Approachable Libraries [01:32:44] by Erik Osheim (2015)
• Run free with the monads: Free Monads for fun and profit [00:22:11] by Ken Scrambler (2015)
• Simplifying Scala Collections [00:46:52] by Bill Venners (2015)

• How types can turn a SQL interpreter into a SQL compiler [00:40:31] by Tiark Rompf (2014)
• Scala Collections: Why Not? [00:45:42] by Paul Phillips (beware: not very optimistic!) (2014)
• Concurrency Anti-Patterns in Scala [00:29:53] by Blake Matheny (2013)
• Scala Monads: Declutter Your Code With Monadic Design [00:31:22] by Dan Rosen (2012)
• Scala Versus Java [01:32:35] by Dan Rosen (2012)
• What's Next for Scala [01:15:06] by Martin Odersky (2011)

Scheme

• The Nanopass Framework as a Nanopass Compiler [00:52:10] by Andrew Keep (2020)
• miniKanren [00:46:23] by Dan Friedman & William Byrd (2013)
• Dan Friedman - Cool Ideas [00:57:00] by Guy Steele (2011)

Smalltalk

• But Really, You Should Learn Smalltalk [00:28:05] by Noel Rappin (2014)

Swift

• Implementing Swift Generics [00:44:37] by Slava Pestov (2017)
• Controlling Complexity in Swift — or — Making Friends with Value Types [00:57:45] by Andy Matuschak (2015)
• Swift's High-Level IR: A Case Study... [00:55:37] by Joe Groff & Chris Lattner (2015) [A]
• Swift Programming Language for JavaScript Developers [00:41:19] by J.P. Simard (2014)
• Thinking in Swift [00:24:23] by Abizer Nasir (2014)

Unison

• Unison: An Introduction [01:53:49] by Rúnar Bjarnason (2020)
• Introduction to the Unison programming language [00:40:58] by Rúnar Bjarnason (2018)
• The Unison Language and its Scala-based Runtime by Paul Chiusano (2017)
• How to write a search engine in 15 lines of code [00:36:04] by Paul Chiusano (2016)

VimL

• Going mouseless with Vim, Tmux, and Hotkeys [00:57:27] by Leeren Chang (2018)
• More Instantly Better Vim [00:38:51] by Damian Conway (2013)
• Vim - I Wish I Knew How To :q You [00:41:08] by Chris Maiden (not really about VimL, more of a general introduction into vim) (2013)
• Write code faster: expert-level vim [00:41:09] by Ben Orenstein (not really expert level) (2012)

Wolfram Language

• Inside the Wolfram Language [01:08:53] by Stephen Wolfram (2014)

Zig

• Zig – a programming language designed for robustness, optimality, and clarity [00:54:13] by Andrew Kelley (2018)

On theory

Compilers/Interpreters

• Towards a Verified Range Analysis for JavaScript JITs by Fraser Brown (2020) (Paper by Brown et al.)
• The Z Garbage Collector [00:37:13] by Erik Österlund (2018)
• Datafun: a functional query language [00:42:30] by Michael Arntzenius (2017)
• What Has My Compiler Done for Me Lately? Unbolting the Compiler's Lid [01:15:45] by Matt Godbolt (2017)
• The Unison Language and its Scala-based Runtime [00:45:49] by Paul Chiusano (2017)
• Datafun: A Functional Datalog [00:24:38] by Michael Arntzenius (2016)
• What I learned from LuaJIT [01:15:42] by Vyacheslav Egorov (2016)
• Bringing Clang and C++ to GPUs: An Open-Source, CUDA-Compatible GPU C++ Compiler [00:59:33] by Justin Lebar (2016)
• An Introduction to Combinator Compilers and Graph Reduction Machines [00:39:30] by David Graunke (2016)
• Ruby and OMR: Experiments in utilizing OMR technologies in MRI [00:45:38] by Charlie Gracie (2016)
• So you want to write an interpreter? [00:40:38] by Alex Gaynor (2015)
• The movfuscator [00:49:14] by Christopher Domas (2015)
• Understanding Compiler Optimizations [01:50:14] by Chandler Carruth (2015)
• Hello Om Next! [01:20:25] by David Nolen (2015)
• Write your own compiler in 24 hours [01:04:07] by Phil Trelford (2015)
• Bits of advice for VM writers [00:43:59] by Cliff Click (2015)
• VM Design Choices [01:01:38] by Cliff Click (2015)
• A VM is a VM is a VM: The Secret Path to High Performance Multi-Language Runtimes [00:47:07] by Mark Stoodley (2015)
• Compilers are Databases [01:08:51] by Martin Odersky (2015)
• Rise of the Transpilers [00:44:00] by Jeremy Ashkenas (2015)
• Instaparse [00:38:38] by Mark Engelberg (2014)
• Superoptimizing LLVM [00:49:07] by John Regehr (2014)
• Writing a Nanopass Compiler [00:40:48] by Andy Keep (2014)
• Let's Write an Interpreter [00:28:34] by Ryan Davis (2013)
• The Java Virtual Machine is Over - The Polyglot VM is here [00:51:02] by Marcus Lagergren (2013)
• Implementing Domain Specific Languages with LLVM [00:50:59] by David Chisnall (2013)
• The Clang AST [00:44:53] by Manuel Klimek (2013)
• How the PyPy JIT works [00:29:05] by Benjamin Peterson (2012)
• Intel OpenCL SDK Vectorizer [00:35:45] by Natav Rotem (2011)
• PTX Back-End: GPU Programming With LLVM [00:39:34] by Justin Holewinski (2011)
• Parsing with Derivatives [01:13:10] by Matthew Might (2011)

Computer Graphics and Vision

• The Glitching Hour [00:22:17] by Amy Wibowo (2018)
• Simit: A Language for Computing on Sparse Systems when Performance Matters [00:58:37] by Fredrik Kjolstad (2016)
• Making things with maths [00:53:45] by Steven Wittens (2013)
• Making WebGL Dance [00:30:55] by Steven Wittens (2013)
• Principles of Lighting and Rendering [01:31:00] by John Carmack (2013)
• OpenCV and High-Performance Vision on GPU [02:24:59] by Victor Eruhimov (2012)

Creative Technology

• The Art of Code [01:00:48] by Dylan Beattie (2020)
• Creative Computation [00:21:00] by Jack Rusher (2019)
• Mapping Imaginary Cities [00:40:56] by Mouse Reeve (2018)
• Making Games for 1920s Hardware [00:32:21] by Em Lazer-Walker (2018)
• Picasso, Geometry, Jupyter [00:30:48] by Ryan Herr (2018)
• How to Hack a Painting [00:44:58] by Tyler Hobbs (2017)
• The Symmetries of Things [00:26:02] by Tom Hall (2017)
• Programming In Time - Live Coding for Creative Performances [00:47:03] by Andrew Sorensen (2014)
• Stop Drawing Dead Fish [00:53:32] by Bret Victor (2013)

Databases

• Jepsen 7: Anna Concurrenina [00:53:06] by Kyle Kingsbury (2017)
• To NoSQL or Not to NoSQL, That Is the Question [01:00:48] by David Ostrovsky (2015)
• Transactions: myths, surprises and opportunities [00:41:07] by Martin Kleppmann (2015)
• Consistency without consensus in production systems [00:41:09] by Peter Bourgon (2014)
• Cassandra and Go Doubleheader [00:58:23] by Kyle Kingsbury & Al Tobey (this video features two distinct talks, only the first one deals with databases) (2014)
• Jepsen II: Linearizable Boogaloo [00:44:46] by Kyle Kingsbury (2014)
• An Ode to 17 Databases in 33 Minutes [00:38:12] by Toby Hede (2014)
• Sharding and Scaling Your Database [00:42:53] by Neha Narula (2014)
• Postgres Performance for Humans [00:33:49] by Craig Kerstiens (2014)
• Introduction to NoSQL [00:54:52] by Martin Fowler (2013)
• The Impedance Mismatch is Our Fault [00:58:31] by Stuart D. Halloway (2012)
• Deconstructing the Database [01:06:24] by Rich Hickey (2012)

Data Science

• You can't do data science in a GUI [01:15:18] by Hadley Wickham (2018)
• Expressing complex data aggregations with Histogrammar [00:35:02] by Jim Pivarski (2016)
• Data as Software as Data [00:40:27] by Andrea Burbank (2016)
• Sonification: a Battle on Two Fronts by Martin Keary (2018)
• How a File Format Led to a Crossword Scandal by Saul Pwanson (2019)

Data Structures & Algorithms

• A CRDT Primer: Defanging Order Theory [00:37:00] by John Mumm (2018)
• Tree-sitter - a new parsing system for programming tools [00:38:37] by Max Brunsfeld (2018)
• Meetings With Remarkable Trees [00:53:29] by Bodil Stokke (2018)
• The simple essence of automatic differentiation [01:01:41] by Conal Elliott (2018)
• Designing a Fast, Efficient, Cache-friendly Hash Table, Step by Step by Matt Kulukundis (2017)
• Reasoning about performance (in the context of search) [00:29:28] by Dan Luu (2016)
• Parsing Text with a Virtual Machine [00:43:53] by Ghadi Shayban (2016)
• Exotic Functional Data Structures: Hitchhiker Trees [00:40:32] by David Greenberg (2016)
• Probabilistic Data Structures [00:38:47] by James Stanier (2016)
• An Overview of Probabilistic Programming [01:02:54] by Vikash K. Mansinghka (I am unsure where to put this) (2015)
• Hash Functions and You: Partners in Freedom [00:27:06] by Curtis Lassam (2015)
• Practical Fractals in Space [00:38:27] by Michelle Brush (2014)
• Persistent Data Structures for Special Occasions [00:44:44] by Michał Marczyk (2014)
• Visualizing Persistent Data Structures [00:37:24] by Dann Toliver (2014)
• Generic sorting and partitioning in linear time and fully abstractly by Fritz Henglein (2012)

Debugging

• The Hurricane's Butterfly: Debugging Pathologically Performing Systems by Bryan Cantrill (2018)
• Tackling Concurrency Bugs with TLA+ [00:30:05] by Hillel Wayne (2017)
• Debugging with the Scientific Method [00:49:08] by Stuart Halloway (2015)

DevOps

• What's Next for DevOps? [00:29:34] by Emily Freeman (2021) [A]
• Pragmatic Automation [00:24:33] by Max Luebbe (2019) [A]
• The Future Of DevOps [00:47:49] by Adrian Cockcroft (2016)
• How Netflix Thinks About DevOps [00:31:10] by Dave Hahn (2016)
• I got 10 trillion problems, but logging ain't one [00:25:17] by John Graham-Cumming (2015)
• Your infrastructure is not a unique snowflake, and that's ok! [00:37:39] by Jeremy Edberg (2015)
• Demistifying SNMP [00:49:19] by Douglas Mauro (2015)
• Salting things up in the sysadmin's world [00:37:21] by Juan Manuel Santos (2015)
• Chef Style DevOps Kungfu [01:16:08] by Adam Jacob (2015)

Distributed Systems

• Everything about distributed systems is terribleDesigning Distributed Systems with TLA+ [00:38:25] by Hillel Wayne (2018)
• Send me your Echolocation [00:26:06] by Vicky Nguyen (2018)
• Load Balancing is Impossible [00:36:43] by Tyler McMullen (2016)
• Scaling Instagram [00:27:13] by Mike Krieger (2015)
• Coordination-Free Computations [00:46:15] by Cristopher Meiklejohn (really fast talker) (2015)
• Everything Will Flow by Zach Tellman (2015) [A]
• Jepsen IV: Hope Springs Eternal [00:54:33] by Kyle Kingsbury (2015)
• Distributed Eventually Consistent Computations [00:49:37] by Christopher Meiklejohn (2015)
• Distributed Systems 101 [00:45:25] by lvh (2015)
• K things I know about building Resilient Reactive Systems [01:00:02] by Joe Armstrong (2014)
• The How and Why of Fitting Things Together [00:46:39] by Joe Armstrong (2013)

Entrepreneurship

• Improving Yesterday [00:37:57] by Eric Fode (2019)
• How and Why to Start A Startup [00:44:42] by Sam Altman & Dustin Moskovitz (2017)
• How to Build a Product (Part IV) [00:51:24] by Jan Koum (2017)
• Barely succeed! It’s easier! [00:39:22] by Maciej Cegłowski (2013)
• Time Management [01:16:21] by Randy Pausch (2007)

Functional Programming

• Why Isn't Functional Programming the Norm? [00:46:08] by Richard Feldman (2019) [A]
• What FP can learn from Smalltalk [00:43:36] by Aditya Siram (2018)
• Profunctor Optics: The Categorical Approach [00:45:33] by Bartosz Milewki (2017)
• Peeling the Banana: Recursion Schemes from First Principles [00:34:21] by Zainab Ali (2017)
• Evolving Functional Programming Languages by Erik Osheim (2017)
• Functional architecture - The pits of success [01:00:10] by Mark Seemann (2016)
• Why Functional Programming Matters [00:56:09] by John Hughes (2016)
• Denotational Design: From Meanings To Programs [02:20:35] by Conal Elliott (2015)
• A More Elegant Specification for FRP [00:29:54] by Conal Elliott (2015)
• The Essence and Origins of Functional Reactive Programming [00:59:24] by Conal Elliott (2015)
• Unconventional Programming with Chemical Computing [00:36:00] by Carin Meier (2015)
• Functional Programming Design Patterns [01:05:43] by Scott Wlaschin (2015)
• Papers We Love: Composable and Compilable Macros [00:54:49] by Sam Tobin-Hochstadt (2015)
• Railway oriented programming: Error handling in functional languages by Scott Wlaschin (2014)
• The Functional Final Frontier [00:27:02] by David Nolen (2014)
• Functional Programming; What? Why? When? How? [00:58:27] by Robert C Martin (2014)
• Living in a Post-Functional World [00:45:46] by Daniel Spiewak (2013)
• Deconstructing Functional Programming [00:48:33] by Gilad Bracha (2013)
• Functional Principles for Object Oriented Development [00:51:13] by Jessica Kerr (2013)
• Don't fear the Monad [01:07:11] by Dr. Brian Beckman (2012)
• Faith, Evolution, and Programming Languages [01:06:54] by Phillip Wadler (2012)
• Adventures in Functional Programming [00:50:34] by Jim Weirich (2012)
• Tangible Functional Programming [00:56:25] by Conal Elliott (2007)

Game Development

• Is There More to Game Architecture than ECS? [00:23:05] by Bob Nystrom (2018)

Hardware

• A Taste of GPU Compute [01:05:06] by Raph Levien (2020)
• Mill vs. Spectre: Performance and Security [00:46:42] by Ivan Godard (2018)
• eMMC hacking, or: how I fixed long-dead Galaxy S3 phones [00:56:07] by Oran Avraham (2018)
• A Crash Course in Modern Hardware [00:59:20] by Cliff Click (2016)
• The Future of Microprocessors [00:46:35] by Sophie Wilson (2016)
• Let's Build a Computer! [00:29:03] by Ryan Davis (2014)

Logic Programming

• Constraint Logic Propagation Conflict Spreadsheets [00:33:50] by William Taysom (2015)
• Web Testing with Logic Programming [00:39:10] by Daniel Gregoire (2015)
• Challenges for Logic Programming [00:40:45] by Steve Miner (2013)

Machine Learning

• Building the Software 2.0 Stack [00:30:08] by Andrej Karpathy (2018)
• Machine learning is not the future [00:38:59] by Rajat Monga (2016)
• Neural Nets for Newbies [00:30:57] by Melanie Warrick (2015)
• From the Lab to the Factory: Building a Production Machine Learning Infrastructure [01:04:27] by Josh Wills (2014)
• The Unreasonable Effectiveness of Deep Learning [01:07:24] by Yann LeCun (2014)
• The Unreasonable Effectiveness of Data [01:02:56] by Peter Norvig (2011)
• Automatic Algorithm Invention with a GPU [01:02:04] by Wesley Faler (2011)

Mathematics

Those are not necessarily programming-related and possibly very advanced mathematics.

• The Continuum Hypothesis and the search for Mathematical Infinity [00:55:18] by W. Hugh Woodin (2015)
• Field of Rationality and Category Theory [00:44:07] by Michał Heller (2015)
• Category Theory [01:36:54] by Tom LaGatta (2014)
• Constructive Type Theory and Homotopy by Steve Awodey (2010)

On Languages

• Homoiconicity It Is What It Is [00:30:39] by Stuart Sierra (2017)
• On Storytelling [00:20:00] by Evan Czaplicki (2017)
• How we program multicores [00:58:52] Joe Armstrong (2016)
• Ideology [00:21:23] by Gary Bernhardt (2015)
• Simplicity is Complicated [00:23:11] by Rob Pike (2015)
• Programming should eat itself [00:47:40] by Nada Amin (2014)
• Make Simple Tasks Simple! [01:37:36] by Bjarne Stroustrup (2014)
• Why C++ Sails When the Vasa Sank [01:07:03] by Scott Meyers (2014)
• Running a startup on Haskell [00:50:23] by Bryan O'Sullivan (2013)
• Scaling Yourself [00:28:51] by Scott Hanselman (2012)

On the Industry/Community

• Dealing with unanticipated needs [00:47:43] by Dave Snowden (2019)
• How to be a Happy Developer. Now! [00:39:32] by Christian Robert (2019)
• Stewardship Made Practical [00:50:35] by Stuart Halloway
• Shaping our children's education in computing [00:51:08] by Simon Peyton Jones (2018)
• Computing, Climate Change, and All of our Relationships [00:40:33] by Nabil Hassein (2018)
• The Hard Parts of Open Source [00:47:15] by Evan Czaplicki (2018)
• Jolly JS Journeys [00:23:02] by Tim Holman (2018)
• Winning the War on Error: Solving Halting Problem, Curing Cancer [01:09:38] by Matt Might (2017) [A]
• Invited Talk [01:07:21] by Guy Steele (2017) (on notation) [A]
• Patterns Failed. Why? Should We Care? [00:26:40] by Brian Marick (2017)
• Code Review, Forwards and Back [00:22:33] by Sumana Harihareswara & Jason Owen (2017)
• On Abstraction [01:00:02] by Zach Tellman (2017)
• Crossing the River by Feeling the Stones [00:55:30] by Simon Wardley (2017)
• Idée Fixe [00:39:36] by David Nolen (2017)
• Humanizing among coders [00:41:15] by Ana Balica (2016)
• extern c: Talking to C Programmers about C++ [01:36:26] by Dan Saks (2016)
• “Am I Senior Yet?” Grow Your Career by Teaching Your Peers [00:37:57] by Katlyn Parvin (2016) [A]
• It's Simple [00:37:35] by Adrian Cockcroft (2016)
• Software, Faster [00:54:19] by Dan North (2016)
• How to become a Data Scientist in 6 months - A hacker’s approach to career planning [00:56:24] by Tetiana Ivanova (2016) [A]
• Common pitfalls of junior developers [00:09:37] by Rachel Warbelow (2015) [A]
• What can programmers learn from pilots? [00:31:07] by Andrew Godwin (2015) [A]
• PyCon 2015 Keynote [00:35:51] by Jacob Kaplan-Moss (2015)
• You are Not an Impostor [00:33:02] by Nickolas Means (2014) [A]
• Being Human [00:19:45] by Brian J. Brennan (not technical, but very important) (2014) [A]
• Career Advice for Programmers [00:54:18] by Trisha Gee (2013)
• Patterns in Architecture [01:03:35] by Christopher Alexander (2013)
• Normal Considered Harmful [01:07:26] by Alan Kay (2012)
• We Really Don't Know How To Compute! [01:04:20] by Gerald Jay Sussman (2011)

Operating Systems

• Extended BPF: A new software type [00:31:03] by Brendan Gregg (2019)
• Learning the Linux Kernel with tracing [01:07:24] by Steven Rostedt (2018)
• You can be a kernel hacker! [00:33:31] by Julia Evans (2014)
• Python, Linkers, and Virtual Memory [00:31:15] by Brandon Rhodes (2012)
• The Origins of Linux [1:25:12] by Linus Torvalds (2001) [A]

Performance Engineering

• Performance Matters [00:42:14] by Emery Berger (2019)
• Software Performance: A Shape Not a Number [00:31:59] by Kay Ousterhout (2018)
• Xi: an editor for the next 20 years [00:53:20] by Raph Levien (2018)
• Designing for Performance [00:50:17] by Martin Thompson (2015)

Programming Language Design

• On the Expressive Power of Programming Languages [00:59:03] by Shriram Krishnamurthi (2019)
• Stuck macros: deterministically interleaving macro-expansion and typechecking [00:41:55] by Samuel Gélineau (2019)
• Three Things I Wish I Knew When I Started Designing Languages [00:44:28] by Peter Alvaro (2019)
• A Little Taste of Dependent Types [00:38:35] by David Christiansen (2018)
• A Tale of Two Asyncs: Open Source Language Design in Rust and Node.js [00:47:24] by Ashley Williams (2018)
• Four Languages from Forty Years Ago [01:01:45] by Scott Wlaschin (2018)
• Gradual typing of Ruby at Scale [00:38:45] by Dmytro Petrashko & Paul Tarjan (2018)
• Proof Theory Impressionism: Blurring the Curry-Howard Line [00:35:07] by Dan Pittman (2018)
• Running With Scissors: Live Coding With Data [00:39:35] by Stuart Halloway (2018)
• Rust and Other Interesting Things [00:37:06] by Bryan Cantrill (2018)
• Types, and why you should care [01:04:05] by Ron Minsky (2017)
• Into the Core - Squeezing Haskell into Nine Constructors [01:07:48] by Simon Peyton Jones (2016)
• Let's Build a Hygienic Macro Expander [00:40:04] by Matthew Flatt (2016)
• Sketch-n-Sketch: Interactive SVG Programming with Direct Manipulation [00:40:17] by Ravi Chugh (2016)
• Make Your Own Programming Language! [00:26:07] by Nick Heiner (2016)
• I See What You Mean [00:52:28] by Peter Alvaro (2015)
• Everything old is new again: Quoted Domain-Specific Languages [00:39:06] by Philip Wadler (2015)
• Syntaxation [00:49:39] by Douglas Crockford (2015)
• Pixie - A Lightweight Lisp with 'Magical' Powers [00:33:12] by Timothy Baldridge (a good intro on tracing JITs) (2015)
• Let's be mainstream! User focused design in Elm [00:58:23] by Evan Czaplicki (2015)
• Propositions as Types [00:42:42] by Philip Wadler (2015)
• Eve [00:46:03] by Chris Granger (2015)
• Papers We Love: Fundamental Concepts in Programming Languages [01:16:39] by John Myles White (2015)
• The Worst Programming Language Ever [00:43:46] by Mark Rendle (there is a bit of static humming in the background and the sound quality is not all that great, but it's worth it) (2015)
• Implement an Esoteric Programming Language for Fun [00:22:16] by Arne Martin Aurlien (2014)
• The Sociology of Programming Languages [00:42:11] by Leo Meyerovich (2014)
• Transducers [00:45:00] by Rich Hickey (2014)
• A Dinosaur's Thoughts on Programming Language Evolution [00:48:47] by Matthew Flatt (2013)
• No Ifs, Ands, or Buts: Uncovering the Simplicity of Conditionals [00:38:20] by Jonathan Edwards (2007)

Program Synthesis

• Liquid resource types for verification and synthesis [01:05:13] by Nadia Polikarpova (2020)
• Type-Driven Program Synthesis [00:39:39] by Nadia Polikarpova (2018)
• Barliman: trying the halting problem backwards, blindfolded [00:36:13] by William Byrd & Greg Rosenblatt (2016)

Research

• How to Give a Great Research Talk [00:58:41] by Simon Peyton Jones (2016)

Robotics

• No, Really... Robots and JavaScript?! [00:36:26] by Raquel Vélez (2015)
• Robots: You're Still Doing It Wrong [00:49:51] by Katy Levinson (not very formal, DefCon) (2012)

Security

• Lessons From Two Years of Crypto Audits [00:45:49] by Jean-Philippe Aumasson (2020)
• DNS, SNI, TLS, HTTPS: Modern DNS & Privacy [00:43:17] by Bert Hubert (2019)
• No source, no problem! High speed binary fuzzing by Nspace & gannimo (2019)
• WebAssembly: A New World of Native Exploits on the Browser [00:45:20] by Justin Engler & Tyler Lukasiewicz (2018)
• You're Probably Not Red Teaming... And Usually I’m Not, Either [00:43:43] by Deviant Ollam (2018)
• GOD MODE UNLOCKED - Hardware Backdoors in x86 CPUs [00:50:59] by Christopher Domas (2018)
• Q: Why Do Keynote Speakers Keep Suggesting That Improving Security Is Possible? A: Because Keynote Speakers Make Bad Life Decisions and Are Poor Role Models [00:51:21] by James Mickens (2018)
• Breaking The x86 Instruction Set [00:44:28] by Christoper Domas (2017)
• Exploit Kit Cornucopia [00:45:08] by Brad Antoniewicz & Matt Foley (2017)
• Ichthyology: Phishing as a Science by Karla Burnett (2017) [A]
• The Search for the Perfect Door [00:50:49] by Deviant Ollam (2016)
• Boot strapping slightly more secure systems [00:47:43] by Trammell Hudson (2016)
• Repsych: Psychological Warfare in Reverse Engineering [00:38:48] by Chris Domas (2015)
• Pulling Back the Curtain on Airport Security: Can a Weapon Get Past TSA [00:31:52] by Billy Rios (2014)

Software Development

• Intro to Empirical Software Engineering: What We Know We Don't Know [00:37:42] by Hillel Wayne [A] (2019)
• Moldable development [00:37:48] by Tudor Gîrba (2019)
• Say What You Mean - Exploring Declarative Computation in Art [00´:43:12] by David Schmudde (2019)
• Sherlock Holmes, Consulting Developer [00:33:28] by Stuart Halloway (2019)
• OOP Is Dead, Long Live Data-oriented Design [01:00:45] by Stoyan Nikolov (2018)
• Old Is the New New [00:50:22] by Kevlin Henney (2018)
• Polly want a Message [00:40:00] by Sandi Metz (2018)
• Programming Across Paradigms [00:49:07] by Anjana Vakil (2017)
• TDD, Where Did It All Go Wrong [01:03:53] by Ian Cooper (2017)
• You're Insufficiently Persuasive [00:35:37] by Sandi Metz (2017)
• The Post JavaScript Apocalypse [00:54:12] by Douglas Crockford (2017)
• Requests Under The Hood [00:31:37] by Cory Benfield (2017)
• Things that Matter [01:06:36] by Scott Meyers (2017)
• The programmer [01:03:10] by Kevlin Henney (2016)
• Small Is Beautiful [01:07:02] by Kevlin Henney (2016)
• The Error of Our Ways [00:49:44] by Kevlin Henney (2016)
• Get a Whiff of This [00:38:14] by Sandi Metz (2016)
• Boundaries [00:30:19] by Gary Bernhardt (2015)
• Scalable is Awesome, Literally! [00:43:48] by Garrett Smith (2015)
• Conceptualizing Large Software Systems [00:17:17] by Alan Shreve (2015)
• Microservices @ Spotify [00:49:07] by Kevin Goldsmith (2015)
• Apparatus: A Hybrid Graphics Editor / Programming Environment [00:37:56] by Toby Schachman (2015)
• One Hacker Way [00:55:36] by Erik Meijer (2015)
• Big Code: Developer Infrastructure at Facebook's Scale [00:46:21] by Bryan O'Sullivan, Christian Legnitto & Katie Coons (2015)
• Demystifying Docker [00:29:53] by Andrew T. Baker (2015)
• All the Little Things [00:38:46] by Sandi Metz (2014)
• Kicking the Complexity Habit [00:55:30] by Dan North (2014)
• What does it mean to be Reactive? [00:46:39] by Erik Meijer (2014)
• The S.O.L.I.D. Principles of Agile OO Design [01:23:35] by Robert C. Martin (way more interesting than it sounds) (2014)
• The Future Doesn't Have to Be Incremental [00:43:50] by Alan Kay (2014)
• Thinking Above the Code [00:59:51] by Leslie Lamport (2014)
• CPU Caches and Why You care [01:01:55] by Scott Meyers (written in C++, reasonable for almost every software developer) (2014)
• The Most Important Design Guideline [00:58:42] by Scott Meyers (2014)
• The Mess We're In [00:45:50] by Joe Armstrong (2014)
• Whence Complexity? [00:55:32] by Michael Nygard (2013)
• The Not-So-Big Software Design [00:47:31] by Reginald Braithwaite (2013)
• I have a good feeling about this. Why tooling is poised to make the jump to hyperspace [00:43:14] by Reginald Braithwaite (2013)
• The Future of Programming [00:32:56] by Bret Victor (2013)
• The Language of the System [01:02:50] by Rich Hickey (2013)
• Programming is terrible - Lessons learned from a life wasted [01:06:44] by Thomas Figg (2013)
• A Whole New World [00:21:20] by Gary Bernhardt (2012)
• Inventing on Principle [00:54:20] by Bret Victor (2012)
• The Value Of Values [00:58:53] by Rich Hickey (2012)
• Hammock Driven Development [00:39:49] by Rich Hickey (2012)
• Simplicity Matters [00:36:54] by Rich Hickey (Simple Made Easy revisited) (2012)
• Growing a Language [00:53:31] by Guy Steele (2012)
• Architecture the Lost Years [01:06:38] by Robert C. Martin (2011)
• Simple Made Easy [01:01:26] by Rich Hickey (2011)
• Real Software Engineering [00:51:56] by Glenn Vanderburg (2010)
• Are We There Yet? [01:10:04] by Rich Hickey (2009)
• SOLID Object-Oriented Design [00:47:11] by Sandi Metz (2009)

System Architecture

• The Salami Method for Cross Platform Development [01:00:16] by Adi Shavit (2018)
• Four Distributed Systems Architectural Patterns [00:50:00] by Tim Berglund (2017)
• Mastering Chaos - A Netflix Guide to Microservice [00:53:13] by Josh Evans (2017)
• 12-Factor Apps and the HashiStack [00:30:39] by Kelsey Hightower (2016)
• Kill "Microservices" before its too late [00:39:41] by Chad Fowler (2016)
• Runtime scheduling: theory and reality [00:42:11] by Eben Freeman (2016)
• The Power Of UNIX [00:30:03] by Dan North (2015)
• Speed & Scale: How to get there [01:04:51] by Adrian Cockcroft (2014)
• Keeping a System Running Forever [00:28:06] by Fred Hebert (2014)
• Narcissistic Design [00:37:14] by Stuart Halloway (2013)
• Scalability at YouTube [00:38:43] by Mike Solomon (long intro; starts at 9:12 minutes in) (2012)

Testing

• Backtracking Generators for Random Testing [01:03:30] by Benjamin Pierce (2020) [A]
• How to Stop Hating Your Tests [00:43:38] by Justin Searls (2015)
• Testing the Hard Stuff and Staying Sane [00:47:16] by John Hughes (2014)

Theoretical Computer Science

• Category Theory for the Working Hacker [00:50:51] by Philip Wadler (2016)
• Impossible Programs [00:50:06] by Tom Stuart (2015)
• A Lever for the Mind [00:38:54] by Tom Stuart (2015)
• Papers We Love: An Axiomatic Basis for Computer Programming [01:04:32] by Jean Yang (2014)
• Lambda Calculus Then and Now [00:30:08] by Dana S. Scott (2013)
• Turing and the Riemann zeta function [01:06:54] by Andrew Odlyzko (2012)
• Programming the Turing Machine [01:06:10] by Barbara Liskov (2012)
• Church's Coincidences [01:03:41] by Philip Wadler (2012)

Type Theory

• Type Theory and its Meaning Explanations [00:52:23] by Jon Sterling (2015)
• Papers We Love: On the Meanings of the Logical Constants and the Justifications of the Logical Laws [01:24:37] by Joseph Abrahamson (2014)
• Papers We Love: The Derivative of a Regular Type is its Type of One-Hole Contexts [01:06:25] by Erik Hinton (2014)

UX/UI

• Designing GNOME Mobile Apps [00:35:48] by Tobias Bernard (2019) [slides]
• Data Driven UIs, Incrementally [00:36:17] by Yaron Minsky (2018)
• Choosing Features [00:23:52] by Kevin Lynagh (2017)
• Practical UI physics [00:34:12] by David DeSandro (2015)
• We Will All Be Game Programmers [00:29:34] by Hunter Loftis (2015)
• User Interface (UX) Techniques [00:51:20] by Janne Jul Jensen (2013)

Web Development

• Accessibility Myths & Solutions [00:28:53] by Tea Ho (2018)
• Implementing and Using GraphQL at GitHub [00:38:55] by Kyle Daigle & Dan Schafer (2016)
• The Website Obesity Crisis [00:53:19] by Maciej Ceglowski (2015)
• Upgrading the Web [00:41:19] by Douglas Crockford (2015)
• How NOT to Measure Latency [00:42:59] by Gil Tene (2015)
• How I learned to Code by Making 180 websites in 180 days [00:22:03] by Jennifer De Walt (2015)
• Immutability: Putting The Dream Machine To Work [00:22:06] by David Nolen (2014)
• Hacker Way: Rethinking Web App Development at Facebook [00:44:36] by Tom Occhino, Jing Chen & Pete Hunt (it starts pretty slow and marketingy, but gets much better over time) (2014)
• React: RESTful UI Rendering [00:36:15] by Pete Hunt (2014)
• Unlock the next era of UI development with Polymer [00:41:31] by Rob Dodson (2014)
• Parallax Performance [00:32:01] by Paul Irish (2014)
• Delivering the goods [00:23:25] by Paul Irish (2014)
• Virtual Machines, JavaScript and Assembler [00:25:57] by Scott Hanselman (2014)
• Life is Terrible: Let's Talk About the Web [00:32:07] by James Mickens (2014)
• The Birth & Death of JavaScript [00:28:44] by Gary Bernhardt (2014)
• C10M - Defending The Internet At Scale [00:47:53] by Robert Graham (2013)
• React: Rethinking best practices [00:29:32] by Pete Hunt (2013)
• An End to Negativity [00:27:26] by Chris Williams (2013)
• Community.js [00:21:40] by Chris Williams (2013)
• Hey Underscore, You're Doing It Wrong! [00:36:31] by Brian Lonsdorf (2013)
• Go To There and Back Again [00:49:06] by Douglas Crockford (2013)
• HTML5 Boilerplate [01:04:20] by Paul Irish (2011)

Miscellaneous

• Start With Just a Few Things [00:09:54] by Max Hallinan (2019)
• Improper Hierarchy [00:34:26] by Tom Murphy VII. (2018)
• It’s super effective! Solving Pokemon Blue with a single, huge regular expression [00:13:57] by Alex Clemmer (2018)
• Let’s Program a Banjo Grammar [00:35:54] by Ryan Herr (2018)
• Soul from Scratch: Designing a More Portable Organ [00:37:59] by Peter Teichman (2018)
• I Don’t Have Time For This [00:31:22] by Aaron Patterson (2017)
• RailsConf 2017: Keynote [00:50:31] by Aaron Patterson (2017)
• Mob Programming A Whole Team Approach [00:37:25] by Woody Zuill (2017)
• LIGO: The Dawn of Gravitational Wave Astronomy [00:56:17] by Jameson Rollins (2016)
• Juggling Patterns and Programs [00:48:50] by Steve Miner (2016)
• African Polyphony & Polyrhythm [00:41:49] by Chris Ford (2016)
• A Brief History of Time [00:45:17] by Fred Hebert (2016)
• Complexity and the Art of the Left Turn [00:52:05] by K Lars Lohn (2016)
• A Programmer’s Guide To Western Music [00:42:13] by Andrew Sorensen (2015)
• Kolmogorov music [00:42:05] by Cristopher Ford (2015)
• Well I Wouldn't Want To Make a *Dys*functional Game [00:18:17] by Morgan Mullaney (2015) [A]
• You Suck at Excel [00:54:00] by Joel Spolsky (2015)
• Stop Treading Water: Learning to Learn [00:40:58] by Edward Kmett (2014)
• Madam Sandi Tells Your Future [00:38:13] by Sandi Metz (2014)
• Software Development Lessons from the Apollo Program [00:29:59] by Julian Simioni (2014)
• States and Nomads: Handling Software Complexity [00:29:54] by Zach Tellman (2015)
• Clojure: Programming with Hand Tools [00:58:38] by Tim Ewald (2014)
• How To Shut Down Tolkien [00:42:41] by Brandon Rhodes (2014)
• Linux Sucks - 2014 [00:44:59] by Bryan Lunduke (2014) [A]
• To the Moon! [00:52:43] by Russ Olsen (2013)
• DjangoCon EU 2013 Keynote [00:31:10] by Brandon Rhodes (2013)
• It's not what you read, it's what you ignore [01:01:52] by Scott Hanselman (2012)
• WAT [00:04:17] by Gary Bernhardt (2012)
• Linus Torvalds on git [01:10:15] by Linus Torvalds (2007) [A]

Contributing

Generally, a lot of talks are welcome on this list. The topic does not matter too much - it should be linked to Computer Science - but the format does. Talks are welcome if

• they were recorded at a conference or meetup (i.e. no screencasts or vlogging)
• they are awesome™!

I hope that is straightforward, understandable and makes sense.

When adding a new section/subsection or entry, please try to ensure it's sorted accordingly:

• The two top-level sections (Languages and Theory) have their subsection headings organised alphabetically (APL > VimL).

• The Languages subsections are sorted ascending by year (last field), then alphabetically by title. For example, an entry with (2012) should be below one with (2017) regardless of title; entries from the same year are then alphabetised within each year-group.

  • Groups of years are separated from one another by <br>\n (<br> followed by an empty line), except if a group would contain only a few (<= 3) talks and it is near another small group, in which case small adjacent year-groups are consolidated. An entry or two might also be included in an adjacent larger year-group iff the entries have different years.

• The Theory subsections are sorted only ascendingly by year, with no attention to title, and no grouping by year.

  • It doesn't matter where in a group of same-year-talks a specific (added) talk goes.