2021

2020

2019

2021

  • Steve Jobs (1992) Speaking to MIT School of Management students. MIT Sloan Distinguished Speaker Series watch

  • Douglas Crockford (2018) The Power of the Paradigm. Amsterdam JSNation 2018 Conf watch

  • Douglas Crockford (2009ish) Long form educational presentation on JavaScript. watch ~4hrs

  • Douglas Crockford (2017) The Post JavaScript Apocalypse. ConFoo Developer Conf watch

  • Mark Allen (2014) All of this has happened before, and it will all happen again. Strange Loop watch

  • Liam Randall and Ralph Squillace (2021) Cloud Native and WebAssembly: Better Together. KubeCon and CloudNativeCon watch

  • Douglas Crockford (2009) JavaScript: The Good Parts. Google TechTalks watch

  • Lin Clark (2021) WASI: A new kind of system interface and what it means for cloud native. KubeCon and CloudNativeCon watch

  • Bridget Kromhout, Taylor Thomas and Brian Ketelsen (2020) WebAssembly, Krustlet, and the Future. Arrested DevOps watch

  • Bridget Kromhout, Alice Goldfuss and Ian Coldwater (2020) Tea and Anarchy. Arrested DevOps watch

  • Bjarne Däcker (2019) Concurrency before Erlang. Code Mesh LDN watch

  • Bjarne Däcker (2019) How Erlang got its name. Code Sync watch

  • Bryan Cantrill (2015) Towards a Containerized Future. Container Camp LDN watch

  • Bryan Cantrill (2015) The Rise of Containers and the Future of App Development. SIGNAL watch

  • Bryan Fink (2016) Less Ado About NTP. Systems We Love watch

  • James Larkby-Lahet (2016) Persistent Virtual Memory in the Great New Operating System in the Sky. Systems We Love watch

  • Jesse Hathaway (2016) The Design of the UNIX Terminal. Systems We Love watch

  • Dave Chinner (2014) Linux Filesystems: Where did they come from? linux.conf.au watch

  • Troy Benjegerdes (2017) Open Source Hardware: Hacking Silicon for Fun instead of Profit. Systems We Love watch

  • Chris Nuernberger (2021) High Performance Data. London Clojurians watch

  • Ivan Richwalski (2017) Metadata Indexes and Queries in the BeOS Filesystem. Systems We Love watch

  • Stuart Halloway (2011) Radical Simplicity. London Clojure User Group watch

  • Rich Hickey (2021) A History of Clojure. HOPL IV watch

  • Laura Abbott and Rick Altherr (2021) Breaking TrustZone M: Privilege Escalation on LPC55S69. DEFCON watch

  • Jeremy Tanner, Mark Coleman and Bryan Cantrill (2021) Discussion: Why Hardware Matters. Equinix Developers watch

  • Ron Pressler (2021) Project Loom: Modern Scalable Concurrency for the Java Platform. Philly ETE Conf watch

  • Todd Montgomery (2021) Modern (In)Efficiencies: Performance on Modern Hardware. Philly ETE Conf watch

  • Dr. Nicole Forsgren (2021) The SPACE of Developer Productivity: There’s More To It Than You Think. Philly ETE Conf watch

  • David Nolen (2021) ClojureScript in the Age of TypeScript. Philly ETE Conf watch

  • Eric Schrock and Adam Leventhal (2013) Solaris Family Reunion. Joyent watch

  • Ross Smith, Scott Sellers, Gary Tarolli and Gordon Campbell (2013) 3dfx Oral History Panel. Computer History Museum watch

  • Bryan Cantrill (2019) RFD 164 Open Source Policy. Joyent Technical Discussion watch

  • Bryan Cantrill (2015) Triton: Docker and the Future of Containers in Production. Container Camp watch

  • Katharina Fey (2018) Embedding Rust in C/C++. RustConf watch

  • Brandon W. Maister (2018) No Spaghetti: Designing for Understanding. RustConf watch

  • Bryan Cantrill (2015) Debugging LX branded zones on SmartOS. Joyent watch

  • Jessie Frazelle (2018) Breaking Containers: Chaos Engineering and Kubernetes. Chaos Conf watch

  • Bryan Cantrill (2017) That’s when gnuplot carried me. Joyent Engineering Meetup watch

  • Juan Pedro Bolívar Puente (2019) Postmodern immutable data structures. Cpp on Sea watch

  • Peter Marshall (2018) Orinoco: The new V8 Garbage Collector. Node Conf EU watch

  • Benno Rice (2019) How Much Do You Trust That Package? Understanding the Software Supply Chain. linux.conf.au watch

  • Benno Rice (2018) You Can’t Unit Test C, Right? linux.conf.au watch

  • Philip Paeps (2020) The ZFS Filesystem. linux.conf.au watch

  • Benno Rice (2020) What UNIX Cost Us. linux.conf.au watch

  • Richard Barry (2018) Amazon FreeRTOS: IoT Operating System for Microcontrollers. AWS re:Invent watch

  • Josh Wilsdon and Bryan Cantrill (2012) SmartOS Diskless Boot. Joyent watch

  • Peter Alvaro (2018) Three Things I Wish I Knew When I Started Designing Languages. QCon San Francisco watch

  • Irene Zhang (2021) The Demikernel and the Future of Kernel-Bypass Systems. Papers We Love watch

  • Sebastian Roll (2019) From circuit board design to finshed product: the hobbyist’s guide to hardware manufacturing. NDC TechTown watch

  • José Manuel Calderón Trilla (2019) What About the Natural Numbers? Papers We Love page watch

  • Shriram Krishnamurthi (2019) On the Expressive Power of Programming Languages. Papers We Love watch

  • Bryan Cantrill and Konstantin Gredeskoul (2021) Open Source Licensing. fossa.com watch ~75mins

  • Alexander Mohr and Jess Frazelle (2017) Building for Trust: How to Secure Your Kubernetes Cluster. watch ~38mins

  • Jess Frazelle (2016) Containers and Dockercon. watch ~33mins

  • Jess Frazelle (2017) Security in a Containerized World. devopsdays Minneapolis watch

  • Bryan Liles, Jess Frazelle, and Andrew Clay Shafer (2017) devopsdays Minneapolis discussion panel watch

  • Jess Frazelle (2018) Keynote: Containers aka crazy user space fun. watch

  • Jess Frazelle (2016) Blurry Lines GitHub Universe watch

  • Jess Frazelle (2016) Application Sandboxes vs Containers. watch

  • Ryan Zezeski (2019) Roger’s /proc Systems We Love watch

  • Jess Frazelle (2019) A Tale of Two Papers. Papers We Love watch

  • Jess Frazelle (2018) Benefits of isolation provided by containers. O’Reilly Security Conf watch

  • Jess Frazelle et al (2019) Panel discussion: Who needs serverless? Scale by the Bay watch

  • Jess Frazelle (2019) Why Open Source Firmware is Important. DevOpsDays Chicago watch

  • Jess Frazelle and Dino Dai Zovi (2017) The role of open source in a company. O’Reilly Velocity Conf watch

  • Jess Frazelle (2016) The future of container security. Cloud Native watch

  • Jess Frazelle and Brandon Philips (2017) Dance Madly on the Lip of a Volcano. Cloud Native Computing Foundation watch

  • Jess Frazelle and Andrew Clay Shafer (2019) Shiny Objects: informal interview. Arrested Devops watch

  • Jess Frazelle (2015) Willy Wonka of Containers. Container Camp watch

  • Jess Frazelle (2017) SCONE: Secure Linux Containers with Intel SGX. Papers We Love watch

  • Adam Leventhal (2016) A brief history of syscalls. Sysdig Summit watch

  • Bryan Cantrill (2011) Solaris Family Reunion. watch

  • Jess Frazelle (2017) Internals of the Go Linker. watch

  • Jerry Jelinek (2012) Enhanced OS Virtualization for the Cloud. illumos Day watch

  • Bryan Cantrill (2018) Statemaps in Rust. watch

  • Marshall Kirk McKusick (2011) A Narrative History of BSD. Linux.conf.au watch

  • Bryan Cantrill (2014) The Dream is Alive! Running Linux containers on an illumos kernel. illumos Day watch

  • Bryan Cantrill (2007) DTrace Review. Google Tech Talks watch

  • Matt Ahrens (2017) RAIDZ Expansion. OpenZFS watch ~35mins

  • Kirk McKusick (2015) ZFS Internals Overview. OpenZFS watch

  • Adam Leventhal (2016) Understanding Performance with DTrace (While the Customer Yells at You): A Case Study. Philly ETE watch

  • Evan Chan (2019) Rust and Scala, Sitting in a Tree. Scale by the Bay watch

  • Allan Jude (2015) Interesting things you didn’t know you could do with ZFS. vBSDcon watch

  • Patrick Mooney (2015) LX Branded Zones. illumos Day, Surge watch ~30mins

  • Julian Squires (2017) Implementations of Timing Wheels. Systems We Love watch

  • Deirdré Straughan (2009) Owls at Sun’s Broomfield Campus. watch

  • Robert Mustacchi (2017) The Soft Ring Cycle. Joyent watch

  • Bridget Kromhout, Jess Frazelle and Ben Hughes (2016) Discussion: Exciting Topics like Containers and Security. Arrested DevOps watch

  • Caitie McCaffrey (2017) Distributed Sagas: A Protocol for Coordinating Microservices. J on the Beach watch

  • Bryan Cantrill (2018) Rust and other Interesting Things. Scale by the Bay watch

  • Bryan Cantrill (2013) Bringing the Unix Philosophy to Big Data. FutureStack, New Relic watch

  • Brendan Gregg (2009) DTrace Tutorial. Kernel Conf Australia, Brisbane watch

  • Jeff Bonwick and Bill Moore (2009) ZFS: The Next Word. Kernel Conf Australia, Brisbane watch

  • Ben Rockwood (2009) ZFS in the Trenches. LISA watch

  • Bryan Cantrill (2009) Keynote: Visualizing DTrace: Sun Storage 7000 Analytics. LISA watch

  • Adam Leventhal (2012) DTrace: the Performance Tuner’s Swiss Army Knife. watch

  • Adam Leventhal and Dave Pacheco (2020) Contract as Code as Contract: Using Rust to Unify Specification and Implementation. OpenAPI Initiative watch ~25mins

  • Manu Drijvers (2017) One TPM to Bind Them All: Fixing TPM2.0 for Provable Secure Anonymous Attestation. IEEE Symposium on Security and Privacy watch

  • Bryan Cantrill (2014) Manta at Joyent. Data Council watch ~91mins

  • Robert Virding (2015) Implementing Languages on the BEAM. London Erlang User Group watch ~108mins

  • Bryan Cantrill (2015) Leaping the chasm from proprietary to open: A survivor’s guide. OSCON watch ~43mins

  • Matthew Garrett (2020) TPM based attestation - how can we use it for good? linux.conf.au watch

  • Matt Ahrens and George Wilson (2018) OpenZFS Basics. OpenZFS watch

  • Steven Rostedt (2019) See what your computer is doing with Ftrace utilities. OpenZFS watch

  • Bryan Cantrill (2018) Is it time to rewrite the operating system in Rust? QCon San Francisco watch ~70mins

  • Julie Pitt, Marius Eriksen, Rúnar Bjarnason, Bryan Cantrill, Cliff Click, Martin Odersky et al (2018) Panel Discussion: Thoughtful Software Engineering. Scale By the Bay watch ~46mins

  • Bryan Cantrill (2019) Scale by the Bay Interview. watch ~6mins

  • Bryan Cantrill (2012) Hallway interview on Software Perfection. MIT Technology Review watch ~1min

  • Bryan Cantrill (2011) Instrumenting the real-time web: Node.js, DTrace and the Robinson Projection. Velocity watch ~47mins

  • Matthew Garrett (2019) Firmware security, why it matters and how you can have it. linux.conf.au watch ~45mins

  • Jeff Bonwick (2015) The Birth of ZFS. OpenZFS watch ~19mins

  • Jordan Hendricks (2019) NVMe Hotplug Walk-Through. Joyent watch

  • Bryan Cantrill (2011) Experiences Porting KVM to SmartOS. KVM Forum Vancouver watch ~41mins

  • Ben Rockwood (2012) SmartOS: An SA Primer. BayLISA meetup watch

  • Bill Pijewski (2012) SmartOS ZFS Architecture. BayLISA meetup watch

  • Robert Mustacchi (2012) Using SmartOS as a Hypervisor. SCALE 10x watch one, two

  • Patrick Mooney (2019) Technical Discussion: Oh Bhyve! Joyent watch

  • Mike Gerdts (2019) Technical Discussion: Moar Bhyve. Joyent watch

  • Bryan Cantrill (2012) Introduction to SmartOS. BayLISA meetup watch ~11mins

  • Bryan Cantrill (2020) Soul of a New Machine: Rethinking the Server-Side Computer. Stanford Seminar watch ~86mins

  • Sam Gwydir (2018) The History and Future of Core Dumps in FreeBSD. vBSDcon watch ~33mins

  • Peter Grehan (2020) FreeBSD bhyve intro. linux.conf.au watch

  • Michael Dexter (2012) The BHyVe Hypervisor in Depth. EuroBSDcon watch ~38mins

  • Bryan Cantrill (2013) Leadership Without Management: Scaling Organizations by Scaling Engineers or Software Engineering Middle Management: Toxin or Cancer? Surge watch ~64mins

  • Bryan Cantrill (2019) (Anti-)Application Video for YC120. watch ~4mins

  • Patrick Mooney (2017) On wings of exec(2). Systems We Love watch ~12mins

  • Sam Gwydir (2018) bhyve zones in SmartOS. bhyveCon Tokyo watch ~11mins

  • Jacob Loveless and Bryan Cantrill (2020) Edgemesh Performance Talks. watch ~68mins

  • Ben Sigelman and Bryan Cantrill (2020) Conversation around Sun, DTrace, and Shouting in the Data Center. Lightstep watch ~49mins

  • Aaron Patterson (2021) Keynote: RailsConf. watch

  • Jeff Bonwick and Bill Moore (2008) ZFS: The Last Word in File Systems. SNIA Software Developers Conf watch

  • Vitaly Gordon, Helena Edelson, Omar Alonso, Bryan Cantrill and Gene Linetsky (2020) Panel Discussion: Will AI Kill Programming? Scale by the Bay watch ~55mins

  • Bridget Kromhout and Bryan Cantrill (2016) Fireside Chat. Arrested DevOps watch ~75mins

  • Bridget Kromhout, Andrew Clay Shafer and Bryan Cantrill (2017) Panel Discussion: Old Geeks Yell at Cloud. GOTO Conf, Chicago watch ~53mins

  • Cody Mello (2018) Technical Discussion: Introduction to AWK. Joyent watch

  • Bryan Cantrill (2020) Tockilator: Deducing Tock Execution Flow from Verilator Traces. Oxidize 1k watch ~12mins

  • Jason Hoffman and Bryan Cantrill (2012) CTO vs VP Engineering: What’s the Difference? RedMonk watch ~43mins

  • Bryan Cantrill (2019) Was he Wright All Along? Software After Moore’s Law. Scale by the Bay watch ~33mins

  • Bryan Cantrill (2017) Debugging Under Fire: Keeping your head when systems have lost their mind. GOTO Chicago watch ~53mins

  • Bryan Cantrill (2015) Run containers on bare metal already: Stop killing kittens and melting the ice caps. Velocity NYC watch ~41mins

  • Bryan Cantrill (2018) Post-Hype Microservices. Lightstep watch ~21mins

  • Bryan Cantrill (2017) ARC: A Self-Tuning, Low Overhead Replacement Cache. Papers We Love watch ~108mins

  • Bryan Cantrill (2015) A Crime Against Common Sense. Surge watch ~21mins

  • Bryan Cantrill (2012) System III heritage, odd commands. Surge watch ~14mins

  • Bryan Cantrill (2016) Down Memory Lane: Two Decades with the Slab Allocator. Systems We Love watch ~24mins

  • Bryan Cantrill and Dave Pacheco (2012) Dynamic Languages in Production: Progress and Open Challenges. GOTO Aarhus watch ~61mins

  • Bryan Cantrill (2021) Hardware/Software Co-design: The Coming Golden Age. RailsConf watch ~62mins

  • Bryan Cantrill (2018) The Hurricane’s Butterfly: Debugging Pathologically Performing Systems. Jane Street watch ~67mins

  • Allan Jude, Kris Moore, Bryan Cantrill (2017) The Cantrillogy Interviews. BSDNow watch ~4hrs

  • Bryan Cantrill (2019) No Moore Left to Give: Enterprise Computing After Moore’s Law. QCon New York watch ~41mins

  • Dave Pacheco (2015) MDB: Now More Than Ever. illumos Day, Surge watch ~50mins

  • Bryan Cantrill (2016) Oral tradition in software engineering: Passing the craft across generations. Monktoberfest watch ~48mins

  • Bryan Cantrill (2017) Principles of Technology Leadership. Monktoberfest watch ~51mins

  • Bryan Cantrill (2018) The Summer of Rust. Systems We Run Meetup watch ~90mins

  • Bryan Cantrill (2013) tail -fml. Surge watch ~17mins

  • Bryan Cantrill (2016) Jails and Solaris Zones. Papers We Love watch ~106mins

  • Slava Pestov and John McCall (2017) Implementing Swift Generics. LLVM Developers Meeting watch

  • Bryan Cantrill and Jess Frazelle (2017) Fireside Chat: Reflections on Systems We Love. watch ~60mins

  • Bryan Cantrill (2019) Andreessen’s Corollary: Ethical Dilemmas in Software Engineering. Craft Conf watch ~46mins

  • Bryan Cantrill (2017) Zebras all the way down: The engineering challenges of the data path. Uptime watch ~47mins

  • Jess Frazelle (2018) Container Hacks and Fun Images. DockerCon watch ~39mins

  • Jess Frazelle (2019) Why Open Source Firmware is Important. GOTO Chicago watch ~32mins

  • Jess Frazelle (2019) Introduction to RISC-V. dotGo Paris watch ~17mins

  • Bryan Cantrill (2011) Fork Yeah! The Rise and Development of illumos. LISA USENIX watch ~64mins

  • Victor Ciura (2018) Enough string_view to Hang Ourselves. CppCon watch

  • John Farrier (2015) Demystifying Floating Point. CppCon watch

  • Craig Andera and Russ Olsen (2021) Podcast Interview. watch

  • Craig Andera and Mike Fikes (2021) Podcast Interview. watch

  • Patricia Aas (2018) Software Vulnerabilities in C and C++. CppCon watch

  • Arthur O’Dwyer (2015) Lambdas from First Principles: A Whirlwind Tour of C++. CppCon watch

  • Arthur O’Dwyer (2017) dynamic cast from scratch. CppCon watch

  • Louis Dionne (2017) Runtime Polymorphism: Back to the Basics. CppCon watch

  • John McCall (2018) Coroutine Representations and ABIs in LLVM. LLVM Developers Meeting watch

  • Ian Coldwater and Kat Cosgrove (2021) We Didn’t Start the Fire: Communication Breakdowns and How to Prevent Them. Cloud Native Computing Foundation watch

  • Arthur O’Dwyer (2018) An Allocator is a Handle to a Heap. CppCon watch

  • John Bandela (2019) Polymorphism != Virtual: Easy, Flexible Runtime Polymorphism Without Inheritance. CppCon watch

  • Joe Bialek and Shayne Hiet-Block (2019) Killing Uninitialized Memory: Protecting the OS Without Destroying Performance. CppCon watch

  • Fei-Fei Li, Justin Johnson and Serena Yeung (2017) Stanford University

    • Lecture 1: Convolutional Neural Networks for Visual Recognition. watch

    • Lecture 5: Convolutional Neural Networks. watch

    • Lecture 10: Recurrent Neural Networks. watch

    • Lecture 11: Detection and Segmentation. watch

  • Sreenivas Bhattiprolu (2019) Image Segmentation using U-Net. watch

  • Daniil Pakhomov (2017) Fully Convolutional Networks for Image Segmentation. SciPy Austin watch

  • Rainer Grimm (2020) Back to Basics: Smart Pointers. CppCon watch

  • Katie Moussouris (2013) The Five Stages of Vulnerability Response Grief. RSA Conf watch ~7mins

  • Peter Maymounkov (2021) Go Circuit: Distributing the Go Language and Runtime. Strange Loop Conf watch

  • Bodil Stokke (2013) BODOL, or How to Accidentally Build Your Own Language. Strange Loop Conf watch

  • Paul McKenney (2014) C++ Memory Model Meets High-Update-Rate Data Structures. CppCon watch

  • Mikey Muhanna and Ramsey Nasser (2021) Conversations around his projects, incl. the Qalb/قلب Programming Language. watch

  • Kate Gregory (2015) Stop Teaching C. CppCon watch

  • Barbara Geller and Ansel Sermersheim (2015) CopperSpice: A Pure C++ GUI Library. CppCon watch

  • Barbara Geller and Ansel Sermersheim (2020) Back to Basics: Lambda Expressions. CppCon watch

  • Colleen Macklin, Nick Fox-Gieg and Ramsey Nasser (2020) Discussion: Cloud Salon. watch

  • Ramsey Nasser (2016) Push Pull ++. Papers We Love watch

  • Daniel Gregoire (2013) Gershwin: Stack-based, Concatenative Clojure. Strange Loop Conf watch

  • Maxime Chevalier-Boisvert (2013) Fast and Dynamic. Strange Loop Conf watch

  • Jack Moffitt (2013) Servo: Designing and Implementing a Parallel Browser. Strange Loop Conf watch

  • Dann Toliver (2013) Daimio: A Language for Sharing. Strange Loop Conf watch

  • Jay McCarthy (2013) Continuations on the Web and in your OS. Strange Loop Conf watch

  • Casey Muratori (2018) The Thirty-Million Line Problem. watch

  • Brandon Benvie (2013) Continuum: A JS (ES6) VM Written in JS (ES3). Strange Loop Conf watch

  • Parisa Tabriz (2013) Chrome Security Secret Sauce. Strange Loop Conf watch

  • Heather Miller (2013) Spores: Distributable Functions in Scala. Strange Loop Conf watch

  • Eugene Burmako (2013) Philosophy of Scala macros. Strange Loop Conf watch

  • Craig Muth (2013) Xiki: GUI and Text Interfaces are Converging. Strange Loop Conf watch

  • Alon Zakai (2013) Native Speed on the Web: JavaScript and asm.js. Strange Loop Conf watch

  • Arthur O’Dwyer (2019) Back to Basics: RAII and the Rule of Zero. CppCon watch

  • Hans Boehm (2016) Using Weakly Ordered C++ Atomics Correctly. CppCon watch

  • Arthur O’Dwyer (2019) Back to Basics: Type Erasure. CppCon watch

  • Arthur O’Dwyer (2019) Back to Basics: Lambdas from Scratch. CppCon watch

  • Andrea Crotti (2014) Metaprogramming, from decorators to macros. EuroPython watch

  • David Beazley (2013) Python 3 Metaprogramming. PyCon watch

  • Andreas Rumpf (2013) Nimrod: A new approach to meta programming. Strange Loop Conf watch

  • Chris Granger (2013) Finding a Way Out. Strange Loop Conf watch

  • Clayton Bauman (2013) Babel: An Untyped, Stack-based HLL. Strange Loop Conf watch

  • William Cook (2013) Enso: Composing DSL Interpreters, Languages and Aspects. Strange Loop Conf watch

  • Ansel Sermersheim (2017) Multithreading is the answer: What is the question? CppCon watch

  • Arthur O’Dwyer (2020) Back to Basics: Concurrency. CppCon watch

  • Michael Wong (2015) C++ 11/14/17 atomics and memory model. CppCon watch

  • JF Bastien (2016) No Sane Compiler Would Optimize Atomics. CppCon watch

  • JF Bastien (2019) Deprecating volatile. CppCon watch

  • Cliff Click, Cameron Purdy, Matt Dziubinski, Teodor Dimov, Aaron Goldman, Yorick Peterse et al (2021) Coffee Compiler Club.

  • Martin Odersky (2013) The Trouble with Types. Strange Loop Conf watch

  • Herb Sutter (2016) Leak-Freedom in C++ by Default. CppCon watch

  • Cliff Click (2020) Tales from the Frontlines: Startup War Stories. watch

  • Martin Kleppmann (2014) Turning the database inside out with Apache Samza. Strange Loop Conf watch

  • Mike Fikes (2021) Discussion: The ClojureScript Compiler. watch ~3.5hrs

  • Ramsey Nasser (2021) What’s So Hard About Writing A Compiler, Anyway? Oh. London Clojurians watch

  • Nicolai Josuttis (2018) The Nightmare of Initialization in C++. CppCon watch

  • Timur Doumler (2016) Want fast C++? Know your hardware! CppCon watch

  • Andrei Alexandrescu (2018) Expect the expected. CppCon watch

  • Timur Doumler (2019) Type punning in modern C++. CppCon watch

  • Chandler Carruth (2016) High Performance Code 201: Hybrid Data Structures. CppCon watch

  • Allan Deutsch (2017) Esoteric Data Structures and Where to Find Them. CppCon watch

  • Malte Skarupke (2018) You Can Do Better Than std::Unordered_Map: New and Recent Improvements to Hash Tables. CppNow watch

  • Matt Kulukundis (2019) Abseil’s Open Source Hashtables: 2 Years in. CppCon watch

  • David Nolen (2013) Everything I Have Learned I Have Learned From Someone Else. Strange Loop Conf watch

  • Isabella Muerte (2019) The Symbiotic Relationship of C++ and Rust. Rust Conf watch

  • Juan Pedro Bolívar Puente (2018) The Most Valuable Values. CppCon watch

  • Jeff Dileo (2019) Evil eBPF: Practical Abuses of In-Kernel Bytecode Runtime. Def Con Conf watch

  • Mohit Thatte (2015) What Lies Beneath: A Deep Dive into Clojure’s data structures. EuroClojure Barcelona watch

  • Juan Pedro Bolívar Puente (2017) Postmodern immutable data structures. CppCon watch

  • Sameer Ajmani, Brad Fitzpatrick, Andrew Gerrand, Robert Griesemer, Rob Pike, David Symonds, Nigel Tao and Ian Lance Taylor (2013) Go Fireside Chat. Google I/O watch

  • Phil Nash (2017) The Holy Grail!? A Persistent Hash-Array-Mapped Trie for C++. CppNow watch

  • Phil Nash (2017) The Holy Grail! A Persistent Hash-Array-Mapped Trie for C++. CppCon watch

  • Aaron Goldman (2017) Ideal Hash Trees. Papers We Love watch ~20mins

  • Phil Bagwell (2013) Striving to Make Things Simple and Fast. Clojure Conj watch

  • Christiaan Pretorius (2016) Cache Optimized Hash Tables. CppCon watch

  • Rich Hickey (2012) Writing Datomic in Clojure. GOTO Copenhagen infoq.com — watch

  • Alex Gaynor (2013) Why Ruby Isn’t Slow. Strange Loop watch

  • Martha Girdler (2013) The JavaScript Interpreter, Interpreted. Strange Loop watch

  • Chiu-Ki Chan (2013) Bust the Android Fragmentation Myth. Strange Loop watch

  • Renzo Borgatti (2013) Dissecting Clojure Reducers. Strange Loop watch

  • Limin Fu (2013) Dao Programming Language for Scripting and Computing. Strange Loop watch

  • Brian Kernighan and Lex Fridman (2020) Discussion: UNIX, C, AWK, and Go. watch

  • Chandler Carruth (2017) Going Nowhere Faster. CppCon watch

  • Kate Gregory (2018) Simplicity: Not Just for Beginners. CppCon watch

  • Gerald Sussman (2011) We Really Don’t Know How to Compute. Strange Loop watch

  • Lindsey Kuper (2020) Lecture 2: Distributed Systems, what and why? UC Santa Cruz watch

  • Brian Kernighan and John Mashey (2017) Oral History. Computer History Museum watch

  • Jim Gray (2003) Distributed Computing Economics. Computer History Museum watch ~2hrs

  • Daira Hopwood (2013) Noether: Symmetry in Programming Language Design. Strange Loop watch

  • Alissa Pajer (2013) Category Theory: An Abstraction for Anything. Strange Loop watch

  • Philipp Haller (2013) Simplifying Asynchronous Code with Scala Async. Strange Loop watch

  • Miles Sabin and Edwin Brady (2013) Scala vs Idris: Dependent Types, Now and in the Future. Strange Loop watch

  • Catherine Havasi and Rob Speer (2013) How does text become data? Strange Loop watch

  • Vyacheslav Egorov (2013) Building an Optimising Compiler for Dart. Strange Loop watch

  • Matthew Graham (2013) Qbrt Bytecode: Interface Between Code and Execution. Strange Loop watch

  • Ben Johnson (2013) Raft: The Understandable Distributed Protocol. Strange Loop watch

  • Chris Martens (2013) Linear Logic Programming. Strange Loop watch

  • Zach Allaun (2013) Functional Vectors, Maps and Sets in Julia. Strange Loop watch

  • Tracy Harms (2013) The J Programming Language. Strange Loop watch

  • Gary Fredericks (2013) Swearjure. Strange Loop watch

  • Lars Bak (2012) Pushing the Limits of Web Browsers. Strange Loop watch

  • Stuart Halloway (2012) Evident Code, at Scale. Clojure/West watch

  • Andrei Alexandrescu, Joe Pamer, Allen Wirfs-Brock, Gerald Sussman, Jeremy Ashkenas and Rich Hickey (2011) Language Panel Discussion. Strange Loop watch

  • Brian Kernighan (2019) Plays Well With Others: The little languages of Unix. Unix50 watch

  • Bjarne Stroustrup (2017) Learning and Teaching Modern C++. CppCon watch

  • Scott Vokes (2013) zip code: Unpacking Data Compression. Strange Loop watch

  • Andrew Gerrand, Brad Fitzpatrick, Rob Pike, Ken Thompson, Robert Griesemer and David Symonds (2012) Meet the Go Team. Google I/O watch

  • Joe Armstrong (2013) Systems that run forever, self-heal and scale. Lambda Jam watch

  • Andrei Alexandrescu (2019) Speed is Found in the Minds of People. CppCon watch

  • Bjarne Stroustrup (2019) C++20: C++ at 40. CppCon watch

  • Marc Gregoire (2020) C++20: An (Almost) Complete Overview. CppCon watch

  • Niko Matzakis (2017) Rust: Hack Without Fear. CppNow watch

  • Shaun Lebron (2017) Inspiring a Future Clojure Editor with Forgotten Lisp UX. Clojure Conj watch

  • Rich Hickey (2017) Effective Programs: 10 Years of Clojure. Clojure Conj watch

  • Rich Hickey (2012) Clojure for Java Programmers. NYC Java Study Group part1, part2 ~3hrs

  • Rich Hickey (2012) The Language of the System. Clojure Conj watch

  • Brian Kernighan (2009) Elements of Programming Style. Princeton Institute for Advanced Study watch

  • Brian Kernighan and Ken Thompson (2019) Interview. Vintage Computer Federation watch

  • Linus Torvalds (2012) Discussion with Students. Aalto University watch

  • Greg Law (2016) GDB: A Lot More Than You Knew. CppCon watch

  • Simon Brand (2018) How C++ Debuggers Work. CppCon watch

  • Kate Gregory (2018) What Do We Mean When We Say Nothing At All? CppCon watch

  • Chandler Carruth (2017) Going Nowhere Faster. CppCon watch

  • Chandler Carruth, Jon Masters, Matt Miller and Matt Godbolt (2018) Panel on Spectre. CppCon watch

  • Chandler Carruth (2018) Spectre: Secrets, Side-Channels, Sandboxes and Security. CppCon watch

  • Bjarne Stroustrup (2018) Concepts: The Future of Generic Programming. CppCon watch

  • Rich Hickey (2018) Maybe Not. Clojure Conj watch

  • Bjarne Stroustrup (1994) The Design of C++. Computer History Museum watch

  • Cliff Click (2019) The Azul Hardware Transactional Memory Experience. Hydra watch

  • Guido van Rossum (2018) Python 3 retrospective. PyCascades watch

  • Guido van Rossum and Hansen Hsu (2018) Oral History. Computer History Museum part1, part2 ~5hrs

  • Dan Ingalls, Hansen Hsu and David C. Brock (2018) Smalltalk Demonstration on the Xerox Alto. Computer History Museum watch ~2hrs

  • Dan Ingalls (1989) Object-Oriented Programming. Computer History Museum watch

  • Bjarne Stroustrup and Paul McJones (2015) Oral History. Computer History Museum watch ~2hrs

  • Stoyan Nikolov (2018) OOP is dead, long live Data-oriented design. CppCon watch

  • Scott Wlaschin (2014) Functional Design Patterns. NDC watch

  • Joe Armstrong and Sam Aaron (2017) Distributed Jamming with Sonic Pi and Erlang. Erlang User Conf watch

  • Rob Martin (2016) Teaching functional programming to n00bs in mobs. lambda days watch

  • Joe Armstrong and Marko Gargenta (2013) Breaking Open: Erlang. Marakana, InfoQ watch

  • David Sankel (2020) Monoids, Monads and Applicative Functors: Repeated Software Patterns. CppCon watch

  • Alan Talbot (2018) Moving Faster: Everyday efficiency in modern C++. CppCon watch

  • Matt Godbolt (2018) The Bits Between the Bits: How We Get to main(). CppCon watch

  • Geoff Romer (2018) What do you mean "thread-safe"? CppCon watch

  • Scott Wlaschin (2019) The Functional Programmer’s Toolkit. NDC watch

  • Brian O’Sullivan (2013) Running a startup on Haskell. Strange Loop watch

  • Simon Peyton Jones (2017) The Haskell Journey. Churchill College watch

  • John Hughes (2016) Why Functional Programming Matters. Functional Conf watch

  • David Turner (2017) Some History of Functional Programming Languages. lambda days watch

  • Marshall Clow (2020) What is an ABI, and Why is Breaking it Bad? CppCon watch

  • Louis Dionne (2019) The C++ ABI from the Ground Up. CppCon watch

  • Michael Yuan (2021) High Performance Node.js Powered by Rust and WebAssembly. Open Source Summit watch

  • D. Richard Hipp (2017) SQLite’s use of Tcl. Tcl/Tk Conf watch

  • D. Richard Hipp (2015) A Database for the Edge of the Network. CMU Database Group watch

  • Martin Kleppmann and Diana Vasile (2016) End-to-end encryption: Behind the scenes. Strange Loop watch

  • Stu Halloway (2013) data.fressian Clojure Conj watch

  • Guy Royse (2021) Introduction to WebAssembly. Redis Labs watch

  • Martin Kleppmann (2020) CRDTs: The Hard Parts. Cambridge watch

  • JF Bastien and Dan Gohman (2015) WebAssembly: Here Be Dragons. LLVM Dev Meeting watch

  • Bjarne Däcker, Joe Armstrong, Mike Williams and Robert Virding (1990) Erlang: The Movie. Ericsson watch

  • Joe Armstrong (2013) 26 Years with Erlang or How I Got My Grey Hairs. Chicago Erlang Factory watch

  • Rich Hickey (2010) Hammock Driven Development. Clojure Conj watch

  • Robert Virding (2014) Implementing Languages on the BEAM. London Erlang User Group watch

  • Alex Miller, Gerald Sussman, Julie Sussman and Chris Hanson (2021) Interview. Strange Loop watch

  • Jane Walerud, Mike Williams, Joe Armstrong, Robert Virding and Garrett Smith (2016) Fireside Chat. Stockholm Erlang User Conf watch

  • Bryan Cantrill (2012) Corporate Open Source Anti-patterns. Liferay Symposium watch

  • Joe Armstrong (2016) How we program multicores. SICS Software Week watch

  • Matt Adereth (2015) Programming Hand Tools. Clojure Conj watch

  • John Gustafson (2017) Beyond Floating Point: Next Generation Computer Arithmetic. Stanford Seminar watch ~90mins

  • Rob Pike (2010) Another Go at Language Design. Stanford watch

  • Rob Pike (2012) Concurrency is not Parallelism. Heroku Waza watch

  • D. Richard Hipp (2015) SQLite: The Database at the Edge of the Network. Skookum watch

  • D. Richard Hipp (2008) How SQL Database Engines Work. OpenSQL Camp watch

  • D. Richard Hipp (2014) SQLite as an Application File Format. SouthEast LinuxFest watch

  • D. Richard Hipp (2006) An Introduction to SQLite. Google TechTalks watch

  • Robert Virding (2016) Pilgrim’s Progress to the Promised Land. Elixir.LDN watch

  • Alan Dipert (2021) Common Lisp for the Curious Clojurian. SciCloj watch ~2hrs

  • Garrett Smith (2014) Why the Cool Kids Don’t Use Erlang. Stockholm Erlang User Conf watch

  • Rich Hickey (2012) Deconstructing the Database. JaxConf watch

  • Joe Armstrong (2014) Modeling the World with Processes, Objects, Functions or Relations. Chicago Erlang watch

  • Duncan McGreggor, Robert Virding and Joe Armstrong (2013) Interview. Rackspace watch

  • Francesco Cesarini, Tony Hoare, Joe Armstrong and Carl Hewitt (2019) Concurrency Panel Discussion. Erlang Solutions watch

  • Joe Armstrong (2018) How to write fault-tolerant software. Studencki Festiwal Informatyczny watch

  • Joe Armstrong (2007) Interview. Software Engineering Radio se-radio.net, watch

  • Joe Armstrong (2016) Computing: The first 100 years. Full Stack Fest watch

  • Joe Armstrong (2013) The How and Why of Fitting Together. Erlang Factory Bay Area watch

  • Joe Armstrong (2018) Talk Concurrency Interview. Erlang Solutions watch

  • Rich Hickey (2012) Reducers. QCon New York watch

  • Rich Hickey (2012) Datomic. Java watch

  • Brian Beckman and Rich Hickey (2009) Expert to Expert: Inside Clojure. Channel 9 msdn.com watch

  • Rich Hickey (2008) Clojure for Lisp Programmers. Boston Lisp Meeting part1, part2 ~3hrs

  • Rich Hickey (2014) Inside Transducers. Clojure Conj watch

  • Rich Hickey (2014) Transducers. Strange Loop watch

  • David McNeil (2014) A core.async Debugging Toolkit. Strange Loop watch

  • David Nolen (2013) Clojure core.async for Asynchronous Programming. Data Council watch

  • Robert Virding (2013) Hitchhiker’s Tour of the BEAM. Erlang User Conf watch

  • Eric Normand, Mike Fikes and Mia (2021) Discussion. Apropos Clojure watch

  • Stu Halloway (2015) core.async: Concurrency without Callbacks. Philly ETE watch, infoq.com

  • Rich Hickey (2013) Clojure core.async. Strange Loop infoq.com, watch

  • Rich Hickey (2014) Clojure core.async Channels. QCon San Francisco infoq.com, watch

  • Rich Hickey (2013) The Functional Database. QCon New York infoq.com, watch

  • Rich Hickey (2013) Design, Composition, and Performance. Philly ETE & QCon San Francisco Aug infoq.com, Nov infoq.com, watch

  • Julian Gamble (2014) Paradigms of core.async. Clojure Conj watch

  • Igor Murashkin (2017) Introduction to the Java Memory Model. Google TechTalks watch

  • Rafael Winterhalter (2015) The Java Memory Model for Practitioners. CON1521 watch

  • Timothy Baldridge (2014) Core.Async Channel Internals. watch

  • Timothy Baldridge (2013) Core.Async Clojure Conj watch

  • Timothy Baldridge (2017) Core.Async in Use. Clojure/West watch

  • Douglas Hawkins (2018) A Visual Introduction to the Inner Workings of the JVM. Devoxx watch

  • David Buck (2019) Java Bytecode Crash Course. watch

  • Chris Bailey (2015) How to Write Memory-Efficient Java Code. IBM watch

  • Colin Hemmings (2017) Why We Chose Erlang over Java, Scala, Go and C. QCon London watch

  • Colt McAnlis (2015) Android Performance Patterns: Garbage Collection. Google Devs watch ~5mins

  • Thomas O’Rourke and Michał Olczak (2020) Taking Elixir Live at a Bank. ElixirConf EU watch

  • Joe Armstrong and Jeremy Ruston (2018) Intertwingling the Tiddlywiki with Erlang. Code Mesh LDN watch

  • Mike Williams, Joe Armstrong and Robert Virding (2013) Over a Century of Programming. Erlang User Conf watch

  • Robert Virding (2016) On Language Design. lambda days watch

2020

  • Rui Ueyama (2017) lld: A Fast, Simple and Portable Linker. LLVM Dev Meeting watch

  • Garrett Smith (2017) Building a Web App in Erlang, Yes You Heard Me Right I Said Erlang, not Elixir. Erlang Factory San Francisco watch

  • Rich Hickey (2009) Persistent Data Structures and Managed References. QCon London infoq.com, watch

  • Alina Sbirlea and Nuno Lopes (2018) Pointers, Alias and ModRef Analyses. Euro LLVM Dev Meeting watch

  • Yury Selivanov (2017) async/await and asyncio in Python 3.6 and beyond. PyCon Portland watch

  • Eric Christopher and Johannes Doerfert (2019) Intro to LLVM. LLVM Dev Meeting watch

  • Lang Hames and Breckin Loggins (2018) Updating ORC for Concurrency. LLVM Dev Meeting watch

  • Louis Dionne (2020) Pushing Back Lit’s Boundaries to Test Libc++. LLVM Dev Meeting watch

  • Yuhan Guo (2019) Handling all Facebook requests with JITed C++ code. Euro LLVM Dev Meeting watch

  • JF Bastien (2019) Mitigating undefined behavior security mitigations through automatic variable initialization. LLVM Dev Meeting watch

  • Mandeep Singh Grang and Katherine Kjeer (2020) Checked C: Adding Memory Safety to LLVM. LLVM Dev Meeting watch

  • David Beazley (2016) Fear and Awaiting in Async: A Savage Journey to the Heart of the Coroutine Dream. PyOhio watch

  • Sumana Harihareswara (2016) HTTP Can Do That?! PyCon Portland watch

  • Jake Vanderplas (2016) Statistics for Hackers. PyCon Portland watch

  • James Bennett (2019) See CPython run: Getting to know your Python interpreter. North Bay Python watch

  • Allison Kaptur (2015) Bytes in the Machine: Inside the CPython interpreter. PyCon Montréal watch

  • Nina Zakharenko (2016) Memory Management in Python — The Basics. PyCon Portland watch

  • Larry Hastings (2016) Removing Python’s GIL: The Gilectomy. PyCon Portland watch

  • Brett Cannon (2013) From Source to Code: How CPython’s Compiler Works. PyCon Toronto watch

  • Larry Hastings (2012) Stepping Through CPython. PyCon Santa Clara watch

  • David Beazley (2010) Understanding the Python GIL. PyCon Atlanta watch

  • Larry Hastings (2015) Python’s Infamous GIL. PyCon Ireland watch

  • Tristan Brindle (2019) An Overview of Standard Ranges. CppCon watch

  • Bob Steagall (2018) Fancy Pointers for Fun and Profit. CppCon watch

  • Matthew Fleming (2019) The Smart Pointers I Wish I Had. CppCon watch

  • James Trunk (2020) Clojure in a Nutshell. Func Prog Sweden watch

  • Simon Brand (2018) How to Write Well-Behaved Value Wrappers. CppCon watch

  • Jonathan Beard (2017) Good FIFOs Make Good Thread Neighbors. CppNow watch

  • Emery Berger (2019) Mesh: Automatically Compacting Your C++ Application’s Memory. CppCon watch

  • Jonathan Boccara (2019) 10 Techniques to Understand Existing Code. CppCon watch

  • Michał Dominiak (2019) Memory Resources in a Heterogeneous World. CppCon watch

  • Andreas Weis (2019) Exceptions Demystified. CppNow watch

  • Malte Skarupke (2017) Sorting in less than O(n log n): Generalizing and optimizing radix sort. CppNow watch

  • Phil Nash and Simon Brand (2018) What Could Possibly Go Wrong? A Tale of Expectations and Exceptions. CppCon watch

  • Titus Winters and Hyrum Wright (2015) All Your Tests are Terrible: Tales from the Trenches. CppCon watch

  • Bernard Duggan (2012) Erlang in production: I wish I’d known that when I started. linux.conf.au watch

  • Kavya Joshi (2016) A Race Detector Unfurled. Systems We Love watch

  • Kavya Joshi (2016) A Tale of Concurrency through Creativity in Python: A Deep Dive into How gevent Works. PyCon Portland watch

  • Fedor Pikus (2015) The Unexceptional Exceptions. CppCon watch

  • Borzoo Bonakdarpour (2016) Model-based Code Generation and Debugging of Concurrent Programs. Microsoft Research watch

  • Will Wilson (2014) Deterministic Simulation Testing of Distributed Systems. Strange Loop watch

  • Shaz Qadeer (2016) Programming Devices and Services with P. Microsoft Research watch

  • Kevlin Henney (2020) Concurrent Affairs: Procedural Programming Unlocked. Code Sync watch

  • Gabbi Fisher (2019) Socket to Me: Where do Sockets Live in Go? GopherCon watch

  • Koushik Sen (2006) DART: Directed Automated Random Testing and Concolic Testing. Cornell watch

  • Peter Sewell (2016) Multiprocessor behaviour — what can’t you rely on? SICS Software Week watch

  • Burcu Kulahcioglu Ozkan (2018) Randomized Testing of Distributed Systems with Probabilistic Guarantees. SIGPLAN SPLASH watch

  • Fabio Falzoi (2019) An Insight into Go Garbage Collection. GoLab Conf watch

  • Patrick Hawley (2019) Controlling the Go Runtime. GopherCon watch

  • Tim Berglund (2017) Four Distributed System Architectural Patterns. Devoxx watch

  • Alastair Donaldson (2016) Concurrency Testing using Schedule Bounding: an Empirical Study. Microsoft Research watch

  • Fedor Pikus (2017) C++ atomics: from basic to advanced. CppCon watch

  • Herb Sutter (2012) atomic weapons: The C++11 Memory Model and Modern Hardware. C++ and Beyond watch ~3hrs

  • Roberto Aloi (2020) Boost your productivity with the Erlang Language Server. Code BEAM V watch

  • Jörgen Brandt (2018) Beyond state machines: services as petri nets. Code BEAM STO watch

  • Parker Selbert (2020) Hardening Applications with Property Tests. ElixirConf EU watch

  • Chris Bailey (2013) From Java Code to Java Heap: Understanding the Memory Usage of your Application. IBM watch

  • Joe Armstrong (2014) K things I know about building Resilient Reactive Systems. React London watch

  • Rich Hickey (2015) Clojure Made Simple. Cognitect watch

  • Pedro Ramalhete (2015) How to Make Your Data Structures Wait-Free for Reads. CppCon watch

  • David Delabassee, Maurizio Cimadamore and Jorn Vernee (2020) Project Panama: The Foreign Memory Access API. Java Podcast watch

  • Stephen Bussey (2020) Anatomy of a Real-Time Elixir App. ElixirConf EU watch

  • David Turner (2020) Open Sourcing Miranda. Code Mesh V watch

  • Paul Nauman (2015) Developers' Introduction to HotSpot Internals. JavaOne watch

  • Ron Pressler (2019) Lightweight Threads on the JVM. Java watch

  • Rich Hickey (2013) Datomic, a Functional DB. Data Council watch

  • Nikita Koval (2019) Lin-Check: Testing concurrent data structures in Java. Hydra watch

  • Jowanza Joseph (2019) Apache Pulsar and the Legacy of Telegraphy. Strange Loop watch

  • Tom Hall (2016) Unlimited Register Machines, Gödelization and Universality. Strange Loop watch

  • Dan Bornstein (2008) Dalvik VM Internals. Google I/O watch

  • Casey Rosenthal (2018) Deprecating Simplicity. GOTO Conf watch

  • Aleksey Shipilëv (2017) Shenandoah GC. Devoxx watch

  • Per Lidén (2018) ZGC: A Scalable Low-Latency Garbage Collector. CodeOne watch

  • Simone Bordet (2019) Concurrent Garbage Collectors: ZGC and Shenandoah. Voxxed Days watch

  • David Delabassee and Per Lidén (2020) The Z Garbage Collector. Inside Java Podcast watch

  • Chad Arimura and Ron Pressler (2020) Project Loom. Inside Java Podcast watch

  • JF Bastien (2016) No Sane Compiler Would Optimize Atomics. CppCon watch

  • JF Bastien (2018) Signed integers are two’s complement. CppCon watch

  • Jevgeni Kabanov (2013) Do you really get classloaders? Java watch

  • Dan Rosen (2015) Purely Functional Data Structures. Java watch

  • Johan Sommerfeld (2017) Python and Erlang: a match made in heaven. Erlang Meetup watch

  • Ron Pressler (2018) Project Loom: Fibers and Continuations for the JVM. NightHacking watch

  • Michael J. Steindorfer (2016) Immutable Collections. JVM Language Summit watch

  • Michael Wong, Paul E. McKenney and Maged Michael (2017) Is Parallel Programming still hard? CppCon part1, part2 ~2hrs

  • Daniel Spiewak (2013) Extreme Cleverness: Functional Data Structures in Scala. Clojure Conj watch

  • Monica Beckwith (2017) Garbage First GC. Devoxx watch

  • Cliff Click (2016) A Crash Course in Modern Hardware. Devoxx watch

  • Erik Duveblad (2017) The G1 GC in JDK 9. JavaOne watch

  • Ian Rogers (2011) JVM Internals: What does the JVM do? San Francisco Java User Group watch

  • David Delabassee, John Rose and Paul Sandoz (2020) The Vector API. Inside Java Podcast watch

  • Rich Hickey (2012) The Database as a Value. GOTO Chicago watch

  • Markus Völter (2018) Build your own Language: Why and How? GOTO Amsterdam watch

  • Joe Armstrong (2018) The Do’s and Don’ts of Error Handling. GOTO Chicago watch

  • Russ Olsen (2018) Functional Programming in 40 Minutes. GOTO Berlin watch

  • Jim Pivarski (2019) Jagged, ragged, awkward arrays! Strange Loop watch

  • Martin Kleppmann (2015) Transactions: myths, surprises and opportunities. Strange Loop watch

  • Oscar Boykin, Jillian Crossley, John A. De Goes, Stu Hood, Miles Sabin and Paul Snively (2019) Future of Functional Programming Panel. Scale by the Bay watch

  • James Gosling (2016) History of Java. London Java Community watch

  • James Gosling (2010) Apple, Apache, Google, Oracle and the Future of Java. Silicon Valley Java User Group watch

  • Shan Lu (2011) Fighting Concurrency Bugs. Microsoft Research watch

  • Kostis Sagonas (2016) Detecting Concurrency Errors using Systematic Testing. SICS Software Week watch

  • Martin Thompson (2017) Functional Performance. Functional Conf watch

  • Martin Thompson (2017) High Performance Managed Languages. J On The Beach watch

  • Juan Facorro (2020) Clojerl on the BEAM. BEAM Meetup GMT watch

  • Stephen Dewhurst (2020) Class Layout. CppCon watch

  • Sanne Kalkman (2020) Who Takes Out Your Trash. Code BEAM watch

  • Martin Thompson (2014) Aeron: Open-source high-performance messaging. Strange Loop watch

  • Steve Vinoski (2016) A Peek Inside Erlang’s OTP. GOTO Chicago watch

  • Andy Walker (2020) Optimize for Time. QCon London watch

  • Martin Thompson (2019) Interaction Protocols: It’s All About Good Manners. GOTO Berlin watch

  • Joe Armstrong (2016) Computing: The first 100 years. Full Stack Fest watch

  • Stavros Aronis (2018) Conquering race conditions in Erlang programs with Concuerror. Functional Conf Bangalore watch

  • Robert Virding (2014) Implementing languages on the BEAM. Code Mesh London watch

  • Koushik Sen (2011) CONCURRIT: A Domain Specific Language for Testing Concurrent Programs. Microsoft Research watch

  • Joe Armstrong (2014) Faults, Scaling, and Erlang Concurrency. Stanford Seminar watch

  • Serdar Tasiran (2011) Location Pairs: A Test Coverage Metric for Shared Memory Concurrent Programs. Microsoft Research watch

  • Trisha Gee (2013) Concurrent Programming Using The Disruptor. Oracle Learning watch

  • Tamir Dresher (2017) Testing and Time and Concurrency with Rx.NET Schedulers. TestCon Moscow Conf watch

  • Pablo Halpern (2015) Work Stealing. CppCon watch

  • Dmitry Vyukov (2019) Go scheduler: Implementing language with lightweight concurrency. Hydra watch

  • Lukas Larsson (2014) Scheduling in the Erlang VM. Lambda Days watch

  • Nikita Koval (2019) Lin-Check: Testing concurrent data structures in Java. Hydra watch

  • Felix Petriconi (2020) Concurrent Code: Test It! How? code::dive conf watch

  • Martin Thompson (2015) Adventures with Concurrent Programming in Java: A Quest for Predictable Latency. Code Mesh London watch

  • Joe Armstrong and Larry Wall (2017) Welcome Inside the Head of Larry Wall. Erlang and Elixir Factory watch

  • Joe Armstrong (2017) Five Hobby Projects. Erlang and Elixir Factory watch

  • Jesse Anderson (2017) The ABCs of OTP. Erlang and Elixir Factory watch

  • Bengt Jonsson and Kostis Sagonas (2017) Testing and Verifying Concurrent Algorithms Using Stateless Model Checking. RISE watch

  • Joe Armstrong (2014) The Mess We’re In. Strange Loop watch

  • Erik Stenman (2014) VM Tuning, Know Your Engine: The Scheduler. Erlang Factory watch

  • Kostis Sagonas (2014) On the Scalability of the Erlang Virtual Machine and ETS. Erlang Solutions watch

  • Lukas Larsson (2014) Understanding the Erlang Scheduler. Erlang Solutions watch

  • Boshan Sun (2019) Understanding Erlang Kernel. Code BEAM watch

  • Jakob Foerster (2016) Learning to Communicate with Deep Multi-Agent Reinforcement Learning. SICS Software Week watch

  • Leif Jonsson (2017) Fast, Parallel and Correct Latent Dirichlet Allocation. RISE watch

  • Osa Gaius (2018) Why Elixir Matters. ElixirDaze watch

  • Vlad Mihalcea (2019) Transactions and Concurrency Control Patterns. Voxxed Days Bucharest watch

  • Hillel Wayne (2017) Tackling Concurrency Bugs with TLA+. Strange Loop watch

  • Joe Armstrong and Alan Kay (2016) Interview. Code Mesh London watch

  • Murali Krishna Ramanathan (2015) Multithreaded Test Synthesis. Google TechTalks watch

  • Michael Walker and Colin Runciman (2015) Déjà Fu: A Concurrency Testing Library for Haskell. ICFP watch

  • Xinhao Yuan (2020) Effective Concurrency Testing for Distributed Systems. ASPLOS watch

  • Kavya Joshi (2016) go test -race: Under the Hood. Strange Loop watch

  • Scott Hanselman (2020) Stack/Heap Allocation, Frames, Call Stacks, Recursion. watch

  • Suvam Mukherjee (2020) Learning-Based Controlled Concurrency Testing. OOPSLA watch

  • Adrián Mugnolo (2017) OTP, Concurrency and Testing Strategies. Montreal Elixir watch

  • Brendan Gregg (2019) Extended BPF: A New Type of Software. Ubuntu Masters Conf watch

  • Thomas Graf (2020) eBPF: Rethinking the Linux Kernel. QCon London watch

  • Max Rottenkolber (2020) RaptorJIT: a fast, dynamic systems programming language. FOSDEM watch

  • Michiel Borkent (2020) Babashka and GraalVM: taking Clojure to new places. Clojure/nyc watch

  • Mateusz Pusz (2020) A Physical Units Library for the Next C++. CppCon watch

  • Saša Jurić (2019) The Soul of Erlang and Elixir. GOTO Chicago watch

  • Brian Goetz (2019) FP vs OO: Choose Two. Jfokus watch

  • David Olsen (2020) Move Semantics. CppCon watch

  • Cliff Click (2018) A War of Words: Self-Awareness for Introverts. GeeCON watch

  • Cliff Click (2016) Everything Your Mother Should Know About Compilers. Devoxx Belgium watch

  • Lucas Cavalcanti (2020) How we test at Nubank. Clojure/nyc watch

  • Stuart Halloway (2016) Agility and Robustness: Clojure spec. Strange Loop watch

  • Jody Hagins (2020) Template Metaprogramming: Type Traits. CppCon part1, part2

  • Ben Saks (2020) Pointers and Memory. CppCon watch

  • Christopher Meiklejohn (2019) Partisan: high performance large scale distributed Erlang. Code BEAM watch

  • Dmytro Lytovchenko (2019) ErlangRT, a BEAM VM reimplementation in Rust. Code BEAM watch

  • Alan Dipert (2012) Programming with Values in Clojure. Clojure/West infoq.com, watch

  • Bob Steagall (2020) The Structure of a Program. CppCon watch

  • Ben Deane and Kris Jusiak (2020) Just-in-Time Compilation: The Next Big Thing? CppCon watch

  • Stephen Dewhurst (2020) Class Layout. CppCon watch

  • Rainer Grimm (2020) 40 Years of Evolution from Functions to Coroutines. CppCon watch

  • Rich Hickey (2012) The Value of Values. JaxConf watch

  • David Vázquez (2018) Growing a Lisp Compiler. Amsterdam Lisp and Scheme Meetup watch

  • R. Matthew Emerson (2018) This Old Lisp. European Lisp Symposium watch

  • Alan Dipert (2020) JACL: JavaScript Assisted Common Lisp. European Lisp Symposium watch

  • Jan Moringen (2020) Eclector: The Extensible and Portable Common Lisp Reader. Online Lisp Meeting watch

  • Daniel Kochmański (2020) On ECL, the Embeddable Common Lisp. European Lisp Symposium watch

  • Marco Cusumano-Towner (2019) New Programming Constructs for Probabilistic AI. Strange Loop watch

  • Nicolai Josuttis (2020) The Hidden Secrets of Move Semantics. CppCon watch

  • Herb Sutter (2020) Empirically Measuring, and Reducing, C++'s Accidental Complexity. CppCon watch

  • JF Bastien (2020) Just-in-Time Compilation. CppCon watch

  • Stanislav Pankevich (2017) Mull meets Rust. LLVM Social Berlin watch

  • Gene Kranz (2013) Excerpts: Failure is Not an Option. Surge watch

  • Eric Torreborre (2018) What Haskell taught us when we were not looking! Voxxed Days Zürich watch

  • Michael Nygard (2014) Simulation Testing. Strange Loop watch

  • Eric Normand (2017) Testing Stateful and Concurrent Systems using test.check. Clojure/West watch

  • Andrea Leopardi (2018) Property-based Testing is a Mindset. ElixirConf EU watch

  • John Hughes (2019) Building on developers' intuitions to create effective property-based tests. Lambda Days watch

  • Craig Maloney (2017) Scheme, Guile and Racket: an Introduction. Michigan!/Usr/Group watch

  • Pete LePage and John McCutchan (2012) Native Client Acceleration Modules. Google Developers watch

  • Nick Bray (2012) Life of a Native Client Instruction. Google I/O watch

  • Tristan Brindle (2020) C++20 Ranges in Practice. CppCon watch

  • Mathieu Ropert (2020) Making Games Start Fast: A Story about Concurrency. CppCon watch

  • Max Arshinov (2020) Beyond LINQ: Using Expression Trees in .NET. NDC Oslo watch

  • Borislav Stanimirov (2020) No Touchy! A Case Study of Software Architecture with Immutable Objects. CppCon watch

  • Ajit Koti and Rashmi Shamprasad (2019) Pattern Matching at Scale Using Finite State Machines. Strange Loop watch

  • Larry Ogrodnek (2014) Building Analog Displays for Your Data. Strange Loop watch

  • Raphaël Gomès (2020) Boosting Python with Rust: The case of Mercurial. FOSDEM watch

  • Jimmy Angelakos (2020) The State of (Full) Text Search in PostgreSQL 12. FOSDEM watch

  • Patrice Roy (2020) The Surprising Costs of void() (and Other Not-Quite-Innocuous Evils) CppCon watch

  • Richard Feldman (2020) The Next Paradigm Shift in Programming. Philly ETE watch

  • Georgios Gousios (2020) FASTEN: Scaling static analysis to ecosystems. FOSDEM watch

  • Ilya Baryshnikov (2019) Progress of Rust and WASM. FOSDEM watch

  • Kyle Kingsbury (2014) Jepsen II: Linearizable Boogaloo. Strange Loop watch

  • Andreas Geffen Lundahl (2017) Generatively testing user interfaces. Dutch Clojure Days watch

  • Robert Krahn (2015) Programming Clojure, Smalltalk-style. Clojure/West watch

  • Scott Wlaschin (2014) Functional Design Patterns. NDC London watch

  • Sebastian Funk (2016) Why Functional Programming Doesn’t Matter. Jane Street watch

  • Eric Normand (2019) You Are in a Maze of Deeply Nested Maps, All Alike. IN/Clojure watch

  • Chinedu Francis Nwafili (2018) Percy: Isomorphic Web Apps with Rust and WebAssembly. Rust Belt Ann Arbor watch

  • Michał Marczyk (2015) Ctries in Clojure, or Concurrent Transients. EuroClojure Barcelona watch

  • Jan Stepien (2015) Generative Testing: Properties, State and Beyond. EuroClojure Barcelona watch

  • John Hughes (2014) Testing the Hard Stuff and Staying Sane. Clojure/West watch

  • Luca Palmieri (2019) Machine Learning is changing: is Rust the right tool for the job? RustLab Conf watch

  • Dave Liepman (2018) Maria: a beginner-friendly coding environment for Clojure. clojureD watch

  • Matt Might (2014) What is Static Analysis? Lambda Lounge Utah watch

  • Phil Nash (2020) OO Considered Harmful. CppCon watch

  • Anders Møller (2019) Static Program Analysis. PLISS watch

  • Sylvan Clebsch (2019) Starting with Semantics. PLISS watch

  • Richard Jones (2016) Building high performance, fully concurrent garbage collectors with confidence. Virtual Machine Summer School watch

  • Timur Doumler (2020) How C++20 Changes the Way We Write Code. CppCon watch

  • Steve Blackburn (2017) Micro Virtual Machines. PLISS watch

  • Nicholas Matsakis (2019) Things I Learned. PLISS watch

  • Jeff Bezanson (2017) Julia: Design and Implementation. PLISS watch

  • Ben Titzer (2016) A Little on V8 and WebAssembly. VMSS watch PLISS (2019) watch

  • Tony Hosking (2019) In Search of Verified On-The-Fly Concurrent Garbage Collection on Modern Processors. PLISS watch

  • John Hughes (2020) How to specify it! A guide to writing properties of pure functions. lambda days watch

  • Nicholas Matsakis (2019) Responsive Compilers. PLISS watch

  • Alastair Donaldson (2018) Metamorphic Testing for "Non-Testable" Systems. VF Conf watch

  • Mario Wolczko (2019) The Coming Persistence Apocalypse. PLISS watch

  • Richard Jones (2017) Building high performance, fully concurrent garbage collectors with confidence. PLISS watch

  • Alastair Donaldson (2017) Testing Language Implementations. PLISS watch

  • Nikhil Mungel and Shishir Das (2012) Using Ruby to Craft and Test Beautiful Command Line Applications. RubyConf India watch

  • Tobias Brandt (2017) You suck at shell scripting: building awesome command line tools in Python for fun and profit! PyCon South Africa watch

  • Dave Copeland (2011) Make awesome command line apps with Ruby. Ruby Midwest watch

  • Itoyanagi Sakura (2019) Technical Background of Interactive CLI of Ruby 2.7. RubyConf Nashville watch

  • Bob Dahlberg (2020) Communication Break Down: Coroutines. FOSDEM watch

  • Vladimir Keleshev (2012) Create Beautiful Command-Line Interfaces with Python. PyCon UK watch

  • Conrad Irwin (2013) REPL driven development with Pry. RubyConf Miami Beach watch

  • Dean Nasseri, Dave Kimura, Eric Berry and Catherine Meyers (2018) Fir: The Friendly Interactive Ruby REPL. Ruby Rogues devchat watch

  • Andreas Kupries (2015) The Cmdr Framework. Tcl Conf New Orleans watch

  • Josh Ge (2018) How to Make a Roguelike. Roguelike Celebration watch

  • George Brocklehurst (2015) Readline: Your Other Editor. VIM Meetup NYC watch

  • Mark Smith (2014) Writing Awesome Command-Line Programs in Python. EuroPython Berlin watch

  • Dzmitry Malyshau (2020) Building WebGPU with Rust. FOSDEM watch

  • Nahid Samsami and Jeff Dickey (2018) Designing a delightful command line interface. DevXCon San Francisco watch

  • Carolyn Van Slyck (2019) Designing Command-Line Tools People Love. FOSDEM watch

  • Thomas Dvornik (2019) Building an enterprise-grade CLI with oclif. Heroku watch

  • Amjith Ramanujam (2017) Awesome Command Line Tools. PyCon Portland watch

  • Sebastian Vetter (2016) Click: A Pleasure to Write, a Pleasure to Use. PyCon Portland watch

  • Michael Lynch (2019) Why Good Developers Write Bad Tests. PyTexas watch

  • Kevlin Henney (2019) The Forgotten Art of Structured Programming. Cpp on Sea watch

  • Todd Leonhardt and Kevin Van Brunt (2019) A Hands-On Guide to Building Interactive Command-Line Apps with cmd2. PyOhio watch

  • Frank Rehberger (2018) Rust — embedding WebAssembly for scripting. FOSDEM watch

  • Dave Forgac (2016) Let’s Make Better Command Line Applications. PyOhio watch

  • Jonathan Slenders (2017) prompt toolkit two years later. FOSDEM watch

  • Robert Aboukhalil (2019) Beyond the Browser with Serverless WebAssembly. WASM San Francisco watch ~90mins

  • Thomas Ballinger (2015) Terminal whispering. PyCon Montréal watch

  • Erik Meijer (2019) Gradient Descent: The Ultimate Optimizer. KotlinConf Copenhagen watch

  • Alex Miller (2017) clojure.spec: Expressing Data Constraints Without Types. Philly ETE infoq.com watch

  • Alex Miller (2017) Dependency Heaven. EuroClojure watch

  • Erik Meijer and Robert Griesemer (2012) Interview about Go. Lang.NEXT watch

  • Alex Chabot-Leclerc (2019) Numerical Computing with NumPy. SciPy watch

  • Nathaniel Smith (2017) Inside NumPy. Berkeley Data Science watch

  • Corentin Wallez and Ricardo Cabello (2019) Next-Generation 3D Graphics on the Web. Google I/O watch

  • Corentin Wallez (2019) WebGPU: Next-Generation 3D Graphics. DevFest Toulouse watch

  • Jon Lopez Garcia (2020) Pushing the limits of the Web with WebAssembly. FOSDEM watch

  • Tiark Rompf (2014) How Types can turn a SQL Interpreter into a SQL Compiler. Strange Loop watch

  • Andreas Gal (2016) Compiling the Web: Building a Just-in-Time Compiler for JavaScript. Microsoft Research watch

  • Roger Corman (2017) Corman Common Lisp and more. Bay Area Lisp and Scheme Meetup watch

  • Christian Schafmeister (2015) Clasp: Common Lisp using LLVM and C++ for Molecular Metaprogramming. Google TechTalks watch

  • Rich Hickey (2016) Spec-ulation. Clojure Conj watch

  • Stuart Halloway (2019) Sherlock Holmes, Consulting Developer. Clojure Conj watch

  • Hugo Duncan (2012) Debuggers for Clojure. Clojure Conj watch

  • Jessica Kerr (2015) Contracts and Clojure: The Best-Yet Compromise Between Types and Tests. Philly ETE watch

  • Rich Hickey (2018) Datomic Ions. Clojure/nyc watch ~105mins

  • Scott Wlaschin (2018) The Power of Composition. NDC London watch

  • Chris Granger (2015) Eve. Strange Loop watch

  • Caitie McCaffrey (2015) Building Scalable Stateful Services. Strange Loop watch

  • Peter Alvaro (2015) I see what you mean: What a tiny language can teach us about gigantic systems. Strange Loop watch

  • Michael Nygard (2018) Uncoupling. GOTO Amsterdam watch

  • Chris Matts (2018) Why Business Cases are Toxic. GOTO Amsterdam watch

  • Todd Montgomery (2018) Making it Count: Quality is NOT an Option. GOTO Chicago watch

  • Phillip Carter (2020) F# as a Better Python. NDC Oslo watch

  • Neal Gafter (2007) Closures for Java. Google TechTalks watch ~2hrs

  • Lynn Langit (2017) Serverless: reality or BS — notes from the trenches. NDC Oslo watch

  • Joe Armstrong (2018) The Forgotten Ideas in Computer Science. Code BEAM SF watch

  • Robert Virding (2014) Erlang Rationale. Elixir Conf Austin watch

  • Robert Virding and Mariano Guerra (2018) Implementing Languages on the BEAM. Code BEAM SF watch

  • Scott Wlaschin (2020) The lazy programmer’s guide to writing thousands of tests. NDC Porto watch

  • Udi Dahan (2017) Microservices and Rules Engines — a blast from the past. NDC Oslo watch

  • Steve Sanderson (2017) Web Apps Can’t Do That, can they? NDC Oslo watch

  • Douglas Crockford (2017) The Post JavaScript Apocalypse. NDC London watch

  • Håkan Silfvernagel (2020) Why you should consider WebAssembly in your next frontend project. NDC Oslo watch

  • Enrico Campidoglio (2020) How Effective Teams Use Git. NDC Oslo watch

  • Aditya Siram (2014) Shen: A Sufficiently Advanced Lisp. Strange Loop watch

  • Timothy Baldridge (2015) Pixie: A Lightweight Lisp with 'Magical' Powers. Strange Loop watch

  • Christopher Webber (2013) Hy: A Lisp that transforms itself into the Python AST. ChiPy watch

  • Brian Beckman (2012) Don’t Fear the Monad. MSDN Channel 9 watch

  • Eric Holk (2018) Schism: A Self-Hosting Scheme to WebAssembly Compiler. ICFP watch

  • Colin Eberhardt (2019) Build your own WebAssembly Compiler. QCon San Francisco watch WebAssembly SF watch

  • Ahmon Dancy (2015) Escape from the Heap: Low-Level Programming in Common Lisp. European Lisp Symposium watch

  • Elliott Stoneham (2014) Write your own Go compiler. FOSDEM watch

  • Evan Czaplicki (2018) The Hard Parts of Open Source. Strange Loop watch

  • Arthur Gleckler (2017) Visualizing Data Structures. Bay Area Lisp and Scheme Meetup watch

  • Andre Kuhlenschmidt (2018) An Efficient Compiler for the Gradually Typed Lambda Calculus. ICFP Scheme Workshop watch

  • Rich Hickey and Sebastian Meyen (2013) Hallway Interview. JAXConf London watch

  • Rich Hickey (2012) Clojure Concurrency. Western Mass. Dev Group watch ~2.5hrs

  • Dave Snowden (2019) Dealing with Unanticipated Needs. Metosin watch

  • Håkan Råberg (2019) The Design and Implementation of a Bitemporal DBMS. ClojuTRE watch

  • Aki Helin (2016) The Story of Sir Owl Lisp. ClojuTRE watch

  • Robert Strandh (2020) Creating a Common Lisp Implementation. Online Lisp Meeting part1, part2

  • Kristoffer Gronlund (2019) Let’s LISP like it’s 1959. linux.conf.au watch

  • Andy Keep (2020) The Nanopass Framework as a Nanopass Compiler. European Lisp Symposium watch

  • Joel Martin (2016) Make Your Own Lisp Interpreter in 10 Steps. LambdaConf watch

  • Simon Danisch (2019) Julia: a Compiler for the Future. Curry On London watch

  • Henry Widd (2019) Cross Platform DateTime Awesomeness. Clojure/north watch

  • Rich Hickey (2013) Keynote. Clojure Conj watch

  • Rafal Dittwald (2019) Solving Problems the Clojure Way. Clojure/north watch

  • Francisco Viramontes (2020) Literate Stream Processing. Clojure/north watch

  • Rich Hickey (2012) Simplicity Matters. Rails Conf Austin watch

  • Luke Wagner (2016) WebAssembly: A New Compiler Target for the Web. NYLUG watch

  • Dan Gohman (2019) WebAssembly Beyond the Browser. Wasm Workshop Berlin watch

  • Mike Voronov (2019) Fast, deterministic, and verifiable computations with WebAssembly. Wasm Workshop Berlin watch

  • Jack Fransham (2019) Lightbeam Wasm Compiler. Wasm Workshop Berlin watch

  • Jay Phelps (2017) WebAssembly Demystified. Jazoon Tech Days watch

  • Ben Smith (2019) Applied WebAssembly: Compiling and Running C++ in Your Web Browser. CppCon watch

  • Lin Clark (2019) Bringing WebAssembly outside the web with WASI. Full Stack Fest watch

  • Rich Hickey (2011) ClojureScript Release. NYC Clojure watch ~90mins

  • Emmanuel Antony (2020) WASM on Clojure. IN/Clojure watch

  • Daniel Persson (2018) WebAssembly with Java. watch

  • Steve Klabnik (2019) Rust, WebAssembly, and the future of Serverless. Full Stack Fest watch

  • Dan Gohman (2019) WebAssembly Beyond the Browser: WASI. WebAssembly SF watch

  • Dmitry Alexandrov (2019) WebAssembly for Java Developers. Voxxed Days Bucharest watch

  • Michael Kennedy and Michael Droettboom (2019) Python in WebAssembly with Pyodide. Talk Python To Me watch

  • Shaun Taylor-Morgan (2019) Python in the Browser. PyCon UK watch

  • Michael Droettboom (2019) Iodide and Pyodide: Bringing Data Science Computation to the Web Browser. PyData New York watch

  • Jonathan Beri (2020) Making it easier to make Things: WebAssembly and the Internet of Things. WebAssembly Summit watch

  • Lin Clark (2020) WebAssembly: Building a new kind of ecosystem. WebAssembly Summit watch

  • Brion Vibber (2020) WebAssembly as a video polyfill. WebAssembly Summit watch

  • Nikita Prokopov (2019) Building My Own Clojure Tools. Clojure/north watch

  • Kevlin Henney (2018) Old is the New New. GOTO Chicago watch

  • Fabrizio Ferrai (2019) Live-coding a Compiler: A Challenge. Heart of Clojure Belgium watch

  • Stuart Sierra (2014) Components: Just Enough Structure. Clojure/West watch

  • Timothy Baldridge (2014) Data All The ASTs. Clojure/West watch

  • Maria Geller (2015) The ClojureScript Compiler: A Look Behind the Curtains. Clojure Conj watch

  • Bruce Hauman (2015) Literate Interactive Coding: Devcards. Strange Loop watch

  • Stuart Halloway (2014) Clojure: Simple by Design. All Things Open watch

  • Judy Rees (2020) Handling "Difficult" Remote Conversations Like a Pro. QCon London watch

  • John Boyle (2016) Implementing a Regular Expression Engine. Bay Area Lisp and Scheme Meetup watch

  • Kevin Hoffman (2020) Building a Containerless Future with WebAssembly. WebAssembly Summit watch

  • James Cash (2020) Don’t Stop Now. Clojure/north watch

  • Rhishikesh Joshi (2020) Ants in My Chans. Clojure/north watch

  • Luke Meyers (2020) Monoids and Software Engineering. Clojure/north watch

  • Patrick Thomson (2019) Building Haskell Programs with Fused Effects. Strange Loop watch

  • Wilker Lúcio (2020) Evolving Code Through Accretion. Clojure/north watch

  • Xavier O’Neil (2020) Surfing with Clojure. Clojure/north watch

  • Kapil Reddy (2020) Building Reliable, Scalable Services with Clojure and Core.async. Clojure/north watch

  • Paulo Feodrippe (2020) TLA+ and Clojure, a Small Primer. Clojure/north watch

  • Ramsey Nasser (2020) The Language of the Language: Comparing my experiences of compiler construction in Clojure and F#. Clojure/north watch

  • Alexander Fertman (2020) Gluing Clojure Microservices. Clojure/north watch

  • Dann Toliver (2020) Software, but not as we know it. Clojure/north watch

  • Łukasz Korecki (2020) Duckula: Type Safe Backend Services with Clojure, HTTP and Avro. Clojure/north watch

  • Mike Fikes (2020) ClojureScript on Microcontrollers. Clojure/north watch

  • Dana Borinski (2020) Unleash the Power of the REPL. Clojure/north watch

  • Carin Meier (2020) Parens for Python. Clojure/north watch

  • Asaf Chelouche (2020) Introduction to Lambda Calculus. Clojure/north watch

  • Anton Volkov (2020) Kosmos: Experimental graphical development environment for Clojure. watch

  • Eric Normand, Mike Fikes and Mia (2020) Discussion. Apropos Clojure Jul 1 watch

  • Tadeu Zagallo (2020) JavaScriptCore’s new WebAssembly interpreter. WebAssembly Summit watch

  • Ashley Williams (2020) Why the Wasm Summit Website isn’t written in Wasm. WebAssembly Summit watch

  • Brian Goetz (2014) Lambdas in Java: A Peek under the hood. GOTO Aarhus watch

  • Charles Nutter (2015) The invokedynamic Instruction in 45 Minutes. Oracle Learning watch

  • Tobi Ajila (2017) Java 9 VarHandles: What you need to know. Devoxx Belgium watch

  • Charles Nutter (2018) Method Handles Everywhere! NightHacking watch

  • Travis Oliphant, Siu Kwan Lam and Mark Florisson (2013) Numba: A Dynamic Python compiler for Science. PyCon watch

  • Chris Houser (2015) Condition Systems in an Exceptional Language. Clojure Conj watch

  • Dmitry Petrov (2017) Common Lisp, good parts. Amsterdam Lisp and Scheme Meetup watch

  • Stefan Karpinski (2016) Julia: To Lisp or not to Lisp. European Lisp Symposium watch

  • Mark Sofroniou (2015) Faster Arbitrary Precision Computation of Elementary Functions. Wolfram Tech Conf watch

  • Phil Nash (2018) Modern C++ Testing with Catch2. CppCon watch

  • Niek Bouman (2018) Multi-Precision Arithmetic for Cryptology in C++ at Run-Time and at Compile-Time. CppCon watch

  • Felix von Leitner (2011) How to Implement Bignum Arithmetic. Chaos Communication Congress watch

  • Angus Lees (2015) Bootstrapping a new programming language. linux.conf.au watch

  • Ron Garret (2016) Elliptic Curve Cryptography: A very brief introduction. Bay Area Lisp and Scheme Meetup watch

  • Luther Johnson (2019) MakerLisp Machine: an eZ80 CPU card running bare-metal Lisp. Bay Area Lisp and Scheme Meetup watch

  • Andy Wingo (2016) Knit, Chisel, Hack: Building Programs in Guile Scheme. Strange Loop watch

  • Matthew Flatt (2018) Rebuilding Racket on Chez Scheme: An Experience Report. ICFP Scheme Workshop watch

  • Robert Smith (2017) Lisp at the Frontier of Computation. Bay Area Lisp and Scheme Meetup watch

  • Jonas Karlsson (2017) Tricks of an Efficient Embedded Lisp Interpreter. Bay Area Lisp and Scheme Meetup watch

  • Chad Fowler (2017) Growing Old. RubyConf New Orleans watch

  • Aaron Patterson (2017) Building a Compacting GC for MRI. RubyConf New Orleans watch

  • Aaron Patterson (2016) How are Method Calls Formed? BathRuby watch

  • Rich Hickey (2012) The Value of Values. GOTO Copenhagen infoq.com, watch

  • Rich Hickey (2009) Are We There Yet? JVM Language Summit infoq.com watch

  • Ścisław Dercz (2016) An unusual compiler for (pure, lexical) Lisp. Bay Area Lisp and Scheme Meetup watch

  • Mey Beisaron (2019) How I Supercharged Learning Clojure through Gamification. Dutch Clojure Days watch

  • Bozhidar Batsov (2019) nREPL Redux. Dutch Clojure Days watch

  • James Reeves (2017) Transparency through Data. Dutch Clojure Days watch

  • Craig Maloney (2017) Scheme, Guile and Racket: an Introduction. Michigan!/Usr/Group watch

  • Alan Shreve (2016) Idealized Commit Logs: Code Simplification via Program Slicing. Strange Loop watch

  • Sam Tobin-Hochstadt (2017) From Scheme to Typed Racket. ICFP Oxford watch

  • Dimitris Vyzovitis (2017) Gerbil on Gambit, as they say Racket on Chez. ICFP Oxford watch

  • Zach Tellman (2012) Playing Go with Clojure. Clojure Conj watch

  • Ramsey Nasser and Tims Gardner (2014) Arcadia: Functional Video Game Development. Code Mesh London watch

  • Ramsey Nasser and Tims Gardner (2014) Clojure in Unity3D: Functional Video Game Development. Strange Loop watch

  • Ramsey Nasser and Tims Gardner (2014) Arcadia: Integrating Clojure with Unity3D for Game Dev. NYC Clojure watch

  • Mark Engelberg (2017) Solving Problems Declaratively. Clojure/West watch

  • Ramsey Nasser (2017) Symbolic Assembly: Using Clojure to Meta-program Bytecode. Clojure/West watch

  • Tims Gardner and Ramsey Nasser (2015) Games and 3D Graphics in Arcadia. Clojure/West watch

  • Ramsey Nasser (2016) Symbolic Compilers: A New Hope. SoftwareGR watch

  • Ramsey Nasser (2019) Fn and Games with Arcadia. Clojure/north watch

  • Ramsey Nasser (2016) The Unfortunate Value of Failure. !!Con watch

  • Kovas Boguta (2015) Gamma: A simple model for WebGL. Strange Loop watch

  • Benjamin Kovach (2018) A Box of Chaos: The Generative Artist’s Toolkit. Strange Loop watch

  • Jimmy Bogard (2020) Continuous Integration and Delivery for Databases. NDC London watch

  • Enrico Campidoglio (2020) How Effective Teams use Git. NDC watch

  • Hana Dusíková (2019) Compile Time Regular Expressions. NDC TechTown watch

  • Ken Mugrage (2019) Modern Continuous Delivery. GOTO Berlin watch

  • Max Brunsfeld (2018) Tree-sitter: A new parsing system for programming tools. FOSDEM watch

  • Martin Kavalar (2019) Our Journey from Elm and Elixir to Clojure. clojureD watch

  • Jame King (2013) Hy: A Lisp that Compiles to Python. PyCon Toronto watch

  • Hans Hübner (2016) Is Clojure an Acceptable Lisp? clojureD watch

  • Ingo Mohr (2019) About the Unknown East of the Ancient LISP World. clojureD watch

  • Dan Callahan (2019) WebAssembly Beyond the Browser. GOTO Copenhagen watch

  • Alon Zakai (2020) Shipping Tiny WebAssembly Builds. WebAssembly Summit watch

  • Stuart Langridge (2019) You Really Don’t Need All That JavaScript, I Promise. GOTO Copenhagen watch

  • Stefan Tilkov (2019) "Good Enough" Architecture. GOTO Berlin watch

  • Sarah Drasner (2020) The Art of Code Comments. JSConf Hawaii watch

  • Tyler McMullen (2020) Lucet: Safe WebAssembly Outside the Browser. Code Mesh London watch

  • Ben Smith (2020) WebAssembly: Expanding the PIE. WebAssembly Summit watch

  • Aaron Patterson (2016) Methods of Memory Management in MRI. RubyConf Cincinnati watch

  • Nate Berkopec (2016) Halve Your Memory Usage with these 12 Weird Tricks. RubyConf Cincinnati watch

  • Kevin Deisz (2017) Compiling Ruby. RubyConf New Orleans watch

  • Ross McIlroy (2019) V8 Lite: Slimming Down JavaScript Memory. BlinkOn watch

  • Derek Slager (2017) Why Clojure? Clojure/West watch

  • Petr Viktorin (2018) Bytecodes and Stacks: A Look at CPython’s compiler and its Execution Model. PyCon Prague watch

  • Franziska Hinkelmann (2017) JavaScript Engines — how do they even? JSConf EU watch

  • Ross McIlroy (2016) Ignition: an Interpreter for V8. BlinkOn watch

  • Chris Seaton (2017) Understanding How Graal Works — a Java JIT Compiler Written in Java. JUG.ru watch

  • Ronald Garcia (2018) Gradual Typing. ICFP SIGPLAN watch

  • Peter Salomonsen (2020) WebAssembly Music. WebAssembly Summit watch

  • Pat Hickey (2019) Evolving WASI with Code Generation. WebAssembly SF watch

  • Nicola Mometto (2015) Immutable code analysis with tools.analyzer. Clojure eXchange watch

  • Maurício Eduardo Chicupo Szabo (2019) Blending the REPL, editor and source code. Clojure South watch

  • Rakhim Davletkaliyev (2019) What could a Clojure/LISP editor be like? Clojure Helsinki Meetup watch

  • Roman Liutikov (2019) ClojureScript and Type Inference. Clojure Day Kyiv watch

  • Erik Assum (2020) Writing Maintainable Clojure. clojureD watch

  • Jakub Dundalek (2020) Shell Scripting Made Simple with Clojure. clojureD watch

  • Dan Bunea (2020) Complexity in Code — Improving flow control with functional pipelines. clojureD watch

  • Paulus Esterhazy (2020) Angels Singing: Writing for Programmers. clojureD watch

  • Maria Geller (2020) Self-hosted ClojureScript: How to bootstrap a compiler? clojureD watch

  • Michiel Borkent (2020) Babashka and the Small Clojure Interpreter. clojureD watch

  • Bozhidar Batsov (2020) The Future of Clojure Tooling. IN/Clojure watch

  • Pratik Karki (2020) Light Table: The strange and wonderful saga of a pure Clojure editor. IN/Clojure watch

  • Ramsharan Gorur Jayaraman (2020) Lazy Seqs: Why are they so lazy? IN/Clojure watch

  • Sergey Kuksenko (2020) Does Java Need Inline Types? What Project Valhalla Can Bring to Java. QCon San Francisco watch

  • Dmitry Petrashko (2020) Sorbet: Why and How We Built a Typechecker for Ruby. QCon San Francisco watch

  • Stuart Halloway (2018) REBL. Clojure Conj watch

  • Andrew Blinn (2019) Fructure: A Structured Editing Engine in Racket. RacketCon watch

  • Christopher Chedeau (2017) JavaScript Code Formatting. React London watch

  • James Long (2017) A Prettier Printer. React Conf watch

  • Tom Stuart (2014) Smalltalk, Lisp, Bash: Three Interesting Languages. Barcelona Ruby Conf watch

  • Terrence Parr (2014) How to Build a Virtual Machine. SF Language Design and Implementation Meetup watch

  • Ariel Ortiz (2017) The Dawn of Lisp, or How to Write Eval and Apply in Clojure. Clojure Conj watch

  • Joel Martin (2016) Make Your Own Lisp Interpreter in 10 Incremental Steps. LambdaConf watch

  • John Austin (2019) RGB to XYZ: The Science and History of Color. Strange Loop watch

  • Rijnard van Tonder (2019) Parser Parser Combinators for Program Transformation. Strange Loop watch

  • Emily Shea (2019) Voice Driven Development: Who needs a keyboard anyway? Strange Loop watch

  • August Lilleaas (2018) Datomic: The Most Innovative DB You’ve Never Heard of. KotlinConf Amsterdam watch

  • Jay Parlar (2019) Finding bugs without running or even looking at code. Strange Loop watch

  • Jamie Jennings (2018) Rosie Pattern Language: Improving on 50-Year Old Regular Expression Technology. Strange Loop watch

  • Doug Hellmann (2016) How I built a power debugger out of the standard library and things I found on the internet. PyCon Portland watch

  • Yaron Minsky (2018) Data Driven UIs, Incrementally. Strange Loop watch

  • Max Brunsfeld (2018) Tree-sitter: A new parsing system for programming tools. Strange Loop watch

  • Kenneth Ormandy (2016) Syntax Highlight Everything. CSSConf.Asia watch

  • Tim Berglund (2017) Four Distributed Systems Architectural Patterns. Devoxx Poland watch

  • Harold Abelson and Gerald Jay Sussman (2019) SICP Lecture 10: Compilation. MIT OpenCourseWare watch

  • Dan Bailey (2011) Jet: A Language and Heterogeneous Compiler for Fluid Simulations. Euro LLVM Dev Meeting watch

  • Stuart Halloway (2015) Debugging with the Scientific Method. Clojure Conj watch

  • Erik Corry (2017) Building Your Own Compiler the Slightly Easier Way with LLVM. YOW! Conf watch

  • Chandler Carruth (2019) There Are No Zero-Cost Abstractions. CppCon watch

  • Oleg Grenrus (2019) Do you have a problem? Write a compiler! ClojuTRE watch

  • Spencer Schneidenbach (2020) Using Immutable Data Structures in C# and .NET. NDC London watch

  • Ellen Chisa (2019) Coding Without Complexity. QCon San Francisco watch

  • Kevlin Henney (2020) Lambda? You Keep Using that Letter. NDC London watch

  • David Renshaw (2014) Cap’n Proto and Rust: Type Systems for Sharing. Strange Loop watch

  • Amanda Laucher and Paul Snively (2014) Type Systems — The Good, Bad and Ugly. Strange Loop watch

  • Ghadi Shayban (2019) Clojure Futures. Java watch

  • Daniel Slutsky (2019) Clojure and R: a love story of two Lispy souls. ClojuTRE watch

  • Chris McCormick (2020) px3d: a browser based pixel 3D nano-engine in ClojureScript. linux.conf.au watch

  • Matthew Gilliard (2019) Clojure in a World of Containers. ReClojure London watch

  • Gary Fredericks (2018) What Are All These Class Files Even About? Clojure Conj watch

  • Chas Emerick (2012) What Sucks about Clojure and Why You’ll Love it Anyway. Clojure/West infoq.com watch

  • Daniel Szmulewicz (2020) When the learning stops. watch ~8mins

  • Steve Klabnik (2020) Rust, WebAssembly, and the future of Serverless. DevFest watch

  • Richard Campbell (2020) Building Trust in Teams. NDC London watch

  • Jeanine Adkisson (2015) Design and Prototype a Language in Clojure. Clojure/West watch

  • Phil Hofmann (2019) Reaching Beyond Traditional Boundaries with Clojure. GOTO Copenhagen watch

  • Bozhidar Batsov (2019) CIDER Distilled: A Common Foundation for Clojure Tooling. Clojure South watch

  • Maarten Truyens (2019) Innovation in an immutable industry: Clojure in Law. Heart of Clojure Belgium watch

  • Magnus Kvalevåg (2019) How to do Stateful Property Testing in Clojure. ClojuTRE watch

  • Alex Miller (2019) Lessons Learned. ClojuTRE watch

  • Bill Piel (2016) Becoming Omniscient with Sayid. Clojure Conj watch

  • Steve Sanderson (2020) Blazor: a new framework for browser-based .NET apps. NDC London watch

  • Martin Thompson (2019) Interaction Protocols in Software: It’s All About Good Manners. QCon London watch

  • Anna Herlihy (2019) Wrestling Python into LLVM Intermediate Representation. PyCon Israel watch

  • Mat Ryer (2019) How I Write HTTP Web Services after Eight Years. GopherCon watch

  • Maurice Naftalin and José Paumard (2019) How Java and Scala are Imitating Functional Languages. GOTO Copenhagen watch

  • Bryan Cantrill (2018) Visualizing Distributed Systems with Statemaps. CNCF watch

  • Elena Morozova (2019) How Uber Goes. GopherCon watch

  • Jason Keene (2019) Dynamic Instrumentation for Go. GopherCon watch

  • Todd Green (2018) Low Level Systems Programming in High Level Julia. JuliaCon watch

  • Matt Dziubinski (2015) Rcpp: Seamless R and C++ Integration. CppCon watch

  • Ola Bini (2008) JRuby: The power of Java and Ruby. Google TechTalks watch

  • Lin Clark (2019) WebAssembly nanoprocesses: making WebAssembly outside-the-browser secure by default. WebAssembly SF watch

  • Tyler McMullen (2019) Isolation without Containers. WebAssembly SF watch

  • Rafał Pocztarski (2020) JS, Node, Deno — WebAssembly WASM WASI. WarsawJS watch

  • Charles Nutter (2010) Expressive Languages for the JVM. Google TechTalks watch

  • Andy Wingo (2019) Guile 3: Faster programs via just-in-time compilation. FOSDEM watch

  • Andrew Bennett (2014) Creating, Coding and Compiling a Compiler with LLVM. /dev/world/2013 watch

  • Frej Drejhammar (2014) BEAMJIT: A Just-in-Time Compiling Runtime for Erlang. Erlang User Conf vimeo, watch

  • Paul Biggar (2009) Compiling and Optimizing Scripting Languages. Google TechTalks watch

  • Dirk Eddelbuettel and Romain Francois (2010) Integrating R with C++: Rcpp, RInside, and RProtobuf. Google TechTalks watch

  • Conal Elliott (2007) Tangible Functional Programming: A Modern Marriage of Usability and Composability. Google TechTalks watch

  • Miško Hevery (2008) The Clean Code Talks: Unit Testing. Google TechTalks watch

  • Gilad Bracha (2010) Newspeak: A Principled Dynamic Language. Google TechTalks watch

  • Andrei Alexandrescu (2010) Three Cool Things About D. Google TechTalks watch

  • Charles Nutter (2010) Mirah: an Expressive JVM Language. Google TechTalks watch

  • Gabe Zichermann (2010) Fun is the Future: Mastering Gamification. Google TechTalks watch

  • Thomas Wouters (2007) Advanced Python (or understanding Python) Google TechTalks watch

  • Tom Faulhaber (2012) Lisp, Functional Programming, and the State of Flow. Clojure Conj watch

  • Irina Shestak (2019) From Electron, to Wasm, to Rust (Aaand Back to Electron) RustConf watch

  • Erik Huelsmann (2013) Common Lisp Applications on the JVM. European Common Lisp Meeting watch

  • Per Bothner (2013) High-performance Scripting with Kawa. JavaOne watch

  • Jamie Brandon (2018) Julia as a platform for language development. JuliaCon watch

  • Adi Levin (2019) Using WebAssembly with WebGL for interactive 3D apps. Full Stack Tech Radar Day watch

  • Paul Tagliamonte (2013) Hy: Lisp in Python. Boston Python watch

  • Herb Sutter (2019) De-fragmenting C++: Making Exceptions and RTTI More Affordable and Usable. CppCon watch

  • Alan Kay (2012) Rethinking Design, Risk and Software. COFES watch

  • Shelley Vohr (2018) Asynchrony: Under the Hood. JSConf EU watch

  • Philip Roberts (2014) What the heck is the event loop anyway? JSConf EU watch

  • Rob Pike (2014) Opening Keynote. GopherCon watch

  • Dan Rubenstein (2019) Time, Clocks and the Ordering of Events in a Distributed System. Papers We Love watch

  • Benedek Gagyi (2018) WebAssembly as Cross-Platform Architecture. YGLF Kyiv watch

  • Milica Mihajlija (2019) WebAssembly: Binary in Plain English. WebCamp Zagreb watch

  • Noritada Shimizu (2017) WebAssembly: now web is a new compiler target architecture. FOSS Asia watch

  • Ed Charbeneau (2019) WebAssembly: Into the WASM’verse. Stir Trek watch

  • Parashuram Narasimhan (2012) IndexedDB. San Francisco HTML User Group watch

  • Gabbi Fisher (2019) WebAssembly: Bringing Go to the Browser and Beyond! WebAssembly SF watch

  • Derek Slager (2015) ClojureScript for Skeptics. Clojure Conj watch

  • Christian Johansen (2018) ClojureScript — It’s not just the language. NDC Oslo watch

  • David Nolan (2016) clojure.spec. React Vienna watch

  • Stuart Sierra (2017) Homoiconicity: It Is What It Is. Clojure Conj watch

  • Viral B. Shah and Shashi Gowda (2016) Julia: A Lisp for Fast Number Crunching. Functional Conf Bangalore watch

  • Axel Naumann (2012) Introducing cling, a C++ Interpreter Based on clang/LLVM. Google TechTalks watch

  • Ryan Dahl (2018) 10 Things I Regret About Node.js. JSConf EU watch

  • Jim Duey (2018) Typing a LISP. LambdaConf watch

  • Ludovic Courtès (2016) GNU Guix: The Functional GNU/Linux Distro That’s a Scheme Library. Scheme Workshop watch

  • Carl Friedrich Bolz (2016) PyPy’s Approach to Implementing Dynamic Languages Using a Tracing JIT Compiler. Microsoft Research watch

  • Stanley Seibert (2015) Accelerating Python with the Numba JIT Compiler. SciPy watch

  • Takashi Kokubun (2017) LLVM-based JIT compiler for MRI. RubyConf New Orleans watch

  • Arthur O’Dwyer (2019) Back to Basics: Smart Pointers. CppCon watch

  • Matthew Page (2019) How to JIT: Writing a Python JIT from scratch in pure Python. PyCon Cleveland watch

  • Antonio Cuni (2019) How to write a JIT compiler in 30 minutes. EuroPython Basel watch

  • Sven Sauleau (2019) WebAssembly: The Next Big Platform. WebAssembly Munich Meetup watch

  • Surma Surma and Deepti Gandluri (2019) WebAssembly for Web Developers. Google I/O watch

  • David Beazley (2019) Lambda Calculus from the Ground Up. PyCon Cleveland watch

  • Tom Greenaway (2019) Modern Web Game Development. Google I/O watch

  • Damien Buhl (2018) C++ Everywhere with WebAssembly. CppCon watch

  • Cédric Champeau (2016) Deep dive into the Groovy compiler. Greach Conf watch

  • Mike Fikes (2019) Expeditious Code via Inference. Clojure/north watch

  • Ben Saks (2019) Back to Basics: Understanding Value Categories. CppCon watch

  • Scott Wlaschin (2017) F# for C# programmers. NDC Oslo watch

  • Lin Clark (2019) WebAssembly Interface Types: Interoperate with All the Things! Mozilla Hacks watch

  • Miro Cupak (2017) Exploring Java 9 with REPL. JavaOne watch

  • Robert Field (2015) JShell: An Interactive Shell for the Java Platform. Devoxx Belgium watch

  • Stefan Behnel (2018) Cython to speed up your Python code. EuroPython Edinburgh watch

  • Caroline Tice (2011) Combining Embedded and Interactive Python in a Debugger: A Case Study. EuroPython watch

  • Rich Hickey (2012) The Language of the System. Clojure Exchange watch

  • Rich Hickey (2012) Interview. GOTO Copenhagen watch

  • Michael Kennedy and Anna Herlihy (2018) Compiling Python through PyLLVM and MongoDB for Data Scientists. Talk Python To Me watch

  • Anna Herlihy (2015) PyLLVM: A compiler from Python to LLVM-IR. PyGotham watch

  • David Beazley (2018) Reinventing the Parser Generator. PyCon Cleveland watch

  • Eduardo Julian (2017) The Lux Programming Language. Strange Loop watch

  • Veit Heller (2019) Carp — A Language for the 21st Century. Curry On London watch

  • Veit Heller (2018) Carp — A Language for the 21st Century. ClojuTRE watch

  • David Nolan (2015) The Front End Architecture Revolution. GOTO Chicago watch

  • David Nolan (2017) Idée Fixe. GOTO Chicago watch

  • David Nolan (2017) A Practical Functional Relational Architecture. Code Mesh London watch

  • Alex Zinenko, Mehdi Amini and Nicolas Vasilache (2019) Building a Compiler with MLIR. LLVM European Developers Meeting Brussels watch

  • Almar Klein (2018) Let’s embrace WebAssembly. EuroPython Edinburgh watch

  • Bryan Mills (2018) Rethinking Classical Concurrency Patterns. GopherCon watch

  • David Beazley (2018) Die Threads. EuroPython Edinburgh watch

  • Without Boats (2019) Zero-Cost Async IO. Rust Latam Montevideo watch

  • Mikhail Smal (2019) Write your own domain specific language with F#. NDC Oslo watch

  • Guy Royse (2019) An Introduction to WebAssembly. Devoxx Belgium watch

  • Tobi Ajila (2019) Welcome to LWorld: The current state of value types in Java. Devoxx Belgium watch

  • Ron Pressler (2019) Project Loom: Helping Write Concurrent Applications on the Java Platform. Devoxx Belgium watch

  • Steve Klabnik (2019) Rust’s Journey to Async/Await. QCon New York watch

  • Scott Hanselman (2014) Virtual Machines, JavaScript and Assembler. Fluent San Francisco watch

  • Hans Elias B. Josephsen (2019) Eir: Infrastructure for working with BEAM code. Code BEAM STO watch

  • Steve Sanderson (2018) Blazor, a new framework for browser-based .NET apps. NDC Minnesota watch

  • Scott Wlaschin (2016) Understanding parser combinators: a deep dive. NDC Oslo watch

  • Adam McCullough (2017) Greek Classics: Lambda Calculus for Beginners. LambdaConf watch

  • David Graunke (2016) An Introduction to Combinator Compilers and Graph Reduction Machines. Strange Loop watch

  • Joshua Bloch (2018) A Brief, Opinionated History of the API. QCon New York watch

  • Klaus Iglberger (2019) Back to Basics: Move Semantics. CppCon watch

  • Brianne Hillmer (2016) Just-in-Time Documentation: Employing Agile Methodology to Create Living Documentation. Write the Docs Portland watch

  • Brian Goetz (2019) Java Language Futures. Devoxx Belgium watch

  • Chris Lattner and Tatiana Shpeisman (2019) MLIR: Multi-Level Intermediate Representation Compiler Infrastructure. LLVM European Developers Meeting Brussels watch

  • Rob Ashton (2019) Purescript on the BEAM: Typed OTP for greatness. Code Mesh London watch

  • Mey Beisaron (2019) Back to the Future: How 80s Arcade Games Taught me Clojure. Devoxx Belgium watch

  • Jim Crossley (2012) REPL-Based Development with Immutant. Clojure Conj watch

  • Robert Virding (2015) Wherefore art thou LFE? ClojuTRE watch

  • Michael Gottesman (2019) Ownership SSA. LLVM Dev Meeting watch

  • Oskar Wickström (2018) Finite-state machines? Your compiler wants in! lambda days watch

  • Igor Kopestenski (2019) IoT Edge Computing with bare-metal Erlang. Code BEAM Amsterdam watch

  • Jacob Walker (2019) Understanding Allocations: the Stack and the Heap. GopherCon watch

  • Kay Hayen (2015) The Python Compiler. EuroPython Bilbao watch

  • Daniel Spiewak (2016) Functional Compilers: From CFG to EXE. Devoxx watch

  • Gijs Stuurman (2017) CREPL: Write and run ClojureScript code together. Dutch Clojure Days watch

  • Heather Miller (2015) Function-Passing Style: Typed, Distributed Functional Programming. ScalarConf watch

  • Chaitanya Koparkar (2018) Gibbon: A Compiler for Recursive Functions on mostly Serialized Data. ICFP St. Louis watch

  • Adam Chlipala (2015) Ur: An Optimizing Compiler for a Purely Functional Web Application Language. ICFP watch

  • Raúl Raja and Simon Vergauwen (2019) Arrow Meta: Enabling Functional Programming in the Kotlin Compiler. Lambda World watch

  • Roy Osherove (2019) Lies, Damned Lies, and Metrics. GOTO Copenhagen watch

  • Adam Tornhill (2019) Prioritizing Technical Debt as if Time and Money Mattered. GOTO Copenhagen watch

  • Ian Lance Taylor (2019) Generics in Go. GopherCon watch

  • Johan Brandhorst (2018) Get Going with WebAssembly. LondonGophers watch

  • Amit Dev (2019) Introduction to Functional Programming in Rust. YOW! Lambda Jam watch

  • Steve Klabnik (2019) How Rust views tradeoffs. QCon London watch

  • Ashley Williams (2019) Rust, WebAssembly, and JavaScript make three: An FFI Story. QCon New York watch

  • Lin Clark, Pat Hickey et al (2019) Bytecode Alliance Panel Discussion. WebAssembly SF watch

  • Alon Zakai (2014) Emscripten and asm.js: C++'s role in the modern web. CppCon watch

  • Alon Zakai (2019) Pause and Resume WebAssembly with Asyncify. WebAssembly SF watch

  • Nidin Vinayakan (2018) WebAssembly in Typescript: Introduction to AssemblyScript. WebAssembly Meetup Munich watch

  • Paul Bone (2018) AST to WebAssembly: Writing a code generator. Compose Melbourne watch

  • John Hume (2015) Life of a Clojure Expression. Clojure/West watch

  • Lin Clark (2019) WebAssembly nanoprocesses: making WebAssembly outside-the-browser secure by default. WebAssembly SF watch

  • Alex Kehayias (2019) Progressive WebAssembly Applications. WebAssembly SF watch

  • Zach Bloom (2019) WebAssembly on the Server. WebAssembly SF watch

  • Paul Schoenfelder (2019) Lumen: Bringing the BEAM to WebAssembly and beyond. Code Mesh London watch

  • Ben Titzer and Andreas Rossberg (2018) WebAssembly: What and What Next? GOTO Berlin watch

  • Robert Virding (2017) Lisp Machine Flavors for LFE: implementing objects on Erlang/OTP. Erlang and Elixir Factory watch

  • Robert Virding (2016) LFE — a lisp flavour on the Erlang VM. Lambda Days Kraków watch

  • David Chisnel (2012) Implementing Domain Specific Languages with LLVM. FOSDEM watch

  • Kai Nacke (2019) Roll your own compiler with LLVM: Easy IR generation. FOSDEM watch

  • Phil Trelford (2015) Write your own compiler in 24 hours. Bristech Conf watch

  • Ariel Ortiz (2017) The Dawn of Lisp, or: How to Write Eval and Apply in Clojure. Clojure Conj watch

2019

  • Jared Smith (2016) How to Write Secure JavaScript Applications. Nodevember watch

  • Zeno Rocha (2016) Web APIs You (Probably) Didn’t Know Existed. NEJS Conf watch

  • Christophe Grand (2018) They’ll have to pry the REPL from our cold dead hands! clojureD watch

  • Rich Hickey, Werner Schuster, Kresten Krab Thorup, Simon Marlow and Robert Virding (2013) Panel Debate: Runtime Evolution, the Future of VMs. Code Mesh London watch

  • Christian Schafmeister (2018) Lessons Learned Implementing Common Lisp with LLVM. LLVM Dev Meeting watch

  • Tom Toor (2019) Why Build Solutions with Fulcro. Clojure Conj watch

  • Avi Flax (2019) (Architecture) Diagrams as Data. Clojure Conj watch

  • Wilker Silva (2019) The Maximal Graph. Clojure Conj watch

  • Pier Federico Gherardini and Ben Kamphaus (2019) Clojure Where it Counts: Tidying Data Science Workflows. Clojure Conj watch

  • Chris Oakman (2019) Probabilistic Record Linkage of Hospital Patients. Clojure Conj watch

  • J.D. Hollis (2019) Datomic with Terraform. Clojure Conj watch

  • Alexander Oloo (2019) From Lazy Lisper to Confident Clojurist. Clojure Conj watch

  • Lucas Cavalcanti (2019) Complex Made Bearable. Clojure Conj watch

  • Gene Kim (2019) My Love Letter to Clojure: And a Datomic Experience Report. Clojure Conj watch

  • David Nolan (2019) Are we there yet? Remix. ReactiveConf watch

  • Ariel Ortiz (2019) The Hitchhikers Guide to Multiparadigm Programming. Clojure Conj watch

  • Derek Troy-West (2019) Follow the Data: Product Development in Clojure. Clojure Conj watch

  • Dennis Heihoff (2019) The Embodied Runtime. Clojure Conj watch

  • Ulrich Schaechtle (2019) Inference QL: AI for data engineers in Clojure. Clojure Conj watch

  • Alex Miller (2019) Composable Tools. Clojure Conj watch

  • Thomas Gebert and Nick Misturak (2019) Distributed Hash Tables, Video and Fun! Clojure Conj watch

  • Eno Compton and Tyler van Hensbergen (2019) Goodbye YAML: Infrastructure as Code in Clojure. Clojure Conj watch

  • Matthew Flatt (2019) A Racket Perspective on Research, Education and Production. Clojure Conj watch

  • Alexander Yakushev (2019) A New Age of JVM Garbage Collectors. Clojure Conj watch

  • Chris Nuernberger (2019) Extending Clojure with Python. Clojure Conj watch

  • Michael Feathers (2018) Unconditional Code. GOTO Chicago watch

  • Stuart Halloway (2010) Simplicity Ain’t Easy. Clojure Conj watch

  • Gil Tene (2012) Understanding Java Garbage Collection and what you can do about it. SpringOne watch

  • Alex Engelberg and Derek Slager (2018) Every Clojure Talk Ever. Clojure Conj watch

  • Ray McDermott, Mike Fikes and Mia (2019) Discussion. Apropos Clojure Oct 31 watch

  • Rick Houlihan (2018) Advanced Design Patterns for DynamoDB. AWS re:Invent watch

  • Joe Armstrong (2018) Computer Science — A Guide for the Perplexed. GOTO Chicago watch

  • Daniel Stenberg (2019) HTTP/3 — HTTP over QUIC is the next generation. New Relic watch

  • Stephen Magill (2019) Disrupting QA — Emerging Trends in Code Quality Automation. GOTO Chicago watch

  • Andreas Hallberg (2016) Secure Coding Patterns. GOTO Amsterdam watch

  • Stuart Halloway (2013) Narcissistic Design. Reaktor Dev Day watch

  • Dan North (2017) Beyond Developer. GOTO Copenhagen watch

  • Dan North (2017) Patterns of Effective Teams. GOTO Chicago watch

  • Dan North (2016) Software, Faster. GOTO Amsterdam watch

  • Dan North (2013) Simplicity, The Way of the Unusual Architect. GOTO Aarhus watch

  • Dan North (2012) The Browser is Dead. GOTO Aarhus watch

  • Dan North (2017) How to Break the Rules. GOTO Amsterdam watch

  • Dan North (2014) Kicking the Complexity Habit. GOTO Chicago watch

  • Adam Butler (2017) DocOps: engineering great documentation. DevRelCon London watch

  • Jack Rusher (2019) Creative Computation. ClojuTRE watch

  • Michael Nygard (2013) Whence Complexity? Clojure Conj watch

  • Dan North (2016) Microservices: software that fits in your head. GOTO Amsterdam watch

  • Adam Tornhill (2016) Seven Secrets of Maintainable Codebases. GOTO Stockholm watch

  • Michael Nygard (2016) Stability Patterns and Antipatterns. GOTO Chicago watch

  • Chris Ward (2016) Explain Yourself! Documentation for Better Code. LinuxCon Berlin watch

  • Michael Nygard (2019) Uncoupling. DevOpsDays watch

  • Michiel Borkent (2019) clj-kondo: a linter for Clojure code that sparks joy. ClojuTRE watch

  • Jarppe Länsiö (2018) First 6 years of a life of a Clojure project. ClojuTRE watch

  • Tommi Reiman (2019) Naked Performance (with Clojure) ClojuTRE watch

  • Simon Brown (2014) Software Architecture vs Code. GOTO Amsterdam watch

  • Nicole Forsgren (2015) DevOps: Next. GOTO Berlin watch

  • Murat Erder (2016) Continuous Architecture. GOTO London watch

  • Michael Keeling and Joe Runde (2017) Architecture Decision Records in Action. Carnegie Mellon watch

  • Jonathan Wolski (2018) Using Architecture Decision Records. VMware Tanzu watch

  • Andreas Rueping (2006) Interview: Agile Documentation._ Software Engineering Radio se-radio.net, watch

  • Birgitta Boeckeler (2017) We’re Agile, We Don’t Do Documentation. LeadDev watch

  • Simon Brown (2017) Visualise, document and explore your software architecture. NDC London watch

  • Dan Saks (2019) "New" Features in C. NDC TechTown watch

  • Carmen Andoh (2017) The Why of Go. QCon San Francisco watch

  • Owen Synge (2019) Why would a Python programmer learn Rust when there are no jobs in it. MiniDebConf Hamburg watch

  • Dan Allen (2019) Antora: Documentation Sites for Software Teams. Devoxx watch

  • Alexandra White (2018) How to tear down existing documentation and rewrite docs that actually work. Write the Docs Prague watch

  • Jon Skeet (2018) Dates and times aren’t that hard, honestly! NDC Oslo watch

  • Brett Slatkin (2015) How to Be More Effective with Functions. PyCon Montréal watch

  • Brett Slatkin (2016) Refactoring Python: Why and how to restructure your code. PyCon Portland watch

  • Greg Ward (2015) How to Write Reusable Code. PyCon Montréal watch

  • Jake VanderPlas (2015) Losing your Loops: Fast Numerical Computing with NumPy. PyCon Montréal watch

  • Richard Feldman (2019) Why Isn’t Functional Programming the Norm? ClojuTRE watch

  • Evan Goer (2013) Thinking of Documentation as Code. YUIConf watch

  • Peter Hilton (2017) Documentation for software developers. I TAKE Unconf watch

  • Jay Kreps (2019) Keynote. Kafka Summit San Francisco watch

  • Gregory Koberger (2015) A Developers Approach to Documentation: From Passive to Dynamic. Write the Docs watch

  • Ben Hall (2017) The Art of Documentation and Readme.md for Open Source Projects. KubeCon and CloudNativeCon watch

  • Daniel D. Beck (2016) Write the Readable README. Write the Docs Portland watch

  • James Cash (2019) Crawling Inside the Tauntaun. Clojure/north watch

  • Jon Pither (2019) The Crux of Bitemporality. Clojure/north watch

  • Martin Klepsch (2019) cljdoc. Clojure/north watch

  • Tommi Reiman (2019) Reitit, the Ancient Art of Routing. Clojure/north watch

  • Alex Hudek (2019) Lessons Learned Creating a Successful Machine Learning Startup with Clojure. Clojure/north watch

  • Rafal Dittwald (2019) Composing Applications. Clojure/north watch

  • Thomas Getgood (2019) Residential Programming without Mutable State. Clojure/north watch

  • Jimmy Miller (2019) Meander: Declarative Explorations at the Limits of FP. Strange Loop watch

  • Joe Ross (2019) Why do tree ensembles work? Strange Loop watch

  • Star Simpson (2019) Building Personable Machines. Papers We Love watch

  • Jeff Bezanson (2019) What’s Bad About Julia. JuliaCon Baltimore watch

  • Heather Miller (2019) Keynote. JuliaCon Baltimore watch

  • Emery Berger (2019) Performance Matters. Strange Loop watch

  • Jay Parlar (2019) Finding bugs without running or even looking at code. Strange Loop watch

  • Vlad Kozin (2019) #lang wishful thinking. Strange Loop watch

  • Hannah Howard (2019) How We Tell Stories in Code. Strange Loop watch

  • Bobby Powers (2019) Compacting the Uncompactable. Strange Loop watch

  • Dave Yarwood (2019) Alda’s dynamic relationship with Clojure. Strange Loop watch

  • Felix Klock (2015) Rust: A type system you didn’t know you wanted. Curry On Prague watch

  • Simon Brown (2016) Visualize, Document and Explore your Software Architecture. GOTO London watch

  • Corey Haines (2015) Fun with the Lambda Calculus. GOTO Chicago watch

  • Matthias Felleisen (2015) The Racket Manifesto. RacketCon St Louis watch

  • Guido van Rossum (2015) Type Hints. PyCon Montréal watch

  • Mark Seemann (2016) Functional Architecture: The pits of success. NDC Sydney watch

  • Dave Cheney (2019) Two Go Programs, Three Different Profiling Techniques. GopherCon watch

  • Maxime Gréau and Dan Allen (2015) Write in AsciiDoc, Publish Everywhere! Devoxx watch

  • Stefan Karpinski (2019) The Unreasonable Effectiveness of Multiple Dispatch. JuliaCon Baltimore watch

  • Jessica Kerr (2015) Elixir Should Take Over the World. Elixir Conf Austin watch

  • Will Leinweber (2016) Introducing the Crystal Programming Language. Ruby on Ales watch

  • Mark Ranallo (2016) Writing CLI applications in Crystal. Full Stack Talks watch

  • Garrett Smith (2015) The Functional Tao of Bash. Code Mesh London watch

  • Mark Stoodley (2019) JIT and AOT in the JVM. Java watch

  • Ben Brinckerhoff (2019) Effect ive Clojure. Den of Clojure watch

  • Ambrose Bonnaire-Sergeant (2017) Tool Assisted spec Development. Clojure Conj watch

  • Zach Tellman (2014) Predictably Fast Clojure. Clojure/West watch

  • Tom Crayford (2015) Performance and Lies. EuroClojure Barcelona watch

  • Rich Hickey (2010) Interview. Software Engineering Radio se-radio.net, watch

  • Robert Balicki (2019) Building WebAssembly Apps in Rust using Smithy. RustNYC watch

  • David Nolen (2012) Jelly Stains! Thoughts on JavaScript, LISP and Play. JSConf Arizona watch

  • Bodil Stokke (2013) Build your own Lisp for Great Justice. FooCafe watch

  • Stu Halloway (2013) Clojure in 10 big ideas. RuPy Budapest watch

  • Laurens Van Houtven (2016) Using Clojure with C APIs for crypto and more. Clojure Conj watch

  • Daniel Higginbotham (2016) Parallel Programming, Fork Join, and Reducers. Clojure/West watch

  • Ambrose Bonnaire-Sergeant (2014) Typed Clojure in Practice. Strange Loop watch

  • Luke VanderHart (2015) Simplicity in Practice. ClojuTRE watch

  • Dave Fetterman (2018) Learning and Teaching Clojure on the job at Amperity. Clojure Conj watch

  • Gary Fredericks (2015) Purely Random. Clojure/West watch

  • Daniel Solano Gómez (2014) How Clojure Works: Understanding the Clojure Runtime. Clojure/West watch

  • Mark Engelberg (2014) Instaparse. Clojure/West watch

  • Maxime Chevalier-Boisvert (2014) Refactoring JIT Compilation. DConf watch

  • Rebecca Stambler (2019) Go, pls stop breaking my editor. GopherCon watch

  • Filippo Valsorda (2016) cgo Safely Taming the Beast. GopherCon watch

  • Rob Pike (2016) The Design of the Go Assembler. GopherCon watch

  • Arne Claus (2017) Concurrency Patterns in Go. GopherCon UK watch

  • Keith Randall (2016) Inside the Map Implementation. GopherCon watch

  • Joe Groff and Chris Lattner (2015) Swift Intermediate Language: A high level IR to complement LLVM. LLVM Dev Meeting watch

  • Dann Toliver (2014) Visualizing Persistent Data Structures. Strange Loop watch

  • Aaron Patterson (2016) How Are Method Calls Formed? Mountain West Ruby watch

  • Christopher Armstrong (2015) Side Effects are a Public API. Strange Loop watch

  • Tom Eastman (2015) Serialization formats are not toys. PyCon Montréal watch

  • Ryan Kelly (2015) PyPy.js: What? How? Why? PyCon Montréal watch

  • David Beazley (2015) Modules and Packages: Live and Let Die! PyCon Montréal watch

  • Bodil Stokke (2018) Meetings with Remarkable Trees. ClojuTRE watch

  • Scott Hanselman (2012) Scaling Yourself. GOTO Aarhus watch

  • Joe Armstrong (2012) A Few Improvements to Erlang. Erlang User Conf Stockholm watch

  • Melvin Zhang (2017) META II: A Syntax-Oriented Compiler Writing Language. Papers We Love Singapore watch

  • Jon Gjengset (2018) Rust at speed—​building a fast concurrent database. Two Sigma watch

  • Colin Eberhardt (2018) WebAssembly and the Death of JavaScript. JS Monthly London watch

  • Jay Phelps (2017) WebAssembly Demystified. Jazoon Tech Days watch

  • Clemens Hammacher (2018) Liftoff: V8’s new baseline compiler for WebAssembly. WebAssembly Meetup Munich watch

  • Max Bittker (2019) Simulating Sand: Building Interactivity with WebAssembly. JSConf EU watch

  • Andreas Haas (2018) WebAssembly Disentangled. WebAssembly Meetup Munich watch

  • Carl Cook (2017) When a Microsecond is an Eternity: High Performance Trading Systems in C++. CppCon watch