Repository files navigation

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 thelist.

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 lookbelow.

Disclaimer: I did not give any of the talks on the list and am responsible neitherfor their content nor for their presentation. All links below will direct you toexternal sites (mostly YouTube, really), be aware of that. If you are one of the peopleresponsible 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 thatsomeone 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.

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

• Scott Meyers (C++): Scott Meyers is one of the most entertaining and knowledgeablespeaker when it comes to all things C++. His talks cover a variety of topics, from typeinference to API design and cache lines.
• Rich Hickey (Clojure): I am not a Clojure programmer, but I like reasoning aboutand building programming languages. Even if you don't, Rich Hickeys talks are inspiringand 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 fornot watching this guy speak.
• Reginald Braithwaite (JavaScript): one of my favourite JavaScript speakers. Healso has a variety of talks on my list, but is more true to his realm (JavaScript) thanmost of the other speakers on my list.
• David Nolen (Clojure/Clojurescript): The core maintainer of Clojurescript. His talksmostly 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 saymore? He has a lot of low-level knowledge about Python and makes poking at the Python interpreterseem 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. Mostof his talks are also very beginner-friendly.
• Brandon Rhodes (Python): Yet another Pythonista. His talks are enjoyable, enlighteningand his way of talking isjust enjoyable - you might think that is secondary, but it is reallyimportant. 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 coredeveloper 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 genericsin 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 moreapproachable than it actually is, and that is a good thing.
• Zach Tellman (Clojure, Theory): Another person in the Clojure landscapewith interesting, important insights that do not only apply to Clojure. Histalks on theory should inspire you to think more deeply about what you aredoing, which is probably the most important thing to take away from anythingever.

• 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

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

• Lessons for the Masses from the Trenches of Co-dfns [00:21:53] byAaron Hsu (2019)
• Tacit Techniques with Dyalog version 18.0 Operators [00:28:53] byMarshall Lochbaum (2019)

• Patterns and Anti-patterns in APL: Escaping the Beginner's Plateau [00:59:02] byAaron Hsu (2017)

• 50 Years of APL Datatypes: From Booleans to Hypercomplex Numbers [00:39:21] byBob Smith (2016)

• Enough x86 Assembly to Be Dangerous [00:30:58] byCharles Bailey (2017)

• The Teensy ELF Executable [00:49:03] byBrian Raiter (2014)

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

• What is new in C and POSIX? [00:49:50] byPeter Eisentraut (2025) (held at PGConf.dev, so from a PostgreSQL PoV)

• Advanced C Coding For Fun! [00:46:53] byRusty Russell (2014)

• Writing application fault handlers [00:49:03] byGilad Ben-Yossef (2008)

• Evolving Clojure with Virtual Threads [00:40:24] byAlex Miller (2025)

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

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

• Core.Async in Use [00:34:04] byTimothy Baldridge (2017)
• Symbolic Assembly: Using Clojure to Meta-program Bytecode [00:39:42] byRamsey Nasser (2017)

• Bare Metal Clojure with clojure.spec [00:36:07] byMichael Reitzenstein (2016)
• Clarifying Rules Engines with Clara Rules [00:37:07] byMike Rodriguez (2016)
• Clojure at DataStax: The Long Road From Python to Clojure [00:29:28] byNick Bailey (2016)
• Composing music with clojure.spec [00:46:30] byWojciech Franke (2016)
• Creating DSLs - A tale of spec tacular success and failure [00:39:46] byClaire Alvis (2016)
• Full stack FP in Datomic, Clojure, and ClojureScript [00:51:30] byPriyatam Mudivarti (2016)
• Live-Coding Mathematics Your First Clojure Proof [00:41:54] byFrederic Peschanski (2016)
• Managing One of the World's Largest Clojure Code Bases [00:41:05] byDonevan Dolby (2016)
• Parallel Programming, Fork Join, and Reducers [00:40:53] byDaniel Higginbotham (2016)
• Proto REPL, a New Clojure Development and Visualization Tool [00:30:10] byJason Gilman (2016)
• Spec-ulation [01:16:23] byRich Hickey (2016)
• The Next Five Years of ClojureScript [01:00:57] byDavid Nolen (2016)
• Using Clojure with C APIs for crypto and more [00:41:07] bylvh (2016)

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

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

• Clojure core.async [00:44:25] byRich Hickey (2013)
• Clojure Data Science [00:32:40] byEdmund Jackson (2013)
• Clojure Enemy of the State [01:06:31] byAlex Miller (2013)
• Clojure in 10 Big Ideas [00:30:48] byStu Halloway (2013)
• Clojure Library Core.async for Asynchronous Programming [00:55:32] byDavid Nolen (2013)
• Core.Async [00:39:45] byTimothy Baldridge (2013)
• Design, Composition and Performance [00:51:10] byRich Hickey (2013)
• Expert to Expert - Inside Clojure [00:53:56] byRich 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] byDavid Nolen (2013)
• Machine Learning Live [00:27:38] byMike Anderson (2013)
• Make Your Own Lisp [00:53:52] byBodil Stokke (2013)
• Playing Go with Clojure [00:35:53] byZach Tellman (2013)
• Predicate Dispatch [00:28:58] byDavid Nolen (2013)
• The Macronomicon [00:42:02] byMichael Fogus (2013)

• Clojure Concurrency [02:32:39] byRich Hickey (2012)
• Why Is A Monad Like A Writing Desk? [00:30:38] byCarin Meier (2012)

• Clojure for Schemers [01:17:27] byDavid Nolen (2011)

• Persistent Data Structures and Managed References [00:55:53] byRich Hickey (2009)

• Embracing an Adversarial Mindset for C++ Security [01:26:19] byAmanda Rousseau (2025)
• Peering Forward - C++’s Next Decade [01:36:29] byHerb Sutter (2025)

• C++ Exceptions for Smaller Firmware [01:24:35] byKhalil Estell (2024)

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

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

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

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

• Back to the Basics! Essentials of Modern C++ Style [01:40:27] byHerb Sutter (2014)
• C++ on Mars: Incorporating C++ into Mars Rover Flight Software [01:26:18] byMark Maimone (2014)
• C++17: I See A Monad In Your Future [01:20:59] byBartosz Milewski (2014)
• Efficiency with Algorithms, Performance with Data [01:13:41] byChandler 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] byHerb Sutter (2014)
  • Lock-Free Programming (or, Juggling Razor Blades), Part II [01:11:19] byHerb Sutter (2014)
• Making C++ Code Beautiful [00:56:23] byJames McNellis & Kate Gregory (2014)
• Optimization Tips - Mo' Hustle Mo' Problems [00:58:19] byAndrei Alexandrescu (2014)
• Plain Threads are the GOTO of todays computing [01:27:36] byHartmut Kaiser (2014)
• Pragmatic Type Erasure: Solving OOP Problems with Elegant Design Pattern [00:43:47] byZach Laine (2014)
• Type Deduction and Why You Care [01:09:34] byScott Meyers (2014)

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

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

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

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

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

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

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

• GenStage and Flow [00:53:32] byJosé Valim (2017)
• Solid Ground [00:31:30] bySaša Juric (2017)
• Transforming Programming [00:46:45] byDave Thomas (2017)

• Building Multiplayer Games with Phoenix and Phaser [00:34:47] byKeith Salisbury (2016)
• Build Your Own Elixir [00:45:37] byLouis Pilfold (2016)
• Code Generation in Elixir [00:43:54] byBryan Weber (2016)
• Dialyzer: Optimistic Type Checking for Erlang and Elixir [00:48:57] byJason Voegele (2016)
• Enhanced Embedded Systems with Nerves [00:56:11] byJustin Schneck (2016)
• Elixir in Elixir [00:46:12] byJay Hayes (2016)
• Explicit Elixir [00:27:50] byPaul Lamb (2016)
• Learn Elixir: Building a Neural Network from Scratch [00:32:26] byKarmen Blake (2016)
• New Heights [00:48:42] byChris McCord (2016)
• Real World Elixir Deployment [00:40:35] byPete Gamache (2016)
• Securing Elixir Applications [00:42:52] byBram Verburg (2016)
• The Climb: Experiencing the Rise of Elixir from the Inside [00:43:22] byBruce Tate & Dave Thomas (2016)

• Elixir Should Take Over the World [00:58:30] byJessica 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] byChris McCord (2015)

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

• Demystifying Parsers [00:22:12] byTereza Sokol (2018)

• If Coco Chanel Reviewed Elm [00:17:30] byTereza Sokol (2017)
• The life of a file [00:47:01] byEvan Czaplicki (2017)

• Controlling Time and Space: understanding the many formulations of FRP [00:40:55] byEvan Czaplicki (2014)

• Operable Erlang and Elixir [00:35:29] byFred Hebert (2019)

• Getting to the BEAM, without going through Erlang [00:24:32] byKofi Gumbs (2018)

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

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

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

• 26 years with Erlang or How I got my grey hairs [01:20:00] byJoe Armstrong (2013)
• A Few Improvements to Erlang [00:43:30] byJoe Armstrong (2013)
• Chicago Boss: A Web Framework Built for Comfort (and Speed) [00:45:59] byEvan Miller (2013)
• Over a Century of Programming [01:00:10] byMike Williams, Joe Armstrong & Robert Virding (2013)

• Erlang in production: I wish I'd known that when I started [00:42:43] byBernard Duggan (2012)

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

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

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

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

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

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

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

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

• Concurrency Is Not Parallelism [00:31:22] byRob Pike (2012)
• Go Concurrency Patterns [00:51:27] byRob Pike (2012)

• Practical Go Programming [00:59:20] byAndrew Gerrand (2011)

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

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

• Dependent Types in Haskell [00:38:41] byStephanie Weirich (2017)
• Escape from the ivory tower: the Haskell journey [01:04:15] bySimon Peyton-Jones (2017)

• Point-Free or Die: Tacit Programming in Haskell and Beyond [00:36:12] byAmar Shah (2016)
• What are Types for, or are they only Against? [01:03:37] byConor McBride (2016)

• Enigmatic Haskell, Haskellish Enigma [00:59:41] byRishiyur S. Nikhil (2015)
• Framing the Discussion with EDSLs [01:41:41] byAnthony Cowley (There is a repository containing the slides and codehere) (2015)
• Next Level MTL [00:44:36] byGeorge Wilson (2015)
• Pure Type Systems [01:17:01] byCody Roux (2015)
• The Road to Running Haskell at Facebook Scale [00:43:36] byJon Coens (2015)

• Demystifying Haskell [00:26:11] byAndrew Rademacher (for Beginners) (2014)
• Getting a Quick Fix on Comonads [00:58:33] byKenneth 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] byErin 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] byAlissa Pajer (2014)
• Introduction to Low Level Haskell Optimization [01:09:40] byDan Doel (2014)
• Safe Zero-Cost Coercions for Haskell [00:26:01] byRichard A. Eisenberg (2014)
• Writing a game in Haskell [00:29:37] byElise Huard (2014)

• Lenses, Folds, and Traversals [01:54:46] byEdward Kmett (2012)
• The Algebra In Algebraic Data Types [01:04:35] byChris Taylor (2012)

• Haskell Amuse-Bouche [00:57:13] byMark Lentczner (the audio quality is scarily bad) (2011)

• Data Parallel Haskell [01:19:56] bySimon Peyton Jones (2010)

• A History of Haskell: being lazy with class [00:56:46] bySimon Peyton Jones (2007)

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

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

• Java in 2018: Change is the Only Constant [00:27:08] byMark Reinhold (2018)

• Modules in One Lesson [00:51:17] byMark Reinhold (2017)
• g ∘ f patterns [00:50:44] byMario Fusco (2017)
• Parallel and Asynchronous Programming with Streams and CompletableFuture [02:34:29] byVenkat Subramaniam (2017)

• A JVM does that??? [00:51:58] byCliff Click (2016)
• Optional - The Mother of All Bikesheds [00:58:42] byStuart Marks (2016)

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

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

• JVM Bytecode for Dummies (and the Rest of Us Too [00:50:34] byCharles O.o Nutter (2013)

• Java - The Good, Bad and Ugly Parts [00:14:34] byJosh Bloch (2011)

• Effective Java; Still Effective After All These Years [01:13:59] byJoshua Bloch (2009)

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

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

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

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

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

• The first ever presentation on Node.js [00:48:31] byRyan Dahl (2012)
• Crockford on JavaScript [10:20:32] byDouglas Crockford (2011) (total runtime across 8 parts)
• Introduction to Node.js [00:58:18] byRyan Dahl (2010)

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

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

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

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

• The Most Beautiful Program Ever Written [01:31:05] byWilliam Byrd (2017)

• Lisp [00:56:00] byIgor Wiedler (2014)

• Practical Common Lisp [01:12:04] byPeter Seibel (2012)

• Object-Oriented Programming in Objective-C [00:31:10] byGraham Lee (2015)

• RACify Non-Reactive Code [00:24:23] byDave Lee (2014)

• Jane and the Compiler [01:03:45] byYaron Minsky (2018) [A]

• Why OCaml [01:06:39] byYaron Minsky (2016)

• Caml Trading [01:12:43] byYaron Minsky (2012)

• Production Prolog [00:39:57] byMichael Hendricks (2014)

• A Taste of Prolog [00:33:48] byAja Hammerly (2012)

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

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

• Exploring the CPython JIT [00:28:45] by *Diego Russo (2025)
• What they don't tell you about building a JIT compiler for CPython [00:29:02] byBrandt Bucher (2025)

• GraalPy - Fast Python Implementation (00:22:47) byŠtěpán Šindelář, Tim Felgentreff (2024)

• A Talk near the Future of Python? [01:01:11] byDavid Beazley (2019)

• Understanding Python Bytecode [00:29:44] byJames Bennett (2018)

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

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

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

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

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

• A Python Æsthetic: Beauty and Why I Python [00:46:56] byBrandon Rhodes (2012)
• Inside the Python GIL [01:01:03] byDavid Beazley (2012)
• pandas: Powerful data analysis tools for Python [00:34:38] byWes McKinney (2012)
• Python Epiphanies [02:21:44] byStuart Williams (PDF version/code can be foundhere) (2012)
• Python Metaprogramming for Mad Scientists and Evil Geniuses [00:37:13] byWalker Hale (2012)
• Stop Writing Classes [00:27:29] byJack Diederich (2012)
• Understanding the Python GIL [00:46:10] byDavid Beazley (2012)

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

• Generic Collections: One Interface to Rule Them All [00:18:26] byAlexis King (2015)
• Generic Syntax Expanders and Extensible Macros [00:16:26] byJack Firth (2015)
• Racket: A Programming-Language Programming Language [00:51:42] byRobby Findler (2015)
• The Racket Manifesto [00:52:42] byMatthias Felleisen (2015)

• Purely Functional 3D in Typed Racket [00:22:15] byNeil Toronto (2014)

• Writing Ruby Like it’s 2018 [00:11:53] byJoe Leo III (2018)

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

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

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

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

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

• What Killed Smalltalk Could Kill Ruby, Too [01:00:55] byRobert Martin (2009)

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

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

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

• What Rust can teach us about Ruby [00:34:07] bySteve Klabnik (2015)

• Cap'n Proto and Rust: Type Systems for Sharing [00:40:47] byDavid Renshaw (2014)
• Concurrency in Rust [00:31:24] byAlex Crichton (2014)

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

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

• How types can turn a SQL interpreter into a SQL compiler [00:40:31] byTiark Rompf (2014)
• Scala Collections: Why Not? [00:45:42] byPaul Phillips (beware: not very optimistic!) (2014)

• Concurrency Anti-Patterns in Scala [00:29:53] byBlake Matheny (2013)

• Scala Monads: Declutter Your Code With Monadic Design [00:31:22] byDan Rosen (2012)
• Scala Versus Java [01:32:35] byDan Rosen (2012)

• What's Next for Scala [01:15:06] byMartin Odersky (2011)

• The Nanopass Framework as a Nanopass Compiler [00:52:10] byAndrew Keep (2020)

• miniKanren [00:46:23] byDan Friedman & William Byrd (2013)

• Dan Friedman - Cool Ideas [00:57:00] byGuy Steele (2011)

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

• Implementing Swift Generics [00:44:37] bySlava Pestov (2017)

• Controlling Complexity in Swift — or — Making Friends with Value Types [00:57:45] byAndy Matuschak (2015)
• Swift's High-Level IR: A Case Study... [00:55:37] byJoe Groff & Chris Lattner (2015) [A]

• Swift Programming Language for JavaScript Developers [00:41:19] byJ.P. Simard (2014)
• Thinking in Swift [00:24:23] byAbizer Nasir (2014)

• Unison: An Introduction [01:53:49] byRúnar Bjarnason (2020)

• Introduction to the Unison programming language [00:40:58] byRúnar Bjarnason (2018)

• The Unison Language and its Scala-based Runtime [00:45:49] byPaul Chiusano (2017)

• How to write a search engine in 15 lines of code [00:36:04] byPaul Chiusano (2016)

• Going mouseless with Vim, Tmux, and Hotkeys [00:57:27] byLeeren Chang (2018)

• More Instantly Better Vim [00:38:51] byDamian Conway (2013)
• Vim - I Wish I Knew How To :q You [00:41:08] byChris Maiden (not really about VimL, more of a general introduction into vim) (2013)

• Write code faster: expert-level vim [00:41:09] byBen Orenstein (not really expert level) (2012)

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

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

• A Beginners’ Guide to SelectionDAG [00:52:09] byAlex MacLean, Justin Fargnoli (2025)
• Auto-Vectorization in HotSpot [00:42:29] byEmanuel Peter (2025)

• Towards a Verified Range Analysis for JavaScript JITs [00:12:19] byFraser Brown (2020) (Paper by Brown et al.)

• The Z Garbage Collector [00:37:13] byErik Österlund (2018)

• Datafun: a functional query language [00:42:30] byMichael Arntzenius (2017)
• The Unison Language and its Scala-based Runtime [00:45:49] byPaul Chiusano (2017)
• What Has My Compiler Done for Me Lately? Unbolting the Compiler's Lid [01:15:45] byMatt Godbolt (2017)

• An Introduction to Combinator Compilers and Graph Reduction Machines [00:39:30] byDavid Graunke (2016)
• Bringing Clang and C++ to GPUs: An Open-Source, CUDA-Compatible GPU C++ Compiler [00:59:33] byJustin Lebar (2016)
• Datafun: A Functional Datalog [00:24:38] byMichael Arntzenius (2016)
• Ruby and OMR: Experiments in utilizing OMR technologies in MRI [00:45:38] byCharlie Gracie (2016)
• What I learned from LuaJIT [01:15:42] byVyacheslav Egorov (2016)

• A VM is a VM is a VM: The Secret Path to High Performance Multi-Language Runtimes [00:47:07] byMark Stoodley (2015)
• Bits of advice for VM writers [00:43:59] byCliff Click (2015)
• Compilers are Databases [01:08:51] byMartin Odersky (2015)
• Hello Om Next! [01:20:25] byDavid Nolen (2015)
• Rise of the Transpilers [00:44:00] byJeremy Ashkenas (2015)
• So you want to write an interpreter? [00:40:38] byAlex Gaynor (2015)
• The movfuscator [00:49:14] byChristopher Domas (2015)
• Understanding Compiler Optimizations [01:50:14] byChandler Carruth (2015)
• VM Design Choices [01:01:38] byCliff Click (2015)
• Write your own compiler in 24 hours [01:04:07] byPhil Trelford (2015)

• Instaparse [00:38:38] byMark Engelberg (2014)
• Superoptimizing LLVM [00:49:07] byJohn Regehr (2014)
• Writing a Nanopass Compiler [00:40:48] byAndy Keep (2014)

• Implementing Domain Specific Languages with LLVM [00:50:59] byDavid Chisnall (2013)
• Let's Write an Interpreter [00:28:34] byRyan Davis (2013)
• The Clang AST [00:44:53] byManuel Klimek (2013)
• The Java Virtual Machine is Over - The Polyglot VM is here [00:51:02] byMarcus Lagergren (2013)

• How the PyPy JIT works [00:29:05] byBenjamin Peterson (2012)

• Intel OpenCL SDK Vectorizer [00:35:45] byNatav Rotem (2011)
• Parsing with Derivatives [01:13:10] byMatthew Might (2011)
• PTX Back-End: GPU Programming With LLVM [00:39:34] byJustin Holewinski (2011)

• The Glitching Hour [00:22:17] byAmy Wibowo (2018)

• Simit: A Language for Computing on Sparse Systems when Performance Matters [00:58:37] byFredrik Kjolstad (2016)

• Making things with maths [00:53:45] bySteven Wittens (2013)
• Making WebGL Dance [00:30:55] bySteven Wittens (2013)
• Principles of Lighting and Rendering [01:31:00] byJohn Carmack (2013)

• OpenCV and High-Performance Vision on GPU [02:24:59] byVictor Eruhimov (2012)

• The Art of Code [01:00:48] byDylan Beattie (2020)

• Creative Computation [00:21:00] byJack Rusher (2019)

• Making Games for 1920s Hardware [00:32:21] byEm Lazer-Walker (2018)
• Mapping Imaginary Cities [00:40:56] byMouse Reeve (2018)
• Picasso, Geometry, Jupyter [00:30:48] byRyan Herr (2018)

• How to Hack a Painting [00:44:58] byTyler Hobbs (2017)
• The Symmetries of Things [00:26:02] byTom Hall (2017)

• Programming In Time - Live Coding for Creative Performances [00:47:03] byAndrew Sorensen (2014)

• Stop Drawing Dead Fish [00:53:32] byBret Victor (2013)

• ACID Jazz [00:30:38] byKyle Kingsbury (2025)
• Investigating Multithreaded PostgreSQL [00:46:11] byThomas Munro (2025)
• Re-engineering Postgres for Millions of Tenants [00:52:01] byGwen Shapira (2025)
• The trouble with extensions [00:51:36] byMarco Slot (2025)

• Jepsen 7: Anna Concurrenina [00:53:06] byKyle Kingsbury (2017)

• To NoSQL or Not to NoSQL, That Is the Question [01:00:48] byDavid Ostrovsky (2015)
• Transactions: myths, surprises and opportunities [00:41:07] byMartin Kleppmann (2015)

• An Ode to 17 Databases in 33 Minutes [00:38:12] byToby Hede (2014)
• Cassandra and Go Doubleheader [00:58:23] byKyle Kingsbury & Al Tobey (this video features two distinct talks, only the first one deals with databases) (2014)
• Consistency without consensus in production systems [00:41:09] byPeter Bourgon (2014)
• Jepsen II: Linearizable Boogaloo [00:44:46] byKyle Kingsbury (2014)
• Postgres Performance for Humans [00:33:49] byCraig Kerstiens (2014)
• Sharding and Scaling Your Database [00:42:53] byNeha Narula (2014)

• Introduction to NoSQL [00:54:52] byMartin Fowler (2013)

• Deconstructing the Database [01:06:24] byRich Hickey (2012)
• The Impedance Mismatch is Our Fault [00:58:31] byStuart D. Halloway (2012)

• How a File Format Led to a Crossword Scandal [00:19:53] bySaul Pwanson (2019)

• Sonification: a Battle on Two Fronts [00:28:21] byMartin Keary (2018)
• You can't do data science in a GUI [01:15:18] byHadley Wickham (2018)

• Data as Software as Data [00:40:27] byAndrea Burbank (2016)
• Expressing complex data aggregations with Histogrammar [00:35:02] byJim Pivarski (2016)

• A CRDT Primer: Defanging Order Theory [00:37:00] byJohn Mumm (2018)
• Meetings With Remarkable Trees [00:53:29] byBodil Stokke (2018)
• The simple essence of automatic differentiation [01:01:41] byConal Elliott (2018)
• Tree-sitter - a new parsing system for programming tools [00:38:37] byMax Brunsfeld (2018)

• Designing a Fast, Efficient, Cache-friendly Hash Table, Step by Step [00:59:33] byMatt Kulukundis (2017)

• Exotic Functional Data Structures: Hitchhiker Trees [00:40:32] byDavid Greenberg (2016)
• Parsing Text with a Virtual Machine [00:43:53] byGhadi Shayban (2016)
• Probabilistic Data Structures [00:38:47] byJames Stanier (2016)
• Reasoning about performance (in the context of search) [00:29:28] byDan Luu (2016)

• An Overview of Probabilistic Programming [01:02:54] byVikash K. Mansinghka (I am unsure where to put this) (2015)
• Hash Functions and You: Partners in Freedom [00:27:06] byCurtis Lassam (2015)

• Persistent Data Structures for Special Occasions [00:44:44] byMichał Marczyk (2014)
• Practical Fractals in Space [00:38:27] byMichelle Brush (2014)
• Visualizing Persistent Data Structures [00:37:24] byDann Toliver (2014)

• Generic sorting and partitioning in linear time and fully abstractly [01:07:41] byFritz Henglein (2012)

• The Hurricane's Butterfly: Debugging Pathologically Performing Systems [01:06:49] byBryan Cantrill (2018)

• Tackling Concurrency Bugs with TLA+ [00:30:05] byHillel Wayne (2017)

• Debugging with the Scientific Method [00:49:08] byStuart Halloway (2015)

• What's Next for DevOps? [00:29:34] byEmily Freeman (2021) [A]

• Pragmatic Automation [00:24:33] byMax Luebbe (2019) [A]

• How Netflix Thinks About DevOps [00:31:10] byDave Hahn (2016)
• The Future Of DevOps [00:47:49] byAdrian Cockcroft (2016)

• Chef Style DevOps Kungfu [01:16:08] byAdam Jacob (2015)
• Demistifying SNMP [00:49:19] byDouglas Mauro (2015)
• I got 10 trillion problems, but logging ain't one [00:25:17] byJohn Graham-Cumming (2015)
• Salting things up in the sysadmin's world [00:37:21] byJuan Manuel Santos (2015)
• Your infrastructure is not a unique snowflake, and that's ok! [00:37:39] byJeremy Edberg (2015)

• Squashing the Heisenbug with Deterministic Simulation Testing [00:25:58] byDominik Tornow (2025)

• Send me your Echolocation [00:26:06] byVicky Nguyen (2018)
• Everything about distributed systems is terribleDesigning Distributed Systems with TLA+ [00:38:25] byHillel Wayne (2018)

• Load Balancing is Impossible [00:36:43] byTyler McMullen (2016)

• Coordination-Free Computations [00:46:15] byCristopher Meiklejohn (really fast talker) (2015)
• Distributed Eventually Consistent Computations [00:49:37] byChristopher Meiklejohn (2015)
• Distributed Systems 101 [00:45:25] bylvh (2015)
• Everything Will Flow [00:40:12] byZach Tellman (2015) [A]
• Jepsen IV: Hope Springs Eternal [00:54:33] byKyle Kingsbury (2015)
• Scaling Instagram [00:27:13] byMike Krieger (2015)

• K things I know about building Resilient Reactive Systems [01:00:02] byJoe Armstrong (2014)

• The How and Why of Fitting Things Together [00:46:39] byJoe Armstrong (2013)

• Improving Yesterday [00:37:57] byEric Fode (2019)

• How and Why to Start A Startup [00:44:42] bySam Altman & Dustin Moskovitz (2017)
• How to Build a Product (Part IV) [00:51:24] byJan Koum (2017)

• Barely succeed! It’s easier! [00:39:22] byMaciej Cegłowski (2013)

• Time Management [01:16:21] byRandy Pausch (2007)

• Why Isn't Functional Programming the Norm? [00:46:08] byRichard Feldman (2019) [A]

• What FP can learn from Smalltalk [00:43:36] byAditya Siram (2018)

• Evolving Functional Programming Languages [00:40:59] byErik Osheim (2017)
• Peeling the Banana: Recursion Schemes from First Principles [00:34:21] byZainab Ali (2017)
• Profunctor Optics: The Categorical Approach [00:45:33] byBartosz Milewki (2017)

• Functional architecture - The pits of success [01:00:10] byMark Seemann (2016)
• Why Functional Programming Matters [00:56:09] byJohn Hughes (2016)

• A More Elegant Specification for FRP [00:29:54] byConal Elliott (2015)
• Denotational Design: From Meanings To Programs [02:20:35] byConal Elliott (2015)
• Functional Programming Design Patterns [01:05:43] byScott Wlaschin (2015)
• Papers We Love: Composable and Compilable Macros [00:54:49] bySam Tobin-Hochstadt (2015)
• The Essence and Origins of Functional Reactive Programming [00:59:24] byConal Elliott (2015)
• Unconventional Programming with Chemical Computing [00:36:00] byCarin Meier (2015)

• Functional Programming; What? Why? When? How? [00:58:27] byRobert C Martin (2014)
• Railway oriented programming: Error handling in functional languages[mirror] [00:56:55] byScott Wlaschin (2014)
• The Functional Final Frontier [00:27:02] byDavid Nolen (2014)

• Deconstructing Functional Programming [00:48:33] byGilad Bracha (2013)
• Functional Principles for Object Oriented Development [00:51:13] byJessica Kerr (2013)
• Living in a Post-Functional World [00:45:46] byDaniel Spiewak (2013)

• Adventures in Functional Programming [00:50:34] byJim Weirich (2012)
• Don't fear the Monad [01:07:11] byDr. Brian Beckman (2012)
• Faith, Evolution, and Programming Languages [01:06:54] byPhillip Wadler (2012)

• Tangible Functional Programming [00:56:25] byConal Elliott (2007)

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

• What Every Programmer Should Know about How CPUs Work [00:43:27] byMatt Godbolt (2024)

• A Taste of GPU Compute [01:05:06] byRaph Levien (2020)

• eMMC hacking, or: how I fixed long-dead Galaxy S3 phones [00:56:07] byOran Avraham (2018)
• Mill vs. Spectre: Performance and Security [00:46:42] byIvan Godard (2018)

• A Crash Course in Modern Hardware [00:59:20] byCliff Click (2016)
• The Future of Microprocessors [00:46:35] bySophie Wilson (2016)

• Let's Build a Computer! [00:29:03] byRyan Davis (2014)

• Constraint Logic Propagation Conflict Spreadsheets [00:33:50] byWilliam Taysom (2015)
• Web Testing with Logic Programming [00:39:10] byDaniel Gregoire (2015)

• Challenges for Logic Programming [00:40:45] bySteve Miner (2013)

• Post-Transformer Architectures: State Space Models, RWKV [00:42:44] byDan Fu & Eugene Cheah (2024)

• Building the Software 2.0 Stack [00:30:08] byAndrej Karpathy (2018)

• Machine learning is not the future [00:38:59] byRajat Monga (2016)

• Neural Nets for Newbies [00:30:57] byMelanie Warrick (2015)

• From the Lab to the Factory: Building a Production Machine Learning Infrastructure [01:04:27] byJosh Wills (2014)
• The Unreasonable Effectiveness of Deep Learning [01:07:24] byYann LeCun (2014)

• Automatic Algorithm Invention with a GPU [01:02:04] byWesley Faler (2011)
• The Unreasonable Effectiveness of Data [01:02:56] byPeter Norvig (2011)

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

• Field of Rationality and Category Theory [00:44:07] byMichał Heller (2015)
• The Continuum Hypothesis and the search for Mathematical Infinity [00:55:18] byW. Hugh Woodin (2015)

• Category Theory [01:36:54] byTom LaGatta (2014)

• Constructive Type Theory and Homotopy [00:41:00] bySteve Awodey (2010)

• Homoiconicity It Is What It Is [00:30:39] byStuart Sierra (2017)
• On Storytelling [00:20:00] byEvan Czaplicki (2017)

• How we program multicores [00:58:52]Joe Armstrong (2016)

• Ideology [00:21:23] byGary Bernhardt (2015)
• Simplicity is Complicated [00:23:11] byRob Pike (2015)

• Make Simple Tasks Simple! [01:37:36] byBjarne Stroustrup (2014)
• Programming should eat itself [00:47:40] byNada Amin (2014)
• Why C++ Sails When the Vasa Sank [01:07:03] byScott Meyers (2014)

• Running a startup on Haskell [00:50:23] byBryan O'Sullivan (2013)

• Scaling Yourself [00:28:51] byScott Hanselman (2012)

• X Marks the Spot: Navigating Possible Futures with Wardley Maps [00:39:25] bySimon Wardley (2025)

• The Best Programmer I Know [00:39:48] byDaniel Terhorst-North (2024)

• Stop Writing Dead Programs [00:43:03] byJack Rusher (2022)

• Dealing with unanticipated needs [00:47:43] byDave Snowden (2019)
• How to be a Happy Developer. Now! [00:39:32] byChristian Robert (2019)
• Stewardship Made Practical [00:50:35] byStuart Halloway (2019)

• Computing, Climate Change, and All of our Relationships [00:40:33] byNabil Hassein (2018)
• Jolly JS Journeys [00:23:02] byTim Holman (2018)
• Shaping our children's education in computing [00:51:08] bySimon Peyton Jones (2018)
• The Hard Parts of Open Source [00:47:15] byEvan Czaplicki (2018)

• Code Review, Forwards and Back [00:22:33] bySumana Harihareswara & Jason Owen (2017)
• Crossing the River by Feeling the Stones [00:55:30] bySimon Wardley (2017)
• Forget Velocity, Let's Talk Acceleration [00:54:46] byJessica Kerr (2017)
• Idée Fixe [00:39:36] byDavid Nolen (2017)
• Invited Talk [01:07:21] byGuy Steele (2017) (on notation) [A]
• On Abstraction [01:00:02] byZach Tellman (2017)
• Patterns Failed. Why? Should We Care? [00:26:40] byBrian Marick (2017)
• Winning the War on Error: Solving Halting Problem, Curing Cancer [01:09:38] byMatt Might (2017) [A]

• Don’t demo facts. Demo stories! [00:57:22] byTudor Gîrba (2016)
• extern c: Talking to C Programmers about C++ [01:36:26] byDan Saks (2016)
• How to become a Data Scientist in 6 months - A hacker’s approach to career planning [00:56:24] byTetiana Ivanova (2016) [A]
• Humanizing among coders [00:41:15] byAna Balica (2016)
• It's Simple [00:37:35] byAdrian Cockcroft (2016)
• Software, Faster [00:54:19] byDan North (2016)
• “Am I Senior Yet?” Grow Your Career by Teaching Your Peers [00:37:57] byKatlyn Parvin (2016) [A]

• Common pitfalls of junior developers [00:09:37] byRachel Warbelow (2015) [A]
• PyCon 2015 Keynote [00:35:51] byJacob Kaplan-Moss (2015)
• What can programmers learn from pilots? [00:31:07] byAndrew Godwin (2015) [A]

• Being Human [00:19:45] byBrian J. Brennan (not technical, but very important) (2014) [A]
• You are Not an Impostor [00:33:02] byNickolas Means (2014) [A]

• Career Advice for Programmers [00:54:18] byTrisha Gee (2013)
• Patterns in Architecture [01:03:35] byChristopher Alexander (2013)

• Normal Considered Harmful [01:07:26] byAlan Kay (2012)

• We Really Don't Know How To Compute! [01:04:20] byGerald Jay Sussman (2011)

• Extended BPF: A new software type [00:31:03] byBrendan Gregg (2019)

• Learning the Linux Kernel with tracing [01:07:24] bySteven Rostedt (2018)

• You can be a kernel hacker! [00:33:31] byJulia Evans (2014)

• Python, Linkers, and Virtual Memory [00:31:15] byBrandon Rhodes (2012)

• The Origins of Linux [1:25:12] byLinus Torvalds (2001) [A]

• Performance Matters [00:42:14] byEmery Berger (2019)

• Software Performance: A Shape Not a Number [00:31:59] byKay Ousterhout (2018)
• Xi: an editor for the next 20 years [00:53:20] byRaph Levien (2018)

• Designing for Performance [00:50:17] byMartin Thompson (2015)

• Do Programming Language Features Deliver on their Promises [00:51:35] byAaron Hsu (2025)
• Jai Demo and Design Explanation [01:13:00] byJonathan Blow (2025)
• My favorite verbose programming technique [00:57:22] byAaron Hsu (2025)

• On the Expressive Power of Programming Languages [00:59:03] byShriram Krishnamurthi (2019)
• Stuck macros: deterministically interleaving macro-expansion and typechecking [00:41:55] bySamuel Gélineau (2019)
• Three Things I Wish I Knew When I Started Designing Languages [00:44:28] byPeter Alvaro (2019)

• A Little Taste of Dependent Types [00:38:35] byDavid Christiansen (2018)
• A Tale of Two Asyncs: Open Source Language Design in Rust and Node.js [00:47:24] byAshley Williams (2018)
• Four Languages from Forty Years Ago [01:01:45] byScott Wlaschin (2018)
• Gradual typing of Ruby at Scale [00:38:45] byDmytro Petrashko & Paul Tarjan (2018)
• Proof Theory Impressionism: Blurring the Curry-Howard Line [00:35:07] byDan Pittman (2018)
• Running With Scissors: Live Coding With Data [00:39:35] byStuart Halloway (2018)
• Rust and Other Interesting Things [00:37:06] byBryan Cantrill (2018)

• Types, and why you should care [01:04:05] byRon Minsky (2017)

• Into the Core - Squeezing Haskell into Nine Constructors [01:07:48] bySimon Peyton Jones (2016)
• Let's Build a Hygienic Macro Expander [00:40:04] byMatthew Flatt (2016)
• Make Your Own Programming Language! [00:26:07] byNick Heiner (2016)
• Sketch-n-Sketch: Interactive SVG Programming with Direct Manipulation [00:40:17] byRavi Chugh (2016)

• Eve [00:46:03] byChris Granger (2015)
• Everything old is new again: Quoted Domain-Specific Languages [00:39:06] byPhilip Wadler (2015)
• I See What You Mean [00:52:28] byPeter Alvaro (2015)
• Let's be mainstream! User focused design in Elm [00:58:23] byEvan Czaplicki (2015)
• Papers We Love: Fundamental Concepts in Programming Languages [01:16:39] byJohn Myles White (2015)
• Pixie - A Lightweight Lisp with 'Magical' Powers [00:33:12] byTimothy Baldridge (a good intro on tracing JITs) (2015)
• Propositions as Types [00:42:42] byPhilip Wadler (2015)
• Syntaxation [00:49:39] byDouglas Crockford (2015)
• The Worst Programming Language Ever [00:43:46] byMark 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] byArne Martin Aurlien (2014)
• The Sociology of Programming Languages [00:42:11] byLeo Meyerovich (2014)
• Transducers [00:45:00] byRich Hickey (2014)

• A Dinosaur's Thoughts on Programming Language Evolution [00:48:47] byMatthew Flatt (2013)

• No Ifs, Ands, or Buts: Uncovering the Simplicity of Conditionals [00:38:20] byJonathan Edwards (2007)

• Liquid resource types for verification and synthesis [01:05:13] byNadia Polikarpova (2020)

• Type-Driven Program Synthesis [00:39:39] byNadia Polikarpova (2018)

• Barliman: trying the halting problem backwards, blindfolded [00:36:13] byWilliam Byrd & Greg Rosenblatt (2016)

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

• No, Really... Robots and JavaScript?! [00:36:26] byRaquel Vélez (2015)

• Robots: You're Still Doing It Wrong [00:49:51] byKaty Levinson (not very formal, DefCon) (2012)

• Lessons From Two Years of Crypto Audits [00:45:49] byJean-Philippe Aumasson (2020)

• DNS, SNI, TLS, HTTPS: Modern DNS & Privacy [00:43:17] byBert Hubert (2019)
• No source, no problem! High speed binary fuzzing [00:59:28] byNspace & gannimo (2019)

• GOD MODE UNLOCKED - Hardware Backdoors in x86 CPUs [00:50:59] byChristopher 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] byJames Mickens (2018)
• WebAssembly: A New World of Native Exploits on the Browser [00:45:20] byJustin Engler & Tyler Lukasiewicz (2018)
• You're Probably Not Red Teaming... And Usually I’m Not, Either [00:43:43] byDeviant Ollam (2018)

• Breaking The x86 Instruction Set [00:44:28] byChristoper Domas (2017)
• Exploit Kit Cornucopia [00:45:08] byBrad Antoniewicz & Matt Foley (2017)
• Ichthyology: Phishing as a Science [00:24:28] byKarla Burnett (2017) [A]

• Boot strapping slightly more secure systems [00:47:43] byTrammell Hudson (2016)
• The Search for the Perfect Door [00:50:49] byDeviant Ollam (2016)

• Repsych: Psychological Warfare in Reverse Engineering [00:38:48] byChris Domas (2015)

• Pulling Back the Curtain on Airport Security: Can a Weapon Get Past TSA [00:31:52] byBilly Rios (2014)

• 28c3: The Science of Insecurity [00:59:22] byMeredith L. Patterson, Sergey (2011)

• Design in Practice [01:00:45] byRich Hickey (2023)
• Is Software Engineering Real Engineering? [00:37:31] byHillel Wayne (2023)

• Intro to Empirical Software Engineering: What We Know We Don't Know [00:37:42] byHillel Wayne [A] (2019)
• Moldable development [00:37:48] byTudor Gîrba (2019)
• Say What You Mean - Exploring Declarative Computation in Art [00:43:12] byDavid Schmudde (2019)
• Sherlock Holmes, Consulting Developer [00:33:28] byStuart Halloway (2019)

• A Philosophy of Software Design [01:01:39] byJohn Ousterhout (2018)
• Old Is the New New [00:50:22] byKevlin Henney (2018)
• OOP Is Dead, Long Live Data-oriented Design [01:00:45] byStoyan Nikolov (2018)
• Polly want a Message [00:40:00] bySandi Metz (2018)

• Programming Across Paradigms [00:49:07] byAnjana Vakil (2017)
• Requests Under The Hood [00:31:37] byCory Benfield (2017)
• TDD, Where Did It All Go Wrong [01:03:53] byIan Cooper (2017)
• The Post JavaScript Apocalypse [00:54:12] byDouglas Crockford (2017)
• Things that Matter [01:06:36] byScott Meyers (2017)
• You're Insufficiently Persuasive [00:35:37] bySandi Metz (2017)

• Get a Whiff of This [00:38:14] bySandi Metz (2016)
• Small Is Beautiful [01:07:02] byKevlin Henney (2016)
• The Error of Our Ways [00:49:44] byKevlin Henney (2016)
• The programmer [01:03:10] byKevlin Henney (2016)

• Apparatus: A Hybrid Graphics Editor / Programming Environment [00:37:56] byToby Schachman (2015)
• Big Code: Developer Infrastructure at Facebook's Scale [00:46:21] byBryan O'Sullivan, Christian Legnitto & Katie Coons (2015)
• Boundaries [00:30:19] byGary Bernhardt (2015)
• Conceptualizing Large Software Systems [00:17:17] byAlan Shreve (2015)
• Demystifying Docker [00:29:53] byAndrew T. Baker (2015)
• Microservices @ Spotify [00:49:07] byKevin Goldsmith (2015)
• One Hacker Way [00:55:36] byErik Meijer (2015)
• Scalable is Awesome, Literally! [00:43:48] byGarrett Smith (2015)

• All the Little Things [00:38:46] bySandi Metz (2014)
• CPU Caches and Why You care [01:01:55] byScott Meyers (written in C++, reasonable for almost every software developer) (2014)
• Kicking the Complexity Habit [00:55:30] byDan North (2014)
• The Future Doesn't Have to Be Incremental [00:43:50] byAlan Kay (2014)
• The Mess We're In [00:45:50] byJoe Armstrong (2014)
• The Most Important Design Guideline [00:58:42] byScott Meyers (2014)
• The S.O.L.I.D. Principles of Agile OO Design [01:23:35] byRobert C. Martin (way more interesting than it sounds) (2014)
• Thinking Above the Code [00:59:51] byLeslie Lamport (2014)
• What does it mean to be Reactive? [00:46:39] byErik Meijer (2014)

• I have a good feeling about this. Why tooling is poised to make the jump to hyperspace [00:43:14] byReginald Braithwaite (2013)
• Programming is terrible - Lessons learned from a life wasted [01:06:44] byThomas Figg (2013)
• The Future of Programming [00:32:56] byBret Victor (2013)
• The Language of the System [01:02:50] byRich Hickey (2013)
• The Not-So-Big Software Design [00:47:31] byReginald Braithwaite (2013)
• Whence Complexity? [00:55:32] byMichael Nygard (2013)

• A Whole New World [00:21:20] byGary Bernhardt (2012)
• Growing a Language [00:53:31] byGuy Steele (2012)
• Hammock Driven Development [00:39:49] byRich Hickey (2012)
• Inventing on Principle [00:54:20] byBret Victor (2012)
• Simplicity Matters [00:36:54] byRich Hickey (Simple Made Easy revisited) (2012)
• The Value Of Values [00:58:53] byRich Hickey (2012)

• Architecture the Lost Years [01:06:38] byRobert C. Martin (2011)
• Simple Made Easy [01:01:26] byRich Hickey (2011)

• Real Software Engineering [00:51:56] byGlenn Vanderburg (2010)

• Are We There Yet? [01:10:04] byRich Hickey (2009)
• SOLID Object-Oriented Design [00:47:11] bySandi Metz (2009)

• The Salami Method for Cross Platform Development [01:00:16] byAdi Shavit (2018)

• Four Distributed Systems Architectural Patterns [00:50:00] byTim Berglund (2017)
• Mastering Chaos - A Netflix Guide to Microservice [00:53:13] byJosh Evans (2017)

• 12-Factor Apps and the HashiStack [00:30:39] byKelsey Hightower (2016)
• Kill "Microservices" before its too late [00:39:41] byChad Fowler (2016)
• Runtime scheduling: theory and reality [00:42:11] byEben Freeman (2016)

• The Power Of UNIX [00:30:03] byDan North (2015)

• Keeping a System Running Forever [00:28:06] byFred Hebert (2014)
• Speed & Scale: How to get there [01:04:51] byAdrian Cockcroft (2014)

• Narcissistic Design [00:37:14] byStuart Halloway (2013)

• Scalability at YouTube [00:38:43] byMike Solomon (long intro; starts at 9:12 minutes in) (2012)

• Backtracking Generators for Random Testing [01:03:30] byBenjamin Pierce (2020) [A]

• How to Stop Hating Your Tests [00:43:38] byJustin Searls (2015)

• Testing the Hard Stuff and Staying Sane [00:47:16] byJohn Hughes (2014)

• Category Theory for the Working Hacker [00:50:51] byPhilip Wadler (2016)

• A Lever for the Mind [00:38:54] byTom Stuart (2015)
• Impossible Programs [00:50:06] byTom Stuart (2015)

• Papers We Love: An Axiomatic Basis for Computer Programming [01:04:32] byJean Yang (2014)

• Lambda Calculus Then and Now [00:30:08] byDana S. Scott (2013)

• Church's Coincidences [01:03:41] byPhilip Wadler (2012)
• Programming the Turing Machine [01:06:10] byBarbara Liskov (2012)
• Turing and the Riemann zeta function [01:06:54] byAndrew Odlyzko (2012)

• Type Theory and its Meaning Explanations [00:52:23] byJon Sterling (2015)

• Papers We Love: On the Meanings of the Logical Constants and the Justifications of the Logical Laws [01:24:37] byJoseph Abrahamson (2014)
• Papers We Love: The Derivative of a Regular Type is its Type of One-Hole Contexts [01:06:25] byErik Hinton (2014)

• Designing GNOME Mobile Apps [00:35:48] byTobias Bernard (2019) [slides]

• Data Driven UIs, Incrementally [00:36:17] byYaron Minsky (2018)

• Choosing Features [00:23:52] byKevin Lynagh (2017)

• Practical UI physics [00:34:12] byDavid DeSandro (2015)
• We Will All Be Game Programmers [00:29:34] byHunter Loftis (2015)

• User Interface (UX) Techniques [00:51:20] byJanne Jul Jensen (2013)

• Accessibility Myths & Solutions [00:28:53] byTea Ho (2018)

• Implementing and Using GraphQL at GitHub [00:38:55] byKyle Daigle & Dan Schafer (2016)

• How I learned to Code by Making 180 websites in 180 days [00:22:03] byJennifer De Walt (2015)
• How NOT to Measure Latency [00:42:59] byGil Tene (2015)
• The Website Obesity Crisis [00:53:19] byMaciej Ceglowski (2015)
• Upgrading the Web [00:41:19] byDouglas Crockford (2015)

• Delivering the goods [00:23:25] byPaul Irish (2014)
• Hacker Way: Rethinking Web App Development at Facebook [00:44:36] byTom Occhino, Jing Chen & Pete Hunt (it starts pretty slow and marketingy, but gets much better over time) (2014)
• Immutability: Putting The Dream Machine To Work [00:22:06] byDavid Nolen (2014)
• Life is Terrible: Let's Talk About the Web [00:32:07] byJames Mickens (2014)
• Parallax Performance [00:32:01] byPaul Irish (2014)
• React: RESTful UI Rendering [00:36:15] byPete Hunt (2014)
• The Birth & Death of JavaScript [00:28:44] byGary Bernhardt (2014)
• Unlock the next era of UI development with Polymer [00:41:31] byRob Dodson (2014)
• Virtual Machines, JavaScript and Assembler [00:25:57] byScott Hanselman (2014)

• An End to Negativity [00:27:26] byChris Williams (2013)
• C10M - Defending The Internet At Scale [00:47:53] byRobert Graham (2013)
• Community.js [00:21:40] byChris Williams (2013)
• Go To There and Back Again [00:49:06] byDouglas Crockford (2013)
• Hey Underscore, You're Doing It Wrong! [00:36:31] byBrian Lonsdorf (2013)
• React: Rethinking best practices [00:29:32] byPete Hunt (2013)

• HTML5 Boilerplate [01:04:20] byPaul Irish (2011)### Miscellaneous
• Preventing the Collapse of Civilization [01:02:41] byJonathan Blow (2019)
• Start With Just a Few Things [00:09:54] byMax Hallinan (2019)
• Improper Hierarchy [00:34:26] byTom Murphy VII. (2018)
• It’s super effective! Solving Pokemon Blue with a single, huge regular expression [00:13:57] byAlex Clemmer (2018)
• Let’s Program a Banjo Grammar [00:35:54] byRyan Herr (2018)
• Soul from Scratch: Designing a More Portable Organ [00:37:59] byPeter Teichman (2018)
• I Don’t Have Time For This [00:31:22] byAaron Patterson (2017)
• RailsConf 2017: Keynote [00:50:31] byAaron Patterson (2017)
• Mob Programming A Whole Team Approach [00:37:25] byWoody Zuill (2017)
• LIGO: The Dawn of Gravitational Wave Astronomy [00:56:17] byJameson Rollins (2016)
• Juggling Patterns and Programs [00:48:50] bySteve Miner (2016)
• African Polyphony & Polyrhythm [00:41:49] byChris Ford (2016)
• A Brief History of Time [00:45:17] byFred Hebert (2016)
• Complexity and the Art of the Left Turn [00:52:05] byK Lars Lohn (2016)
• A Programmer’s Guide To Western Music [00:42:13] byAndrew Sorensen (2015)
• Kolmogorov music [00:42:05] byCristopher Ford (2015)
• Well I Wouldn't Want To Make a *Dys*functional Game [00:18:17] byMorgan Mullaney (2015) [A]
• You Suck at Excel [00:54:00] byJoel Spolsky (2015)
• Stop Treading Water: Learning to Learn [00:40:58] byEdward Kmett (2014)
• Madam Sandi Tells Your Future [00:38:13] bySandi Metz (2014)
• Software Development Lessons from the Apollo Program [00:29:59] byJulian Simioni (2014)
• States and Nomads: Handling Software Complexity [00:29:54] byZach Tellman (2015)
• Clojure: Programming with Hand Tools [00:58:38] byTim Ewald (2014)
• How To Shut Down Tolkien [00:42:41] byBrandon Rhodes (2014)
• Linux Sucks - 2014 [00:44:59] byBryan Lunduke (2014) [A]
• To the Moon! [00:52:43] byRuss Olsen (2013)
• DjangoCon EU 2013 Keynote [00:31:10] byBrandon Rhodes (2013)
• It's not what you read, it's what you ignore [01:01:52] byScott Hanselman (2012)
• WAT [00:04:17] byGary Bernhardt (2012)
• Linus Torvalds on git [01:10:15] byLinus Torvalds (2007) [A]

Generally, a lot of talks are welcome on this list. The topic does not matter too much-itshould 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) and
• 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).
• All subsections are sorted descending by year (newest first), then alphabetically by title within each year. For example, an entry with(2020) should be above one with(2015) regardless of title; entries sharing a year stay in their existing relative order unless you are also alphabetising a tie.
  • Separate distinct year groups with<br>\n (<br> followed by an empty line).